public WorkoutLinkSelectionDialog(Workout parentWorkout, IStep destinationStep)
{
InitializeComponent();
this.Text = GarminFitnessView.GetLocalizedString("SelectWorkoutText");
OKButton.Text = CommonResources.Text.ActionOk;
Cancel_Button.Text = CommonResources.Text.ActionCancel;
WorkoutsListBox.Format += new ListControlConvertEventHandler(WorkoutsListBox_Format);
foreach (Workout workout in GarminWorkoutManager.Instance.Workouts)
{
// Don't allow recursive workouts or the same workout link twice since
// we can't tell the difference between substeps
if (workout != parentWorkout &&
!workout.ContainsWorkoutLink(parentWorkout) &&
parentWorkout.CanAcceptNewStep(workout.StepCount, destinationStep))
{
WorkoutsListBox.Items.Add(workout);
}
}
if (WorkoutsListBox.Items.Count > 0)
{
WorkoutsListBox.SelectedIndex = 0;
}
else
{
OKButton.Enabled = false;
}
}
public StepWrapper(StepWrapper parent, IStep element, Workout baseWorkout, bool isWorkoutLinkChild)
: base(parent, element)
{
Debug.Assert(baseWorkout != null);
m_BaseWorkout = baseWorkout;
m_IsWorkoutLinkChild = isWorkoutLinkChild;
}
public PowerBelowDuration(UInt16 minPower, bool isPercentFTP, IStep parent)
: this(parent)
{
ValidateValue(minPower, isPercentFTP);
m_IsPercentFTP.Value = isPercentFTP;
InternalMinPower.Value = minPower;
}
public PowerAboveDuration(UInt16 maxPower, bool isPercentFTP, IStep parent)
: this(parent)
{
ValidateValue(maxPower, isPercentFTP);
m_IsPercentFTP.Value = isPercentFTP;
InternalMaxPower.Value = maxPower;
}
public HeartRateAboveDuration(Byte maxHeartRate, bool isPercentageMaxHeartRate, IStep parent)
: this(parent)
{
ValidateValue(maxHeartRate, isPercentageMaxHeartRate);
m_IsPercentageMaxHR.Value = isPercentageMaxHeartRate;
InternalMaxHeartRate.Value = maxHeartRate;
}
public BaseSpeedTarget(IStep parent)
: base(TargetType.Speed, parent)
{
if (Options.Instance.UseSportTracksSpeedZones)
{
ConcreteTarget = new SpeedZoneSTTarget(this);
}
else
{
ConcreteTarget = new SpeedZoneGTCTarget(this);
}
}
public BasePowerTarget(IStep parent)
: base(ITarget.TargetType.Power, parent)
{
if (Options.Instance.UseSportTracksPowerZones)
{
ConcreteTarget = new PowerZoneSTTarget(this);
}
else
{
ConcreteTarget = new PowerZoneGTCTarget(this);
}
}
void OnStepChanged(IStep modifiedStep, PropertyChangedEventArgs changedProperty)
{
if (changedProperty.PropertyName == "ForceSplitOnStep" ||
changedProperty.PropertyName == "LinkSteps")
{
TriggerWorkoutChangedEvent(new PropertyChangedEventArgs("PartsCount"));
}
if (ConcreteWorkout.StepChanged != null)
{
ConcreteWorkout.StepChanged(this, modifiedStep, changedProperty);
}
}
private bool GetStepExportIdInternal(IStep step, List<IStep> stepsList, ref UInt16 stepCounter)
{
foreach (IStep currentStep in stepsList)
{
if (currentStep is WorkoutLinkStep)
{
WorkoutLinkStep concreteStep = currentStep as WorkoutLinkStep;
UInt16 tempCounter = 0;
if (GetStepExportIdInternal(step, concreteStep.LinkedWorkoutSteps, ref tempCounter))
{
stepCounter += tempCounter;
return true;
}
}
else if (currentStep is RepeatStep)
{
RepeatStep concreteStep = currentStep as RepeatStep;
UInt16 tempCounter = 0;
if (GetStepExportIdInternal(step, concreteStep.StepsToRepeat, ref tempCounter))
{
stepCounter += tempCounter;
return true;
}
}
stepCounter += currentStep.StepCount;
if (currentStep == step)
{
return true;
}
}
return false;
}
protected void RegisterStep(IStep stepToRegister)
{
stepToRegister.StepChanged += new IStep.StepChangedEventHandler(OnStepChanged);
if (stepToRegister is RegularStep)
{
RegularStep regularStep = stepToRegister as RegularStep;
regularStep.DurationChanged += new RegularStep.StepDurationChangedEventHandler(OnDurationChanged);
regularStep.TargetChanged += new RegularStep.StepTargetChangedEventHandler(OnTargetChanged);
}
else if (stepToRegister is RepeatStep)
{
RepeatStep repeatStep = stepToRegister as RepeatStep;
repeatStep.DurationChanged += new RepeatStep.StepDurationChangedEventHandler(OnRepeatDurationChanged);
}
stepToRegister.ParentConcreteWorkout = ConcreteWorkout;
if (stepToRegister.Type == IStep.StepType.Repeat)
{
RegisterRepeatStep((RepeatStep)stepToRegister);
}
}
public UInt16 GetStepSplitPart(IStep step)
{
UInt16 counter = 0;
UInt16 partNumber = 1;
if (GetStepSplitPart(step, Steps, ref partNumber, ref counter))
{
return partNumber;
}
return 0;
}
public IStep GetPreviousStep(IStep nextStep)
{
UInt16 index;
List<IStep> parentList;
if (Utils.GetStepInfo(nextStep, Steps, out parentList, out index))
{
if (index != 0)
{
return parentList[index - 1];
}
}
return null;
}
// Abstract methods public abstract bool CanAcceptNewStep(int newStepCount, IStep destinationStep);
protected IRepeatDuration(RepeatDurationType type, RepeatStep parent)
{
Debug.Assert(type != RepeatDurationType.RepeatDurationTypeCount);
m_Type = type;
m_ParentStep = parent;
}
protected IDuration(DurationType type, IStep parent)
{
Debug.Assert(type != DurationType.DurationTypeCount);
m_Type = type;
m_ParentStep = parent;
}
protected ITarget(Stream stream, DataVersion version, IStep parent)
{
Deserialize(stream, version);
}
public bool CanAcceptNewStep(IStep newStep, IStep destinationStep)
{
return CanAcceptNewStep(newStep.StepCount, destinationStep);
}
protected IRepeatDuration(Stream stream, DataVersion version, RepeatStep parent)
{
m_ParentStep = parent;
Deserialize(stream, version);
}
public IStep GetNextStep(IStep previousStep)
{
UInt16 index;
List<IStep> parentList;
if (Utils.GetStepInfo(previousStep, Steps, out parentList, out index))
{
if (index != parentList.Count - 1)
{
index++;
}
return parentList[index];
}
return null;
}
public BaseCadenceTarget(IStep parent)
: base(ITarget.TargetType.Cadence, parent)
{
ConcreteTarget = new CadenceZoneSTTarget(this);
}
public int GetStepExportId(IStep step)
{
IWorkout containerWorkout = this;
UInt16 counter = 0;
if (step is WorkoutLinkStep)
{
step = (step as WorkoutLinkStep).LinkedWorkoutSteps[0];
}
if (GetSplitPartsCount() > 1)
{
ushort stepSplitPart = GetStepSplitPart(step);
if (stepSplitPart == 0)
{
throw new Exception("Step not found in workout");
}
containerWorkout = ConcreteWorkout.SplitInSeperateParts()[stepSplitPart - 1];
}
if(!containerWorkout.GetStepExportIdInternal(step, containerWorkout.Steps, ref counter))
{
throw new Exception("Step not found in workout");
}
return counter;
}
public BaseCadenceTarget(Stream stream, DataVersion version, IStep parent)
: this(parent)
{
Deserialize(stream, version);
}
public void MoveStepUp(IStep step)
{
UInt16 selectedPosition = 0;
List<IStep> selectedList = null;
if (Utils.GetStepInfo(step, Steps, out selectedList, out selectedPosition))
{
Debug.Assert(selectedPosition > 0);
selectedList.Reverse(selectedPosition - 1, 2);
TriggerWorkoutChangedEvent(new PropertyChangedEventArgs("Steps"));
}
}
public DistanceDuration(IStep parent)
: base(DurationType.Distance, parent)
{
SetDistanceInBaseUnit(1);
}
protected void UnregisterStep(IStep stepToUnregister)
{
stepToUnregister.StepChanged -= new IStep.StepChangedEventHandler(OnStepChanged);
if (stepToUnregister is RegularStep)
{
RegularStep regularStep = stepToUnregister as RegularStep;
regularStep.DurationChanged -= new RegularStep.StepDurationChangedEventHandler(OnDurationChanged);
regularStep.TargetChanged -= new RegularStep.StepTargetChangedEventHandler(OnTargetChanged);
}
else if (stepToUnregister is RepeatStep)
{
RepeatStep repeatStep = stepToUnregister as RepeatStep;
repeatStep.DurationChanged -= new RepeatStep.StepDurationChangedEventHandler(OnRepeatDurationChanged);
}
}
public DistanceDuration(double distanceToGo, Length.Units distanceUnit, IStep parent)
: this(parent)
{
SetDistanceInUnits(distanceToGo, distanceUnit);
}
private bool GetStepSplitPart(IStep step, WorkoutStepsList stepsList, ref UInt16 stepPart, ref UInt16 stepCounter)
{
IStep topMostRepeat = Steps.GetTopMostRepeatForStep(step);
IStep stepToFind = step;
if (topMostRepeat != null)
{
stepToFind = topMostRepeat;
}
if (stepsList.Count > 0 &&
stepsList[0].ForceSplitOnStep && stepsList[0] != Steps[0])
{
stepPart++;
stepCounter = 0;
}
foreach (IStep currentStep in stepsList)
{
if (currentStep is WorkoutLinkStep)
{
WorkoutLinkStep linkStep = currentStep as WorkoutLinkStep;
if (currentStep == step)
{
if (linkStep.LinkedWorkoutSteps.Count > 0)
{
// The part # of a workout link is the part number of it's last step
return GetStepSplitPart(linkStep.LinkedWorkoutSteps[linkStep.LinkedWorkoutSteps.Count - 1],
linkStep.LinkedWorkoutSteps,
ref stepPart,
ref stepCounter);
}
else
{
return true;
}
}
else
{
if (GetStepSplitPart(step, linkStep.LinkedWorkoutSteps,
ref stepPart, ref stepCounter))
{
return true;
}
}
}
else
{
if ((currentStep.ForceSplitOnStep && currentStep != Steps[0]) ||
stepCounter + currentStep.StepCount > Constants.MaxStepsPerWorkout)
{
stepPart++;
stepCounter = 0;
}
stepCounter += currentStep.StepCount;
}
if (currentStep == stepToFind)
{
return true;
}
}
return false;
}
public DistanceDuration(Stream stream, DataVersion version, IStep parent)
: this(parent)
{
Deserialize(stream, version);
}
void OnTargetChanged(IStep modifiedStep, ITarget targetChanged, PropertyChangedEventArgs changedProperty)
{
Debug.Assert(modifiedStep.Type == IStep.StepType.Regular);
if (ConcreteWorkout.StepTargetChanged != null)
{
ConcreteWorkout.StepTargetChanged(this, (RegularStep)modifiedStep, targetChanged, changedProperty);
}
}
protected ITarget(TargetType type, IStep parent)
{
Debug.Assert(type != TargetType.TargetTypeCount);
m_Type = type;
m_ParentStep = parent;
}
