666 lines
28 KiB
C#
666 lines
28 KiB
C#
using C4IT.F4SD.DisplayFormatting;
|
|
using C4IT.F4SD.SupportCaseProtocoll.Models;
|
|
using C4IT.FASD.Base;
|
|
using F4SD_AdaptableIcon.Enums;
|
|
using F4SD.Gamification;
|
|
using FasdDesktopUi.Basics.Converter;
|
|
using FasdDesktopUi.Basics.Models;
|
|
using FasdDesktopUi.Basics.Services.ProtocollService;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections.Specialized;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Data;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using static C4IT.Logging.cLogManager;
|
|
using F4SD.Gamification.Services;
|
|
using FasdDesktopUi.Basics.Models.QuickActionOutput;
|
|
|
|
namespace FasdDesktopUi.Basics.UserControls
|
|
{
|
|
public partial class QuickActionStatusMonitor : UserControl, IBlurInvoker
|
|
{
|
|
private bool secretsAreShown = false;
|
|
private readonly IRawValueFormatter _rawValueFormatter = new RawValueFormatter();
|
|
|
|
private static object _currentQuickActionLock = new object();
|
|
|
|
private Guid _currentRunningQuickActionId;
|
|
|
|
public Guid CurrentRunningQuickActionId
|
|
{
|
|
get { lock (_currentQuickActionLock) { return _currentRunningQuickActionId; } }
|
|
set { lock (_currentQuickActionLock) { _currentRunningQuickActionId = value; } }
|
|
}
|
|
|
|
#region Properties
|
|
|
|
private CancellationTokenSource tokenSource;
|
|
private bool quickActionIsRunning = false;
|
|
private cQuickActionStatusMonitorModel tempQuickActionData;
|
|
private readonly RevisionStatusToAdaptableIconConverter revisionStatusToIconConverter = new RevisionStatusToAdaptableIconConverter();
|
|
public cSupportCaseDataProvider DataProvider { get; set; }
|
|
|
|
public bool HasQuickActionDataChangedSinceRun { get => QuickActionData == null || !QuickActionData.Equals(tempQuickActionData); }
|
|
|
|
#region QuickActionData
|
|
|
|
private static void QuickActionDataChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if (d is QuickActionStatusMonitor _me && e.NewValue is cQuickActionStatusMonitorModel quickActionData)
|
|
{
|
|
_me.SetQuickActionCompletionSteps(quickActionData.ActionSteps);
|
|
_me.CopyButton.Visibility = Visibility.Collapsed;
|
|
_me.secretsAreShown = false;
|
|
_me.SecretButton.SelectedMaterialIcon = MaterialIcons.MaterialIconType.ic_visibility;
|
|
_me.SecretButton.Visibility = Visibility.Collapsed;
|
|
_me.AdjustableParameterSectionUc.ToggleIsActive(true);
|
|
}
|
|
}
|
|
|
|
public static readonly DependencyProperty QuickActionDataProperty =
|
|
DependencyProperty.Register("QuickActionData", typeof(cQuickActionStatusMonitorModel), typeof(QuickActionStatusMonitor), new PropertyMetadata(new cQuickActionStatusMonitorModel(), new PropertyChangedCallback(QuickActionDataChangedCallback)));
|
|
|
|
|
|
public cQuickActionStatusMonitorModel QuickActionData
|
|
{
|
|
get { return (cQuickActionStatusMonitorModel)GetValue(QuickActionDataProperty); }
|
|
set { SetValue(QuickActionDataProperty, value); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsCloseButtonVisible
|
|
|
|
public static readonly DependencyProperty IsCloseButtonVisibleProperty =
|
|
DependencyProperty.Register("IsCloseButtonVisible", typeof(bool), typeof(QuickActionStatusMonitor), new PropertyMetadata(false));
|
|
|
|
public bool IsCloseButtonVisible
|
|
{
|
|
get { return (bool)GetValue(IsCloseButtonVisibleProperty); }
|
|
set { SetValue(IsCloseButtonVisibleProperty, value); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region QuickActionOutputs
|
|
|
|
private ObservableCollection<cF4sdQuickActionRevision.cOutput> quickActionOutputs = new ObservableCollection<cF4sdQuickActionRevision.cOutput>();
|
|
|
|
public ObservableCollection<cF4sdQuickActionRevision.cOutput> QuickActionOutputs
|
|
{
|
|
get { return quickActionOutputs; }
|
|
set
|
|
{
|
|
QuickActionResultStack.Children.Clear();
|
|
quickActionOutputs.CollectionChanged -= QuickActionOutputsChanged;
|
|
quickActionOutputs = value;
|
|
quickActionOutputs.CollectionChanged += QuickActionOutputsChanged;
|
|
}
|
|
}
|
|
|
|
private void QuickActionOutputsChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (e.Action is NotifyCollectionChangedAction.Reset)
|
|
QuickActionResultStack.Children.Clear();
|
|
|
|
if (e.Action is NotifyCollectionChangedAction.Add)
|
|
{
|
|
foreach (cF4sdQuickActionRevision.cOutput quickActionOutput in e.NewItems)
|
|
{
|
|
try
|
|
{
|
|
if (!cQuickActionOutput.HasError(quickActionOutput))
|
|
{
|
|
if (quickActionOutput?.Values is null)
|
|
continue;
|
|
|
|
var helperQuickActionOutput = cQuickActionOutput.GetQuickActionOutput(quickActionOutput, DataProvider);
|
|
|
|
if (helperQuickActionOutput is null)
|
|
continue;
|
|
|
|
if (helperQuickActionOutput is cQuickActionOutputObject outObj && outObj.Values.Count <= 0)
|
|
continue;
|
|
|
|
if (helperQuickActionOutput is cQuickActionOutputList outList && outList.Values.Count <= 0)
|
|
continue;
|
|
}
|
|
|
|
var outputElement = new QuickActionStatusMonitorResultElement();
|
|
outputElement.SetQuickActionOutputData(quickActionOutput, DataProvider, QuickActionData.QuickActionDefinition);
|
|
QuickActionResultStack.Children.Add(outputElement);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region QuickActionMeasureValues
|
|
|
|
private static void QuickActionMeasureValuesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if (!(d is QuickActionStatusMonitor _me))
|
|
return;
|
|
|
|
if (!(e.NewValue is List<cQuickActionMeasureValue> newValue))
|
|
return;
|
|
|
|
_me.UpdateQuickActionMeasureValues(newValue);
|
|
}
|
|
|
|
public static readonly DependencyProperty MeasureValuesProperty =
|
|
DependencyProperty.Register("MeasureValues", typeof(List<cQuickActionMeasureValue>), typeof(QuickActionStatusMonitor), new PropertyMetadata(null, new PropertyChangedCallback(QuickActionMeasureValuesChanged)));
|
|
|
|
|
|
public List<cQuickActionMeasureValue> MeasureValues
|
|
{
|
|
get { return (List<cQuickActionMeasureValue>)GetValue(MeasureValuesProperty); }
|
|
set { SetValue(MeasureValuesProperty, value); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
public Action CloseButtonClickedAction { get; set; }
|
|
|
|
#endregion
|
|
|
|
public QuickActionStatusMonitor()
|
|
{
|
|
InitializeComponent();
|
|
tokenSource = new CancellationTokenSource();
|
|
quickActionOutputs.CollectionChanged += QuickActionOutputsChanged;
|
|
}
|
|
|
|
public void BlurInvoker_IsActiveChanged(object sender, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
BlurInvoker.InvokeVisibilityChanged(this, new EventArgs());
|
|
}
|
|
|
|
public bool BlurInvoker_IsActive => IsVisible;
|
|
|
|
public void SetQuickActionCompletionSteps(List<cQuickActionStatusMonitorModel.cQuickActionStep> ActionSteps)
|
|
{
|
|
try
|
|
{
|
|
ResetExecuteButton();
|
|
|
|
//required to prevent binding errors
|
|
//todo: add clean way to remove bindings of Quick Action Steps
|
|
foreach (var child in CompletionStatusPanel.Children)
|
|
{
|
|
if (!(child is Panel panelElement))
|
|
continue;
|
|
|
|
foreach (var childElement in panelElement.Children)
|
|
{
|
|
if (childElement is AdaptableIcon.AdaptableIcon childIcon)
|
|
{
|
|
BindingOperations.ClearBinding(childIcon, AdaptableIcon.AdaptableIcon.SelectedInternIconProperty);
|
|
BindingOperations.ClearBinding(childIcon, AdaptableIcon.AdaptableIcon.SelectedInternGifProperty);
|
|
BindingOperations.ClearBinding(childIcon, AdaptableIcon.AdaptableIcon.SelectedMaterialIconProperty);
|
|
}
|
|
|
|
if (childElement is Panel childPanel)
|
|
{
|
|
foreach (var panelChildElement in childPanel.Children)
|
|
{
|
|
if (panelChildElement is AdaptableIcon.AdaptableIcon panelChildIcon)
|
|
{
|
|
BindingOperations.ClearBinding(panelChildIcon, AdaptableIcon.AdaptableIcon.SelectedInternIconProperty);
|
|
BindingOperations.ClearBinding(panelChildIcon, AdaptableIcon.AdaptableIcon.SelectedInternGifProperty);
|
|
BindingOperations.ClearBinding(panelChildIcon, AdaptableIcon.AdaptableIcon.SelectedMaterialIconProperty);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CompletionStatusPanel.Children.Clear();
|
|
|
|
if (ActionSteps == null || ActionSteps.Count < 1)
|
|
return;
|
|
|
|
foreach (var step in ActionSteps)
|
|
{
|
|
DockPanel actionStepStatusPanel = new DockPanel() { Margin = new Thickness(0, 2.5, 0, 2.5), LastChildFill = false };
|
|
DockPanel.SetDock(actionStepStatusPanel, Dock.Top);
|
|
|
|
AdaptableIcon.AdaptableIcon completionIcon = new AdaptableIcon.AdaptableIcon() { IconHeight = 12, IconWidth = 12, BorderPadding = new Thickness(0) };
|
|
Binding adaptableIconBinding = new Binding($"QuickActionData.ActionSteps[{ActionSteps.IndexOf(step)}].Status")
|
|
{
|
|
ElementName = nameof(QuickActionStatusMonitorUc),
|
|
Converter = revisionStatusToIconConverter
|
|
};
|
|
completionIcon.SetBinding(AdaptableIcon.AdaptableIcon.SelectedInternIconProperty, adaptableIconBinding);
|
|
completionIcon.SetBinding(AdaptableIcon.AdaptableIcon.SelectedInternGifProperty, adaptableIconBinding);
|
|
completionIcon.SetBinding(AdaptableIcon.AdaptableIcon.SelectedMaterialIconProperty, adaptableIconBinding);
|
|
|
|
TextBlock actionStepTextBlock = new TextBlock() { Text = step.DisplayName, Margin = new Thickness(5, 0, 5, 0) };
|
|
|
|
DockPanel.SetDock(completionIcon, Dock.Left);
|
|
DockPanel.SetDock(actionStepTextBlock, Dock.Left);
|
|
|
|
actionStepStatusPanel.Children.Add(completionIcon);
|
|
actionStepStatusPanel.Children.Add(actionStepTextBlock);
|
|
|
|
CompletionStatusPanel.Children.Add(actionStepStatusPanel);
|
|
|
|
if (step.SubSteps?.Count > 0)
|
|
{
|
|
StackPanel subStackPanel = new StackPanel() { Margin = new Thickness(25, 0, 0, 0), Visibility = Visibility.Collapsed, Tag = step.QuickActionName };
|
|
DockPanel.SetDock(subStackPanel, Dock.Top);
|
|
|
|
foreach (var subStep in step.SubSteps)
|
|
{
|
|
DockPanel subActionStepStatusPanel = new DockPanel() { Margin = new Thickness(0, 2.5, 0, 2.5), LastChildFill = false };
|
|
DockPanel.SetDock(subActionStepStatusPanel, Dock.Top);
|
|
|
|
AdaptableIcon.AdaptableIcon subCompletionIcon = new AdaptableIcon.AdaptableIcon() { IconHeight = 12, IconWidth = 12, BorderPadding = new Thickness(0) };
|
|
Binding subAdaptableIconBinding = new Binding($"QuickActionData.ActionSteps[{ActionSteps.IndexOf(step)}].SubSteps[{step.SubSteps.IndexOf(subStep)}].Status")
|
|
{
|
|
ElementName = nameof(QuickActionStatusMonitorUc),
|
|
Converter = revisionStatusToIconConverter
|
|
};
|
|
subCompletionIcon.SetBinding(AdaptableIcon.AdaptableIcon.SelectedInternIconProperty, subAdaptableIconBinding);
|
|
subCompletionIcon.SetBinding(AdaptableIcon.AdaptableIcon.SelectedInternGifProperty, subAdaptableIconBinding);
|
|
subCompletionIcon.SetBinding(AdaptableIcon.AdaptableIcon.SelectedMaterialIconProperty, subAdaptableIconBinding);
|
|
|
|
TextBlock subActionStepTextBlock = new TextBlock() { Text = subStep.DisplayName, Margin = new Thickness(5, 0, 5, 0) };
|
|
|
|
DockPanel.SetDock(subCompletionIcon, Dock.Left);
|
|
DockPanel.SetDock(subActionStepTextBlock, Dock.Left);
|
|
|
|
subActionStepStatusPanel.Children.Add(subCompletionIcon);
|
|
subActionStepStatusPanel.Children.Add(subActionStepTextBlock);
|
|
|
|
subStackPanel.Children.Add(subActionStepStatusPanel);
|
|
}
|
|
|
|
CompletionStatusPanel.Children.Add(subStackPanel);
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
private void UpdateQuickActionMeasureValues(List<cQuickActionMeasureValue> measureValues)
|
|
{
|
|
try
|
|
{
|
|
MeasureValueGrid.Children.Clear();
|
|
MeasureValueGrid.RowDefinitions.Clear();
|
|
|
|
if (measureValues?.Count <= 0)
|
|
return;
|
|
|
|
_rawValueFormatter.SetDefaultCulture(cFasdCockpitConfig.Instance.SelectedCulture);
|
|
_rawValueFormatter.SetDefaultTimeZone(TimeZoneInfo.Local);
|
|
|
|
for (int i = 0; i < measureValues.Count; i++)
|
|
{
|
|
var measureValue = measureValues[i];
|
|
|
|
MeasureValueGrid.RowDefinitions.Add(new RowDefinition());
|
|
|
|
WrapPanel wrapPanel = new WrapPanel() { Orientation = Orientation.Horizontal };
|
|
|
|
Border titleBorder = new Border() { Padding = new Thickness(5, 2.5, 5, 2.5) };
|
|
TextBlock titleTextBlock = new TextBlock()
|
|
{
|
|
Text = measureValue.Names.GetValue(),
|
|
TextWrapping = TextWrapping.Wrap,
|
|
VerticalAlignment = VerticalAlignment.Center,
|
|
Style = (Style)FindResource("DetailsPage.DataHistory.TitleColumn.OverviewTitle")
|
|
};
|
|
|
|
titleBorder.Child = titleTextBlock;
|
|
wrapPanel.Children.Add(titleBorder);
|
|
|
|
TextBlock valueTextBlock = new TextBlock()
|
|
{
|
|
Text = _rawValueFormatter.GetDisplayValue(measureValue.Value, measureValue.Display),
|
|
Margin = new Thickness(5, 2.5, 5, 2.5),
|
|
VerticalAlignment = VerticalAlignment.Center,
|
|
FontWeight = FontWeights.Normal,
|
|
Style = (Style)FindResource("DetailsPage.DataHistory.TitleColumn.OverviewTitle")
|
|
};
|
|
wrapPanel.Children.Add(valueTextBlock);
|
|
|
|
TextBlock arrowTextBlock = new TextBlock()
|
|
{
|
|
Text = "➜",
|
|
VerticalAlignment = VerticalAlignment.Center,
|
|
Style = (Style)FindResource("DetailsPage.DataHistory.TitleColumn.OverviewTitle")
|
|
};
|
|
wrapPanel.Children.Add(arrowTextBlock);
|
|
|
|
TextBlock postValueTextBlock = new TextBlock()
|
|
{
|
|
Text = _rawValueFormatter.GetDisplayValue(measureValue.PostValue, measureValue.Display),
|
|
Margin = new Thickness(5, 2.5, 5, 2.5),
|
|
VerticalAlignment = VerticalAlignment.Center,
|
|
FontWeight = FontWeights.Bold,
|
|
Style = (Style)FindResource("DetailsPage.DataHistory.TitleColumn.OverviewTitle")
|
|
|
|
};
|
|
wrapPanel.Children.Add(postValueTextBlock);
|
|
|
|
if (measureValue.Difference != null)
|
|
{
|
|
TextBlock differenceTextBlock = new TextBlock()
|
|
{
|
|
Text = $"(∆ {_rawValueFormatter.GetDisplayValue(measureValue.Difference, measureValue.Display)})",
|
|
VerticalAlignment = VerticalAlignment.Center,
|
|
FontWeight = FontWeights.Normal,
|
|
Style = (Style)FindResource("DetailsPage.DataHistory.TitleColumn.OverviewTitle")
|
|
};
|
|
|
|
wrapPanel.Children.Add(differenceTextBlock);
|
|
}
|
|
|
|
Grid.SetRow(wrapPanel, i);
|
|
MeasureValueGrid.Children.Add(wrapPanel);
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
#region Events
|
|
|
|
#region CloseButton_Click
|
|
|
|
private void CloseButton_Click()
|
|
{
|
|
CloseButtonClickedAction?.Invoke();
|
|
}
|
|
|
|
private void CloseButton_MouseUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
CloseButton_Click();
|
|
}
|
|
|
|
private void CloseButton_TouchDown(object sender, TouchEventArgs e)
|
|
{
|
|
CloseButton_Click();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ExecuteButton_Click
|
|
|
|
private void ResetExecuteButton()
|
|
{
|
|
try
|
|
{
|
|
ExecuteButton.SelectedInternIcon = enumInternIcons.misc_play;
|
|
ExecuteButton.SelectedMaterialIcon = null;
|
|
ExecuteButton.BorderPadding = new Thickness(2.5);
|
|
ExecuteButton.ClearValue(AdaptableIcon.AdaptableIcon.PrimaryIconColorProperty);
|
|
ExecuteButton.ClearValue(CursorProperty);
|
|
ExecuteButton.ClearValue(IsHitTestVisibleProperty);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
public void CancelQuickAction()
|
|
{
|
|
try
|
|
{
|
|
tokenSource.Cancel(true);
|
|
quickActionIsRunning = false;
|
|
ResetExecuteButton();
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
private void VisualizeQuickActionStart()
|
|
{
|
|
try
|
|
{
|
|
ExecuteButton.ClearValue(AdaptableIcon.AdaptableIcon.PrimaryIconColorProperty);
|
|
ExecuteButton.SelectedInternIcon = null;
|
|
ExecuteButton.SelectedMaterialIcon = MaterialIcons.MaterialIconType.ic_stop;
|
|
ExecuteButton.BorderPadding = new Thickness(0);
|
|
cQuickActionStatusMonitorModel.cQuickActionStep.SetAllQuickActionStepStatuses(QuickActionData.ActionSteps, enumQuickActionRevisionStatus.inProgress);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
public void VisualizeQuickActionFinish(enumQuickActionRevisionStatus status)
|
|
{
|
|
if (HasQuickActionDataChangedSinceRun) //todo: think about better solution
|
|
return;
|
|
|
|
switch (status)
|
|
{
|
|
case enumQuickActionRevisionStatus.finishedSuccessfull:
|
|
ExecuteButton.SelectedMaterialIcon = null;
|
|
ExecuteButton.SelectedInternIcon = enumInternIcons.status_good;
|
|
ExecuteButton.PrimaryIconColor = (SolidColorBrush)FindResource("Color.Green");
|
|
ExecuteButton.IsHitTestVisible = false;
|
|
break;
|
|
case enumQuickActionRevisionStatus.finishedWithError:
|
|
ExecuteButton.SelectedMaterialIcon = null;
|
|
ExecuteButton.SelectedInternIcon = enumInternIcons.status_bad;
|
|
ExecuteButton.PrimaryIconColor = (SolidColorBrush)FindResource("Color.Red");
|
|
ExecuteButton.IsHitTestVisible = false;
|
|
break;
|
|
case enumQuickActionRevisionStatus.canceled:
|
|
default:
|
|
ResetExecuteButton();
|
|
break;
|
|
}
|
|
}
|
|
|
|
public async Task RunQuickActionAsync()
|
|
{
|
|
var status = enumQuickActionRevisionStatus.unknown;
|
|
|
|
try
|
|
{
|
|
tokenSource.Dispose();
|
|
tokenSource = new CancellationTokenSource();
|
|
|
|
quickActionIsRunning = true;
|
|
|
|
VisualizeQuickActionStart();
|
|
tempQuickActionData = QuickActionData;
|
|
|
|
Dictionary<cAdjustableParameter, object> parameterValues = null;
|
|
|
|
if (QuickActionData.QuickActionParameters != null)
|
|
{
|
|
parameterValues = AdjustableParameterSectionUc.ParameterValues;
|
|
AdjustableParameterSectionUc.ToggleIsActive(false);
|
|
}
|
|
|
|
List<object> result = await QuickActionData.RunQuickAction.Invoke(tokenSource.Token, parameterValues);
|
|
|
|
if (QuickActionData.ActionSteps.Any(step => step.Status == enumQuickActionRevisionStatus.finishedWithError))
|
|
status = enumQuickActionRevisionStatus.finishedWithError;
|
|
else if (QuickActionData.ActionSteps.Any(step => step.Status == enumQuickActionRevisionStatus.canceled))
|
|
status = enumQuickActionRevisionStatus.canceled;
|
|
else if (QuickActionData.ActionSteps.All(step => step.Status == enumQuickActionRevisionStatus.finishedSuccessfull))
|
|
status = enumQuickActionRevisionStatus.finishedSuccessfull;
|
|
|
|
RaiseEvent(new QuickActionEventArgs(QuickActionFinishedEvent, this) { QuickActionResult = result, QuickActionStatus = status, QuickAction = QuickActionData.QuickActionDefinition });
|
|
|
|
CopyButton.Visibility = Visibility.Visible;
|
|
|
|
if (QuickActionData.QuickActionDefinition.ColumnOutputFormattings?.Values.Any(formatting => formatting.IsSecret) ?? false)
|
|
SecretButton.Visibility = Visibility.Visible;
|
|
|
|
quickActionIsRunning = false;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
VisualizeQuickActionFinish(status);
|
|
GamificationService.TrackAction(CockpitAction.QuickActionExecuted);
|
|
}
|
|
}
|
|
|
|
private async void ExecuteButton_Click()
|
|
{
|
|
try
|
|
{
|
|
if (quickActionIsRunning)
|
|
{
|
|
CancelQuickAction();
|
|
}
|
|
else
|
|
{
|
|
await RunQuickActionAsync();
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
private void ExecuteButton_MouseUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
ExecuteButton_Click();
|
|
}
|
|
|
|
private void ExecuteButton_TouchDown(object sender, TouchEventArgs e)
|
|
{
|
|
ExecuteButton_Click();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CopyButton_Click
|
|
|
|
private async Task CopyButton_ClickAsync()
|
|
{
|
|
try
|
|
{
|
|
if (quickActionIsRunning || DataProvider is null)
|
|
return;
|
|
|
|
if (CopyButton.SelectedInternIcon == enumInternIcons.misc_check)
|
|
return;
|
|
|
|
DataObject copyObject = null;
|
|
|
|
if (QuickActionData.QuickActionDefinition is cF4sdQuickActionChained chainedQuickAction)
|
|
{
|
|
int protocollCount = QuickActionData.ActionSteps.Count(step => step.Status == enumQuickActionRevisionStatus.finishedSuccessfull);
|
|
if (QuickActionData.ActionSteps.Count > protocollCount)
|
|
if (QuickActionData.ActionSteps[protocollCount].Status != enumQuickActionRevisionStatus.canceled)
|
|
protocollCount++;
|
|
|
|
copyObject = F4SDProtocoll.Instance.GetOfTypeAsDataObject<QuickActionProtocollEntry>(false, protocollCount);
|
|
}
|
|
else
|
|
copyObject = F4SDProtocoll.Instance.GetLatestOfTypeAsDataObject<QuickActionProtocollEntry>(false);
|
|
|
|
System.Windows.Forms.Clipboard.SetDataObject(copyObject);
|
|
|
|
await cUtility.ChangeIconToCheckAsync(CopyButton);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
private async void CopyButton_MouseLeftButtonUp(object sender, MouseButtonEventArgs e) => await CopyButton_ClickAsync();
|
|
|
|
private async void CopyButton_TouchDown(object sender, TouchEventArgs e) => await CopyButton_ClickAsync();
|
|
|
|
#endregion
|
|
|
|
#region VisbilityButton_Click
|
|
|
|
private void SecretButton_Click(object sender)
|
|
{
|
|
secretsAreShown = !secretsAreShown;
|
|
|
|
foreach (var resultElement in QuickActionResultStack.Children.OfType<QuickActionStatusMonitorResultElement>())
|
|
{
|
|
resultElement.ToggleSecretVisibility(secretsAreShown);
|
|
}
|
|
|
|
if (sender is AdaptableIcon.AdaptableIcon icon)
|
|
icon.SelectedMaterialIcon = secretsAreShown ? MaterialIcons.MaterialIconType.ic_visibility_off : MaterialIcons.MaterialIconType.ic_visibility;
|
|
|
|
}
|
|
|
|
private void SecretButton_MouseLeftButtonUp(object sender, MouseButtonEventArgs e) => SecretButton_Click(sender);
|
|
|
|
private void SecretButton_TouchDown(object sender, TouchEventArgs e) => SecretButton_Click(sender);
|
|
|
|
#endregion
|
|
|
|
#region QuickActionFinished RoutedEvent
|
|
|
|
public delegate void UiActionEventHandlerDelegate(object sender, QuickActionEventArgs args);
|
|
|
|
public static readonly RoutedEvent QuickActionFinishedEvent = EventManager.RegisterRoutedEvent("QuickActionFinished", RoutingStrategy.Bubble, typeof(UiActionEventHandlerDelegate), typeof(QuickActionStatusMonitor));
|
|
|
|
public event RoutedEventHandler QuickActionFinished
|
|
{
|
|
add { AddHandler(QuickActionFinishedEvent, value); }
|
|
remove { RemoveHandler(QuickActionFinishedEvent, value); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
|
|
public class QuickActionEventArgs : RoutedEventArgs
|
|
{
|
|
public List<object> QuickActionResult { get; set; }
|
|
|
|
public cFasdQuickAction QuickAction { get; set; }
|
|
|
|
public enumQuickActionRevisionStatus QuickActionStatus { get; set; }
|
|
|
|
public QuickActionEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source)
|
|
{
|
|
}
|
|
}
|
|
}
|