diff -r 000000000000 -r 6474c204b198 widget/gtk/nsGtkIMModule.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/widget/gtk/nsGtkIMModule.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,319 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsGtkIMModule_h__
+#define __nsGtkIMModule_h__
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "nsString.h"
+#include "nsAutoPtr.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+#include "nsIWidget.h"
+#include "mozilla/EventForwards.h"
+
+class nsWindow;
+
+class nsGtkIMModule
+{
+protected:
+    typedef mozilla::widget::InputContext InputContext;
+    typedef mozilla::widget::InputContextAction InputContextAction;
+
+public:
+    nsrefcnt AddRef()
+    {
+        NS_PRECONDITION(int32_t(mRefCnt) >= 0, "mRefCnt is negative");
+        ++mRefCnt;
+        NS_LOG_ADDREF(this, mRefCnt, "nsGtkIMModule", sizeof(*this));
+        return mRefCnt;
+    }
+    nsrefcnt Release()
+    {
+        NS_PRECONDITION(mRefCnt != 0, "mRefCnt is alrady zero");
+        --mRefCnt;
+        NS_LOG_RELEASE(this, mRefCnt, "nsGtkIMModule");
+        if (mRefCnt == 0) {
+            mRefCnt = 1; /* stabilize */
+            delete this;
+            return 0;
+        }
+        return mRefCnt;
+    }
+
+protected:
+    nsAutoRefCnt mRefCnt;
+
+public:
+    // aOwnerWindow is a pointer of the owner window.  When aOwnerWindow is
+    // destroyed, the related IME contexts are released (i.e., IME cannot be
+    // used with the instance after that).
+    nsGtkIMModule(nsWindow* aOwnerWindow);
+    ~nsGtkIMModule();
+
+    // "Enabled" means the users can use all IMEs.
+    // I.e., the focus is in the normal editors.
+    bool IsEnabled();
+
+    // OnFocusWindow is a notification that aWindow is going to be focused.
+    void OnFocusWindow(nsWindow* aWindow);
+    // OnBlurWindow is a notification that aWindow is going to be unfocused.
+    void OnBlurWindow(nsWindow* aWindow);
+    // OnDestroyWindow is a notification that aWindow is going to be destroyed.
+    void OnDestroyWindow(nsWindow* aWindow);
+    // OnFocusChangeInGecko is a notification that an editor gets focus.
+    void OnFocusChangeInGecko(bool aFocus);
+
+    // OnKeyEvent is called when aWindow gets a native key press event or a
+    // native key release event.  If this returns TRUE, the key event was
+    // filtered by IME.  Otherwise, this returns FALSE.
+    // NOTE: When the keypress event starts composition, this returns TRUE but
+    //       this dispatches keydown event before compositionstart event.
+    bool OnKeyEvent(nsWindow* aWindow, GdkEventKey* aEvent,
+                      bool aKeyDownEventWasSent = false);
+
+    // IME related nsIWidget methods.
+    nsresult CommitIMEComposition(nsWindow* aCaller);
+    void SetInputContext(nsWindow* aCaller,
+                         const InputContext* aContext,
+                         const InputContextAction* aAction);
+    InputContext GetInputContext();
+    nsresult CancelIMEComposition(nsWindow* aCaller);
+    void OnUpdateComposition();
+
+    // If a software keyboard has been opened, this returns TRUE.
+    // Otherwise, FALSE.
+    static bool IsVirtualKeyboardOpened();
+
+protected:
+    // Owner of an instance of this class. This should be top level window.
+    // The owner window must release the contexts when it's destroyed because
+    // the IME contexts need the native window.  If OnDestroyWindow() is called
+    // with the owner window, it'll release IME contexts.  Otherwise, it'll
+    // just clean up any existing composition if it's related to the destroying
+    // child window.
+    nsWindow* mOwnerWindow;
+
+    // A last focused window in this class's context.
+    nsWindow* mLastFocusedWindow;
+
+    // Actual context. This is used for handling the user's input.
+    GtkIMContext       *mContext;
+
+    // mSimpleContext is used for the password field and
+    // the |ime-mode: disabled;| editors if sUseSimpleContext is true.
+    // These editors disable IME.  But dead keys should work.  Fortunately,
+    // the simple IM context of GTK2 support only them.
+    GtkIMContext       *mSimpleContext;
+
+    // mDummyContext is a dummy context and will be used in Focus()
+    // when the state of mEnabled means disabled.  This context's IME state is
+    // always "closed", so it closes IME forcedly.
+    GtkIMContext       *mDummyContext;
+
+    // IME enabled state and other things defined in InputContext.
+    // Use following helper methods if you don't need the detail of the status.
+    InputContext mInputContext;
+
+    // mCompositionStart is the start offset of the composition string in the
+    // current content.  When <textarea> or <input> have focus, it means offset
+    // from the first character of them.  When a HTML editor has focus, it
+    // means offset from the first character of the root element of the editor.
+    uint32_t mCompositionStart;
+
+    // mDispatchedCompositionString is the latest composition string which
+    // was dispatched by compositionupdate event.
+    nsString mDispatchedCompositionString;
+
+    // mSelectedString is the selected string which was removed by first
+    // text event.
+    nsString mSelectedString;
+
+    // OnKeyEvent() temporarily sets mProcessingKeyEvent to the given native
+    // event.
+    GdkEventKey* mProcessingKeyEvent;
+
+    // current target offset of IME composition
+    uint32_t mCompositionTargetOffset;
+
+    // mCompositionState indicates current status of composition.
+    enum eCompositionState {
+        eCompositionState_NotComposing,
+        eCompositionState_CompositionStartDispatched,
+        eCompositionState_TextEventDispatched,
+        eCompositionState_CommitTextEventDispatched
+    };
+    eCompositionState mCompositionState;
+
+    bool IsComposing()
+    {
+        return (mCompositionState != eCompositionState_NotComposing);
+    }
+
+    bool EditorHasCompositionString()
+    {
+        return (mCompositionState == eCompositionState_TextEventDispatched);
+    }
+
+#ifdef PR_LOGGING
+    const char* GetCompositionStateName()
+    {
+        switch (mCompositionState) {
+            case eCompositionState_NotComposing:
+                return "NotComposing";
+            case eCompositionState_CompositionStartDispatched:
+                return "CompositionStartDispatched";
+            case eCompositionState_TextEventDispatched:
+                return "TextEventDispatched";
+            case eCompositionState_CommitTextEventDispatched:
+                return "CommitTextEventDispatched";
+            default:
+                return "InvaildState";
+        }
+    }
+#endif // PR_LOGGING
+
+
+    // mIsIMFocused is set to TRUE when we call gtk_im_context_focus_in(). And
+    // it's set to FALSE when we call gtk_im_context_focus_out().
+    bool mIsIMFocused;
+    // mFilterKeyEvent is used by OnKeyEvent().  If the commit event should
+    // be processed as simple key event, this is set to TRUE by the commit
+    // handler.
+    bool mFilterKeyEvent;
+    // When mIgnoreNativeCompositionEvent is TRUE, all native composition
+    // should be ignored except that the compositon should be restarted in
+    // another content (nsIContent).  Don't refer this value directly, use
+    // ShouldIgnoreNativeCompositionEvent().
+    bool mIgnoreNativeCompositionEvent;
+    // mKeyDownEventWasSent is used by OnKeyEvent() and
+    // DispatchCompositionStart().  DispatchCompositionStart() dispatches
+    // a keydown event if the composition start is caused by a native
+    // keypress event.  If this is true, the keydown event has been dispatched.
+    // Then, DispatchCompositionStart() doesn't dispatch keydown event.
+    bool mKeyDownEventWasSent;
+
+    // sLastFocusedModule is a pointer to the last focused instance of this
+    // class.  When a instance is destroyed and sLastFocusedModule refers it,
+    // this is cleared.  So, this refers valid pointer always.
+    static nsGtkIMModule* sLastFocusedModule;
+
+    // sUseSimpleContext indeicates if password editors and editors with
+    // |ime-mode: disabled;| should use GtkIMContextSimple.
+    // If true, they use GtkIMContextSimple.  Otherwise, not.
+    static bool sUseSimpleContext;
+
+    // Callback methods for native IME events.  These methods should call
+    // the related instance methods simply.
+    static gboolean OnRetrieveSurroundingCallback(GtkIMContext  *aContext,
+                                                  nsGtkIMModule *aModule);
+    static gboolean OnDeleteSurroundingCallback(GtkIMContext  *aContext,
+                                                gint           aOffset,
+                                                gint           aNChars,
+                                                nsGtkIMModule *aModule);
+    static void OnCommitCompositionCallback(GtkIMContext *aContext,
+                                            const gchar *aString,
+                                            nsGtkIMModule* aModule);
+    static void OnChangeCompositionCallback(GtkIMContext *aContext,
+                                            nsGtkIMModule* aModule);
+    static void OnStartCompositionCallback(GtkIMContext *aContext,
+                                           nsGtkIMModule* aModule);
+    static void OnEndCompositionCallback(GtkIMContext *aContext,
+                                         nsGtkIMModule* aModule);
+
+    // The instance methods for the native IME events.
+    gboolean OnRetrieveSurroundingNative(GtkIMContext  *aContext);
+    gboolean OnDeleteSurroundingNative(GtkIMContext  *aContext,
+                                       gint           aOffset,
+                                       gint           aNChars);
+    void OnCommitCompositionNative(GtkIMContext *aContext,
+                                   const gchar *aString);
+    void OnChangeCompositionNative(GtkIMContext *aContext);
+    void OnStartCompositionNative(GtkIMContext *aContext);
+    void OnEndCompositionNative(GtkIMContext *aContext);
+
+
+    // GetContext() returns current IM context which is chosen by the enabled
+    // state.  So, this means *current* IM context.
+    GtkIMContext* GetContext();
+
+    // "Editable" means the users can input characters. They may be not able to
+    // use IMEs but they can use dead keys.
+    // I.e., the focus is in the normal editors or the password editors or
+    // the |ime-mode: disabled;| editors.
+    bool IsEditable();
+
+    // If the owner window and IM context have been destroyed, returns TRUE.
+    bool IsDestroyed() { return !mOwnerWindow; }
+
+    // Sets focus to the instance of this class.
+    void Focus();
+
+    // Steals focus from the instance of this class.
+    void Blur();
+
+    // Initializes the instance.
+    void Init();
+
+    // Reset the current composition of IME.  All native composition events
+    // during this processing are ignored.
+    void ResetIME();
+
+    // Gets the current composition string by the native APIs.
+    void GetCompositionString(nsAString &aCompositionString);
+
+    // Generates our text range array from current composition string.
+    already_AddRefed<mozilla::TextRangeArray> CreateTextRangeArray();
+
+    // Sets the offset's cursor position to IME.
+    void SetCursorPosition(uint32_t aTargetOffset);
+
+    // Queries the current selection offset of the window.
+    uint32_t GetSelectionOffset(nsWindow* aWindow);
+
+    // Get current paragraph text content and cursor position
+    nsresult GetCurrentParagraph(nsAString& aText, uint32_t& aCursorPos);
+
+    // Delete text portion
+    nsresult DeleteText(const int32_t aOffset, const uint32_t aNChars);
+
+    // Initializes the GUI event.
+    void InitEvent(mozilla::WidgetGUIEvent& aEvent);
+
+    // Called before destroying the context to work around some platform bugs.
+    void PrepareToDestroyContext(GtkIMContext *aContext);
+
+    bool ShouldIgnoreNativeCompositionEvent();
+
+    /**
+     *  WARNING:
+     *    Following methods dispatch gecko events.  Then, the focused widget
+     *    can be destroyed, and also it can be stolen focus.  If they returns
+     *    FALSE, callers cannot continue the composition.
+     *      - CommitCompositionBy
+     *      - DispatchCompositionStart
+     *      - DispatchCompositionEnd
+     *      - DispatchTextEvent
+     */
+
+    // Commits the current composition by the aString.
+    bool CommitCompositionBy(const nsAString& aString);
+
+    // Dispatches a composition start event or a composition end event.
+    bool DispatchCompositionStart();
+    bool DispatchCompositionEnd();
+
+    // Dispatches a text event.  If aIsCommit is TRUE, dispatches a committed
+    // text event.  Otherwise, dispatches a composing text event.
+    bool DispatchTextEvent(const nsAString& aCompositionString,
+                           bool aIsCommit);
+
+};
+
+#endif // __nsGtkIMModule_h__