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


/// `interface nsISelection : nsISupports`
///

/// ```text
/// /**
///  * Interface for manipulating and querying the current selected range
///  * of nodes within the document.
///  *
///  * @version 1.0
///  */
/// ```
///

// 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 nsISelection {
    vtable: *const nsISelectionVTable,

    /// 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 nsISelection.
unsafe impl XpCom for nsISelection {
    const IID: nsIID = nsID(0xe0a4d4b3, 0xf34e, 0x44bd,
        [0xb1, 0xf2, 0x4e, 0x3b, 0xde, 0x9b, 0x69, 0x15]);
}

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

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

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

    /* readonly attribute nsIDOMNode anchorNode; */
    pub GetAnchorNode: unsafe extern "system" fn (this: *const nsISelection, aAnchorNode: *mut *const nsIDOMNode) -> nsresult,

    /* readonly attribute long anchorOffset; */
    pub GetAnchorOffset: unsafe extern "system" fn (this: *const nsISelection, aAnchorOffset: *mut libc::int32_t) -> nsresult,

    /* readonly attribute nsIDOMNode focusNode; */
    pub GetFocusNode: unsafe extern "system" fn (this: *const nsISelection, aFocusNode: *mut *const nsIDOMNode) -> nsresult,

    /* readonly attribute long focusOffset; */
    pub GetFocusOffset: unsafe extern "system" fn (this: *const nsISelection, aFocusOffset: *mut libc::int32_t) -> nsresult,

    /* readonly attribute boolean isCollapsed; */
    pub GetIsCollapsed: unsafe extern "system" fn (this: *const nsISelection, aIsCollapsed: *mut bool) -> nsresult,

    /* [noscript,nostdcall,notxpcom] boolean collapsed (); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub Collapsed: *const ::libc::c_void,

    /* readonly attribute long rangeCount; */
    pub GetRangeCount: unsafe extern "system" fn (this: *const nsISelection, aRangeCount: *mut libc::int32_t) -> nsresult,

    /* nsIDOMRange getRangeAt (in long index); */
    pub GetRangeAt: unsafe extern "system" fn (this: *const nsISelection, index: libc::int32_t, _retval: *mut *const nsIDOMRange) -> nsresult,

    /* void collapse (in nsIDOMNode parentNode, in long offset); */
    pub Collapse: unsafe extern "system" fn (this: *const nsISelection, parentNode: *const nsIDOMNode, offset: libc::int32_t) -> nsresult,

    /* [noscript] void collapseNative (in nsINode parentNode, in long offset); */
    pub CollapseNative: unsafe extern "system" fn (this: *const nsISelection, parentNode: *const nsINode, offset: libc::int32_t) -> nsresult,

    /* void extend (in nsIDOMNode parentNode, in long offset); */
    pub Extend: unsafe extern "system" fn (this: *const nsISelection, parentNode: *const nsIDOMNode, offset: libc::int32_t) -> nsresult,

    /* [noscript] void extendNative (in nsINode parentNode, in long offset); */
    pub ExtendNative: unsafe extern "system" fn (this: *const nsISelection, parentNode: *const nsINode, offset: libc::int32_t) -> nsresult,

    /* void collapseToStart (); */
    pub CollapseToStart: unsafe extern "system" fn (this: *const nsISelection) -> nsresult,

    /* void collapseToEnd (); */
    pub CollapseToEnd: unsafe extern "system" fn (this: *const nsISelection) -> nsresult,

    /* boolean containsNode (in nsIDOMNode node, in boolean partlyContained); */
    pub ContainsNode: unsafe extern "system" fn (this: *const nsISelection, node: *const nsIDOMNode, partlyContained: bool, _retval: *mut bool) -> nsresult,

    /* void selectAllChildren (in nsIDOMNode parentNode); */
    pub SelectAllChildren: unsafe extern "system" fn (this: *const nsISelection, parentNode: *const nsIDOMNode) -> nsresult,

    /* void addRange (in nsIDOMRange range); */
    pub AddRange: unsafe extern "system" fn (this: *const nsISelection, range: *const nsIDOMRange) -> nsresult,

    /* void removeRange (in nsIDOMRange range); */
    pub RemoveRange: unsafe extern "system" fn (this: *const nsISelection, range: *const nsIDOMRange) -> nsresult,

    /* void removeAllRanges (); */
    pub RemoveAllRanges: unsafe extern "system" fn (this: *const nsISelection) -> nsresult,

    /* void deleteFromDocument (); */
    pub DeleteFromDocument: unsafe extern "system" fn (this: *const nsISelection) -> nsresult,

    /* DOMString toString (); */
    pub ToString: unsafe extern "system" fn (this: *const nsISelection, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void modify (in DOMString alter, in DOMString direction, in DOMString granularity); */
    pub Modify: unsafe extern "system" fn (this: *const nsISelection, alter: &::nsstring::nsAString, direction: &::nsstring::nsAString, granularity: &::nsstring::nsAString) -> 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 nsISelection {

    /// ```text
    /// /**
    ///      * Returns the node in which the selection begins.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsIDOMNode anchorNode;`
    #[inline]
    pub unsafe fn GetAnchorNode(&self, aAnchorNode: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).GetAnchorNode)(self, aAnchorNode)
    }


    /// ```text
    /// /**
    ///      * The offset within the (text) node where the selection begins.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Returns the node in which the selection ends.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsIDOMNode focusNode;`
    #[inline]
    pub unsafe fn GetFocusNode(&self, aFocusNode: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).GetFocusNode)(self, aFocusNode)
    }


    /// ```text
    /// /**
    ///      * The offset within the (text) node where the selection ends.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Indicates if the selection is collapsed or not.
    ///      */
    /// ```
    ///

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



    /// `[noscript,nostdcall,notxpcom] boolean collapsed ();`
    const _Collapsed: () = ();

    /// ```text
    /// /**
    ///      * Returns the number of ranges in the selection.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Returns the range at the specified index.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Collapses the selection to a single point, at the specified offset
    ///      * in the given DOM node. When the selection is collapsed, and the content
    ///      * is focused and editable, the caret will blink there.
    ///      * @param parentNode      The given dom node where the selection will be set
    ///      * @param offset          Where in given dom node to place the selection (the offset into the given node)
    ///      */
    /// ```
    ///

    /// `void collapse (in nsIDOMNode parentNode, in long offset);`
    #[inline]
    pub unsafe fn Collapse(&self, parentNode: *const nsIDOMNode, offset: libc::int32_t) -> nsresult {
        ((*self.vtable).Collapse)(self, parentNode, offset)
    }



    /// `[noscript] void collapseNative (in nsINode parentNode, in long offset);`
    #[inline]
    pub unsafe fn CollapseNative(&self, parentNode: *const nsINode, offset: libc::int32_t) -> nsresult {
        ((*self.vtable).CollapseNative)(self, parentNode, offset)
    }


    /// ```text
    /// /**
    ///      * Extends the selection by moving the selection end to the specified node and offset,
    ///      * preserving the selection begin position. The new selection end result will always
    ///      * be from the anchorNode to the new focusNode, regardless of direction.
    ///      * @param parentNode      The node where the selection will be extended to
    ///      * @param offset          Where in node to place the offset in the new selection end
    ///      */
    /// ```
    ///

    /// `void extend (in nsIDOMNode parentNode, in long offset);`
    #[inline]
    pub unsafe fn Extend(&self, parentNode: *const nsIDOMNode, offset: libc::int32_t) -> nsresult {
        ((*self.vtable).Extend)(self, parentNode, offset)
    }



    /// `[noscript] void extendNative (in nsINode parentNode, in long offset);`
    #[inline]
    pub unsafe fn ExtendNative(&self, parentNode: *const nsINode, offset: libc::int32_t) -> nsresult {
        ((*self.vtable).ExtendNative)(self, parentNode, offset)
    }


    /// ```text
    /// /**
    ///      * Collapses the whole selection to a single point at the start
    ///      * of the current selection (irrespective of direction).  If content
    ///      * is focused and editable, the caret will blink there.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Collapses the whole selection to a single point at the end
    ///      * of the current selection (irrespective of direction).  If content
    ///      * is focused and editable, the caret will blink there.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Indicates whether the node is part of the selection. If partlyContained
    ///      * is set to PR_TRUE, the function returns true when some part of the node
    ///      * is part of the selection. If partlyContained is set to PR_FALSE, the
    ///      * function only returns true when the entire node is part of the selection.
    ///      */
    /// ```
    ///

    /// `boolean containsNode (in nsIDOMNode node, in boolean partlyContained);`
    #[inline]
    pub unsafe fn ContainsNode(&self, node: *const nsIDOMNode, partlyContained: bool, _retval: *mut bool) -> nsresult {
        ((*self.vtable).ContainsNode)(self, node, partlyContained, _retval)
    }


    /// ```text
    /// /**
    ///      * Adds all children of the specified node to the selection.
    ///      * @param parentNode  the parent of the children to be added to the selection.
    ///      */
    /// ```
    ///

    /// `void selectAllChildren (in nsIDOMNode parentNode);`
    #[inline]
    pub unsafe fn SelectAllChildren(&self, parentNode: *const nsIDOMNode) -> nsresult {
        ((*self.vtable).SelectAllChildren)(self, parentNode)
    }


    /// ```text
    /// /**
    ///      * Adds a range to the current selection.
    ///      */
    /// ```
    ///

    /// `void addRange (in nsIDOMRange range);`
    #[inline]
    pub unsafe fn AddRange(&self, range: *const nsIDOMRange) -> nsresult {
        ((*self.vtable).AddRange)(self, range)
    }


    /// ```text
    /// /**
    ///      * Removes a range from the current selection.
    ///      */
    /// ```
    ///

    /// `void removeRange (in nsIDOMRange range);`
    #[inline]
    pub unsafe fn RemoveRange(&self, range: *const nsIDOMRange) -> nsresult {
        ((*self.vtable).RemoveRange)(self, range)
    }


    /// ```text
    /// /**
    ///      * Removes all ranges from the current selection.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Deletes this selection from document the nodes belong to.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Returns the whole selection into a plain text string.
    ///      */
    /// ```
    ///

    /// `DOMString toString ();`
    #[inline]
    pub unsafe fn ToString(&self, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).ToString)(self, _retval)
    }


    /// ```text
    /// /**
    ///      * Modifies the selection.  Note that the parameters are case-insensitive.
    ///      *
    ///      * @param alter can be one of { "move", "extend" }
    ///      *   - "move" collapses the selection to the end of the selection and
    ///      *      applies the movement direction/granularity to the collapsed
    ///      *      selection.
    ///      *   - "extend" leaves the start of the selection unchanged, and applies
    ///      *      movement direction/granularity to the end of the selection.
    ///      * @param direction can be one of { "forward", "backward", "left", "right" }
    ///      * @param granularity can be one of { "character", "word",
        ///      *                                    "line", "lineboundary" }
    ///      *
    ///      * @returns NS_ERROR_NOT_IMPLEMENTED if the granularity is "sentence",
    ///      * "sentenceboundary", "paragraph", "paragraphboundary", or
    ///      * "documentboundary".  Returns NS_ERROR_INVALID_ARG if alter, direction,
    ///      * or granularity has an unrecognized value.
    ///      */
    /// ```
    ///

    /// `void modify (in DOMString alter, in DOMString direction, in DOMString granularity);`
    #[inline]
    pub unsafe fn Modify(&self, alter: &::nsstring::nsAString, direction: &::nsstring::nsAString, granularity: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).Modify)(self, alter, direction, granularity)
    }


}