public static IList <EditTrailRow> getEditTrailRows(Trail tgps, TrailResult tr)
{
IList <EditTrailRow> result = new List <EditTrailRow>();
int i = 0;
int inc = 1;
//The result index may not match the trailGPS index
if (tgps.IsCompleteActivity)
{
//An extra point at start/end has been added compared to the trail points
i = 1;
}
if (tr != null && tr.Reverse)
{
i = tr.TrailPointDateTime.Count - 1 - i;
inc = -1;
}
foreach (TrailGPSLocation t in tgps.TrailLocations)
{
EditTrailRow row = new EditTrailRow(t, tr, i);
result.Add(row);
i += inc;
}
return(result);
}
//Mark all
public TrailResultMarked(TrailResult tr)
{
this.trailResult = tr;
if (tr is SummaryTrailResult)
{
//Just fake a selection, dont care if time is enough...
this.selInfo.Activity = Controller.TrailController.Instance.ReferenceActivity;
this.selInfo.MarkedTimes = new ValueRangeSeries <DateTime>();
DateTime endTime;
try
{
endTime = ZoneFiveSoftware.Common.Data.Algorithm.DateTimeRangeSeries.AddTimeAndPauses(
this.selInfo.Activity.StartTime, tr.Duration, this.selInfo.Activity.TimerPauses);
}
catch
{
endTime = this.selInfo.Activity.StartTime + tr.Duration;
}
this.selInfo.MarkedTimes.Add(new ValueRange <DateTime>(
this.selInfo.Activity.StartTime,
endTime));
}
else
{
this.selInfo.MarkedTimes = tr.GetSelInfo(true);
this.selInfo.Activity = tr.Activity;
}
}
private static float[] GetTimeChartResultFromDateTime(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, DateTime d1, DateTime d2)
{
//Convert to distance display unit, Time is always in seconds
float x1 = GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d1);
float x2 = GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d2);
return(new float[] { x1, x2 });
}
private static float[] GetDistChartResultFromDistResult(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, double t1, double t2)
{
//distance is for result, then to display units
float x1 = GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t1);
float x2 = GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t2);
return(new float[] { x1, x2 });
}
public void UpdateRow(TrailResult tr, TrailGPSLocation t)
{
this.TrailGPS = t;
if (tr != null && m_resultPointIndex < tr.TrailPointDateTime.Count)
{
SetDistance(tr, tr.TrailPointDateTime[m_resultPointIndex]);
}
}
//Reset calculations, without changing selected activities
public void Reset()
{
TrailResult.Reset();
foreach (ActivityTrail at in m_CurrentOrderedTrails)
{
at.Init();
}
//activityGps handled separately
}
//Marked part of a track
public static IList<TrailMapPolyline> GetTrailMapPolyline(TrailResult tr, TrailsItemTrackSelectionInfo sel)
{
IList<TrailMapPolyline> results = new List<TrailMapPolyline>();
foreach (IList<IGPSPoint> gp in tr.GpsPoints(sel))
{
results.Add(new TrailMapPolyline(gp, UnitUtil.GetApplication().SystemPreferences.RouteSettings.RouteWidth * 2, MarkedColor(tr.TrailColor), tr, "m" + results.Count));
}
return results;
}
//Marked part of a track
public static IList <TrailMapPolyline> GetTrailMapMarkedPolyline(TrailResult tr, TrailsItemTrackSelectionInfo sel)
{
IList <TrailMapPolyline> results = new List <TrailMapPolyline>();
foreach (IList <IGPSPoint> gp in tr.GpsPoints(sel))
{
results.Add(new TrailMapPolyline(gp, RouteWidth() * 2, MarkedColor(tr.ResultColor.LineNormal), tr, "m" + cSeparator + results.Count));
}
return(results);
}
//Note: IItemTrackSelectionInfo uses Activity distances, avoid...
//public TrailResultMarked(TrailResult tr, IValueRangeSeries<double> t)
//{
// trailResult = tr;
// selInfo.MarkedDistances = t;
//}
public TrailResultMarked(TrailResult tr, IItemTrackSelectionInfo t)
{
this.trailResult = tr;
this.selInfo.SetFromSelection(t, tr.Activity);
if (selInfo.MarkedTimes != null)
{
selInfo.MarkedTimes = TrailsItemTrackSelectionInfo.excludePauses(selInfo.MarkedTimes, tr.Pauses);
}
//Note that SelectedTime can still include paused time
}
/*******************************************************/
private static float GetTimeChartResultFromDateTime(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, DateTime d1)
{
float x1 = (float)(tr.GetTimeResult(d1));
if (isOffset)
{
float nextElapsed;
x1 += GetChartResultsResyncOffset(true, tr, ReferenceTrailResult, x1, out nextElapsed);
}
x1 += tr.GetXOffset(true, ReferenceTrailResult);
return(x1);
}
/****************************************************/
private static float GetChartResultFromDateTime(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, DateTime t)
{
//Note: Selecting in Route gives unpaused distance, but this should be handled in the selection
if (xIsTime)
{
return(GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, t));
}
else
{
return(GetDistChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, t));
}
}
private static float GetDistChartResultFromDistResult(bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, double t1)
{
//distance is for result, then to display units
float x1 = (float)t1;
if (isOffset)
{
float nextElapsed;
x1 += GetChartResultsResyncOffset(false, tr, ReferenceTrailResult, x1, out nextElapsed);
}
x1 += tr.GetXOffset(false, ReferenceTrailResult);
x1 = (float)TrackUtil.DistanceConvertFrom(x1, ReferenceTrailResult);
return(x1);
}
public void UpdateRow(TrailResult tr, DateTime d1)
{
//ITimeValueEntry<IGPSPoint> entry = tr.Activity.GPSRoute.GetInterpolatedValue(d1);
//if (entry != null)
//{
// this.TrailGPS.GpsLocation = new GPSLocation(
// entry.Value.LatitudeDegrees,
// entry.Value.LongitudeDegrees);
//}
if (tr != null)
{
IGPSPoint t = Utils.TrackUtil.getGpsLoc(tr.Activity, d1);
this.TrailGPS.GpsPoint = t;
SetDistance(tr, d1);
}
}
//A trail consisting of several parts (due to pauses)
public static IList <TrailMapPolyline> GetTrailMapPolyline(TrailResult tr)
{
IList <TrailMapPolyline> results = new List <TrailMapPolyline>();
string s = "r";
if (tr is ChildTrailResult)
{
s = "c" + tr.Order;
}
foreach (IList <IGPSPoint> gp in tr.GpsPoints())
{
Color c = tr.ResultColor.LineNormal;
c = Color.FromArgb(Data.Settings.RouteLineAlpha, c.R, c.G, c.B);
results.Add(new TrailMapPolyline(gp, RouteWidth(), c, tr, s + cSeparator + results.Count));
}
return(results);
}
private EditTrailRow(TrailGPSLocation loc, TrailResult tr, int i)
: this(loc)
{
this.m_resultPointIndex = i;
if (tr != null && tr.TrailPointDateTime.Count > 0)
{
DateTime d = DateTime.MinValue;
if (tr.TrailPointDateTime != null &&
tr.TrailPointDateTime.Count > m_resultPointIndex && m_resultPointIndex >= 0)
{
d = tr.TrailPointDateTime[m_resultPointIndex];
}
SetDistance(tr, d);
if (this.m_resultPointIndex < tr.SubResultInfo.Count)
{
this.m_diff = tr.PointDiff(this.m_resultPointIndex);
}
}
}
public EditTrail(ITheme visualTheme, System.Globalization.CultureInfo culture, ActivityDetailPageControl page,
IDailyActivityView view, TrailPointsLayer layer, bool addMode, bool copy, TrailResult tr)
#endif
: this(addMode, copy)
{
#if !ST_2_1
this.m_page = page;
this.m_view = view;
this.m_layer = layer;
this.m_layer.TrailPoints = m_TrailToEdit.TrailLocations;
#endif
this.m_trailResult = tr;
//It is possible that the trail result is not for the trail to edit (if more than one is selected)
if (tr != null && tr.Trail != Controller.TrailController.Instance.PrimaryCurrentActivityTrail.Trail)
{
this.m_trailResult = null;
}
ThemeChanged(visualTheme);
UICultureChanged(culture);
}
private void SetDistance(TrailResult tr, DateTime d1)
{
//if (DateTime.MinValue == d1)
//{
// //Try get the value from the track
// if (null != this.TrailGPS.DateTime)
// {
// d1 = (DateTime)this.TrailGPS.DateTime;
// }
//}
if (DateTime.MinValue != d1)
{
try
{
//Elapsed time/distance is for the activity
m_distance = UnitUtil.Distance.ConvertFrom(tr.GetDistActivity(d1), tr.Activity);
m_time = tr.GetTimeActivity(d1);
m_elevation = tr.GetElevation(d1);
}
catch
{ }
}
}
void summaryList_SelectedItemsChanged(object sender, System.EventArgs e)
{
IList<UniqueRoutesResult> results = getListSelection(this.summaryList.SelectedItems);
IDictionary<string, MapPolyline> routes = new Dictionary<string, MapPolyline>();
foreach (UniqueRoutesResult ur in results)
{
//Possibly limit no of Trails shown, it slows down (show complete Activities?)
TrailResult tr = new TrailResult(ur);
TrailMapPolyline m = new TrailMapPolyline(tr);
m.Click += new MouseEventHandler(mapPoly_Click);
routes.Add(m.key, m);
}
if (this.m_layer != null)
{
m_layer.TrailRoutes = routes;
}
}
public void AfterImport(IList added, IList updated)
{
//Only added, not updated
foreach (object item in added)
{
if (item is IActivity)
{
IActivity activity = (IActivity)item;
//Set for barometric devices only
bool setEle = false;
if (TrailsPlugin.Data.Settings.SetAdjustElevationAtImport)
{
foreach (string devName in Settings.BarometricDevices)
{
if (activity.Metadata.Source.Contains(devName))
{
setEle = true;
break;
}
}
}
if (setEle)
{
//Do not keep selection, sort find best
Controller.TrailController.Instance.SetActivities(new List <IActivity> {
activity
}, false);
foreach (ActivityTrail at in Controller.TrailController.Instance.OrderedTrails())
{
if (at.Trail.IsSplits)
{
at.CalcResults(null);
}
if (at.Status == TrailOrderStatus.Match)
{
TrailResult tr = null;
if (!at.Trail.IsCompleteActivity)
{
//Recalculate, to get "full" first result
IList <TrailResultWrapper> ats = at.CalcTrailCompleteResult(activity);
if (ats.Count > 0)
{
tr = ats[0].Result;
}
}
else if (at.Results.Count > 0)
{
tr = at.Results[0].Result;
}
if (tr != null)
{
tr.SetDeviceElevation(true);
break;
}
}
}
}
}
}
}
//Note: IItemTrackSelectionInfo uses Activity distances, avoid...
public TrailResultMarked(TrailResult tr, IValueRangeSeries<double> t)
{
trailResult = tr;
selInfo.MarkedDistances = t;
}
private static float[] GetChartResultFromDistResult(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IValueRange <double> v)
{
//Note: Selecting in Route gives unpaused distance, but this should be handled in the selection
if (xIsTime)
{
DateTime d1 = tr.GetDateTimeFromDistActivity(v.Lower);
DateTime d2 = tr.GetDateTimeFromDistActivity(v.Upper);
return(GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d1, d2));
}
else
{
double t1 = tr.GetDistResultFromDistActivity(v.Lower);
double t2 = tr.GetDistResultFromDistActivity(v.Upper);
return(GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t1, t2));
}
}
//Complete trail
public TrailMapPolyline(TrailResult tr)
: this(tr.GpsPoints(), UnitUtil.GetApplication().SystemPreferences.RouteSettings.RouteWidth, tr.TrailColor, tr)
{ }
//Mark all
public TrailResultMarked(TrailResult tr)
{
trailResult = tr;
selInfo.MarkedTimes = tr.getSelInfo();
selInfo.Activity = tr.Activity;
}
public TrailResultMarked(TrailResult tr, IValueRangeSeries <DateTime> t)
{
this.trailResult = tr;
this.selInfo.MarkedTimes = TrailsItemTrackSelectionInfo.excludePauses(t, tr.Pauses);
this.selInfo.Activity = tr.Activity;
}
public static float ChartResultConvert(bool xOldIsTime, bool xNewIsTime, bool isOffset, TrailResult newTr, TrailResult ReferenceTrailResult, float t)
{
if (float.IsNaN(t))
{
return(t);
}
DateTime time = TrackUtil.GetDateTimeFromChartResult(xOldIsTime, isOffset, newTr, ReferenceTrailResult, t);
float res = TrackUtil.GetChartResultFromDateTime(xNewIsTime, isOffset, newTr, ReferenceTrailResult, time);
return(res);
}
public static IValueRangeSeries <DateTime> GetDateTimeFromChartResult(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IList <float[]> regions)
{
IValueRangeSeries <DateTime> t = new ValueRangeSeries <DateTime>();
foreach (float[] at in regions)
{
DateTime d1 = GetDateTimeFromChartResult(xIsTime, isOffset, tr, ReferenceTrailResult, at[0]);
DateTime d2 = GetDateTimeFromChartResult(xIsTime, isOffset, tr, ReferenceTrailResult, at[1]);
t.Add(new ValueRange <DateTime>(d1, d2));
}
return(t);
}
private TrailMapPolyline(IList<IGPSPoint> g, int w, Color c, TrailResult tr, string tkey)
: this(g, w, c, tr)
{
m_key += tkey;
}
/*************************************************/
//From result elapsed, get chart result
//TBD: incorrect to result
public static float GetChartResultsResyncOffset(bool xIsTime, TrailResult tr, TrailResult ReferenceTrailResult, float elapsed, out float nextElapsed)
{
float offset = 0;
nextElapsed = float.MaxValue;
if (Data.Settings.SyncChartAtTrailPoints && tr.Trail.TrailType == Trail.CalcType.TrailPoints)
{
IList <float> trElapsed;
//IList<float> trOffset;
IList <float> refElapsed;
if (xIsTime)
{
trElapsed = tr.TrailPointTime0(ReferenceTrailResult);
//trOffset = tr.TrailPointTimeOffset0(ReferenceTrailResult);
refElapsed = ReferenceTrailResult.TrailPointTime0(ReferenceTrailResult);
}
else
{
trElapsed = tr.TrailPointDist0(ReferenceTrailResult);
//trOffset = tr.TrailPointDistOffset0(ReferenceTrailResult);
refElapsed = ReferenceTrailResult.TrailPointDist0(ReferenceTrailResult);
}
//If the result/reference has no laps, no offset
if (trElapsed.Count <= 2 || refElapsed.Count <= 2)
{
return(offset);
}
int currOffsetIndex = 0;
while (currOffsetIndex < trElapsed.Count && currOffsetIndex < refElapsed.Count &&
(float.IsNaN(trElapsed[currOffsetIndex]) || elapsed > trElapsed[currOffsetIndex]))
{
if (!float.IsNaN(trElapsed[currOffsetIndex]) && !float.IsNaN(refElapsed[currOffsetIndex]))
{
offset = refElapsed[currOffsetIndex] - trElapsed[currOffsetIndex];
//if (currOffsetIndex < trOffset.Count && !float.IsNaN(trOffset[currOffsetIndex]))
//{
// offset += trOffset[currOffsetIndex];
//}
}
currOffsetIndex++;
}
//currOffsetIndex is at least one step over already
while (currOffsetIndex < trElapsed.Count && currOffsetIndex < refElapsed.Count &&
(float.IsNaN(trElapsed[currOffsetIndex]) || float.IsNaN(refElapsed[currOffsetIndex]) ||
elapsed < trElapsed[currOffsetIndex]))
{
if (currOffsetIndex >= trElapsed.Count - 1 || currOffsetIndex >= refElapsed.Count - 1)
{
//Last point - no limitation
nextElapsed = float.MaxValue;
break;
}
else if (!float.IsNaN(trElapsed[currOffsetIndex]) && !float.IsNaN(refElapsed[currOffsetIndex]))
{
nextElapsed = refElapsed[currOffsetIndex];
}
currOffsetIndex++;
}
}
return(offset);
}
internal static IList <float[]> GetChartResultFromActivity(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IItemTrackSelectionInfo sel)
{
IList <float[]> result = new List <float[]>();
//Currently only one range but several regions in the chart can be selected
//Only use one of the selections
if (sel.MarkedTimes != null)
{
foreach (IValueRange <DateTime> v in sel.MarkedTimes)
{
result.Add(GetChartResultFromDateTime(xIsTime, isOffset, tr, ReferenceTrailResult, v));
}
}
else if (sel.MarkedDistances != null)
{
foreach (IValueRange <double> v in sel.MarkedDistances)
{
result.Add(GetChartResultFromDistResult(xIsTime, isOffset, tr, ReferenceTrailResult, v));
}
}
else if (sel.SelectedTime != null)
{
result.Add(GetChartResultFromDateTime(xIsTime, isOffset, tr, ReferenceTrailResult, sel.SelectedTime));
}
else if (sel.SelectedDistance != null)
{
result.Add(GetChartResultFromDistResult(xIsTime, isOffset, tr, ReferenceTrailResult, sel.SelectedDistance));
}
return(result);
}
void summaryList_Click(object sender, System.EventArgs e)
{
#if !ST_2_1
//From Trails plugin
if (sender is TreeList)
{
TreeList l = sender as TreeList;
object row;
TreeList.RowHitState hit;
row = summaryList.RowHitTest(((MouseEventArgs)e).Location, out hit);
if (row != null && hit == TreeList.RowHitState.Row)
{
UniqueRoutesResult utr = (UniqueRoutesResult)(row);
bool colorSelected = false;
if (hit != TreeList.RowHitState.PlusMinus)
{
int nStart = ((MouseEventArgs)e).X;
int spos = l.Location.X;// +l.Parent.Location.X;
for (int i = 0; i < l.Columns.Count; i++)
{
int epos = spos + l.Columns[i].Width;
if (nStart > spos && nStart < epos)
{
if (l.Columns[i].Id == SummaryColumnIds.ActColor)
{
colorSelected = true;
break;
}
}
spos = epos;
}
}
if (colorSelected)
{
ColorSelectorPopup cs = new ColorSelectorPopup();
cs.Width = 70;
cs.ThemeChanged(m_visualTheme);
cs.DesktopLocation = ((Control)sender).PointToScreen(((MouseEventArgs)e).Location);
cs.Selected = utr.ActColor;
m_ColorSelectorResult = utr;
cs.ItemSelected += new ColorSelectorPopup.ItemSelectedEventHandler(cs_ItemSelected);
cs.Show();
}
else
{
bool isMatch = false;
foreach (UniqueRoutesResult t in getListSelection(this.summaryList.SelectedItems))
{
if (t == utr)
{
isMatch = true;
break;
}
}
IList<TrailResultMarked> aTrm = new List<TrailResultMarked>();
if (isMatch && m_refActivity != null)
{
IDictionary<IActivity, IList<PointInfo[]>> commonStretches = SimilarPoints;
if (commonStretches.Count > 0 &&
commonStretches.ContainsKey(utr.Activity) &&
commonStretches[utr.Activity] != null &&
commonStretches[utr.Activity].Count > 0)
{
TrailResult tr = new TrailResult(utr);
IItemTrackSelectionInfo[] i = CommonStretches.getSelInfo(new DateTime[] { utr.Activity.StartTime, m_refActivity.StartTime },
commonStretches[utr.Activity], true);
((TrailsItemTrackSelectionInfo)i[0]).Activity = utr.Activity;
((TrailsItemTrackSelectionInfo)i[1]).Activity = m_refActivity;
aTrm.Add(new TrailResultMarked(tr, i[0].MarkedTimes));
aTrm.Add(new TrailResultMarked(tr, i[1].MarkedTimes));
}
}
this.MarkTrack(aTrm);
}
}
}
#endif
}
public TrailResultMarked(TrailResult tr, IValueRangeSeries<DateTime> t)
{
trailResult = tr;
selInfo.MarkedTimes = t;
selInfo.Activity = tr.Activity;
}
public static void ChartResultConvert(bool xOldIsTime, bool xNewIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, float[] t)
{
if (TrackUtil.AnyRangeOverlap(xOldIsTime, isOffset, tr, ReferenceTrailResult, t))
{
t[0] = ChartResultConvert(xOldIsTime, xNewIsTime, isOffset, tr, ReferenceTrailResult, t[0]);
t[1] = ChartResultConvert(xOldIsTime, xNewIsTime, isOffset, tr, ReferenceTrailResult, t[1]);
}
else
{
t[0] = float.NaN;
t[1] = float.NaN;
}
}
public TrailResultMarked(TrailResult tr, IValueRange <DateTime> t)
{
this.trailResult = tr;
this.selInfo.SelectedTime = t; //include pauses
this.selInfo.Activity = tr.Activity;
}
public static void ChartResultConvert(bool xOldIsTime, bool xNewIsTime, bool isOffset, TrailResult oldTr, TrailResult newTr, TrailResult ReferenceTrailResult, float[] t)
{
DateTime time0 = DateTime.MinValue;
if (!float.IsNaN(t[0]))
{
time0 = TrackUtil.GetDateTimeFromChartResult(xOldIsTime, isOffset, oldTr, ReferenceTrailResult, t[0]);
}
DateTime time1 = DateTime.MinValue;
if (!float.IsNaN(t[1]))
{
time1 = TrackUtil.GetDateTimeFromChartResult(xOldIsTime, isOffset, oldTr, ReferenceTrailResult, t[1]);
}
if (TrackUtil.AnyOverlap(time0, time1, newTr.StartTime, newTr.EndTime))
{
t[0] = TrackUtil.GetChartResultFromDateTime(xNewIsTime, isOffset, newTr, ReferenceTrailResult, time0);
t[1] = TrackUtil.GetChartResultFromDateTime(xNewIsTime, isOffset, newTr, ReferenceTrailResult, time1);
}
else
{
t[0] = float.NaN;
t[1] = float.NaN;
}
}
public TrailResultMarked(TrailResult tr, IItemTrackSelectionInfo t)
{
trailResult = tr;
selInfo.SetFromSelection(t, tr.Activity);
}
public InsertValues(TrailResult result) :
this(result.StartTime, result.EndTime, result.Pauses)
{
this.points = result.SubResultInfo.Points;
}
/****************************************************/
public static bool AnyRangeOverlap(bool isTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, float[] t)
{
float[] t2 = GetChartResultFromDateTime(isTime, isOffset, tr, ReferenceTrailResult, new ValueRange <DateTime>(tr.StartTime, tr.EndTime));
return(TrackUtil.AnyRangeOverlap(t, t2[0], t2[1]));
}
private static float[] GetChartResultFromDateTime(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, IValueRange <DateTime> v)
{
DateTime d1 = v.Lower;
DateTime d2 = v.Upper;
if (xIsTime)
{
return(GetTimeChartResultFromDateTime(isOffset, tr, ReferenceTrailResult, d1, d2));
}
else
{
double t1 = tr.GetDistResult(d1);
double t2 = tr.GetDistResult(d2);
return(GetDistChartResultFromDistResult(isOffset, tr, ReferenceTrailResult, t1, t2));
}
}
public static DateTime GetDateTimeFromChartResult(bool xIsTime, bool isOffset, TrailResult tr, TrailResult ReferenceTrailResult, float t)
{
DateTime dateTime;
float xOffset = tr.GetXOffset(xIsTime, ReferenceTrailResult);
if (!xIsTime)
{
xOffset = (float)TrackUtil.DistanceConvertFrom(xOffset, ReferenceTrailResult);
}
t -= xOffset;
if (isOffset)
{
float nextElapsed;
t -= GetChartResultsResyncOffset(xIsTime, tr, ReferenceTrailResult, t, out nextElapsed);
}
if (xIsTime)
{
dateTime = tr.GetDateTimeFromTimeResult(t);
}
else
{
dateTime = tr.GetDateTimeFromDistResult(TrackUtil.DistanceConvertTo(t, ReferenceTrailResult));
}
return(dateTime);
}
private TrailMapPolyline(IList<IGPSPoint> g, int w, Color c, TrailResult tr)
: base(g, w, c)
{
m_trailResult = tr;
m_key = tr.Activity + ":" + tr.Order;
}
