src/chrome/browser/chromeos/input_method/input_method_engine_interface.h

   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 #ifndef CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_INTERFACE_H_
   6 #define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_INTERFACE_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "ui/base/ime/chromeos/ime_bridge.h"
  12
  13 class GURL;
  14
  15 namespace chromeos {
  16
  17 namespace input_method {
  18 class InputMethodDescriptor;
  19 struct KeyEventHandle;
  20 }  // namespace input_method
  21
  22 // InputMethodEngine is used to translate from the Chrome IME API to the native
  23 // API.
  24 class InputMethodEngineInterface : public IMEEngineHandlerInterface {
  25  public:
  26   struct KeyboardEvent {
  27     KeyboardEvent();
  28     virtual ~KeyboardEvent();
  29
  30     std::string type;
  31     std::string key;
  32     std::string code;
  33     int key_code; // only used by on-screen keyboards.
  34     std::string extension_id;
  35     bool alt_key;
  36     bool ctrl_key;
  37     bool shift_key;
  38     bool caps_lock;
  39   };
  40
  41   enum {
  42     MENU_ITEM_MODIFIED_LABEL        = 0x0001,
  43     MENU_ITEM_MODIFIED_STYLE        = 0x0002,
  44     MENU_ITEM_MODIFIED_VISIBLE      = 0x0004,
  45     MENU_ITEM_MODIFIED_ENABLED      = 0x0008,
  46     MENU_ITEM_MODIFIED_CHECKED      = 0x0010,
  47     MENU_ITEM_MODIFIED_ICON         = 0x0020,
  48   };
  49
  50   enum MenuItemStyle {
  51     MENU_ITEM_STYLE_NONE,
  52     MENU_ITEM_STYLE_CHECK,
  53     MENU_ITEM_STYLE_RADIO,
  54     MENU_ITEM_STYLE_SEPARATOR,
  55   };
  56
  57   enum MouseButtonEvent {
  58     MOUSE_BUTTON_LEFT,
  59     MOUSE_BUTTON_RIGHT,
  60     MOUSE_BUTTON_MIDDLE,
  61   };
  62
  63   enum SegmentStyle {
  64     SEGMENT_STYLE_UNDERLINE,
  65     SEGMENT_STYLE_DOUBLE_UNDERLINE,
  66   };
  67
  68   enum CandidateWindowPosition {
  69     WINDOW_POS_CURSOR,
  70     WINDOW_POS_COMPOSITTION,
  71   };
  72
  73   struct MenuItem {
  74     MenuItem();
  75     virtual ~MenuItem();
  76
  77     std::string id;
  78     std::string label;
  79     MenuItemStyle style;
  80     bool visible;
  81     bool enabled;
  82     bool checked;
  83
  84     unsigned int modified;
  85     std::vector<MenuItem> children;
  86   };
  87
  88   struct InputContext {
  89     int id;
  90     std::string type;
  91   };
  92
  93   struct UsageEntry {
  94     std::string title;
  95     std::string body;
  96   };
  97
  98   struct Candidate {
  99     Candidate();
 100     virtual ~Candidate();
 101
 102     std::string value;
 103     int id;
 104     std::string label;
 105     std::string annotation;
 106     UsageEntry usage;
 107     std::vector<Candidate> candidates;
 108   };
 109
 110   struct CandidateWindowProperty {
 111     CandidateWindowProperty();
 112     virtual ~CandidateWindowProperty();
 113     int page_size;
 114     bool is_cursor_visible;
 115     bool is_vertical;
 116     bool show_window_at_composition;
 117
 118     // Auxiliary text is typically displayed in the footer of the candidate
 119     // window.
 120     std::string auxiliary_text;
 121     bool is_auxiliary_text_visible;
 122   };
 123
 124   struct SegmentInfo {
 125     int start;
 126     int end;
 127     SegmentStyle style;
 128   };
 129
 130   class Observer {
 131    public:
 132     virtual ~Observer();
 133
 134     // Called when the IME becomes the active IME.
 135     virtual void OnActivate(const std::string& engine_id) = 0;
 136
 137     // Called when the IME is no longer active.
 138     virtual void OnDeactivated(const std::string& engine_id) = 0;
 139
 140     // Called when a text field gains focus, and will be sending key events.
 141     virtual void OnFocus(const InputContext& context) = 0;
 142
 143     // Called when a text field loses focus, and will no longer generate events.
 144     virtual void OnBlur(int context_id) = 0;
 145
 146     // Called when an InputContext's properties change while it is focused.
 147     virtual void OnInputContextUpdate(const InputContext& context) = 0;
 148
 149     // Called when the user pressed a key with a text field focused.
 150     virtual void OnKeyEvent(const std::string& engine_id,
 151                             const KeyboardEvent& event,
 152                             input_method::KeyEventHandle* key_data) = 0;
 153
 154     // Called when the user clicks on an item in the candidate list.
 155     virtual void OnCandidateClicked(const std::string& engine_id,
 156                                     int candidate_id,
 157                                     MouseButtonEvent button) = 0;
 158
 159     // Called when a menu item for this IME is interacted with.
 160     virtual void OnMenuItemActivated(const std::string& engine_id,
 161                                      const std::string& menu_id) = 0;
 162
 163     // Called when a surrounding text is changed.
 164     virtual void OnSurroundingTextChanged(const std::string& engine_id,
 165                                           const std::string& text,
 166                                           int cursor_pos,
 167                                           int anchor_pos) = 0;
 168
 169     // Called when Chrome terminates on-going text input session.
 170     virtual void OnReset(const std::string& engine_id) = 0;
 171   };
 172
 173   virtual ~InputMethodEngineInterface() {}
 174
 175   virtual const input_method::InputMethodDescriptor& GetDescriptor() const = 0;
 176
 177   // Called when the input metho initialization is done.
 178   virtual void NotifyImeReady() = 0;
 179
 180   // Set the current composition and associated properties.
 181   virtual bool SetComposition(int context_id,
 182                               const char* text,
 183                               int selection_start,
 184                               int selection_end,
 185                               int cursor,
 186                               const std::vector<SegmentInfo>& segments,
 187                               std::string* error) = 0;
 188
 189   // Clear the current composition.
 190   virtual bool ClearComposition(int context_id, std::string* error) = 0;
 191
 192   // Commit the specified text to the specified context.  Fails if the context
 193   // is not focused.
 194   virtual bool CommitText(int context_id, const char* text,
 195                           std::string* error) = 0;
 196
 197   // Send the sequence of key events.
 198   virtual bool SendKeyEvents(int context_id,
 199                              const std::vector<KeyboardEvent>& events) = 0;
 200
 201   // This function returns the current property of the candidate window.
 202   // The caller can use the returned value as the default property and
 203   // modify some of specified items.
 204   virtual const CandidateWindowProperty&
 205     GetCandidateWindowProperty() const = 0;
 206
 207   // Change the property of the candidate window and repaint the candidate
 208   // window widget.
 209   virtual void SetCandidateWindowProperty(
 210       const CandidateWindowProperty& property) = 0;
 211
 212   // Show or hide the candidate window.
 213   virtual bool SetCandidateWindowVisible(bool visible, std::string* error) = 0;
 214
 215   // Set the list of entries displayed in the candidate window.
 216   virtual bool SetCandidates(int context_id,
 217                              const std::vector<Candidate>& candidates,
 218                              std::string* error) = 0;
 219
 220   // Set the position of the cursor in the candidate window.
 221   virtual bool SetCursorPosition(int context_id, int candidate_id,
 222                                  std::string* error) = 0;
 223
 224   // Set the list of items that appears in the language menu when this IME is
 225   // active.
 226   virtual bool SetMenuItems(const std::vector<MenuItem>& items) = 0;
 227
 228   // Update the state of the menu items.
 229   virtual bool UpdateMenuItems(const std::vector<MenuItem>& items) = 0;
 230
 231   // Returns true if this IME is active, false if not.
 232   virtual bool IsActive() const = 0;
 233
 234   // Inform the engine that a key event has been processed.
 235   virtual void KeyEventDone(input_method::KeyEventHandle* key_data,
 236                             bool handled) = 0;
 237
 238   // Deletes |number_of_chars| unicode characters as the basis of |offset| from
 239   // the surrounding text. The |offset| is relative position based on current
 240   // caret.
 241   // NOTE: Currently we are falling back to backspace forwarding workaround,
 242   // because delete_surrounding_text is not supported in Chrome. So this
 243   // function is restricted for only preceding text.
 244   // TODO(nona): Support full spec delete surrounding text.
 245   virtual bool DeleteSurroundingText(int context_id,
 246                                      int offset,
 247                                      size_t number_of_chars,
 248                                      std::string* error) = 0;
 249
 250   // Hides the input view window (from API call).
 251   virtual void HideInputView() = 0;
 252 };
 253
 254 }  // namespace chromeos
 255
 256 #endif  // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_INTERFACE_H_