Home | History | Annotate | Download | only in undo 
      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);
     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.
     33   int get_undo_label_id() const { return undo_label_id_; }
     34   void set_undo_label_id(int label_id) { undo_label_id_ = label_id; }
     35 
     36   int get_redo_label_id() const { return redo_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 
     62   size_t undo_count() const { return undo_actions_.size(); }
     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);
     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