public IObservable <Unit> Clear()
 {
     UpdateSubjects(true);
     StackRedo.Clear();
     StackUndo.Clear();
     UpdateSubjects();
     return(Observables.Unit);
 }
Пример #2
0
 public void Redo(Action <HistoryEntry> redo)
 {
     if (StackRedo.Count > 0)
     {
         HistoryEntry last = StackRedo.Pop();
         redo.Invoke(last);
         StackUndo.Push(last);
     }
 }
        public void Dispose()
        {
            StackRedo.Clear();
            StackUndo.Clear();

            _canUndo.Dispose();
            _canRedo.Dispose();
            _canClear.Dispose();
            _canRecord.Dispose();
        }
 public IObservable <HistoryEntry> Record(HistoryEntry entry, Func <HistoryEntry, IObservable <HistoryEntry> > execute)
 {
     StackRedo.Clear();
     UpdateSubjects(true);
     return(execute(entry).Do(updatedEntry =>
     {
         StackUndo.Push(updatedEntry);
         UpdateSubjects();
     }));
 }
        public IObservable <HistoryEntry> Redo(Func <HistoryEntry, IObservable <HistoryEntry> > execute)
        {
            if (StackRedo.Count == 0)
            {
                throw new Exception();
            }

            UpdateSubjects(true);
            return(execute(StackRedo.Pop()).Do(entry =>
            {
                StackUndo.Push(entry);
                UpdateSubjects();
            }));
        }
        private void UpdateSubjects(bool disableAll = false)
        {
            if (disableAll)
            {
                _canUndo.OnNext(false);
                _canRedo.OnNext(false);
                _canClear.OnNext(false);
                _canRecord.OnNext(false);
            }
            else
            {
                var hasUndoEntries = StackUndo.Any();
                var hasRedoEntries = StackRedo.Any();

                _canUndo.OnNext(hasUndoEntries);
                _canRedo.OnNext(hasRedoEntries);
                _canClear.OnNext(hasUndoEntries || hasRedoEntries);
                _canRecord.OnNext(true);
            }
        }
        /// <summary>
        /// Выполнение команды
        /// </summary>
        /// <param name="parameter"> Параметр команды </param>
        public void Execute(object parameter)
        {
            //Запоминаем параметр ( чтобы можно было егоже передать в отмену)
            Parameters = (parameter as TParameter);

            //Выполняем команду и запоминаем результат ( чтобы можно было выполнить отмену именно для этого результата)
            Result = this._execute(Parameters, Result) as TResult;

            //Если команду можно отменить
            if (CanUnExecute)
            {
                //Добавляем копию команды в стек команд, которые можно отменить
                AddInUndo(this.Clone() as CommandUndoRedo);

                //Очищаем список отмененнных команд ( началась новая ветка изменений)
                StackRedo.Clear();
            }

            //Очищаем результат ( чтобы не передавать его при повторном выполнении)
            Result = null;

            //Очищаем параметр ( чтобы не передавать его при повторном выполнении)
            Parameters = null;
        }
 /// <summary>
 /// Добавить команду в стек команд, которые можно выполнить повторно
 /// </summary>
 public void AddInRedo(CommandUndoRedo command)
 {
     StackRedo.Push(command);
 }
Пример #9
0
 public void Dispose()
 {
     StackRedo.Clear();
     StackUndo.Clear();
 }
Пример #10
0
 public void Snapshot(HistoryEntry entry)
 {
     StackRedo.Clear();
     StackUndo.Push(entry);
 }
Пример #11
0
 public void Clear()
 {
     StackRedo.Clear();
     StackUndo.Clear();
 }