mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-11 02:56:06 +00:00
169 lines
5.5 KiB
Plaintext
169 lines
5.5 KiB
Plaintext
/* -*- 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"
|
|
#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);
|
|
};
|
|
|