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


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

    /// 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 nsIHTMLAbsPosEditor.
unsafe impl XpCom for nsIHTMLAbsPosEditor {
    const IID: nsIID = nsID(0x91375f52, 0x20e6, 0x4757,
        [0x98, 0x35, 0xeb, 0x04, 0xfa, 0xbe, 0x54, 0x98]);
}

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

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

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

    /* readonly attribute boolean selectionContainerAbsolutelyPositioned; */
    pub GetSelectionContainerAbsolutelyPositioned: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aSelectionContainerAbsolutelyPositioned: *mut bool) -> nsresult,

    /* readonly attribute nsIDOMElement positionedElement; */
    pub GetPositionedElement: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aPositionedElement: *mut *const nsIDOMElement) -> nsresult,

    /* attribute boolean absolutePositioningEnabled; */
    pub GetAbsolutePositioningEnabled: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aAbsolutePositioningEnabled: *mut bool) -> nsresult,

    /* attribute boolean absolutePositioningEnabled; */
    pub SetAbsolutePositioningEnabled: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aAbsolutePositioningEnabled: bool) -> nsresult,

    /* attribute boolean snapToGridEnabled; */
    pub GetSnapToGridEnabled: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aSnapToGridEnabled: *mut bool) -> nsresult,

    /* attribute boolean snapToGridEnabled; */
    pub SetSnapToGridEnabled: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aSnapToGridEnabled: bool) -> nsresult,

    /* attribute unsigned long gridSize; */
    pub GetGridSize: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aGridSize: *mut libc::uint32_t) -> nsresult,

    /* attribute unsigned long gridSize; */
    pub SetGridSize: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aGridSize: libc::uint32_t) -> nsresult,

    /* readonly attribute nsIDOMElement absolutelyPositionedSelectionContainer; */
    pub GetAbsolutelyPositionedSelectionContainer: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aAbsolutelyPositionedSelectionContainer: *mut *const nsIDOMElement) -> nsresult,

    /* void absolutePositionSelection (in boolean aEnabled); */
    pub AbsolutePositionSelection: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aEnabled: bool) -> nsresult,

    /* void relativeChangeZIndex (in long aChange); */
    pub RelativeChangeZIndex: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aChange: libc::int32_t) -> nsresult,

    /* void absolutelyPositionElement (in nsIDOMElement aElement, in boolean aEnabled); */
    pub AbsolutelyPositionElement: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aElement: *const nsIDOMElement, aEnabled: bool) -> nsresult,

    /* void setElementPosition (in nsIDOMElement aElement, in long aX, in long aY); */
    pub SetElementPosition: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aElement: *const nsIDOMElement, aX: libc::int32_t, aY: libc::int32_t) -> nsresult,

    /* long getElementZIndex (in nsIDOMElement aElement); */
    pub GetElementZIndex: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aElement: *const nsIDOMElement, _retval: *mut libc::int32_t) -> nsresult,

    /* void setElementZIndex (in nsIDOMElement aElement, in long aZorder); */
    pub SetElementZIndex: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aElement: *const nsIDOMElement, aZorder: libc::int32_t) -> nsresult,

    /* long relativeChangeElementZIndex (in nsIDOMElement aElement, in long aChange); */
    pub RelativeChangeElementZIndex: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aElement: *const nsIDOMElement, aChange: libc::int32_t, _retval: *mut libc::int32_t) -> nsresult,

    /* void showGrabberOnElement (in nsIDOMElement aElement); */
    pub ShowGrabberOnElement: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor, aElement: *const nsIDOMElement) -> nsresult,

    /* void hideGrabber (); */
    pub HideGrabber: unsafe extern "system" fn (this: *const nsIHTMLAbsPosEditor) -> nsresult,

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

    /// ```text
    /// /**
    ///    * true if the selection container is absolutely positioned
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * this contains the absolutely positioned element currently edited
    ///    * or null
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * true if Absolute Positioning handling is enabled in the editor
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * true if Absolute Positioning handling is enabled in the editor
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * true if Snap To Grid is enabled in the editor.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * true if Snap To Grid is enabled in the editor.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * sets the grid size in pixels.
    ///    * @param aSizeInPixels [IN] the size of the grid in pixels
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * sets the grid size in pixels.
    ///    * @param aSizeInPixels [IN] the size of the grid in pixels
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * returns the deepest absolutely positioned container of the selection
    ///    * if it exists or null.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * extracts the selection from the normal flow of the document and
    ///    * positions it.
    ///    * @param aEnabled [IN] true to absolutely position the selection,
    ///    *                      false to put it back in the normal flow
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * adds aChange to the z-index of the currently positioned element.
    ///    * @param aChange [IN] relative change to apply to current z-index
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * extracts an element from the normal flow of the document and
    ///    * positions it, and puts it back in the normal flow.
    ///    * @param aElement [IN] the element
    ///    * @param aEnabled [IN] true to absolutely position the element,
    ///    *                      false to put it back in the normal flow
    ///    */
    /// ```
    ///

    /// `void absolutelyPositionElement (in nsIDOMElement aElement, in boolean aEnabled);`
    #[inline]
    pub unsafe fn AbsolutelyPositionElement(&self, aElement: *const nsIDOMElement, aEnabled: bool) -> nsresult {
        ((*self.vtable).AbsolutelyPositionElement)(self, aElement, aEnabled)
    }


    /// ```text
    /// /**
    ///    * sets the position of an element; warning it does NOT check if the
    ///    * element is already positioned or not and that's on purpose.
    ///    * @param aElement [IN] the element
    ///    * @param aX       [IN] the x position in pixels.
    ///    * @param aY       [IN] the y position in pixels.
    ///    */
    /// ```
    ///

    /// `void setElementPosition (in nsIDOMElement aElement, in long aX, in long aY);`
    #[inline]
    pub unsafe fn SetElementPosition(&self, aElement: *const nsIDOMElement, aX: libc::int32_t, aY: libc::int32_t) -> nsresult {
        ((*self.vtable).SetElementPosition)(self, aElement, aX, aY)
    }


    /// ```text
    /// /**
    ///    * returns the absolute z-index of a positioned element. Never returns 'auto'.
    ///    * @return         the z-index of the element
    ///    * @param aElement [IN] the element.
    ///    */
    /// ```
    ///

    /// `long getElementZIndex (in nsIDOMElement aElement);`
    #[inline]
    pub unsafe fn GetElementZIndex(&self, aElement: *const nsIDOMElement, _retval: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetElementZIndex)(self, aElement, _retval)
    }


    /// ```text
    /// /**
    ///    * sets the z-index of an element.
    ///    * @param aElement [IN] the element
    ///    * @param aZorder  [IN] the z-index
    ///    */
    /// ```
    ///

    /// `void setElementZIndex (in nsIDOMElement aElement, in long aZorder);`
    #[inline]
    pub unsafe fn SetElementZIndex(&self, aElement: *const nsIDOMElement, aZorder: libc::int32_t) -> nsresult {
        ((*self.vtable).SetElementZIndex)(self, aElement, aZorder)
    }


    /// ```text
    /// /**
    ///    * adds aChange to the z-index of an arbitrary element.
    ///    * @return         the new z-index of the element
    ///    * @param aElement [IN] the element
    ///    * @param aChange  [IN] relative change to apply to current z-index of
    ///    *                      the element
    ///    */
    /// ```
    ///

    /// `long relativeChangeElementZIndex (in nsIDOMElement aElement, in long aChange);`
    #[inline]
    pub unsafe fn RelativeChangeElementZIndex(&self, aElement: *const nsIDOMElement, aChange: libc::int32_t, _retval: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).RelativeChangeElementZIndex)(self, aElement, aChange, _retval)
    }


    /// ```text
    /// /**
    ///    * shows a grabber attached to an arbitrary element. The grabber is an image
    ///    * positioned on the left hand side of the top border of the element. Dragging
    ///    * and dropping it allows to change the element's absolute position in the
    ///    * document. See chrome://editor/content/images/grabber.gif
    ///    * @param aElement [IN] the element
    ///    */
    /// ```
    ///

    /// `void showGrabberOnElement (in nsIDOMElement aElement);`
    #[inline]
    pub unsafe fn ShowGrabberOnElement(&self, aElement: *const nsIDOMElement) -> nsresult {
        ((*self.vtable).ShowGrabberOnElement)(self, aElement)
    }


    /// ```text
    /// /**
    ///    * hide the grabber if it shown.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * refreshes the grabber if it shown, possibly updating its position or
    ///    * even hiding it.
    ///    */
    /// ```
    ///

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


}