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


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

    /// 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 nsITreeBoxObject.
unsafe impl XpCom for nsITreeBoxObject {
    const IID: nsIID = nsID(0xf3da0c5e, 0x51f5, 0x45f0,
        [0xb2, 0xcd, 0x6b, 0xe3, 0xab, 0x68, 0x47, 0xae]);
}

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

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

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

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

    /* attribute nsITreeView view; */
    pub GetView: unsafe extern "system" fn (this: *const nsITreeBoxObject, aView: *mut *const nsITreeView) -> nsresult,

    /* attribute nsITreeView view; */
    pub SetView: unsafe extern "system" fn (this: *const nsITreeBoxObject, aView: *const nsITreeView) -> nsresult,

    /* attribute boolean focused; */
    pub GetFocused: unsafe extern "system" fn (this: *const nsITreeBoxObject, aFocused: *mut bool) -> nsresult,

    /* attribute boolean focused; */
    pub SetFocused: unsafe extern "system" fn (this: *const nsITreeBoxObject, aFocused: bool) -> nsresult,

    /* readonly attribute nsIDOMElement treeBody; */
    pub GetTreeBody: unsafe extern "system" fn (this: *const nsITreeBoxObject, aTreeBody: *mut *const nsIDOMElement) -> nsresult,

    /* readonly attribute long rowHeight; */
    pub GetRowHeight: unsafe extern "system" fn (this: *const nsITreeBoxObject, aRowHeight: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long rowWidth; */
    pub GetRowWidth: unsafe extern "system" fn (this: *const nsITreeBoxObject, aRowWidth: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long horizontalPosition; */
    pub GetHorizontalPosition: unsafe extern "system" fn (this: *const nsITreeBoxObject, aHorizontalPosition: *mut libc::int32_t) -> nsresult,

    /* readonly attribute nsIScriptableRegion selectionRegion; */
    pub GetSelectionRegion: unsafe extern "system" fn (this: *const nsITreeBoxObject, aSelectionRegion: *mut *const nsIScriptableRegion) -> nsresult,

    /* long getFirstVisibleRow (); */
    pub GetFirstVisibleRow: unsafe extern "system" fn (this: *const nsITreeBoxObject, _retval: *mut libc::int32_t) -> nsresult,

    /* long getLastVisibleRow (); */
    pub GetLastVisibleRow: unsafe extern "system" fn (this: *const nsITreeBoxObject, _retval: *mut libc::int32_t) -> nsresult,

    /* long getPageLength (); */
    pub GetPageLength: unsafe extern "system" fn (this: *const nsITreeBoxObject, _retval: *mut libc::int32_t) -> nsresult,

    /* void ensureRowIsVisible (in long index); */
    pub EnsureRowIsVisible: unsafe extern "system" fn (this: *const nsITreeBoxObject, index: libc::int32_t) -> nsresult,

    /* void ensureCellIsVisible (in long row, in nsITreeColumn col); */
    pub EnsureCellIsVisible: unsafe extern "system" fn (this: *const nsITreeBoxObject, row: libc::int32_t, col: *const nsITreeColumn) -> nsresult,

    /* void scrollToRow (in long index); */
    pub ScrollToRow: unsafe extern "system" fn (this: *const nsITreeBoxObject, index: libc::int32_t) -> nsresult,

    /* void scrollByLines (in long numLines); */
    pub ScrollByLines: unsafe extern "system" fn (this: *const nsITreeBoxObject, numLines: libc::int32_t) -> nsresult,

    /* void scrollByPages (in long numPages); */
    pub ScrollByPages: unsafe extern "system" fn (this: *const nsITreeBoxObject, numPages: libc::int32_t) -> nsresult,

    /* void scrollToCell (in long row, in nsITreeColumn col); */
    pub ScrollToCell: unsafe extern "system" fn (this: *const nsITreeBoxObject, row: libc::int32_t, col: *const nsITreeColumn) -> nsresult,

    /* void scrollToColumn (in nsITreeColumn col); */
    pub ScrollToColumn: unsafe extern "system" fn (this: *const nsITreeBoxObject, col: *const nsITreeColumn) -> nsresult,

    /* void scrollToHorizontalPosition (in long horizontalPosition); */
    pub ScrollToHorizontalPosition: unsafe extern "system" fn (this: *const nsITreeBoxObject, horizontalPosition: libc::int32_t) -> nsresult,

    /* void invalidate (); */
    pub Invalidate: unsafe extern "system" fn (this: *const nsITreeBoxObject) -> nsresult,

    /* void invalidateColumn (in nsITreeColumn col); */
    pub InvalidateColumn: unsafe extern "system" fn (this: *const nsITreeBoxObject, col: *const nsITreeColumn) -> nsresult,

    /* void invalidateRow (in long index); */
    pub InvalidateRow: unsafe extern "system" fn (this: *const nsITreeBoxObject, index: libc::int32_t) -> nsresult,

    /* void invalidateCell (in long row, in nsITreeColumn col); */
    pub InvalidateCell: unsafe extern "system" fn (this: *const nsITreeBoxObject, row: libc::int32_t, col: *const nsITreeColumn) -> nsresult,

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

    /* void invalidateColumnRange (in long startIndex, in long endIndex, in nsITreeColumn col); */
    pub InvalidateColumnRange: unsafe extern "system" fn (this: *const nsITreeBoxObject, startIndex: libc::int32_t, endIndex: libc::int32_t, col: *const nsITreeColumn) -> nsresult,

    /* long getRowAt (in long x, in long y); */
    pub GetRowAt: unsafe extern "system" fn (this: *const nsITreeBoxObject, x: libc::int32_t, y: libc::int32_t, _retval: *mut libc::int32_t) -> nsresult,

    /* void getCellAt (in long x, in long y, out long row, out nsITreeColumn col, out AString childElt); */
    pub GetCellAt: unsafe extern "system" fn (this: *const nsITreeBoxObject, x: libc::int32_t, y: libc::int32_t, row: *mut libc::int32_t, col: *mut *const nsITreeColumn, childElt: &mut ::nsstring::nsAString) -> nsresult,

    /* void getCoordsForCellItem (in long row, in nsITreeColumn col, in AString element, out long x, out long y, out long width, out long height); */
    pub GetCoordsForCellItem: unsafe extern "system" fn (this: *const nsITreeBoxObject, row: libc::int32_t, col: *const nsITreeColumn, element: &::nsstring::nsAString, x: *mut libc::int32_t, y: *mut libc::int32_t, width: *mut libc::int32_t, height: *mut libc::int32_t) -> nsresult,

    /* boolean isCellCropped (in long row, in nsITreeColumn col); */
    pub IsCellCropped: unsafe extern "system" fn (this: *const nsITreeBoxObject, row: libc::int32_t, col: *const nsITreeColumn, _retval: *mut bool) -> nsresult,

    /* void rowCountChanged (in long index, in long count); */
    pub RowCountChanged: unsafe extern "system" fn (this: *const nsITreeBoxObject, index: libc::int32_t, count: libc::int32_t) -> nsresult,

    /* void beginUpdateBatch (); */
    pub BeginUpdateBatch: unsafe extern "system" fn (this: *const nsITreeBoxObject) -> nsresult,

    /* void endUpdateBatch (); */
    pub EndUpdateBatch: unsafe extern "system" fn (this: *const nsITreeBoxObject) -> nsresult,

    /* void clearStyleAndImageCaches (); */
    pub ClearStyleAndImageCaches: unsafe extern "system" fn (this: *const nsITreeBoxObject) -> nsresult,

    /* void removeImageCacheEntry (in long row, in nsITreeColumn col); */
    pub RemoveImageCacheEntry: unsafe extern "system" fn (this: *const nsITreeBoxObject, row: libc::int32_t, col: *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 nsITreeBoxObject {

    /// ```text
    /// /**
    ///    * Obtain the columns.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * The view that backs the tree and that supplies it with its data.
    ///    * It is dynamically settable, either using a view attribute on the
    ///    * tree tag or by setting this attribute to a new value.
    ///    */
    /// ```
    ///

    /// `attribute nsITreeView view;`
    #[inline]
    pub unsafe fn GetView(&self, aView: *mut *const nsITreeView) -> nsresult {
        ((*self.vtable).GetView)(self, aView)
    }


    /// ```text
    /// /**
    ///    * The view that backs the tree and that supplies it with its data.
    ///    * It is dynamically settable, either using a view attribute on the
    ///    * tree tag or by setting this attribute to a new value.
    ///    */
    /// ```
    ///

    /// `attribute nsITreeView view;`
    #[inline]
    pub unsafe fn SetView(&self, aView: *const nsITreeView) -> nsresult {
        ((*self.vtable).SetView)(self, aView)
    }


    /// ```text
    /// /**
    ///    * Whether or not we are currently focused.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Whether or not we are currently focused.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Obtain the treebody content node
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Obtain the height of a row.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Obtain the width of a row.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Get the pixel position of the horizontal scrollbar.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Return the region for the visible parts of the selection, in device pixels.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIScriptableRegion selectionRegion;`
    #[inline]
    pub unsafe fn GetSelectionRegion(&self, aSelectionRegion: *mut *const nsIScriptableRegion) -> nsresult {
        ((*self.vtable).GetSelectionRegion)(self, aSelectionRegion)
    }


    /// ```text
    /// /**
    ///    * Get the index of the first visible row.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Get the index of the last visible row.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Gets the number of possible visible rows.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Ensures that a row at a given index is visible.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Ensures that a given cell in the tree is visible.
    ///    */
    /// ```
    ///

    /// `void ensureCellIsVisible (in long row, in nsITreeColumn col);`
    #[inline]
    pub unsafe fn EnsureCellIsVisible(&self, row: libc::int32_t, col: *const nsITreeColumn) -> nsresult {
        ((*self.vtable).EnsureCellIsVisible)(self, row, col)
    }


    /// ```text
    /// /**
    ///    * Scrolls such that the row at index is at the top of the visible view.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Scroll the tree up or down by numLines lines. Positive
    ///    * values move down in the tree. Prevents scrolling off the
    ///    * end of the tree.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Scroll the tree up or down by numPages pages. A page
    ///    * is considered to be the amount displayed by the tree.
    ///    * Positive values move down in the tree. Prevents scrolling
    ///    * off the end of the tree.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Scrolls such that a given cell is visible (if possible)
    ///    * at the top left corner of the visible view.
    ///    */
    /// ```
    ///

    /// `void scrollToCell (in long row, in nsITreeColumn col);`
    #[inline]
    pub unsafe fn ScrollToCell(&self, row: libc::int32_t, col: *const nsITreeColumn) -> nsresult {
        ((*self.vtable).ScrollToCell)(self, row, col)
    }


    /// ```text
    /// /**
    ///    * Scrolls horizontally so that the specified column is
    ///    * at the left of the view (if possible).
    ///    */
    /// ```
    ///

    /// `void scrollToColumn (in nsITreeColumn col);`
    #[inline]
    pub unsafe fn ScrollToColumn(&self, col: *const nsITreeColumn) -> nsresult {
        ((*self.vtable).ScrollToColumn)(self, col)
    }


    /// ```text
    /// /**
    ///    * Scroll to a specific horizontal pixel position.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Invalidation methods for fine-grained painting control.
    ///    */
    /// ```
    ///

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



    /// `void invalidateColumn (in nsITreeColumn col);`
    #[inline]
    pub unsafe fn InvalidateColumn(&self, col: *const nsITreeColumn) -> nsresult {
        ((*self.vtable).InvalidateColumn)(self, col)
    }



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



    /// `void invalidateCell (in long row, in nsITreeColumn col);`
    #[inline]
    pub unsafe fn InvalidateCell(&self, row: libc::int32_t, col: *const nsITreeColumn) -> nsresult {
        ((*self.vtable).InvalidateCell)(self, row, col)
    }



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



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


    /// ```text
    /// /**
    ///    * A hit test that can tell you what row the mouse is over.
    ///    * returns -1 for invalid mouse coordinates.
    ///    *
    ///    * The coordinate system is the client coordinate system for the
    ///    * document this boxObject lives in, and the units are CSS pixels.
    ///    */
    /// ```
    ///

    /// `long getRowAt (in long x, in long y);`
    #[inline]
    pub unsafe fn GetRowAt(&self, x: libc::int32_t, y: libc::int32_t, _retval: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetRowAt)(self, x, y, _retval)
    }


    /// ```text
    /// /**
    ///    * A hit test that can tell you what cell the mouse is over.  Row is the row index
    ///    * hit,  returns -1 for invalid mouse coordinates.  ColID is the column hit.
    ///    * ChildElt is the pseudoelement hit: this can have values of
    ///    * "cell", "twisty", "image", and "text".
    ///    *
    ///    * The coordinate system is the client coordinate system for the
    ///    * document this boxObject lives in, and the units are CSS pixels.
    ///    */
    /// ```
    ///

    /// `void getCellAt (in long x, in long y, out long row, out nsITreeColumn col, out AString childElt);`
    #[inline]
    pub unsafe fn GetCellAt(&self, x: libc::int32_t, y: libc::int32_t, row: *mut libc::int32_t, col: *mut *const nsITreeColumn, childElt: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetCellAt)(self, x, y, row, col, childElt)
    }


    /// ```text
    /// /**
    ///    * Find the coordinates of an element within a specific cell.
    ///    */
    /// ```
    ///

    /// `void getCoordsForCellItem (in long row, in nsITreeColumn col, in AString element, out long x, out long y, out long width, out long height);`
    #[inline]
    pub unsafe fn GetCoordsForCellItem(&self, row: libc::int32_t, col: *const nsITreeColumn, element: &::nsstring::nsAString, x: *mut libc::int32_t, y: *mut libc::int32_t, width: *mut libc::int32_t, height: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetCoordsForCellItem)(self, row, col, element, x, y, width, height)
    }


    /// ```text
    /// /**
    ///    * Determine if the text of a cell is being cropped or not.
    ///    */
    /// ```
    ///

    /// `boolean isCellCropped (in long row, in nsITreeColumn col);`
    #[inline]
    pub unsafe fn IsCellCropped(&self, row: libc::int32_t, col: *const nsITreeColumn, _retval: *mut bool) -> nsresult {
        ((*self.vtable).IsCellCropped)(self, row, col, _retval)
    }


    /// ```text
    /// /**
    ///    * The view is responsible for calling these notification methods when
    ///    * rows are added or removed.  Index is the position at which the new
    ///    * rows were added or at which rows were removed.  For
    ///    * non-contiguous additions/removals, this method should be called multiple times.
    ///    */
    /// ```
    ///

    /// `void rowCountChanged (in long index, in long count);`
    #[inline]
    pub unsafe fn RowCountChanged(&self, index: libc::int32_t, count: libc::int32_t) -> nsresult {
        ((*self.vtable).RowCountChanged)(self, index, count)
    }


    /// ```text
    /// /**
    ///    * Notify the tree that the view is about to perform a batch
    ///    * update, that is, add, remove or invalidate several rows at once.
    ///    * This must be followed by calling endUpdateBatch(), otherwise the tree
    ///    * will get out of sync.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Notify the tree that the view has completed a batch update.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Called on a theme switch to flush out the tree's style and image caches.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Remove an image source from the image cache to allow its invalidation.
    ///    *
    ///    * @note This only affects images supplied by the view, not the ones supplied
    ///    *       through the styling context, like twisties or checkboxes.
    ///    */
    /// ```
    ///

    /// `void removeImageCacheEntry (in long row, in nsITreeColumn col);`
    #[inline]
    pub unsafe fn RemoveImageCacheEntry(&self, row: libc::int32_t, col: *const nsITreeColumn) -> nsresult {
        ((*self.vtable).RemoveImageCacheEntry)(self, row, col)
    }


}