Add Chewing options window

BUG=chromium-os:2624
TEST=Open the IME settings window.  Add Traditional Chinese.  Check that there is an options dialog next to Chewing, and click on it.

Review URL: http://codereview.chromium.org/2421001

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@48619 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 616 insertions, 0 deletions

diff --git a/chrome/app/generated_resources.grd b/chrome/app/generated_resources.grd
index a7e1cb3..90b8654 100644
--- a/chrome/app/generated_resources.grd
+++ b/chrome/app/generated_resources.grd
@@ -7512,6 +7512,134 @@ Keep your key file in a safe place. You will need it to create new versions of y
       <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_LANGUAGES" desc="The label for the list of languages">
         Languages
       </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTINGS_TITLE"
+               desc="The title for the Chewing input settings dialog">
+        Chewing Input Settings
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_AUTO_SHIFT_CUR"
+               desc="The checkbox label for a Chewing input method preference">
+        Automatically move cursor to the next character
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_ADD_PHRASE_DIRECTION"
+               desc="The checkbox label for a Chewing input method preference">
+        Add phrases in front
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_EASY_SYMBOL_INPUT"
+               desc="The checkbox label for a Chewing input method preference">
+        Easy symbol input
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_ESC_CLEAN_ALL_BUF"
+               desc="The checkbox label for a Chewing input method preference">
+        Esc cleans whole pre-edit buffer
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_FORCE_LOWER_CASE_ENGLISH"
+               desc="The checkbox label for a Chewing input method preference">
+        Ignore CapsLock status and input lowercase by default
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_PLAIN_ZHUYIN"
+               desc="The checkbox label for a Chewing input method preference">
+        Plain Zhuyin mode.  Automatic candidate selection and related options
+        are disabled or ignored.
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_PHRASE_CHOICE_REARWARD"
+               desc="The checkbox label for a Chewing input method preference">
+        Choose phrases from the back, without moving the cursor
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_SPACE_AS_SELECTION"
+               desc="The checkbox label for a Chewing input method preference">
+        Press Space to select the candidate
+      </message>
+
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE"
+               desc="The combobox description for the Chewing keyboard type">
+	Keyboard Type
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DEFAULT"
+               desc="The combobox value for the Chewing keyboard type">
+	Default
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_HSU"
+               desc="The combobox value for the Chewing keyboard type">
+	Hsu
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_IBM"
+               desc="The combobox value for the Chewing keyboard type">
+	IBM
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_GIN_YIEH"
+               desc="The combobox value for the Chewing keyboard type">
+	Gin Yieh
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_ETEN"
+               desc="The combobox value for the Chewing keyboard type">
+	Eten
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_ETEN26"
+               desc="The combobox value for the Chewing keyboard type">
+	Eten 26
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DVORAK"
+               desc="The combobox value for the Chewing keyboard type">
+	Dvorak
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DVORAK_HSU"
+               desc="The combobox value for the Chewing keyboard type">
+	Dvorak (Hsu)
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DACHEN_26"
+               desc="The combobox value for the Chewing keyboard type">
+	Dachen 26
+      </message>
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_HANYU"
+               desc="The combobox value for the Chewing keyboard type">
+	Hanyu
+      </message>
+
+      <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS"
+               desc="The combobox description for the Chewing selection keys">
+	Selection Keys
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_1234567890"
+               desc="The combobox value for the Chewing selection keys">
+	1234567890
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_ASDFGHJKLS"
+               desc="The combobox value for the Chewing selection keys">
+	asdfghjkl;
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_ASDFZXCV89"
+               desc="The combobox value for the Chewing selection keys">
+	asdfzxcv89
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_ASDFJKL789"
+               desc="The combobox value for the Chewing selection keys">
+	asdfjkl789
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_AOEUSQJKIX"
+               desc="The combobox value for the Chewing selection keys">
+	aoeu;qjkix (Dvorak)
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_AOEUHTNSID"
+               desc="The combobox value for the Chewing selection keys">
+	aoeuhtnsid (Dvorak)
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_AOEUIDHTNS"
+               desc="The combobox value for the Chewing selection keys">
+	aoeuidhtns (Dvorak)
+      </message>
+      <message translateable="false"
+               name="IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_1234QWERAS"
+               desc="The combobox value for the Chewing selection keys">
+	1234qweras
+      </message>
+
       <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_HANGUL_SETTINGS_TITLE"
                desc="The title for the Hangul input settings dialog">
         Hangul Input Settings
diff --git a/chrome/browser/chromeos/language_preferences.h b/chrome/browser/chromeos/language_preferences.h
index c4ae77b..d8f0776 100644
--- a/chrome/browser/chromeos/language_preferences.h
+++ b/chrome/browser/chromeos/language_preferences.h
@@ -34,6 +34,95 @@ const wchar_t kHotkeyNextEngineInMenu[] =
 // TODO(suzhe): Add more key bindings?
 const wchar_t kHotkeyPreviousEngine[] = L"Control+space";
 
+// For Simplified Chinese input method (ibus-chewing)
+const char kChewingSectionName[] = "engine/Chewing";
+
+// We have to sync the |ibus_config_name|s with those in
+// ibus-chewing/files/src/Config.cc.
+const struct {
+  const wchar_t* pref_name;  // Chrome preference name.
+  bool default_pref_value;
+  const char* ibus_config_name;
+  int message_id;
+} kChewingBooleanPrefs[] = {
+  { prefs::kLanguageChewingAutoShiftCur, false, "autoShiftCur",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_AUTO_SHIFT_CUR},
+  { prefs::kLanguageChewingAddPhraseDirection, false, "addPhraseDirection",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_ADD_PHRASE_DIRECTION},
+  { prefs::kLanguageChewingEasySymbolInput, true, "easySymbolInput",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_EASY_SYMBOL_INPUT},
+  { prefs::kLanguageChewingEscCleanAllBuf, false, "escCleanAllBuf",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_ESC_CLEAN_ALL_BUF},
+  { prefs::kLanguageChewingForceLowercaseEnglish, false,
+    "forceLowercaseEnglish",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_FORCE_LOWER_CASE_ENGLISH},
+  { prefs::kLanguageChewingPlainZhuyin, false, "plainZhuyin",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_PLAIN_ZHUYIN},
+  { prefs::kLanguageChewingPhraseChoiceRearward, true, "phraseChoiceRearward",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_PHRASE_CHOICE_REARWARD},
+  { prefs::kLanguageChewingSpaceAsSelection, true, "spaceAsSelection",
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTING_SPACE_AS_SELECTION},
+};
+const size_t kNumChewingBooleanPrefs = ARRAYSIZE_UNSAFE(kChewingBooleanPrefs);
+
+const struct ChewingMultipleChoicePreference {
+  const wchar_t* pref_name;  // Chrome preference name.
+  const wchar_t* default_pref_value;
+  const char* ibus_config_name;
+  // Currently we have 10 combobox items at most.
+  static const size_t kMaxItems = 10;
+  struct {
+    const char* ibus_config_value;
+    int item_message_id;  // Resource grd ID for the combobox item.
+  } values_and_ids[kMaxItems];
+  int label_message_id;  // Resource grd ID for the label.
+
+} kChewingMultipleChoicePrefs[] = {
+  { prefs::kLanguageChewingKeyboardType,
+    L"default",
+    "KBType",
+    {{ "default",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DEFAULT },
+     { "hsu", IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_HSU },
+     { "ibm", IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_IBM },
+     { "gin_yieh",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_GIN_YIEH },
+     { "eten", IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_ETEN },
+     { "eten26", IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_ETEN26 },
+     { "dvorak", IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DVORAK },
+     { "dvorak_hsu",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DVORAK_HSU },
+     { "dachen_26",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_DACHEN_26 },
+     { "hanyu", IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE_HANYU }},
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_KEYBOARD_TYPE,
+  },
+  { prefs::kLanguageChewingSelKeys,
+    L"1234567890",
+    "selKeys",
+    {{ "1234567890",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_1234567890 },
+     { "asdfghjkl;",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_ASDFGHJKLS },
+     { "asdfzxcv89",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_ASDFZXCV89 },
+     { "asdfjkl789",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_ASDFJKL789 },
+     { "aoeu;qjkix",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_AOEUSQJKIX },
+     { "aoeuhtnsid",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_AOEUHTNSID },
+     { "aoeuidhtns",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_AOEUIDHTNS },
+     { "1234qweras",
+       IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS_1234QWERAS }},
+    IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SEL_KEYS,
+  },
+};
+const size_t kNumChewingMultipleChoicePrefs =
+    arraysize(kChewingMultipleChoicePrefs);
+// TODO(zork): Support candPerPage, hsuSelKeyType, and maxChiSymbolLen
+
 // For Korean input method (ibus-hangul)
 const char kHangulSectionName[] = "engine/Hangul";
 const char kHangulKeyboardConfigName[] = "HangulKeyboard";
diff --git a/chrome/browser/chromeos/options/language_chewing_config_view.cc b/chrome/browser/chromeos/options/language_chewing_config_view.cc
new file mode 100644
index 0000000..25c25a8
--- /dev/null
+++ b/chrome/browser/chromeos/options/language_chewing_config_view.cc
@@ -0,0 +1,243 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/options/language_chewing_config_view.h"
+
+#include "app/combobox_model.h"
+#include "app/l10n_util.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/common/notification_type.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/language_library.h"
+#include "chrome/browser/chromeos/preferences.h"
+#include "chrome/browser/profile.h"
+#include "grit/generated_resources.h"
+#include "grit/locale_settings.h"
+#include "views/controls/button/checkbox.h"
+#include "views/controls/label.h"
+#include "views/grid_layout.h"
+#include "views/standard_layout.h"
+#include "views/window/window.h"
+
+namespace chromeos {
+
+// The combobox model for Chewing Chinese input method prefs.
+// TODO(zork): Share this with MozcComboboxModel
+class ChewingComboboxModel : public ComboboxModel {
+ public:
+  explicit ChewingComboboxModel(
+      const ChewingMultipleChoicePreference* pref_data)
+          : pref_data_(pref_data), num_items_(0) {
+    // Check how many items are defined in the |pref_data->values_and_ids|
+    // array.
+    for (size_t i = 0; i < ChewingMultipleChoicePreference::kMaxItems; ++i) {
+      if ((pref_data_->values_and_ids)[i].ibus_config_value == NULL) {
+        break;
+      }
+      ++num_items_;
+    }
+  }
+
+  // Implements ComboboxModel interface.
+  virtual int GetItemCount() {
+    return num_items_;
+  }
+
+  // Implements ComboboxModel interface.
+  virtual std::wstring GetItemAt(int index) {
+    if (index < 0 || index >= num_items_) {
+      LOG(ERROR) << "Index is out of bounds: " << index;
+      return L"";
+    }
+    const int message_id = (pref_data_->values_and_ids)[index].item_message_id;
+    return l10n_util::GetString(message_id);
+  }
+
+  // Gets a label for the combobox like "Input mode". This function is NOT part
+  // of the ComboboxModel interface.
+  std::wstring GetLabel() const {
+    return l10n_util::GetString(pref_data_->label_message_id);
+  }
+
+  // Gets a config value for the ibus configuration daemon (e.g. "KUTEN_TOUTEN",
+  // "KUTEN_PERIOD", ..) for an item at zero-origin |index|. This function is
+  // NOT part of the ComboboxModel interface.
+  std::wstring GetConfigValueAt(int index) const {
+    if (index < 0 || index >= num_items_) {
+      LOG(ERROR) << "Index is out of bounds: " << index;
+      return L"";
+    }
+    return UTF8ToWide((pref_data_->values_and_ids)[index].ibus_config_value);
+  }
+
+  // Gets an index (>= 0) of an item such that GetConfigValueAt(index) is equal
+  // to the |config_value|. Returns -1 if such item is not found. This function
+  // is NOT part of the ComboboxModel interface.
+  int GetIndexFromConfigValue(const std::wstring& config_value) const {
+    for (int i = 0; i < num_items_; ++i) {
+      if (GetConfigValueAt(i) == config_value) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+ private:
+  const ChewingMultipleChoicePreference* pref_data_;
+  int num_items_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChewingComboboxModel);
+};
+
+// The combobox for the dialog which has minimum width.
+class ChewingCombobox : public views::Combobox {
+ public:
+  explicit ChewingCombobox(ComboboxModel* model) : Combobox(model) {
+  }
+
+  virtual gfx::Size GetPreferredSize() {
+    gfx::Size size = Combobox::GetPreferredSize();
+    if (size.width() < kMinComboboxWidth) {
+      size.set_width(kMinComboboxWidth);
+    }
+    return size;
+  }
+
+ private:
+  static const int kMinComboboxWidth = 100;
+
+  DISALLOW_COPY_AND_ASSIGN(ChewingCombobox);
+};
+
+LanguageChewingConfigView::LanguageChewingConfigView(Profile* profile)
+    : OptionsPageView(profile), contents_(NULL) {
+  for (size_t i = 0; i < kNumChewingBooleanPrefs; ++i) {
+    chewing_boolean_prefs_[i].Init(
+        kChewingBooleanPrefs[i].pref_name, profile->GetPrefs(), this);
+    chewing_boolean_checkboxes_[i] = NULL;
+  }
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    ChewingPrefAndAssociatedCombobox& current = prefs_and_comboboxes_[i];
+    current.multiple_choice_pref.Init(
+        kChewingMultipleChoicePrefs[i].pref_name, profile->GetPrefs(), this);
+    current.combobox_model =
+        new ChewingComboboxModel(&kChewingMultipleChoicePrefs[i]);
+    current.combobox = NULL;
+  }
+}
+
+LanguageChewingConfigView::~LanguageChewingConfigView() {
+}
+
+void LanguageChewingConfigView::ButtonPressed(
+    views::Button* sender, const views::Event& event) {
+  views::Checkbox* checkbox = static_cast<views::Checkbox*>(sender);
+  const int pref_id = checkbox->tag();
+  DCHECK(pref_id >= 0 && pref_id < static_cast<int>(kNumChewingBooleanPrefs));
+  chewing_boolean_prefs_[pref_id].SetValue(checkbox->checked());
+}
+
+void LanguageChewingConfigView::ItemChanged(
+    views::Combobox* sender, int prev_index, int new_index) {
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    ChewingPrefAndAssociatedCombobox& current = prefs_and_comboboxes_[i];
+    if (current.combobox == sender) {
+      const std::wstring config_value =
+          current.combobox_model->GetConfigValueAt(new_index);
+      LOG(INFO) << "Changing Chewing pref to " << config_value;
+      // Update the Chrome pref.
+      current.multiple_choice_pref.SetValue(config_value);
+      break;
+    }
+  }
+}
+
+void LanguageChewingConfigView::Layout() {
+  // Not sure why but this is needed to show contents in the dialog.
+  contents_->SetBounds(0, 0, width(), height());
+}
+
+std::wstring LanguageChewingConfigView::GetWindowTitle() const {
+  return l10n_util::GetString(
+      IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_SETTINGS_TITLE);
+}
+
+gfx::Size LanguageChewingConfigView::GetPreferredSize() {
+  return gfx::Size(views::Window::GetLocalizedContentsSize(
+      IDS_LANGUAGES_INPUT_DIALOG_WIDTH_CHARS,
+      IDS_LANGUAGES_INPUT_DIALOG_HEIGHT_LINES));
+}
+
+void LanguageChewingConfigView::InitControlLayout() {
+  using views::ColumnSet;
+  using views::GridLayout;
+
+  contents_ = new views::View;
+  AddChildView(contents_);
+
+  GridLayout* layout = new GridLayout(contents_);
+  layout->SetInsets(kPanelVertMargin, kPanelHorizMargin,
+                    kPanelVertMargin, kPanelHorizMargin);
+  contents_->SetLayoutManager(layout);
+
+  const int kColumnSetId = 0;
+  ColumnSet* column_set = layout->AddColumnSet(kColumnSetId);
+  column_set->AddColumn(GridLayout::LEADING, GridLayout::CENTER, 0,
+                        GridLayout::USE_PREF, 0, 0);
+  column_set->AddPaddingColumn(0, kRelatedControlHorizontalSpacing);
+  column_set->AddColumn(GridLayout::LEADING, GridLayout::CENTER, 0,
+                        GridLayout::USE_PREF, 0, 0);
+
+  for (size_t i = 0; i < kNumChewingBooleanPrefs; ++i) {
+    chewing_boolean_checkboxes_[i] = new views::Checkbox(
+        l10n_util::GetString(kChewingBooleanPrefs[i].message_id));
+    chewing_boolean_checkboxes_[i]->set_listener(this);
+    chewing_boolean_checkboxes_[i]->set_tag(i);
+  }
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    ChewingPrefAndAssociatedCombobox& current = prefs_and_comboboxes_[i];
+    current.combobox = new ChewingCombobox(current.combobox_model);
+    current.combobox->set_listener(this);
+  }
+  NotifyPrefChanged();
+  for (size_t i = 0; i < kNumChewingBooleanPrefs; ++i) {
+    layout->StartRow(0, kColumnSetId);
+    layout->AddView(chewing_boolean_checkboxes_[i]);
+  }
+
+  // Show the comboboxes.
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    const ChewingPrefAndAssociatedCombobox& current = prefs_and_comboboxes_[i];
+    layout->StartRow(0, kColumnSetId);
+    layout->AddView(new views::Label(current.combobox_model->GetLabel()));
+    layout->AddView(current.combobox);
+  }
+}
+
+void LanguageChewingConfigView::Observe(NotificationType type,
+                                        const NotificationSource& source,
+                                        const NotificationDetails& details) {
+  if (type == NotificationType::PREF_CHANGED) {
+    NotifyPrefChanged();
+  }
+}
+
+void LanguageChewingConfigView::NotifyPrefChanged() {
+  for (size_t i = 0; i < kNumChewingBooleanPrefs; ++i) {
+    const bool checked = chewing_boolean_prefs_[i].GetValue();
+    chewing_boolean_checkboxes_[i]->SetChecked(checked);
+  }
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    ChewingPrefAndAssociatedCombobox& current = prefs_and_comboboxes_[i];
+    const std::wstring value = current.multiple_choice_pref.GetValue();
+    const int combo_index =
+        current.combobox_model->GetIndexFromConfigValue(value);
+    if (combo_index >= 0) {
+      current.combobox->SetSelectedItem(combo_index);
+    }
+  }
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/options/language_chewing_config_view.h b/chrome/browser/chromeos/options/language_chewing_config_view.h
new file mode 100644
index 0000000..6e2e88b
--- /dev/null
+++ b/chrome/browser/chromeos/options/language_chewing_config_view.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_CHROMEOS_OPTIONS_LANGUAGE_CHEWING_CONFIG_VIEW_H_
+#define CHROME_BROWSER_CHROMEOS_OPTIONS_LANGUAGE_CHEWING_CONFIG_VIEW_H_
+
+#include <string>
+
+#include "chrome/browser/chromeos/cros/language_library.h"
+#include "chrome/browser/chromeos/language_preferences.h"
+#include "chrome/browser/pref_member.h"
+#include "chrome/browser/views/options/options_page_view.h"
+#include "views/controls/button/checkbox.h"
+#include "views/controls/combobox/combobox.h"
+#include "views/controls/label.h"
+#include "views/window/dialog_delegate.h"
+
+namespace chromeos {
+
+class ChewingCombobox;
+class ChewingComboboxModel;
+
+// A dialog box for showing Traditional Chinese (Chewing) input method
+// preferences.
+class LanguageChewingConfigView : public views::ButtonListener,
+                                  public views::Combobox::Listener,
+                                  public views::DialogDelegate,
+                                  public OptionsPageView {
+ public:
+  explicit LanguageChewingConfigView(Profile* profile);
+  virtual ~LanguageChewingConfigView();
+
+  // views::ButtonListener overrides.
+  virtual void ButtonPressed(views::Button* sender, const views::Event& event);
+
+  // views::Combobox::Listener overrides.
+  virtual void ItemChanged(views::Combobox* sender,
+                           int prev_index,
+                           int new_index);
+
+  // views::DialogDelegate overrides.
+  virtual bool IsModal() const { return true; }
+  virtual views::View* GetContentsView() { return this; }
+  virtual std::wstring GetWindowTitle() const;
+
+  // views::View overrides.
+  virtual void Layout();
+  virtual gfx::Size GetPreferredSize();
+
+  // OptionsPageView overrides.
+  virtual void InitControlLayout();
+
+  // NotificationObserver overrides.
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+ private:
+  // Updates the chewing checkboxes.
+  void NotifyPrefChanged();
+
+  BooleanPrefMember chewing_boolean_prefs_[kNumChewingBooleanPrefs];
+  views::View* contents_;
+
+  // Checkboxes for Chewing.
+  views::Checkbox* chewing_boolean_checkboxes_[kNumChewingBooleanPrefs];
+
+  struct ChewingPrefAndAssociatedCombobox {
+    StringPrefMember multiple_choice_pref;
+    ChewingComboboxModel* combobox_model;
+    ChewingCombobox* combobox;
+  } prefs_and_comboboxes_[kNumChewingMultipleChoicePrefs];
+
+  DISALLOW_COPY_AND_ASSIGN(LanguageChewingConfigView);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_OPTIONS_LANGUAGE_CHEWING_CONFIG_VIEW_H_
diff --git a/chrome/browser/chromeos/options/language_config_view.cc b/chrome/browser/chromeos/options/language_config_view.cc
index ace7bec..7cdfa6d 100644
--- a/chrome/browser/chromeos/options/language_config_view.cc
+++ b/chrome/browser/chromeos/options/language_config_view.cc
@@ -15,6 +15,7 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/language_library.h"
+#include "chrome/browser/chromeos/options/language_chewing_config_view.h"
 #include "chrome/browser/chromeos/options/language_hangul_config_view.h"
 #include "chrome/browser/chromeos/options/language_mozc_config_view.h"
 #include "chrome/browser/chromeos/options/language_pinyin_config_view.h"
@@ -60,6 +61,9 @@ const int kPreferredLanguageTableWidth = 300;
 
 // Creates the LanguageHangulConfigView. The function is used to create
 // the object via a function pointer. See also InitInputMethodConfigViewMap().
+views::DialogDelegate* CreateLanguageChewingConfigView(Profile* profile) {
+  return new LanguageChewingConfigView(profile);
+}
 views::DialogDelegate* CreateLanguageHangulConfigView(Profile* profile) {
   return new LanguageHangulConfigView(profile);
 }
@@ -496,6 +500,7 @@ void LanguageConfigView::InitControlLayout() {
 }
 
 void LanguageConfigView::InitInputMethodConfigViewMap() {
+  input_method_config_view_map_["chewing"] = CreateLanguageChewingConfigView;
   input_method_config_view_map_["hangul"] = CreateLanguageHangulConfigView;
   input_method_config_view_map_["pinyin"] = CreateLanguagePinyinConfigView;
 
diff --git a/chrome/browser/chromeos/preferences.cc b/chrome/browser/chromeos/preferences.cc
index f783138..ea45ae4 100644
--- a/chrome/browser/chromeos/preferences.cc
+++ b/chrome/browser/chromeos/preferences.cc
@@ -31,6 +31,15 @@ void Preferences::RegisterUserPrefs(PrefService* prefs) {
                             kHotkeyPreviousEngine);
   prefs->RegisterStringPref(prefs::kLanguagePreloadEngines,
                             UTF8ToWide(kFallbackInputMethodId));  // EN layout
+  for (size_t i = 0; i < kNumChewingBooleanPrefs; ++i) {
+    prefs->RegisterBooleanPref(kChewingBooleanPrefs[i].pref_name,
+                               kChewingBooleanPrefs[i].default_pref_value);
+  }
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    prefs->RegisterStringPref(
+        kChewingMultipleChoicePrefs[i].pref_name,
+        kChewingMultipleChoicePrefs[i].default_pref_value);
+  }
   prefs->RegisterStringPref(prefs::kLanguageHangulKeyboard,
                             kHangulKeyboardNameIDPairs[0].keyboard_id);
   for (size_t i = 0; i < kNumPinyinBooleanPrefs; ++i) {
@@ -59,6 +68,14 @@ void Preferences::Init(PrefService* prefs) {
   language_hotkey_previous_engine_.Init(
       prefs::kLanguageHotkeyPreviousEngine, prefs, this);
   language_preload_engines_.Init(prefs::kLanguagePreloadEngines, prefs, this);
+  for (size_t i = 0; i < kNumChewingBooleanPrefs; ++i) {
+    language_chewing_boolean_prefs_[i].Init(
+        kChewingBooleanPrefs[i].pref_name, prefs, this);
+  }
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    language_chewing_multiple_choice_prefs_[i].Init(
+        kChewingMultipleChoicePrefs[i].pref_name, prefs, this);
+  }
   language_hangul_keyboard_.Init(prefs::kLanguageHangulKeyboard, prefs, this);
   for (size_t i = 0; i < kNumPinyinBooleanPrefs; ++i) {
     language_pinyin_boolean_prefs_[i].Init(
@@ -122,6 +139,21 @@ void Preferences::NotifyPrefChanged(const std::wstring* pref_name) {
                                      kPreloadEnginesConfigName,
                                      language_preload_engines_.GetValue());
   }
+  for (size_t i = 0; i < kNumChewingBooleanPrefs; ++i) {
+    if (!pref_name || *pref_name == kChewingBooleanPrefs[i].pref_name) {
+      SetLanguageConfigBoolean(kChewingSectionName,
+                               kChewingBooleanPrefs[i].ibus_config_name,
+                               language_chewing_boolean_prefs_[i].GetValue());
+    }
+  }
+  for (size_t i = 0; i < kNumChewingMultipleChoicePrefs; ++i) {
+    if (!pref_name || *pref_name == kChewingMultipleChoicePrefs[i].pref_name) {
+      SetLanguageConfigString(
+          kChewingSectionName,
+          kChewingMultipleChoicePrefs[i].ibus_config_name,
+          language_chewing_multiple_choice_prefs_[i].GetValue());
+    }
+  }
   if (!pref_name || *pref_name == prefs::kLanguageHangulKeyboard) {
     SetLanguageConfigString(kHangulSectionName, kHangulKeyboardConfigName,
                             language_hangul_keyboard_.GetValue());
diff --git a/chrome/browser/chromeos/preferences.h b/chrome/browser/chromeos/preferences.h
index 2617bd1..0fc1ea3 100644
--- a/chrome/browser/chromeos/preferences.h
+++ b/chrome/browser/chromeos/preferences.h
@@ -87,6 +87,9 @@ class Preferences : public NotificationObserver {
   StringPrefMember language_hotkey_next_engine_in_menu_;
   StringPrefMember language_hotkey_previous_engine_;
   StringPrefMember language_preload_engines_;
+  BooleanPrefMember language_chewing_boolean_prefs_[kNumChewingBooleanPrefs];
+  StringPrefMember language_chewing_multiple_choice_prefs_[
+      kNumChewingMultipleChoicePrefs];
   StringPrefMember language_hangul_keyboard_;
   BooleanPrefMember language_pinyin_boolean_prefs_[kNumPinyinBooleanPrefs];
   IntegerPrefMember language_pinyin_int_prefs_[kNumPinyinIntegerPrefs];
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index ed1893c..890b972 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -466,6 +466,8 @@
         'browser/chromeos/options/ip_config_view.h',
         'browser/chromeos/options/language_config_view.cc',
         'browser/chromeos/options/language_config_view.h',
+        'browser/chromeos/options/language_chewing_config_view.cc',
+        'browser/chromeos/options/language_chewing_config_view.h',
         'browser/chromeos/options/language_hangul_config_view.cc',
         'browser/chromeos/options/language_hangul_config_view.h',
         'browser/chromeos/options/language_pinyin_config_view.cc',
diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc
index a4040ae..4c64cf5 100644
--- a/chrome/common/pref_names.cc
+++ b/chrome/common/pref_names.cc
@@ -208,6 +208,30 @@ const wchar_t kLanguageHotkeyPreviousEngine[] =
 // method IDs.
 const wchar_t kLanguagePreloadEngines[] = L"settings.language.preload_engines";
 
+// Boolean prefs for ibus-chewing Chinese input method.
+const wchar_t kLanguageChewingAutoShiftCur[] =
+    L"settings.language.chewing_auto_shift_cur";
+const wchar_t kLanguageChewingAddPhraseDirection[] =
+    L"settings.language.chewing_add_phrase_direction";
+const wchar_t kLanguageChewingEasySymbolInput[] =
+    L"settings.language.chewing_easy_symbol_input";
+const wchar_t kLanguageChewingEscCleanAllBuf[] =
+    L"settings.language.chewing_esc_clean_all_buf";
+const wchar_t kLanguageChewingForceLowercaseEnglish[] =
+    L"settings.language.chewing_force_lowercase_english";
+const wchar_t kLanguageChewingPlainZhuyin[] =
+    L"settings.language.chewing_plain_zhuyin";
+const wchar_t kLanguageChewingPhraseChoiceRearward[] =
+    L"settings.language.chewing_phrase_choice_rearward";
+const wchar_t kLanguageChewingSpaceAsSelection[] =
+    L"settings.language.chewing_space_as_selection";
+
+// String prefs for ibus-chewing Chinese input method.
+const wchar_t kLanguageChewingKeyboardType[] =
+    L"settings.language.chewing_keyboard_type";
+const wchar_t kLanguageChewingSelKeys[] =
+    L"settings.language.chewing_sel_keys";
+
 // A string pref which determines the keyboard layout for Hangul input method.
 const wchar_t kLanguageHangulKeyboard[] = L"settings.language.hangul_keyboard";
 
diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h
index 69533ee8..0be932b 100644
--- a/chrome/common/pref_names.h
+++ b/chrome/common/pref_names.h
@@ -76,6 +76,16 @@ extern const wchar_t kTouchpadSensitivity[];
 extern const wchar_t kLanguageHotkeyNextEngineInMenu[];
 extern const wchar_t kLanguageHotkeyPreviousEngine[];
 extern const wchar_t kLanguagePreloadEngines[];
+extern const wchar_t kLanguageChewingAutoShiftCur[];
+extern const wchar_t kLanguageChewingAddPhraseDirection[];
+extern const wchar_t kLanguageChewingEasySymbolInput[];
+extern const wchar_t kLanguageChewingEscCleanAllBuf[];
+extern const wchar_t kLanguageChewingForceLowercaseEnglish[];
+extern const wchar_t kLanguageChewingPlainZhuyin[];
+extern const wchar_t kLanguageChewingPhraseChoiceRearward[];
+extern const wchar_t kLanguageChewingSpaceAsSelection[];
+extern const wchar_t kLanguageChewingKeyboardType[];
+extern const wchar_t kLanguageChewingSelKeys[];
 extern const wchar_t kLanguageHangulKeyboard[];
 extern const wchar_t kLanguagePinyinCorrectPinyin[];
 extern const wchar_t kLanguagePinyinFuzzyPinyin[];