// Copyright 2013 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef COMPONENTS_UNDO_UNDO_MANAGER_H_ #define COMPONENTS_UNDO_UNDO_MANAGER_H_ #include #include #include #include #include "base/observer_list.h" class UndoManagerObserver; class UndoOperation; // UndoGroup ------------------------------------------------------------------ // UndoGroup represents a user action and stores all the operations that // make that action. Typically there is only one operation per UndoGroup. class UndoGroup { public: UndoGroup(); UndoGroup(const UndoGroup&) = delete; UndoGroup& operator=(const UndoGroup&) = delete; ~UndoGroup(); void AddOperation(std::unique_ptr operation); const std::vector>& undo_operations() { return operations_; } void Undo(); // The resource string id describing the undo and redo action. int get_undo_label_id() const { return undo_label_id_; } void set_undo_label_id(int label_id) { undo_label_id_ = label_id; } int get_redo_label_id() const { return redo_label_id_; } void set_redo_label_id(int label_id) { redo_label_id_ = label_id; } private: std::vector> operations_; // The resource string id describing the undo and redo action. int undo_label_id_; int redo_label_id_; }; // UndoManager ---------------------------------------------------------------- // Maintains user actions as a group of operations that store enough info to // undo and redo those operations. class UndoManager { public: UndoManager(); UndoManager(const UndoManager&) = delete; UndoManager& operator=(const UndoManager&) = delete; ~UndoManager(); // Perform an undo or redo operation. void Undo(); void Redo(); size_t undo_count() const { return undo_actions_.size(); } size_t redo_count() const { return redo_actions_.size(); } std::u16string GetUndoLabel() const; std::u16string GetRedoLabel() const; void AddUndoOperation(std::unique_ptr operation); // Group multiple operations into one undoable action. void StartGroupingActions(); void EndGroupingActions(); // Suspend undo tracking while processing non-user initiated changes such as // profile synchonization. void SuspendUndoTracking(); void ResumeUndoTracking(); bool IsUndoTrakingSuspended() const; // Remove all undo and redo operations. Note that grouping of actions and // suspension of undo tracking states are left unchanged. void RemoveAllOperations(); // Observers are notified when the internal state of this class changes. void AddObserver(UndoManagerObserver* observer); void RemoveObserver(UndoManagerObserver* observer); private: friend class UndoManagerTestApi; void Undo(bool* performing_indicator, std::vector>* active_undo_group); bool is_user_action() const { return !performing_undo_ && !performing_redo_; } // Notifies the observers that the undo manager's state has changed. void NotifyOnUndoManagerStateChange(); // Handle the addition of |new_undo_group| to the active undo group container. void AddUndoGroup(std::unique_ptr new_undo_group); // Returns the undo or redo UndoGroup container that should store the next // change taking into account if an undo or redo is being executed. std::vector>* GetActiveUndoGroup(); // Containers of user actions ready for an undo or redo treated as a stack. std::vector> undo_actions_; std::vector> redo_actions_; // The observers to notify when internal state changes. base::ObserverList::Unchecked observers_; // Supports grouping operations into a single undo action. int group_actions_count_; // The container that is used when actions are grouped. std::unique_ptr pending_grouped_action_; // The action that is in the process of being undone. UndoGroup* undo_in_progress_action_; // Supports the suspension of undo tracking. int undo_suspended_count_; // Set when executing Undo or Redo so that incoming changes are correctly // processed. bool performing_undo_; bool performing_redo_; }; #endif // COMPONENTS_UNDO_UNDO_MANAGER_H_