public void InvokeStepExecutionChanged(StepExecutionChangedEventArgs args) { if (this.StepExecutionChanged != null) { this.StepExecutionChanged(this, args); } }
private void OnStepExecutionChanged(object sender, StepExecutionChangedEventArgs e) { if (!string.IsNullOrWhiteSpace(e.ProgressDetailText) && !StringComparer.CurrentCulture.Equals(previousProgressDetail, e.ProgressDetailText)) { previousProgressDetail = e.ProgressDetailText; string format = string.IsNullOrWhiteSpace(this.MessageFormat) ? "{0}" : this.MessageFormat; VsShellUtils.WriteToSonarLintOutputPane(this.serviceProvider, format, e.ProgressDetailText); } }
private void OnStepStateChanged(object sender, StepExecutionChangedEventArgs args) { if (this.StepExecutionChangedPrivate != null) { VsThreadingHelper.RunInline(this, VsTaskRunContext.UIThreadNormalPriority, () => { var delegates = this.StepExecutionChangedPrivate; if (delegates != null) { delegates(sender, args); // Verify that the observer handled it since now easy way of testing // serialized raising and handling of the event across the classes args.CheckHandled(); } }); } }
/// <summary> /// Updates the <see cref="ProgressStepViewModel"/> with the current step changes. /// The <see cref="ProgressStepViewModel"/> represents a <see cref="ExecutionGroup"/> /// of one visible step and zero or more hidden steps. The progress in <see cref="ProgressStepViewModel"/> /// is used as the sub progress and it will be indeterminate if there's one indeterminate /// <see cref="IProgressStep"/> in <see cref="ExecutionGroup"/>, otherwise the sub progress /// will be relative to the number of steps in <see cref="ExecutionGroup"/>. /// </summary> /// <param name="e">Execution update</param> private void UpdateViewModelStep(StepExecutionChangedEventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); ProgressStepViewModel vm = this.progressStepToViewModelMapping[e.Step]; ExecutionGroup executionGroup = this.viewModelToExecutionGroupMapping[vm]; bool isLastStep = e.Step == executionGroup.Steps.Last(); double groupCompletionPercentange = GetCompletedStepCount(executionGroup.Steps) / (double)executionGroup.Steps.Count; this.CurrentExecutingGroup = executionGroup; executionGroup.ExecutingStep = e.Step; // Update the step VM // Progress update: Indeterminate step progress should remain as it was // and the determinate step progress should be updated switch (e.State) { case StepExecutionState.NotStarted: Debug.Fail("Unexpected transition to NotStarted"); if (!vm.Progress.IsIndeterminate) { vm.Progress.SetUpperBoundLimitedValue(0); } break; case StepExecutionState.Executing: if (!vm.Progress.IsIndeterminate) { Debug.Assert(!executionGroup.Steps.Any(s => s.Indeterminate), "Not expecting any Indeterminate steps"); vm.Progress.SetUpperBoundLimitedValue(groupCompletionPercentange + (e.Progress / (double)executionGroup.Steps.Count)); } vm.ExecutionState = e.State; vm.ProgressDetailText = e.ProgressDetailText; break; default: Debug.Assert(ProgressControllerHelper.IsFinalState(e.State), "Unexpected non-final state", "State: {0}", e.State); if (!vm.Progress.IsIndeterminate) { vm.Progress.SetUpperBoundLimitedValue(groupCompletionPercentange); } // Succeeded state which is not the last will indicate // that the group is still executing if (e.State == StepExecutionState.Succeeded && !isLastStep) { vm.ExecutionState = StepExecutionState.Executing; } else { vm.ExecutionState = e.State; } executionGroup.ExecutingStep = null; if (isLastStep) { vm.ProgressDetailText = null; this.CurrentExecutingGroup = null; } break; } vm.ProgressDetailText = e.ProgressDetailText; }
/// <summary> /// Updates the main progress based on the number of steps in final state /// an the current step being executed. Each <see cref="IProgressStep"/> which impacts /// progress will have one "slot" in the main progress bar. /// </summary> /// <param name="e">Execution update</param> private void UpdateMainProgress(StepExecutionChangedEventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); double totalNumberOfSteps = this.ProgressImpactingSteps.Count(); double completedSteps = GetCompletedStepCount(this.ProgressImpactingSteps); this.viewModelRoot.Current = this.progressStepToViewModelMapping[e.Step]; this.viewModelRoot.MainProgress.SetUpperBoundLimitedValue(completedSteps / totalNumberOfSteps); // When a determinate step is executing take it's progress into account if (!e.IsProgressIndeterminate() && e.State == StepExecutionState.Executing) { this.viewModelRoot.MainProgress.SetUpperBoundLimitedValue(this.viewModelRoot.MainProgress.Value + e.Progress / totalNumberOfSteps); } }
private void OnStepExecutionChanged(object sender, StepExecutionChangedEventArgs e) { try { // Don't have to do it on the UI thread since we don't expect the mapping to change during execution if (!this.progressStepToViewModelMapping.ContainsKey(e.Step)) { Debug.Assert(!e.Step.ImpactsProgress, "View model out of sync. The step execution is for unexpected step"); return; } VsThreadingHelper.RunInline(this.serviceProvider, VsTaskRunContext.UIThreadNormalPriority, () => { this.UpdateViewModelStep(e); this.UpdateMainProgress(e); }); } finally { // Flag that handled to assist with the verification, otherwise the controller will assert e.Handled(); } }
private void OnStepExecutionChanged(object sender, StepExecutionChangedEventArgs e) { AssertEventHandlerArgsNotNull(sender, e); List<StepExecutionChangedEventArgs> list; if (!this.executionChanges.TryGetValue(e.Step, out list)) { this.executionChanges[e.Step] = list = new List<StepExecutionChangedEventArgs>(); } list.Add(e); // Satisfy the sequential controller verification code e.Handled(); }
private void OnStepStateChanged(object sender, StepExecutionChangedEventArgs args) { if (this.StepExecutionChangedPrivate != null) { VsThreadingHelper.RunInline(this, VsTaskRunContext.UIThreadNormalPriority, () => { var delegates = this.StepExecutionChangedPrivate; if (delegates != null) { delegates(sender, args); // Verify that the observer handled it since now easy way of testing // serialized raising and handling of the event across the classes args.CheckHandled(); } }); } }