public object[] ParseArgs(ICommandModel command, string[] args)
{
object[] parsedArgs = new object[command.Parameters.Length];
for (int i = 0; i < command.Parameters.Length; i++)
{
if (i >= args.Length)
{
parsedArgs[i] = Type.Missing;
continue;
}
try
{
parsedArgs[i] = typeParser.Parse(args[i], command.Parameters[i].ParameterType);
}
catch (FormatException inner)
{
throw new FormatException(
$"[DeveloperConsole] Failed to parse argument {args[i]} "
+ $"of type: {args[i].GetType()}. "
+ $"Expected: {command.Parameters[i].ParameterType}",
inner
);
}
}
return(parsedArgs);
}
/// <summary>
/// Translates a CommandModel into a raw formatted string if given a correct command or returns empty string for error
/// </summary>
/// <param name="givenCommand">Command to be transformed into raw string</param>
/// <returns>Raw formatted string that can be understood by connected machine</returns>
public string FromCommand(ICommandModel givenCommand)
{
if (givenCommand is null)
{
throw new ArgumentNullException(nameof(givenCommand), "Cannot create raw command string from NULL.");
}
if (!IsKnownTypeOfCommand(givenCommand))
{
return(string.Empty);
}
var command = new StringBuilder(_settings.Separator.ToString());
command.Append(GetHostId(givenCommand)).Append(_settings.Separator);
command.Append(GetCommandType(givenCommand)).Append(_settings.Separator);
command.Append(GetID(givenCommand)).Append(_settings.Separator);
if (IsCommandADataType(givenCommand))
{
command.Append(GetDataPack(givenCommand));
}
return(command.ToString());
}
public MainViewModel(MainWindow mainWindow)
{
CurrentSerialPort = new ViewModelProperty <string>(ConnectToArduino);
CurrentProgrammerProfile = new ViewModelProperty <string>(LoadProfile);
SerialPorts = new ViewModelProperty <IEnumerable <string> >();
ProgrammerProfiles = new ViewModelProperty <IEnumerable <string> >();
SerialPortMenuItems = new ReadOnlyViewModelProperty <List <SerialPortMenuItem> >(SerialPorts, () =>
{
var items = new List <SerialPortMenuItem>();
if (SerialPorts.Value != null)
{
foreach (var item in SerialPorts.Value)
{
items.Add(new SerialPortSelectionItem(this, item));
}
}
if (items.Count == 0)
{
items.Add(NoPortsAvailable.Value);
}
return(items);
});
SerialMonitor = new SerialMonitor();
TestButtonDeckCommand = new ActionCommandModel(() => !string.IsNullOrEmpty(CurrentSerialPort.Value), OnTestButtonDeck);
LoggingCommand = new ActionCommandModel(() => true, OnOpenLogging);
OpenProgrammer = new ActionCommandModel(() => true, OnOpenProgrammer);
LogListener = new LogListener();
RootLogger = new LoggerFactory().Create(LogListener);
Communication = new ButtonDeckCommunication(RootLogger);
MainWindow = mainWindow;
}
/// <inheritdoc />
public new void BindCommand(T element, ICommandModel commandModel, ICommandProvider commandProvider)
{
if (commandModel is null)
{
throw new UIException(nameof(commandModel));
}
string eventName = commandModel.EventName;
string methodName = commandModel.Method;
IEnumerable <ICommandArgModel> methodArgs = commandModel.Args;
switch (eventName)
{
case Click:
{
if (element is ButtonBase button)
{
button.Click += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
}
break;
}
default:
{
break;
//throw new NotSupportedException($"Event {eventName} is not supported.");
}
}
}
public bool RegisterRuntimeCommand(
string commandName,
string methodName,
object context,
bool developerOnly,
bool hidden
)
{
ICommandModel command = commandFactory.Create(
commandName,
methodName,
context,
developerOnly,
hidden
);
lock (_lock)
{
if (registeredCommands.ContainsKey(commandName))
{
Debug.LogError(
"[UnityDevConsole] Failed to insert runtime command. "
+ "Reason: duplicate command name."
);
return(false);
}
registeredCommands.Add(commandName, command);
return(true);
}
}
public async Task <bool> SendAsync(ICommandModel command)
{
_isSending = true;
bool status = await _device.SendAsync(_commandTranslator.FromCommand(command)).ConfigureAwait(false);
_isSending = false;
return(status);
}
public int CompareTo(ICommandModel other)
{
if (other != null)
{
return(-this.Priority.CompareTo(other.Priority));
}
return(-1);
}
private static async Task ExecuteCommand(ICommandModel commandModel, object commandView, ConsoleRequestContext context)
{
await commandModel.Execute(context.Arguments);
if (commandView != null)
{
ExecuteView(commandView, commandModel);
}
}
public async Task SaveCommand(ICommandModel model)
{
var dbModel = new StateEventModel {
Model = model
};
await _collection.InsertOneAsync(dbModel);
_logger.LogTrace($"Command saved: {model}");
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="model"> Recieves a command model</param>
public JoystickViewModel(ICommandModel model)
{
this.model = model;
model.PropertyChanged += delegate(Object sender, PropertyChangedEventArgs e)
{
NotifyPropertyChanged("VM_" + e.PropertyName);
};
}
private void ProcessCommandsContinously()
{
while (true)
{
ICommandModel command = GetNextCommand();
Process(command);
_cancelProcessingCTS.Token.ThrowIfCancellationRequested();
}
}
private void ProcessCommandsTillSomethingInBuffer()
{
while (_awaitingQueue.Count > 0)
{
ICommandModel command = GetNextCommand();
Process(command);
_cancelProcessingCTS.Token.ThrowIfCancellationRequested();
}
}
public IMessageModel GenerateConfirmationOf(IMessageModel message)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message), "ConfirmationFactory - GenerateConfirmationOf: Cannot create confirmation of NULL");
}
IMessageModel confirmation = _messageFactory.CreateNew(Direction.Outgoing,
MessageType.Confirmation,
message.Id);
confirmation.Add(_commandFactory.Create(CommandType.HandShake));
confirmation.Add(_commandFactory.Create(CommandType.Confirmation));
foreach (var c in message)
{
ICommandModel responseCommand = _commandFactory.Create(timestampOverride: confirmation.Timestamp);
switch (c.CommandType)
{
case CommandType.Error:
responseCommand.CommandType = CommandType.ReceivedAsError;
break;
case CommandType.Unknown:
responseCommand.CommandType = CommandType.ReceivedAsUnknown;
break;
case CommandType.Partial:
responseCommand.CommandType = CommandType.ReceivedAsPartial;
break;
default:
responseCommand.CommandType = CommandType.ReceivedAsCorrect;
break;
}
confirmation.Add(responseCommand);
}
if (message.Errors.HasFlag(Errors.CompletitionTimeout))
{
confirmation.Add(_commandFactory.Create(CommandType.CompletitionTimeoutOccured));
}
if (message.Errors.HasFlag(Errors.ConfirmationTimeout))
{
confirmation.Add(_commandFactory.Create(CommandType.ConfirmationTimeoutOccurred));
}
confirmation.Add(_commandFactory.Create(CommandType.EndMessage));
// Assigns id also to all commands inside
confirmation.AssaignID(message.Id);
confirmation.AssighHostID(_hostId);
return(confirmation);
}
static DebugUtil()
{
_debugUtilIId = new Guid("71D56E14-BC19-4687-98C5-DE9EBEF5A0E0");
ICommandModel debugUtilCommand = PropertyModelInstance.ObjectFactory.TryCreateObject(
_debugUtilIId,
null) as ICommandModel;
System.Diagnostics.Debug.Assert(debugUtilCommand != null);
_debugUtilInstance = new DebugUtilInstance(debugUtilCommand);
}
public CommandViewModel(ICommandModel commandModel, IParameterDicConverter parameterDicConverter, ICommandViewModel parentCommandViewModel = null)
{
CommandModel = commandModel;
_parentCommandViewModel = parentCommandViewModel;
_parameterDicConverter = parameterDicConverter;
if (CommandModel != null)
{
if (CommandModel is IRoutedCommandModel && (CommandModel as IRoutedCommandModel).RoutedCommand != null)
{
CommandBinding = ScriptCommandBinding.ForRoutedUICommand((CommandModel as IRoutedCommandModel).RoutedCommand);
}
else
{
CommandBinding = ScriptCommandBinding.FromScriptCommand(
ApplicationCommands.NotACommand, commandModel, cm => cm.Command,
parameterDicConverter, /*ParameterDicConverters.ConvertUIParameter, */ ScriptBindingScope.Local);
}
}
CommandModel.PropertyChanged += (o, e) =>
{
switch (e.PropertyName)
{
case "IsChecked":
case "Symbol":
case "HeaderIconExtractor":
RefreshIcon();
break;
case "SubCommands":
SubCommands.LoadAsync(UpdateMode.Replace, true);
RefreshIcon();
break;
case "IsEnabled":
case "IsVisibleOnMenu":
case "IsVisibleOnToolbar":
NotifyOfPropertyChange(() => IsVisibleOnMenu);
NotifyOfPropertyChange(() => IsVisibleOnToolbar);
break;
}
};
RefreshIcon();
if (commandModel is IDirectoryCommandModel)
{
IDirectoryCommandModel directoryModel = CommandModel as IDirectoryCommandModel;
SubCommands = new EntriesHelper <ICommandViewModel>(
(cts) => Task.Run <IEnumerable <ICommandViewModel> >(
() => directoryModel.SubCommands.Select(c => (ICommandViewModel) new CommandViewModel(c, parameterDicConverter, this))));
SubCommands.LoadAsync(UpdateMode.Replace, false);
}
}
private IMessageModel CreateNewIncomingMessage(string id, ICommandModel commandToBaseOn)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentException("Id cannot be empty", nameof(id));
}
IMessageModel message = _msgFactory.CreateNew(direction: Enums.Direction.Incoming, id: id, timestampOverride: commandToBaseOn.TimeStamp, hostId: commandToBaseOn.HostId);
_idGenerator.MarkAsUsedUp(id);
return(message);
}
private string GetHostId(ICommandModel command)
{
var id = command.HostId.ToUpperInvariant();
if (id.Length > _settings.HostIdLength)
{
id = id.Substring(0, _settings.HostIdLength);
}
else if (id.Length < _settings.HostIdLength)
{
id = id.PadLeft(_settings.HostIdLength, '0');
}
return(id);
}
public async Task AddCommandAsync(ICommandModel command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
await HubContext.Clients.All.ReceiveCommand(command);
if (CommandAdded != null)
{
CommandAdded.Invoke(this, new CommandEventArgs(command));
}
}
/// <summary>
/// show uiPathCommand version information.
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public FlagManager.ProcessStatus ExecuteCommand(ICommandModel model)
{
var internalModel = model as EmptyCommandModel;
if (internalModel == null)
{
return(FlagManager.ProcessStatus.Error);
}
var version = Assembly.GetExecutingAssembly().GetName().Version;
CommandManager.ResultList.Add(nameof(VersionCommand), $"KUiPath command {version}");
return(FlagManager.ProcessStatus.Success);
}
public ICommandModel CreateModel(ICommandModelFactory commandModelFactory)
{
ICommandModel commandModel = commandModelFactory.Create(CommandType);
if (commandModel == null)
{
throw new InvalidCommandException();
}
foreach (CommandParameterSeed parameterInfo in ParametersSeeds)
{
parameterInfo.SetPropertyValueOn(commandModel);
}
return(commandModel);
}
public ICommandModel Create(CommandType type = CommandType.Empty, string idOverride = "", long timestampOverride = 0, string data = "", string hostId = "")
{
if (!Enum.IsDefined(typeof(CommandType), type))
{
return(null);
}
ICommandModel output = _commandFactory();
output.HostId = hostId;
output.CommandType = type;
output.Id = idOverride;
output.TimeStamp = timestampOverride < 0 ? Timestamp.TimestampNow : timestampOverride;
output.Data = data;
return(output);
}
private MessageType GetTypeFromCommand(ICommandModel command)
{
switch (command.CommandType)
{
case CommandType.Master:
return(MessageType.Master);
case CommandType.Slave:
return(MessageType.Slave);
case CommandType.Confirmation:
return(MessageType.Confirmation);
default:
return(MessageType.Unknown);
}
}
/// <summary>
/// Process single command by trying to inject it into existing / new message and checking this message for completition / timeout.<br/>
/// Using this method does not guarantee first priority of processing if <see cref="StartProcessingCommands"/> is running.
/// </summary>
/// <param name="command">Command to be processed</param>
public void Process(ICommandModel command)
{
if (IsMessageAlreadyComplete(command.Id))
{
HandleBadCommand(command);
}
else
{
IMessageModel message = GetMessageToWorkWithBasedOn(command);
if (!message?.Add(command) ?? true)
{
HandleBadCommand(command);
}
if (IsComplete(message))
{
PushFromIncompleteToProcessed(message);
}
}
}
public async Task StartReceiveingAsync(CancellationToken ct)
{
if (!CanStartReceiving())
{
return;
}
CancellationToken internalCT = SetupCancellationTokenReceiving(ct);
try
{
while (_device.IsOpen)
{
internalCT.ThrowIfCancellationRequested();
string rawData = await _device.ReceiveAsync(internalCT).ConfigureAwait(false);
internalCT.ThrowIfCancellationRequested();
List <string> rawCommands = _incomingDataPreparer.DataSearch(rawData);
foreach (string c in rawCommands)
{
internalCT.ThrowIfCancellationRequested();
ICommandModel receivedCommad = _commandTranslator.FromString(c);
_output.Add(receivedCommad);
OnCommandReceived(receivedCommad);
}
}
_receiverRunning = false;
}
catch (Exception e)
{
if (!WasStartReceivingCorrectlyCancelled(e))
{
throw;
}
}
}
public ButtonDeckTestViewModel()
{
Messages = new ObservableCollection <string>();
HeartbeatValue = new ViewModelProperty <int>();
LEDBrightness = new ViewModelProperty <int>
{
Value = 255
};
LEDBrightnessGet = new ViewModelProperty <bool>();
SelectedToggle = new ViewModelProperty <int>();
SelectedLED = new ViewModelProperty <int>
{
Value = 1
};
LEDColor = new ViewModelProperty <Color>
{
Value = Colors.Blue
};
ActionType = new ViewModelProperty <ActionTypes>();
AllLEDs = new ViewModelProperty <bool>();
SelectColor = new ActionCommandModel(() => true, OnSelectColor);
Send = new ActionCommandModel(() => true, OnSend);
}
public async Task InvokeAsync(ConsoleRequestContext context, RequestDelegate next)
{
CommandSeed commandSeed = commandPool.GetMatchingCommand(context.Arguments);
ICommandModel commandModel = commandSeed.CreateModel(commandModelFactory);
object commandView = commandSeed.CreateView(commandViewFactory);
bool isLongCommandView = IsLongCommandView(commandView);
if (isLongCommandView)
{
await ExecuteLongCommand(commandModel, commandView, context);
}
else
{
await ExecuteCommand(commandModel, commandView, context);
}
if (next != null)
{
await next.Invoke(context);
}
}
public FlagManager.ProcessStatus ExecuteCommand(ICommandModel model)
{
StringBuilder infoBuilder = new StringBuilder();
infoBuilder.AppendLine("usage: KUiPath [-v / --version]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-i / --info]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-? / --help]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-f fileName]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-H host name]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-U user name]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-W password]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-T tenantn ame]");
infoBuilder.AppendLine($"{new string(' ', 15)}[-C orchestrator API Name]");
infoBuilder.AppendLine("");
infoBuilder.AppendLine("Support \"Orchestrator API\" is Authenticate");
infoBuilder.AppendLine($"{new string(' ', 30)}Settings");
infoBuilder.AppendLine($"{new string(' ', 30)}Robots");
infoBuilder.AppendLine($"{new string(' ', 30)}Environments");
infoBuilder.AppendLine($"{new string(' ', 30)}Jobs");
infoBuilder.AppendLine($"{new string(' ', 30)}Release");
CommandManager.ResultList.Add(nameof(InformationCommand), infoBuilder.ToString());
return(FlagManager.ProcessStatus.Success);
}
/// <summary>
/// Executes the command against the API.
/// </summary>
/// <param name="commandModel"></param>
protected virtual void ExecuteCommand(ICommandModel commandModel)
{
SyncProxy.Instance.ExecuteCommand(commandModel);
}
/// <inheritdoc />
public virtual void BindCommand(T element, ICommandModel commandModel, ICommandProvider commandProvider)
{
if (element is null)
{
throw new UIException(nameof(element));
}
if (commandModel is null)
{
throw new UIException(nameof(commandModel));
}
string eventName = commandModel.EventName;
string methodName = commandModel.Method;
IEnumerable <ICommandArgModel> methodArgs = commandModel.Args;
switch (eventName)
{
case DragEnter:
{
element.DragEnter += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case DragLeave:
{
element.DragLeave += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case DragOver:
{
element.DragOver += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case Drop:
{
element.Drop += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case FocusableChanged:
{
element.FocusableChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case GiveFeedback:
{
element.GiveFeedback += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case GotFocus:
{
element.GotFocus += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case GotKeyboardFocus:
{
element.GotKeyboardFocus += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case GotMouseCapture:
{
element.GotMouseCapture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case GotStylusCapture:
{
element.GotStylusCapture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case GotTouchCapture:
{
element.GotTouchCapture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsEnabledChanged:
{
element.IsEnabledChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsHitTestVisibleChanged:
{
element.IsHitTestVisibleChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsKeyboardFocusedChanged:
{
element.IsKeyboardFocusedChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsKeyboardFocusWithinChanged:
{
element.IsKeyboardFocusWithinChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsMouseCapturedChanged:
{
element.IsMouseCapturedChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsMouseCaptureWithinChanged:
{
element.IsMouseCaptureWithinChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsMouseDirectlyOverChanged:
{
element.IsMouseDirectlyOverChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsStylusCapturedChanged:
{
element.IsStylusCapturedChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsStylusCaptureWithinChanged:
{
element.IsStylusCaptureWithinChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsStylusDirectlyOverChanged:
{
element.IsStylusDirectlyOverChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case IsVisibleChanged:
{
element.IsVisibleChanged += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case KeyDown:
{
element.KeyDown += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case KeyUp:
{
element.KeyUp += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case LayoutUpdated:
{
element.LayoutUpdated += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case LostFocus:
{
element.LostFocus += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case LostKeyboardFocus:
{
element.LostKeyboardFocus += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case LostMouseCapture:
{
element.LostMouseCapture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case LostStylusCapture:
{
element.LostStylusCapture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case LostTouchCapture:
{
element.LostTouchCapture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case ManipulationBoundaryFeedback:
{
element.ManipulationBoundaryFeedback += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case ManipulationCompleted:
{
element.ManipulationCompleted += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case ManipulationDelta:
{
element.ManipulationDelta += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case ManipulationInertiaStarting:
{
element.ManipulationInertiaStarting += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case ManipulationStarted:
{
element.ManipulationStarted += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case ManipulationStarting:
{
element.ManipulationStarting += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseDown:
{
element.MouseDown += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseEnter:
{
element.MouseEnter += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseLeave:
{
element.MouseLeave += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseLeftButtonDown:
{
element.MouseLeftButtonDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseLeftButtonUp:
{
element.MouseLeftButtonUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseMove:
{
element.MouseMove += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseRightButtonDown:
{
element.MouseRightButtonDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseRightButtonUp:
{
element.MouseRightButtonUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseUp:
{
element.MouseUp += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case MouseWheel:
{
element.MouseWheel += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewDragEnter:
{
element.PreviewDragEnter += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewDragLeave:
{
element.PreviewDragLeave += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewDragOver:
{
element.PreviewDragOver += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewDrop:
{
element.PreviewDrop += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewGiveFeedback:
{
element.PreviewGiveFeedback += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewGotKeyboardFocus:
{
element.PreviewGotKeyboardFocus += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewKeyDown:
{
element.PreviewKeyDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewKeyUp:
{
element.PreviewKeyUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewLostKeyboardFocus:
{
element.PreviewLostKeyboardFocus += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseDown:
{
element.PreviewMouseDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseLeftButtonDown:
{
element.PreviewMouseLeftButtonDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseLeftButtonUp:
{
element.PreviewMouseLeftButtonUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseMove:
{
element.PreviewMouseMove += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseRightButtonDown:
{
element.PreviewMouseRightButtonDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseRightButtonUp:
{
element.PreviewMouseRightButtonUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseUp:
{
element.PreviewMouseUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewMouseWheel:
{
element.PreviewMouseWheel += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewQueryContinueDrag:
{
element.PreviewQueryContinueDrag += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusButtonDown:
{
element.PreviewStylusButtonDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusButtonUp:
{
element.PreviewStylusButtonUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusDown:
{
element.PreviewStylusDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusInAirMove:
{
element.PreviewStylusInAirMove += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusInRange:
{
element.PreviewStylusInRange += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusMove:
{
element.PreviewStylusMove += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusOutOfRange:
{
element.PreviewStylusOutOfRange += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusSystemGesture:
{
element.PreviewStylusSystemGesture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewStylusUp:
{
element.PreviewStylusUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewTextInput:
{
element.PreviewTextInput += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewTouchDown:
{
element.PreviewTouchDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewTouchMove:
{
element.PreviewTouchMove += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case PreviewTouchUp:
{
element.PreviewTouchUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case QueryContinueDrag:
{
element.QueryContinueDrag += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case QueryCursor:
{
element.QueryCursor += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusButtonDown:
{
element.StylusButtonDown += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusButtonUp:
{
element.StylusButtonUp += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusDown:
{
element.StylusDown += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusEnter:
{
element.StylusEnter += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusInAirMove:
{
element.StylusInAirMove += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusInRange:
{
element.StylusInRange += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusLeave:
{
element.StylusLeave += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusMove:
{
element.StylusMove += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusOutOfRange:
{
element.StylusOutOfRange += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusSystemGesture:
{
element.StylusSystemGesture += (sender, args) =>
commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case StylusUp:
{
element.StylusUp += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case TextInput:
{
element.TextInput += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case TouchDown:
{
element.TouchDown += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case TouchEnter:
{
element.TouchEnter += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case TouchLeave:
{
element.TouchLeave += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case TouchMove:
{
element.TouchMove += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
case TouchUp:
{
element.TouchUp += (sender, args) => commandProvider.RunCommand(methodName, sender, methodArgs);
break;
}
default:
{
break;
//throw new NotSupportedException($"Event {eventName} is not supported.");
}
}
}
public void Register(ICommandModel command)
{
if (command == null)
throw new ArgumentNullException("command");
if (Commands.ContainsName(command.Name))
throw new CommandIllegalException("Command with name {0} is registed.".FormatArgs(command.Name));
Commands.Add(command);
command.Command.PreExecute += (s, e) => OnCommandPreExecute(command, e);
command.Command.Executed += (s, e) => OnCommandExecuted(command, e);
OnPropertyChanged(this, new PropertyChangedEventArgs("Commands"));
}
/// <summary>
/// Add single command to be processed / injected into corresponding / new message in internal collection.
/// Thread safe
/// </summary>
/// <param name="command">command object to be ingested</param>
/// <returns>true if success</returns>
public void AddCommandToProcess(ICommandModel command)
{
_ = command ?? throw new ArgumentNullException(nameof(command));
_awaitingQueue.Add(command);
}
