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


/// `interface nsIPrintSettings : nsISupports`
///

/// ```text
/// /**
///  * Simplified graphics interface for JS rendering.
///  */
/// ```
///

// 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 nsIPrintSettings {
    vtable: *const nsIPrintSettingsVTable,

    /// 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 nsIPrintSettings.
unsafe impl XpCom for nsIPrintSettings {
    const IID: nsIID = nsID(0xecc5cbad, 0x57fc, 0x4731,
        [0xb0, 0xbd, 0x09, 0xe8, 0x65, 0xbd, 0x62, 0xad]);
}

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

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

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

    /* void SetPrintOptions (in int32_t aType, in boolean aTurnOnOff); */
    pub SetPrintOptions: unsafe extern "system" fn (this: *const nsIPrintSettings, aType: int32_t, aTurnOnOff: bool) -> nsresult,

    /* boolean GetPrintOptions (in int32_t aType); */
    pub GetPrintOptions: unsafe extern "system" fn (this: *const nsIPrintSettings, aType: int32_t, _retval: *mut bool) -> nsresult,

    /* int32_t GetPrintOptionsBits (); */
    pub GetPrintOptionsBits: unsafe extern "system" fn (this: *const nsIPrintSettings, _retval: *mut int32_t) -> nsresult,

    /* void SetPrintOptionsBits (in int32_t bits); */
    pub SetPrintOptionsBits: unsafe extern "system" fn (this: *const nsIPrintSettings, bits: int32_t) -> nsresult,

    /* void GetEffectivePageSize (out double aWidth, out double aHeight); */
    pub GetEffectivePageSize: unsafe extern "system" fn (this: *const nsIPrintSettings, aWidth: *mut libc::c_double, aHeight: *mut libc::c_double) -> nsresult,

    /* nsIPrintSettings clone (); */
    pub Clone: unsafe extern "system" fn (this: *const nsIPrintSettings, _retval: *mut *const nsIPrintSettings) -> nsresult,

    /* void assign (in nsIPrintSettings aPS); */
    pub Assign: unsafe extern "system" fn (this: *const nsIPrintSettings, aPS: *const nsIPrintSettings) -> nsresult,

    /* [noscript] attribute nsIPrintSession printSession; */
    pub GetPrintSession: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintSession: *mut *const nsIPrintSession) -> nsresult,

    /* [noscript] attribute nsIPrintSession printSession; */
    pub SetPrintSession: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintSession: *const nsIPrintSession) -> nsresult,

    /* attribute long startPageRange; */
    pub GetStartPageRange: unsafe extern "system" fn (this: *const nsIPrintSettings, aStartPageRange: *mut libc::int32_t) -> nsresult,

    /* attribute long startPageRange; */
    pub SetStartPageRange: unsafe extern "system" fn (this: *const nsIPrintSettings, aStartPageRange: libc::int32_t) -> nsresult,

    /* attribute long endPageRange; */
    pub GetEndPageRange: unsafe extern "system" fn (this: *const nsIPrintSettings, aEndPageRange: *mut libc::int32_t) -> nsresult,

    /* attribute long endPageRange; */
    pub SetEndPageRange: unsafe extern "system" fn (this: *const nsIPrintSettings, aEndPageRange: libc::int32_t) -> nsresult,

    /* attribute double edgeTop; */
    pub GetEdgeTop: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeTop: *mut libc::c_double) -> nsresult,

    /* attribute double edgeTop; */
    pub SetEdgeTop: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeTop: libc::c_double) -> nsresult,

    /* attribute double edgeLeft; */
    pub GetEdgeLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeLeft: *mut libc::c_double) -> nsresult,

    /* attribute double edgeLeft; */
    pub SetEdgeLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeLeft: libc::c_double) -> nsresult,

    /* attribute double edgeBottom; */
    pub GetEdgeBottom: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeBottom: *mut libc::c_double) -> nsresult,

    /* attribute double edgeBottom; */
    pub SetEdgeBottom: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeBottom: libc::c_double) -> nsresult,

    /* attribute double edgeRight; */
    pub GetEdgeRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeRight: *mut libc::c_double) -> nsresult,

    /* attribute double edgeRight; */
    pub SetEdgeRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aEdgeRight: libc::c_double) -> nsresult,

    /* attribute double marginTop; */
    pub GetMarginTop: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginTop: *mut libc::c_double) -> nsresult,

    /* attribute double marginTop; */
    pub SetMarginTop: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginTop: libc::c_double) -> nsresult,

    /* attribute double marginLeft; */
    pub GetMarginLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginLeft: *mut libc::c_double) -> nsresult,

    /* attribute double marginLeft; */
    pub SetMarginLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginLeft: libc::c_double) -> nsresult,

    /* attribute double marginBottom; */
    pub GetMarginBottom: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginBottom: *mut libc::c_double) -> nsresult,

    /* attribute double marginBottom; */
    pub SetMarginBottom: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginBottom: libc::c_double) -> nsresult,

    /* attribute double marginRight; */
    pub GetMarginRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginRight: *mut libc::c_double) -> nsresult,

    /* attribute double marginRight; */
    pub SetMarginRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aMarginRight: libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginTop; */
    pub GetUnwriteableMarginTop: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginTop: *mut libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginTop; */
    pub SetUnwriteableMarginTop: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginTop: libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginLeft; */
    pub GetUnwriteableMarginLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginLeft: *mut libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginLeft; */
    pub SetUnwriteableMarginLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginLeft: libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginBottom; */
    pub GetUnwriteableMarginBottom: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginBottom: *mut libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginBottom; */
    pub SetUnwriteableMarginBottom: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginBottom: libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginRight; */
    pub GetUnwriteableMarginRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginRight: *mut libc::c_double) -> nsresult,

    /* attribute double unwriteableMarginRight; */
    pub SetUnwriteableMarginRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aUnwriteableMarginRight: libc::c_double) -> nsresult,

    /* attribute double scaling; */
    pub GetScaling: unsafe extern "system" fn (this: *const nsIPrintSettings, aScaling: *mut libc::c_double) -> nsresult,

    /* attribute double scaling; */
    pub SetScaling: unsafe extern "system" fn (this: *const nsIPrintSettings, aScaling: libc::c_double) -> nsresult,

    /* attribute boolean printBGColors; */
    pub GetPrintBGColors: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintBGColors: *mut bool) -> nsresult,

    /* attribute boolean printBGColors; */
    pub SetPrintBGColors: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintBGColors: bool) -> nsresult,

    /* attribute boolean printBGImages; */
    pub GetPrintBGImages: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintBGImages: *mut bool) -> nsresult,

    /* attribute boolean printBGImages; */
    pub SetPrintBGImages: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintBGImages: bool) -> nsresult,

    /* attribute short printRange; */
    pub GetPrintRange: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintRange: *mut libc::int16_t) -> nsresult,

    /* attribute short printRange; */
    pub SetPrintRange: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintRange: libc::int16_t) -> nsresult,

    /* attribute AString title; */
    pub GetTitle: unsafe extern "system" fn (this: *const nsIPrintSettings, aTitle: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString title; */
    pub SetTitle: unsafe extern "system" fn (this: *const nsIPrintSettings, aTitle: &::nsstring::nsAString) -> nsresult,

    /* attribute AString docURL; */
    pub GetDocURL: unsafe extern "system" fn (this: *const nsIPrintSettings, aDocURL: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString docURL; */
    pub SetDocURL: unsafe extern "system" fn (this: *const nsIPrintSettings, aDocURL: &::nsstring::nsAString) -> nsresult,

    /* attribute AString headerStrLeft; */
    pub GetHeaderStrLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aHeaderStrLeft: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString headerStrLeft; */
    pub SetHeaderStrLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aHeaderStrLeft: &::nsstring::nsAString) -> nsresult,

    /* attribute AString headerStrCenter; */
    pub GetHeaderStrCenter: unsafe extern "system" fn (this: *const nsIPrintSettings, aHeaderStrCenter: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString headerStrCenter; */
    pub SetHeaderStrCenter: unsafe extern "system" fn (this: *const nsIPrintSettings, aHeaderStrCenter: &::nsstring::nsAString) -> nsresult,

    /* attribute AString headerStrRight; */
    pub GetHeaderStrRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aHeaderStrRight: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString headerStrRight; */
    pub SetHeaderStrRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aHeaderStrRight: &::nsstring::nsAString) -> nsresult,

    /* attribute AString footerStrLeft; */
    pub GetFooterStrLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aFooterStrLeft: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString footerStrLeft; */
    pub SetFooterStrLeft: unsafe extern "system" fn (this: *const nsIPrintSettings, aFooterStrLeft: &::nsstring::nsAString) -> nsresult,

    /* attribute AString footerStrCenter; */
    pub GetFooterStrCenter: unsafe extern "system" fn (this: *const nsIPrintSettings, aFooterStrCenter: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString footerStrCenter; */
    pub SetFooterStrCenter: unsafe extern "system" fn (this: *const nsIPrintSettings, aFooterStrCenter: &::nsstring::nsAString) -> nsresult,

    /* attribute AString footerStrRight; */
    pub GetFooterStrRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aFooterStrRight: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString footerStrRight; */
    pub SetFooterStrRight: unsafe extern "system" fn (this: *const nsIPrintSettings, aFooterStrRight: &::nsstring::nsAString) -> nsresult,

    /* attribute short howToEnableFrameUI; */
    pub GetHowToEnableFrameUI: unsafe extern "system" fn (this: *const nsIPrintSettings, aHowToEnableFrameUI: *mut libc::int16_t) -> nsresult,

    /* attribute short howToEnableFrameUI; */
    pub SetHowToEnableFrameUI: unsafe extern "system" fn (this: *const nsIPrintSettings, aHowToEnableFrameUI: libc::int16_t) -> nsresult,

    /* attribute boolean isCancelled; */
    pub GetIsCancelled: unsafe extern "system" fn (this: *const nsIPrintSettings, aIsCancelled: *mut bool) -> nsresult,

    /* attribute boolean isCancelled; */
    pub SetIsCancelled: unsafe extern "system" fn (this: *const nsIPrintSettings, aIsCancelled: bool) -> nsresult,

    /* attribute short printFrameTypeUsage; */
    pub GetPrintFrameTypeUsage: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintFrameTypeUsage: *mut libc::int16_t) -> nsresult,

    /* attribute short printFrameTypeUsage; */
    pub SetPrintFrameTypeUsage: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintFrameTypeUsage: libc::int16_t) -> nsresult,

    /* attribute short printFrameType; */
    pub GetPrintFrameType: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintFrameType: *mut libc::int16_t) -> nsresult,

    /* attribute short printFrameType; */
    pub SetPrintFrameType: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintFrameType: libc::int16_t) -> nsresult,

    /* attribute boolean printSilent; */
    pub GetPrintSilent: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintSilent: *mut bool) -> nsresult,

    /* attribute boolean printSilent; */
    pub SetPrintSilent: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintSilent: bool) -> nsresult,

    /* attribute boolean shrinkToFit; */
    pub GetShrinkToFit: unsafe extern "system" fn (this: *const nsIPrintSettings, aShrinkToFit: *mut bool) -> nsresult,

    /* attribute boolean shrinkToFit; */
    pub SetShrinkToFit: unsafe extern "system" fn (this: *const nsIPrintSettings, aShrinkToFit: bool) -> nsresult,

    /* attribute boolean showPrintProgress; */
    pub GetShowPrintProgress: unsafe extern "system" fn (this: *const nsIPrintSettings, aShowPrintProgress: *mut bool) -> nsresult,

    /* attribute boolean showPrintProgress; */
    pub SetShowPrintProgress: unsafe extern "system" fn (this: *const nsIPrintSettings, aShowPrintProgress: bool) -> nsresult,

    /* attribute AString paperName; */
    pub GetPaperName: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperName: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString paperName; */
    pub SetPaperName: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperName: &::nsstring::nsAString) -> nsresult,

    /* attribute short paperData; */
    pub GetPaperData: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperData: *mut libc::int16_t) -> nsresult,

    /* attribute short paperData; */
    pub SetPaperData: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperData: libc::int16_t) -> nsresult,

    /* attribute double paperWidth; */
    pub GetPaperWidth: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperWidth: *mut libc::c_double) -> nsresult,

    /* attribute double paperWidth; */
    pub SetPaperWidth: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperWidth: libc::c_double) -> nsresult,

    /* attribute double paperHeight; */
    pub GetPaperHeight: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperHeight: *mut libc::c_double) -> nsresult,

    /* attribute double paperHeight; */
    pub SetPaperHeight: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperHeight: libc::c_double) -> nsresult,

    /* attribute short paperSizeUnit; */
    pub GetPaperSizeUnit: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperSizeUnit: *mut libc::int16_t) -> nsresult,

    /* attribute short paperSizeUnit; */
    pub SetPaperSizeUnit: unsafe extern "system" fn (this: *const nsIPrintSettings, aPaperSizeUnit: libc::int16_t) -> nsresult,

    /* attribute boolean printReversed; */
    pub GetPrintReversed: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintReversed: *mut bool) -> nsresult,

    /* attribute boolean printReversed; */
    pub SetPrintReversed: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintReversed: bool) -> nsresult,

    /* attribute boolean printInColor; */
    pub GetPrintInColor: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintInColor: *mut bool) -> nsresult,

    /* attribute boolean printInColor; */
    pub SetPrintInColor: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintInColor: bool) -> nsresult,

    /* attribute long orientation; */
    pub GetOrientation: unsafe extern "system" fn (this: *const nsIPrintSettings, aOrientation: *mut libc::int32_t) -> nsresult,

    /* attribute long orientation; */
    pub SetOrientation: unsafe extern "system" fn (this: *const nsIPrintSettings, aOrientation: libc::int32_t) -> nsresult,

    /* attribute long numCopies; */
    pub GetNumCopies: unsafe extern "system" fn (this: *const nsIPrintSettings, aNumCopies: *mut libc::int32_t) -> nsresult,

    /* attribute long numCopies; */
    pub SetNumCopies: unsafe extern "system" fn (this: *const nsIPrintSettings, aNumCopies: libc::int32_t) -> nsresult,

    /* attribute AString printerName; */
    pub GetPrinterName: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrinterName: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString printerName; */
    pub SetPrinterName: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrinterName: &::nsstring::nsAString) -> nsresult,

    /* attribute boolean printToFile; */
    pub GetPrintToFile: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintToFile: *mut bool) -> nsresult,

    /* attribute boolean printToFile; */
    pub SetPrintToFile: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintToFile: bool) -> nsresult,

    /* attribute AString toFileName; */
    pub GetToFileName: unsafe extern "system" fn (this: *const nsIPrintSettings, aToFileName: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString toFileName; */
    pub SetToFileName: unsafe extern "system" fn (this: *const nsIPrintSettings, aToFileName: &::nsstring::nsAString) -> nsresult,

    /* attribute short outputFormat; */
    pub GetOutputFormat: unsafe extern "system" fn (this: *const nsIPrintSettings, aOutputFormat: *mut libc::int16_t) -> nsresult,

    /* attribute short outputFormat; */
    pub SetOutputFormat: unsafe extern "system" fn (this: *const nsIPrintSettings, aOutputFormat: libc::int16_t) -> nsresult,

    /* attribute long printPageDelay; */
    pub GetPrintPageDelay: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintPageDelay: *mut libc::int32_t) -> nsresult,

    /* attribute long printPageDelay; */
    pub SetPrintPageDelay: unsafe extern "system" fn (this: *const nsIPrintSettings, aPrintPageDelay: libc::int32_t) -> nsresult,

    /* attribute long resolution; */
    pub GetResolution: unsafe extern "system" fn (this: *const nsIPrintSettings, aResolution: *mut libc::int32_t) -> nsresult,

    /* attribute long resolution; */
    pub SetResolution: unsafe extern "system" fn (this: *const nsIPrintSettings, aResolution: libc::int32_t) -> nsresult,

    /* attribute long duplex; */
    pub GetDuplex: unsafe extern "system" fn (this: *const nsIPrintSettings, aDuplex: *mut libc::int32_t) -> nsresult,

    /* attribute long duplex; */
    pub SetDuplex: unsafe extern "system" fn (this: *const nsIPrintSettings, aDuplex: libc::int32_t) -> nsresult,

    /* attribute boolean isInitializedFromPrinter; */
    pub GetIsInitializedFromPrinter: unsafe extern "system" fn (this: *const nsIPrintSettings, aIsInitializedFromPrinter: *mut bool) -> nsresult,

    /* attribute boolean isInitializedFromPrinter; */
    pub SetIsInitializedFromPrinter: unsafe extern "system" fn (this: *const nsIPrintSettings, aIsInitializedFromPrinter: bool) -> nsresult,

    /* attribute boolean isInitializedFromPrefs; */
    pub GetIsInitializedFromPrefs: unsafe extern "system" fn (this: *const nsIPrintSettings, aIsInitializedFromPrefs: *mut bool) -> nsresult,

    /* attribute boolean isInitializedFromPrefs; */
    pub SetIsInitializedFromPrefs: unsafe extern "system" fn (this: *const nsIPrintSettings, aIsInitializedFromPrefs: bool) -> nsresult,

    /* [noscript] void SetMarginInTwips (in nsNativeIntMarginRef aMargin); */
    /// Unable to generate binding because `native type nsIntMargin is unsupported`
    pub SetMarginInTwips: *const ::libc::c_void,

    /* [noscript] void SetEdgeInTwips (in nsNativeIntMarginRef aEdge); */
    /// Unable to generate binding because `native type nsIntMargin is unsupported`
    pub SetEdgeInTwips: *const ::libc::c_void,

    /* [noscript] void GetMarginInTwips (in nsNativeIntMarginRef aMargin); */
    /// Unable to generate binding because `native type nsIntMargin is unsupported`
    pub GetMarginInTwips: *const ::libc::c_void,

    /* [noscript] void GetEdgeInTwips (in nsNativeIntMarginRef aEdge); */
    /// Unable to generate binding because `native type nsIntMargin is unsupported`
    pub GetEdgeInTwips: *const ::libc::c_void,

    /* [noscript] void SetupSilentPrinting (); */
    pub SetupSilentPrinting: unsafe extern "system" fn (this: *const nsIPrintSettings) -> nsresult,

    /* [noscript] void SetUnwriteableMarginInTwips (in nsNativeIntMarginRef aEdge); */
    /// Unable to generate binding because `native type nsIntMargin is unsupported`
    pub SetUnwriteableMarginInTwips: *const ::libc::c_void,

    /* [noscript] void GetUnwriteableMarginInTwips (in nsNativeIntMarginRef aEdge); */
    /// Unable to generate binding because `native type nsIntMargin is unsupported`
    pub GetUnwriteableMarginInTwips: *const ::libc::c_void,

    /* [noscript] void GetPageRanges (in IntegerArray aPages); */
    /// Unable to generate binding because `native type nsTArray<int32_t> is unsupported`
    pub GetPageRanges: *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 nsIPrintSettings {
    /// ```text
    /// /**
    ///    * PrintSettings to be Saved Navigation Constants
    ///    */
    /// ```
    ///

    pub const kInitSaveOddEvenPages: i64 = 1;


    pub const kInitSaveHeaderLeft: i64 = 2;


    pub const kInitSaveHeaderCenter: i64 = 4;


    pub const kInitSaveHeaderRight: i64 = 8;


    pub const kInitSaveFooterLeft: i64 = 16;


    pub const kInitSaveFooterCenter: i64 = 32;


    pub const kInitSaveFooterRight: i64 = 64;


    pub const kInitSaveBGColors: i64 = 128;


    pub const kInitSaveBGImages: i64 = 256;


    pub const kInitSavePaperSize: i64 = 512;


    pub const kInitSaveResolution: i64 = 1024;


    pub const kInitSaveDuplex: i64 = 2048;


    pub const kInitSavePaperData: i64 = 8192;


    pub const kInitSaveUnwriteableMargins: i64 = 16384;


    pub const kInitSaveEdges: i64 = 32768;


    pub const kInitSaveReversed: i64 = 65536;


    pub const kInitSaveInColor: i64 = 131072;


    pub const kInitSaveOrientation: i64 = 262144;


    pub const kInitSavePrinterName: i64 = 1048576;


    pub const kInitSavePrintToFile: i64 = 2097152;


    pub const kInitSaveToFileName: i64 = 4194304;


    pub const kInitSavePageDelay: i64 = 8388608;


    pub const kInitSaveMargins: i64 = 16777216;


    pub const kInitSaveNativeData: i64 = 33554432;


    pub const kInitSaveShrinkToFit: i64 = 134217728;


    pub const kInitSaveScaling: i64 = 268435456;


    pub const kInitSaveAll: i64 = 4294967295;


    pub const kPrintOddPages: i64 = 1;


    pub const kPrintEvenPages: i64 = 2;


    pub const kEnableSelectionRB: i64 = 4;


    pub const kRangeAllPages: i64 = 0;


    pub const kRangeSpecifiedPageRange: i64 = 1;


    pub const kRangeSelection: i64 = 2;


    pub const kRangeFocusFrame: i64 = 3;


    pub const kJustLeft: i64 = 0;


    pub const kJustCenter: i64 = 1;


    pub const kJustRight: i64 = 2;

    /// ```text
    /// /**
    ///    * FrameSet Default Type Constants
    ///    */
    /// ```
    ///

    pub const kUseInternalDefault: i64 = 0;


    pub const kUseSettingWhenPossible: i64 = 1;

    /// ```text
    /// /**
    ///    * Page Size Type Constants
    ///    */
    /// ```
    ///

    pub const kPaperSizeNativeData: i64 = 0;


    pub const kPaperSizeDefined: i64 = 1;

    /// ```text
    /// /**
    ///    * Page Size Unit Constants
    ///    */
    /// ```
    ///

    pub const kPaperSizeInches: i64 = 0;


    pub const kPaperSizeMillimeters: i64 = 1;

    /// ```text
    /// /**
    ///    * Orientation Constants
    ///    */
    /// ```
    ///

    pub const kPortraitOrientation: i64 = 0;


    pub const kLandscapeOrientation: i64 = 1;

    /// ```text
    /// /**
    ///    * Print Frame Constants
    ///    */
    /// ```
    ///

    pub const kNoFrames: i64 = 0;


    pub const kFramesAsIs: i64 = 1;


    pub const kSelectedFrame: i64 = 2;


    pub const kEachFrameSep: i64 = 3;

    /// ```text
    /// /**
    ///    * How to Enable Frame Set Printing Constants
    ///    */
    /// ```
    ///

    pub const kFrameEnableNone: i64 = 0;


    pub const kFrameEnableAll: i64 = 1;


    pub const kFrameEnableAsIsAndEach: i64 = 2;

    /// ```text
    /// /**
    ///    * Output file format
    ///    */
    /// ```
    ///

    pub const kOutputFormatNative: i64 = 0;


    pub const kOutputFormatPS: i64 = 1;


    pub const kOutputFormatPDF: i64 = 2;

    /// ```text
    /// /**
    ///    * Set PrintOptions
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Get PrintOptions
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Get PrintOptions Bit field
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Set PrintOptions Bit field
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Get the page size in twips, considering the
    ///    * orientation (portrait or landscape).
    ///    */
    /// ```
    ///

    /// `void GetEffectivePageSize (out double aWidth, out double aHeight);`
    #[inline]
    pub unsafe fn GetEffectivePageSize(&self, aWidth: *mut libc::c_double, aHeight: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetEffectivePageSize)(self, aWidth, aHeight)
    }


    /// ```text
    /// /**
    ///    * Makes a new copy
    ///    */
    /// ```
    ///

    /// `nsIPrintSettings clone ();`
    #[inline]
    pub unsafe fn Clone(&self, _retval: *mut *const nsIPrintSettings) -> nsresult {
        ((*self.vtable).Clone)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Assigns the internal values from the "in" arg to the current object
    ///    */
    /// ```
    ///

    /// `void assign (in nsIPrintSettings aPS);`
    #[inline]
    pub unsafe fn Assign(&self, aPS: *const nsIPrintSettings) -> nsresult {
        ((*self.vtable).Assign)(self, aPS)
    }


    /// ```text
    /// /**
    ///    * Data Members
    ///    */
    /// ```
    ///

    /// `[noscript] attribute nsIPrintSession printSession;`
    #[inline]
    pub unsafe fn GetPrintSession(&self, aPrintSession: *mut *const nsIPrintSession) -> nsresult {
        ((*self.vtable).GetPrintSession)(self, aPrintSession)
    }


    /// ```text
    /// /**
    ///    * Data Members
    ///    */
    /// ```
    ///

    /// `[noscript] attribute nsIPrintSession printSession;`
    #[inline]
    pub unsafe fn SetPrintSession(&self, aPrintSession: *const nsIPrintSession) -> nsresult {
        ((*self.vtable).SetPrintSession)(self, aPrintSession)
    }



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



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



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



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


    /// ```text
    /// /**
    ///    * The edge measurements define the positioning of the headers
    ///    * and footers on the page. They're measured as an offset from
    ///    * the "unwriteable margin" (described below).
    ///    */
    /// ```
    ///

    /// `attribute double edgeTop;`
    #[inline]
    pub unsafe fn GetEdgeTop(&self, aEdgeTop: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetEdgeTop)(self, aEdgeTop)
    }


    /// ```text
    /// /**
    ///    * The edge measurements define the positioning of the headers
    ///    * and footers on the page. They're measured as an offset from
    ///    * the "unwriteable margin" (described below).
    ///    */
    /// ```
    ///

    /// `attribute double edgeTop;`
    #[inline]
    pub unsafe fn SetEdgeTop(&self, aEdgeTop: libc::c_double) -> nsresult {
        ((*self.vtable).SetEdgeTop)(self, aEdgeTop)
    }



    /// `attribute double edgeLeft;`
    #[inline]
    pub unsafe fn GetEdgeLeft(&self, aEdgeLeft: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetEdgeLeft)(self, aEdgeLeft)
    }



    /// `attribute double edgeLeft;`
    #[inline]
    pub unsafe fn SetEdgeLeft(&self, aEdgeLeft: libc::c_double) -> nsresult {
        ((*self.vtable).SetEdgeLeft)(self, aEdgeLeft)
    }



    /// `attribute double edgeBottom;`
    #[inline]
    pub unsafe fn GetEdgeBottom(&self, aEdgeBottom: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetEdgeBottom)(self, aEdgeBottom)
    }



    /// `attribute double edgeBottom;`
    #[inline]
    pub unsafe fn SetEdgeBottom(&self, aEdgeBottom: libc::c_double) -> nsresult {
        ((*self.vtable).SetEdgeBottom)(self, aEdgeBottom)
    }



    /// `attribute double edgeRight;`
    #[inline]
    pub unsafe fn GetEdgeRight(&self, aEdgeRight: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetEdgeRight)(self, aEdgeRight)
    }



    /// `attribute double edgeRight;`
    #[inline]
    pub unsafe fn SetEdgeRight(&self, aEdgeRight: libc::c_double) -> nsresult {
        ((*self.vtable).SetEdgeRight)(self, aEdgeRight)
    }


    /// ```text
    /// /**
    ///    * The margins define the positioning of the content on the page.
    ///    * They're treated as an offset from the "unwriteable margin"
    ///    * (described below).
    ///    */
    /// ```
    ///

    /// `attribute double marginTop;`
    #[inline]
    pub unsafe fn GetMarginTop(&self, aMarginTop: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetMarginTop)(self, aMarginTop)
    }


    /// ```text
    /// /**
    ///    * The margins define the positioning of the content on the page.
    ///    * They're treated as an offset from the "unwriteable margin"
    ///    * (described below).
    ///    */
    /// ```
    ///

    /// `attribute double marginTop;`
    #[inline]
    pub unsafe fn SetMarginTop(&self, aMarginTop: libc::c_double) -> nsresult {
        ((*self.vtable).SetMarginTop)(self, aMarginTop)
    }



    /// `attribute double marginLeft;`
    #[inline]
    pub unsafe fn GetMarginLeft(&self, aMarginLeft: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetMarginLeft)(self, aMarginLeft)
    }



    /// `attribute double marginLeft;`
    #[inline]
    pub unsafe fn SetMarginLeft(&self, aMarginLeft: libc::c_double) -> nsresult {
        ((*self.vtable).SetMarginLeft)(self, aMarginLeft)
    }



    /// `attribute double marginBottom;`
    #[inline]
    pub unsafe fn GetMarginBottom(&self, aMarginBottom: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetMarginBottom)(self, aMarginBottom)
    }



    /// `attribute double marginBottom;`
    #[inline]
    pub unsafe fn SetMarginBottom(&self, aMarginBottom: libc::c_double) -> nsresult {
        ((*self.vtable).SetMarginBottom)(self, aMarginBottom)
    }



    /// `attribute double marginRight;`
    #[inline]
    pub unsafe fn GetMarginRight(&self, aMarginRight: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetMarginRight)(self, aMarginRight)
    }



    /// `attribute double marginRight;`
    #[inline]
    pub unsafe fn SetMarginRight(&self, aMarginRight: libc::c_double) -> nsresult {
        ((*self.vtable).SetMarginRight)(self, aMarginRight)
    }


    /// ```text
    /// /**
    ///    * The unwriteable margin defines the printable region of the paper, creating
    ///    * an invisible border from which the edge and margin attributes are measured.
    ///    */
    /// ```
    ///

    /// `attribute double unwriteableMarginTop;`
    #[inline]
    pub unsafe fn GetUnwriteableMarginTop(&self, aUnwriteableMarginTop: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetUnwriteableMarginTop)(self, aUnwriteableMarginTop)
    }


    /// ```text
    /// /**
    ///    * The unwriteable margin defines the printable region of the paper, creating
    ///    * an invisible border from which the edge and margin attributes are measured.
    ///    */
    /// ```
    ///

    /// `attribute double unwriteableMarginTop;`
    #[inline]
    pub unsafe fn SetUnwriteableMarginTop(&self, aUnwriteableMarginTop: libc::c_double) -> nsresult {
        ((*self.vtable).SetUnwriteableMarginTop)(self, aUnwriteableMarginTop)
    }



    /// `attribute double unwriteableMarginLeft;`
    #[inline]
    pub unsafe fn GetUnwriteableMarginLeft(&self, aUnwriteableMarginLeft: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetUnwriteableMarginLeft)(self, aUnwriteableMarginLeft)
    }



    /// `attribute double unwriteableMarginLeft;`
    #[inline]
    pub unsafe fn SetUnwriteableMarginLeft(&self, aUnwriteableMarginLeft: libc::c_double) -> nsresult {
        ((*self.vtable).SetUnwriteableMarginLeft)(self, aUnwriteableMarginLeft)
    }



    /// `attribute double unwriteableMarginBottom;`
    #[inline]
    pub unsafe fn GetUnwriteableMarginBottom(&self, aUnwriteableMarginBottom: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetUnwriteableMarginBottom)(self, aUnwriteableMarginBottom)
    }



    /// `attribute double unwriteableMarginBottom;`
    #[inline]
    pub unsafe fn SetUnwriteableMarginBottom(&self, aUnwriteableMarginBottom: libc::c_double) -> nsresult {
        ((*self.vtable).SetUnwriteableMarginBottom)(self, aUnwriteableMarginBottom)
    }



    /// `attribute double unwriteableMarginRight;`
    #[inline]
    pub unsafe fn GetUnwriteableMarginRight(&self, aUnwriteableMarginRight: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetUnwriteableMarginRight)(self, aUnwriteableMarginRight)
    }



    /// `attribute double unwriteableMarginRight;`
    #[inline]
    pub unsafe fn SetUnwriteableMarginRight(&self, aUnwriteableMarginRight: libc::c_double) -> nsresult {
        ((*self.vtable).SetUnwriteableMarginRight)(self, aUnwriteableMarginRight)
    }



    /// `attribute double scaling;`
    #[inline]
    pub unsafe fn GetScaling(&self, aScaling: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetScaling)(self, aScaling)
    }



    /// `attribute double scaling;`
    #[inline]
    pub unsafe fn SetScaling(&self, aScaling: libc::c_double) -> nsresult {
        ((*self.vtable).SetScaling)(self, aScaling)
    }



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



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



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



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



    /// `attribute short printRange;`
    #[inline]
    pub unsafe fn GetPrintRange(&self, aPrintRange: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetPrintRange)(self, aPrintRange)
    }



    /// `attribute short printRange;`
    #[inline]
    pub unsafe fn SetPrintRange(&self, aPrintRange: libc::int16_t) -> nsresult {
        ((*self.vtable).SetPrintRange)(self, aPrintRange)
    }



    /// `attribute AString title;`
    #[inline]
    pub unsafe fn GetTitle(&self, aTitle: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetTitle)(self, aTitle)
    }



    /// `attribute AString title;`
    #[inline]
    pub unsafe fn SetTitle(&self, aTitle: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetTitle)(self, aTitle)
    }



    /// `attribute AString docURL;`
    #[inline]
    pub unsafe fn GetDocURL(&self, aDocURL: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetDocURL)(self, aDocURL)
    }



    /// `attribute AString docURL;`
    #[inline]
    pub unsafe fn SetDocURL(&self, aDocURL: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetDocURL)(self, aDocURL)
    }



    /// `attribute AString headerStrLeft;`
    #[inline]
    pub unsafe fn GetHeaderStrLeft(&self, aHeaderStrLeft: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetHeaderStrLeft)(self, aHeaderStrLeft)
    }



    /// `attribute AString headerStrLeft;`
    #[inline]
    pub unsafe fn SetHeaderStrLeft(&self, aHeaderStrLeft: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetHeaderStrLeft)(self, aHeaderStrLeft)
    }



    /// `attribute AString headerStrCenter;`
    #[inline]
    pub unsafe fn GetHeaderStrCenter(&self, aHeaderStrCenter: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetHeaderStrCenter)(self, aHeaderStrCenter)
    }



    /// `attribute AString headerStrCenter;`
    #[inline]
    pub unsafe fn SetHeaderStrCenter(&self, aHeaderStrCenter: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetHeaderStrCenter)(self, aHeaderStrCenter)
    }



    /// `attribute AString headerStrRight;`
    #[inline]
    pub unsafe fn GetHeaderStrRight(&self, aHeaderStrRight: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetHeaderStrRight)(self, aHeaderStrRight)
    }



    /// `attribute AString headerStrRight;`
    #[inline]
    pub unsafe fn SetHeaderStrRight(&self, aHeaderStrRight: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetHeaderStrRight)(self, aHeaderStrRight)
    }



    /// `attribute AString footerStrLeft;`
    #[inline]
    pub unsafe fn GetFooterStrLeft(&self, aFooterStrLeft: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetFooterStrLeft)(self, aFooterStrLeft)
    }



    /// `attribute AString footerStrLeft;`
    #[inline]
    pub unsafe fn SetFooterStrLeft(&self, aFooterStrLeft: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetFooterStrLeft)(self, aFooterStrLeft)
    }



    /// `attribute AString footerStrCenter;`
    #[inline]
    pub unsafe fn GetFooterStrCenter(&self, aFooterStrCenter: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetFooterStrCenter)(self, aFooterStrCenter)
    }



    /// `attribute AString footerStrCenter;`
    #[inline]
    pub unsafe fn SetFooterStrCenter(&self, aFooterStrCenter: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetFooterStrCenter)(self, aFooterStrCenter)
    }



    /// `attribute AString footerStrRight;`
    #[inline]
    pub unsafe fn GetFooterStrRight(&self, aFooterStrRight: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetFooterStrRight)(self, aFooterStrRight)
    }



    /// `attribute AString footerStrRight;`
    #[inline]
    pub unsafe fn SetFooterStrRight(&self, aFooterStrRight: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetFooterStrRight)(self, aFooterStrRight)
    }



    /// `attribute short howToEnableFrameUI;`
    #[inline]
    pub unsafe fn GetHowToEnableFrameUI(&self, aHowToEnableFrameUI: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetHowToEnableFrameUI)(self, aHowToEnableFrameUI)
    }



    /// `attribute short howToEnableFrameUI;`
    #[inline]
    pub unsafe fn SetHowToEnableFrameUI(&self, aHowToEnableFrameUI: libc::int16_t) -> nsresult {
        ((*self.vtable).SetHowToEnableFrameUI)(self, aHowToEnableFrameUI)
    }



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



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



    /// `attribute short printFrameTypeUsage;`
    #[inline]
    pub unsafe fn GetPrintFrameTypeUsage(&self, aPrintFrameTypeUsage: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetPrintFrameTypeUsage)(self, aPrintFrameTypeUsage)
    }



    /// `attribute short printFrameTypeUsage;`
    #[inline]
    pub unsafe fn SetPrintFrameTypeUsage(&self, aPrintFrameTypeUsage: libc::int16_t) -> nsresult {
        ((*self.vtable).SetPrintFrameTypeUsage)(self, aPrintFrameTypeUsage)
    }



    /// `attribute short printFrameType;`
    #[inline]
    pub unsafe fn GetPrintFrameType(&self, aPrintFrameType: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetPrintFrameType)(self, aPrintFrameType)
    }



    /// `attribute short printFrameType;`
    #[inline]
    pub unsafe fn SetPrintFrameType(&self, aPrintFrameType: libc::int16_t) -> nsresult {
        ((*self.vtable).SetPrintFrameType)(self, aPrintFrameType)
    }



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



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



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



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



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



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



    /// `attribute AString paperName;`
    #[inline]
    pub unsafe fn GetPaperName(&self, aPaperName: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetPaperName)(self, aPaperName)
    }



    /// `attribute AString paperName;`
    #[inline]
    pub unsafe fn SetPaperName(&self, aPaperName: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetPaperName)(self, aPaperName)
    }



    /// `attribute short paperData;`
    #[inline]
    pub unsafe fn GetPaperData(&self, aPaperData: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetPaperData)(self, aPaperData)
    }



    /// `attribute short paperData;`
    #[inline]
    pub unsafe fn SetPaperData(&self, aPaperData: libc::int16_t) -> nsresult {
        ((*self.vtable).SetPaperData)(self, aPaperData)
    }



    /// `attribute double paperWidth;`
    #[inline]
    pub unsafe fn GetPaperWidth(&self, aPaperWidth: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetPaperWidth)(self, aPaperWidth)
    }



    /// `attribute double paperWidth;`
    #[inline]
    pub unsafe fn SetPaperWidth(&self, aPaperWidth: libc::c_double) -> nsresult {
        ((*self.vtable).SetPaperWidth)(self, aPaperWidth)
    }



    /// `attribute double paperHeight;`
    #[inline]
    pub unsafe fn GetPaperHeight(&self, aPaperHeight: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetPaperHeight)(self, aPaperHeight)
    }



    /// `attribute double paperHeight;`
    #[inline]
    pub unsafe fn SetPaperHeight(&self, aPaperHeight: libc::c_double) -> nsresult {
        ((*self.vtable).SetPaperHeight)(self, aPaperHeight)
    }



    /// `attribute short paperSizeUnit;`
    #[inline]
    pub unsafe fn GetPaperSizeUnit(&self, aPaperSizeUnit: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetPaperSizeUnit)(self, aPaperSizeUnit)
    }



    /// `attribute short paperSizeUnit;`
    #[inline]
    pub unsafe fn SetPaperSizeUnit(&self, aPaperSizeUnit: libc::int16_t) -> nsresult {
        ((*self.vtable).SetPaperSizeUnit)(self, aPaperSizeUnit)
    }



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



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



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



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



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



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



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



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



    /// `attribute AString printerName;`
    #[inline]
    pub unsafe fn GetPrinterName(&self, aPrinterName: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetPrinterName)(self, aPrinterName)
    }



    /// `attribute AString printerName;`
    #[inline]
    pub unsafe fn SetPrinterName(&self, aPrinterName: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetPrinterName)(self, aPrinterName)
    }



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



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



    /// `attribute AString toFileName;`
    #[inline]
    pub unsafe fn GetToFileName(&self, aToFileName: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetToFileName)(self, aToFileName)
    }



    /// `attribute AString toFileName;`
    #[inline]
    pub unsafe fn SetToFileName(&self, aToFileName: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetToFileName)(self, aToFileName)
    }



    /// `attribute short outputFormat;`
    #[inline]
    pub unsafe fn GetOutputFormat(&self, aOutputFormat: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetOutputFormat)(self, aOutputFormat)
    }



    /// `attribute short outputFormat;`
    #[inline]
    pub unsafe fn SetOutputFormat(&self, aOutputFormat: libc::int16_t) -> nsresult {
        ((*self.vtable).SetOutputFormat)(self, aOutputFormat)
    }



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



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



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



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



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



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


    /// ```text
    /// /**
    ///    * This attribute tracks whether the PS has been initialized
    ///    * from a printer specified by the "printerName" attr.
    ///    * If a different name is set into the "printerName"
    ///    * attribute than the one it was initialized with the PS
    ///    * will then get intialized from that printer.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This attribute tracks whether the PS has been initialized
    ///    * from a printer specified by the "printerName" attr.
    ///    * If a different name is set into the "printerName"
    ///    * attribute than the one it was initialized with the PS
    ///    * will then get intialized from that printer.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This attribute tracks whether the PS has been initialized
    ///    * from prefs. If a different name is set into the "printerName"
    ///    * attribute than the one it was initialized with the PS
    ///    * will then get intialized from prefs again.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * This attribute tracks whether the PS has been initialized
    ///    * from prefs. If a different name is set into the "printerName"
    ///    * attribute than the one it was initialized with the PS
    ///    * will then get intialized from prefs again.
    ///    */
    /// ```
    ///

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



    /// `[noscript] void SetMarginInTwips (in nsNativeIntMarginRef aMargin);`
    const _SetMarginInTwips: () = ();


    /// `[noscript] void SetEdgeInTwips (in nsNativeIntMarginRef aEdge);`
    const _SetEdgeInTwips: () = ();


    /// `[noscript] void GetMarginInTwips (in nsNativeIntMarginRef aMargin);`
    const _GetMarginInTwips: () = ();


    /// `[noscript] void GetEdgeInTwips (in nsNativeIntMarginRef aEdge);`
    const _GetEdgeInTwips: () = ();

    /// ```text
    /// /**
    ///    * We call this function so that anything that requires a run of the event loop
    ///    * can do so safely. The print dialog runs the event loop but in silent printing
    ///    * that doesn't happen.
    ///    *
    ///    * Either this or ShowPrintDialog (but not both) MUST be called by the print engine
    ///    * before printing, otherwise printing can fail on some platforms.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Sets/Gets the "unwriteable margin" for the page format.  This defines
    ///    * the boundary from which we'll measure the EdgeInTwips and MarginInTwips
    ///    * attributes, to place the headers and content, respectively.
    ///    *
    ///    * Note: Implementations of SetUnwriteableMarginInTwips should handle
    ///    * negative margin values by falling back on the system default for
    ///    * that margin.
    ///    */
    /// ```
    ///

    /// `[noscript] void SetUnwriteableMarginInTwips (in nsNativeIntMarginRef aEdge);`
    const _SetUnwriteableMarginInTwips: () = ();


    /// `[noscript] void GetUnwriteableMarginInTwips (in nsNativeIntMarginRef aEdge);`
    const _GetUnwriteableMarginInTwips: () = ();

    /// ```text
    /// /**
    ///    * Get more accurate print ranges from the superior interval
    ///    * (startPageRange, endPageRange). The aPages array is populated with a
    ///    * list of pairs (start, end), where the endpoints are included. The print
    ///    * ranges (start, end), must not overlap and must be in the
    ///    * (startPageRange, endPageRange) scope.
    ///    *
    ///    * If there are no print ranges the aPages array is cleared.
    ///    */
    /// ```
    ///

    /// `[noscript] void GetPageRanges (in IntegerArray aPages);`
    const _GetPageRanges: () = ();

}