src/ui/base/ime/win/imm32_manager.cc

   1 // Copyright 2013 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/win/imm32_manager.h"
   6
   7 #include <atlbase.h>
   8 #include <atlcom.h>
   9 #include <msctf.h>
  10
  11 #include "base/basictypes.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/strings/string16.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/win/scoped_comptr.h"
  17 #include "third_party/skia/include/core/SkColor.h"
  18 #include "ui/base/ime/composition_text.h"
  19
  20 // "imm32.lib" is required by IMM32 APIs used in this file.
  21 // NOTE(hbono): To comply with a comment from Darin, I have added
  22 // this #pragma directive instead of adding "imm32.lib" to a project file.
  23 #pragma comment(lib, "imm32.lib")
  24
  25 // Following code requires wchar_t to be same as char16. It should always be
  26 // true on Windows.
  27 COMPILE_ASSERT(sizeof(wchar_t) == sizeof(char16), wchar_t__char16_diff);
  28
  29 ///////////////////////////////////////////////////////////////////////////////
  30 // IMM32Manager
  31
  32 namespace {
  33
  34 // Determines whether or not the given attribute represents a target
  35 // (a.k.a. a selection).
  36 bool IsTargetAttribute(char attribute) {
  37   return (attribute == ATTR_TARGET_CONVERTED ||
  38           attribute == ATTR_TARGET_NOTCONVERTED);
  39 }
  40
  41 // Helper function for IMM32Manager::GetCompositionInfo() method, to get the
  42 // target range that's selected by the user in the current composition string.
  43 void GetCompositionTargetRange(HIMC imm_context, int* target_start,
  44                                int* target_end) {
  45   int attribute_size = ::ImmGetCompositionString(imm_context, GCS_COMPATTR,
  46                                                  NULL, 0);
  47   if (attribute_size > 0) {
  48     int start = 0;
  49     int end = 0;
  50     scoped_ptr<char[]> attribute_data(new char[attribute_size]);
  51     if (attribute_data.get()) {
  52       ::ImmGetCompositionString(imm_context, GCS_COMPATTR,
  53                                 attribute_data.get(), attribute_size);
  54       for (start = 0; start < attribute_size; ++start) {
  55         if (IsTargetAttribute(attribute_data[start]))
  56           break;
  57       }
  58       for (end = start; end < attribute_size; ++end) {
  59         if (!IsTargetAttribute(attribute_data[end]))
  60           break;
  61       }
  62     }
  63     *target_start = start;
  64     *target_end = end;
  65   }
  66 }
  67
  68 // Helper function for IMM32Manager::GetCompositionInfo() method, to get
  69 // underlines information of the current composition string.
  70 void GetCompositionUnderlines(HIMC imm_context,
  71                               int target_start,
  72                               int target_end,
  73                               ui::CompositionUnderlines* underlines) {
  74   int clause_size = ::ImmGetCompositionString(imm_context, GCS_COMPCLAUSE,
  75                                               NULL, 0);
  76   int clause_length = clause_size / sizeof(uint32);
  77   if (clause_length) {
  78     scoped_ptr<uint32[]> clause_data(new uint32[clause_length]);
  79     if (clause_data.get()) {
  80       ::ImmGetCompositionString(imm_context, GCS_COMPCLAUSE,
  81                                 clause_data.get(), clause_size);
  82       for (int i = 0; i < clause_length - 1; ++i) {
  83         ui::CompositionUnderline underline;
  84         underline.start_offset = clause_data[i];
  85         underline.end_offset = clause_data[i+1];
  86         underline.color = SK_ColorBLACK;
  87         underline.thick = false;
  88
  89         // Use thick underline for the target clause.
  90         if (underline.start_offset >= static_cast<unsigned>(target_start) &&
  91             underline.end_offset <= static_cast<unsigned>(target_end)) {
  92           underline.thick = true;
  93         }
  94         underlines->push_back(underline);
  95       }
  96     }
  97   }
  98 }
  99
 100 // Checks if a given primary language ID is a RTL language.
 101 bool IsRTLPrimaryLangID(LANGID lang) {
 102   switch (lang) {
 103     case LANG_ARABIC:
 104     case LANG_HEBREW:
 105     case LANG_PERSIAN:
 106     case LANG_SYRIAC:
 107     case LANG_UIGHUR:
 108     case LANG_URDU:
 109       return true;
 110     default:
 111       return false;
 112   }
 113 }
 114
 115 }  // namespace
 116
 117 namespace ui {
 118
 119 IMM32Manager::IMM32Manager()
 120     : ime_status_(false),
 121       input_language_id_(LANG_USER_DEFAULT),
 122       is_composing_(false),
 123       system_caret_(false),
 124       caret_rect_(-1, -1, 0, 0),
 125       use_composition_window_(false) {
 126 }
 127
 128 IMM32Manager::~IMM32Manager() {
 129 }
 130
 131 bool IMM32Manager::SetInputLanguage() {
 132   // Retrieve the current keyboard layout from Windows and determine whether
 133   // or not the current input context has IMEs.
 134   // Also save its input language for language-specific operations required
 135   // while composing a text.
 136   HKL keyboard_layout = ::GetKeyboardLayout(0);
 137   input_language_id_ = reinterpret_cast<LANGID>(keyboard_layout);
 138
 139   // Check TSF Input Processor first.
 140   // If the active profile is TSF INPUTPROCESSOR, this is IME.
 141   base::win::ScopedComPtr<ITfInputProcessorProfileMgr> prof_mgr;
 142   TF_INPUTPROCESSORPROFILE prof;
 143   if (SUCCEEDED(prof_mgr.CreateInstance(CLSID_TF_InputProcessorProfiles)) &&
 144       SUCCEEDED(prof_mgr->GetActiveProfile(GUID_TFCAT_TIP_KEYBOARD, &prof)) &&
 145       prof.hkl == NULL &&
 146       prof.dwProfileType == TF_PROFILETYPE_INPUTPROCESSOR) {
 147       ime_status_ = true;
 148   } else {
 149     // If the curent language is not using TSF, check IMM32 based IMEs.
 150     // As ImmIsIME always returns non-0 value on Vista+, use ImmGetIMEFileName
 151     // instead to check if this HKL has any associated IME file.
 152     ime_status_ = (ImmGetIMEFileName(keyboard_layout, NULL, 0) != 0);
 153   }
 154
 155   return ime_status_;
 156 }
 157
 158 void IMM32Manager::CreateImeWindow(HWND window_handle) {
 159   // When a user disables TSF (Text Service Framework) and CUAS (Cicero
 160   // Unaware Application Support), Chinese IMEs somehow ignore function calls
 161   // to ::ImmSetCandidateWindow(), i.e. they do not move their candidate
 162   // window to the position given as its parameters, and use the position
 163   // of the current system caret instead, i.e. it uses ::GetCaretPos() to
 164   // retrieve the position of their IME candidate window.
 165   // Therefore, we create a temporary system caret for Chinese IMEs and use
 166   // it during this input context.
 167   // Since some third-party Japanese IME also uses ::GetCaretPos() to determine
 168   // their window position, we also create a caret for Japanese IMEs.
 169   if (PRIMARYLANGID(input_language_id_) == LANG_CHINESE ||
 170       PRIMARYLANGID(input_language_id_) == LANG_JAPANESE) {
 171     if (!system_caret_) {
 172       if (::CreateCaret(window_handle, NULL, 1, 1)) {
 173         system_caret_ = true;
 174       }
 175     }
 176   }
 177   // Restore the positions of the IME windows.
 178   UpdateImeWindow(window_handle);
 179 }
 180
 181 LRESULT IMM32Manager::SetImeWindowStyle(HWND window_handle, UINT message,
 182                                     WPARAM wparam, LPARAM lparam,
 183                                     BOOL* handled) {
 184   // To prevent the IMM (Input Method Manager) from displaying the IME
 185   // composition window, Update the styles of the IME windows and EXPLICITLY
 186   // call ::DefWindowProc() here.
 187   // NOTE(hbono): We can NEVER let WTL call ::DefWindowProc() when we update
 188   // the styles of IME windows because the 'lparam' variable is a local one
 189   // and all its updates disappear in returning from this function, i.e. WTL
 190   // does not call ::DefWindowProc() with our updated 'lparam' value but call
 191   // the function with its original value and over-writes our window styles.
 192   *handled = TRUE;
 193   lparam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
 194   return ::DefWindowProc(window_handle, message, wparam, lparam);
 195 }
 196
 197 void IMM32Manager::DestroyImeWindow(HWND window_handle) {
 198   // Destroy the system caret if we have created for this IME input context.
 199   if (system_caret_) {
 200     ::DestroyCaret();
 201     system_caret_ = false;
 202   }
 203 }
 204
 205 void IMM32Manager::MoveImeWindow(HWND window_handle, HIMC imm_context) {
 206   // Does nothing when the target window has no input focus. This is important
 207   // because the renderer may issue SelectionBoundsChanged event even when it
 208   // has no input focus. (e.g. the page update caused by incremental search.)
 209   // So this event should be ignored when the |window_handle| no longer has the
 210   // input focus.
 211   if (GetFocus() != window_handle)
 212     return;
 213
 214   int x = caret_rect_.x();
 215   int y = caret_rect_.y();
 216
 217   const int kCaretMargin = 1;
 218   if (!use_composition_window_ &&
 219       PRIMARYLANGID(input_language_id_) == LANG_CHINESE) {
 220     // As written in a comment in IMM32Manager::CreateImeWindow(),
 221     // Chinese IMEs ignore function calls to ::ImmSetCandidateWindow()
 222     // when a user disables TSF (Text Service Framework) and CUAS (Cicero
 223     // Unaware Application Support).
 224     // On the other hand, when a user enables TSF and CUAS, Chinese IMEs
 225     // ignore the position of the current system caret and uses the
 226     // parameters given to ::ImmSetCandidateWindow() with its 'dwStyle'
 227     // parameter CFS_CANDIDATEPOS.
 228     // Therefore, we do not only call ::ImmSetCandidateWindow() but also
 229     // set the positions of the temporary system caret if it exists.
 230     CANDIDATEFORM candidate_position = {0, CFS_CANDIDATEPOS, {x, y},
 231                                         {0, 0, 0, 0}};
 232     ::ImmSetCandidateWindow(imm_context, &candidate_position);
 233   }
 234   if (system_caret_) {
 235     switch (PRIMARYLANGID(input_language_id_)) {
 236       case LANG_JAPANESE:
 237         ::SetCaretPos(x, y + caret_rect_.height());
 238         break;
 239       default:
 240         ::SetCaretPos(x, y);
 241         break;
 242     }
 243   }
 244   if (use_composition_window_) {
 245     // Moves the composition text window.
 246     COMPOSITIONFORM cf = {CFS_POINT, {x, y}};
 247     ::ImmSetCompositionWindow(imm_context, &cf);
 248     // Don't need to set the position of candidate window.
 249     return;
 250   }
 251
 252   if (PRIMARYLANGID(input_language_id_) == LANG_KOREAN) {
 253     // Chinese IMEs and Japanese IMEs require the upper-left corner of
 254     // the caret to move the position of their candidate windows.
 255     // On the other hand, Korean IMEs require the lower-left corner of the
 256     // caret to move their candidate windows.
 257     y += kCaretMargin;
 258   }
 259   // Japanese IMEs and Korean IMEs also use the rectangle given to
 260   // ::ImmSetCandidateWindow() with its 'dwStyle' parameter CFS_EXCLUDE
 261   // to move their candidate windows when a user disables TSF and CUAS.
 262   // Therefore, we also set this parameter here.
 263   CANDIDATEFORM exclude_rectangle = {0, CFS_EXCLUDE, {x, y},
 264       {x, y, x + caret_rect_.width(), y + caret_rect_.height()}};
 265   ::ImmSetCandidateWindow(imm_context, &exclude_rectangle);
 266 }
 267
 268 void IMM32Manager::UpdateImeWindow(HWND window_handle) {
 269   // Just move the IME window attached to the given window.
 270   if (caret_rect_.x() >= 0 && caret_rect_.y() >= 0) {
 271     HIMC imm_context = ::ImmGetContext(window_handle);
 272     if (imm_context) {
 273       MoveImeWindow(window_handle, imm_context);
 274       ::ImmReleaseContext(window_handle, imm_context);
 275     }
 276   }
 277 }
 278
 279 void IMM32Manager::CleanupComposition(HWND window_handle) {
 280   // Notify the IMM attached to the given window to complete the ongoing
 281   // composition, (this case happens when the given window is de-activated
 282   // while composing a text and re-activated), and reset the omposition status.
 283   if (is_composing_) {
 284     HIMC imm_context = ::ImmGetContext(window_handle);
 285     if (imm_context) {
 286       ::ImmNotifyIME(imm_context, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
 287       ::ImmReleaseContext(window_handle, imm_context);
 288     }
 289     ResetComposition(window_handle);
 290   }
 291 }
 292
 293 void IMM32Manager::ResetComposition(HWND window_handle) {
 294   // Currently, just reset the composition status.
 295   is_composing_ = false;
 296 }
 297
 298 void IMM32Manager::CompleteComposition(HWND window_handle, HIMC imm_context) {
 299   // We have to confirm there is an ongoing composition before completing it.
 300   // This is for preventing some IMEs from getting confused while completing an
 301   // ongoing composition even if they do not have any ongoing compositions.)
 302   if (is_composing_) {
 303     ::ImmNotifyIME(imm_context, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
 304     ResetComposition(window_handle);
 305   }
 306 }
 307
 308 void IMM32Manager::GetCompositionInfo(HIMC imm_context, LPARAM lparam,
 309                                   CompositionText* composition) {
 310   // We only care about GCS_COMPATTR, GCS_COMPCLAUSE and GCS_CURSORPOS, and
 311   // convert them into underlines and selection range respectively.
 312   composition->underlines.clear();
 313
 314   int length = static_cast<int>(composition->text.length());
 315
 316   // Find out the range selected by the user.
 317   int target_start = length;
 318   int target_end = length;
 319   if (lparam & GCS_COMPATTR)
 320     GetCompositionTargetRange(imm_context, &target_start, &target_end);
 321
 322   // Retrieve the selection range information. If CS_NOMOVECARET is specified,
 323   // that means the cursor should not be moved, then we just place the caret at
 324   // the beginning of the composition string. Otherwise we should honour the
 325   // GCS_CURSORPOS value if it's available.
 326   // TODO(suzhe): due to a bug of webkit, we currently can't use selection range
 327   // with composition string. See: https://bugs.webkit.org/show_bug.cgi?id=40805
 328   if (!(lparam & CS_NOMOVECARET) && (lparam & GCS_CURSORPOS)) {
 329     // IMM32 does not support non-zero-width selection in a composition. So
 330     // always use the caret position as selection range.
 331     int cursor = ::ImmGetCompositionString(imm_context, GCS_CURSORPOS, NULL, 0);
 332     composition->selection = gfx::Range(cursor);
 333   } else {
 334     composition->selection = gfx::Range(0);
 335   }
 336
 337   // Retrieve the clause segmentations and convert them to underlines.
 338   if (lparam & GCS_COMPCLAUSE) {
 339     GetCompositionUnderlines(imm_context, target_start, target_end,
 340                              &composition->underlines);
 341   }
 342
 343   // Set default underlines in case there is no clause information.
 344   if (!composition->underlines.size()) {
 345     CompositionUnderline underline;
 346     underline.color = SK_ColorBLACK;
 347     if (target_start > 0) {
 348       underline.start_offset = 0;
 349       underline.end_offset = target_start;
 350       underline.thick = false;
 351       composition->underlines.push_back(underline);
 352     }
 353     if (target_end > target_start) {
 354       underline.start_offset = target_start;
 355       underline.end_offset = target_end;
 356       underline.thick = true;
 357       composition->underlines.push_back(underline);
 358     }
 359     if (target_end < length) {
 360       underline.start_offset = target_end;
 361       underline.end_offset = length;
 362       underline.thick = false;
 363       composition->underlines.push_back(underline);
 364     }
 365   }
 366 }
 367
 368 bool IMM32Manager::GetString(HIMC imm_context,
 369                          WPARAM lparam,
 370                          int type,
 371                          string16* result) {
 372   if (!(lparam & type))
 373     return false;
 374   LONG string_size = ::ImmGetCompositionString(imm_context, type, NULL, 0);
 375   if (string_size <= 0)
 376     return false;
 377   DCHECK_EQ(0u, string_size % sizeof(wchar_t));
 378   ::ImmGetCompositionString(imm_context, type,
 379       WriteInto(result, (string_size / sizeof(wchar_t)) + 1), string_size);
 380   return true;
 381 }
 382
 383 bool IMM32Manager::GetResult(
 384     HWND window_handle, LPARAM lparam, string16* result) {
 385   bool ret = false;
 386   HIMC imm_context = ::ImmGetContext(window_handle);
 387   if (imm_context) {
 388     ret = GetString(imm_context, lparam, GCS_RESULTSTR, result);
 389     ::ImmReleaseContext(window_handle, imm_context);
 390   }
 391   return ret;
 392 }
 393
 394 bool IMM32Manager::GetComposition(HWND window_handle, LPARAM lparam,
 395                               CompositionText* composition) {
 396   bool ret = false;
 397   HIMC imm_context = ::ImmGetContext(window_handle);
 398   if (imm_context) {
 399     // Copy the composition string to the CompositionText object.
 400     ret = GetString(imm_context, lparam, GCS_COMPSTR, &composition->text);
 401
 402     if (ret) {
 403       // This is a dirty workaround for facebook. Facebook deletes the
 404       // placeholder character (U+3000) used by Traditional-Chinese IMEs at the
 405       // beginning of composition text. This prevents WebKit from replacing this
 406       // placeholder character with a Traditional-Chinese character, i.e. we
 407       // cannot input any characters in a comment box of facebook with
 408       // Traditional-Chinese IMEs. As a workaround, we replace U+3000 at the
 409       // beginning of composition text with U+FF3F, a placeholder character used
 410       // by Japanese IMEs.
 411       if (input_language_id_ == MAKELANGID(LANG_CHINESE,
 412                                            SUBLANG_CHINESE_TRADITIONAL) &&
 413           composition->text[0] == 0x3000) {
 414         composition->text[0] = 0xFF3F;
 415       }
 416
 417       // Retrieve the composition underlines and selection range information.
 418       GetCompositionInfo(imm_context, lparam, composition);
 419
 420       // Mark that there is an ongoing composition.
 421       is_composing_ = true;
 422     }
 423
 424     ::ImmReleaseContext(window_handle, imm_context);
 425   }
 426   return ret;
 427 }
 428
 429 void IMM32Manager::DisableIME(HWND window_handle) {
 430   // A renderer process have moved its input focus to a password input
 431   // when there is an ongoing composition, e.g. a user has clicked a
 432   // mouse button and selected a password input while composing a text.
 433   // For this case, we have to complete the ongoing composition and
 434   // clean up the resources attached to this object BEFORE DISABLING THE IME.
 435   CleanupComposition(window_handle);
 436   ::ImmAssociateContextEx(window_handle, NULL, 0);
 437 }
 438
 439 void IMM32Manager::CancelIME(HWND window_handle) {
 440   if (is_composing_) {
 441     HIMC imm_context = ::ImmGetContext(window_handle);
 442     if (imm_context) {
 443       ::ImmNotifyIME(imm_context, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
 444       ::ImmReleaseContext(window_handle, imm_context);
 445     }
 446     ResetComposition(window_handle);
 447   }
 448 }
 449
 450 void IMM32Manager::EnableIME(HWND window_handle) {
 451   // Load the default IME context.
 452   // NOTE(hbono)
 453   //   IMM ignores this call if the IME context is loaded. Therefore, we do
 454   //   not have to check whether or not the IME context is loaded.
 455   ::ImmAssociateContextEx(window_handle, NULL, IACE_DEFAULT);
 456 }
 457
 458 void IMM32Manager::UpdateCaretRect(HWND window_handle,
 459                                const gfx::Rect& caret_rect) {
 460   // Save the caret position, and Update the position of the IME window.
 461   // This update is used for moving an IME window when a renderer process
 462   // resize/moves the input caret.
 463   if (caret_rect_ != caret_rect) {
 464     caret_rect_ = caret_rect;
 465     // Move the IME windows.
 466     HIMC imm_context = ::ImmGetContext(window_handle);
 467     if (imm_context) {
 468       MoveImeWindow(window_handle, imm_context);
 469       ::ImmReleaseContext(window_handle, imm_context);
 470     }
 471   }
 472 }
 473
 474 void IMM32Manager::SetUseCompositionWindow(bool use_composition_window) {
 475   use_composition_window_ = use_composition_window;
 476 }
 477
 478 std::string IMM32Manager::GetInputLanguageName() const {
 479   const LCID locale_id = MAKELCID(input_language_id_, SORT_DEFAULT);
 480   // max size for LOCALE_SISO639LANGNAME and LOCALE_SISO3166CTRYNAME is 9.
 481   wchar_t buffer[9];
 482
 483   // Get language id.
 484   int length = ::GetLocaleInfo(locale_id, LOCALE_SISO639LANGNAME, &buffer[0],
 485                                arraysize(buffer));
 486   if (length <= 1)
 487     return std::string();
 488
 489   std::string language;
 490   WideToUTF8(buffer, length - 1, &language);
 491   if (SUBLANGID(input_language_id_) == SUBLANG_NEUTRAL)
 492     return language;
 493
 494   // Get region id.
 495   length = ::GetLocaleInfo(locale_id, LOCALE_SISO3166CTRYNAME, &buffer[0],
 496                            arraysize(buffer));
 497   if (length <= 1)
 498     return language;
 499
 500   std::string region;
 501   WideToUTF8(buffer, length - 1, &region);
 502   return language.append(1, '-').append(region);
 503 }
 504
 505 base::i18n::TextDirection IMM32Manager::GetTextDirection() const {
 506   return IsRTLPrimaryLangID(PRIMARYLANGID(input_language_id_)) ?
 507       base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
 508 }
 509
 510 void IMM32Manager::SetTextInputMode(HWND window_handle,
 511                                     TextInputMode input_mode) {
 512   if (input_mode == ui::TEXT_INPUT_MODE_DEFAULT)
 513     return;
 514
 515   const HIMC imm_context = ::ImmGetContext(window_handle);
 516   if (!imm_context)
 517     return;
 518
 519   DWORD conversion_mode = 0;
 520   DWORD sentence_mode = 0;
 521   if (::ImmGetConversionStatus(imm_context, &conversion_mode, &sentence_mode)
 522       == FALSE) {
 523     return;
 524   }
 525
 526   BOOL open = FALSE;
 527   ConvertInputModeToImmFlags(input_mode, conversion_mode, &open,
 528                              &conversion_mode),
 529
 530   ::ImmSetOpenStatus(imm_context, open);
 531   if (open)
 532     ::ImmSetConversionStatus(imm_context, conversion_mode, sentence_mode);
 533   ::ImmReleaseContext(window_handle, imm_context);
 534 }
 535
 536 // static
 537 bool IMM32Manager::IsRTLKeyboardLayoutInstalled() {
 538   static enum {
 539     RTL_KEYBOARD_LAYOUT_NOT_INITIALIZED,
 540     RTL_KEYBOARD_LAYOUT_INSTALLED,
 541     RTL_KEYBOARD_LAYOUT_NOT_INSTALLED,
 542     RTL_KEYBOARD_LAYOUT_ERROR,
 543   } layout = RTL_KEYBOARD_LAYOUT_NOT_INITIALIZED;
 544
 545   // Cache the result value.
 546   if (layout != RTL_KEYBOARD_LAYOUT_NOT_INITIALIZED)
 547     return layout == RTL_KEYBOARD_LAYOUT_INSTALLED;
 548
 549   // Retrieve the number of layouts installed in this system.
 550   int size = GetKeyboardLayoutList(0, NULL);
 551   if (size <= 0) {
 552     layout = RTL_KEYBOARD_LAYOUT_ERROR;
 553     return false;
 554   }
 555
 556   // Retrieve the keyboard layouts in an array and check if there is an RTL
 557   // layout in it.
 558   scoped_ptr<HKL[]> layouts(new HKL[size]);
 559   ::GetKeyboardLayoutList(size, layouts.get());
 560   for (int i = 0; i < size; ++i) {
 561     if (IsRTLPrimaryLangID(PRIMARYLANGID(layouts[i]))) {
 562       layout = RTL_KEYBOARD_LAYOUT_INSTALLED;
 563       return true;
 564     }
 565   }
 566
 567   layout = RTL_KEYBOARD_LAYOUT_NOT_INSTALLED;
 568   return false;
 569 }
 570
 571 bool IMM32Manager::IsCtrlShiftPressed(base::i18n::TextDirection* direction) {
 572   uint8_t keystate[256];
 573   if (!::GetKeyboardState(&keystate[0]))
 574     return false;
 575
 576   // To check if a user is pressing only a control key and a right-shift key
 577   // (or a left-shift key), we use the steps below:
 578   // 1. Check if a user is pressing a control key and a right-shift key (or
 579   //    a left-shift key).
 580   // 2. If the condition 1 is true, we should check if there are any other
 581   //    keys pressed at the same time.
 582   //    To ignore the keys checked in 1, we set their status to 0 before
 583   //    checking the key status.
 584   const int kKeyDownMask = 0x80;
 585   if ((keystate[VK_CONTROL] & kKeyDownMask) == 0)
 586     return false;
 587
 588   if (keystate[VK_RSHIFT] & kKeyDownMask) {
 589     keystate[VK_RSHIFT] = 0;
 590     *direction = base::i18n::RIGHT_TO_LEFT;
 591   } else if (keystate[VK_LSHIFT] & kKeyDownMask) {
 592     keystate[VK_LSHIFT] = 0;
 593     *direction = base::i18n::LEFT_TO_RIGHT;
 594   } else {
 595     return false;
 596   }
 597
 598   // Scan the key status to find pressed keys. We should abandon changing the
 599   // text direction when there are other pressed keys.
 600   // This code is executed only when a user is pressing a control key and a
 601   // right-shift key (or a left-shift key), i.e. we should ignore the status of
 602   // the keys: VK_SHIFT, VK_CONTROL, VK_RCONTROL, and VK_LCONTROL.
 603   // So, we reset their status to 0 and ignore them.
 604   keystate[VK_SHIFT] = 0;
 605   keystate[VK_CONTROL] = 0;
 606   keystate[VK_RCONTROL] = 0;
 607   keystate[VK_LCONTROL] = 0;
 608   for (int i = 0; i <= VK_PACKET; ++i) {
 609     if (keystate[i] & kKeyDownMask)
 610       return false;
 611   }
 612   return true;
 613 }
 614
 615 void IMM32Manager::ConvertInputModeToImmFlags(TextInputMode input_mode,
 616                                               DWORD initial_conversion_mode,
 617                                               BOOL* open,
 618                                               DWORD* new_conversion_mode) {
 619   *open = TRUE;
 620   *new_conversion_mode = initial_conversion_mode;
 621   switch (input_mode) {
 622     case ui::TEXT_INPUT_MODE_FULL_WIDTH_LATIN:
 623       *new_conversion_mode |= IME_CMODE_FULLSHAPE;
 624       *new_conversion_mode &= ~(IME_CMODE_NATIVE
 625                               | IME_CMODE_KATAKANA);
 626       break;
 627     case ui::TEXT_INPUT_MODE_KANA:
 628       *new_conversion_mode |= (IME_CMODE_NATIVE
 629                              | IME_CMODE_FULLSHAPE);
 630       *new_conversion_mode &= ~IME_CMODE_KATAKANA;
 631       break;
 632     case ui::TEXT_INPUT_MODE_KATAKANA:
 633       *new_conversion_mode |= (IME_CMODE_NATIVE
 634                              | IME_CMODE_KATAKANA
 635                              | IME_CMODE_FULLSHAPE);
 636       break;
 637     default:
 638       *open = FALSE;
 639       break;
 640   }
 641 }
 642
 643 }  // namespace ui