Struct xpcom::interfaces::nsIWindowMediator

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

interface nsIWindowMediator : nsISupports

Methods

impl nsIWindowMediator

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

Cast this nsIWindowMediator to one of its base interfaces.

impl nsIWindowMediator

pub const zLevelTop: i64

zLevelTop: i64 = 1

pub const zLevelBottom: i64

zLevelBottom: i64 = 2

pub const zLevelBelow: i64

zLevelBelow: i64 = 3

pub unsafe fn GetEnumerator(
    &self,
    aWindowType: *const int16_t,
    _retval: *mut *const nsISimpleEnumerator
) -> nsresult

/** Return an enumerator which iterates over all windows of type aWindowType
    * from the oldest window to the youngest.
    * @param  aWindowType the returned enumerator will enumerate only
    *                     windows of this type. ("type" is the
    *                     |windowtype| attribute of the XML <window> element.)
    *                     If null, all windows will be enumerated.
    * @return an enumerator of nsIDOMWindows.  Note that windows close
    *         asynchronously in many cases, so windows returned from this
    *         enumerator can have .closed set to true.  Caveat enumerator!
    */

nsISimpleEnumerator getEnumerator (in wstring aWindowType);

pub unsafe fn GetXULWindowEnumerator(
    &self,
    aWindowType: *const int16_t,
    _retval: *mut *const nsISimpleEnumerator
) -> nsresult

/** Identical to getEnumerator except:
    * @return an enumerator of nsIXULWindows
  */

nsISimpleEnumerator getXULWindowEnumerator (in wstring aWindowType);

pub unsafe fn GetZOrderDOMWindowEnumerator(
    &self,
    aWindowType: *const int16_t,
    aFrontToBack: bool,
    _retval: *mut *const nsISimpleEnumerator
) -> nsresult

/** Return an enumerator which iterates over all windows of type aWindowType
    * in their z (front-to-back) order. Note this interface makes
    * no requirement that a window couldn't be revisited if windows
    * are re-ordered while z-order enumerators are active.
    * @param  aWindowType the returned enumerator will enumerate only
    *                     windows of this type. ("type" is the
    *                     |windowtype| attribute of the XML <window> element.)
    *                     If null, all windows will be enumerated.
    * @param  aFrontToBack if true, the enumerator enumerates windows in order
    *                      from front to back. back to front if false.
    * @return an enumerator of nsIDOMWindows
    */

nsISimpleEnumerator getZOrderDOMWindowEnumerator (in wstring aWindowType, in boolean aFrontToBack);

pub unsafe fn GetZOrderXULWindowEnumerator(
    &self,
    aWindowType: *const int16_t,
    aFrontToBack: bool,
    _retval: *mut *const nsISimpleEnumerator
) -> nsresult

/** Identical to getZOrderDOMWindowEnumerator except:
    * @return an enumerator of nsIXULWindows
    */

nsISimpleEnumerator getZOrderXULWindowEnumerator (in wstring aWindowType, in boolean aFrontToBack);

pub unsafe fn GetMostRecentWindow(
    &self,
    aWindowType: *const int16_t,
    _retval: *mut *const mozIDOMWindowProxy
) -> nsresult

/** This is a shortcut for simply fetching the first window in
    * front to back order.
    * @param  aWindowType return the topmost window of this type.
    *                     ("type" is the |windowtype| attribute of
    *                     the XML <window> element.)
    *                     If null, return the topmost window of any type.
    * @return the topmost window
    */

mozIDOMWindowProxy getMostRecentWindow (in wstring aWindowType);

pub unsafe fn GetOuterWindowWithId(
    &self,
    aOuterWindowID: uint64_t,
    _retval: *mut *const mozIDOMWindowProxy
) -> nsresult

/**
   * Return the outer window with the given ID, if any.  Can return null.
   */

mozIDOMWindowProxy getOuterWindowWithId (in unsigned long long aOuterWindowID);

pub unsafe fn GetCurrentInnerWindowWithId(
    &self,
    aInnerWindowID: uint64_t,
    _retval: *mut *const mozIDOMWindow
) -> nsresult

/**
    * Return the inner window with the given current window ID, if any.
    * Can return null if no inner window with the ID exists or if it's not
    * a current inner anymore.
    */

mozIDOMWindow getCurrentInnerWindowWithId (in unsigned long long aInnerWindowID);

pub unsafe fn RegisterWindow(&self, aWindow: *const nsIXULWindow) -> nsresult

/** Add the window to the list of known windows. Listeners (see
    * addListener) will be notified through their onOpenWindow method.
    * @param aWindow the window to add
    */

[noscript] void registerWindow (in nsIXULWindow aWindow);

pub unsafe fn UnregisterWindow(&self, aWindow: *const nsIXULWindow) -> nsresult

/** Remove the window from the list of known windows. Listeners (see
    * addListener) will be be notified through their onCloseWindow method.
    * @param aWindow the window to remove
    */

[noscript] void unregisterWindow (in nsIXULWindow aWindow);

pub unsafe fn UpdateWindowTimeStamp(
    &self,
    aWindow: *const nsIXULWindow
) -> nsresult

/** Call this method when a window gains focus. It's a primitive means of
    * determining the most recent window. It's no longer necessary and it
    * really should be removed.
    * @param aWindow the window which has gained focus
    */

[noscript] void updateWindowTimeStamp (in nsIXULWindow aWindow);

pub unsafe fn CalculateZPosition(
    &self,
    inWindow: *const nsIXULWindow,
    inPosition: uint32_t,
    inBelow: *const nsIWidget,
    outPosition: *mut uint32_t,
    outBelow: *mut *const nsIWidget,
    _retval: *mut bool
) -> nsresult

/** A window wants to be moved in z-order. Calculate whether and how
    * it should be constrained. Note this method is advisory only:
    * it changes nothing either in WindowMediator's internal state
    * or with the window.
    * Note it compares the nsIXULWindow to nsIWidgets. A pure interface
    * would use all nsIXULWindows. But we expect this to be called from
    * callbacks originating in native window code. They are expected to
    * hand us comparison values which are pulled from general storage
    * in the native widget, and may not correspond to an nsIWidget at all.
    * For that reason this interface requires only objects one step
    * removed from the native window (nsIWidgets), and its implementation
    * must be very understanding of what may be completely invalid
    * pointers in those parameters.
    *
    * @param inWindow the window in question
    * @param inPosition requested position
    *                   values: zLevelTop: topmost window. zLevelBottom: bottom.
    *                   zLevelBelow: below ioBelow. (the value of ioBelow will
    *                   be ignored for zLevelTop and Bottom.)
    * @param inBelow if inPosition==zLevelBelow, the window
    *                 below which inWindow wants to be placed. Otherwise this
    *                 variable is ignored.
    * @param outPosition constrained position, values like inPosition.
    * @param outBelow if outPosition==zLevelBelow, the window
    *                 below which inWindow should be placed. Otherwise this
    *                 this value will be null.
    * @return PR_TRUE if the position returned is different from
    *         the position given.
    */

[noscript] boolean calculateZPosition (in nsIXULWindow inWindow, in unsigned long inPosition, in nsIWidget inBelow, out unsigned long outPosition, out nsIWidget outBelow);

pub unsafe fn SetZPosition(
    &self,
    inWindow: *const nsIXULWindow,
    inPosition: uint32_t,
    inBelow: *const nsIXULWindow
) -> nsresult

/** A window has been positioned behind another. Inform WindowMediator
    * @param inWindow the window in question
    * @param inPosition new position. values:
    *                   zLevelTop: topmost window.
    *                   zLevelBottom: bottom.
    *                   zLevelBelow: below inBelow. (inBelow is ignored
    *                                for other values of inPosition.)
    * @param inBelow the window inWindow is behind, if zLevelBelow
    */

[noscript] void setZPosition (in nsIXULWindow inWindow, in unsigned long inPosition, in nsIXULWindow inBelow);

pub unsafe fn GetZLevel(
    &self,
    aWindow: *const nsIXULWindow,
    _retval: *mut uint32_t
) -> nsresult

/** Return the window's Z level (as defined in nsIXULWindow).
    * @param aWindow the window in question
    * @return aWindow's z level
    */

[noscript] uint32_t getZLevel (in nsIXULWindow aWindow);

pub unsafe fn SetZLevel(
    &self,
    aWindow: *const nsIXULWindow,
    aZLevel: uint32_t
) -> nsresult

/** Set the window's Z level (as defined in nsIXULWindow). The implementation
    * will reposition the window as necessary to match its new Z level.
    * The implementation will assume a window's Z level to be
    * nsIXULWindow::normalZ until it has been informed of a different level.
    * @param aWindow the window in question
    * @param aZLevel the window's new Z level
    */

[noscript] void setZLevel (in nsIXULWindow aWindow, in uint32_t aZLevel);

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

/** Register a listener for window status changes.
    * keeps strong ref? (to be decided)
    * @param aListener the listener to register
    */

void addListener (in nsIWindowMediatorListener aListener);

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

/** Unregister a listener of window status changes.
    * @param aListener the listener to unregister
    */

void removeListener (in nsIWindowMediatorListener 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 nsIWindowMediator

const IID: nsIID

IID: nsIID = nsID(3742212182, 13693, 17023, [186, 253, 230, 203, 241, 156, 147, 129])

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 nsIWindowMediator

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIWindowMediator

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.