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