Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 148 insertions, 0 deletions

diff --git a/editor/txmgr/nsITransactionManager.idl b/editor/txmgr/nsITransactionManager.idl
new file mode 100644
index 0000000000..612071380b
--- /dev/null
+++ b/editor/txmgr/nsITransactionManager.idl
@@ -0,0 +1,148 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsITransaction.idl"
+
+%{C++
+namespace mozilla {
+class TransactionManager;
+} // namespace mozilla
+%}
+
+/**
+ * The nsITransactionManager interface.
+ * <P>
+ * This interface is implemented by an object that wants to
+ * manage/track transactions.
+ */
+[scriptable, builtinclass, uuid(c77763df-0fb9-41a8-8074-8e882f605755)]
+interface nsITransactionManager : nsISupports
+{
+  /**
+   * Calls a transaction's doTransaction() method, then pushes it on the
+   * undo stack.
+   * <P>
+   * This method calls the transaction's AddRef() method.
+   * The transaction's Release() method will be called when the undo or redo
+   * stack is pruned or when the transaction manager is destroyed.
+   * @param aTransaction the transaction to do.
+   */
+  [can_run_script]
+  void doTransaction(in nsITransaction aTransaction);
+
+  /**
+   * Pops the topmost transaction on the undo stack, calls its
+   * undoTransaction() method, then pushes it on the redo stack.
+   */
+  [can_run_script]
+  void undoTransaction();
+
+  /**
+   * Pops the topmost transaction on the redo stack, calls its
+   * redoTransaction() method, then pushes it on the undo stack.
+   */
+  [can_run_script]
+  void redoTransaction();
+
+  /**
+   * Clears the undo and redo stacks.
+   */
+  void clear();
+
+  /**
+   * Clears the undo stack only.
+   */
+  void clearUndoStack();
+
+  /**
+   * Clears the redo stack only.
+   */
+  void clearRedoStack();
+
+  /**
+   * Turns on the transaction manager's batch mode, forcing all transactions
+   * executed by the transaction manager's doTransaction() method to be
+   * aggregated together until EndBatch() is called.  This mode allows an
+   * application to execute and group together several independent transactions
+   * so they can be undone with a single call to undoTransaction().
+   * @param aData An arbitrary nsISupports object that is associated with the
+   * batch. Can be retrieved from the undo or redo stacks.
+   */
+  [can_run_script]
+  void beginBatch(in nsISupports aData);
+
+  /**
+   * Turns off the transaction manager's batch mode.
+   * @param aAllowEmpty If true, a batch containing no children will be
+   * pushed onto the undo stack. Otherwise, ending a batch with no
+   * children will result in no transactions being pushed on the undo stack.
+   */
+  void endBatch(in boolean aAllowEmpty);
+
+  /**
+   * The number of items on the undo stack.
+   */
+  readonly attribute long numberOfUndoItems;
+
+  /**
+   * The number of items on the redo stack.
+   */
+  readonly attribute long numberOfRedoItems;
+
+  /**
+   * Sets the maximum number of transaction items the transaction manager will
+   * maintain at any time. This is commonly referred to as the number of levels
+   * of undo.
+   * @param aMaxCount A value of -1 means no limit. A value of zero means the
+   * transaction manager will execute each transaction, then immediately release
+   * all references it has to the transaction without pushing it on the undo
+   * stack. A value greater than zero indicates the max number of transactions
+   * that can exist at any time on both the undo and redo stacks. This method
+   * will prune the necessary number of transactions on the undo and redo
+   * stacks if the value specified is less than the number of items that exist
+   * on both the undo and redo stacks.
+   */
+  attribute long maxTransactionCount;
+
+  /**
+   * Combines the transaction at the top of the undo stack (if any) with the
+   * preceding undo transaction (if any) into a batch transaction. Thus,
+   * a call to undoTransaction() will undo both transactions.
+   */
+  void batchTopUndo();
+
+  /**
+   * Removes the transaction at the top of the undo stack (if any) without
+   * transacting.
+   */
+  void removeTopUndo();
+
+  /**
+   * Returns an AddRef'd pointer to the transaction at the top of the
+   * undo stack. Callers should be aware that this method could return
+   * return a null in some implementations if there is a batch at the top
+   * of the undo stack.
+   */
+  nsITransaction peekUndoStack();
+
+  /**
+   * Returns an AddRef'd pointer to the transaction at the top of the
+   * redo stack. Callers should be aware that this method could return
+   * return a null in some implementations if there is a batch at the top
+   * of the redo stack.
+   */
+  nsITransaction peekRedoStack();
+
+%{C++
+  /**
+   * AsTransactionManager() returns a pointer to TransactionManager class.
+   *
+   * In order to avoid circular dependency issues, this method is defined
+   * in mozilla/TransactionManager.h.  Consumers need to #include that header.
+   */
+  inline mozilla::TransactionManager* AsTransactionManager();
+%}
+};