Struct xpcom::interfaces::nsIMozIconURI

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

interface nsIMozIconURI : nsIURI

/**
   * nsIIconURI
   *
   * This interface derives from nsIURI, to provide additional information
   * about moz-icon URIs.
   *
   * What *is* a moz-icon URI you ask?  Well, it has the following syntax:
   *
   * moz-icon:[<valid-url> | //<file-with-extension> | //stock/<stock-icon>]?
   *            ['?'[<parameter-value-pairs>]]
   *
   * <valid-url> is a valid URL spec.
   *
   * <file-with-extension> is any filename with an extension, e.g. "dummy.html".
   * If the file you want an icon for isn't known to exist, you can use this
   * instead of a URL and just place a dummy file name with the extension or
   * content type you want.
   *
   * <stock-icon> is the name of a platform-dependant stock icon.
   *
   * Legal parameter value pairs are listed below:
   *
   *   Parameter:   size
   *   Values:      [<integer> | button | toolbar | toolbarsmall | menu |
   *                 dialog]
   *   Description: If integer, this is the desired size in square pixels of
   *                the icon
   *                Else, use the OS default for the specified keyword context.
   *
   *   Parameter:   state
   *   Values:      [normal | disabled]
   *   Description: The state of the icon.
   *
   *   Parameter:   contentType
   *   Values:      <mime-type>
   *   Description: The mime type we want an icon for. This is ignored by
   *                stock images.
   */

Methods

impl nsIMozIconURI

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

Cast this nsIMozIconURI to one of its base interfaces.

impl nsIMozIconURI

pub unsafe fn GetIconURL(&self, aIconURL: *mut *const nsIURL) -> nsresult

attribute nsIURL iconURL;

pub unsafe fn SetIconURL(&self, aIconURL: *const nsIURL) -> nsresult

attribute nsIURL iconURL;

pub unsafe fn GetImageSize(&self, aImageSize: *mut uint32_t) -> nsresult

attribute unsigned long imageSize;

pub unsafe fn SetImageSize(&self, aImageSize: uint32_t) -> nsresult

attribute unsigned long imageSize;

pub unsafe fn GetStockIcon(&self, aStockIcon: &mut nsACString) -> nsresult

readonly attribute ACString stockIcon;

pub unsafe fn GetIconSize(&self, aIconSize: &mut nsACString) -> nsresult

readonly attribute ACString iconSize;

pub unsafe fn GetIconState(&self, aIconState: &mut nsACString) -> nsresult

readonly attribute ACString iconState;

pub unsafe fn GetContentType(&self, aContentType: &mut nsACString) -> nsresult

attribute ACString contentType;

pub unsafe fn SetContentType(&self, aContentType: &nsACString) -> nsresult

attribute ACString contentType;

pub unsafe fn GetFileExtension(
    &self,
    aFileExtension: &mut nsACString
) -> nsresult

readonly attribute ACString fileExtension;

Methods from Deref<Target = nsIURI>

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

Cast this nsIURI to one of its base interfaces.

pub unsafe fn GetSpec(&self, aSpec: &mut nsACString) -> nsresult

/************************************************************************
     * The URI is broken down into the following principal components:
     */
/**
     * Returns a string representation of the URI. Setting the spec causes
     * the new spec to be parsed per the rules for the scheme the URI
     * currently has.  In particular, setting the spec to a URI string with a
     * different scheme will generally produce incorrect results; no one
     * outside of a protocol handler implementation should be doing that.  If
     * the URI stores information from the nsIIOService.newURI call used to
     * create it other than just the parsed string, then behavior of this
     * information on setting the spec attribute is undefined.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String spec;

pub unsafe fn SetSpec(&self, aSpec: &nsACString) -> nsresult

/************************************************************************
     * The URI is broken down into the following principal components:
     */
/**
     * Returns a string representation of the URI. Setting the spec causes
     * the new spec to be parsed per the rules for the scheme the URI
     * currently has.  In particular, setting the spec to a URI string with a
     * different scheme will generally produce incorrect results; no one
     * outside of a protocol handler implementation should be doing that.  If
     * the URI stores information from the nsIIOService.newURI call used to
     * create it other than just the parsed string, then behavior of this
     * information on setting the spec attribute is undefined.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String spec;

pub unsafe fn GetPrePath(&self, aPrePath: &mut nsACString) -> nsresult

/**
     * The prePath (eg. scheme://user:password@host:port) returns the string
     * before the path.  This is useful for authentication or managing sessions.
     *
     * Some characters may be escaped.
     */

readonly attribute AUTF8String prePath;

pub unsafe fn GetScheme(&self, aScheme: &mut nsACString) -> nsresult

/**
     * The Scheme is the protocol to which this URI refers.  The scheme is
     * restricted to the US-ASCII charset per RFC3986.  Setting this is
     * highly discouraged outside of a protocol handler implementation, since
     * that will generally lead to incorrect results.
     */

attribute ACString scheme;

pub unsafe fn SetScheme(&self, aScheme: &nsACString) -> nsresult

/**
     * The Scheme is the protocol to which this URI refers.  The scheme is
     * restricted to the US-ASCII charset per RFC3986.  Setting this is
     * highly discouraged outside of a protocol handler implementation, since
     * that will generally lead to incorrect results.
     */

attribute ACString scheme;

pub unsafe fn GetUserPass(&self, aUserPass: &mut nsACString) -> nsresult

/**
     * The username:password (or username only if value doesn't contain a ':')
     *
     * Some characters may be escaped.
     */

attribute AUTF8String userPass;

pub unsafe fn SetUserPass(&self, aUserPass: &nsACString) -> nsresult

/**
     * The username:password (or username only if value doesn't contain a ':')
     *
     * Some characters may be escaped.
     */

attribute AUTF8String userPass;

pub unsafe fn GetUsername(&self, aUsername: &mut nsACString) -> nsresult

/**
     * The optional username and password, assuming the preHost consists of
     * username:password.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String username;

pub unsafe fn SetUsername(&self, aUsername: &nsACString) -> nsresult

/**
     * The optional username and password, assuming the preHost consists of
     * username:password.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String username;

pub unsafe fn GetPassword(&self, aPassword: &mut nsACString) -> nsresult

attribute AUTF8String password;

pub unsafe fn SetPassword(&self, aPassword: &nsACString) -> nsresult

attribute AUTF8String password;

pub unsafe fn GetHostPort(&self, aHostPort: &mut nsACString) -> nsresult

/**
     * The host:port (or simply the host, if port == -1).
     *
     * If this attribute is set to a value that only has a host part, the port
     * will not be reset. To reset the port as well use setHostAndPort.
     */

attribute AUTF8String hostPort;

pub unsafe fn SetHostPort(&self, aHostPort: &nsACString) -> nsresult

/**
     * The host:port (or simply the host, if port == -1).
     *
     * If this attribute is set to a value that only has a host part, the port
     * will not be reset. To reset the port as well use setHostAndPort.
     */

attribute AUTF8String hostPort;

pub unsafe fn SetHostAndPort(&self, hostport: &nsACString) -> nsresult

/**
     * This function will always set a host and a port. If the port part is
     * empty, the value of the port will be set to the default value.
     */

void setHostAndPort (in AUTF8String hostport);

pub unsafe fn GetHost(&self, aHost: &mut nsACString) -> nsresult

/**
     * The host is the internet domain name to which this URI refers.  It could
     * be an IPv4 (or IPv6) address literal. Otherwise it is an ASCII or punycode
     * encoded string.
     */

attribute AUTF8String host;

pub unsafe fn SetHost(&self, aHost: &nsACString) -> nsresult

/**
     * The host is the internet domain name to which this URI refers.  It could
     * be an IPv4 (or IPv6) address literal. Otherwise it is an ASCII or punycode
     * encoded string.
     */

attribute AUTF8String host;

pub unsafe fn GetPort(&self, aPort: *mut int32_t) -> nsresult

/**
     * A port value of -1 corresponds to the protocol's default port (eg. -1
     * implies port 80 for http URIs).
     */

attribute long port;

pub unsafe fn SetPort(&self, aPort: int32_t) -> nsresult

/**
     * A port value of -1 corresponds to the protocol's default port (eg. -1
     * implies port 80 for http URIs).
     */

attribute long port;

pub unsafe fn GetPathQueryRef(&self, aPathQueryRef: &mut nsACString) -> nsresult

/**
     * The path, typically including at least a leading '/' (but may also be
     * empty, depending on the protocol).
     *
     * Some characters may be escaped.
     *
     * This attribute contains query and ref parts for historical reasons.
     * Use the 'filePath' attribute if you do not want those parts included.
     */

attribute AUTF8String pathQueryRef;

pub unsafe fn SetPathQueryRef(&self, aPathQueryRef: &nsACString) -> nsresult

/**
     * The path, typically including at least a leading '/' (but may also be
     * empty, depending on the protocol).
     *
     * Some characters may be escaped.
     *
     * This attribute contains query and ref parts for historical reasons.
     * Use the 'filePath' attribute if you do not want those parts included.
     */

attribute AUTF8String pathQueryRef;

pub unsafe fn Equals(
    &self,
    other: *const nsIURI,
    _retval: *mut bool
) -> nsresult

/************************************************************************
     * An URI supports the following methods:
     */
/**
     * URI equivalence test (not a strict string comparison).
     *
     * eg. http://foo.com:80/ == http://foo.com/
     */

boolean equals (in nsIURI other);

pub unsafe fn SchemeIs(
    &self,
    scheme: *const c_char,
    _retval: *mut bool
) -> nsresult

/**
     * An optimization to do scheme checks without requiring the users of nsIURI
     * to GetScheme, thereby saving extra allocating and freeing. Returns true if
     * the schemes match (case ignored).
     */

boolean schemeIs (in string scheme);

pub unsafe fn Clone(&self, _retval: *mut *const nsIURI) -> nsresult

/**
     * Clones the current URI.
     */

nsIURI clone ();

pub unsafe fn Resolve(
    &self,
    relativePath: &nsACString,
    _retval: &mut nsACString
) -> nsresult

/**
     * This method resolves a relative string into an absolute URI string,
     * using this URI as the base.
     *
     * NOTE: some implementations may have no concept of a relative URI.
     */

AUTF8String resolve (in AUTF8String relativePath);

pub unsafe fn GetAsciiSpec(&self, aAsciiSpec: &mut nsACString) -> nsresult

/************************************************************************
     * Additional attributes:
     */
/**
     * The URI spec with an ASCII compatible encoding.  Host portion follows
     * the IDNA draft spec.  Other parts are URL-escaped per the rules of
     * RFC2396.  The result is strictly ASCII.
     */

readonly attribute ACString asciiSpec;

pub unsafe fn GetAsciiHostPort(
    &self,
    aAsciiHostPort: &mut nsACString
) -> nsresult

/**
     * The host:port (or simply the host, if port == -1), with an ASCII compatible
     * encoding.  Host portion follows the IDNA draft spec.  The result is strictly
     * ASCII.
     */

readonly attribute ACString asciiHostPort;

pub unsafe fn GetAsciiHost(&self, aAsciiHost: &mut nsACString) -> nsresult

/**
     * The URI host with an ASCII compatible encoding.  Follows the IDNA
     * draft spec for converting internationalized domain names (UTF-8) to
     * ASCII for compatibility with existing internet infrasture.
     */

readonly attribute ACString asciiHost;

pub unsafe fn GetRef(&self, aRef: &mut nsACString) -> nsresult

/************************************************************************
     * Additional attribute & methods added for .ref support:
     */
/**
     * Returns the reference portion (the part after the "#") of the URI.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String ref;

pub unsafe fn SetRef(&self, aRef: &nsACString) -> nsresult

/************************************************************************
     * Additional attribute & methods added for .ref support:
     */
/**
     * Returns the reference portion (the part after the "#") of the URI.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String ref;

pub unsafe fn EqualsExceptRef(
    &self,
    other: *const nsIURI,
    _retval: *mut bool
) -> nsresult

/**
     * URI equivalence test (not a strict string comparison), ignoring
     * the value of the .ref member.
     *
     * eg. http://foo.com/# == http://foo.com/
     *     http://foo.com/#aaa == http://foo.com/#bbb
     */

boolean equalsExceptRef (in nsIURI other);

pub unsafe fn CloneIgnoringRef(&self, _retval: *mut *const nsIURI) -> nsresult

/**
     * Clones the current URI, clearing the 'ref' attribute in the clone.
     */

nsIURI cloneIgnoringRef ();

pub unsafe fn CloneWithNewRef(
    &self,
    newRef: &nsACString,
    _retval: *mut *const nsIURI
) -> nsresult

/**
     * Clones the current URI, replacing the 'ref' attribute in the clone with
     * the ref supplied.
     */

nsIURI cloneWithNewRef (in AUTF8String newRef);

pub unsafe fn GetSpecIgnoringRef(
    &self,
    aSpecIgnoringRef: &mut nsACString
) -> nsresult

/**
     * returns a string for the current URI with the ref element cleared.
     */

readonly attribute AUTF8String specIgnoringRef;

pub unsafe fn GetHasRef(&self, aHasRef: *mut bool) -> nsresult

/**
     * Returns if there is a reference portion (the part after the "#") of the URI.
     */

readonly attribute boolean hasRef;

pub unsafe fn GetFilePath(&self, aFilePath: &mut nsACString) -> nsresult

/************************************************************************
     * Additional attributes added for .query support:
     */
/**
     * Returns a path including the directory and file portions of a
     * URL.  For example, the filePath of "http://host/foo/bar.html#baz"
     * is "/foo/bar.html".
     *
     * Some characters may be escaped.
     */

attribute AUTF8String filePath;

pub unsafe fn SetFilePath(&self, aFilePath: &nsACString) -> nsresult

/************************************************************************
     * Additional attributes added for .query support:
     */
/**
     * Returns a path including the directory and file portions of a
     * URL.  For example, the filePath of "http://host/foo/bar.html#baz"
     * is "/foo/bar.html".
     *
     * Some characters may be escaped.
     */

attribute AUTF8String filePath;

pub unsafe fn GetQuery(&self, aQuery: &mut nsACString) -> nsresult

/**
     * Returns the query portion (the part after the "?") of the URL.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String query;

pub unsafe fn SetQuery(&self, aQuery: &nsACString) -> nsresult

/**
     * Returns the query portion (the part after the "?") of the URL.
     * If there isn't one, an empty string is returned.
     *
     * Some characters may be escaped.
     */

attribute AUTF8String query;

pub unsafe fn GetDisplayHost(&self, aDisplayHost: &mut nsACString) -> nsresult

/**
     * If the URI has a punycode encoded hostname, this will hold the UTF8
     * representation of that hostname (if that representation doesn't contain
     * blacklisted characters, and the network.IDN_show_punycode pref is false)
     * Otherwise, if the hostname is ASCII, it will return the same as .asciiHost
     */

readonly attribute AUTF8String displayHost;

pub unsafe fn GetDisplayHostPort(
    &self,
    aDisplayHostPort: &mut nsACString
) -> nsresult

/**
     * The displayHost:port (or simply the displayHost, if port == -1).
     */

readonly attribute AUTF8String displayHostPort;

pub unsafe fn GetDisplaySpec(&self, aDisplaySpec: &mut nsACString) -> nsresult

/**
     * Returns the same as calling .spec, only with a UTF8 encoded hostname
     * (if that hostname doesn't contain blacklisted characters, and
     * the network.IDN_show_punycode pref is false)
     */

readonly attribute AUTF8String displaySpec;

pub unsafe fn GetDisplayPrePath(
    &self,
    aDisplayPrePath: &mut nsACString
) -> nsresult

/**
     * Returns the same as calling .prePath, only with a UTF8 encoded hostname
     * (if that hostname doesn't contain blacklisted characters, and
     * the network.IDN_show_punycode pref is false)
     */

readonly attribute AUTF8String displayPrePath;

pub unsafe fn Mutate(&self, _retval: *mut *const nsIURIMutator) -> nsresult

/**
     * Returns an nsIURIMutator that can be used to make changes to the URI.
     * After performing the setter operations on the mutator, one may call
     * mutator.finalize() to get a new immutable URI with the desired
     * properties.
     */

nsIURIMutator mutate ();

Trait Implementations

impl XpCom for nsIMozIconURI

const IID: nsIID

IID: nsIID = nsID(4177420018, 24363, 17395, [133, 125, 91, 100, 209, 146, 196, 39])

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 nsIMozIconURI

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIMozIconURI

type Target = nsIURI

The resulting type after dereferencing.

fn deref(&self) -> &nsIURI

Dereferences the value.