gecko-dev/editor/txmgr/nsITransactionManager.idl

169 строки
5.5 KiB
Plaintext
Исходник Обычный вид История

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2012-05-21 15:12:37 +04:00
/* 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"
#include "nsITransactionList.idl"
#include "nsITransactionListener.idl"
%{ C++
#define NS_TRANSACTIONMANAGER_CONTRACTID "@mozilla.org/transactionmanager;1"
%} C++
/**
* 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.
*/
void doTransaction(in nsITransaction aTransaction);
/**
* Pops the topmost transaction on the undo stack, calls its
* undoTransaction() method, then pushes it on the redo stack.
*/
void undoTransaction();
/**
* Pops the topmost transaction on the redo stack, calls its
* redoTransaction() method, then pushes it on the undo stack.
*/
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 nsITransactionList.
*/
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();
/**
* Returns the list of transactions on the undo stack. Note that the
* transaction at the top of the undo stack will actually be at the
* index 'n-1' in the list, where 'n' is the number of items in the list.
*/
nsITransactionList getUndoList();
/**
* Returns the list of transactions on the redo stack. Note that the
* transaction at the top of the redo stack will actually be at the
* index 'n-1' in the list, where 'n' is the number of items in the list.
*/
nsITransactionList getRedoList();
/**
* Adds a listener to the transaction manager's notification list. Listeners
* are notified whenever a transaction is done, undone, or redone.
* <P>
* The listener's AddRef() method is called.
* @param aListener the lister to add.
*/
void AddListener(in nsITransactionListener aListener);
/**
* Removes a listener from the transaction manager's notification list.
* <P>
* The listener's Release() method is called.
* @param aListener the lister to remove.
*/
void RemoveListener(in nsITransactionListener aListener);
};