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


/// `interface nsITextInputProcessor : nsISupports`
///

/// ```text
/// /**
///  * An nsITextInputProcessor instance is associated with a top level widget which
///  * handles native IME.  It's associated by calling beginInputTransaction() or
///  * beginInputTransactionForTests().  While an instance has composition, nobody
///  * can steal the rights to make composition on the top level widget.  In other
///  * words, if another instance is composing on a top level widget, either
///  * beginInputTransaction() or beginInputTransactionForTests() returns false
///  * (i.e., not throws an exception).
///  *
///  * NOTE: See nsITextInputProcessorCallback.idl for examples of |callback| in
///  *       following examples,
///  *
///  * Example #1 JS-IME can start composition like this:
///  *
///  *   var TIP = Components.classes["@mozilla.org/text-input-processor;1"].
///  *               createInstance(Components.interfaces.nsITextInputProcessor);
///  *   if (!TIP.beginInputTransaction(window, callback)) {
    ///  *     return; // You failed to get the rights to make composition
    ///  *   }
///  *   // Create a keyboard event if the following compositionc change is caused
///  *   // by a key event.
///  *   var keyEvent =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   // Set new composition string first
///  *   TIP.setPendingCompositionString("some-words-are-inputted");
///  *   // Set clause information.
///  *   TIP.appendClauseToPendingComposition(23, TIP.ATTR_RAW_CLAUSE);
///  *   // Set caret position, this is optional.
///  *   TIP.setCaretInPendingComposition(23);
///  *   // Flush the pending composition
///  *   if (!TIP.flushPendingComposition(keyEvent)) {
    ///  *     // If it returns false, it fails to start composition.
    ///  *     return;
    ///  *   }
///  *
///  * Example #2 JS-IME can separate composition string to two or more clauses:
///  *
///  *   // Create a keyboard event if the following compositionc change is caused
///  *   // by a key event.
///  *   var keyEvent =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   // First, set composition string again
///  *   TIP.setPendingCompositionString("some-words-are-inputted");
///  *   // Then, if "are" is selected to convert, there are 3 clauses:
///  *   TIP.appendClauseToPendingComposition(11, TIP.ATTR_CONVERTED_CLAUSE);
///  *   TIP.appendClauseToPendingComposition(3,  TIP.ATTR_SELECTED_CLAUSE);
///  *   TIP.appendClauseToPendingComposition(9,  TIP.ATTR_CONVERTED_CLAUSE);
///  *   // Show caret at the beginning of the selected clause
///  *   TIP.setCaretInPendingComposition(11);
///  *   // Flush the pending composition.  Note that if there is a composition,
///  *   // flushPendingComposition() won't return false.
///  *   TIP.flushPendingComposition(keyEvent);
///  *
///  * Example #3 JS-IME can commit composition with specific string with this:
///  *
///  *   // Create a keyboard event if the following compositionc change is caused
///  *   // by a key event.
///  *   var keyEvent1 =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   // First, there is a composition.
///  *   TIP.setPendingCompositionString("some-words-directly-inputted");
///  *   TIP.appendClauseToPendingComposition(28, TIP.ATTR_RAW_CLAUSE);
///  *   TIP.flushPendingComposition(keyEvent1);
///  *   // Create a keyboard event if the following commit composition is caused
///  *   // by a key event.
///  *   var keyEvent2 =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   // This is useful when user selects a commit string from candidate list UI
///  *   // which is provided by JS-IME.
///  *   TIP.commitCompositionWith("selected-words-from-candidate-list", keyEvent2);
///  *
///  * Example #4 JS-IME can commit composition with the last composition string
///  *            without specifying commit string:
///  *
///  *   // Create a keyboard event if the following compositionc change is caused
///  *   // by a key event.
///  *   var keyEvent1 =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   // First, there is a composition.
///  *   TIP.setPendingCompositionString("some-words-will-be-commited");
///  *   TIP.appendClauseToPendingComposition(27, TIP.ATTR_RAW_CLAUSE);
///  *   TIP.flushPendingComposition(keyEvent1);
///  *   // Create a keyboard event if the following commit is caused by a key
///  *   // event.
///  *   var keyEvent2 =
///  *     new KeyboardEvent("", { key: "Enter", code: "Enter",
        ///                                keyCode: KeyboardEvent.DOM_VK_RETURN });
///  *   // This is useful when user just type Enter key.
///  *   TIP.commitComposition(keyEvent2);
///  *
///  * Example #5 JS-IME can cancel composition with this:
///  *
///  *   // Create a keyboard event if the following composition change is caused
///  *   // by a key event.
///  *   var keyEvent1 =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   // First, there is a composition.
///  *   TIP.setPendingCompositionString("some-words-will-be-canceled");
///  *   TIP.appendClauseToPendingComposition(27, TIP.ATTR_RAW_CLAUSE);
///  *   TIP.flushPendingComposition(keyEvent1);
///  *   // Create a keyboard event if the following canceling composition is
///  *   // caused by a key event.
///  *   var keyEvent2 =
///  *     new KeyboardEvent("", { key: "Escape", code: "Escape",
        ///                                keyCode: KeyboardEvent.DOM_VK_ESCAPE });
///  *   // This is useful when user doesn't want to commit the composition.
///  *   // FYI: This is same as TIP.commitCompositionWith("") for now.
///  *   TIP.cancelComposition(keyEvent2);
///  *
///  * Example #6 JS-IME can insert text only with commitCompositionWith():
///  *
///  *   // Create a keyboard event if the following inserting text is caused by a
///  *   // key event.
///  *   var keyEvent1 =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   if (!TIP.beginInputTransaction(window, callback)) {
    ///  *     return; // You failed to get the rights to make composition
    ///  *   }
///  *   TIP.commitCompositionWith("Some words", keyEvent1);
///  *
///  * Example #7 JS-IME can start composition explicitly:
///  *
///  *   if (!TIP.beginInputTransaction(window, callback)) {
    ///  *     return; // You failed to get the rights to make composition
    ///  *   }
///  *   // Create a keyboard event if the following starting composition is caused
///  *   // by a key event.
///  *   var keyEvent1 =
///  *     new KeyboardEvent("", { key: "foo", code: "bar", keyCode: buzz });
///  *   // If JS-IME don't want to show composing string in the focused editor,
///  *   // JS-IME can dispatch only compositionstart event with this.
///  *   if (!TIP.startComposition(keyEvent1)) {
    ///  *     // Failed to start composition.
    ///  *     return;
    ///  *   }
///  *   // And when user selects a result from UI of JS-IME, commit with it.
///  *   // Then, the key event should be null.
///  *   TIP.commitCompositionWith("selected-words");
///  *
///  * Example #8 JS-IME or JS-Keyboard should dispatch key events even during
///  *            composition (non-printable key case):
///  *
///  *   if (!TIP.beginInputTransaction(window, callback)) {
    ///  *     return; // You failed to get the rights to dispatch key events
    ///  *   }
///  *
///  *   // You don't need to specify .keyCode value if it's non-printable key
///  *   // because it can be computed from .key value.
///  *   // If you specify non-zero value to .keyCode, it'll be used.
///  *   var keyEvent = new KeyboardEvent("", { code: "Enter", key: "Enter" });
///  *   if (TIP.keydown(keyEvent)) {
    ///  *     // Handle its default action
    ///  *   }
///  *
///  *   // Even if keydown event was consumed, keyup event should be dispatched.
///  *   if (TIP.keyup(keyEvent)) {
    ///  *     // Handle its default action
    ///  *   }
///  *
///  * Example #9 JS-IME or JS-Keyboard should dispatch key events even during
///  *            composition (printable key case):
///  *
///  *   if (!TIP.beginInputTransaction(window, callback)) {
    ///  *     return; // You failed to get the rights to dispatch key events
    ///  *   }
///  *
///  *   // You need to specify .keyCode value if it's printable key.
///  *   // The rules of .keyCode value is documented in MDN:
///  *   //   https://developer.mozilla.org/docs/Web/API/KeyboardEvent.keyCode
///  *   //
///  *   //   #1 If the key location is DOM_KEY_LOCATION_NUMPAD and NumLock is
///  *   //      active, you should specify DOM_VK_NUMPAD[0-9], DOM_VK_MULTIPLY,
///  *   //      DOM_VK_ADD, DOM_VK_SEPARATOR, DOM_VK_SUBTRACT, DOM_VK_DECIMAL or
///  *   //      DOM_VK_DIVIDE.
///  *   //   #2 If the key is Spacebar, use DOM_VK_SPACE.
///  *   //
///  *   //   Following rules are printable keys in DOM_KEY_LOCATION_STANDARD.
///  *   //   .keyCode value for a key shouldn't be changed by modifier states:
///  *   //     #1 If the key can input [0-9] with any modifier state (except
    ///  *   //        NumLock state), the value should be DOM_VK_[0-9].
///  *   //     #2 Otherwise, and if the key inputs an ASCII alphabet with no
///  *   //        active modifiers, use DOM_VK_[A-Z].
///  *   //     #3 Otherwise, and if the key inputs an ASCII alphabet with no
///  *   //        active modifiers except Shift key state, use DOM_VK_[A-Z] for
///  *   //        the shifted character.  E.g., if a key causes non-alphabet
///  *   //        character such as "@" or a Unicode character without Shift key
///  *   //        but "a" is inputted when Shift key is pressed, the proper
///  *   //        keyCode is DOM_VK_A.
///  *   //     #4 Otherwise, and if the key inputs another ASCII character with
///  *   //        no modifier states, use a proper value for the character.  E.g.,
///  *   //        if the key inputs "*" without Shift key state, it should be
///  *   //        DOM_VK_ASTERISK.
///  *   //     #5 Otherwise, and if the key inputs another ASCII character with
///  *   //        Shift key state, use a proper value for the character.  E.g.,
///  *   //        if a key causes a Unicode character without Shift key but "&"
///  *   //        is inputted when Shift key is pressed, the proper keyCode is
///  *   //        DOM_VK_AMPERSAND.
///  *   //     See above document for the other cases.
///  *   //
///  *   // NOTE: If the software keyboard is 10-key like simple phone,
///  *   //       We don't have common rules to decide its .keyCode value.
///  *   //       Above rules should be used when the JS-Keyboard emulates PC
///  *   //       keyboard.
///  *   // .key value should be inputting character by the key with current
///  *   // modifier state.
///  *   // .code value should be empty string if the JS-Keyboard isn't emulating
///  *   // physical keyboard.  Otherwise, use same value with physical keyboard's
///  *   // same key.
///  *   var keyEvent = new KeyboardEvent("", { code: "KeyA", key: "a",
        ///  *                                          keyCode: KeyboardEvent.DOM_VK_A });
///  *   if (TIP.keydown(keyEvent)) {
    ///  *     // Handle its default action
    ///  *   }
///  *
///  *   // Even if keydown event was consumed, keyup event should be dispatched.
///  *   if (TIP.keyup(keyEvent)) {
    ///  *     // Handle its default action
    ///  *   }
///  *
///  * Example #10 JS-Keyboard doesn't need to initialize modifier states at
///  *             calling either keydown() or keyup().
///  *
///  *   // Neither beginInputTransaction() nor beginInputTransactionForTests()
///  *   // resets modifier state.
///  *   if (!TIP.beginInputTransaction(window, callback)) {
    ///  *     return; // You failed to get the rights to dispatch key events
    ///  *   }
///  *
///  *   var leftShift = new KeyboardEvent("", { code: "ShiftLeft", key: "Shift" });
///  *
///  *   // This causes following key events will be shifted automatically.
///  *   TIP.keydown(leftShift);
///  *
///  *   var rightShift =
///  *     new KeyboardEvent("", { code: "ShiftRight", key: "Shift" });
///  *
///  *   TIP.keydown(rightShift);
///  *
///  *   // keyup of one of shift key doesn't cause inactivating "Shift" state.
///  *   TIP.keyup(rightShift);
///  *
///  *   // This causes inactivating "Shift" state completely.
///  *   TIP.keyup(leftShift);
///  */
/// ```
///

// 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 nsITextInputProcessor {
    vtable: *const nsITextInputProcessorVTable,

    /// 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 nsITextInputProcessor.
unsafe impl XpCom for nsITextInputProcessor {
    const IID: nsIID = nsID(0x47ae2181, 0x2e98, 0x4d58,
        [0x84, 0xa2, 0xb8, 0xdb, 0x67, 0x64, 0xce, 0x9a]);
}

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

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

impl nsITextInputProcessor {
    /// Cast this `nsITextInputProcessor` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsITextInputProcessorCoerce>(&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 nsITextInputProcessor {
    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> nsITextInputProcessorCoerce for T {
    #[inline]
    fn coerce_from(v: &nsITextInputProcessor) -> &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 nsITextInputProcessor
// 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 nsITextInputProcessorVTable {
    /// 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 hasComposition; */
    pub GetHasComposition: unsafe extern "system" fn (this: *const nsITextInputProcessor, aHasComposition: *mut bool) -> nsresult,

    /* boolean beginInputTransaction (in mozIDOMWindow aWindow, in nsITextInputProcessorCallback aCallback); */
    pub BeginInputTransaction: unsafe extern "system" fn (this: *const nsITextInputProcessor, aWindow: *const mozIDOMWindow, aCallback: *const nsITextInputProcessorCallback, _retval: *mut bool) -> nsresult,

    /* [optional_argc] boolean beginInputTransactionForTests (in mozIDOMWindow aWindow, [optional] in nsITextInputProcessorCallback aCallback); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub BeginInputTransactionForTests: *const ::libc::c_void,

    /* [optional_argc] boolean startComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub StartComposition: *const ::libc::c_void,

    /* void setPendingCompositionString (in DOMString aString); */
    pub SetPendingCompositionString: unsafe extern "system" fn (this: *const nsITextInputProcessor, aString: &::nsstring::nsAString) -> nsresult,

    /* void appendClauseToPendingComposition (in unsigned long aLength, in unsigned long aAttribute); */
    pub AppendClauseToPendingComposition: unsafe extern "system" fn (this: *const nsITextInputProcessor, aLength: libc::uint32_t, aAttribute: libc::uint32_t) -> nsresult,

    /* void setCaretInPendingComposition (in unsigned long aOffset); */
    pub SetCaretInPendingComposition: unsafe extern "system" fn (this: *const nsITextInputProcessor, aOffset: libc::uint32_t) -> nsresult,

    /* [optional_argc] boolean flushPendingComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub FlushPendingComposition: *const ::libc::c_void,

    /* [optional_argc] void commitComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub CommitComposition: *const ::libc::c_void,

    /* [optional_argc] boolean commitCompositionWith (in DOMString aCommitString, [optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub CommitCompositionWith: *const ::libc::c_void,

    /* [optional_argc] void cancelComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub CancelComposition: *const ::libc::c_void,

    /* [optional_argc] unsigned long keydown (in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub Keydown: *const ::libc::c_void,

    /* [optional_argc] boolean keyup (in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags); */
    /// Unable to generate binding because `optional_argc is unsupported`
    pub Keyup: *const ::libc::c_void,

    /* boolean getModifierState (in DOMString aModifierKey); */
    pub GetModifierState: unsafe extern "system" fn (this: *const nsITextInputProcessor, aModifierKey: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* void shareModifierStateOf (in nsITextInputProcessor aOther); */
    pub ShareModifierStateOf: unsafe extern "system" fn (this: *const nsITextInputProcessor, aOther: *const nsITextInputProcessor) -> 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 nsITextInputProcessor {

    pub const ATTR_RAW_CLAUSE: i64 = 2;


    pub const ATTR_SELECTED_RAW_CLAUSE: i64 = 3;


    pub const ATTR_CONVERTED_CLAUSE: i64 = 4;


    pub const ATTR_SELECTED_CLAUSE: i64 = 5;


    pub const KEY_DEFAULT_PREVENTED: i64 = 1;


    pub const KEY_NON_PRINTABLE_KEY: i64 = 2;


    pub const KEY_FORCE_PRINTABLE_KEY: i64 = 4;


    pub const KEY_KEEP_KEY_LOCATION_STANDARD: i64 = 8;


    pub const KEY_KEEP_KEYCODE_ZERO: i64 = 16;


    pub const KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT: i64 = 32;


    pub const KEYEVENT_NOT_CONSUMED: i64 = 0;


    pub const KEYDOWN_IS_CONSUMED: i64 = 1;


    pub const KEYPRESS_IS_CONSUMED: i64 = 2;

    /// ```text
    /// /**
    ///    * Returns true if this instance was dispatched compositionstart but hasn't
    ///    * dispatched compositionend yet.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * When you create an instance, you must call beginInputTransaction() first
    ///    * except when you created the instance for automated tests.
    ///    *
    ///    * @param aWindow         A DOM window.  The instance will look for a top
    ///    *                        level widget from this.
    ///    * @param aCallback       Callback interface which handles requests to
    ///    *                        IME and notifications to IME.  This must not be
    ///    *                        null.
    ///    * @return                If somebody uses internal text input service for a
    ///    *                        composition, this returns false.  Otherwise, returns
    ///    *                        true.  I.e., only your TIP can create composition
    ///    *                        when this returns true.  If this returns false,
    ///    *                        your TIP should wait next chance.
    ///    */
    /// ```
    ///

    /// `boolean beginInputTransaction (in mozIDOMWindow aWindow, in nsITextInputProcessorCallback aCallback);`
    #[inline]
    pub unsafe fn BeginInputTransaction(&self, aWindow: *const mozIDOMWindow, aCallback: *const nsITextInputProcessorCallback, _retval: *mut bool) -> nsresult {
        ((*self.vtable).BeginInputTransaction)(self, aWindow, aCallback, _retval)
    }


    /// ```text
    /// /**
    ///    * When you create an instance for automated test, you must call
    ///    * beginInputTransaction(), first.  See beginInputTransaction() for more
    ///    * detail of this.
    ///    * Note that aCallback can be null.  If it's null, nsITextInputProcessor
    ///    * implementation will handle them automatically.
    ///    */
    /// ```
    ///

    /// `[optional_argc] boolean beginInputTransactionForTests (in mozIDOMWindow aWindow, [optional] in nsITextInputProcessorCallback aCallback);`
    const _BeginInputTransactionForTests: () = ();

    /// ```text
    /// /**
    ///    * startComposition() dispatches compositionstart event explicitly.
    ///    * IME does NOT need to call this typically since compositionstart event
    ///    * is automatically dispatched by sendPendingComposition() if
    ///    * compositionstart event hasn't been dispatched yet.  If this is called
    ///    * when compositionstart has already been dispatched, this throws an
    ///    * exception.
    ///    *
    ///    * @param aKeyboardEvent  Key event which causes starting composition.
    ///    *                        If its type value is "keydown", this method
    ///    *                        dispatches only keydown event first.  Otherwise,
    ///    *                        dispatches keydown first and keyup at last.
    ///    * @param aKeyFlags       See KEY_* constants.
    ///    * @return                Returns true if composition starts normally.
    ///    *                        Otherwise, returns false because it might be
    ///    *                        canceled by the web application.
    ///    */
    /// ```
    ///

    /// `[optional_argc] boolean startComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags);`
    const _StartComposition: () = ();

    /// ```text
    /// /**
    ///    * Set new composition string.  Pending composition will be flushed by
    ///    * a call of flushPendingComposition().  However, if the new composition
    ///    * string isn't empty, you need to call appendClauseToPendingComposition() to
    ///    * fill all characters of aString with one or more clauses before flushing.
    ///    * Note that if you need to commit or cancel composition, use
    ///    * commitComposition(), commitCompositionWith() or cancelComposition().
    ///    */
    /// ```
    ///

    /// `void setPendingCompositionString (in DOMString aString);`
    #[inline]
    pub unsafe fn SetPendingCompositionString(&self, aString: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetPendingCompositionString)(self, aString)
    }


    /// ```text
    /// /**
    ///    * Append a clause to the pending composition.
    ///    *
    ///    * If you need to fill the pending composition string with a clause, you
    ///    * should call this once.  For example:
    ///    *   appendClauseToPendingComposition(compositionString.length,
        ///    *                                    ATTR_RAW_CLAUSE);
    ///    * is enough.  If you need to separate the pending composition string to
    ///    * multiple clauses, you need to call this multiple times. For example,
    ///    * if your pending composition string has three clauses and the second clause
    ///    * is being converted:
    ///    *  appendClauseToPendingComposition(firstClauseLength,
        ///    *                                   ATTR_CONVERTED_CLAUSE);
    ///    *  appendClauseToPendingComposition(secondClauseLength,
        ///    *                                   ATTR_SELECTED_CLAUSE);
    ///    *  appendClauseToPendingComposition(thirdClauseLength,
        ///    *                                   ATTR_CONVERTED_CLAUSE);
    ///    * Note that if sum of aLength mismatches length of the pending composition
    ///    * string, flushPendingComposition() will throw an exception.  I.e.,
    ///    * |firstClauseLength + secondClauseLength + thirdClauseLength| must be
    ///    * same as the length of pending composition string.
    ///    *
    ///    * TODO: Should be able to specify custom clause style.
    ///    *
    ///    * @param aLength         Length of the clause.
    ///    * @param aAttribute      One of ATTR_* constants.
    ///    */
    /// ```
    ///

    /// `void appendClauseToPendingComposition (in unsigned long aLength, in unsigned long aAttribute);`
    #[inline]
    pub unsafe fn AppendClauseToPendingComposition(&self, aLength: libc::uint32_t, aAttribute: libc::uint32_t) -> nsresult {
        ((*self.vtable).AppendClauseToPendingComposition)(self, aLength, aAttribute)
    }


    /// ```text
    /// /**
    ///    * Set caret offset in the pending composition string.  If you don't need to
    ///    * show a caret, you don't need to call this.
    ///    *
    ///    * @param aOffset         Caret offset in the pending composition string.
    ///    *                        This must be between 0 and length of the pending
    ///    *                        composition string.
    ///    */
    /// ```
    ///

    /// `void setCaretInPendingComposition (in unsigned long aOffset);`
    #[inline]
    pub unsafe fn SetCaretInPendingComposition(&self, aOffset: libc::uint32_t) -> nsresult {
        ((*self.vtable).SetCaretInPendingComposition)(self, aOffset)
    }


    /// ```text
    /// /**
    ///    * flushPendingComposition() must be called after
    ///    * setPendingCompositionString() and appendClauseToPendingComposition()
    ///    * (setCaretInPendingComposition() is optional) are called.
    ///    *
    ///    * Note that compositionstart will be automatically dispatched if this is
    ///    * called when there is no composition.
    ///    *
    ///    * Note that if sum of lengths of appended clauses are not same as composition
    ///    * string or caret offset is larger than the composition string length, this
    ///    * throws an exception.
    ///    *
    ///    * @param aKeyboardEvent  Key event which causes the composition string.
    ///    *                        If its type value is "keydown", this method
    ///    *                        dispatches only keydown event first.  Otherwise,
    ///    *                        dispatches keydown first and keyup at last.
    ///    * @param aKeyFlags       See KEY_* constants.
    ///    * @return                Returns true if there is a composition already or
    ///    *                        starting composition automatically.
    ///    *                        Otherwise, i.e., if it cannot start composition
    ///    *                        automatically, e.g., canceled by web apps, returns
    ///    *                        false.
    ///    */
    /// ```
    ///

    /// `[optional_argc] boolean flushPendingComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags);`
    const _FlushPendingComposition: () = ();

    /// ```text
    /// /**
    ///    * commitComposition() will commit composition with the last composition
    ///    * string.  If there is no composition, this will throw an exception.
    ///    *
    ///    * @param aKeyboardEvent  Key event which causes the commit composition.
    ///    *                        If its type value is "keydown", this method
    ///    *                        dispatches only keydown event first.  Otherwise,
    ///    *                        dispatches keydown first and keyup at last.
    ///    * @param aKeyFlags       See KEY_* constants.
    ///    */
    /// ```
    ///

    /// `[optional_argc] void commitComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags);`
    const _CommitComposition: () = ();

    /// ```text
    /// /**
    ///    * commitCompositionWith() will commit composition with the specific string.
    ///    * If there is no composition, this will start composition and commit it
    ///    * with the specified string.
    ///    *
    ///    * @param aCommitString   The string to be committed.
    ///    * @param aKeyboardEvent  Key event which causes the commit composition.
    ///    *                        If its type value is "keydown", this method
    ///    *                        dispatches only keydown event first.  Otherwise,
    ///    *                        dispatches keydown first and keyup at last.
    ///    * @param aKeyFlags       See KEY_* constants.
    ///    * @return                Returns true if there is a composition already or
    ///    *                        starting composition automatically.
    ///    *                        Otherwise, i.e., if it cannot start composition
    ///    *                        automatically, e.g., canceled by web apps, returns
    ///    *                        false.
    ///    */
    /// ```
    ///

    /// `[optional_argc] boolean commitCompositionWith (in DOMString aCommitString, [optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags);`
    const _CommitCompositionWith: () = ();

    /// ```text
    /// /**
    ///    * cancelComposition() will cancel composition.  This is for now the same as
    ///    * calling commitComposition("").  However, in the future, this might work
    ///    * better.  If your IME needs to cancel composition, use this instead of
    ///    * commitComposition().
    ///    *
    ///    * Note that if you tries to cancel composition when there is no composition,
    ///    * this throws an exception.
    ///    *
    ///    * @param aKeyboardEvent  Key event which causes the canceling composition.
    ///    *                        If its type value is "keydown", this method
    ///    *                        dispatches only keydown event first.  Otherwise,
    ///    *                        dispatches keydown first and keyup at last.
    ///    * @param aKeyFlags       See KEY_* constants.
    ///    */
    /// ```
    ///

    /// `[optional_argc] void cancelComposition ([optional] in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags);`
    const _CancelComposition: () = ();

    /// ```text
    /// /**
    ///    * keydown() may dispatch a keydown event and some keypress events if
    ///    * preceding keydown event isn't consumed and they are necessary.
    ///    * Note that even if this is called during composition, key events may not
    ///    * be dispatched.  In this case, this returns false.
    ///    *
    ///    * You should initialize at least .key value and .code value of the event.
    ///    * Additionally, if you try to emulate a printable key, .keyCode value should
    ///    * be specified if there is proper key value.  See the comment of above
    ///    * example how to decide .keyCode value of a printable key.  On the other
    ///    * hand, .keyCode value is automatically computed when you try to emulate
    ///    * non-printable key.  However, if you try to emulate physical keyboard of
    ///    * desktop platform, you need to specify proper value explicitly because
    ///    * the mapping table of this API isn't enough to emulate the behavior of
    ///    * Gecko for desktop platforms.
    ///    *
    ///    * NOTE: Even if this has composition, JS-Keyboard should call keydown() and
    ///    *       keyup().  Although, with the default preferences and normal
    ///    *       conditions, DOM key events won't be fired during composition.
    ///    *       However, they MAY be dispatched for some reasons, e.g., the web
    ///    *       content listens only key events, or if the standard DOM event spec
    ///    *       will be changed in the future.
    ///    *
    ///    * @param aKeyboardEvent  Must be a keyboard event which should be dispatched
    ///    *                        as a keydown event and keypress events.
    ///    *                        #1 Note that you don't need to set charCode value
    ///    *                        because it's computed from its key value.
    ///    *                        #2 If code value is set properly and location value
    ///    *                        isn't specified (i.e., 0), the location value will
    ///    *                        be guessed from the code value.
    ///    *                        #3 Non-defined code names are not allowed. If your
    ///    *                        key isn't registered, file a bug. If your key isn't
    ///    *                        defined by any standards, use "" (empty string).
    ///    *                        #4 .keyCode is guessed from .key value if the key
    ///    *                        name is registered and .keyCode isn't initialized.
    ///    *                        #5 modifier key states, e.g., .shiftKey, are
    ///    *                        ignored.  Instead, modifier states are managed by
    ///    *                        each instance and set automatically.
    ///    * @param aKeyFlags       Special flags.  The values can be some of KEY_*
    ///    *                        constants.
    ///    * @return                KEYEVENT_NOT_CONSUMED, if the keydown event nor
    ///    *                        the following keypress event(s) are consumed.
    ///    *                        KEYDOWN_IS_CONSUMED, if the keydown event is
    ///    *                        consumed. No keypress event will be dispatched in
    ///    *                        this case.
    ///    *                        KEYPRESS_IS_CONSUMED, if the keypress event(s) is
    ///    *                        consumed when dispatched.
    ///    *                        Note that keypress event is always consumed by
    ///    *                        native code for the printable keys (indicating the
        ///    *                        default action has been taken).
    ///    */
    /// ```
    ///

    /// `[optional_argc] unsigned long keydown (in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags);`
    const _Keydown: () = ();

    /// ```text
    /// /**
    ///    * Similar to keydown(), but this dispatches only a keyup event.
    ///    */
    /// ```
    ///

    /// `[optional_argc] boolean keyup (in nsIDOMKeyEvent aKeyboardEvent, [optional] in unsigned long aKeyFlags);`
    const _Keyup: () = ();

    /// ```text
    /// /**
    ///    * getModifierState() returns modifier state managed by this instance.
    ///    *
    ///    * @param aModifier       One of modifier key names.  This doesn't support
    ///    *                        virtual modifiers like "Accel".
    ///    * @return                true if the modifier key is active.  Otherwise,
    ///    *                        false.
    ///    */
    /// ```
    ///

    /// `boolean getModifierState (in DOMString aModifierKey);`
    #[inline]
    pub unsafe fn GetModifierState(&self, aModifierKey: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).GetModifierState)(self, aModifierKey, _retval)
    }


    /// ```text
    /// /**
    ///    * shareModifierStateOf() makes the instance shares modifier state of
    ///    * another instance.  When this is called, the instance refers the modifier
    ///    * state of another instance.  After that, changes to either this and the
    ///    * other instance's modifier state is synchronized.
    ///    *
    ///    * @param aOther          Another instance which will be referred by the
    ///    *                        instance.  If this is null, the instance restarts
    ///    *                        to manage modifier state independently.
    ///    */
    /// ```
    ///

    /// `void shareModifierStateOf (in nsITextInputProcessor aOther);`
    #[inline]
    pub unsafe fn ShareModifierStateOf(&self, aOther: *const nsITextInputProcessor) -> nsresult {
        ((*self.vtable).ShareModifierStateOf)(self, aOther)
    }


}