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


/// `interface nsIWebBrowserPrint : nsISupports`
///

/// ```text
/// /**
///  * nsIWebBrowserPrint corresponds to the main interface
///  * for printing an embedded Gecko web browser window/document
///  */
/// ```
///

// 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 nsIWebBrowserPrint {
    vtable: *const nsIWebBrowserPrintVTable,

    /// 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 nsIWebBrowserPrint.
unsafe impl XpCom for nsIWebBrowserPrint {
    const IID: nsIID = nsID(0xc9a934ed, 0xfff1, 0x4971,
        [0xbf, 0xba, 0x6c, 0x25, 0xad, 0x70, 0xe1, 0xe6]);
}

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

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

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

    /* readonly attribute nsIPrintSettings globalPrintSettings; */
    pub GetGlobalPrintSettings: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aGlobalPrintSettings: *mut *const nsIPrintSettings) -> nsresult,

    /* readonly attribute nsIPrintSettings currentPrintSettings; */
    pub GetCurrentPrintSettings: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aCurrentPrintSettings: *mut *const nsIPrintSettings) -> nsresult,

    /* readonly attribute mozIDOMWindowProxy currentChildDOMWindow; */
    pub GetCurrentChildDOMWindow: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aCurrentChildDOMWindow: *mut *const mozIDOMWindowProxy) -> nsresult,

    /* readonly attribute boolean doingPrint; */
    pub GetDoingPrint: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aDoingPrint: *mut bool) -> nsresult,

    /* readonly attribute boolean doingPrintPreview; */
    pub GetDoingPrintPreview: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aDoingPrintPreview: *mut bool) -> nsresult,

    /* readonly attribute boolean isFramesetDocument; */
    pub GetIsFramesetDocument: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aIsFramesetDocument: *mut bool) -> nsresult,

    /* readonly attribute boolean isFramesetFrameSelected; */
    pub GetIsFramesetFrameSelected: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aIsFramesetFrameSelected: *mut bool) -> nsresult,

    /* readonly attribute boolean isIFrameSelected; */
    pub GetIsIFrameSelected: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aIsIFrameSelected: *mut bool) -> nsresult,

    /* readonly attribute boolean isRangeSelection; */
    pub GetIsRangeSelection: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aIsRangeSelection: *mut bool) -> nsresult,

    /* readonly attribute long printPreviewNumPages; */
    pub GetPrintPreviewNumPages: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aPrintPreviewNumPages: *mut libc::int32_t) -> nsresult,

    /* void print (in nsIPrintSettings aThePrintSettings, in nsIWebProgressListener aWPListener); */
    pub Print: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aThePrintSettings: *const nsIPrintSettings, aWPListener: *const nsIWebProgressListener) -> nsresult,

    /* void printPreview (in nsIPrintSettings aThePrintSettings, in mozIDOMWindowProxy aChildDOMWin, in nsIWebProgressListener aWPListener); */
    pub PrintPreview: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aThePrintSettings: *const nsIPrintSettings, aChildDOMWin: *const mozIDOMWindowProxy, aWPListener: *const nsIWebProgressListener) -> nsresult,

    /* void printPreviewNavigate (in short aNavType, in long aPageNum); */
    pub PrintPreviewNavigate: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aNavType: libc::int16_t, aPageNum: libc::int32_t) -> nsresult,

    /* void cancel (); */
    pub Cancel: unsafe extern "system" fn (this: *const nsIWebBrowserPrint) -> nsresult,

    /* void enumerateDocumentNames (out uint32_t aCount, [array, size_is (aCount), retval] out wstring aResult); */
    pub EnumerateDocumentNames: unsafe extern "system" fn (this: *const nsIWebBrowserPrint, aCount: *mut uint32_t, aResult: *mut *mut *const libc::int16_t) -> nsresult,

    /* void exitPrintPreview (); */
    pub ExitPrintPreview: unsafe extern "system" fn (this: *const nsIWebBrowserPrint) -> 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 nsIWebBrowserPrint {
    /// ```text
    /// /**
    ///    * PrintPreview Navigation Constants
    ///    */
    /// ```
    ///

    pub const PRINTPREVIEW_GOTO_PAGENUM: i64 = 0;


    pub const PRINTPREVIEW_PREV_PAGE: i64 = 1;


    pub const PRINTPREVIEW_NEXT_PAGE: i64 = 2;


    pub const PRINTPREVIEW_HOME: i64 = 3;


    pub const PRINTPREVIEW_END: i64 = 4;

    /// ```text
    /// /**
    ///    * Returns a "global" PrintSettings object
    ///    * Creates a new the first time, if one doesn't exist.
    ///    *
    ///    * Then returns the same object each time after that.
    ///    *
    ///    * Initializes the globalPrintSettings from the default printer
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIPrintSettings globalPrintSettings;`
    #[inline]
    pub unsafe fn GetGlobalPrintSettings(&self, aGlobalPrintSettings: *mut *const nsIPrintSettings) -> nsresult {
        ((*self.vtable).GetGlobalPrintSettings)(self, aGlobalPrintSettings)
    }


    /// ```text
    /// /**
    ///    * Returns a pointer to the PrintSettings object that
    ///    * that was passed into either "print" or "print preview"
    ///    *
    ///    * This enables any consumers of the interface to have access
    ///    * to the "current" PrintSetting at later points in the execution
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIPrintSettings currentPrintSettings;`
    #[inline]
    pub unsafe fn GetCurrentPrintSettings(&self, aCurrentPrintSettings: *mut *const nsIPrintSettings) -> nsresult {
        ((*self.vtable).GetCurrentPrintSettings)(self, aCurrentPrintSettings)
    }


    /// ```text
    /// /**
    ///    * Returns a pointer to the current child DOMWindow
    ///    * that is being print previewed. (FrameSet Frames)
    ///    *
    ///    * Returns null if parent document is not a frameset or the entire FrameSet
    ///    * document is being print previewed
    ///    *
    ///    * This enables any consumers of the interface to have access
    ///    * to the "current" child DOMWindow at later points in the execution
    ///    */
    /// ```
    ///

    /// `readonly attribute mozIDOMWindowProxy currentChildDOMWindow;`
    #[inline]
    pub unsafe fn GetCurrentChildDOMWindow(&self, aCurrentChildDOMWindow: *mut *const mozIDOMWindowProxy) -> nsresult {
        ((*self.vtable).GetCurrentChildDOMWindow)(self, aCurrentChildDOMWindow)
    }


    /// ```text
    /// /**
    ///    * Returns whether it is in Print mode
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Returns whether it is in Print Preview mode
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This returns whether the current document is a frameset document
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This returns whether the current document is a frameset document
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This returns whether there is an IFrame selected
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This returns whether there is a "range" selection
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This returns the total number of pages for the Print Preview
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Print the specified DOM window
    ///    *
    ///    * @param aThePrintSettings - Printer Settings for the print job, if aThePrintSettings is null
    ///    *                            then the global PS will be used.
    ///    * @param aWPListener - is updated during the print
    ///    * @return void
    ///    */
    /// ```
    ///

    /// `void print (in nsIPrintSettings aThePrintSettings, in nsIWebProgressListener aWPListener);`
    #[inline]
    pub unsafe fn Print(&self, aThePrintSettings: *const nsIPrintSettings, aWPListener: *const nsIWebProgressListener) -> nsresult {
        ((*self.vtable).Print)(self, aThePrintSettings, aWPListener)
    }


    /// ```text
    /// /**
    ///    * Print Preview the specified DOM window
    ///    *
    ///    * @param aThePrintSettings - Printer Settings for the print preview, if aThePrintSettings is null
    ///    *                            then the global PS will be used.
    ///    * @param aChildDOMWin - DOM Window to be print previewed.
    ///    * @param aWPListener - is updated during the printpreview
    ///    * @return void
    ///    */
    /// ```
    ///

    /// `void printPreview (in nsIPrintSettings aThePrintSettings, in mozIDOMWindowProxy aChildDOMWin, in nsIWebProgressListener aWPListener);`
    #[inline]
    pub unsafe fn PrintPreview(&self, aThePrintSettings: *const nsIPrintSettings, aChildDOMWin: *const mozIDOMWindowProxy, aWPListener: *const nsIWebProgressListener) -> nsresult {
        ((*self.vtable).PrintPreview)(self, aThePrintSettings, aChildDOMWin, aWPListener)
    }


    /// ```text
    /// /**
    ///    * Print Preview - Navigates within the window
    ///    *
    ///    * @param aNavType - navigation enum
    ///    * @param aPageNum - page num to navigate to when aNavType = ePrintPreviewGoToPageNum
    ///    * @return void
    ///    */
    /// ```
    ///

    /// `void printPreviewNavigate (in short aNavType, in long aPageNum);`
    #[inline]
    pub unsafe fn PrintPreviewNavigate(&self, aNavType: libc::int16_t, aPageNum: libc::int32_t) -> nsresult {
        ((*self.vtable).PrintPreviewNavigate)(self, aNavType, aPageNum)
    }


    /// ```text
    /// /**
    ///    * Cancels the current print
    ///    * @return void
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Returns an array of the names of all documents names (Title or URL)
    ///    * and sub-documents. This will return a single item if the attr "isFramesetDocument" is false
    ///    * and may return any number of items is "isFramesetDocument" is true
    ///    *
    ///    * @param  aCount - returns number of printers returned
    ///    * @param  aResult - returns array of names
    ///    * @return void
    ///    */
    /// ```
    ///

    /// `void enumerateDocumentNames (out uint32_t aCount, [array, size_is (aCount), retval] out wstring aResult);`
    #[inline]
    pub unsafe fn EnumerateDocumentNames(&self, aCount: *mut uint32_t, aResult: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).EnumerateDocumentNames)(self, aCount, aResult)
    }


    /// ```text
    /// /**
    ///    * This exists PrintPreview mode and returns browser window to galley mode
    ///    * @return void
    ///    */
    /// ```
    ///

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


}