1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_UNDO_UNDO_MANAGER_H_ 6 #define CHROME_BROWSER_UNDO_UNDO_MANAGER_H_ 7 8 #include "base/basictypes.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/memory/scoped_vector.h" 11 #include "base/observer_list.h" 12 #include "base/strings/string16.h" 13 14 class UndoManagerObserver; 15 class UndoOperation; 16 17 // UndoGroup ------------------------------------------------------------------ 18 19 // UndoGroup represents a user action and stores all the operations that 20 // make that action. Typically there is only one operation per UndoGroup. 21 class UndoGroup { 22 public: 23 UndoGroup(); 24 ~UndoGroup(); 25 26 void AddOperation(scoped_ptr<UndoOperation> operation); undo_operations()27 const std::vector<UndoOperation*>& undo_operations() { 28 return operations_.get(); 29 } 30 void Undo(); 31 32 // The resource string id describing the undo and redo action. get_undo_label_id()33 int get_undo_label_id() const { return undo_label_id_; } set_undo_label_id(int label_id)34 void set_undo_label_id(int label_id) { undo_label_id_ = label_id; } 35 get_redo_label_id()36 int get_redo_label_id() const { return redo_label_id_; } set_redo_label_id(int label_id)37 void set_redo_label_id(int label_id) { redo_label_id_ = label_id; } 38 39 private: 40 ScopedVector<UndoOperation> operations_; 41 42 // The resource string id describing the undo and redo action. 43 int undo_label_id_; 44 int redo_label_id_; 45 46 DISALLOW_COPY_AND_ASSIGN(UndoGroup); 47 }; 48 49 // UndoManager ---------------------------------------------------------------- 50 51 // Maintains user actions as a group of operations that store enough info to 52 // undo and redo those operations. 53 class UndoManager { 54 public: 55 UndoManager(); 56 ~UndoManager(); 57 58 // Perform an undo or redo operation. 59 void Undo(); 60 void Redo(); 61 undo_count()62 size_t undo_count() const { return undo_actions_.size(); } redo_count()63 size_t redo_count() const { return redo_actions_.size(); } 64 65 base::string16 GetUndoLabel() const; 66 base::string16 GetRedoLabel() const; 67 68 void AddUndoOperation(scoped_ptr<UndoOperation> operation); 69 70 // Group multiple operations into one undoable action. 71 void StartGroupingActions(); 72 void EndGroupingActions(); 73 74 // Suspend undo tracking while processing non-user initiated changes such as 75 // profile synchonization. 76 void SuspendUndoTracking(); 77 void ResumeUndoTracking(); 78 bool IsUndoTrakingSuspended() const; 79 80 // Returns all UndoOperations that are awaiting Undo or Redo. Note that 81 // ownership of the UndoOperations is retained by UndoManager. 82 std::vector<UndoOperation*> GetAllUndoOperations() const; 83 84 // Remove all undo and redo operations. Note that grouping of actions and 85 // suspension of undo tracking states are left unchanged. 86 void RemoveAllOperations(); 87 88 // Observers are notified when the internal state of this class changes. 89 void AddObserver(UndoManagerObserver* observer); 90 void RemoveObserver(UndoManagerObserver* observer); 91 92 private: 93 void Undo(bool* performing_indicator, 94 ScopedVector<UndoGroup>* active_undo_group); is_user_action()95 bool is_user_action() const { return !performing_undo_ && !performing_redo_; } 96 97 // Notifies the observers that the undo manager's state has changed. 98 void NotifyOnUndoManagerStateChange(); 99 100 // Handle the addition of |new_undo_group| to the active undo group container. 101 void AddUndoGroup(UndoGroup* new_undo_group); 102 103 // Returns the undo or redo UndoGroup container that should store the next 104 // change taking into account if an undo or redo is being executed. 105 ScopedVector<UndoGroup>* GetActiveUndoGroup(); 106 107 // Containers of user actions ready for an undo or redo treated as a stack. 108 ScopedVector<UndoGroup> undo_actions_; 109 ScopedVector<UndoGroup> redo_actions_; 110 111 // The observers to notify when internal state changes. 112 ObserverList<UndoManagerObserver> observers_; 113 114 // Supports grouping operations into a single undo action. 115 int group_actions_count_; 116 117 // The container that is used when actions are grouped. 118 scoped_ptr<UndoGroup> pending_grouped_action_; 119 120 // The action that is in the process of being undone. 121 UndoGroup* undo_in_progress_action_; 122 123 // Supports the suspension of undo tracking. 124 int undo_suspended_count_; 125 126 // Set when executing Undo or Redo so that incoming changes are correctly 127 // processed. 128 bool performing_undo_; 129 bool performing_redo_; 130 131 DISALLOW_COPY_AND_ASSIGN(UndoManager); 132 }; 133 134 #endif // CHROME_BROWSER_UNDO_UNDO_MANAGER_H_ 135