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 WorkoutStepsList GetStepsForPart(int partNumber)
{
WorkoutStepsList result = new WorkoutStepsList(this);
UInt16 currentPartNumber = 0;
int counter = 0;
GetStepsForPart(partNumber, ref result, ref currentPartNumber, ref counter);
return result;
}
public WorkoutStepsList GetStepsForPart(int partNumber, ref WorkoutStepsList result,
ref UInt16 partNumberCounter, ref int stepCounter)
{
for (int i = 0; i < Steps.Count; ++i)
{
IStep currentStep = Steps[i];
if (currentStep is WorkoutLinkStep)
{
WorkoutLinkStep linkStep = currentStep as WorkoutLinkStep;
linkStep.GetStepsForPart(partNumber, ref result,
ref partNumberCounter, ref stepCounter);
}
else
{
stepCounter += currentStep.StepCount;
if (i != 0 && (currentStep.ForceSplitOnStep || stepCounter > Constants.MaxStepsPerWorkout))
{
partNumberCounter++;
stepCounter = currentStep.StepCount;
}
if (partNumberCounter == partNumber)
{
// Add step to result, it's in the right part
result.Add(currentStep);
}
else if (partNumberCounter > partNumber)
{
break;
}
}
}
return result;
}
private void Initialize()
{
m_WorkoutStepsCopy = new WorkoutStepsList(ParentConcreteWorkout);
LinkedWorkout.WorkoutChanged += new IWorkout.WorkoutChangedEventHandler(OnWorkoutChanged);
LinkedWorkout.StepChanged += new IWorkout.StepChangedEventHandler(OnWorkoutStepChanged);
LinkedWorkout.StepDurationChanged += new IWorkout.StepDurationChangedEventHandler(OnWorkoutStepDurationChanged);
LinkedWorkout.StepTargetChanged += new IWorkout.StepTargetChangedEventHandler(OnWorkoutStepTargetChanged);
LinkedWorkout.Steps.StepAdded += new WorkoutStepsList.StepAddedEventHandler(OnWorkoutStepsChanged);
LinkedWorkout.Steps.StepRemoved += new WorkoutStepsList.StepRemovedEventHandler(OnWorkoutStepsChanged);
LinkedWorkout.Steps.ListChanged += new PropertyChangedEventHandler(OnWorkoutStepsListChanged);
UpdateWorkoutStepsCopy();
m_CurrentTopMostRepeat = ParentConcreteWorkout.Steps.GetTopMostRepeatForStep(this);
}
public List<IStep> DeserializeSteps(Stream stream)
{
List<IStep> deserializedSteps = new List<IStep>();
byte[] intBuffer = new byte[sizeof(Int32)];
Byte stepCount = (Byte)stream.ReadByte();
for (int i = 0; i < stepCount; i++)
{
IStep.StepType type;
stream.Read(intBuffer, 0, sizeof(Int32));
type = (IStep.StepType)BitConverter.ToInt32(intBuffer, 0);
if (type == IStep.StepType.Regular)
{
deserializedSteps.Add(new RegularStep(stream, Constants.CurrentVersion, ConcreteWorkout));
}
else if (type == IStep.StepType.Repeat)
{
deserializedSteps.Add(new RepeatStep(stream, Constants.CurrentVersion, ConcreteWorkout));
}
else
{
WorkoutLinkStep tempLink = new WorkoutLinkStep(stream, Constants.CurrentVersion, ConcreteWorkout);
if (tempLink.LinkedWorkout != null)
{
deserializedSteps.Add(tempLink);
}
else
{
WorkoutStepsList linkSteps = new WorkoutStepsList(ConcreteWorkout);
linkSteps.Deserialize(stream, Constants.CurrentVersion);
deserializedSteps.AddRange(linkSteps);
}
}
}
// Now that we deserialized, paste in the current workout
if (Steps.AddStepsToRoot(deserializedSteps))
{
return deserializedSteps;
}
return null;
}
public void Deserialize_V15(Stream stream, DataVersion version)
{
Deserialize_V14(stream, version);
// Check if we found the workout link. If we did deserialize the steps
// list in a disposable one. If we can't find the workout, then we must
// not deserialize the list so it can simply add the steps the the workout
if (m_LinkedWorkout != null)
{
WorkoutStepsList tempStepsList = new WorkoutStepsList(ParentConcreteWorkout);
tempStepsList.Deserialize(stream, version);
}
}
protected override void OnPrintPage(PrintPageEventArgs e)
{
try
{
base.OnPrintPage(e);
if (m_CurrentWorkout != null || m_WorkoutsToPrint.Count > 0)
{
RectangleF outputArea = new RectangleF(e.PageSettings.Bounds.Left + e.PageSettings.Margins.Left,
e.PageSettings.Bounds.Top + e.PageSettings.Margins.Top,
e.PageSettings.Bounds.Width - e.PageSettings.Margins.Left - e.PageSettings.Margins.Right,
e.PageSettings.Bounds.Height - e.PageSettings.Margins.Top - e.PageSettings.Margins.Bottom);
float headerHeight = 0;
if (m_CurrentWorkout == null)
{
m_CurrentWorkout = m_WorkoutsToPrint[0].CloneUnregistered();
m_CurrentWorkoutSteps = UnrollRepeats(m_CurrentWorkout.Steps, m_CurrentWorkout);
m_CurrentStep = 0;
m_WorkoutsToPrint.RemoveAt(0);
headerHeight = PrintWorkoutHeader(m_CurrentWorkout,
e.Graphics,
new RectangleF(outputArea.Left, outputArea.Top,
outputArea.Width - (1.5f * m_CornerRadius), outputArea.Height));
}
int nextStepToDraw = PrintWorkoutSteps(m_CurrentWorkout, m_CurrentStep,
e.Graphics,
new RectangleF(outputArea.Left, outputArea.Top + headerHeight,
outputArea.Width - (1.5f * m_CornerRadius), outputArea.Height - headerHeight));
if (nextStepToDraw < m_CurrentWorkoutSteps.StepCount)
{
m_CurrentStep = nextStepToDraw;
}
else
{
m_CurrentWorkout = null;
m_CurrentWorkoutSteps = null;
}
e.HasMorePages = m_CurrentWorkout != null || m_WorkoutsToPrint.Count > 0;
}
}
catch(Exception exception)
{
throw exception;
}
}
private WorkoutStepsList UnrollRepeats(List<IStep> originalSteps, Workout parent)
{
WorkoutStepsList result = new WorkoutStepsList(parent);
foreach(IStep currentStep in originalSteps)
{
bool copyOriginal = true;
if (m_UnrollRepeats)
{
if (currentStep is RepeatStep)
{
RepeatStep currentRepeat = currentStep as RepeatStep;
WorkoutStepsList unrolledRepeat;
if (currentRepeat.Duration is RepeatCountDuration)
{
RepeatCountDuration duration = currentRepeat.Duration as RepeatCountDuration;
copyOriginal = false;
unrolledRepeat = UnrollRepeats(currentRepeat.StepsToRepeat, parent);
for (int i = 0; i < duration.RepetitionCount; ++i)
{
foreach (IStep currentUnrolledStep in unrolledRepeat)
{
result.Add(currentUnrolledStep.Clone());
}
}
}
}
else if (currentStep is WorkoutLinkStep)
{
WorkoutLinkStep currentLink = currentStep as WorkoutLinkStep;
WorkoutStepsList unrolledRepeat;
copyOriginal = false;
unrolledRepeat = UnrollRepeats(currentLink.LinkedWorkoutSteps, parent);
foreach (IStep currentUnrolledStep in unrolledRepeat)
{
result.Add(currentUnrolledStep);
}
}
}
if (copyOriginal)
{
result.Add(currentStep.Clone());
}
}
return result;
}
public void Deserialize_V20(Stream stream, DataVersion version)
{
// Call base deserialization
Deserialize(typeof(IStep), stream, version);
byte[] intBuffer = new byte[sizeof(Int32)];
Int32 stepCount;
stream.Read(intBuffer, 0, sizeof(Int32));
stepCount = BitConverter.ToInt32(intBuffer, 0);
// In case the repeat was already registered on the workout
ParentConcreteWorkout.Steps.RemoveSteps(StepsToRepeat, false);
m_StepsToRepeat.Clear();
for (int i = 0; i < stepCount; ++i)
{
IStep.StepType type;
stream.Read(intBuffer, 0, sizeof(Int32));
type = (IStep.StepType)BitConverter.ToInt32(intBuffer, 0);
if (type == IStep.StepType.Regular)
{
m_StepsToRepeat.Add(new RegularStep(stream, version, ParentConcreteWorkout));
}
else if (type == IStep.StepType.Link)
{
WorkoutLinkStep tempLink = new WorkoutLinkStep(stream, version, ParentConcreteWorkout);
if (tempLink.LinkedWorkout != null)
{
m_StepsToRepeat.Add(tempLink);
}
else
{
WorkoutStepsList linkSteps = new WorkoutStepsList(ParentConcreteWorkout);
linkSteps.Deserialize(stream, Constants.CurrentVersion);
m_StepsToRepeat.AddRange(linkSteps);
}
}
else
{
m_StepsToRepeat.Add(new RepeatStep(stream, version, ParentConcreteWorkout));
}
}
stream.Read(intBuffer, 0, sizeof(Int32));
IRepeatDuration.RepeatDurationType durationType = (IRepeatDuration.RepeatDurationType)(BitConverter.ToInt32(intBuffer, 0));
Duration = DurationFactory.Create(durationType, stream, version, this);
}
private void CreateStepsList()
{
m_Steps = new WorkoutStepsList(this);
m_Steps.StepAdded += new WorkoutStepsList.StepAddedEventHandler(OnStepAdded);
m_Steps.StepRemoved += new WorkoutStepsList.StepRemovedEventHandler(OnStepRemoved);
m_Steps.ListChanged += new PropertyChangedEventHandler(OnStepsListChanged);
}
