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


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

    /// 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 nsITreeColumn.
unsafe impl XpCom for nsITreeColumn {
    const IID: nsIID = nsID(0xae835ecf, 0x6b32, 0x4660,
        [0x9b, 0x43, 0x8a, 0x27, 0x0d, 0xf5, 0x6e, 0x02]);
}

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

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

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

    /* readonly attribute nsIDOMElement element; */
    pub GetElement: unsafe extern "system" fn (this: *const nsITreeColumn, aElement: *mut *const nsIDOMElement) -> nsresult,

    /* readonly attribute nsITreeColumns columns; */
    pub GetColumns: unsafe extern "system" fn (this: *const nsITreeColumn, aColumns: *mut *const nsITreeColumns) -> nsresult,

    /* readonly attribute long x; */
    pub GetX: unsafe extern "system" fn (this: *const nsITreeColumn, aX: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long width; */
    pub GetWidth: unsafe extern "system" fn (this: *const nsITreeColumn, aWidth: *mut libc::int32_t) -> nsresult,

    /* readonly attribute AString id; */
    pub GetId: unsafe extern "system" fn (this: *const nsITreeColumn, aId: &mut ::nsstring::nsAString) -> nsresult,

    /* [noscript] void getIdConst ([shared] out wstring idConst); */
    pub GetIdConst: unsafe extern "system" fn (this: *const nsITreeColumn, idConst: *mut *const libc::int16_t) -> nsresult,

    /* readonly attribute long index; */
    pub GetIndex: unsafe extern "system" fn (this: *const nsITreeColumn, aIndex: *mut libc::int32_t) -> nsresult,

    /* readonly attribute boolean primary; */
    pub GetPrimary: unsafe extern "system" fn (this: *const nsITreeColumn, aPrimary: *mut bool) -> nsresult,

    /* readonly attribute boolean cycler; */
    pub GetCycler: unsafe extern "system" fn (this: *const nsITreeColumn, aCycler: *mut bool) -> nsresult,

    /* readonly attribute boolean editable; */
    pub GetEditable: unsafe extern "system" fn (this: *const nsITreeColumn, aEditable: *mut bool) -> nsresult,

    /* readonly attribute boolean selectable; */
    pub GetSelectable: unsafe extern "system" fn (this: *const nsITreeColumn, aSelectable: *mut bool) -> nsresult,

    /* readonly attribute short type; */
    pub GetType: unsafe extern "system" fn (this: *const nsITreeColumn, aType: *mut libc::int16_t) -> nsresult,

    /* nsITreeColumn getNext (); */
    pub GetNext: unsafe extern "system" fn (this: *const nsITreeColumn, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getPrevious (); */
    pub GetPrevious: unsafe extern "system" fn (this: *const nsITreeColumn, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* void invalidate (); */
    pub Invalidate: unsafe extern "system" fn (this: *const nsITreeColumn) -> 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 nsITreeColumn {

    pub const TYPE_TEXT: i64 = 1;


    pub const TYPE_CHECKBOX: i64 = 2;


    pub const TYPE_PROGRESSMETER: i64 = 3;


    pub const TYPE_PASSWORD: i64 = 4;


    /// `readonly attribute nsIDOMElement element;`
    #[inline]
    pub unsafe fn GetElement(&self, aElement: *mut *const nsIDOMElement) -> nsresult {
        ((*self.vtable).GetElement)(self, aElement)
    }



    /// `readonly attribute nsITreeColumns columns;`
    #[inline]
    pub unsafe fn GetColumns(&self, aColumns: *mut *const nsITreeColumns) -> nsresult {
        ((*self.vtable).GetColumns)(self, aColumns)
    }



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



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



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



    /// `[noscript] void getIdConst ([shared] out wstring idConst);`
    #[inline]
    pub unsafe fn GetIdConst(&self, idConst: *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).GetIdConst)(self, idConst)
    }



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



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



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



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



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



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



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



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



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


}


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

    /// 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 nsITreeColumns.
unsafe impl XpCom for nsITreeColumns {
    const IID: nsIID = nsID(0xf8a8d6b4, 0x6788, 0x438d,
        [0x90, 0x09, 0x71, 0x42, 0x79, 0x87, 0x67, 0xab]);
}

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

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

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

    /* readonly attribute nsITreeBoxObject tree; */
    pub GetTree: unsafe extern "system" fn (this: *const nsITreeColumns, aTree: *mut *const nsITreeBoxObject) -> nsresult,

    /* readonly attribute long count; */
    pub GetCount: unsafe extern "system" fn (this: *const nsITreeColumns, aCount: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long length; */
    pub GetLength: unsafe extern "system" fn (this: *const nsITreeColumns, aLength: *mut libc::int32_t) -> nsresult,

    /* nsITreeColumn getFirstColumn (); */
    pub GetFirstColumn: unsafe extern "system" fn (this: *const nsITreeColumns, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getLastColumn (); */
    pub GetLastColumn: unsafe extern "system" fn (this: *const nsITreeColumns, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getPrimaryColumn (); */
    pub GetPrimaryColumn: unsafe extern "system" fn (this: *const nsITreeColumns, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getSortedColumn (); */
    pub GetSortedColumn: unsafe extern "system" fn (this: *const nsITreeColumns, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getKeyColumn (); */
    pub GetKeyColumn: unsafe extern "system" fn (this: *const nsITreeColumns, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getColumnFor (in nsIDOMElement element); */
    pub GetColumnFor: unsafe extern "system" fn (this: *const nsITreeColumns, element: *const nsIDOMElement, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getNamedColumn (in AString id); */
    pub GetNamedColumn: unsafe extern "system" fn (this: *const nsITreeColumns, id: &::nsstring::nsAString, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* nsITreeColumn getColumnAt (in long index); */
    pub GetColumnAt: unsafe extern "system" fn (this: *const nsITreeColumns, index: libc::int32_t, _retval: *mut *const nsITreeColumn) -> nsresult,

    /* void invalidateColumns (); */
    pub InvalidateColumns: unsafe extern "system" fn (this: *const nsITreeColumns) -> nsresult,

    /* void restoreNaturalOrder (); */
    pub RestoreNaturalOrder: unsafe extern "system" fn (this: *const nsITreeColumns) -> 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 nsITreeColumns {

    /// ```text
    /// /**
    ///    * The tree widget for these columns.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsITreeBoxObject tree;`
    #[inline]
    pub unsafe fn GetTree(&self, aTree: *mut *const nsITreeBoxObject) -> nsresult {
        ((*self.vtable).GetTree)(self, aTree)
    }


    /// ```text
    /// /**
    ///    * The number of columns.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * An alias for count (for the benefit of scripts which treat this as an
        ///    * array).
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Get the first/last column.
    ///    */
    /// ```
    ///

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



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


    /// ```text
    /// /**
    ///    * Attribute based column getters.
    ///    */
    /// ```
    ///

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



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



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


    /// ```text
    /// /**
    ///    * Get the column for the given element.
    ///    */
    /// ```
    ///

    /// `nsITreeColumn getColumnFor (in nsIDOMElement element);`
    #[inline]
    pub unsafe fn GetColumnFor(&self, element: *const nsIDOMElement, _retval: *mut *const nsITreeColumn) -> nsresult {
        ((*self.vtable).GetColumnFor)(self, element, _retval)
    }


    /// ```text
    /// /**
    ///    * Parametric column getters.
    ///    */
    /// ```
    ///

    /// `nsITreeColumn getNamedColumn (in AString id);`
    #[inline]
    pub unsafe fn GetNamedColumn(&self, id: &::nsstring::nsAString, _retval: *mut *const nsITreeColumn) -> nsresult {
        ((*self.vtable).GetNamedColumn)(self, id, _retval)
    }



    /// `nsITreeColumn getColumnAt (in long index);`
    #[inline]
    pub unsafe fn GetColumnAt(&self, index: libc::int32_t, _retval: *mut *const nsITreeColumn) -> nsresult {
        ((*self.vtable).GetColumnAt)(self, index, _retval)
    }


    /// ```text
    /// /**
    ///    * This method is called whenever a treecol is added or removed and
    ///    * the column cache needs to be rebuilt.
    ///    */
    /// ```
    ///

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



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


}