src/ui/base/ime/fake_input_method.cc

   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 #include "ui/base/ime/fake_input_method.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/string16.h"
   9 #include "ui/base/glib/glib_integers.h"
  10 #include "ui/base/ime/input_method_delegate.h"
  11 #include "ui/base/ime/text_input_client.h"
  12 #include "ui/events/event.h"
  13 #include "ui/events/event_constants.h"
  14 #include "ui/events/event_utils.h"
  15 #include "ui/events/keycodes/keyboard_code_conversion.h"
  16
  17 #if defined(USE_X11)
  18 #include <X11/X.h>
  19 #include <X11/Xlib.h>
  20 #include <X11/Xutil.h>
  21 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
  22 #endif
  23
  24 namespace {
  25
  26 #if defined(USE_X11)
  27 uint32 EventFlagsFromXFlags(unsigned int flags) {
  28   return (flags & LockMask ? ui::EF_CAPS_LOCK_DOWN : 0U) |
  29       (flags & ControlMask ? ui::EF_CONTROL_DOWN : 0U) |
  30       (flags & ShiftMask ? ui::EF_SHIFT_DOWN : 0U) |
  31       (flags & Mod1Mask ? ui::EF_ALT_DOWN : 0U);
  32 }
  33 #endif
  34
  35 }  // namespace
  36
  37 namespace ui {
  38
  39 FakeInputMethod::FakeInputMethod(internal::InputMethodDelegate* delegate)
  40     : delegate_(NULL),
  41       text_input_client_(NULL) {
  42   SetDelegate(delegate);
  43 }
  44
  45 FakeInputMethod::~FakeInputMethod() {
  46 }
  47
  48 void FakeInputMethod::SetDelegate(internal::InputMethodDelegate* delegate) {
  49   delegate_ = delegate;
  50 }
  51
  52 void FakeInputMethod::SetFocusedTextInputClient(TextInputClient* client) {
  53   text_input_client_ = client;
  54   FOR_EACH_OBSERVER(InputMethodObserver, observers_,
  55                     OnTextInputStateChanged(client));
  56 }
  57
  58 void FakeInputMethod::DetachTextInputClient(TextInputClient* client) {
  59   if (text_input_client_ == client) {
  60     text_input_client_ = NULL;
  61     FOR_EACH_OBSERVER(InputMethodObserver, observers_,
  62                       OnTextInputStateChanged(client));
  63   }
  64 }
  65
  66 TextInputClient* FakeInputMethod::GetTextInputClient() const {
  67   return text_input_client_;
  68 }
  69
  70 bool FakeInputMethod::DispatchKeyEvent(const base::NativeEvent& native_event) {
  71   bool handled = false;
  72 #if defined(OS_WIN)
  73   if (native_event.message == WM_CHAR) {
  74     if (text_input_client_) {
  75       text_input_client_->InsertChar(ui::KeyboardCodeFromNative(native_event),
  76                                      ui::EventFlagsFromNative(native_event));
  77       handled = true;
  78     }
  79   } else {
  80     handled = delegate_->DispatchKeyEventPostIME(native_event);
  81   }
  82 #elif defined(USE_X11)
  83   DCHECK(native_event);
  84   if (native_event->type == KeyRelease) {
  85     // On key release, just dispatch it.
  86     handled = delegate_->DispatchKeyEventPostIME(native_event);
  87   } else {
  88     const uint32 state = EventFlagsFromXFlags(native_event->xkey.state);
  89     // Send a RawKeyDown event first,
  90     handled = delegate_->DispatchKeyEventPostIME(native_event);
  91     if (text_input_client_) {
  92       // then send a Char event via ui::TextInputClient.
  93       const KeyboardCode key_code = ui::KeyboardCodeFromNative(native_event);
  94       uint16 ch = 0;
  95       if (!(state & ui::EF_CONTROL_DOWN))
  96         ch = ui::GetCharacterFromXEvent(native_event);
  97       if (!ch)
  98         ch = ui::GetCharacterFromKeyCode(key_code, state);
  99       if (ch)
 100         text_input_client_->InsertChar(ch, state);
 101     }
 102   }
 103 #elif defined(USE_OZONE)
 104   DCHECK(native_event);
 105   if (EventTypeFromNative(native_event) == ET_KEY_RELEASED) {
 106     // On key release, just dispatch it.
 107     handled = delegate_->DispatchKeyEventPostIME(native_event);
 108   } else {
 109     const uint32 state = EventFlagsFromNative(native_event);
 110     // Send a RawKeyDown event first,
 111     handled = delegate_->DispatchKeyEventPostIME(native_event);
 112     if (text_input_client_) {
 113       // then send a Char event via ui::TextInputClient.
 114       const KeyboardCode key_code = ui::KeyboardCodeFromNative(native_event);
 115       uint16 ch = 0;
 116
 117       // TODO(vignatti): Support EF_CONTROL_DOWN state
 118
 119       ch = ui::GetCharacterFromKeyCode(key_code, state);
 120       if (ch)
 121         text_input_client_->InsertChar(ch, state);
 122     }
 123   }
 124 #else
 125   // TODO(yusukes): Support other platforms. Call InsertChar() when necessary.
 126   handled = delegate_->DispatchKeyEventPostIME(native_event);
 127 #endif
 128   return handled;
 129 }
 130
 131 bool FakeInputMethod::DispatchFabricatedKeyEvent(const ui::KeyEvent& event) {
 132   bool handled = delegate_->DispatchFabricatedKeyEventPostIME(
 133       event.type(), event.key_code(), event.flags());
 134   if (event.type() == ET_KEY_PRESSED && text_input_client_) {
 135     uint16 ch = event.GetCharacter();
 136     if (ch)
 137       text_input_client_->InsertChar(ch, event.flags());
 138   }
 139   return handled;
 140 }
 141
 142 void FakeInputMethod::Init(bool focused) {}
 143 void FakeInputMethod::OnFocus() {}
 144 void FakeInputMethod::OnBlur() {}
 145 bool FakeInputMethod::OnUntranslatedIMEMessage(const base::NativeEvent& event,
 146                                                NativeEventResult* result) {
 147   return false;
 148 }
 149 void FakeInputMethod::OnTextInputTypeChanged(const TextInputClient* client) {
 150   FOR_EACH_OBSERVER(InputMethodObserver, observers_,
 151                     OnTextInputStateChanged(client));
 152 }
 153 void FakeInputMethod::OnCaretBoundsChanged(const TextInputClient* client) {}
 154 void FakeInputMethod::CancelComposition(const TextInputClient* client) {}
 155 void FakeInputMethod::OnInputLocaleChanged() {}
 156
 157 std::string FakeInputMethod::GetInputLocale() {
 158   return "";
 159 }
 160
 161 base::i18n::TextDirection FakeInputMethod::GetInputTextDirection() {
 162   return base::i18n::UNKNOWN_DIRECTION;
 163 }
 164
 165 bool FakeInputMethod::IsActive() {
 166   return true;
 167 }
 168
 169 bool FakeInputMethod::IsCandidatePopupOpen() const {
 170   return false;
 171 }
 172
 173 TextInputType FakeInputMethod::GetTextInputType() const {
 174   return TEXT_INPUT_TYPE_NONE;
 175 }
 176
 177 TextInputMode FakeInputMethod::GetTextInputMode() const {
 178   return TEXT_INPUT_MODE_DEFAULT;
 179 }
 180
 181 bool FakeInputMethod::CanComposeInline() const {
 182   return true;
 183 }
 184
 185 void FakeInputMethod::AddObserver(InputMethodObserver* observer) {
 186   observers_.AddObserver(observer);
 187 }
 188
 189 void FakeInputMethod::RemoveObserver(InputMethodObserver* observer) {
 190   observers_.RemoveObserver(observer);
 191 }
 192
 193 }  // namespace ui