Struct xpcom::interfaces::nsIHandlerInfo

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

interface nsIHandlerInfo : nsISupports

/**
 * nsIHandlerInfo gives access to the information about how a given protocol
 * scheme or MIME-type is handled.
 */

Methods

impl nsIHandlerInfo

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

Cast this nsIHandlerInfo to one of its base interfaces.

impl nsIHandlerInfo

pub const saveToDisk: i64

saveToDisk: i64 = 0

pub const alwaysAsk: i64

alwaysAsk: i64 = 1

/**
     * Used to indicate that we know nothing about what to do with this.  You
     * could consider this to be not initialized.
     */

pub const useHelperApp: i64

useHelperApp: i64 = 2

pub const handleInternally: i64

handleInternally: i64 = 3

pub const useSystemDefault: i64

useSystemDefault: i64 = 4

pub unsafe fn GetType(&self, aType: &mut nsACString) -> nsresult

/**
     * The type of this handler info.  For MIME handlers, this is the MIME type.
     * For protocol handlers, it's the scheme.
     *
     * @return String representing the type.
     */

readonly attribute ACString type;

pub unsafe fn GetDescription(&self, aDescription: &mut nsAString) -> nsresult

/**
     * A human readable description of the handler type
     */

attribute AString description;

pub unsafe fn SetDescription(&self, aDescription: &nsAString) -> nsresult

/**
     * A human readable description of the handler type
     */

attribute AString description;

pub unsafe fn GetPreferredApplicationHandler(
    &self,
    aPreferredApplicationHandler: *mut *const nsIHandlerApp
) -> nsresult

/**
     * The application the user has said they want associated with this content
     * type. This is not always guaranteed to be set!!
     */

attribute nsIHandlerApp preferredApplicationHandler;

pub unsafe fn SetPreferredApplicationHandler(
    &self,
    aPreferredApplicationHandler: *const nsIHandlerApp
) -> nsresult

/**
     * The application the user has said they want associated with this content
     * type. This is not always guaranteed to be set!!
     */

attribute nsIHandlerApp preferredApplicationHandler;

pub unsafe fn GetPossibleApplicationHandlers(
    &self,
    aPossibleApplicationHandlers: *mut *const nsIMutableArray
) -> nsresult

/**
     * Applications that can handle this content type.
     *
     * The list will include the preferred handler, if any.  Elements of this
     * array are nsIHandlerApp objects, and this attribute will always reference
     * an array, whether or not there are any possible handlers.  If there are
     * no possible handlers, the array will contain no elements, so just check
     * its length (nsIArray::length) to see if there are any possible handlers.
     */

readonly attribute nsIMutableArray possibleApplicationHandlers;

pub unsafe fn GetHasDefaultHandler(
    &self,
    aHasDefaultHandler: *mut bool
) -> nsresult

/**
     * Indicates whether a default application handler exists,
     * i.e. whether launchWithFile with action = useSystemDefault is possible
     * and defaultDescription will contain usable information.
     */

readonly attribute boolean hasDefaultHandler;

pub unsafe fn GetDefaultDescription(
    &self,
    aDefaultDescription: &mut nsAString
) -> nsresult

/**
     * A pretty name description of the associated default application. Only
     * usable if hasDefaultHandler is true.
     */

readonly attribute AString defaultDescription;

pub unsafe fn LaunchWithURI(
    &self,
    aURI: *const nsIURI,
    aWindowContext: *const nsIInterfaceRequestor
) -> nsresult

/**
     * Launches the application with the specified URI, in a way that
     * depends on the value of preferredAction. preferredAction must be
     * useHelperApp or useSystemDefault.
     *
     * @note Only the URI scheme is used to determine how to launch.  This is
     * essentially a pass-by-value operation.  This means that in the case of
     * a file: URI, the handler that is registered for file: will be launched
     * and our code will not make any decision based on the content-type or
     * extension, though the invoked file: handler is free to do so.
     *
     * @param aURI
     *        The URI to launch this application with
     *
     * @param aWindowContext
     *        The window to parent the dialog against, and, if a web handler
     *        is chosen, it is loaded in this window as well.  See
     *        nsIHandlerApp.launchWithURI for more details.
     *
     * @throw NS_ERROR_INVALID_ARG if preferredAction is not valid for this
     * call. Other exceptions may be thrown.
     */

void launchWithURI (in nsIURI aURI, [optional] in nsIInterfaceRequestor aWindowContext);

pub unsafe fn GetPreferredAction(
    &self,
    aPreferredAction: *mut nsHandlerInfoAction
) -> nsresult

/**
     * preferredAction is how the user specified they would like to handle
     * this content type: save to disk, use specified helper app, use OS
     * default handler or handle using navigator; possible value constants
     * listed below
     */

attribute nsHandlerInfoAction preferredAction;

pub unsafe fn SetPreferredAction(
    &self,
    aPreferredAction: nsHandlerInfoAction
) -> nsresult

/**
     * preferredAction is how the user specified they would like to handle
     * this content type: save to disk, use specified helper app, use OS
     * default handler or handle using navigator; possible value constants
     * listed below
     */

attribute nsHandlerInfoAction preferredAction;

pub unsafe fn GetAlwaysAskBeforeHandling(
    &self,
    aAlwaysAskBeforeHandling: *mut bool
) -> nsresult

/**
     * alwaysAskBeforeHandling: if true, we should always give the user a
     * dialog asking how to dispose of this content.
     */

attribute boolean alwaysAskBeforeHandling;

pub unsafe fn SetAlwaysAskBeforeHandling(
    &self,
    aAlwaysAskBeforeHandling: bool
) -> nsresult

/**
     * alwaysAskBeforeHandling: if true, we should always give the user a
     * dialog asking how to dispose of this content.
     */

attribute boolean alwaysAskBeforeHandling;

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 nsIHandlerInfo

const IID: nsIID

IID: nsIID = nsID(845043367, 14178, 17170, [174, 199, 241, 252, 248, 75, 65, 69])

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 nsIHandlerInfo

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIHandlerInfo

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.