content/browser/renderer_host/gtk_im_context_wrapper.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
   6 #define CONTENT_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
   7
   8 #include <gdk/gdk.h>
   9 #include <pango/pango-attributes.h>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/gtest_prod_util.h"
  14 #include "base/strings/string16.h"
  15 #include "third_party/WebKit/public/web/WebInputEvent.h"
  16 #include "ui/base/ime/composition_text.h"
  17 #include "ui/base/ime/text_input_type.h"
  18
  19 typedef struct _GtkIMContext GtkIMContext;
  20 typedef struct _GtkWidget GtkWidget;
  21
  22 namespace gfx {
  23 class Rect;
  24 }
  25
  26 namespace content {
  27 class RenderWidgetHostViewGtk;
  28 struct NativeWebKeyboardEvent;
  29
  30 // This class is a convenience wrapper for GtkIMContext.
  31 // It creates and manages two GtkIMContext instances, one is GtkIMMulticontext,
  32 // for plain text input box, another is GtkIMContextSimple, for password input
  33 // box.
  34 //
  35 // This class is in charge of dispatching key events to these two GtkIMContext
  36 // instances and handling signals emitted by them. Key events then will be
  37 // forwarded to renderer along with input method results via corresponding host
  38 // view.
  39 //
  40 // This class is used solely by RenderWidgetHostViewGtk.
  41 class GtkIMContextWrapper {
  42  public:
  43   explicit GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view);
  44   ~GtkIMContextWrapper();
  45
  46   // Processes a gdk key event received by |host_view|.
  47   void ProcessKeyEvent(GdkEventKey* event);
  48
  49   void UpdateInputMethodState(ui::TextInputType type,
  50                               bool can_compose_inline);
  51   void UpdateCaretBounds(const gfx::Rect& caret_bounds);
  52   void OnFocusIn();
  53   void OnFocusOut();
  54   bool is_focused() const { return is_focused_; }
  55
  56   GtkWidget* BuildInputMethodsGtkMenu();
  57
  58   void CancelComposition();
  59
  60   void ConfirmComposition();
  61
  62  private:
  63   // Check if a text needs commit by forwarding a char event instead of
  64   // by confirming as a composition text.
  65   bool NeedCommitByForwardingCharEvent() const;
  66
  67   // Check if the input method returned any result, eg. preedit and commit text.
  68   bool HasInputMethodResult() const;
  69
  70   void ProcessFilteredKeyPressEvent(NativeWebKeyboardEvent* wke);
  71   void ProcessUnfilteredKeyPressEvent(NativeWebKeyboardEvent* wke);
  72
  73   // Processes result returned from input method after filtering a key event.
  74   // |filtered| indicates if the key event was filtered by the input method.
  75   void ProcessInputMethodResult(const GdkEventKey* event, bool filtered);
  76
  77   // Real code of "commit" signal handler.
  78   void HandleCommit(const string16& text);
  79
  80   // Real code of "preedit-start" signal handler.
  81   void HandlePreeditStart();
  82
  83   // Real code of "preedit-changed" signal handler.
  84   void HandlePreeditChanged(const gchar* text,
  85                             PangoAttrList* attrs,
  86                             int cursor_position);
  87
  88   // Real code of "preedit-end" signal handler.
  89   void HandlePreeditEnd();
  90
  91   // Real code of "retrieve-surrounding" signal handler.
  92   gboolean HandleRetrieveSurrounding(GtkIMContext* context);
  93
  94   // Real code of "realize" signal handler, used for setting im context's client
  95   // window.
  96   void HandleHostViewRealize(GtkWidget* widget);
  97
  98   // Real code of "unrealize" signal handler, used for unsetting im context's
  99   // client window.
 100   void HandleHostViewUnrealize();
 101
 102   // Sends a fake composition key event with specified event type. A composition
 103   // key event is a key event with special key code 229.
 104   void SendFakeCompositionKeyEvent(WebKit::WebInputEvent::Type type);
 105
 106   // Signal handlers of GtkIMContext object.
 107   static void HandleCommitThunk(GtkIMContext* context, gchar* text,
 108                                 GtkIMContextWrapper* self);
 109   static void HandlePreeditStartThunk(GtkIMContext* context,
 110                                       GtkIMContextWrapper* self);
 111   static void HandlePreeditChangedThunk(GtkIMContext* context,
 112                                         GtkIMContextWrapper* self);
 113   static void HandlePreeditEndThunk(GtkIMContext* context,
 114                                     GtkIMContextWrapper* self);
 115   static gboolean HandleRetrieveSurroundingThunk(GtkIMContext* context,
 116                                                  GtkIMContextWrapper* self);
 117
 118   // Signal handlers connecting to |host_view_|'s native view widget.
 119   static void HandleHostViewRealizeThunk(GtkWidget* widget,
 120                                          GtkIMContextWrapper* self);
 121   static void HandleHostViewUnrealizeThunk(GtkWidget* widget,
 122                                            GtkIMContextWrapper* self);
 123
 124   // The parent object.
 125   RenderWidgetHostViewGtk* host_view_;
 126
 127   // The GtkIMContext object.
 128   // In terms of the DOM event specification Appendix A
 129   //   <http://www.w3.org/TR/DOM-Level-3-Events/keyset.html>,
 130   // GTK uses a GtkIMContext object for the following two purposes:
 131   //  1. Composing Latin characters (A.1.2), and;
 132   //  2. Composing CJK characters with an IME (A.1.3).
 133   // Many JavaScript pages assume composed Latin characters are dispatched to
 134   // their onkeypress() handlers but not dispatched CJK characters composed
 135   // with an IME. To emulate this behavior, we should monitor the status of
 136   // this GtkIMContext object and prevent sending Char events when a
 137   // GtkIMContext object sends a "commit" signal with the CJK characters
 138   // composed by an IME.
 139   GtkIMContext* context_;
 140
 141   // A GtkIMContextSimple object, for supporting dead/compose keys when input
 142   // method is disabled, eg. in password input box.
 143   GtkIMContext* context_simple_;
 144
 145   // Whether or not this widget is focused.
 146   bool is_focused_;
 147
 148   // Whether or not the above GtkIMContext is composing a text with an IME.
 149   // This flag is used in "commit" signal handler of the GtkIMContext object,
 150   // which determines how to submit the result text to WebKit according to this
 151   // flag.
 152   // If this flag is true or there are more than one characters in the result,
 153   // then the result text will be committed to WebKit as a confirmed
 154   // composition. Otherwise, it'll be forwarded as a key event.
 155   //
 156   // The GtkIMContext object sends a "preedit_start" before it starts composing
 157   // a text and a "preedit_end" signal after it finishes composing it.
 158   // "preedit_start" signal is monitored to turn it on.
 159   // We don't monitor "preedit_end" signal to turn it off, because an input
 160   // method may fire "preedit_end" signal before "commit" signal.
 161   // A buggy input method may not fire "preedit_start" and/or "preedit_end"
 162   // at all, so this flag will also be set to true when "preedit_changed" signal
 163   // is fired with non-empty preedit text.
 164   bool is_composing_text_;
 165
 166   // Whether or not the IME is enabled.
 167   bool is_enabled_;
 168
 169   // Whether or not it's currently running inside key event handler.
 170   // If it's true, then preedit-changed and commit handler will backup the
 171   // preedit or commit text instead of sending them down to webkit.
 172   // key event handler will send them later.
 173   bool is_in_key_event_handler_;
 174
 175   // The most recent composition text information retrieved from context_;
 176   ui::CompositionText composition_;
 177
 178   // Whether or not the composition has been changed since last key event.
 179   bool is_composition_changed_;
 180
 181   // Stores a copy of the most recent commit text received by commit signal
 182   // handler.
 183   string16 commit_text_;
 184
 185   // If it's true then the next "commit" signal will be suppressed.
 186   // It's only used to workaround http://crbug.com/50485.
 187   // TODO(suzhe): Remove it after input methods get fixed.
 188   bool suppress_next_commit_;
 189
 190   // Information of the last key event, for working around
 191   // http://crosbug.com/6582
 192   int last_key_code_;
 193   bool last_key_was_up_;
 194   bool last_key_filtered_no_result_;
 195
 196   DISALLOW_COPY_AND_ASSIGN(GtkIMContextWrapper);
 197 };
 198
 199 }  // namespace content
 200
 201 #endif  // CONTENT_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_