/// <summary> /// Filters activities for a category (and it's subcategories), and includes only those activities with a HeartRateTrack. /// </summary> /// <param name="category">Category to filter for</param> /// <param name="activityList">List of activities to be filtered from.</param> /// <returns>Returns a list of activities filtered by category</returns> internal static IEnumerable <IActivity> FilterActivities(IActivityCategory category, IList <IActivity> activityList) { IList <IActivity> filteredActivities = new List <IActivity>(); ActivityInfoCache info = ActivityInfoCache.Instance; IActivityCategory activityCategory; foreach (IActivity activity in activityList) { activityCategory = info.GetInfo(activity).Activity.Category; while (true) { if (activityCategory == category) { // Include Activity filteredActivities.Add(info.GetInfo(activity).Activity); break; } else if (activityCategory.Parent != null) { // Keep searching activityCategory = activityCategory.Parent; } else { // Exclude Activity break; } } } return(filteredActivities); }
public Workout(Guid workoutId, string name, IActivityCategory category) : this(name, category) { m_Id.Value = workoutId; CreateStepsList(); WorkoutChanged += new WorkoutChangedEventHandler(OnWorkoutChanged); }
public Workout(string name, IActivityCategory category, List<IStep> steps) { m_Name.Value = name; Category = category; CreateStepsList(); Steps.AddStepsToRoot(steps); WorkoutChanged += new WorkoutChangedEventHandler(OnWorkoutChanged); }
public Workout(string name, IActivityCategory category) { m_Name.Value = name; Category = category; CreateStepsList(); Steps.AddStepToRoot(new RegularStep(this)); WorkoutChanged += new WorkoutChangedEventHandler(OnWorkoutChanged); }
void OnActivityCategoryChanged(object sender, IActivityCategory category) { foreach (SprocketComboInfoCacheItem cachedItem in m_InfoCache.Values) { if (Utils.IsInActivityCategoryHierarchy(cachedItem.m_Activity, category)) { // We might have changed our activity category hierarchy, stopped meters // per second, use parent settings, etc. so refresh the cached item cachedItem.m_Dirty = true; } } }
private void addNode(IActivityCategory category, TreeNode parent) { TreeNode node = new TreeNode(category.Name); if (parent == null) tree.Nodes.Add(node); else parent.Nodes.Add(node); node2category.Add(node, category); foreach (IActivityCategory subcategory in category.SubCategories) { addNode(subcategory, node); } }
public static bool IsInActivityCategoryHierarchy(IActivity activity, IActivityCategory category) { IActivityCategory currentCategory = activity.Category; do { if (category == currentCategory) { return(true); } else if (!currentCategory.UseParentSettings) { return(false); } currentCategory = currentCategory.Parent; }while (currentCategory != null); return(false); }
/// <summary> /// Get a list of the categories for display /// </summary> /// <param name="cat"></param> /// <param name="display"></param> public void GetActivityCategories(IActivityCategory cat, ref List <string> display) { if (cat.SubCategories.Count != 0) { for (int i = 0; i < cat.SubCategories.Count; i++) { GetActivityCategories(cat.SubCategories[i], ref display); } } else { if (categories.Contains(cat.ReferenceId)) { if (cat.Parent != null) { display.Add(cat.Parent.Name + ": " + cat.Name); } else { display.Add(cat.Name); } } } }
private void OnActivityCategoryDataChanged(object sender, PropertyChangedEventArgs e) { if (Activity != null) { IActivityCategory modifiedCategory = sender as IActivityCategory; if (Utils.IsInActivityCategoryHierarchy(m_Activity, modifiedCategory)) { ActivityInfoCache.Instance.ClearInfo(m_Activity); if (e.PropertyName != "StoppedMetersPerSecond" || !PluginMain.GetApplication().SystemPreferences.AnalysisSettings.IncludeStopped) { TriggerPropertyChangedEvent(m_Activity.Category, "ActivityCategory." + e.PropertyName); } } if (e.PropertyName == "SubCategories") { UnregisterCategoryCallback(PluginMain.GetApplication().Logbook); RegisterCategoryCallback(PluginMain.GetApplication().Logbook); } } }
private static bool load() { //Backwards compatibility, read old preferences file String prefsPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + Path.DirectorySeparatorChar + "UniqueRoutesPlugin" + Path.DirectorySeparatorChar + "preferences.xml"; if (!File.Exists(prefsPath)) return false; XmlDocument document = new XmlDocument(); XmlReader reader = new XmlTextReader(prefsPath); document.Load(reader); try { XmlNode elm = document.ChildNodes[0]["view"]; windowSize = new Size(int.Parse(elm.Attributes["viewWidth"].Value), int.Parse(elm.Attributes["viewHeight"].Value)); errorMargin = GpsRunningPlugin.Source.Settings.parseDouble(elm.Attributes["errorMargin"].Value); radius = int.Parse(elm.Attributes["bandwidth"].Value); hasDirection = bool.Parse(elm.Attributes["hasDirection"].Value); if (elm.Attributes["ignoreBeginning"] != null) ignoreBeginning = GpsRunningPlugin.Source.Settings.parseDouble(elm.Attributes["ignoreBeginning"].Value); if (elm.Attributes["ignoreEnd"] != null) ignoreEnd = GpsRunningPlugin.Source.Settings.parseDouble(elm.Attributes["ignoreEnd"].Value); selectAll = bool.Parse(elm.Attributes["selectAll"].Value); selectedCategory = parseCategory(elm.Attributes["selectedCategory"].Value); selectedPlugin = elm.Attributes["selectedPlugin"].Value; } catch (Exception) { reader.Close(); return false; } reader.Close(); return true; }
public STCategoriesInfo(IActivityCategory STCategory, GarminCategories garminCategory) : this(STCategory, garminCategory, true, true) { }
//private void changeCategory_Click(object sender, EventArgs e) //{ // CategorySelector cs = new CategorySelector(m_visualTheme, m_culture); // cs.ShowDialog(); // setCategoryLabel(); // _needsRecalculation = true; // calculate(); //} private static void addNode(IActivityCategory category, System.Collections.IList parentCategories) { if (parentCategories != null) { if (category.SubCategories.Count > 0) parentCategories.Add(category); } foreach (IActivityCategory subcategory in category.SubCategories) { addNode(subcategory, parentCategories); } }
public static int GetFunbeatActivityTypeID(IActivityCategory st) { foreach (ActivityTypeMapping m in Instance.ActivityTypeMappings) if (m.SportTracks == st.ReferenceId) return m.Funbeat; return 51; // The id for "Övriga aktiviteter" }
public STCategoriesInfo(IActivityCategory STCategory, GarminCategories garminCategory, bool expandInWorkoutList, bool showInWorkoutList) { m_STCategory = STCategory; m_GarminCategory = garminCategory; m_ExpandInWorkoutList = expandInWorkoutList; m_ShowInWorkoutList = showInWorkoutList; }
public FITSports GetFITSport(IActivityCategory STCategory) { GarminCategories category = GetGarminCategory(STCategory); if (category == GarminCategories.Biking) { return FITSports.Cycling; } else if (category == GarminCategories.Running) { return FITSports.Running; } return FITSports.Other; }
private ActivityCategoryWrapper CreateCategoryNode(IActivityCategory category) { ActivityCategoryWrapper wrapper = GetActivityCategoryWrapper(category, null); wrapper.Children.Clear(); CreateCategoryNode(wrapper, null); return wrapper; }
public void OnActivityCategoryChanged(object sender, IActivityCategory categoryChanged) { List<IActivityCategory> itemsToDelete = new List<IActivityCategory>(); Dictionary<IActivityCategory, STCategoriesInfo>.KeyCollection.Enumerator iter = m_STToGarminCategoryMap.Keys.GetEnumerator(); while(iter.MoveNext()) { if (Utils.FindCategoryByID(iter.Current.ReferenceId) == null) { itemsToDelete.Add(iter.Current); } } for (int i = 0; i < itemsToDelete.Count; ++i) { m_STToGarminCategoryMap.Remove(itemsToDelete[i]); } }
public void RemoveGarminCategory(IActivityCategory STCategory) { if (m_STToGarminCategoryMap.ContainsKey(STCategory) && m_STToGarminCategoryMap[STCategory].GarminCategory != GarminCategories.GarminCategoriesCount) { m_STToGarminCategoryMap[STCategory].GarminCategory = GarminCategories.GarminCategoriesCount; TriggerOptionsChangedEvent("STToGarminCategoryMap"); } }
public bool IsCustomGarminCategory(IActivityCategory STCategory) { if (STToGarminCategoryMap.ContainsKey(STCategory)) { return STToGarminCategoryMap[STCategory].GarminCategory != GarminCategories.GarminCategoriesCount; } else { return STCategory.Parent == null; } }
public bool GetVisibleInWorkoutList(IActivityCategory STCategory) { if (m_STToGarminCategoryMap.ContainsKey(STCategory)) { return m_STToGarminCategoryMap[STCategory].ShowInWorkoutList; } return true; }
public GarminCategories GetGarminCategory(IActivityCategory STCategory) { if (m_STToGarminCategoryMap.ContainsKey(STCategory) && m_STToGarminCategoryMap[STCategory].GarminCategory != GarminCategories.GarminCategoriesCount) { return m_STToGarminCategoryMap[STCategory].GarminCategory; } else if(STCategory.Parent != null) { return GetGarminCategory(STCategory.Parent); } return GarminCategories.Other; }
public static string printFullCategoryPath(IActivityCategory iActivityCategory) { return printFullCategoryPath(iActivityCategory, null, ": "); }
private static void FlattenSportTrackActivityTypes(Dictionary<string, string> list, IActivityCategory category) { foreach (IActivityCategory sub in category.SubCategories) { list.Add(sub.ReferenceId, sub.Name); FlattenSportTrackActivityTypes(list, sub); } }
private static string printFullCategoryPath(IActivityCategory iActivityCategory, string p, string sep) { if (iActivityCategory == null) return p; if (p == null) return printFullCategoryPath(iActivityCategory.Parent, iActivityCategory.Name, sep); return printFullCategoryPath(iActivityCategory.Parent, iActivityCategory.Name + sep + p, sep); }
public ActivityTemplate(ITerminal terminal, IActivityCategory activityCategory) { IsATandTCacheDisabled = string.Equals(CloudConfigurationManager.GetSetting("DisableATandTCache"), "true", StringComparison.InvariantCultureIgnoreCase); _terminal = terminal; _activityCategory = activityCategory; }
private ActivityCategoryWrapper GetActivityCategoryWrapper(IActivityCategory category, ActivityCategoryWrapper parent) { ActivityCategoryWrapper wrapper; // If we already have a wrapper for this category, use it if (m_CategoryWrapperMap.ContainsKey(category)) { wrapper = m_CategoryWrapperMap[category]; } else { // Create a new wrapper wrapper = new ActivityCategoryWrapper(parent, category); m_CategoryWrapperMap[category] = wrapper; } return wrapper; }
public bool GetExpandedInWorkoutList(IActivityCategory STCategory) { if (m_STToGarminCategoryMap.ContainsKey(STCategory)) { return m_STToGarminCategoryMap[STCategory].ExpandInWorkoutList; } return true; }
public ActivityCategoryWrapper(ActivityCategoryWrapper parent, IActivityCategory element) : base(parent, element) { }
public void GetNewWorkoutNameAndCategory(ref string name, ref IActivityCategory category) { if (InvokeRequired) { object[] parameters = new object[] { name, category }; Invoke(new GetNewWorkoutNameAndCategoryDelegate(GetNewWorkoutNameAndCategory), parameters); name = parameters[0] as string; category = parameters[1]as IActivityCategory; } else { bool isUsedByPart = false; if (!GarminWorkoutManager.Instance.IsWorkoutNameAvailable(name, out isUsedByPart)) { if (!isUsedByPart) { ReplaceRenameDialog dlg = new ReplaceRenameDialog(GarminWorkoutManager.Instance.GetUniqueName(name)); if (dlg.ShowDialog() == DialogResult.Yes) { // Yes = replace, delete the current workout from the list Workout oldWorkout = GarminWorkoutManager.Instance.GetWorkout(name); category = oldWorkout.Category; GarminWorkoutManager.Instance.RemoveWorkout(oldWorkout); } else { // No = rename name = dlg.NewName; } } else { // Auto rename name = GarminWorkoutManager.Instance.GetUniqueName(name); } } if (category == null) { if (Options.Instance.UseLastCategoryForAllImportedWorkout && Options.Instance.LastImportCategory != null) { category = Options.Instance.LastImportCategory; } else { SelectCategoryDialog categoryDlg = new SelectCategoryDialog(name); categoryDlg.ShowDialog(); category = categoryDlg.SelectedCategory; Options.Instance.LastImportCategory = category; } } } }
public STToGarminActivityCategoryWrapper(STToGarminActivityCategoryWrapper parent, IActivityCategory element) : base(parent, element) { }
public void SetGarminCategory(IActivityCategory STCategory, GarminCategories GarminCategory) { bool modified = false; if(!m_STToGarminCategoryMap.ContainsKey(STCategory)) { m_STToGarminCategoryMap[STCategory] = new STCategoriesInfo(STCategory, GarminCategory); modified = true; } if (m_STToGarminCategoryMap[STCategory].GarminCategory != GarminCategory) { m_STToGarminCategoryMap[STCategory].GarminCategory = GarminCategory; modified = true; } if (modified) { TriggerOptionsChangedEvent("STToGarminCategoryMap"); } }
public static Workout ImportWorkoutFromMessage(FITMessage workoutMessage, IActivityCategory category) { // Peek name FITMessageField nameField = workoutMessage.GetField((Byte)FITWorkoutFieldIds.WorkoutName); if (nameField != null) { GarminFitnessView pluginView = PluginMain.GetApplication().ActiveView as GarminFitnessView; String workoutName = nameField.GetString(); if (category == null && pluginView != null) { GarminWorkoutControl workoutControl = pluginView.GetCurrentView() as GarminWorkoutControl; if (workoutControl != null) { workoutControl.GetNewWorkoutNameAndCategory(ref workoutName, ref category); } } return GarminWorkoutManager.Instance.CreateWorkout(workoutName, workoutMessage, category); } else { throw new FITParserException("No name for workout"); } }
public static void defaults() { selectedPlugin = ""; selectedCategory = null; errorMargin = 0.1; radius = 40; hasDirection = false; useActive = false; ignoreBeginning = 0; ignoreEnd = 0; selectAll = true; summaryViewSortColumn = SummaryColumnIds.StartDate; summaryViewSortDirection = ListSortDirection.Ascending; showTrailsHint = true; windowSize = new Size(800, 600); m_activityPageColumns = new List<string>(); m_activityPageColumns.Add(SummaryColumnIds.StartDate); m_activityPageColumns.Add(SummaryColumnIds.StartTime); m_activityPageColumns.Add(SummaryColumnIds.Time); m_activityPageColumns.Add(SummaryColumnIds.Distance); m_activityPageColumns.Add(SummaryColumnIds.AvgSpeedPace); m_activityPageColumns.Add(SummaryColumnIds.AvgHR); }
private void UnregisterCategoryCallback(IActivityCategory category) { category.SubCategories.CollectionChanged -= this.OnActivityCategoriesCollectionChanged; foreach (IActivityCategory subCategory in category.SubCategories) { UnregisterCategoryCallback(subCategory); } }
public static void ReadOptions(XmlDocument xmlDoc, XmlNamespaceManager nsmgr, XmlElement pluginNode) { String attr, attr2; attr = pluginNode.GetAttribute(xmlTags.settingsVersion); if (attr.Length > 0) { settingsVersion = (Int16)XmlConvert.ToInt16(attr); } if (0 == settingsVersion) { // No settings in Preferences.System found, try read old files (ST2) load(); } attr = pluginNode.GetAttribute(xmlTags.selectedPlugin); if (attr.Length > 0) { selectedPlugin = attr; } attr = pluginNode.GetAttribute(xmlTags.selectedCategory); if (attr.Length > 0) { selectedCategory = parseCategory(attr); } attr = pluginNode.GetAttribute(xmlTags.errorMargin); if (attr.Length > 0) { errorMargin = (float)XmlConvert.ToDouble(attr); } attr = pluginNode.GetAttribute(xmlTags.radius); if (attr.Length > 0) { radius = XmlConvert.ToDouble(attr); //Compatibility svn 165-265 if (settingsVersion == 1) { radius *= 2; } } else { //Compatibility before svn 165, no setting version changed attr = pluginNode.GetAttribute(xmlTags.bandwidth); if (attr.Length > 0) { radius = XmlConvert.ToInt16(attr); } } attr = pluginNode.GetAttribute(xmlTags.hasDirection); if (attr.Length > 0) { hasDirection = XmlConvert.ToBoolean(attr); } attr = pluginNode.GetAttribute(xmlTags.useActive); if (attr.Length > 0) { useActive = XmlConvert.ToBoolean(attr); } attr = pluginNode.GetAttribute(xmlTags.ignoreBeginning); if (attr.Length > 0) { ignoreBeginning = (float)XmlConvert.ToDouble(attr); } attr = pluginNode.GetAttribute(xmlTags.ignoreEnd); if (attr.Length > 0) { ignoreEnd = (float)XmlConvert.ToDouble(attr); } attr = pluginNode.GetAttribute(xmlTags.selectAll); if (attr.Length > 0) { selectAll = XmlConvert.ToBoolean(attr); } attr = pluginNode.GetAttribute(xmlTags.showPace); if (attr.Length > 0) { showPace = XmlConvert.ToBoolean(attr); } attr = pluginNode.GetAttribute(xmlTags.summaryViewSortColumn); if (attr.Length > 0) { summaryViewSortColumn = attr; } attr = pluginNode.GetAttribute(xmlTags.summaryViewSortDirection); if (attr.Length > 0) { summaryViewSortDirection = (ListSortDirection)Enum.Parse(typeof(ListSortDirection), attr); } attr = pluginNode.GetAttribute(xmlTags.showTrailsHint); if (attr.Length > 0) { showTrailsHint = XmlConvert.ToBoolean(attr); } attr = pluginNode.GetAttribute(xmlTags.viewWidth); attr2 = pluginNode.GetAttribute(xmlTags.viewHeight); if (attr.Length > 0 && attr2.Length > 0) { windowSize = new Size(XmlConvert.ToInt16(attr), XmlConvert.ToInt16(attr2)); } attr = pluginNode.GetAttribute(xmlTags.sColumns); if (attr.Length > 0) { m_activityPageColumns.Clear(); String[] values = attr.Split(';'); foreach (String column in values) { m_activityPageColumns.Add(column); } } }
public TagGenerator(IPlanNode activity, IActivityCategory activityCategory) { _activity = activity; _activityCategory = activityCategory; }
public void SetVisibleInWorkoutList(IActivityCategory STCategory, bool show) { bool modified = false; if (!m_STToGarminCategoryMap.ContainsKey(STCategory)) { m_STToGarminCategoryMap[STCategory] = new STCategoriesInfo(STCategory, GarminCategories.GarminCategoriesCount, true, show); modified = true; } if (m_STToGarminCategoryMap[STCategory].ShowInWorkoutList != show) { m_STToGarminCategoryMap[STCategory].ShowInWorkoutList = show; modified = true; } if (modified) { TriggerOptionsChangedEvent("STCategoryVisibleInWorkoutList"); } }