//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsIContentViewer.idl
//


/// `interface nsIContentViewer : nsISupports`
///


// 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 nsIContentViewer {
    vtable: *const nsIContentViewerVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// 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 nsIContentViewer.
unsafe impl XpCom for nsIContentViewer {
    const IID: nsIID = nsID(0x2da17016, 0x7851, 0x4a45,
        [0xa7, 0xa8, 0x00, 0xb3, 0x60, 0xe0, 0x15, 0x95]);
}

// 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 nsIContentViewer {
    #[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 nsIContentViewer.
// 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 nsIContentViewerCoerce {
    /// Cheaply cast a value of this type from a `nsIContentViewer`.
    fn coerce_from(v: &nsIContentViewer) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIContentViewerCoerce for nsIContentViewer {
    #[inline]
    fn coerce_from(v: &nsIContentViewer) -> &Self {
        v
    }
}

impl nsIContentViewer {
    /// Cast this `nsIContentViewer` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIContentViewerCoerce>(&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 nsIContentViewer {
    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> nsIContentViewerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIContentViewer) -> &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 nsIContentViewer
// 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 nsIContentViewerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* [noscript] void init (in nsIWidgetPtr aParentWidget, [const] in nsIntRectRef aBounds); */
    /// Unable to generate binding because `native type nsIWidget is unsupported`
    pub Init: *const ::libc::c_void,

    /* attribute nsIDocShell container; */
    pub GetContainer: unsafe extern "system" fn (this: *const nsIContentViewer, aContainer: *mut *const nsIDocShell) -> nsresult,

    /* attribute nsIDocShell container; */
    pub SetContainer: unsafe extern "system" fn (this: *const nsIContentViewer, aContainer: *const nsIDocShell) -> nsresult,

    /* [noscript,nostdcall,notxpcom] void loadStart (in nsIDocument aDoc); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub LoadStart: *const ::libc::c_void,

    /* void loadComplete (in nsresult aStatus); */
    pub LoadComplete: unsafe extern "system" fn (this: *const nsIContentViewer, aStatus: nsresult) -> nsresult,

    /* [noscript] readonly attribute boolean loadCompleted; */
    pub GetLoadCompleted: unsafe extern "system" fn (this: *const nsIContentViewer, aLoadCompleted: *mut bool) -> nsresult,

    /* [noscript] readonly attribute boolean isStopped; */
    pub GetIsStopped: unsafe extern "system" fn (this: *const nsIContentViewer, aIsStopped: *mut bool) -> nsresult,

    /* boolean permitUnload ([optional] in unsigned long aPermitUnloadFlags); */
    pub PermitUnload: unsafe extern "system" fn (this: *const nsIContentViewer, aPermitUnloadFlags: libc::uint32_t, _retval: *mut bool) -> nsresult,

    /* readonly attribute boolean inPermitUnload; */
    pub GetInPermitUnload: unsafe extern "system" fn (this: *const nsIContentViewer, aInPermitUnload: *mut bool) -> nsresult,

    /* [noscript,nostdcall] boolean permitUnloadInternal (inout unsigned long aPermitUnloadFlags); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub PermitUnloadInternal: *const ::libc::c_void,

    /* readonly attribute boolean beforeUnloadFiring; */
    pub GetBeforeUnloadFiring: unsafe extern "system" fn (this: *const nsIContentViewer, aBeforeUnloadFiring: *mut bool) -> nsresult,

    /* void pageHide (in boolean isUnload); */
    pub PageHide: unsafe extern "system" fn (this: *const nsIContentViewer, isUnload: bool) -> nsresult,

    /* void close (in nsISHEntry historyEntry); */
    pub Close: unsafe extern "system" fn (this: *const nsIContentViewer, historyEntry: *const nsISHEntry) -> nsresult,

    /* void destroy (); */
    pub Destroy: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* void stop (); */
    pub Stop: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* attribute nsIDOMDocument DOMDocument; */
    pub GetDOMDocument: unsafe extern "system" fn (this: *const nsIContentViewer, aDOMDocument: *mut *const nsIDOMDocument) -> nsresult,

    /* attribute nsIDOMDocument DOMDocument; */
    pub SetDOMDocument: unsafe extern "system" fn (this: *const nsIContentViewer, aDOMDocument: *const nsIDOMDocument) -> nsresult,

    /* [noscript,notxpcom] nsIDocument getDocument (); */
    pub GetDocument: unsafe extern "system" fn (this: *const nsIContentViewer) -> *const nsIDocument,

    /* [noscript] void getBounds (in nsIntRectRef aBounds); */
    /// Unable to generate binding because `native type nsIntRect is unsupported`
    pub GetBounds: *const ::libc::c_void,

    /* [noscript] void setBounds ([const] in nsIntRectRef aBounds); */
    /// Unable to generate binding because `native type nsIntRect is unsupported`
    pub SetBounds: *const ::libc::c_void,

    /* [noscript] void setBoundsWithFlags ([const] in nsIntRectRef aBounds, in unsigned long aFlags); */
    /// Unable to generate binding because `native type nsIntRect is unsupported`
    pub SetBoundsWithFlags: *const ::libc::c_void,

    /* [noscript] attribute nsIContentViewer previousViewer; */
    pub GetPreviousViewer: unsafe extern "system" fn (this: *const nsIContentViewer, aPreviousViewer: *mut *const nsIContentViewer) -> nsresult,

    /* [noscript] attribute nsIContentViewer previousViewer; */
    pub SetPreviousViewer: unsafe extern "system" fn (this: *const nsIContentViewer, aPreviousViewer: *const nsIContentViewer) -> nsresult,

    /* void move (in long aX, in long aY); */
    pub Move: unsafe extern "system" fn (this: *const nsIContentViewer, aX: libc::int32_t, aY: libc::int32_t) -> nsresult,

    /* void show (); */
    pub Show: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* void hide (); */
    pub Hide: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* attribute boolean sticky; */
    pub GetSticky: unsafe extern "system" fn (this: *const nsIContentViewer, aSticky: *mut bool) -> nsresult,

    /* attribute boolean sticky; */
    pub SetSticky: unsafe extern "system" fn (this: *const nsIContentViewer, aSticky: bool) -> nsresult,

    /* boolean requestWindowClose (); */
    pub RequestWindowClose: unsafe extern "system" fn (this: *const nsIContentViewer, _retval: *mut bool) -> nsresult,

    /* void open (in nsISupports aState, in nsISHEntry aSHEntry); */
    pub Open: unsafe extern "system" fn (this: *const nsIContentViewer, aState: *const nsISupports, aSHEntry: *const nsISHEntry) -> nsresult,

    /* void clearHistoryEntry (); */
    pub ClearHistoryEntry: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* void setPageMode (in boolean aPageMode, in nsIPrintSettings aPrintSettings); */
    pub SetPageMode: unsafe extern "system" fn (this: *const nsIContentViewer, aPageMode: bool, aPrintSettings: *const nsIPrintSettings) -> nsresult,

    /* readonly attribute nsISHEntry historyEntry; */
    pub GetHistoryEntry: unsafe extern "system" fn (this: *const nsIContentViewer, aHistoryEntry: *mut *const nsISHEntry) -> nsresult,

    /* readonly attribute boolean isTabModalPromptAllowed; */
    pub GetIsTabModalPromptAllowed: unsafe extern "system" fn (this: *const nsIContentViewer, aIsTabModalPromptAllowed: *mut bool) -> nsresult,

    /* attribute boolean isHidden; */
    pub GetIsHidden: unsafe extern "system" fn (this: *const nsIContentViewer, aIsHidden: *mut bool) -> nsresult,

    /* attribute boolean isHidden; */
    pub SetIsHidden: unsafe extern "system" fn (this: *const nsIContentViewer, aIsHidden: bool) -> nsresult,

    /* [noscript] readonly attribute nsIPresShellPtr presShell; */
    /// Unable to generate binding because `native type nsIPresShell is unsupported`
    pub GetPresShell: *const ::libc::c_void,

    /* [noscript] readonly attribute nsPresContextPtr presContext; */
    /// Unable to generate binding because `native type nsPresContext is unsupported`
    pub GetPresContext: *const ::libc::c_void,

    /* [noscript] void setDocumentInternal (in nsIDocument aDocument, in boolean aForceReuseInnerWindow); */
    pub SetDocumentInternal: unsafe extern "system" fn (this: *const nsIContentViewer, aDocument: *const nsIDocument, aForceReuseInnerWindow: bool) -> nsresult,

    /* [noscript,nostdcall,notxpcom] nsViewPtr findContainerView (); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub FindContainerView: *const ::libc::c_void,

    /* [noscript,nostdcall,notxpcom] void setNavigationTiming (in nsDOMNavigationTimingPtr aTiming); */
    /// Unable to generate binding because `native type nsDOMNavigationTiming is unsupported`
    pub SetNavigationTiming: *const ::libc::c_void,

    /* void scrollToNode (in nsIDOMNode node); */
    pub ScrollToNode: unsafe extern "system" fn (this: *const nsIContentViewer, node: *const nsIDOMNode) -> nsresult,

    /* attribute float textZoom; */
    pub GetTextZoom: unsafe extern "system" fn (this: *const nsIContentViewer, aTextZoom: *mut libc::c_float) -> nsresult,

    /* attribute float textZoom; */
    pub SetTextZoom: unsafe extern "system" fn (this: *const nsIContentViewer, aTextZoom: libc::c_float) -> nsresult,

    /* readonly attribute float effectiveTextZoom; */
    pub GetEffectiveTextZoom: unsafe extern "system" fn (this: *const nsIContentViewer, aEffectiveTextZoom: *mut libc::c_float) -> nsresult,

    /* attribute float fullZoom; */
    pub GetFullZoom: unsafe extern "system" fn (this: *const nsIContentViewer, aFullZoom: *mut libc::c_float) -> nsresult,

    /* attribute float fullZoom; */
    pub SetFullZoom: unsafe extern "system" fn (this: *const nsIContentViewer, aFullZoom: libc::c_float) -> nsresult,

    /* readonly attribute float deviceFullZoom; */
    pub GetDeviceFullZoom: unsafe extern "system" fn (this: *const nsIContentViewer, aDeviceFullZoom: *mut libc::c_float) -> nsresult,

    /* attribute float overrideDPPX; */
    pub GetOverrideDPPX: unsafe extern "system" fn (this: *const nsIContentViewer, aOverrideDPPX: *mut libc::c_float) -> nsresult,

    /* attribute float overrideDPPX; */
    pub SetOverrideDPPX: unsafe extern "system" fn (this: *const nsIContentViewer, aOverrideDPPX: libc::c_float) -> nsresult,

    /* attribute boolean authorStyleDisabled; */
    pub GetAuthorStyleDisabled: unsafe extern "system" fn (this: *const nsIContentViewer, aAuthorStyleDisabled: *mut bool) -> nsresult,

    /* attribute boolean authorStyleDisabled; */
    pub SetAuthorStyleDisabled: unsafe extern "system" fn (this: *const nsIContentViewer, aAuthorStyleDisabled: bool) -> nsresult,

    /* attribute ACString forceCharacterSet; */
    pub GetForceCharacterSet: unsafe extern "system" fn (this: *const nsIContentViewer, aForceCharacterSet: &mut ::nsstring::nsACString) -> nsresult,

    /* attribute ACString forceCharacterSet; */
    pub SetForceCharacterSet: unsafe extern "system" fn (this: *const nsIContentViewer, aForceCharacterSet: &::nsstring::nsACString) -> nsresult,

    /* attribute ACString hintCharacterSet; */
    pub GetHintCharacterSet: unsafe extern "system" fn (this: *const nsIContentViewer, aHintCharacterSet: &mut ::nsstring::nsACString) -> nsresult,

    /* attribute ACString hintCharacterSet; */
    pub SetHintCharacterSet: unsafe extern "system" fn (this: *const nsIContentViewer, aHintCharacterSet: &::nsstring::nsACString) -> nsresult,

    /* attribute int32_t hintCharacterSetSource; */
    pub GetHintCharacterSetSource: unsafe extern "system" fn (this: *const nsIContentViewer, aHintCharacterSetSource: *mut int32_t) -> nsresult,

    /* attribute int32_t hintCharacterSetSource; */
    pub SetHintCharacterSetSource: unsafe extern "system" fn (this: *const nsIContentViewer, aHintCharacterSetSource: int32_t) -> nsresult,

    /* void getContentSize (out long width, out long height); */
    pub GetContentSize: unsafe extern "system" fn (this: *const nsIContentViewer, width: *mut libc::int32_t, height: *mut libc::int32_t) -> nsresult,

    /* void getContentSizeConstrained (in long maxWidth, in long maxHeight, out long width, out long height); */
    pub GetContentSizeConstrained: unsafe extern "system" fn (this: *const nsIContentViewer, maxWidth: libc::int32_t, maxHeight: libc::int32_t, width: *mut libc::int32_t, height: *mut libc::int32_t) -> nsresult,

    /* attribute long minFontSize; */
    pub GetMinFontSize: unsafe extern "system" fn (this: *const nsIContentViewer, aMinFontSize: *mut libc::int32_t) -> nsresult,

    /* attribute long minFontSize; */
    pub SetMinFontSize: unsafe extern "system" fn (this: *const nsIContentViewer, aMinFontSize: libc::int32_t) -> nsresult,

    /* [noscript] void appendSubtree (in nsIContentViewerTArray array); */
    /// Unable to generate binding because `native type nsTArray<nsCOMPtr<nsIContentViewer> > is unsupported`
    pub AppendSubtree: *const ::libc::c_void,

    /* void pausePainting (); */
    pub PausePainting: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* void resumePainting (); */
    pub ResumePainting: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* void emulateMedium (in AString aMediaType); */
    pub EmulateMedium: unsafe extern "system" fn (this: *const nsIContentViewer, aMediaType: &::nsstring::nsAString) -> nsresult,

    /* void stopEmulatingMedium (); */
    pub StopEmulatingMedium: unsafe extern "system" fn (this: *const nsIContentViewer) -> nsresult,

    /* [noscript,notxpcom] Encoding getHintCharset (); */
    /// Unable to generate binding because `native type const mozilla::Encoding is unsupported`
    pub GetHintCharset: *const ::libc::c_void,

    /* [noscript,notxpcom] void setHintCharset (in Encoding aEncoding); */
    /// Unable to generate binding because `native type const mozilla::Encoding is unsupported`
    pub SetHintCharset: *const ::libc::c_void,

    /* [noscript,notxpcom] Encoding getForceCharset (); */
    /// Unable to generate binding because `native type const mozilla::Encoding is unsupported`
    pub GetForceCharset: *const ::libc::c_void,

    /* [noscript,notxpcom] void setForceCharset (in Encoding aEncoding); */
    /// Unable to generate binding because `native type const mozilla::Encoding is unsupported`
    pub SetForceCharset: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIContentViewer {
    /// ```text
    /// /**
    ///    * aPermitUnloadFlags are passed to PermitUnload to indicate what action to take
    ///    * if a beforeunload handler wants to prompt the user.  It is also used by
    ///    * permitUnloadInternal to ensure we only prompt once.
    ///    *
    ///    * ePrompt: Prompt and return the user's choice (default).
    ///    * eDontPromptAndDontUnload: Don't prompt and return false (unload not permitted)
    ///    *                           if the document (or its children) asks us to prompt.
    ///    * eDontPromptAndUnload: Don't prompt and return true (unload permitted) no matter what.
    ///    */
    /// ```
    ///

    pub const ePrompt: i64 = 0;


    pub const eDontPromptAndDontUnload: i64 = 1;


    pub const eDontPromptAndUnload: i64 = 2;

    /// ```text
    /// /**
    ///    * The 'aFlags' argument to setBoundsWithFlags is a set of these bits.
    ///    */
    /// ```
    ///

    pub const eDelayResize: i64 = 1;


    /// `[noscript] void init (in nsIWidgetPtr aParentWidget, [const] in nsIntRectRef aBounds);`
    const _Init: () = ();


    /// `attribute nsIDocShell container;`
    #[inline]
    pub unsafe fn GetContainer(&self, aContainer: *mut *const nsIDocShell) -> nsresult {
        ((*self.vtable).GetContainer)(self, aContainer)
    }



    /// `attribute nsIDocShell container;`
    #[inline]
    pub unsafe fn SetContainer(&self, aContainer: *const nsIDocShell) -> nsresult {
        ((*self.vtable).SetContainer)(self, aContainer)
    }



    /// `[noscript,nostdcall,notxpcom] void loadStart (in nsIDocument aDoc);`
    const _LoadStart: () = ();


    /// `void loadComplete (in nsresult aStatus);`
    #[inline]
    pub unsafe fn LoadComplete(&self, aStatus: nsresult) -> nsresult {
        ((*self.vtable).LoadComplete)(self, aStatus)
    }



    /// `[noscript] readonly attribute boolean loadCompleted;`
    #[inline]
    pub unsafe fn GetLoadCompleted(&self, aLoadCompleted: *mut bool) -> nsresult {
        ((*self.vtable).GetLoadCompleted)(self, aLoadCompleted)
    }



    /// `[noscript] readonly attribute boolean isStopped;`
    #[inline]
    pub unsafe fn GetIsStopped(&self, aIsStopped: *mut bool) -> nsresult {
        ((*self.vtable).GetIsStopped)(self, aIsStopped)
    }


    /// ```text
    /// /**
    ///    * Overload PermitUnload method for C++ consumers with no aPermitUnloadFlags
    ///    * argument.
    ///    */
    /// /**
    ///    * Checks if the document wants to prevent unloading by firing beforeunload on
    ///    * the document, and if it does, takes action directed by aPermitUnloadFlags.
    ///    * The result is returned.
    ///    */
    /// ```
    ///

    /// `boolean permitUnload ([optional] in unsigned long aPermitUnloadFlags);`
    #[inline]
    pub unsafe fn PermitUnload(&self, aPermitUnloadFlags: libc::uint32_t, _retval: *mut bool) -> nsresult {
        ((*self.vtable).PermitUnload)(self, aPermitUnloadFlags, _retval)
    }


    /// ```text
    /// /**
    ///    * Exposes whether we're blocked in a call to permitUnload.
    ///    */
    /// ```
    ///

    /// `readonly attribute boolean inPermitUnload;`
    #[inline]
    pub unsafe fn GetInPermitUnload(&self, aInPermitUnload: *mut bool) -> nsresult {
        ((*self.vtable).GetInPermitUnload)(self, aInPermitUnload)
    }


    /// ```text
    /// /**
    ///    * As above, but this passes around the aPermitUnloadFlags argument to keep
    ///    * track of whether the user has responded to a prompt.
    ///    * Used internally by the scriptable version to ensure we only prompt once.
    ///    */
    /// ```
    ///

    /// `[noscript,nostdcall] boolean permitUnloadInternal (inout unsigned long aPermitUnloadFlags);`
    const _PermitUnloadInternal: () = ();

    /// ```text
    /// /**
    ///    * Exposes whether we're in the process of firing the beforeunload event.
    ///    * In this case, the corresponding docshell will not allow navigation.
    ///    */
    /// ```
    ///

    /// `readonly attribute boolean beforeUnloadFiring;`
    #[inline]
    pub unsafe fn GetBeforeUnloadFiring(&self, aBeforeUnloadFiring: *mut bool) -> nsresult {
        ((*self.vtable).GetBeforeUnloadFiring)(self, aBeforeUnloadFiring)
    }



    /// `void pageHide (in boolean isUnload);`
    #[inline]
    pub unsafe fn PageHide(&self, isUnload: bool) -> nsresult {
        ((*self.vtable).PageHide)(self, isUnload)
    }


    /// ```text
    /// /**
    ///    * All users of a content viewer are responsible for calling both
    ///    * close() and destroy(), in that order.
    ///    *
    ///    * close() should be called when the load of a new page for the next
    ///    * content viewer begins, and destroy() should be called when the next
    ///    * content viewer replaces this one.
    ///    *
    ///    * |historyEntry| sets the session history entry for the content viewer.  If
    ///    * this is null, then Destroy() will be called on the document by close().
    ///    * If it is non-null, the document will not be destroyed, and the following
    ///    * actions will happen when destroy() is called (*):
    ///    *  - Sanitize() will be called on the viewer's document
    ///    *  - The content viewer will set the contentViewer property on the
    ///    *    history entry, and release its reference (ownership reversal).
    ///    *  - hide() will be called, and no further destruction will happen.
    ///    *
    ///    *  (*) unless the document is currently being printed, in which case
    ///    *      it will never be saved in session history.
    ///    *
    ///    */
    /// ```
    ///

    /// `void close (in nsISHEntry historyEntry);`
    #[inline]
    pub unsafe fn Close(&self, historyEntry: *const nsISHEntry) -> nsresult {
        ((*self.vtable).Close)(self, historyEntry)
    }



    /// `void destroy ();`
    #[inline]
    pub unsafe fn Destroy(&self, ) -> nsresult {
        ((*self.vtable).Destroy)(self, )
    }



    /// `void stop ();`
    #[inline]
    pub unsafe fn Stop(&self, ) -> nsresult {
        ((*self.vtable).Stop)(self, )
    }



    /// `attribute nsIDOMDocument DOMDocument;`
    #[inline]
    pub unsafe fn GetDOMDocument(&self, aDOMDocument: *mut *const nsIDOMDocument) -> nsresult {
        ((*self.vtable).GetDOMDocument)(self, aDOMDocument)
    }



    /// `attribute nsIDOMDocument DOMDocument;`
    #[inline]
    pub unsafe fn SetDOMDocument(&self, aDOMDocument: *const nsIDOMDocument) -> nsresult {
        ((*self.vtable).SetDOMDocument)(self, aDOMDocument)
    }


    /// ```text
    /// /**
    ///    * Returns DOMDocument as nsIDocument and without addrefing.
    ///    */
    /// ```
    ///

    /// `[noscript,notxpcom] nsIDocument getDocument ();`
    #[inline]
    pub unsafe fn GetDocument(&self, ) -> *const nsIDocument {
        ((*self.vtable).GetDocument)(self, )
    }



    /// `[noscript] void getBounds (in nsIntRectRef aBounds);`
    const _GetBounds: () = ();


    /// `[noscript] void setBounds ([const] in nsIntRectRef aBounds);`
    const _SetBounds: () = ();


    /// `[noscript] void setBoundsWithFlags ([const] in nsIntRectRef aBounds, in unsigned long aFlags);`
    const _SetBoundsWithFlags: () = ();

    /// ```text
    /// /**
    ///    * The previous content viewer, which has been |close|d but not
    ///    * |destroy|ed.
    ///    */
    /// ```
    ///

    /// `[noscript] attribute nsIContentViewer previousViewer;`
    #[inline]
    pub unsafe fn GetPreviousViewer(&self, aPreviousViewer: *mut *const nsIContentViewer) -> nsresult {
        ((*self.vtable).GetPreviousViewer)(self, aPreviousViewer)
    }


    /// ```text
    /// /**
    ///    * The previous content viewer, which has been |close|d but not
    ///    * |destroy|ed.
    ///    */
    /// ```
    ///

    /// `[noscript] attribute nsIContentViewer previousViewer;`
    #[inline]
    pub unsafe fn SetPreviousViewer(&self, aPreviousViewer: *const nsIContentViewer) -> nsresult {
        ((*self.vtable).SetPreviousViewer)(self, aPreviousViewer)
    }



    /// `void move (in long aX, in long aY);`
    #[inline]
    pub unsafe fn Move(&self, aX: libc::int32_t, aY: libc::int32_t) -> nsresult {
        ((*self.vtable).Move)(self, aX, aY)
    }



    /// `void show ();`
    #[inline]
    pub unsafe fn Show(&self, ) -> nsresult {
        ((*self.vtable).Show)(self, )
    }



    /// `void hide ();`
    #[inline]
    pub unsafe fn Hide(&self, ) -> nsresult {
        ((*self.vtable).Hide)(self, )
    }



    /// `attribute boolean sticky;`
    #[inline]
    pub unsafe fn GetSticky(&self, aSticky: *mut bool) -> nsresult {
        ((*self.vtable).GetSticky)(self, aSticky)
    }



    /// `attribute boolean sticky;`
    #[inline]
    pub unsafe fn SetSticky(&self, aSticky: bool) -> nsresult {
        ((*self.vtable).SetSticky)(self, aSticky)
    }



    /// `boolean requestWindowClose ();`
    #[inline]
    pub unsafe fn RequestWindowClose(&self, _retval: *mut bool) -> nsresult {
        ((*self.vtable).RequestWindowClose)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Attach the content viewer to its DOM window and docshell.
    ///    * @param aState A state object that might be useful in attaching the DOM
    ///    *               window.
    ///    * @param aSHEntry The history entry that the content viewer was stored in.
    ///    *                 The entry must have the docshells for all of the child
    ///    *                 documents stored in its child shell list.
    ///    */
    /// ```
    ///

    /// `void open (in nsISupports aState, in nsISHEntry aSHEntry);`
    #[inline]
    pub unsafe fn Open(&self, aState: *const nsISupports, aSHEntry: *const nsISHEntry) -> nsresult {
        ((*self.vtable).Open)(self, aState, aSHEntry)
    }


    /// ```text
    /// /**
    ///    * Clears the current history entry.  This is used if we need to clear out
    ///    * the saved presentation state.
    ///    */
    /// ```
    ///

    /// `void clearHistoryEntry ();`
    #[inline]
    pub unsafe fn ClearHistoryEntry(&self, ) -> nsresult {
        ((*self.vtable).ClearHistoryEntry)(self, )
    }


    /// ```text
    /// /**
    ///    * Change the layout to view the document with page layout (like print preview), but
    ///    * dynamic and editable (like Galley layout).
    ///    */
    /// ```
    ///

    /// `void setPageMode (in boolean aPageMode, in nsIPrintSettings aPrintSettings);`
    #[inline]
    pub unsafe fn SetPageMode(&self, aPageMode: bool, aPrintSettings: *const nsIPrintSettings) -> nsresult {
        ((*self.vtable).SetPageMode)(self, aPageMode, aPrintSettings)
    }


    /// ```text
    /// /**
    ///    * Get the history entry that this viewer will save itself into when
    ///    * destroyed.  Can return null
    ///    */
    /// ```
    ///

    /// `readonly attribute nsISHEntry historyEntry;`
    #[inline]
    pub unsafe fn GetHistoryEntry(&self, aHistoryEntry: *mut *const nsISHEntry) -> nsresult {
        ((*self.vtable).GetHistoryEntry)(self, aHistoryEntry)
    }


    /// ```text
    /// /**
    ///    * Indicates when we're in a state where content shouldn't be allowed to
    ///    * trigger a tab-modal prompt (as opposed to a window-modal prompt) because
    ///    * we're part way through some operation (eg beforeunload) that shouldn't be
    ///    * rentrant if the user closes the tab while the prompt is showing.
    ///    * See bug 613800.
    ///    */
    /// ```
    ///

    /// `readonly attribute boolean isTabModalPromptAllowed;`
    #[inline]
    pub unsafe fn GetIsTabModalPromptAllowed(&self, aIsTabModalPromptAllowed: *mut bool) -> nsresult {
        ((*self.vtable).GetIsTabModalPromptAllowed)(self, aIsTabModalPromptAllowed)
    }


    /// ```text
    /// /**
    ///    * Returns whether this content viewer is in a hidden state.
    ///    *
    ///    * @note Only Gecko internal code should set the attribute!
    ///    */
    /// ```
    ///

    /// `attribute boolean isHidden;`
    #[inline]
    pub unsafe fn GetIsHidden(&self, aIsHidden: *mut bool) -> nsresult {
        ((*self.vtable).GetIsHidden)(self, aIsHidden)
    }


    /// ```text
    /// /**
    ///    * Returns whether this content viewer is in a hidden state.
    ///    *
    ///    * @note Only Gecko internal code should set the attribute!
    ///    */
    /// ```
    ///

    /// `attribute boolean isHidden;`
    #[inline]
    pub unsafe fn SetIsHidden(&self, aIsHidden: bool) -> nsresult {
        ((*self.vtable).SetIsHidden)(self, aIsHidden)
    }



    /// `[noscript] readonly attribute nsIPresShellPtr presShell;`
    const _GetPresShell: () = ();


    /// `[noscript] readonly attribute nsPresContextPtr presContext;`
    const _GetPresContext: () = ();


    /// `[noscript] void setDocumentInternal (in nsIDocument aDocument, in boolean aForceReuseInnerWindow);`
    #[inline]
    pub unsafe fn SetDocumentInternal(&self, aDocument: *const nsIDocument, aForceReuseInnerWindow: bool) -> nsresult {
        ((*self.vtable).SetDocumentInternal)(self, aDocument, aForceReuseInnerWindow)
    }


    /// ```text
    /// /**
    ///    * Find the view to use as the container view for MakeWindow. Returns
    ///    * null if this will be the root of a view manager hierarchy. In that
    ///    * case, if mParentWidget is null then this document should not even
    ///    * be displayed.
    ///    */
    /// ```
    ///

    /// `[noscript,nostdcall,notxpcom] nsViewPtr findContainerView ();`
    const _FindContainerView: () = ();

    /// ```text
    /// /**
    ///    * Set collector for navigation timing data (load, unload events).
    ///    */
    /// ```
    ///

    /// `[noscript,nostdcall,notxpcom] void setNavigationTiming (in nsDOMNavigationTimingPtr aTiming);`
    const _SetNavigationTiming: () = ();


    /// `void scrollToNode (in nsIDOMNode node);`
    #[inline]
    pub unsafe fn ScrollToNode(&self, node: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).ScrollToNode)(self, node)
    }


    /// ```text
    /// /** The amount by which to scale all text. Default is 1.0. */
    /// ```
    ///

    /// `attribute float textZoom;`
    #[inline]
    pub unsafe fn GetTextZoom(&self, aTextZoom: *mut libc::c_float) -> nsresult {
        ((*self.vtable).GetTextZoom)(self, aTextZoom)
    }


    /// ```text
    /// /** The amount by which to scale all text. Default is 1.0. */
    /// ```
    ///

    /// `attribute float textZoom;`
    #[inline]
    pub unsafe fn SetTextZoom(&self, aTextZoom: libc::c_float) -> nsresult {
        ((*self.vtable).SetTextZoom)(self, aTextZoom)
    }


    /// ```text
    /// /** The actual text zoom in effect, as modified by the system font scale. */
    /// ```
    ///

    /// `readonly attribute float effectiveTextZoom;`
    #[inline]
    pub unsafe fn GetEffectiveTextZoom(&self, aEffectiveTextZoom: *mut libc::c_float) -> nsresult {
        ((*self.vtable).GetEffectiveTextZoom)(self, aEffectiveTextZoom)
    }


    /// ```text
    /// /** The amount by which to scale all lengths. Default is 1.0. */
    /// ```
    ///

    /// `attribute float fullZoom;`
    #[inline]
    pub unsafe fn GetFullZoom(&self, aFullZoom: *mut libc::c_float) -> nsresult {
        ((*self.vtable).GetFullZoom)(self, aFullZoom)
    }


    /// ```text
    /// /** The amount by which to scale all lengths. Default is 1.0. */
    /// ```
    ///

    /// `attribute float fullZoom;`
    #[inline]
    pub unsafe fn SetFullZoom(&self, aFullZoom: libc::c_float) -> nsresult {
        ((*self.vtable).SetFullZoom)(self, aFullZoom)
    }


    /// ```text
    /// /**
    ///    * The actual full zoom in effect, as modified by the device context.
    ///    * For a requested full zoom, the device context may choose a slightly
    ///    * different effectiveFullZoom to accomodate integer rounding of app units
    ///    * per dev pixel. This property returns the actual zoom amount in use,
    ///    * though it may not be good user experience to report that a requested zoom
    ///    * of 90% is actually 89.1%, for example. This value is provided primarily to
    ///    * support media queries of dppx values, because those queries are matched
    ///    * against the actual native device pixel ratio and the actual full zoom.
    ///    */
    /// ```
    ///

    /// `readonly attribute float deviceFullZoom;`
    #[inline]
    pub unsafe fn GetDeviceFullZoom(&self, aDeviceFullZoom: *mut libc::c_float) -> nsresult {
        ((*self.vtable).GetDeviceFullZoom)(self, aDeviceFullZoom)
    }


    /// ```text
    /// /**
    ///    * The value used to override devicePixelRatio and media queries dppx.
    ///    * Default is 0.0, that means no overriding is done (only a positive value
        ///    * is applied).
    ///    */
    /// ```
    ///

    /// `attribute float overrideDPPX;`
    #[inline]
    pub unsafe fn GetOverrideDPPX(&self, aOverrideDPPX: *mut libc::c_float) -> nsresult {
        ((*self.vtable).GetOverrideDPPX)(self, aOverrideDPPX)
    }


    /// ```text
    /// /**
    ///    * The value used to override devicePixelRatio and media queries dppx.
    ///    * Default is 0.0, that means no overriding is done (only a positive value
        ///    * is applied).
    ///    */
    /// ```
    ///

    /// `attribute float overrideDPPX;`
    #[inline]
    pub unsafe fn SetOverrideDPPX(&self, aOverrideDPPX: libc::c_float) -> nsresult {
        ((*self.vtable).SetOverrideDPPX)(self, aOverrideDPPX)
    }


    /// ```text
    /// /** Disable entire author style level (including HTML presentation hints) */
    /// ```
    ///

    /// `attribute boolean authorStyleDisabled;`
    #[inline]
    pub unsafe fn GetAuthorStyleDisabled(&self, aAuthorStyleDisabled: *mut bool) -> nsresult {
        ((*self.vtable).GetAuthorStyleDisabled)(self, aAuthorStyleDisabled)
    }


    /// ```text
    /// /** Disable entire author style level (including HTML presentation hints) */
    /// ```
    ///

    /// `attribute boolean authorStyleDisabled;`
    #[inline]
    pub unsafe fn SetAuthorStyleDisabled(&self, aAuthorStyleDisabled: bool) -> nsresult {
        ((*self.vtable).SetAuthorStyleDisabled)(self, aAuthorStyleDisabled)
    }


    /// ```text
    /// /**
    ///    * XXX comm-central only: bug 829543. Not the Character Encoding menu in
    ///    * browser!
    ///    */
    /// ```
    ///

    /// `attribute ACString forceCharacterSet;`
    #[inline]
    pub unsafe fn GetForceCharacterSet(&self, aForceCharacterSet: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetForceCharacterSet)(self, aForceCharacterSet)
    }


    /// ```text
    /// /**
    ///    * XXX comm-central only: bug 829543. Not the Character Encoding menu in
    ///    * browser!
    ///    */
    /// ```
    ///

    /// `attribute ACString forceCharacterSet;`
    #[inline]
    pub unsafe fn SetForceCharacterSet(&self, aForceCharacterSet: &::nsstring::nsACString) -> nsresult {
        ((*self.vtable).SetForceCharacterSet)(self, aForceCharacterSet)
    }


    /// ```text
    /// /**
    ///    * XXX comm-central only: bug 829543.
    ///    */
    /// ```
    ///

    /// `attribute ACString hintCharacterSet;`
    #[inline]
    pub unsafe fn GetHintCharacterSet(&self, aHintCharacterSet: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetHintCharacterSet)(self, aHintCharacterSet)
    }


    /// ```text
    /// /**
    ///    * XXX comm-central only: bug 829543.
    ///    */
    /// ```
    ///

    /// `attribute ACString hintCharacterSet;`
    #[inline]
    pub unsafe fn SetHintCharacterSet(&self, aHintCharacterSet: &::nsstring::nsACString) -> nsresult {
        ((*self.vtable).SetHintCharacterSet)(self, aHintCharacterSet)
    }


    /// ```text
    /// /**
    ///    * XXX comm-central only: bug 829543.
    ///    */
    /// ```
    ///

    /// `attribute int32_t hintCharacterSetSource;`
    #[inline]
    pub unsafe fn GetHintCharacterSetSource(&self, aHintCharacterSetSource: *mut int32_t) -> nsresult {
        ((*self.vtable).GetHintCharacterSetSource)(self, aHintCharacterSetSource)
    }


    /// ```text
    /// /**
    ///    * XXX comm-central only: bug 829543.
    ///    */
    /// ```
    ///

    /// `attribute int32_t hintCharacterSetSource;`
    #[inline]
    pub unsafe fn SetHintCharacterSetSource(&self, aHintCharacterSetSource: int32_t) -> nsresult {
        ((*self.vtable).SetHintCharacterSetSource)(self, aHintCharacterSetSource)
    }


    /// ```text
    /// /**
    ///    * Requests the size of the content to the container.
    ///    */
    /// ```
    ///

    /// `void getContentSize (out long width, out long height);`
    #[inline]
    pub unsafe fn GetContentSize(&self, width: *mut libc::int32_t, height: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetContentSize)(self, width, height)
    }


    /// ```text
    /// /**
    ///    * Returns the preferred width and height of the content, constrained to the
    ///    * given maximum values. If either maxWidth or maxHeight is less than zero,
    ///    * that dimension is not constrained.
    ///    *
    ///    * All input and output values are in device pixels, rather than CSS pixels.
    ///    */
    /// ```
    ///

    /// `void getContentSizeConstrained (in long maxWidth, in long maxHeight, out long width, out long height);`
    #[inline]
    pub unsafe fn GetContentSizeConstrained(&self, maxWidth: libc::int32_t, maxHeight: libc::int32_t, width: *mut libc::int32_t, height: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetContentSizeConstrained)(self, maxWidth, maxHeight, width, height)
    }


    /// ```text
    /// /** The minimum font size  */
    /// ```
    ///

    /// `attribute long minFontSize;`
    #[inline]
    pub unsafe fn GetMinFontSize(&self, aMinFontSize: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetMinFontSize)(self, aMinFontSize)
    }


    /// ```text
    /// /** The minimum font size  */
    /// ```
    ///

    /// `attribute long minFontSize;`
    #[inline]
    pub unsafe fn SetMinFontSize(&self, aMinFontSize: libc::int32_t) -> nsresult {
        ((*self.vtable).SetMinFontSize)(self, aMinFontSize)
    }


    /// ```text
    /// /**
    ///    * Append |this| and all of its descendants to the given array,
    ///    * in depth-first pre-order traversal.
    ///    */
    /// ```
    ///

    /// `[noscript] void appendSubtree (in nsIContentViewerTArray array);`
    const _AppendSubtree: () = ();

    /// ```text
    /// /**
    ///    * Instruct the refresh driver to discontinue painting until further
    ///    * notice.
    ///    */
    /// ```
    ///

    /// `void pausePainting ();`
    #[inline]
    pub unsafe fn PausePainting(&self, ) -> nsresult {
        ((*self.vtable).PausePainting)(self, )
    }


    /// ```text
    /// /**
    ///    * Instruct the refresh driver to resume painting after a previous call to
    ///    * pausePainting().
    ///    */
    /// ```
    ///

    /// `void resumePainting ();`
    #[inline]
    pub unsafe fn ResumePainting(&self, ) -> nsresult {
        ((*self.vtable).ResumePainting)(self, )
    }



    /// `void emulateMedium (in AString aMediaType);`
    #[inline]
    pub unsafe fn EmulateMedium(&self, aMediaType: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).EmulateMedium)(self, aMediaType)
    }



    /// `void stopEmulatingMedium ();`
    #[inline]
    pub unsafe fn StopEmulatingMedium(&self, ) -> nsresult {
        ((*self.vtable).StopEmulatingMedium)(self, )
    }



    /// `[noscript,notxpcom] Encoding getHintCharset ();`
    const _GetHintCharset: () = ();


    /// `[noscript,notxpcom] void setHintCharset (in Encoding aEncoding);`
    const _SetHintCharset: () = ();


    /// `[noscript,notxpcom] Encoding getForceCharset ();`
    const _GetForceCharset: () = ();


    /// `[noscript,notxpcom] void setForceCharset (in Encoding aEncoding);`
    const _SetForceCharset: () = ();

}