Home | History | Annotate | Download | only in ime 
      1 // Copyright 2014 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 UI_BASE_IME_INPUT_METHOD_CHROMEOS_H_
      6 #define UI_BASE_IME_INPUT_METHOD_CHROMEOS_H_
      7 
      8 #include <set>
      9 #include <string>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/compiler_specific.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "base/memory/weak_ptr.h"
     15 #include "ui/base/ime/chromeos/character_composer.h"
     16 #include "ui/base/ime/chromeos/ime_bridge.h"
     17 #include "ui/base/ime/composition_text.h"
     18 #include "ui/base/ime/input_method_base.h"
     19 
     20 namespace ui {
     21 
     22 // A ui::InputMethod implementation based on IBus.
     23 class UI_BASE_EXPORT InputMethodChromeOS
     24     : public InputMethodBase,
     25       public chromeos::IMEInputContextHandlerInterface {
     26  public:
     27   explicit InputMethodChromeOS(internal::InputMethodDelegate* delegate);
     28   virtual ~InputMethodChromeOS();
     29 
     30   // Overridden from InputMethod:
     31   virtual void OnFocus() OVERRIDE;
     32   virtual void OnBlur() OVERRIDE;
     33   virtual bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
     34                                         NativeEventResult* result) OVERRIDE;
     35   virtual bool DispatchKeyEvent(const ui::KeyEvent& event) OVERRIDE;
     36   virtual void OnTextInputTypeChanged(const TextInputClient* client) OVERRIDE;
     37   virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE;
     38   virtual void CancelComposition(const TextInputClient* client) OVERRIDE;
     39   virtual void OnInputLocaleChanged() OVERRIDE;
     40   virtual std::string GetInputLocale() OVERRIDE;
     41   virtual bool IsActive() OVERRIDE;
     42   virtual bool IsCandidatePopupOpen() const OVERRIDE;
     43 
     44  protected:
     45   // Converts |text| into CompositionText.
     46   void ExtractCompositionText(const chromeos::CompositionText& text,
     47                               uint32 cursor_position,
     48                               CompositionText* out_composition) const;
     49 
     50   // Process a key returned from the input method.
     51   virtual void ProcessKeyEventPostIME(const ui::KeyEvent& event,
     52                                       bool handled);
     53 
     54   // Resets context and abandon all pending results and key events.
     55   void ResetContext();
     56 
     57  private:
     58   class PendingKeyEvent;
     59 
     60   // Overridden from InputMethodBase:
     61   virtual void OnWillChangeFocusedClient(TextInputClient* focused_before,
     62                                          TextInputClient* focused) OVERRIDE;
     63   virtual void OnDidChangeFocusedClient(TextInputClient* focused_before,
     64                                         TextInputClient* focused) OVERRIDE;
     65 
     66   // Asks the client to confirm current composition text.
     67   void ConfirmCompositionText();
     68 
     69   // Checks the availability of focused text input client and update focus
     70   // state.
     71   void UpdateContextFocusState();
     72 
     73   // Processes a key event that was already filtered by the input method.
     74   // A VKEY_PROCESSKEY may be dispatched to the focused View.
     75   void ProcessFilteredKeyPressEvent(const ui::KeyEvent& event);
     76 
     77   // Processes a key event that was not filtered by the input method.
     78   void ProcessUnfilteredKeyPressEvent(const ui::KeyEvent& event);
     79 
     80   // Sends input method result caused by the given key event to the focused text
     81   // input client.
     82   void ProcessInputMethodResult(const ui::KeyEvent& event, bool filtered);
     83 
     84   // Checks if the pending input method result needs inserting into the focused
     85   // text input client as a single character.
     86   bool NeedInsertChar() const;
     87 
     88   // Checks if there is pending input method result.
     89   bool HasInputMethodResult() const;
     90 
     91   // Sends a fake key event for IME composing without physical key events.
     92   void SendFakeProcessKeyEvent(bool pressed) const;
     93 
     94   // Abandons all pending key events. It usually happends when we lose keyboard
     95   // focus, the text input type is changed or we are destroyed.
     96   void AbandonAllPendingKeyEvents();
     97 
     98   // Passes keyevent and executes character composition if necessary. Returns
     99   // true if character composer comsumes key event.
    100   bool ExecuteCharacterComposer(const ui::KeyEvent& event);
    101 
    102   // chromeos::IMEInputContextHandlerInterface overrides:
    103   virtual void CommitText(const std::string& text) OVERRIDE;
    104   virtual void UpdateCompositionText(const chromeos::CompositionText& text,
    105                                      uint32 cursor_pos,
    106                                      bool visible) OVERRIDE;
    107   virtual void DeleteSurroundingText(int32 offset, uint32 length) OVERRIDE;
    108 
    109   // Hides the composition text.
    110   void HidePreeditText();
    111 
    112   // Callback function for IMEEngineHandlerInterface::ProcessKeyEvent.
    113   void ProcessKeyEventDone(uint32 id, ui::KeyEvent* event, bool is_handled);
    114 
    115   // Returns whether an input field is focused. Note that password field is not
    116   // considered as an input field.
    117   bool IsInputFieldFocused();
    118 
    119   // All pending key events. Note: we do not own these object, we just save
    120   // pointers to these object so that we can abandon them when necessary.
    121   // They will be deleted in ProcessKeyEventDone().
    122   std::set<uint32> pending_key_events_;
    123 
    124   // Pending composition text generated by the current pending key event.
    125   // It'll be sent to the focused text input client as soon as we receive the
    126   // processing result of the pending key event.
    127   CompositionText composition_;
    128 
    129   // Pending result text generated by the current pending key event.
    130   // It'll be sent to the focused text input client as soon as we receive the
    131   // processing result of the pending key event.
    132   base::string16 result_text_;
    133 
    134   base::string16 previous_surrounding_text_;
    135   gfx::Range previous_selection_range_;
    136 
    137   // Indicates if there is an ongoing composition text.
    138   bool composing_text_;
    139 
    140   // Indicates if the composition text is changed or deleted.
    141   bool composition_changed_;
    142 
    143   // The latest id of key event.
    144   uint32 current_keyevent_id_;
    145 
    146   // An object to compose a character from a sequence of key presses
    147   // including dead key etc.
    148   CharacterComposer character_composer_;
    149 
    150   // Used for making callbacks.
    151   base::WeakPtrFactory<InputMethodChromeOS> weak_ptr_factory_;
    152 
    153   DISALLOW_COPY_AND_ASSIGN(InputMethodChromeOS);
    154 };
    155 
    156 }  // namespace ui
    157 
    158 #endif  // UI_BASE_IME_INPUT_METHOD_CHROMEOS_H_
    159