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


/// `interface nsIAutoCompleteInput : 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 nsIAutoCompleteInput {
    vtable: *const nsIAutoCompleteInputVTable,

    /// 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 nsIAutoCompleteInput.
unsafe impl XpCom for nsIAutoCompleteInput {
    const IID: nsIID = nsID(0xb068e70f, 0xf82c, 0x4c12,
        [0xad, 0x87, 0x82, 0xe2, 0x71, 0xc5, 0xc1, 0x80]);
}

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

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

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

    /* readonly attribute nsIAutoCompletePopup popup; */
    pub GetPopup: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aPopup: *mut *const nsIAutoCompletePopup) -> nsresult,

    /* readonly attribute nsIAutoCompleteController controller; */
    pub GetController: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aController: *mut *const nsIAutoCompleteController) -> nsresult,

    /* attribute boolean popupOpen; */
    pub GetPopupOpen: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aPopupOpen: *mut bool) -> nsresult,

    /* attribute boolean popupOpen; */
    pub SetPopupOpen: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aPopupOpen: bool) -> nsresult,

    /* attribute boolean disableAutoComplete; */
    pub GetDisableAutoComplete: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aDisableAutoComplete: *mut bool) -> nsresult,

    /* attribute boolean disableAutoComplete; */
    pub SetDisableAutoComplete: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aDisableAutoComplete: bool) -> nsresult,

    /* attribute boolean completeDefaultIndex; */
    pub GetCompleteDefaultIndex: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aCompleteDefaultIndex: *mut bool) -> nsresult,

    /* attribute boolean completeDefaultIndex; */
    pub SetCompleteDefaultIndex: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aCompleteDefaultIndex: bool) -> nsresult,

    /* attribute boolean completeSelectedIndex; */
    pub GetCompleteSelectedIndex: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aCompleteSelectedIndex: *mut bool) -> nsresult,

    /* attribute boolean completeSelectedIndex; */
    pub SetCompleteSelectedIndex: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aCompleteSelectedIndex: bool) -> nsresult,

    /* attribute boolean forceComplete; */
    pub GetForceComplete: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aForceComplete: *mut bool) -> nsresult,

    /* attribute boolean forceComplete; */
    pub SetForceComplete: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aForceComplete: bool) -> nsresult,

    /* attribute unsigned long minResultsForPopup; */
    pub GetMinResultsForPopup: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aMinResultsForPopup: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long minResultsForPopup; */
    pub SetMinResultsForPopup: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aMinResultsForPopup: libc::uint32_t) -> nsresult,

    /* attribute unsigned long maxRows; */
    pub GetMaxRows: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aMaxRows: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long maxRows; */
    pub SetMaxRows: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aMaxRows: libc::uint32_t) -> nsresult,

    /* attribute boolean showCommentColumn; */
    pub GetShowCommentColumn: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aShowCommentColumn: *mut bool) -> nsresult,

    /* attribute boolean showCommentColumn; */
    pub SetShowCommentColumn: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aShowCommentColumn: bool) -> nsresult,

    /* attribute boolean showImageColumn; */
    pub GetShowImageColumn: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aShowImageColumn: *mut bool) -> nsresult,

    /* attribute boolean showImageColumn; */
    pub SetShowImageColumn: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aShowImageColumn: bool) -> nsresult,

    /* attribute unsigned long timeout; */
    pub GetTimeout: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aTimeout: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long timeout; */
    pub SetTimeout: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aTimeout: libc::uint32_t) -> nsresult,

    /* attribute AString searchParam; */
    pub GetSearchParam: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aSearchParam: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString searchParam; */
    pub SetSearchParam: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aSearchParam: &::nsstring::nsAString) -> nsresult,

    /* readonly attribute unsigned long searchCount; */
    pub GetSearchCount: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aSearchCount: *mut libc::uint32_t) -> nsresult,

    /* ACString getSearchAt (in unsigned long index); */
    pub GetSearchAt: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, index: libc::uint32_t, _retval: &mut ::nsstring::nsACString) -> nsresult,

    /* attribute AString textValue; */
    pub GetTextValue: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aTextValue: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString textValue; */
    pub SetTextValue: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aTextValue: &::nsstring::nsAString) -> nsresult,

    /* void setTextValueWithReason (in AString aValue, in unsigned short aReason); */
    pub SetTextValueWithReason: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aValue: &::nsstring::nsAString, aReason: libc::uint16_t) -> nsresult,

    /* readonly attribute long selectionStart; */
    pub GetSelectionStart: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aSelectionStart: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long selectionEnd; */
    pub GetSelectionEnd: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aSelectionEnd: *mut libc::int32_t) -> nsresult,

    /* void selectTextRange (in long startIndex, in long endIndex); */
    pub SelectTextRange: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, startIndex: libc::int32_t, endIndex: libc::int32_t) -> nsresult,

    /* void onSearchBegin (); */
    pub OnSearchBegin: unsafe extern "system" fn (this: *const nsIAutoCompleteInput) -> nsresult,

    /* void onSearchComplete (); */
    pub OnSearchComplete: unsafe extern "system" fn (this: *const nsIAutoCompleteInput) -> nsresult,

    /* boolean onTextEntered ([optional] in nsIDOMEvent aEvent); */
    pub OnTextEntered: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aEvent: *const nsIDOMEvent, _retval: *mut bool) -> nsresult,

    /* boolean onTextReverted (); */
    pub OnTextReverted: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, _retval: *mut bool) -> nsresult,

    /* readonly attribute boolean consumeRollupEvent; */
    pub GetConsumeRollupEvent: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aConsumeRollupEvent: *mut bool) -> nsresult,

    /* readonly attribute boolean inPrivateContext; */
    pub GetInPrivateContext: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aInPrivateContext: *mut bool) -> nsresult,

    /* readonly attribute boolean noRollupOnCaretMove; */
    pub GetNoRollupOnCaretMove: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aNoRollupOnCaretMove: *mut bool) -> nsresult,

    /* readonly attribute unsigned long userContextId; */
    pub GetUserContextId: unsafe extern "system" fn (this: *const nsIAutoCompleteInput, aUserContextId: *mut libc::uint32_t) -> 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 nsIAutoCompleteInput {

    pub const TEXTVALUE_REASON_UNKNOWN: i64 = 0;


    pub const TEXTVALUE_REASON_COMPLETEDEFAULT: i64 = 1;


    pub const TEXTVALUE_REASON_COMPLETESELECTED: i64 = 2;


    pub const TEXTVALUE_REASON_REVERT: i64 = 3;


    pub const TEXTVALUE_REASON_ENTERMATCH: i64 = 4;


    /// `readonly attribute nsIAutoCompletePopup popup;`
    #[inline]
    pub unsafe fn GetPopup(&self, aPopup: *mut *const nsIAutoCompletePopup) -> nsresult {
        ((*self.vtable).GetPopup)(self, aPopup)
    }



    /// `readonly attribute nsIAutoCompleteController controller;`
    #[inline]
    pub unsafe fn GetController(&self, aController: *mut *const nsIAutoCompleteController) -> nsresult {
        ((*self.vtable).GetController)(self, aController)
    }



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



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



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



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



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



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



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



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



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



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



    /// `attribute unsigned long minResultsForPopup;`
    #[inline]
    pub unsafe fn GetMinResultsForPopup(&self, aMinResultsForPopup: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetMinResultsForPopup)(self, aMinResultsForPopup)
    }



    /// `attribute unsigned long minResultsForPopup;`
    #[inline]
    pub unsafe fn SetMinResultsForPopup(&self, aMinResultsForPopup: libc::uint32_t) -> nsresult {
        ((*self.vtable).SetMinResultsForPopup)(self, aMinResultsForPopup)
    }



    /// `attribute unsigned long maxRows;`
    #[inline]
    pub unsafe fn GetMaxRows(&self, aMaxRows: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetMaxRows)(self, aMaxRows)
    }



    /// `attribute unsigned long maxRows;`
    #[inline]
    pub unsafe fn SetMaxRows(&self, aMaxRows: libc::uint32_t) -> nsresult {
        ((*self.vtable).SetMaxRows)(self, aMaxRows)
    }



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



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



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



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



    /// `attribute unsigned long timeout;`
    #[inline]
    pub unsafe fn GetTimeout(&self, aTimeout: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetTimeout)(self, aTimeout)
    }



    /// `attribute unsigned long timeout;`
    #[inline]
    pub unsafe fn SetTimeout(&self, aTimeout: libc::uint32_t) -> nsresult {
        ((*self.vtable).SetTimeout)(self, aTimeout)
    }



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



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



    /// `readonly attribute unsigned long searchCount;`
    #[inline]
    pub unsafe fn GetSearchCount(&self, aSearchCount: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetSearchCount)(self, aSearchCount)
    }



    /// `ACString getSearchAt (in unsigned long index);`
    #[inline]
    pub unsafe fn GetSearchAt(&self, index: libc::uint32_t, _retval: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetSearchAt)(self, index, _retval)
    }



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



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



    /// `void setTextValueWithReason (in AString aValue, in unsigned short aReason);`
    #[inline]
    pub unsafe fn SetTextValueWithReason(&self, aValue: &::nsstring::nsAString, aReason: libc::uint16_t) -> nsresult {
        ((*self.vtable).SetTextValueWithReason)(self, aValue, aReason)
    }



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



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



    /// `void selectTextRange (in long startIndex, in long endIndex);`
    #[inline]
    pub unsafe fn SelectTextRange(&self, startIndex: libc::int32_t, endIndex: libc::int32_t) -> nsresult {
        ((*self.vtable).SelectTextRange)(self, startIndex, endIndex)
    }



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



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



    /// `boolean onTextEntered ([optional] in nsIDOMEvent aEvent);`
    #[inline]
    pub unsafe fn OnTextEntered(&self, aEvent: *const nsIDOMEvent, _retval: *mut bool) -> nsresult {
        ((*self.vtable).OnTextEntered)(self, aEvent, _retval)
    }



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



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



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



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


    /// ```text
    /// /**
    ///    * The userContextId of the current browser.
    ///    */
    /// ```
    ///

    /// `readonly attribute unsigned long userContextId;`
    #[inline]
    pub unsafe fn GetUserContextId(&self, aUserContextId: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetUserContextId)(self, aUserContextId)
    }


}