chrome/browser/chromeos/input_method/input_method_engine_ibus.h

   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 #ifndef CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_IBUS_H_
   6 #define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_IBUS_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
  12 #include "chromeos/dbus/ibus/ibus_engine_factory_service.h"
  13 #include "chromeos/dbus/ibus/ibus_engine_service.h"
  14 #include "chromeos/ime/ibus_bridge.h"
  15 #include "dbus/object_path.h"
  16
  17 namespace chromeos {
  18
  19 class IBusComponent;
  20 class IBusLookupTable;
  21 class IBusText;
  22
  23 class IBusEngineService;
  24 namespace input_method {
  25 struct KeyEventHandle;
  26 }  // namespace input_method
  27
  28 class InputMethodEngineIBus : public InputMethodEngine,
  29                               public IBusEngineHandlerInterface {
  30  public:
  31   InputMethodEngineIBus();
  32
  33   virtual ~InputMethodEngineIBus();
  34
  35   void Initialize(
  36       InputMethodEngine::Observer* observer,
  37       const char* engine_name,
  38       const char* extension_id,
  39       const char* engine_id,
  40       const char* description,
  41       const std::vector<std::string>& languages,
  42       const std::vector<std::string>& layouts,
  43       const GURL& options_page,
  44       std::string* error);
  45
  46   // InputMethodEngine overrides.
  47   virtual void StartIme() OVERRIDE;
  48   virtual bool SetComposition(int context_id,
  49                               const char* text,
  50                               int selection_start,
  51                               int selection_end,
  52                               int cursor,
  53                               const std::vector<SegmentInfo>& segments,
  54                               std::string* error) OVERRIDE;
  55   virtual bool ClearComposition(int context_id, std::string* error) OVERRIDE;
  56   virtual bool CommitText(int context_id, const char* text,
  57                           std::string* error) OVERRIDE;
  58   virtual bool SetCandidateWindowVisible(bool visible,
  59                                          std::string* error) OVERRIDE;
  60   virtual void SetCandidateWindowCursorVisible(bool visible) OVERRIDE;
  61   virtual void SetCandidateWindowVertical(bool vertical) OVERRIDE;
  62   virtual void SetCandidateWindowPageSize(int size) OVERRIDE;
  63   virtual void SetCandidateWindowAuxText(const char* text) OVERRIDE;
  64   virtual void SetCandidateWindowAuxTextVisible(bool visible) OVERRIDE;
  65   virtual void SetCandidateWindowPosition(
  66       CandidateWindowPosition position) OVERRIDE;
  67   virtual bool SetCandidates(int context_id,
  68                              const std::vector<Candidate>& candidates,
  69                              std::string* error) OVERRIDE;
  70   virtual bool SetCursorPosition(int context_id, int candidate_id,
  71                                  std::string* error) OVERRIDE;
  72   virtual bool SetMenuItems(const std::vector<MenuItem>& items) OVERRIDE;
  73   virtual bool UpdateMenuItems(const std::vector<MenuItem>& items) OVERRIDE;
  74   virtual bool IsActive() const OVERRIDE;
  75   virtual void KeyEventDone(input_method::KeyEventHandle* key_data,
  76                             bool handled) OVERRIDE;
  77   virtual bool DeleteSurroundingText(int context_id,
  78                                      int offset,
  79                                      size_t number_of_chars,
  80                                      std::string* error) OVERRIDE;
  81
  82   // IBusEngineHandlerInterface overrides.
  83   virtual void FocusIn() OVERRIDE;
  84   virtual void FocusOut() OVERRIDE;
  85   virtual void Enable() OVERRIDE;
  86   virtual void Disable() OVERRIDE;
  87   virtual void PropertyActivate(
  88       const std::string& property_name,
  89       ibus::IBusPropertyState property_state) OVERRIDE;
  90   virtual void PropertyShow(const std::string& property_name) OVERRIDE;
  91   virtual void PropertyHide(const std::string& property_name) OVERRIDE;
  92   virtual void SetCapability(IBusCapability capability) OVERRIDE;
  93   virtual void Reset() OVERRIDE;
  94   virtual void ProcessKeyEvent(uint32 keysym, uint32 keycode, uint32 state,
  95                                const KeyEventDoneCallback& callback) OVERRIDE;
  96   virtual void CandidateClicked(uint32 index, ibus::IBusMouseButton button,
  97                                 uint32 state) OVERRIDE;
  98   virtual void SetSurroundingText(const std::string& text, uint32 cursor_pos,
  99                                   uint32 anchor_pos) OVERRIDE;
 100
 101   // Called when the connection with ibus-daemon is connected.
 102   void OnConnected();
 103
 104   // Called whtn the connection with ibus-daemon is disconnected.
 105   void OnDisconnected();
 106
 107  private:
 108   // Returns true if the connection to ibus-daemon is avaiable.
 109   bool IsConnected();
 110
 111   // Converts MenuItem to IBusProperty.
 112   bool MenuItemToProperty(const MenuItem& item, IBusProperty* property);
 113
 114   // Registers the engine component.
 115   void RegisterComponent();
 116
 117   // Called when the RegisterComponent is failed.
 118   void OnComponentRegistrationFailed();
 119
 120   // Called when the RegisterComponent is succeeded.
 121   void OnComponentRegistered();
 122
 123   // Called when the ibus-daemon sends CreateEngine message with corresponding
 124   // engine id.
 125   void CreateEngineHandler(
 126       const IBusEngineFactoryService::CreateEngineResponseSender& sender);
 127
 128   // Returns current IBusEngineService, if there is no available service, this
 129   // function returns NULL.
 130   IBusEngineService* GetCurrentService();
 131
 132   // True if the current context has focus.
 133   bool focused_;
 134
 135   // True if this engine is active.
 136   bool active_;
 137
 138   // ID that is used for the current input context.  False if there is no focus.
 139   int context_id_;
 140
 141   // Next id that will be assigned to a context.
 142   int next_context_id_;
 143
 144   // This IME ID in Chrome Extension.
 145   std::string engine_id_;
 146
 147   // This IME ID in ibus.
 148   std::string ibus_id_;
 149
 150   // The current object path.
 151   dbus::ObjectPath object_path_;
 152
 153   // The current auxialy text and it's visiblity.
 154   scoped_ptr<IBusText> aux_text_;
 155   bool aux_text_visible_;
 156
 157   // Pointer to the object recieving events for this IME.
 158   InputMethodEngine::Observer* observer_;
 159
 160   // The current preedit text, and it's cursor position.
 161   scoped_ptr<IBusText> preedit_text_;
 162   int preedit_cursor_;
 163
 164   // The current engine component.
 165   scoped_ptr<IBusComponent> component_;
 166
 167   // The current lookup table.
 168   scoped_ptr<IBusLookupTable> table_;
 169
 170   // Indicates whether the candidate window is visible.
 171   bool window_visible_;
 172
 173   // Mapping of candidate index to candidate id.
 174   std::vector<int> candidate_ids_;
 175
 176   // Mapping of candidate id to index.
 177   std::map<int, int> candidate_indexes_;
 178
 179   // Used for making callbacks.
 180   base::WeakPtrFactory<InputMethodEngineIBus> weak_ptr_factory_;
 181 };
 182
 183 }  // namespace chromeos
 184
 185 #endif  // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_ENGINE_IBUS_H_