Struct xpcom::interfaces::nsITransactionListener

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

interface nsITransactionListener : nsISupports

/**
 * The nsITransactionListener interface.
 * <P>
 * This interface is implemented by an object that tracks transactions.
 */

Methods

impl nsITransactionListener

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

Cast this nsITransactionListener to one of its base interfaces.

impl nsITransactionListener

pub unsafe fn WillDo(
    &self,
    aManager: *const nsITransactionManager,
    aTransaction: *const nsITransaction,
    _retval: *mut bool
) -> nsresult

/**
   * Called before a transaction manager calls a transaction's
   * doTransaction() method.
   * @param aManager the transaction manager doing the transaction.
   * @param aTransaction the transaction being executed.
   * @result boolean value returned by listener which indicates
   * its desire to interrupt normal control flow. Listeners should
   * return true if they want to interrupt normal control flow, without
   * throwing an error.
   */

boolean willDo (in nsITransactionManager aManager, in nsITransaction aTransaction);

pub unsafe fn DidDo(
    &self,
    aManager: *const nsITransactionManager,
    aTransaction: *const nsITransaction,
    aDoResult: nsresult
) -> nsresult

/**
   * Called after a transaction manager calls the doTransaction() method of
   * a transaction.
   * @param aManager the transaction manager that did the transaction.
   * @param aTransaction the transaction that was executed.
   * @param aDoResult the nsresult returned after executing
   * the transaction.
   */

void didDo (in nsITransactionManager aManager, in nsITransaction aTransaction, in nsresult aDoResult);

pub unsafe fn WillUndo(
    &self,
    aManager: *const nsITransactionManager,
    aTransaction: *const nsITransaction,
    _retval: *mut bool
) -> nsresult

/**
   * Called before a transaction manager calls the Undo() method of
   * a transaction.
   * @param aManager the transaction manager undoing the transaction.
   * @param aTransaction the transaction being undone.
   * @result boolean value returned by listener which indicates
   * its desire to interrupt normal control flow. Listeners should
   * return true if they want to interrupt normal control flow, without
   * throwing an error. Note that listeners can also interrupt normal
   * control flow by throwing an nsresult that indicates an error.
   */

boolean willUndo (in nsITransactionManager aManager, in nsITransaction aTransaction);

pub unsafe fn DidUndo(
    &self,
    aManager: *const nsITransactionManager,
    aTransaction: *const nsITransaction,
    aUndoResult: nsresult
) -> nsresult

/**
   * Called after a transaction manager calls the Undo() method of
   * a transaction.
   * @param aManager the transaction manager undoing the transaction.
   * @param aTransaction the transaction being undone.
   * @param aUndoResult the nsresult returned after undoing the transaction.
   */

void didUndo (in nsITransactionManager aManager, in nsITransaction aTransaction, in nsresult aUndoResult);

pub unsafe fn WillRedo(
    &self,
    aManager: *const nsITransactionManager,
    aTransaction: *const nsITransaction,
    _retval: *mut bool
) -> nsresult

/**
   * Called before a transaction manager calls the Redo() method of
   * a transaction.
   * @param aManager the transaction manager redoing the transaction.
   * @param aTransaction the transaction being redone.
   * @result boolean value returned by listener which indicates
   * its desire to interrupt normal control flow. Listeners should
   * return true if they want to interrupt normal control flow, without
   * throwing an error. Note that listeners can also interrupt normal
   * control flow by throwing an nsresult that indicates an error.
   */

boolean willRedo (in nsITransactionManager aManager, in nsITransaction aTransaction);

pub unsafe fn DidRedo(
    &self,
    aManager: *const nsITransactionManager,
    aTransaction: *const nsITransaction,
    aRedoResult: nsresult
) -> nsresult

/**
   * Called after a transaction manager calls the Redo() method of
   * a transaction.
   * @param aManager the transaction manager redoing the transaction.
   * @param aTransaction the transaction being redone.
   * @param aRedoResult the nsresult returned after redoing the transaction.
   */

void didRedo (in nsITransactionManager aManager, in nsITransaction aTransaction, in nsresult aRedoResult);

pub unsafe fn WillBeginBatch(
    &self,
    aManager: *const nsITransactionManager,
    _retval: *mut bool
) -> nsresult

/**
   * Called before a transaction manager begins a batch.
   * @param aManager the transaction manager beginning a batch.
   * @result boolean value returned by listener which indicates
   * its desire to interrupt normal control flow. Listeners should
   * return true if they want to interrupt normal control flow, without
   * throwing an error. Note that listeners can also interrupt normal
   * control flow by throwing an nsresult that indicates an error.
   */

boolean willBeginBatch (in nsITransactionManager aManager);

pub unsafe fn DidBeginBatch(
    &self,
    aManager: *const nsITransactionManager,
    aResult: nsresult
) -> nsresult

/**
   * Called after a transaction manager begins a batch.
   * @param aManager the transaction manager that began a batch.
   * @param aResult the nsresult returned after beginning a batch.
   */

void didBeginBatch (in nsITransactionManager aManager, in nsresult aResult);

pub unsafe fn WillEndBatch(
    &self,
    aManager: *const nsITransactionManager,
    _retval: *mut bool
) -> nsresult

/**
   * Called before a transaction manager ends a batch.
   * @param aManager the transaction manager ending a batch.
   * @result boolean value returned by listener which indicates
   * its desire to interrupt normal control flow. Listeners should
   * return true if they want to interrupt normal control flow, without
   * throwing an error. Note that listeners can also interrupt normal
   * control flow by throwing an nsresult that indicates an error.
   */

boolean willEndBatch (in nsITransactionManager aManager);

pub unsafe fn DidEndBatch(
    &self,
    aManager: *const nsITransactionManager,
    aResult: nsresult
) -> nsresult

/**
   * Called after a transaction manager ends a batch.
   * @param aManager the transaction manager ending a batch.
   * @param aResult the nsresult returned after ending a batch.
   */

void didEndBatch (in nsITransactionManager aManager, in nsresult aResult);

pub unsafe fn WillMerge(
    &self,
    aManager: *const nsITransactionManager,
    aTopTransaction: *const nsITransaction,
    aTransactionToMerge: *const nsITransaction,
    _retval: *mut bool
) -> nsresult

/**
   * Called before a transaction manager tries to merge
   * a transaction, that was just executed, with the
   * transaction at the top of the undo stack.
   * @param aManager the transaction manager ending a batch.
   * @param aTopTransaction the transaction at the top of the undo stack.
   * @param aTransactionToMerge the transaction to merge.
   * @result boolean value returned by listener which indicates
   * its desire to interrupt normal control flow. Listeners should
   * return true if they want to interrupt normal control flow, without
   * throwing an error. Note that listeners can also interrupt normal
   * control flow by throwing an nsresult that indicates an error.
   */

boolean willMerge (in nsITransactionManager aManager, in nsITransaction aTopTransaction, in nsITransaction aTransactionToMerge);

pub unsafe fn DidMerge(
    &self,
    aManager: *const nsITransactionManager,
    aTopTransaction: *const nsITransaction,
    aTransactionToMerge: *const nsITransaction,
    aDidMerge: bool,
    aMergeResult: nsresult
) -> nsresult

/**
   * Called after a transaction manager tries to merge
   * a transaction, that was just executed, with the
   * transaction at the top of the undo stack.
   * @param aManager the transaction manager ending a batch.
   * @param aTopTransaction the transaction at the top of the undo stack.
   * @param aTransactionToMerge the transaction to merge.
   * @param aDidMerge true if transaction was merged, else false.
   * @param aMergeResult the nsresult returned after the merge attempt.
   * @param aInterrupt listeners should set this to PR_TRUE if they
   * want to interrupt normal control flow, without throwing an error.
   */

void didMerge (in nsITransactionManager aManager, in nsITransaction aTopTransaction, in nsITransaction aTransactionToMerge, in boolean aDidMerge, in nsresult aMergeResult);

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 nsITransactionListener

const IID: nsIID

IID: nsIID = nsID(1491284164, 31560, 4562, [152, 185, 0, 128, 95, 41, 125, 137])

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 nsITransactionListener

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsITransactionListener

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.