private void DeleteModelImpl(DeleteModelCommand command) { List <ModelBase> modelsToDelete = new List <ModelBase>(); if (command.ModelGuid != Guid.Empty) { modelsToDelete.Add(CurrentSpace.GetModelInternal(command.ModelGuid)); } else { // When nothing is specified then it means all selected models. foreach (ISelectable selectable in DynamoSelection.Instance.Selection) { if (selectable is ModelBase) { modelsToDelete.Add(selectable as ModelBase); } } } model.DeleteModelInternal(modelsToDelete); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void Undo() { _textEditor.Undo(); RedoCommand.RaiseCanExecuteChanged(); UndoCommand.RaiseCanExecuteChanged(); }
private void LeaseBook() { Action redo = () => { SelectedBook.LeasedTo = Session.Current.LoggedInUser; LeaseCommand.RaiseCanExecuteChanged(); OnPropertyChanged("SelectedBook"); BookList.Refresh(); }; Action undo = () => { SelectedBook.LeasedTo = string.Empty; LeaseCommand.RaiseCanExecuteChanged(); OnPropertyChanged("SelectedBook"); BookList.Refresh(); }; history.AddAndExecute(new RevertableCommand(redo, undo)); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); ClientLogger.Log($"{Session.Current.LoggedInUser} leased book {selectedBook.BookName}", Common.LogLevel.Info); }
private void OnLoadText(TabInfo tabInfo) { if (tabInfo.Guid != _fileGuid || _textEditor == null) { return; } Reset(() => { IsReadOnly = tabInfo.IsReadOnly; IsShowEditor = tabInfo.IsShowEditor; _fileGuid = tabInfo.Guid; _textEditor.Text = tabInfo.FileContent; }); if (IsSelected) { CompileCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); UndoCommand.RaiseCanExecuteChanged(); _textEditor.Focus(); CaretPosChanged(); if (AutoCompile || IsReadOnly) { Compile(tabInfo.FileContent); } } }
private void SendModelEventImpl(ModelEventCommand command) { CurrentSpace.SendModelEvent(command.ModelGuid, command.EventName); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
/// <summary> /// Updates UI bound to the view model properties. /// </summary> private void UpdateView() { SyncModelProperties(); UpdateBoard(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); MoveCommand.RaiseCanExecuteChanged(); }
private void ExecuteClearFormatCommand(object parameter) { txt.Text = Strings.RadialMenuClear; _canExecuteUndo = true; _canExecuteRedo = false; UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void ExecuteUndoCommand(object parameter) { txt.Text = "Undo Command executed"; _canExecuteUndo = false; _canExecuteRedo = true; UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void UpdateModelValueImpl(UpdateModelValueCommand command) { CurrentSpace.UpdateModelValue(command.ModelGuid, command.Name, command.Value); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void ConvertNodesToCodeImpl(ConvertNodesToCodeCommand command) { CurrentSpace.ConvertNodesToCodeInternal(command.NodeId); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); CurrentSpace.HasUnsavedChanges = true; }
private void CreateNoteImpl(CreateNoteCommand command) { NoteModel noteModel = Model.AddNoteInternal(command, null); CurrentSpace.RecordCreatedModel(noteModel); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
public void SetComposition(Composition composition) { var lilypondText = LilypondFactory.GetLilypond(composition); LilypondTextLoaded(lilypondText); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void UpdateCommands() { RemoveImageCommand.RaiseCanExecuteChanged(); SaveCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); UndoCommand.RaiseCanExecuteChanged(); RemoveBackgroundCommand.RaiseCanExecuteChanged(); RemoveOverlayCommand.RaiseCanExecuteChanged(); }
public void LilypondTextLoaded(string text) { _textChangedByLoad = true; _caretaker.reset(); LilypondText = text; _caretaker.change(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); _textChangedByLoad = false; }
private void OnLevelPropertyChanged(Object sender, PropertyChangedEventArgs e) { if ("CanUndo".Equals(e.PropertyName)) { UndoCommand.RaiseCanExecuteChanged(); } else if ("CanRedo".Equals(e.PropertyName)) { RedoCommand.RaiseCanExecuteChanged(); } }
private void UndoRedoManagerOnPropertyChanged(object sender, PropertyChangedEventArgs args) { if (args.IsProperty<UndoRedoManager>(i => i.CanUndo)) { UndoCommand.RaiseCanExecuteChanged(); SaveDocumentCommand.RaiseCanExecuteChanged(); SaveDocumentAsCommand.RaiseCanExecuteChanged(); } if (args.IsProperty<UndoRedoManager>(i => i.CanRedo)) RedoCommand.RaiseCanExecuteChanged(); }
private void UndoRedoImpl(UndoRedoCommand command) { if (command.CmdOperation == UndoRedoCommand.Operation.Undo) { CurrentSpace.Undo(); } else if (command.CmdOperation == UndoRedoCommand.Operation.Redo) { CurrentSpace.Redo(); } UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void CreateNoteImpl(CreateNoteCommand command) { NoteModel noteModel = Model.CurrentWorkspace.AddNote( command.DefaultPosition, command.X, command.Y, command.NoteText, command.NodeId); CurrentSpace.RecordCreatedModel(noteModel); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
//Summary // Commit changes to data source, after commit, clear undo/redo list public void Commit() { _selectedVertices.Clear(); _operations.Clear(); _operationsRedo.Clear(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); HasChange = false; IsInEditing = false; PostStatusMessage("Ready"); }
private void CreateNodeImpl(CreateNodeCommand command) { NodeModel nodeModel = CurrentSpace.AddNode( command.NodeId, command.NodeName, command.X, command.Y, command.DefaultPosition, command.TransformCoordinates); CurrentSpace.RecordCreatedModel(nodeModel); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void OnIsActiveChanged() { SaveCommand.RaiseCanExecuteChanged(); CompileCommand.IsActive = IsActive; CompileCommand.RaiseCanExecuteChanged(); RedoCommand.IsActive = IsActive; RedoCommand.RaiseCanExecuteChanged(); UndoCommand.IsActive = IsActive; UndoCommand.RaiseCanExecuteChanged(); IsActiveChanged?.Invoke(this, new EventArgs()); }
private void RedoUndoModel_PropertyChanged(object sender, PropertyChangedEventArgs e) { switch (e.PropertyName) { case "CanRedoOneStep": RedoCommand.RaiseCanExecuteChanged(); break; case "CanUndoOneStep": UndoCommand.RaiseCanExecuteChanged(); break; default: break; } }
public LilypondViewModel(MainViewModel mainViewModel, MusicLoader musicLoader) { // TODO: Can we use some sort of eventing system so the managers layer doesn't have to know the viewmodel layer and viewmodels don't know each other? // And viewmodels don't _mainViewModel = mainViewModel; _musicLoader = musicLoader; _musicLoader.LilypondViewModel = this; _text = new LilypondText(); _caretaker = new LilypondTextCaretaker(_text); _movedInHistory = false; LilypondText = "Your lilypond text will appear here."; _caretaker.change(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
//Summary // Execute new operaton and put the operation in to undoable list public void Do(IOperation operation) { operation.Do(); HasChange = true; _operations.Insert(0, operation); foreach (var v in _operationsRedo) { v.Dispose(); } _operationsRedo.Clear(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); if (!string.IsNullOrEmpty(operation.Sammary)) { PostStatusMessage(operation.Sammary); } }
void ExecuteUndo() { var op = Operations.FirstOrDefault(); if (op == null || !op.IsUnDoable) { return; } op.UnDo(); Operations.Remove(op); OperationsRedo.Insert(0, op); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); if (!string.IsNullOrEmpty(op.Sammary)) { PostStatusMessage("Undo " + op.Sammary); } }
private void TextChanged() { UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void Current_PropertyChanged(object sender, PropertyChangedEventArgs e) { UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
private void UpdateCommandStatus() { UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }
void OnModelCommandCompleted(DynamoModel.RecordableCommand command) { var name = command.GetType().Name; switch (name) { case "OpenFileCommand": this.AddToRecentFiles((command as DynamoModel.OpenFileCommand).XmlFilePath); this.VisualizationManager.UnPause(); break; case "MutateTestCommand": var mutatorDriver = new Dynamo.TestInfrastructure.MutatorDriver(this); mutatorDriver.RunMutationTests(); break; case "SelectInRegionCommand": var selectC = command as DynamoModel.SelectInRegionCommand; CurrentSpaceViewModel.SelectInRegion(selectC.Region, selectC.IsCrossSelection); break; case "DragSelectionCommand": var dragC = command as DynamoModel.DragSelectionCommand; if (DynamoModel.DragSelectionCommand.Operation.BeginDrag == dragC.DragOperation) { CurrentSpaceViewModel.BeginDragSelection(dragC.MouseCursor); } else { CurrentSpaceViewModel.EndDragSelection(dragC.MouseCursor); } break; case "DeleteModelCommand": case "CreateNodeCommand": case "CreateNoteCommand": case "UndoRedoCommand": case "ModelEventCommand": case "UpdateModelValueCommand": case "ConvertNodesToCodeCommand": UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); break; case "SwitchTabCommand": if (command.IsInPlaybackMode) { RaisePropertyChanged("CurrentWorkspaceIndex"); } break; case "RunCancelCommand": case "ForceRunCancelCommand": case "SelectModelCommand": case "MakeConnectionCommand": case "CreateCustomNodeCommand": // for this commands there is no need // to do anything after execution break; default: throw new InvalidOperationException("Unhandled command name"); } }
public MainViewModel(IDialogCoordinator _dialogCoordinator) { DialogCoordinator = _dialogCoordinator; MenuBar = new MenuBarViewModel(this); ToolBar = new ToolBarViewModel(this); try { NativeMethods.EnablePrivilege("SeBackupPrivilege"); NativeMethods.EnablePrivilege("SeRestorePrivilege"); IsAdmin = true; } catch { } ActiveView = this; var computer = new RegistryKeyItemSpecial(null) { Text = "Computer", Icon = "/images/workstation2.png", IsExpanded = true }; computer.SubItems.Add(new RegistryKeyItem(computer, Registry.ClassesRoot)); computer.SubItems.Add(new RegistryKeyItem(computer, Registry.CurrentUser)); computer.SubItems.Add(new RegistryKeyItem(computer, Registry.LocalMachine)); computer.SubItems.Add(new RegistryKeyItem(computer, Registry.CurrentConfig)); computer.SubItems.Add(new RegistryKeyItem(computer, Registry.Users)); _roots = new List <RegistryKeyItemBase> { computer, //new RegistryKeyItemSpecial(null) { // Text = "Files", // Icon = "/images/folder_blue.png" //}, new RegistryKeyItemSpecial(null) { Text = "Favorites", Icon = "/images/favorites.png", IsExpanded = true } }; LoadFavorites(); ExitCommand = new DelegateCommand(() => Application.Current.Shutdown()); LaunchWithAdminRightsCommand = new DelegateCommand(() => { var pi = new ProcessStartInfo(Process.GetCurrentProcess().MainModule.FileName) { Verb = "RunAs" }; try { if (Process.Start(pi) != null) { Environment.Exit(0); } } catch (Exception ex) { MessageBox.Show(ex.Message, App.Name); } }, () => !IsAdmin); EditNewKeyCommand = new DelegateCommand <RegistryKeyItem>(item => { var name = item.GenerateUniqueSubKeyName(); CommandManager.AddCommand(Commands.CreateKey(new CreateKeyCommandContext { Key = item, Name = name })); item.IsExpanded = true; var newItem = item.GetSubItem <RegistryKeyItem>(name); newItem.IsSelected = true; Dispatcher.CurrentDispatcher.InvokeAsync(() => IsEditMode = true, DispatcherPriority.Background); }, item => !IsReadOnlyMode && item is RegistryKeyItem) .ObservesProperty(() => IsReadOnlyMode); EditPermissionsCommand = new DelegateCommand(() => { // TODO }, () => SelectedItem is RegistryKeyItem) .ObservesProperty(() => SelectedItem); CopyKeyNameCommand = new DelegateCommand <RegistryKeyItemBase>(_ => Clipboard.SetText(SelectedItem.Text), _ => SelectedItem != null).ObservesProperty(() => SelectedItem); CopyKeyPathCommand = new DelegateCommand(() => Clipboard.SetText(((RegistryKeyItem)SelectedItem).Path ?? SelectedItem.Text), () => SelectedItem is RegistryKeyItem) .ObservesProperty(() => SelectedItem); RefreshCommand = new DelegateCommand(() => SelectedItem.Refresh(), () => SelectedItem != null) .ObservesProperty(() => SelectedItem); EndEditingCommand = new DelegateCommand <string>(async name => { try { var item = SelectedItem as RegistryKeyItem; Debug.Assert(item != null); if (name == null || name.Equals(item.Text, StringComparison.InvariantCultureIgnoreCase)) { return; } if (item.Parent.SubItems.Any(i => name.Equals(i.Text, StringComparison.InvariantCultureIgnoreCase))) { await DialogCoordinator.ShowMessageAsync(this, App.Name, string.Format("Key name '{0}' already exists", name)); return; } CommandManager.AddCommand(Commands.RenameKey(new RenameKeyCommandContext { Key = item, OldName = item.Text, NewName = name })); } catch (Exception ex) { MessageBox.Show(ex.Message, App.Name); } finally { IsEditMode = false; CommandManager.UpdateChanges(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); } }, _ => IsEditMode).ObservesCanExecute(() => IsEditMode); BeginRenameCommand = new DelegateCommand(() => IsEditMode = true, () => !IsReadOnlyMode && SelectedItem is RegistryKeyItem && !string.IsNullOrEmpty(((RegistryKeyItem)SelectedItem).Path)) .ObservesProperty(() => SelectedItem).ObservesProperty(() => IsReadOnlyMode); UndoCommand = new DelegateCommand(() => { CommandManager.Undo(); RedoCommand.RaiseCanExecuteChanged(); UndoCommand.RaiseCanExecuteChanged(); }, () => !IsReadOnlyMode && CommandManager.CanUndo).ObservesProperty(() => IsReadOnlyMode); RedoCommand = new DelegateCommand(() => { CommandManager.Redo(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }, () => !IsReadOnlyMode && CommandManager.CanRedo).ObservesProperty(() => IsReadOnlyMode); LoadHiveCommand = new DelegateCommand(async() => { var vm = DialogHelper.ShowDialog <LoadHiveViewModel, LoadHiveView>(); if (vm.ShowDialog() == true) { int error = NativeMethods.RegLoadKey(vm.Hive == "HKLM" ? Registry.LocalMachine.Handle : Registry.Users.Handle, vm.Name, vm.FileName); if (error != 0) { await DialogCoordinator.ShowMessageAsync(this, App.Name, string.Format("Error opening file: {0}", error.ToString())); return; } var item = _roots[0].SubItems[vm.Hive == "HKLM" ? 2 : 4]; item.Refresh(); ((RegistryKeyItem)item.SubItems.First(i => i.Text == vm.Name)).HiveKey = true; } }, () => IsAdmin && !IsReadOnlyMode) .ObservesProperty(() => IsReadOnlyMode); DeleteCommand = new DelegateCommand(() => { var item = SelectedItem as RegistryKeyItem; Debug.Assert(item != null); if (!IsAdmin) { if (MessageBox.Show("Running with standard user rights prevents undo for deletion. Delete anyway?", App.Name, MessageBoxButton.OKCancel, MessageBoxImage.Exclamation) == MessageBoxResult.Cancel) { return; } CommandManager.Clear(); } var tempFile = Path.GetTempFileName(); CommandManager.AddCommand(Commands.DeleteKey(new DeleteKeyCommandContext { Key = item, TempFile = tempFile })); CommandManager.UpdateChanges(); UndoCommand.RaiseCanExecuteChanged(); RedoCommand.RaiseCanExecuteChanged(); }, () => !IsReadOnlyMode && SelectedItem is RegistryKeyItem && SelectedItem.Path != null).ObservesProperty(() => IsReadOnlyMode); ExportCommand = new DelegateCommand(() => { var dlg = new SaveFileDialog { Title = "Select output file", Filter = "Registry data files|*.dat", OverwritePrompt = true }; if (dlg.ShowDialog() == true) { var item = SelectedItem as RegistryKeyItem; Debug.Assert(item != null); using (var key = item.Root.OpenSubKey(item.Path)) { File.Delete(dlg.FileName); int error = NativeMethods.RegSaveKeyEx(key.Handle, dlg.FileName, IntPtr.Zero, 2); Debug.Assert(error == 0); } } }, () => IsAdmin && SelectedItem is RegistryKeyItem) .ObservesProperty(() => SelectedItem); CreateNewValueCommand = new DelegateCommand <ValueViewModel>(vm => { }, vm => !IsReadOnlyMode) .ObservesProperty(() => IsReadOnlyMode); AddToFavoritesCommand = new DelegateCommand(() => { var item = SelectedItem as RegistryKeyItem; Debug.Assert(item != null); _roots[1].SubItems.Add(new RegistryKeyItem(item.Parent as RegistryKeyItem, item.Text)); SaveFavorites(); }, () => SelectedItem is RegistryKeyItem && !string.IsNullOrEmpty(SelectedItem.Path)) .ObservesProperty(() => SelectedItem); RemoveFromFavoritesCommand = new DelegateCommand(() => { _roots[1].SubItems.Remove(SelectedItem); SaveFavorites(); }, () => SelectedItem != null && SelectedItem.Flags.HasFlag(RegistryKeyFlags.Favorite)) .ObservesProperty(() => SelectedItem); }