The Tor Browser: widget/gtk/nsGtkIMModule.h@b8a032363ba2 (annotated)

widget/gtk/nsGtkIMModule.h@b8a032363ba2 (annotated)

widget/gtk/nsGtkIMModule.h

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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__

The Tor Browser / annotate

widget/gtk/nsGtkIMModule.h@b8a032363ba2 (annotated)

widget/gtk/nsGtkIMModule.h