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