private void BoxDefActivity_ButtonClick(object sender, EventArgs e)
{
TreeListPopup treeListPopup = new TreeListPopup();
treeListPopup.ThemeChanged(m_visualTheme);
treeListPopup.Tree.Columns.Add(new TreeList.Column());
IList <object> acts = new List <object> {
TrailsPlugin.Properties.Resources.UI_EditList_AutomaticRefActivity
}; //TBD: How to handle null activity?
System.Collections.IList currSel = new object[1] {
acts[0]
};
foreach (IActivity act in TrailResultWrapper.Activities(TrailsPlugin.Controller.TrailController.Instance.Results))
{
acts.Add(act);
if (act != null && act == this.Trail.DefaultRefActivity)
{
currSel[0] = (IActivity)act;
}
}
treeListPopup.Tree.RowData = acts;
#if ST_2_1
treeListPopup.Tree.Selected = currSel;
#else
treeListPopup.Tree.SelectedItems = currSel;
#endif
treeListPopup.Tree.LabelProvider = new ActivityDropdownLabelProvider();
treeListPopup.ItemSelected += new TreeListPopup.ItemSelectedEventHandler(BoxDefActivity_ItemSelected);
treeListPopup.Popup(this.boxDefActivity.Parent.RectangleToScreen(this.boxDefActivity.Bounds));
}
private TrailResultWrapper checkReferenceTrailResult(System.Windows.Forms.ProgressBar progressBar)
{
System.Diagnostics.Debug.Assert(m_currentActivityTrails != null);
if (m_currentActivityTrails.Count > 0)
{
//Check that the ref is for current calculation
if (this.CurrentStatus() <= TrailOrderStatus.MatchPartial)
{
if (m_refResultWrapper != null)
{
//Check if ref is in all results (may have changed, Contains() will not work)
IList <TrailResultWrapper> trs = this.UpdateResults(new List <TrailResultWrapper> {
m_refResultWrapper
});
System.Diagnostics.Debug.Assert(trs != null);
if (trs.Count > 0)
{
m_refResultWrapper = trs[0];
}
else
{
m_refResultWrapper = null;
}
}
}
//If the reference result is not set, try a result for current reference activity,
// secondly the first result
//No forced calculations, should already be done
if (this.m_refResultWrapper == null &&
this.CurrentStatus() <= TrailOrderStatus.MatchPartial)
{
IList <TrailResultWrapper> unpaused = TrailResultWrapper.UnpausedResults(this.Results);
if (this.m_referenceActivity != null)
{
foreach (TrailResultWrapper tr in unpaused)
{
if (this.m_referenceActivity.Equals(tr.Result.Activity))
{
this.m_refResultWrapper = tr;
break;
}
}
}
if (this.m_refResultWrapper == null && unpaused.Count > 0)
{
this.m_refResultWrapper = unpaused[0];
}
}
}
//Reference activity may have to be updated
checkReferenceActivity(progressBar);
return(m_refResultWrapper);
}
//CalculatedFields integration
public static Dictionary <string, List <ITrailResult> > GetTrailsResultsForActivities(IList <IActivity> activities)
{
var results = new Dictionary <string, List <ITrailResult> >();
Controller.TrailController.Instance.Activities = activities;
foreach (Trail trail in Data.TrailData.AllTrails.Values)
{
var activityTrail = new ActivityTrail(trail);
List <ITrailResult> trailResults = new List <ITrailResult>();
foreach (TrailResult tr in TrailResultWrapper.TrailResults(activityTrail.Results))
{
if (!(tr is Data.PausedChildTrailResult))
{
trailResults.Add(new CFTrailResult(tr));
}
}
results.Add(trail.Name, trailResults);
}
return(results);
}
//check that the reference result is reasonable
//Called after activities are updated, before trail is selected/calculated
internal IActivity checkReferenceActivity(System.Windows.Forms.ProgressBar progressBar)
{
bool moreChecks = true;
//Should always follow the trail result, if it exists
if (m_refResultWrapper != null)
{
if (this.PossibleActivities.Contains(this.m_refResultWrapper.Result.Activity))
{
//The ref result is at least possible, set ref activity
this.m_referenceActivity = m_refResultWrapper.Result.Activity;
//Save last used activity
this.m_refResultWrapper.Result.Trail.ReferenceActivity = m_referenceActivity;
//skip a Contains check...
moreChecks = false;
}
else
{
//result not possible
this.m_refResultWrapper = null;
}
}
//If refAct no longer in activities, reset (if set from result or not does not matter)
if (moreChecks && m_referenceActivity != null)
{
if (!this.PossibleActivities.Contains(this.m_referenceActivity))
{
this.m_referenceActivity = null;
}
}
if (m_referenceActivity == null && this.PossibleActivities.Count > 0)
{
if (this.PrimaryCurrentActivityTrail != null &&
this.PrimaryCurrentActivityTrail.Trail.ReferenceActivity != null &&
this.PossibleActivities.Contains(this.PrimaryCurrentActivityTrail.Trail.ReferenceActivity))
{
//Switch back to a trail with prev activities (not used in most usage patterns, but from m_prevSelectedTrails)
this.m_referenceActivity = this.PrimaryCurrentActivityTrail.Trail.ReferenceActivity;
}
else if (this.PrimaryCurrentActivityTrail != null &&
this.PrimaryCurrentActivityTrail.Trail.DefaultRefActivity != null)
{
//Use the reference activity, result added separetly
this.m_referenceActivity = this.PrimaryCurrentActivityTrail.Trail.DefaultRefActivity;
}
else if (this.PrimaryCurrentActivityTrail == null)
{
foreach (ActivityTrail at in this.m_prevSelectedTrails)
{
if (at.Trail.ReferenceActivity != null &&
this.PossibleActivities.Contains(at.Trail.ReferenceActivity))
{
//Switch back to a trail with prev activities (not used in most usage patterns)
this.m_referenceActivity = at.Trail.ReferenceActivity;
break;
}
}
}
if (m_referenceActivity == null)
{
//Last resort, use first activity
//This also covers the trivial situation with only one activity
this.m_referenceActivity = this.PossibleActivities[0];
}
}
//ReferenceActivity trail: ref activity possibly changed - reset calculations
if (this.m_referenceActivity != null &&
this.m_referenceActivity != this.m_referenceActivityTrail.Trail.ReferenceActivity)
{
this.m_referenceActivityTrail.Trail.ReferenceActivity = m_referenceActivity;
this.m_referenceActivityTrail.Init();
}
return(m_referenceActivity);
}
public void RefreshChart()
{
if (m_showPage && this.ChartVisible)
{
LineChartTypes speedPaceChart = LineChartTypes.Speed;
LineChartTypes deviceSpeedPaceChart = LineChartTypes.DeviceSpeed;
if (Controller.TrailController.Instance.ReferenceActivity != null &&
Controller.TrailController.Instance.ReferenceActivity.Category.SpeedUnits.Equals(Speed.Units.Pace))
{
speedPaceChart = LineChartTypes.Pace;
deviceSpeedPaceChart = LineChartTypes.DevicePace;
}
LineChartTypes diffChart = LineChartTypes.DiffDist;
if (Data.Settings.XAxisValue == XAxisValue.Distance)
{
diffChart = LineChartTypes.DiffTime;
}
bool isData = Controller.TrailController.Instance.CurrentActivityTrailIsSelected;
IList <Data.TrailResult> selectedPresentableResults =
TrailResultWrapper.TrailResults(Controller.TrailController.Instance.SelectedResults);
if (selectedPresentableResults.Count > Data.Settings.MaxChartResults)
{
//Move summary first, so it is not truncated
for (int i = 0; i < selectedPresentableResults.Count; i++)
{
TrailResult t = selectedPresentableResults[i];
if (t is SummaryTrailResult)
{
selectedPresentableResults.RemoveAt(i);
selectedPresentableResults.Insert(0, t);
break;
}
}
((List <Data.TrailResult>)selectedPresentableResults).RemoveRange(Data.Settings.MaxChartResults,
selectedPresentableResults.Count - Data.Settings.MaxChartResults);
}
m_multiChart.ChartTypes = new List <LineChartTypes>();
multiChart.ShowPage = false;
//TODO: Temporary handling. Cleanup and decide multiple graphs and charts
TrailLineChart updateChart = m_multiChart;
if (!m_expanded)
{
foreach (TrailLineChart chart in m_lineCharts)
{
chart.ShowPage = false;
}
m_multiChart.BeginUpdate();
m_multiChart.XAxisReferential = Data.Settings.XAxisValue;
m_multiChart.TrailResults = selectedPresentableResults;
foreach (LineChartTypes t in Data.Settings.MultiChartType)
{
LineChartTypes t2 = t;
if (t2 == LineChartTypes.SpeedPace)
{
t2 = speedPaceChart;
}
else if (t2 == LineChartTypes.DeviceSpeedPace)
{
t2 = deviceSpeedPaceChart;
}
else if (t2 == LineChartTypes.DiffDistTime)
{
t2 = diffChart;
}
if (!m_multiChart.ChartTypes.Contains(t2) &&
m_multiChart.HasValues(t2))
{
m_multiChart.ChartTypes.Add(t2);
}
}
m_multiChart.ShowPage = true;
if (!m_multiChart.AnyData())
{
m_multiChart.ShowPage = false;
m_multiChart.LeftChartType = speedPaceChart;
m_multiChart.ShowPage = true;
}
this.ChartBanner.Text = LineChartUtil.ChartTypeString(m_multiChart.LeftChartType) + " / " +
LineChartUtil.XAxisValueString(m_multiChart.XAxisReferential);
m_multiChart.EndUpdate(true);
}
else
{
foreach (TrailLineChart chart in m_lineCharts)
{
bool visible = false;
if (m_expanded &&
(Data.Settings.MultiGraphType.Contains(chart.LeftChartType) ||
chart.LeftChartType == speedPaceChart &&
(Data.Settings.MultiGraphType.Contains(LineChartTypes.SpeedPace) || Data.Settings.MultiGraphType.Contains(LineChartTypes.DeviceSpeedPace)) ||
chart.LeftChartType == diffChart &&
(Data.Settings.MultiGraphType.Contains(LineChartTypes.DiffDistTime) || Data.Settings.MultiGraphType.Contains(LineChartTypes.DeviceDiffDist))) ||
!m_expanded &&
(chart.LeftChartType == Data.Settings.ChartType ||
chart.LeftChartType == speedPaceChart &&
(LineChartTypes.SpeedPace == Data.Settings.ChartType || LineChartTypes.DeviceSpeedPace == Data.Settings.ChartType) ||
chart.LeftChartType == diffChart &&
(LineChartTypes.DiffDistTime == Data.Settings.ChartType || LineChartTypes.DiffDistTime == Data.Settings.ChartType)))
{
visible = true;
}
updateChart = chart;
updateChart.BeginUpdate();
chart.ShowPage = false;
if (visible && isData)
{
updateChart.XAxisReferential = Data.Settings.XAxisValue;
updateChart.TrailResults = selectedPresentableResults;
if (!m_expanded && updateChart.ChartTypes.Count == 1)
{
this.ChartBanner.Text = LineChartUtil.ChartTypeString(chart.LeftChartType) + " / " +
LineChartUtil.XAxisValueString(chart.XAxisReferential);
}
if (updateChart.HasValues(chart.LeftChartType))
{
updateChart.ShowPage = visible;
}
else
{
if (visible && !updateChart.HasValues(chart.LeftChartType))
{
chart.ShowPage = false;
//Replace empty chart
if (!m_expanded && chart.LeftChartType != speedPaceChart)
{
foreach (TrailLineChart replaceChart in m_lineCharts)
{
if (replaceChart.LeftChartType == speedPaceChart)
{
replaceChart.BeginUpdate();
replaceChart.ShowPage = false;
replaceChart.XAxisReferential = Data.Settings.XAxisValue;
replaceChart.TrailResults = selectedPresentableResults;
if (!m_expanded)
{
this.ChartBanner.Text = LineChartUtil.ChartTypeString(replaceChart.LeftChartType) + " / " +
LineChartUtil.XAxisValueString(replaceChart.XAxisReferential);
}
replaceChart.ShowPage = visible;
replaceChart.EndUpdate(true);
}
}
}
}
}
}
updateChart.EndUpdate(true);
}
}
RefreshRows();
RefreshChartMenu();
}
}
