Struct xpcom::interfaces::nsITransactionManager

#[repr(C)]
pub struct nsITransactionManager { /* fields omitted */ }

interface nsITransactionManager : nsISupports

Methods

impl nsITransactionManager

pub fn coerce<T: nsITransactionManagerCoerce>(&self) -> &T

Cast this nsITransactionManager to one of its base interfaces.

impl nsITransactionManager

pub unsafe fn DoTransaction(
    &self,
    aTransaction: *const nsITransaction
) -> nsresult

/**
 * The nsITransactionManager interface.
 * <P>
 * This interface is implemented by an object that wants to
 * manage/track transactions.
 */
/**
   * 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);

pub unsafe fn UndoTransaction(&self) -> nsresult

/**
   * Pops the topmost transaction on the undo stack, calls its
   * undoTransaction() method, then pushes it on the redo stack.
   */

void undoTransaction ();

pub unsafe fn RedoTransaction(&self) -> nsresult

/**
   * Pops the topmost transaction on the redo stack, calls its
   * redoTransaction() method, then pushes it on the undo stack.
   */

void redoTransaction ();

pub unsafe fn Clear(&self) -> nsresult

/**
   * Clears the undo and redo stacks.
   */

void clear ();

pub unsafe fn ClearUndoStack(&self) -> nsresult

/**
   * Clears the undo stack only.
   */

void clearUndoStack ();

pub unsafe fn ClearRedoStack(&self) -> nsresult

/**
   * Clears the redo stack only.
   */

void clearRedoStack ();

pub unsafe fn BeginBatch(&self, aData: *const nsISupports) -> nsresult

/**
   * 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.
   */

void beginBatch (in nsISupports aData);

pub unsafe fn EndBatch(&self, aAllowEmpty: bool) -> nsresult

/**
   * 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);

pub unsafe fn GetNumberOfUndoItems(
    &self,
    aNumberOfUndoItems: *mut int32_t
) -> nsresult

/**
   * The number of items on the undo stack.
   */

readonly attribute long numberOfUndoItems;

pub unsafe fn GetNumberOfRedoItems(
    &self,
    aNumberOfRedoItems: *mut int32_t
) -> nsresult

/**
   * The number of items on the redo stack.
   */

readonly attribute long numberOfRedoItems;

pub unsafe fn GetMaxTransactionCount(
    &self,
    aMaxTransactionCount: *mut int32_t
) -> nsresult

/**
   * 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;

pub unsafe fn SetMaxTransactionCount(
    &self,
    aMaxTransactionCount: int32_t
) -> nsresult

/**
   * 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;

pub unsafe fn BatchTopUndo(&self) -> nsresult

/**
   * 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 ();

pub unsafe fn RemoveTopUndo(&self) -> nsresult

/**
   * Removes the transaction at the top of the undo stack (if any) without
   * transacting.
   */

void removeTopUndo ();

pub unsafe fn PeekUndoStack(
    &self,
    _retval: *mut *const nsITransaction
) -> nsresult

/**
   * 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 ();

pub unsafe fn PeekRedoStack(
    &self,
    _retval: *mut *const nsITransaction
) -> nsresult

/**
   * 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 ();

pub unsafe fn AddListener(
    &self,
    aListener: *const nsITransactionListener
) -> nsresult

/**
   * 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);

pub unsafe fn RemoveListener(
    &self,
    aListener: *const nsITransactionListener
) -> nsresult

/**
   * 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);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsITransactionManager

const IID: nsIID

IID: nsIID = nsID(3346490335, 4025, 16808, [128, 116, 142, 136, 47, 96, 87, 85])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsITransactionManager

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsITransactionManager

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.