/// <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");
}
}
