Struct xpcom::interfaces::nsINavHistoryResult

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

interface nsINavHistoryResult : nsISupports

Methods

impl nsINavHistoryResult

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

Cast this nsINavHistoryResult to one of its base interfaces.

impl nsINavHistoryResult

pub unsafe fn GetSortingMode(&self, aSortingMode: *mut uint16_t) -> nsresult

/**
 * The result of a history/bookmark query.
 */
/**
   * Sorts all nodes recursively by the given parameter, one of
   * nsINavHistoryQueryOptions.SORT_BY_*  This will update the corresponding
   * options for this result, so that re-using the current options/queries will
   * always give you the current view.
   */

attribute unsigned short sortingMode;

pub unsafe fn SetSortingMode(&self, aSortingMode: uint16_t) -> nsresult

/**
 * The result of a history/bookmark query.
 */
/**
   * Sorts all nodes recursively by the given parameter, one of
   * nsINavHistoryQueryOptions.SORT_BY_*  This will update the corresponding
   * options for this result, so that re-using the current options/queries will
   * always give you the current view.
   */

attribute unsigned short sortingMode;

pub unsafe fn GetSortingAnnotation(
    &self,
    aSortingAnnotation: &mut nsACString
) -> nsresult

/**
   * The annotation to use in SORT_BY_ANNOTATION_* sorting modes, set this
   * before setting the sortingMode attribute.
   */

attribute AUTF8String sortingAnnotation;

pub unsafe fn SetSortingAnnotation(
    &self,
    aSortingAnnotation: &nsACString
) -> nsresult

/**
   * The annotation to use in SORT_BY_ANNOTATION_* sorting modes, set this
   * before setting the sortingMode attribute.
   */

attribute AUTF8String sortingAnnotation;

pub unsafe fn GetSuppressNotifications(
    &self,
    aSuppressNotifications: *mut bool
) -> nsresult

/**
   * Whether or not notifications on result changes are suppressed.
   * Initially set to false.
   *
   * Use this to avoid flickering and to improve performance when you
   * do temporary changes to the result structure (e.g. when searching for a
   * node recursively).
   */

attribute boolean suppressNotifications;

pub unsafe fn SetSuppressNotifications(
    &self,
    aSuppressNotifications: bool
) -> nsresult

/**
   * Whether or not notifications on result changes are suppressed.
   * Initially set to false.
   *
   * Use this to avoid flickering and to improve performance when you
   * do temporary changes to the result structure (e.g. when searching for a
   * node recursively).
   */

attribute boolean suppressNotifications;

pub unsafe fn AddObserver(
    &self,
    aObserver: *const nsINavHistoryResultObserver,
    aOwnsWeak: bool
) -> nsresult

/**
   * Adds an observer for changes done in the result.
   *
   * @param aObserver
   *        a result observer.
   * @param aOwnsWeak
   *        If false, the result will keep an owning reference to the observer,
   *        which must be removed using removeObserver.
   *        If true, the result will keep a weak reference to the observer, which
   *        must implement nsISupportsWeakReference.
   *
   * @see nsINavHistoryResultObserver
   */

void addObserver (in nsINavHistoryResultObserver aObserver, [optional] in boolean aOwnsWeak);

pub unsafe fn RemoveObserver(
    &self,
    aObserver: *const nsINavHistoryResultObserver
) -> nsresult

/**
   * Removes an observer that was added by addObserver.
   *
   * @param aObserver
   *        a result observer that was added by addObserver.
   */

void removeObserver (in nsINavHistoryResultObserver aObserver);

pub unsafe fn GetRoot(
    &self,
    aRoot: *mut *const nsINavHistoryContainerResultNode
) -> nsresult

/**
   * This is the root of the results. Remember that you need to open all
   * containers for their contents to be valid.
   *
   * When a result goes out of scope it will continue to observe changes till
   * it is cycle collected.  While the result waits to be collected it will stay
   * in memory, and continue to update itself, potentially causing unwanted
   * additional work.  When you close the root node the result will stop
   * observing changes, so it is good practice to close the root node when you
   * are done with a result, since that will avoid unwanted performance hits.
   */

readonly attribute nsINavHistoryContainerResultNode root;

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 nsINavHistoryResult

const IID: nsIID

IID: nsIID = nsID(3257048291, 8537, 16385, [133, 156, 112, 19, 197, 47, 118, 25])

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 nsINavHistoryResult

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsINavHistoryResult

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.