Struct xpcom::interfaces::nsINavHistoryResultObserver

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

interface nsINavHistoryResultObserver : nsISupports

/**
 * Allows clients to observe what is happening to a result as it updates itself
 * according to history and bookmark system events. Register this observer on a
 * result using nsINavHistoryResult::addObserver.
 */

Methods

impl nsINavHistoryResultObserver

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

Cast this nsINavHistoryResultObserver to one of its base interfaces.

impl nsINavHistoryResultObserver

pub unsafe fn NodeInserted(
    &self,
    aParent: *const nsINavHistoryContainerResultNode,
    aNode: *const nsINavHistoryResultNode,
    aNewIndex: uint32_t
) -> nsresult

/**
   * Called when 'aItem' is inserted into 'aParent' at index 'aNewIndex'.
   * The item previously at index (if any) and everything below it will have
   * been shifted down by one. The item may be a container or a leaf.
   */

void nodeInserted (in nsINavHistoryContainerResultNode aParent, in nsINavHistoryResultNode aNode, in unsigned long aNewIndex);

pub unsafe fn NodeRemoved(
    &self,
    aParent: *const nsINavHistoryContainerResultNode,
    aItem: *const nsINavHistoryResultNode,
    aOldIndex: uint32_t
) -> nsresult

/**
   * Called whan 'aItem' is removed from 'aParent' at 'aOldIndex'. The item
   * may be a container or a leaf. This function will be called after the item
   * has been removed from its parent list, but before anything else (including
   * NULLing out the item's parent) has happened.
   */

void nodeRemoved (in nsINavHistoryContainerResultNode aParent, in nsINavHistoryResultNode aItem, in unsigned long aOldIndex);

pub unsafe fn NodeMoved(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aOldParent: *const nsINavHistoryContainerResultNode,
    aOldIndex: uint32_t,
    aNewParent: *const nsINavHistoryContainerResultNode,
    aNewIndex: uint32_t
) -> nsresult

/**
   * Called whan 'aItem' is moved from 'aOldParent' at 'aOldIndex' to
   * aNewParent at aNewIndex. The item may be a container or a leaf.
   *
   * XXX: at the moment, this method is called only when an item is moved
   * within the same container. When an item is moved between containers,
   * a new node is created for the item, and the itemRemoved/itemAdded methods
   * are used.
   */

void nodeMoved (in nsINavHistoryResultNode aNode, in nsINavHistoryContainerResultNode aOldParent, in unsigned long aOldIndex, in nsINavHistoryContainerResultNode aNewParent, in unsigned long aNewIndex);

pub unsafe fn NodeTitleChanged(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aNewTitle: &nsACString
) -> nsresult

/**
   * Called right after aNode's title has changed.
   *
   * @param aNode
   *        a result node
   * @param aNewTitle
   *        the new title
   */

void nodeTitleChanged (in nsINavHistoryResultNode aNode, in AUTF8String aNewTitle);

pub unsafe fn NodeURIChanged(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aOldURI: &nsACString
) -> nsresult

/**
   * Called right after aNode's uri property has changed.
   *
   * @param aNode
   *        a result node
   * @param aNewURI
   *        the old uri
   */

void nodeURIChanged (in nsINavHistoryResultNode aNode, in AUTF8String aOldURI);

pub unsafe fn NodeIconChanged(
    &self,
    aNode: *const nsINavHistoryResultNode
) -> nsresult

/**
   * Called right after aNode's icon property has changed.
   *
   * @param aNode
   *        a result node
   *
   * @note: The new icon is accessible through aNode.icon.
   */

void nodeIconChanged (in nsINavHistoryResultNode aNode);

pub unsafe fn NodeHistoryDetailsChanged(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aOldVisitDate: PRTime,
    aOldAccessCount: uint32_t
) -> nsresult

/**
   * Called right after aNode's time property or accessCount property, or both,
   * have changed.
   *
   * @param aNode
   *        a uri result node
   * @param aOldVisitDate
   *        the old visit date
   * @param aOldAccessCount
   *        the old access-count
   */

void nodeHistoryDetailsChanged (in nsINavHistoryResultNode aNode, in PRTime aOldVisitDate, in unsigned long aOldAccessCount);

pub unsafe fn NodeTagsChanged(
    &self,
    aNode: *const nsINavHistoryResultNode
) -> nsresult

/**
   * Called when the tags set on the uri represented by aNode have changed.
   *
   * @param aNode
   *        a uri result node
   *
   * @note: The new tags list is accessible through aNode.tags.
   */

void nodeTagsChanged (in nsINavHistoryResultNode aNode);

pub unsafe fn NodeKeywordChanged(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aNewKeyword: &nsACString
) -> nsresult

/**
   * Called right after the aNode's keyword property has changed.
   *
   * @param aNode
   *        a uri result node
   * @param aNewKeyword
   *        the new keyword
   */

void nodeKeywordChanged (in nsINavHistoryResultNode aNode, in AUTF8String aNewKeyword);

pub unsafe fn NodeAnnotationChanged(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aAnnoName: &nsACString
) -> nsresult

/**
   * Called right after an annotation of aNode's has changed (set, altered, or
   * unset).
   *
   * @param aNode
   *        a result node
   * @param aAnnoName
   *        the name of the annotation that changed
   */

void nodeAnnotationChanged (in nsINavHistoryResultNode aNode, in AUTF8String aAnnoName);

pub unsafe fn NodeDateAddedChanged(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aNewValue: PRTime
) -> nsresult

/**
   * Called right after aNode's dateAdded property has changed.
   *
   * @param aNode
   *        a result node
   * @param aNewValue
   *        the new value of the dateAdded property
   */

void nodeDateAddedChanged (in nsINavHistoryResultNode aNode, in PRTime aNewValue);

pub unsafe fn NodeLastModifiedChanged(
    &self,
    aNode: *const nsINavHistoryResultNode,
    aNewValue: PRTime
) -> nsresult

/**
   * Called right after aNode's dateModified property has changed.
   *
   * @param aNode
   *        a result node
   * @param aNewValue
   *        the new value of the dateModified property
   */

void nodeLastModifiedChanged (in nsINavHistoryResultNode aNode, in PRTime aNewValue);

pub unsafe fn ContainerStateChanged(
    &self,
    aContainerNode: *const nsINavHistoryContainerResultNode,
    aOldState: uint32_t,
    aNewState: uint32_t
) -> nsresult

/**
   * Called after a container changes state.
   *
   * @param aContainerNode
   *        The container that has changed state.
   * @param aOldState
   *        The state that aContainerNode has transitioned out of.
   * @param aNewState
   *        The state that aContainerNode has transitioned into.
   */

void containerStateChanged (in nsINavHistoryContainerResultNode aContainerNode, in unsigned long aOldState, in unsigned long aNewState);

pub unsafe fn InvalidateContainer(
    &self,
    aContainerNode: *const nsINavHistoryContainerResultNode
) -> nsresult

/**
   * Called when something significant has happened within the container. The
   * contents of the container should be re-built.
   *
   * @param aContainerNode
   *        the container node to invalidate
   */

void invalidateContainer (in nsINavHistoryContainerResultNode aContainerNode);

pub unsafe fn SortingChanged(&self, sortingMode: uint16_t) -> nsresult

/**
   * This is called to indicate to the UI that the sort has changed to the
   * given mode. For trees, for example, this would update the column headers
   * to reflect the sorting. For many other types of views, this won't be
   * applicable.
   *
   * @param sortingMode  One of nsINavHistoryQueryOptions.SORT_BY_* that
   *                     indicates the new sorting mode.
   *
   * This only is expected to update the sorting UI. invalidateAll() will also
   * get called if the sorting changes to update everything.
   */

void sortingChanged (in unsigned short sortingMode);

pub unsafe fn Batching(&self, aToggleMode: bool) -> nsresult

/**
   * This is called to indicate that a batch operation is about to start or end.
   * The observer could want to disable some events or updates during batches,
   * since multiple operations are packed in a short time.
   * For example treeviews could temporarily suppress select notifications.
   *
   * @param aToggleMode
   *        true if a batch is starting, false if it's ending.
   */

void batching (in boolean aToggleMode);

pub unsafe fn GetResult(
    &self,
    aResult: *mut *const nsINavHistoryResult
) -> nsresult

/**
   * Called by the result when this observer is added.
   */

attribute nsINavHistoryResult result;

pub unsafe fn SetResult(&self, aResult: *const nsINavHistoryResult) -> nsresult

/**
   * Called by the result when this observer is added.
   */

attribute nsINavHistoryResult result;

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 nsINavHistoryResultObserver

const IID: nsIID

IID: nsIID = nsID(4130179947, 15438, 19103, [168, 151, 219, 96, 93, 11, 122, 15])

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 nsINavHistoryResultObserver

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsINavHistoryResultObserver

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.