chrome/browser/undo/undo_manager.h

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