chrome/browser/chromeos/input_method/input_method_engine.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_H_
   6 #define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11 #include "chrome/browser/chromeos/input_method/input_method_engine_interface.h"
  12 #include "chromeos/ime/input_method_descriptor.h"
  13 #include "url/gurl.h"
  14
  15 namespace ui {
  16 class CandidateWindow;
  17 class KeyEvent;
  18 }  // namespace ui
  19
  20 namespace ash {
  21 namespace ime {
  22 struct InputMethodMenuItem;
  23 }  // namespace ime
  24 }  // namespace ash
  25
  26 namespace chromeos {
  27
  28 class CompositionText;
  29
  30 namespace input_method {
  31 struct KeyEventHandle;
  32 }  // namespace input_method
  33
  34 class InputMethodEngine : public InputMethodEngineInterface {
  35  public:
  36   InputMethodEngine();
  37
  38   virtual ~InputMethodEngine();
  39
  40   void Initialize(scoped_ptr<InputMethodEngineInterface::Observer> observer,
  41                   const char* engine_name,
  42                   const char* extension_id,
  43                   const char* engine_id,
  44                   const std::vector<std::string>& languages,
  45                   const std::vector<std::string>& layouts,
  46                   const GURL& options_page,
  47                   const GURL& input_view);
  48
  49   // InputMethodEngineInterface overrides.
  50   virtual const input_method::InputMethodDescriptor& GetDescriptor()
  51       const OVERRIDE;
  52   virtual void NotifyImeReady() OVERRIDE;
  53   virtual bool SetComposition(int context_id,
  54                               const char* text,
  55                               int selection_start,
  56                               int selection_end,
  57                               int cursor,
  58                               const std::vector<SegmentInfo>& segments,
  59                               std::string* error) OVERRIDE;
  60   virtual bool ClearComposition(int context_id, std::string* error) OVERRIDE;
  61   virtual bool CommitText(int context_id, const char* text,
  62                           std::string* error) OVERRIDE;
  63   virtual bool SendKeyEvents(int context_id,
  64                              const std::vector<KeyboardEvent>& events) OVERRIDE;
  65   virtual const CandidateWindowProperty&
  66     GetCandidateWindowProperty() const OVERRIDE;
  67   virtual void SetCandidateWindowProperty(
  68       const CandidateWindowProperty& property) OVERRIDE;
  69   virtual bool SetCandidateWindowVisible(bool visible,
  70                                          std::string* error) OVERRIDE;
  71   virtual bool SetCandidates(int context_id,
  72                              const std::vector<Candidate>& candidates,
  73                              std::string* error) OVERRIDE;
  74   virtual bool SetCursorPosition(int context_id, int candidate_id,
  75                                  std::string* error) OVERRIDE;
  76   virtual bool SetMenuItems(const std::vector<MenuItem>& items) OVERRIDE;
  77   virtual bool UpdateMenuItems(const std::vector<MenuItem>& items) OVERRIDE;
  78   virtual bool IsActive() const OVERRIDE;
  79   virtual void KeyEventDone(input_method::KeyEventHandle* key_data,
  80                             bool handled) OVERRIDE;
  81   virtual bool DeleteSurroundingText(int context_id,
  82                                      int offset,
  83                                      size_t number_of_chars,
  84                                      std::string* error) OVERRIDE;
  85
  86   // IMEEngineHandlerInterface overrides.
  87   virtual void FocusIn(
  88       const IMEEngineHandlerInterface::InputContext& input_context) OVERRIDE;
  89   virtual void FocusOut() OVERRIDE;
  90   virtual void Enable() OVERRIDE;
  91   virtual void Disable() OVERRIDE;
  92   virtual void PropertyActivate(const std::string& property_name) OVERRIDE;
  93   virtual void Reset() OVERRIDE;
  94   virtual void ProcessKeyEvent(const ui::KeyEvent& key_event,
  95                                const KeyEventDoneCallback& callback) OVERRIDE;
  96   virtual void CandidateClicked(uint32 index) OVERRIDE;
  97   virtual void SetSurroundingText(const std::string& text, uint32 cursor_pos,
  98                                   uint32 anchor_pos) OVERRIDE;
  99   virtual void HideInputView() OVERRIDE;
 100
 101  private:
 102   // Converts MenuItem to InputMethodMenuItem.
 103   void MenuItemToProperty(const MenuItem& item,
 104                           ash::ime::InputMethodMenuItem* property);
 105
 106   // Descriptor of this input method.
 107   input_method::InputMethodDescriptor descriptor_;
 108
 109   // True if the current context has focus.
 110   bool focused_;
 111
 112   // True if this engine is active.
 113   bool active_;
 114
 115   // ID that is used for the current input context.  False if there is no focus.
 116   int context_id_;
 117
 118   // Next id that will be assigned to a context.
 119   int next_context_id_;
 120
 121   // This IME ID in Chrome Extension.
 122   std::string engine_id_;
 123
 124   // This IME's Chrome Extension ID.
 125   std::string extension_id_;
 126
 127   // This IME ID in InputMethodManager.
 128   std::string imm_id_;
 129
 130   // The observer object recieving events for this IME.
 131   scoped_ptr<InputMethodEngineInterface::Observer> observer_;
 132
 133   // The current preedit text, and it's cursor position.
 134   scoped_ptr<CompositionText> composition_text_;
 135   int composition_cursor_;
 136
 137   // The current candidate window.
 138   scoped_ptr<ui::CandidateWindow> candidate_window_;
 139
 140   // The current candidate window property.
 141   CandidateWindowProperty candidate_window_property_;
 142
 143   // Indicates whether the candidate window is visible.
 144   bool window_visible_;
 145
 146   // Mapping of candidate index to candidate id.
 147   std::vector<int> candidate_ids_;
 148
 149   // Mapping of candidate id to index.
 150   std::map<int, int> candidate_indexes_;
 151
 152   // Used for input view window.
 153   GURL input_view_url_;
 154
 155   // Used with SendKeyEvents and ProcessKeyEvent to check if the key event
 156   // sent to ProcessKeyEvent is sent by SendKeyEvents.
 157   const ui::KeyEvent* sent_key_event_;
 158 };
 159
 160 }  // namespace chromeos
 161
 162 #endif  // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_H_