mozilla-central/__GENERATED__/dist/xpcrs/rt/nsILegacyJumpListItem.rs

Copy as Markdown

Other Tools

//
// DO NOT EDIT. THIS FILE IS GENERATED FROM $SRCDIR/widget/nsILegacyJumpListItem.idl
//
/// `interface nsILegacyJumpListItem : nsISupports`
///
/// ```text
/// /**
/// * Implements Win7 Taskbar jump list item interfaces.
/// *
/// * Note to consumers: it's reasonable to expect we'll need support for other types
/// * of jump list items (an audio file, an email message, etc.). To add types,
/// * create the specific interface here, add an implementation class to WinJumpListItem,
/// * and add support to addListBuild & removed items processing.
/// *
/// */
/// ```
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsILegacyJumpListItem {
vtable: &'static nsILegacyJumpListItemVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsILegacyJumpListItem.
unsafe impl XpCom for nsILegacyJumpListItem {
const IID: nsIID = nsID(0xacb8fb3c, 0xe1b0, 0x4044,
[0x8a, 0x50, 0xe5, 0x2c, 0x3e, 0x7c, 0x10, 0x57]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsILegacyJumpListItem {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsILegacyJumpListItem.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsILegacyJumpListItemCoerce {
/// Cheaply cast a value of this type from a `nsILegacyJumpListItem`.
fn coerce_from(v: &nsILegacyJumpListItem) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsILegacyJumpListItemCoerce for nsILegacyJumpListItem {
#[inline]
fn coerce_from(v: &nsILegacyJumpListItem) -> &Self {
v
}
}
impl nsILegacyJumpListItem {
/// Cast this `nsILegacyJumpListItem` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsILegacyJumpListItemCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsILegacyJumpListItem {
type Target = nsISupports;
#[inline]
fn deref(&self) -> &nsISupports {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsILegacyJumpListItemCoerce for T {
#[inline]
fn coerce_from(v: &nsILegacyJumpListItem) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsILegacyJumpListItem
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsILegacyJumpListItemVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsISupportsVTable,
/* readonly attribute short type; */
pub GetType: unsafe extern "system" fn (this: *const nsILegacyJumpListItem, aType: *mut i16) -> ::nserror::nsresult,
/* boolean equals (in nsILegacyJumpListItem item); */
pub Equals: unsafe extern "system" fn (this: *const nsILegacyJumpListItem, item: *const nsILegacyJumpListItem, _retval: *mut bool) -> ::nserror::nsresult,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsILegacyJumpListItem {
pub const JUMPLIST_ITEM_EMPTY: i16 = 0;
pub const JUMPLIST_ITEM_SEPARATOR: i16 = 1;
pub const JUMPLIST_ITEM_LINK: i16 = 2;
pub const JUMPLIST_ITEM_SHORTCUT: i16 = 3;
/// ```text
/// /**
/// * Retrieves the jump list item type.
/// */
/// ```
///
/// `readonly attribute short type;`
#[inline]
pub unsafe fn GetType(&self, aType: *mut i16) -> ::nserror::nsresult {
((*self.vtable).GetType)(self, aType)
}
/// ```text
/// /**
/// * Compare this item to another.
/// *
/// * Compares the type and other properties specific to this item's
/// * type.
/// *
/// * separator: type
/// * link: type, uri, title
/// * shortcut: type, handler app
/// */
/// ```
///
/// `boolean equals (in nsILegacyJumpListItem item);`
#[inline]
pub unsafe fn Equals(&self, item: *const nsILegacyJumpListItem, _retval: *mut bool) -> ::nserror::nsresult {
((*self.vtable).Equals)(self, item, _retval)
}
}
/// `interface nsILegacyJumpListSeparator : nsILegacyJumpListItem`
///
/// ```text
/// /**
/// * A menu separator.
/// */
/// ```
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsILegacyJumpListSeparator {
vtable: &'static nsILegacyJumpListSeparatorVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsILegacyJumpListSeparator.
unsafe impl XpCom for nsILegacyJumpListSeparator {
const IID: nsIID = nsID(0x69a2d5c5, 0x14dc, 0x47da,
[0x92, 0x5d, 0x86, 0x9e, 0x0b, 0xd6, 0x4d, 0x27]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsILegacyJumpListSeparator {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsILegacyJumpListSeparator.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsILegacyJumpListSeparatorCoerce {
/// Cheaply cast a value of this type from a `nsILegacyJumpListSeparator`.
fn coerce_from(v: &nsILegacyJumpListSeparator) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsILegacyJumpListSeparatorCoerce for nsILegacyJumpListSeparator {
#[inline]
fn coerce_from(v: &nsILegacyJumpListSeparator) -> &Self {
v
}
}
impl nsILegacyJumpListSeparator {
/// Cast this `nsILegacyJumpListSeparator` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsILegacyJumpListSeparatorCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsILegacyJumpListSeparator {
type Target = nsILegacyJumpListItem;
#[inline]
fn deref(&self) -> &nsILegacyJumpListItem {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsILegacyJumpListItemCoerce> nsILegacyJumpListSeparatorCoerce for T {
#[inline]
fn coerce_from(v: &nsILegacyJumpListSeparator) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsILegacyJumpListSeparator
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsILegacyJumpListSeparatorVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsILegacyJumpListItemVTable,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsILegacyJumpListSeparator {
}
/// `interface nsILegacyJumpListLink : nsILegacyJumpListItem`
///
/// ```text
/// /**
/// * A URI link jump list item.
/// *
/// * Note the application must be the registered protocol
/// * handler for the protocol of the link.
/// */
/// ```
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsILegacyJumpListLink {
vtable: &'static nsILegacyJumpListLinkVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsILegacyJumpListLink.
unsafe impl XpCom for nsILegacyJumpListLink {
const IID: nsIID = nsID(0x76ea47b1, 0xc797, 0x49b3,
[0x9f, 0x18, 0x5e, 0x74, 0x0a, 0x68, 0x85, 0x24]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsILegacyJumpListLink {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsILegacyJumpListLink.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsILegacyJumpListLinkCoerce {
/// Cheaply cast a value of this type from a `nsILegacyJumpListLink`.
fn coerce_from(v: &nsILegacyJumpListLink) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsILegacyJumpListLinkCoerce for nsILegacyJumpListLink {
#[inline]
fn coerce_from(v: &nsILegacyJumpListLink) -> &Self {
v
}
}
impl nsILegacyJumpListLink {
/// Cast this `nsILegacyJumpListLink` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsILegacyJumpListLinkCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsILegacyJumpListLink {
type Target = nsILegacyJumpListItem;
#[inline]
fn deref(&self) -> &nsILegacyJumpListItem {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsILegacyJumpListItemCoerce> nsILegacyJumpListLinkCoerce for T {
#[inline]
fn coerce_from(v: &nsILegacyJumpListLink) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsILegacyJumpListLink
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsILegacyJumpListLinkVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsILegacyJumpListItemVTable,
/* attribute nsIURI uri; */
pub GetUri: unsafe extern "system" fn (this: *const nsILegacyJumpListLink, aUri: *mut*const nsIURI) -> ::nserror::nsresult,
/* attribute nsIURI uri; */
pub SetUri: unsafe extern "system" fn (this: *const nsILegacyJumpListLink, aUri: *const nsIURI) -> ::nserror::nsresult,
/* attribute AString uriTitle; */
pub GetUriTitle: unsafe extern "system" fn (this: *const nsILegacyJumpListLink, aUriTitle: *mut ::nsstring::nsAString) -> ::nserror::nsresult,
/* attribute AString uriTitle; */
pub SetUriTitle: unsafe extern "system" fn (this: *const nsILegacyJumpListLink, aUriTitle: *const ::nsstring::nsAString) -> ::nserror::nsresult,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsILegacyJumpListLink {
/// ```text
/// /**
/// * Set or get the uri for this link item.
/// */
/// ```
///
/// `attribute nsIURI uri;`
#[inline]
pub unsafe fn GetUri(&self, aUri: *mut*const nsIURI) -> ::nserror::nsresult {
((*self.vtable).GetUri)(self, aUri)
}
/// ```text
/// /**
/// * Set or get the uri for this link item.
/// */
/// ```
///
/// `attribute nsIURI uri;`
#[inline]
pub unsafe fn SetUri(&self, aUri: *const nsIURI) -> ::nserror::nsresult {
((*self.vtable).SetUri)(self, aUri)
}
/// ```text
/// /**
/// * Set or get the title for a link item.
/// */
/// ```
///
/// `attribute AString uriTitle;`
#[inline]
pub unsafe fn GetUriTitle(&self, aUriTitle: *mut ::nsstring::nsAString) -> ::nserror::nsresult {
((*self.vtable).GetUriTitle)(self, aUriTitle)
}
/// ```text
/// /**
/// * Set or get the title for a link item.
/// */
/// ```
///
/// `attribute AString uriTitle;`
#[inline]
pub unsafe fn SetUriTitle(&self, aUriTitle: *const ::nsstring::nsAString) -> ::nserror::nsresult {
((*self.vtable).SetUriTitle)(self, aUriTitle)
}
}
/// `interface nsILegacyJumpListShortcut : nsILegacyJumpListItem`
///
/// ```text
/// /**
/// * A generic application shortcut with command line support.
/// */
/// ```
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsILegacyJumpListShortcut {
vtable: &'static nsILegacyJumpListShortcutVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsILegacyJumpListShortcut.
unsafe impl XpCom for nsILegacyJumpListShortcut {
const IID: nsIID = nsID(0xcbe3a37c, 0xbce1, 0x4fec,
[0x80, 0xa5, 0x5f, 0xfb, 0xc7, 0xf3, 0x3e, 0xea]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsILegacyJumpListShortcut {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsILegacyJumpListShortcut.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsILegacyJumpListShortcutCoerce {
/// Cheaply cast a value of this type from a `nsILegacyJumpListShortcut`.
fn coerce_from(v: &nsILegacyJumpListShortcut) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsILegacyJumpListShortcutCoerce for nsILegacyJumpListShortcut {
#[inline]
fn coerce_from(v: &nsILegacyJumpListShortcut) -> &Self {
v
}
}
impl nsILegacyJumpListShortcut {
/// Cast this `nsILegacyJumpListShortcut` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsILegacyJumpListShortcutCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsILegacyJumpListShortcut {
type Target = nsILegacyJumpListItem;
#[inline]
fn deref(&self) -> &nsILegacyJumpListItem {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsILegacyJumpListItemCoerce> nsILegacyJumpListShortcutCoerce for T {
#[inline]
fn coerce_from(v: &nsILegacyJumpListShortcut) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsILegacyJumpListShortcut
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsILegacyJumpListShortcutVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsILegacyJumpListItemVTable,
/* attribute nsILocalHandlerApp app; */
pub GetApp: unsafe extern "system" fn (this: *const nsILegacyJumpListShortcut, aApp: *mut*const nsILocalHandlerApp) -> ::nserror::nsresult,
/* attribute nsILocalHandlerApp app; */
pub SetApp: unsafe extern "system" fn (this: *const nsILegacyJumpListShortcut, aApp: *const nsILocalHandlerApp) -> ::nserror::nsresult,
/* attribute long iconIndex; */
pub GetIconIndex: unsafe extern "system" fn (this: *const nsILegacyJumpListShortcut, aIconIndex: *mut i32) -> ::nserror::nsresult,
/* attribute long iconIndex; */
pub SetIconIndex: unsafe extern "system" fn (this: *const nsILegacyJumpListShortcut, aIconIndex: i32) -> ::nserror::nsresult,
/* attribute nsIURI faviconPageUri; */
pub GetFaviconPageUri: unsafe extern "system" fn (this: *const nsILegacyJumpListShortcut, aFaviconPageUri: *mut*const nsIURI) -> ::nserror::nsresult,
/* attribute nsIURI faviconPageUri; */
pub SetFaviconPageUri: unsafe extern "system" fn (this: *const nsILegacyJumpListShortcut, aFaviconPageUri: *const nsIURI) -> ::nserror::nsresult,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsILegacyJumpListShortcut {
/// ```text
/// /**
/// * Set or get the handler app for this shortcut item.
/// *
/// * The handler app may also be used along with iconIndex to generate an icon
/// * for the jump list item.
/// *
/// * @throw NS_ERROR_FILE_NOT_FOUND if the handler app can
/// * not be found on the system.
/// *
/// * @see faviconPageUri
/// */
/// ```
///
/// `attribute nsILocalHandlerApp app;`
#[inline]
pub unsafe fn GetApp(&self, aApp: *mut*const nsILocalHandlerApp) -> ::nserror::nsresult {
((*self.vtable).GetApp)(self, aApp)
}
/// ```text
/// /**
/// * Set or get the handler app for this shortcut item.
/// *
/// * The handler app may also be used along with iconIndex to generate an icon
/// * for the jump list item.
/// *
/// * @throw NS_ERROR_FILE_NOT_FOUND if the handler app can
/// * not be found on the system.
/// *
/// * @see faviconPageUri
/// */
/// ```
///
/// `attribute nsILocalHandlerApp app;`
#[inline]
pub unsafe fn SetApp(&self, aApp: *const nsILocalHandlerApp) -> ::nserror::nsresult {
((*self.vtable).SetApp)(self, aApp)
}
/// ```text
/// /**
/// * Set or get the icon displayed with the jump list item.
/// *
/// * Indicates the resource index of the icon contained within the handler
/// * executable which may be used as the jump list icon.
/// *
/// * @see faviconPageUri
/// */
/// ```
///
/// `attribute long iconIndex;`
#[inline]
pub unsafe fn GetIconIndex(&self, aIconIndex: *mut i32) -> ::nserror::nsresult {
((*self.vtable).GetIconIndex)(self, aIconIndex)
}
/// ```text
/// /**
/// * Set or get the icon displayed with the jump list item.
/// *
/// * Indicates the resource index of the icon contained within the handler
/// * executable which may be used as the jump list icon.
/// *
/// * @see faviconPageUri
/// */
/// ```
///
/// `attribute long iconIndex;`
#[inline]
pub unsafe fn SetIconIndex(&self, aIconIndex: i32) -> ::nserror::nsresult {
((*self.vtable).SetIconIndex)(self, aIconIndex)
}
/// ```text
/// /**
/// * Set or get the URI of a page whose favicon may be used as the icon.
/// *
/// * When a jump list build occurs, the favicon to be used for the item is
/// * obtained using the following steps:
/// * - First, attempt to use the asynchronously retrieved and scaled favicon
/// * associated with the faviconPageUri.
/// * - If faviconPageUri is null, or if retrieving the favicon fails, fall
/// * back to using the handler executable and iconIndex.
/// */
/// ```
///
/// `attribute nsIURI faviconPageUri;`
#[inline]
pub unsafe fn GetFaviconPageUri(&self, aFaviconPageUri: *mut*const nsIURI) -> ::nserror::nsresult {
((*self.vtable).GetFaviconPageUri)(self, aFaviconPageUri)
}
/// ```text
/// /**
/// * Set or get the URI of a page whose favicon may be used as the icon.
/// *
/// * When a jump list build occurs, the favicon to be used for the item is
/// * obtained using the following steps:
/// * - First, attempt to use the asynchronously retrieved and scaled favicon
/// * associated with the faviconPageUri.
/// * - If faviconPageUri is null, or if retrieving the favicon fails, fall
/// * back to using the handler executable and iconIndex.
/// */
/// ```
///
/// `attribute nsIURI faviconPageUri;`
#[inline]
pub unsafe fn SetFaviconPageUri(&self, aFaviconPageUri: *const nsIURI) -> ::nserror::nsresult {
((*self.vtable).SetFaviconPageUri)(self, aFaviconPageUri)
}
}