public void InvalidateCommands_AutomaticByPropertyChange() { bool canExecuteChangedTriggered = false; var canExecuteChangedEvent = new ManualResetEvent(false); var viewModel = new TestViewModel(); viewModel.SetInvalidateCommandsOnPropertyChanged(true); ICatelCommand command = viewModel.GenerateData; command.CanExecuteChanged += delegate { canExecuteChangedTriggered = true; canExecuteChangedEvent.Set(); }; // By default, command can be executed Assert.IsTrue(viewModel.GenerateData.CanExecute(null)); viewModel.FirstName = "first name"; Assert.IsFalse(viewModel.GenerateData.CanExecute(null)); #if NET canExecuteChangedEvent.WaitOne(1000, false); #else canExecuteChangedEvent.WaitOne(1000); #endif Assert.IsTrue(canExecuteChangedTriggered); }
/// <summary> /// Unregisters a command with the specified command name. /// </summary> /// <param name="commandName">Name of the command.</param> /// <param name="command">The command.</param> /// <exception cref="ArgumentException">The <paramref name="commandName"/> is <c>null</c> or whitespace.</exception> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> /// <exception cref="InvalidOperationException">The specified command is not created using the <see cref="CreateCommand"/> method.</exception> public void UnregisterCommand(string commandName, ICatelCommand command) { Argument.IsNotNullOrWhitespace("commandName", commandName); Argument.IsNotNull("command", command); if (CatelEnvironment.IsInDesignMode) { return; } lock (_lockObject) { Log.Debug("Unregistering command from '{0}'", commandName); if (!_commands.ContainsKey(commandName)) { string error = string.Format("Command '{0}' is not yet created using the CreateCommand method", commandName); Log.Error(error); throw new InvalidOperationException(error); } _commands[commandName].UnregisterCommand(command); InvalidateCommands(); } }
/// <summary> /// Uninitializes this binding. /// </summary> protected override void Uninitialize() { if (_eventHandler != null) { _eventInfo.RemoveEventHandler(_element, _eventHandler); _eventHandler = null; } if (_canExecuteChangedHandler != null) { _command.CanExecuteChanged -= _canExecuteChangedHandler; _canExecuteChangedHandler = null; } if (_commandBindingParameterValueChangedHandler != null) { _commandParameterBinding.ValueChanged -= _commandBindingParameterValueChangedHandler; _commandBindingParameterValueChangedHandler = null; } _element = null; _eventInfo = null; _enabledPropertyInfo = null; _command = null; _commandParameterBinding = null; // TODO: call commandParameterBinding.ClearBinding();? }
protected override void OnViewModelCommandExecuted(IViewModel viewModel, ICatelCommand command, object commandParameter) { base.OnViewModelCommandExecuted(viewModel, command, commandParameter); if (viewModel != null && command.Tag != null) { switch (command.Tag.ToString()) { case "saveSettings": var settingsViewModel = viewModel as SettingsWindowViewModel; folderToWatch = settingsViewModel.FolderToWatch; folderWatcher.ChangeWatcherFolder(folderToWatch); CheckMessagesWithWaiting(); break; case "quitting": var param = commandParameter as CancelEventArgs; if (!param.Cancel) { new FinalSaveCommand().Save(Messages); } break; } } }
public override void OnCommandExecuted(IViewModel viewModel, string commandName, ICatelCommand command, object commandParameter) { base.OnCommandExecuted(viewModel, commandName, command, commandParameter); var viewModelName = viewModel != null ? viewModel.GetType().Name : string.Empty; _analyticsService.SendCommandAsync(viewModelName, commandName); }
/// <summary> /// Initializes a new instance of the <see cref="CommandExecutedEventArgs"/> class. /// </summary> /// <param name="command">The command that just has been executed.</param> /// <param name="commandParameter">The command parameter that was used for the execution.</param> /// <param name="commandPropertyName">The property name under which the command is registered.</param> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> public CommandExecutedEventArgs(ICatelCommand command, object commandParameter = null, string commandPropertyName = null) { Argument.IsNotNull("command", command); Command = command; CommandParameter = commandParameter; CommandPropertyName = commandPropertyName; }
protected override void OnViewModelCommandExecuted(IViewModel viewModel, ICatelCommand command, object commandParameter) { if (command.Tag != null && command.Tag.ToString().Equals("saveSettings")) { SelectedIndexTab = 0; } }
/// <summary> /// Registers the specified command. /// </summary> /// <param name="command">The command.</param> /// <param name="viewModel">The view model. If specified, the command will automatically be unregistered when the view model is closed.</param> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> /// <remarks> /// Note that if the view model is not specified, the command must be unregistered manually in order to prevent memory leaks. /// </remarks> public void RegisterCommand(ICatelCommand command, IViewModel viewModel = null) { Argument.IsNotNull("command", command); lock (_lock) { _commandInfo.Add(new CommandInfo(this, command, viewModel)); Log.Debug("Registered command in CompositeCommand"); } }
public CommandInfo(CompositeCommand compositeCommand, ICatelCommand command, IViewModel viewModel) { _compositeCommand = compositeCommand; Command = command; ViewModel = viewModel; if (viewModel != null) { viewModel.Closed += OnViewModelClosed; } }
public override void OnCommandExecuted(IViewModel viewModel, string commandName, ICatelCommand command, object commandParameter) { if (OnCommandExecutedCalled) { return; } OnCommandExecutedCalled = true; OnCommandExecutedViewModel = viewModel; OnCommandExecutedCommandName = commandName; OnCommandExecutedCommand = command; OnCommandExecutedCommandParameter = commandParameter; }
/// <inheritdoc /> /// <summary>Handles commands from child ViewModels (Add query, ...)</summary> protected override void OnViewModelCommandExecuted( IViewModel viewModel, ICatelCommand command, object commandParameter) { switch (command.Tag as string) { case "AddQuery": ShowQueryBuilder(); break; case "EditQuery": ShowQueryBuilder(commandParameter as FilterScheme); break; } }
/// <summary> /// Registers the specified command. /// </summary> /// <param name="command">The command.</param> /// <param name="viewModel">The view model. If specified, the command will automatically be unregistered when the view model is closed.</param> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> /// <remarks> /// Note that if the view model is not specified, the command must be unregistered manually in order to prevent memory leaks. /// </remarks> public void RegisterCommand(ICatelCommand command, IViewModel viewModel = null) { Argument.IsNotNull(() => command); lock (_lock) { var commandInfo = new CommandInfo(this, command, viewModel); _commandInfo.Add(commandInfo); command.CanExecuteChanged += OnCommandCanExecuteChanged; Log.Debug("Registered command in CompositeCommand"); } }
/// <summary> /// Unregisters the specified command. /// </summary> /// <param name="command">The command.</param> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> public void UnregisterCommand(ICatelCommand command) { Argument.IsNotNull("command", command); lock (_lock) { for (int i = _commandInfo.Count - 1; i >= 0; i--) { var commandInfo = _commandInfo[i]; if (ReferenceEquals(commandInfo.Command, command)) { _commandInfo.RemoveAt(i); Log.Debug("Unregistered command from CompositeCommand"); } } } }
/// <summary> /// Registers a command with the specified /// </summary> /// <param name="commandName">Name of the command.</param> /// <param name="command">The command.</param> /// <param name="viewModel">The view model.</param> /// <exception cref="ArgumentException">The <paramref name="commandName"/> is <c>null</c> or whitespace.</exception> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> /// <exception cref="InvalidOperationException">The specified command is not created using the <see cref="CreateCommand"/> method.</exception> public void RegisterCommand(string commandName, ICatelCommand command, IViewModel viewModel = null) { Argument.IsNotNullOrWhitespace("commandName", commandName); Argument.IsNotNull("command", command); lock (_lockObject) { Log.Debug("Registering command to '{0}'", commandName); if (!_commands.ContainsKey(commandName)) { string error = string.Format("Command '{0}' is not yet created using the CreateCommand method", commandName); Log.Error(error); throw new InvalidOperationException(error); } _commands[commandName].RegisterCommand(command, viewModel); } }
/// <summary> /// Initializes a new instance of the <see cref="CommandBinding"/> class. /// </summary> /// <param name="element">The element.</param> /// <param name="eventName">Name of the event.</param> /// <param name="command">The command.</param> /// <param name="commandParameterBinding">The command parameter binding.</param> /// <exception cref="ArgumentNullException">The <paramref name="element"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">The <paramref name="eventName"/> is <c>null</c> or whitespace.</exception> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> public CommandBinding(object element, string eventName, ICatelCommand command, Binding commandParameterBinding = null) { Argument.IsNotNull("element", element); Argument.IsNotNullOrWhitespace("eventName", eventName); Argument.IsNotNull("command", command); _element = element; _command = command; _commandParameterBinding = commandParameterBinding; var elementType = _element.GetType(); _eventInfo = elementType.GetEventEx(eventName); if (_eventInfo == null) { Log.ErrorAndThrowException <InvalidOperationException>("Event '{0}.{1}' not found, cannot create command binding", elementType.Name, eventName); } _enabledPropertyInfo = elementType.GetPropertyEx("Enabled"); _eventHandler = delegate { var commandParameter = _commandParameterBinding.GetBindingValue(); if (_command.CanExecute(commandParameter)) { _command.Execute(commandParameter); } }; _eventInfo.AddEventHandler(element, _eventHandler); _canExecuteChangedHandler = (sender, e) => UpdateEnabledState(); command.CanExecuteChanged += _canExecuteChangedHandler; if (commandParameterBinding != null) { _commandBindingParameterValueChangedHandler = (sender, e) => UpdateEnabledState(); commandParameterBinding.ValueChanged += _commandBindingParameterValueChangedHandler; } UpdateEnabledState(); }
/// <summary> /// Initializes a new instance of the <see cref="CommandBinding"/> class. /// </summary> /// <param name="element">The element.</param> /// <param name="eventName">Name of the event.</param> /// <param name="command">The command.</param> /// <param name="commandParameterBinding">The command parameter binding.</param> /// <exception cref="ArgumentNullException">The <paramref name="element"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">The <paramref name="eventName"/> is <c>null</c> or whitespace.</exception> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> public CommandBinding(object element, string eventName, ICatelCommand command, Binding commandParameterBinding = null) { Argument.IsNotNull("element", element); Argument.IsNotNullOrWhitespace("eventName", eventName); Argument.IsNotNull("command", command); _element = element; _command = command; _commandParameterBinding = commandParameterBinding; var elementType = _element.GetType(); _eventInfo = elementType.GetEventEx(eventName); if (_eventInfo == null) { throw Log.ErrorAndCreateException<InvalidOperationException>("Event '{0}.{1}' not found, cannot create command binding", elementType.Name, eventName); } _enabledPropertyInfo = elementType.GetPropertyEx("Enabled"); _eventHandler = delegate { var commandParameter = _commandParameterBinding.GetBindingValue(); if (_command.CanExecute(commandParameter)) { _command.Execute(commandParameter); } }; _eventInfo.AddEventHandler(element, _eventHandler); _canExecuteChangedHandler = (sender, e) => UpdateEnabledState(); command.CanExecuteChanged += _canExecuteChangedHandler; if (commandParameterBinding != null) { _commandBindingParameterValueChangedHandler = (sender, e) => UpdateEnabledState(); commandParameterBinding.ValueChanged += _commandBindingParameterValueChangedHandler; } UpdateEnabledState(); }
/// <summary> /// Called when a command for a view model type that the current view model is interested in has been executed. This can /// be accomplished by decorating the view model with the <see cref="InterestedInAttribute"/>. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="command">The command that has been executed.</param> /// <param name="commandParameter">The command parameter used during the execution.</param> protected override void OnViewModelCommandExecuted(IViewModel viewModel, ICatelCommand command, object commandParameter) { if (viewModel is InterestingViewModel) { string tag = (command.Tag is string) ? (string)command.Tag : string.Empty; if (tag == "test") { CommandHasBeenExecuted = true; if ((commandParameter is string) && (((string)commandParameter) == "parameter")) { CommandHasBeenExecutedWithParameter = true; } } if (tag == "unregistered") { NotRegisteredCommandHasBeenExecuted = true; if ((commandParameter is string) && (((string)commandParameter) == "parameter")) { NotRegisteredCommandHasBeenExecutedWithParameter = true; } } if (tag == "registered") { RegisteredCommandHasBeenExecuted = true; if ((commandParameter is string) && (((string)commandParameter) == "parameter")) { RegisteredCommandHasBeenExecutedWithParameter = true; } } } }
public void IncludeCommand(ICatelCommand command) { command.CanExecuteChanged += (sender, e) => { }; }
/// <summary> /// Called when a command of a view model has just been executed. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="commandName">Name of the command, which is the name of the command property.</param> /// <param name="command">The command that has been executed.</param> /// <param name="commandParameter">The command parameter.</param> public virtual void OnCommandExecuted(IViewModel viewModel, string commandName, ICatelCommand command, object commandParameter) { }
/// <summary> /// Called when a command for a view model type that the current view model is interested in has been executed. This can /// be accomplished by decorating the view model with the <see cref="InterestedInAttribute"/>. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="command">The command that has been executed.</param> /// <param name="commandParameter">The command parameter used during the execution.</param> protected virtual void OnViewModelCommandExecuted(IViewModel viewModel, ICatelCommand command, object commandParameter) { }
/// <summary> /// Registers a command with the specified /// </summary> /// <param name="commandName">Name of the command.</param> /// <param name="command">The command.</param> /// <exception cref="ArgumentException">The <paramref name="commandName"/> is <c>null</c> or whitespace.</exception> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> /// <exception cref="InvalidOperationException">The specified command is not created using the <see cref="CreateCommand"/> method.</exception> public void UnregisterCommand(string commandName, ICatelCommand command) { Argument.IsNotNullOrWhitespace("commandName", commandName); Argument.IsNotNull("command", command); lock (_lockObject) { Log.Debug("Unregistering command from '{0}'", commandName); if (!_commands.ContainsKey(commandName)) { string error = string.Format("Command '{0}' is not yet created using the CreateCommand method", commandName); Log.Error(error); throw new InvalidOperationException(error); } _commands[commandName].UnregisterCommand(command); } }
/// <summary> /// Called when a command for a view model type that the current view model is interested in has been executed. This can /// be accomplished by decorating the view model with the <see cref="InterestedInAttribute"/>. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="command">The command that has been executed.</param> /// <param name="commandParameter">The command parameter used during the execution.</param> /// <remarks> /// This method should only be called by Catel so the <see cref="ManagedViewModel"/> can invoke it. This method is only used as a pass-through /// to the actual <see cref="OnViewModelCommandExecuted"/> method. /// </remarks> void INotifyableViewModel.ViewModelCommandExecuted(IViewModel viewModel, ICatelCommand command, object commandParameter) { Log.Debug("A view model ('{0}') the current view model ('{1}') is interested in has executed a command with tag '{2}'", viewModel.GetType(), GetType(), ObjectToStringHelper.ToString(command.Tag)); OnViewModelCommandExecuted(viewModel, command, commandParameter); }
public bool CanCommandBeExecuted(ICatelCommand command, object commandParameter) { //https://catelproject.atlassian.net/wiki/display/CTL/Commands+authentication?src=search return(true); }
protected override void OnViewModelCommandExecuted(IViewModel viewModel, ICatelCommand command, object commandParameter) { AddCommand(viewModel.GetType()); }
/// <summary> /// Adds a new command binding to the element. /// </summary> /// <param name="bindingContext">The binding context.</param> /// <param name="element">The element.</param> /// <param name="eventName">Name of the event.</param> /// <param name="command">The command.</param> /// <param name="commandParameterBinding">The command parameter binding.</param> /// <returns>Catel.MVVM.CommandBinding.</returns> /// <exception cref="ArgumentNullException">The <paramref name="element"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">The <paramref name="eventName"/> is <c>null</c> or whitespace.</exception> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> public static CommandBinding AddCommandBinding(this BindingContext bindingContext, object element, string eventName, ICatelCommand command, Binding commandParameterBinding = null) { var commandBinding = new CommandBinding(element, eventName, command, commandParameterBinding); bindingContext.AddCommandBinding(commandBinding); return(commandBinding); }
/// <summary> /// Must be called when a command of a view model has just been executed. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="commandName">Name of the command, which is the name of the command property.</param> /// <param name="command">The command that has been executed.</param> /// <param name="commandParameter">The command parameter.</param> internal static void OnCommandExecuted(IViewModel viewModel, string commandName, ICatelCommand command, object commandParameter) { lock (_instance._auditors) { foreach (var auditor in _instance._auditors) { auditor.OnCommandExecuted(viewModel, commandName, command, commandParameter); } } }
/// <summary> /// Called when a command for a view model type that the current view model is interested in has been executed. This can /// be accomplished by decorating the view model with the <see cref="InterestedInAttribute"/>. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="command">The command that has been executed.</param> /// <param name="commandParameter">The command parameter used during the execution.</param> protected override void OnViewModelCommandExecuted(IViewModel viewModel, ICatelCommand command, object commandParameter) { if (viewModel is InterestingViewModel) { string tag = (command.Tag is string) ? (string) command.Tag : string.Empty; if (tag == "test") { CommandHasBeenExecuted = true; if ((commandParameter is string) && (((string) commandParameter) == "parameter")) { CommandHasBeenExecutedWithParameter = true; } } if (tag == "unregistered") { NotRegisteredCommandHasBeenExecuted = true; if ((commandParameter is string) && (((string) commandParameter) == "parameter")) { NotRegisteredCommandHasBeenExecutedWithParameter = true; } } if (tag == "registered") { RegisteredCommandHasBeenExecuted = true; if ((commandParameter is string) && (((string) commandParameter) == "parameter")) { RegisteredCommandHasBeenExecutedWithParameter = true; } } } }
/// <summary> /// Registers a command with the specified command name. /// </summary> /// <param name="commandName">Name of the command.</param> /// <param name="command">The command.</param> /// <param name="viewModel">The view model.</param> /// <exception cref="ArgumentException">The <paramref name="commandName"/> is <c>null</c> or whitespace.</exception> /// <exception cref="ArgumentNullException">The <paramref name="command"/> is <c>null</c>.</exception> /// <exception cref="InvalidOperationException">The specified command is not created using the <see cref="CreateCommand"/> method.</exception> public void RegisterCommand(string commandName, ICatelCommand command, IViewModel viewModel = null) { Argument.IsNotNullOrWhitespace("commandName", commandName); Argument.IsNotNull("command", command); if (CatelEnvironment.IsInDesignMode) { return; } lock (_lockObject) { Log.Debug("Registering command to '{0}'", commandName); if (!_commands.ContainsKey(commandName)) { string error = string.Format("Command '{0}' is not yet created using the CreateCommand method", commandName); Log.Error(error); throw new InvalidOperationException(error); } _commands[commandName].RegisterCommand(command, viewModel); InvalidateCommands(); } }
public override void OnCommandExecuted(IViewModel viewModel, string commandName, ICatelCommand command, object commandParameter) { _appTracker.TrackEvent(ApplicationTrackerCategories.Command, string.Format("{0}.{1}", viewModel.GetType().Name, commandName)); }
public bool CanCommandBeExecuted(ICatelCommand command, object commandParameter) { return true; }
public bool CanCommandBeExecuted(ICatelCommand command, object commandParameter) { //podemos identificar el comando con la propiedad tag de ICatelCommand return true; }
public override void OnCommandExecuted(IViewModel viewModel, string commandName, ICatelCommand command, object commandParameter) { base.OnCommandExecuted(viewModel, commandName, command, commandParameter); var viewModelName = viewModel != null?viewModel.GetType().Name : string.Empty; _analyticsService.SendCommandAsync(viewModelName, commandName); }
public bool CanCommandBeExecuted(ICatelCommand command, object commandParameter) { return(true); }
public bool CanCommandBeExecuted(ICatelCommand command, object commandParameter) { //podemos identificar el comando con la propiedad tag de ICatelCommand return(true); }