editor/libeditor/PlaceholderTransaction.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef PlaceholderTransaction_h
   7 #define PlaceholderTransaction_h
   8
   9 #include "EditAggregateTransaction.h"
  10 #include "mozilla/Maybe.h"
  11 #include "mozilla/SelectionState.h"
  12 #include "mozilla/WeakPtr.h"
  13
  14 namespace mozilla {
  15
  16 class EditorBase;
  17
  18 /**
  19  * An aggregate transaction that knows how to absorb all subsequent
  20  * transactions with the same name.  This transaction does not "Do" anything.
  21  * But it absorbs other transactions via merge, and can undo/redo the
  22  * transactions it has absorbed.
  23  */
  24
  25 class PlaceholderTransaction final : public EditAggregateTransaction,
  26                                      public SupportsWeakPtr {
  27  protected:
  28   PlaceholderTransaction(EditorBase& aEditorBase, nsStaticAtom& aName,
  29                          Maybe<SelectionState>&& aSelState);
  30
  31  public:
  32   /**
  33    * Creates a placeholder transaction.  This never returns nullptr.
  34    *
  35    * @param aEditorBase     The editor.
  36    * @param aName           The name of creating transaction.
  37    * @param aSelState       The selection state of aEditorBase.
  38    */
  39   static already_AddRefed<PlaceholderTransaction> Create(
  40       EditorBase& aEditorBase, nsStaticAtom& aName,
  41       Maybe<SelectionState>&& aSelState) {
  42     // Make sure to move aSelState into a local variable to null out the
  43     // original Maybe<SelectionState> variable.
  44     Maybe<SelectionState> selState(std::move(aSelState));
  45     RefPtr<PlaceholderTransaction> transaction =
  46         new PlaceholderTransaction(aEditorBase, aName, std::move(selState));
  47     return transaction.forget();
  48   }
  49
  50   NS_DECL_ISUPPORTS_INHERITED
  51
  52   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PlaceholderTransaction,
  53                                            EditAggregateTransaction)
  54   // ------------ EditAggregateTransaction -----------------------
  55
  56   NS_DECL_EDITTRANSACTIONBASE
  57   NS_DECL_EDITTRANSACTIONBASE_GETASMETHODS_OVERRIDE(PlaceholderTransaction)
  58
  59   MOZ_CAN_RUN_SCRIPT NS_IMETHOD RedoTransaction() override;
  60   NS_IMETHOD Merge(nsITransaction* aTransaction, bool* aDidMerge) override;
  61
  62   bool StartSelectionEquals(SelectionState& aSelectionState);
  63
  64   nsresult EndPlaceHolderBatch();
  65
  66   void ForwardEndBatchTo(PlaceholderTransaction& aForwardingTransaction) {
  67     mForwardingTransaction = &aForwardingTransaction;
  68   }
  69
  70   void Commit() { mCommitted = true; }
  71
  72   nsresult RememberEndingSelection();
  73
  74  protected:
  75   virtual ~PlaceholderTransaction() = default;
  76
  77   // The editor for this transaction.
  78   RefPtr<EditorBase> mEditorBase;
  79
  80   WeakPtr<PlaceholderTransaction> mForwardingTransaction;
  81
  82   // First IME txn in this placeholder - used for IME merging.
  83   WeakPtr<CompositionTransaction> mCompositionTransaction;
  84
  85   // These next two members store the state of the selection in a safe way.
  86   // Selection at the start of the transaction is stored, as is the selection
  87   // at the end.  This is so that UndoTransaction() and RedoTransaction() can
  88   // restore the selection properly.
  89
  90   SelectionState mStartSel;
  91   SelectionState mEndSel;
  92
  93   // Do we auto absorb any and all transaction?
  94   bool mAbsorb;
  95   // Do we stop auto absorbing any matching placeholder transactions?
  96   bool mCommitted;
  97 };
  98
  99 }  // namespace mozilla
 100
 101 #endif  // #ifndef PlaceholderTransaction_h