OLD | NEW |
| (Empty) |
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 UI_BASE_IME_CHROMEOS_INPUT_METHOD_MANAGER_H_ | |
6 #define UI_BASE_IME_CHROMEOS_INPUT_METHOD_MANAGER_H_ | |
7 | |
8 #include <map> | |
9 #include <string> | |
10 #include <vector> | |
11 | |
12 #include "base/memory/ref_counted.h" | |
13 #include "base/memory/scoped_ptr.h" | |
14 #include "ui/base/ime/chromeos/input_method_descriptor.h" | |
15 #include "ui/base/ui_base_export.h" | |
16 | |
17 class Profile; | |
18 | |
19 namespace ui { | |
20 class Accelerator; | |
21 } // namespace ui | |
22 | |
23 namespace user_manager { | |
24 class User; | |
25 } // namespace user_manager | |
26 | |
27 namespace chromeos { | |
28 class ComponentExtensionIMEManager; | |
29 class InputMethodEngineInterface; | |
30 namespace input_method { | |
31 class InputMethodUtil; | |
32 class ImeKeyboard; | |
33 | |
34 // This class manages input methodshandles. Classes can add themselves as | |
35 // observers. Clients can get an instance of this library class by: | |
36 // InputMethodManager::Get(). | |
37 class UI_BASE_EXPORT InputMethodManager { | |
38 public: | |
39 enum UISessionState { | |
40 STATE_LOGIN_SCREEN = 0, | |
41 STATE_BROWSER_SCREEN, | |
42 STATE_LOCK_SCREEN, | |
43 STATE_TERMINATING, | |
44 }; | |
45 | |
46 class Observer { | |
47 public: | |
48 virtual ~Observer() {} | |
49 // Called when the current input method is changed. |show_message| | |
50 // indicates whether the user should be notified of this change. | |
51 virtual void InputMethodChanged(InputMethodManager* manager, | |
52 bool show_message) = 0; | |
53 }; | |
54 | |
55 // CandidateWindowObserver is notified of events related to the candidate | |
56 // window. The "suggestion window" used by IMEs such as ibus-mozc does not | |
57 // count as the candidate window (this may change if we later want suggestion | |
58 // window events as well). These events also won't occur when the virtual | |
59 // keyboard is used, since it controls its own candidate window. | |
60 class CandidateWindowObserver { | |
61 public: | |
62 virtual ~CandidateWindowObserver() {} | |
63 // Called when the candidate window is opened. | |
64 virtual void CandidateWindowOpened(InputMethodManager* manager) = 0; | |
65 // Called when the candidate window is closed. | |
66 virtual void CandidateWindowClosed(InputMethodManager* manager) = 0; | |
67 }; | |
68 | |
69 class State : public base::RefCounted<InputMethodManager::State> { | |
70 public: | |
71 // Returns a copy of state. | |
72 virtual scoped_refptr<State> Clone() const = 0; | |
73 | |
74 // Adds an input method extension. This function does not takes ownership of | |
75 // |instance|. | |
76 virtual void AddInputMethodExtension( | |
77 const std::string& extension_id, | |
78 const InputMethodDescriptors& descriptors, | |
79 InputMethodEngineInterface* instance) = 0; | |
80 | |
81 // Removes an input method extension. | |
82 virtual void RemoveInputMethodExtension( | |
83 const std::string& extension_id) = 0; | |
84 | |
85 // Changes the current input method to |input_method_id|. If | |
86 // |input_method_id| | |
87 // is not active, switch to the first one in the active input method list. | |
88 virtual void ChangeInputMethod(const std::string& input_method_id, | |
89 bool show_message) = 0; | |
90 | |
91 // Adds one entry to the list of active input method IDs, and then starts or | |
92 // stops the system input method framework as needed. | |
93 virtual bool EnableInputMethod( | |
94 const std::string& new_active_input_method_id) = 0; | |
95 | |
96 // Enables "login" keyboard layouts (e.g. US Qwerty, US Dvorak, French | |
97 // Azerty) that are necessary for the |language_code| and then switches to | |
98 // |initial_layouts| if the given list is not empty. For example, if | |
99 // |language_code| is "en-US", US Qwerty, US International, US Extended, US | |
100 // Dvorak, and US Colemak layouts would be enabled. Likewise, for Germany | |
101 // locale, US Qwerty which corresponds to the hardware keyboard layout and | |
102 // several keyboard layouts for Germany would be enabled. | |
103 // Only layouts suitable for login screen are enabled. | |
104 virtual void EnableLoginLayouts( | |
105 const std::string& language_code, | |
106 const std::vector<std::string>& initial_layouts) = 0; | |
107 | |
108 // Filters current state layouts and leaves only suitable for lock screen. | |
109 virtual void EnableLockScreenLayouts() = 0; | |
110 | |
111 // Returns a list of descriptors for all Input Method Extensions. | |
112 virtual void GetInputMethodExtensions(InputMethodDescriptors* result) = 0; | |
113 | |
114 // Returns the list of input methods we can select (i.e. active) including | |
115 // extension input methods. | |
116 virtual scoped_ptr<InputMethodDescriptors> GetActiveInputMethods() | |
117 const = 0; | |
118 | |
119 // Returns the list of input methods we can select (i.e. active) including | |
120 // extension input methods. | |
121 // The same as GetActiveInputMethods but returns reference to internal list. | |
122 virtual const std::vector<std::string>& GetActiveInputMethodIds() const = 0; | |
123 | |
124 // Returns the number of active input methods including extension input | |
125 // methods. | |
126 virtual size_t GetNumActiveInputMethods() const = 0; | |
127 | |
128 // Returns the input method descriptor from the given input method id | |
129 // string. | |
130 // If the given input method id is invalid, returns NULL. | |
131 virtual const InputMethodDescriptor* GetInputMethodFromId( | |
132 const std::string& input_method_id) const = 0; | |
133 | |
134 // Sets the list of extension IME ids which should be enabled. | |
135 virtual void SetEnabledExtensionImes(std::vector<std::string>* ids) = 0; | |
136 | |
137 // Sets current input method to login default (first owners, then hardware). | |
138 virtual void SetInputMethodLoginDefault() = 0; | |
139 | |
140 // Sets current input method to login default with the given locale and | |
141 // layout info from VPD. | |
142 virtual void SetInputMethodLoginDefaultFromVPD( | |
143 const std::string& locale, | |
144 const std::string& layout) = 0; | |
145 | |
146 // Switches the current input method (or keyboard layout) to the next one. | |
147 virtual bool SwitchToNextInputMethod() = 0; | |
148 | |
149 // Switches the current input method (or keyboard layout) to the previous | |
150 // one. | |
151 virtual bool SwitchToPreviousInputMethod( | |
152 const ui::Accelerator& accelerator) = 0; | |
153 | |
154 // Switches to an input method (or keyboard layout) which is associated with | |
155 // the |accelerator|. | |
156 virtual bool SwitchInputMethod(const ui::Accelerator& accelerator) = 0; | |
157 | |
158 // Gets the descriptor of the input method which is currently selected. | |
159 virtual InputMethodDescriptor GetCurrentInputMethod() const = 0; | |
160 | |
161 // Updates the list of active input method IDs, and then starts or stops the | |
162 // system input method framework as needed. | |
163 virtual bool ReplaceEnabledInputMethods( | |
164 const std::vector<std::string>& new_active_input_method_ids) = 0; | |
165 | |
166 protected: | |
167 friend base::RefCounted<InputMethodManager::State>; | |
168 | |
169 virtual ~State(); | |
170 }; | |
171 | |
172 virtual ~InputMethodManager() {} | |
173 | |
174 // Gets the global instance of InputMethodManager. Initialize() must be called | |
175 // first. | |
176 static UI_BASE_EXPORT InputMethodManager* Get(); | |
177 | |
178 // Sets the global instance. |instance| will be owned by the internal pointer | |
179 // and deleted by Shutdown(). | |
180 // TODO(nona): Instanciate InputMethodManagerImpl inside of this function once | |
181 // crbug.com/164375 is fixed. | |
182 static UI_BASE_EXPORT void Initialize(InputMethodManager* instance); | |
183 | |
184 // Destroy the global instance. | |
185 static UI_BASE_EXPORT void Shutdown(); | |
186 | |
187 // Get the current UI session state (e.g. login screen, lock screen, etc.). | |
188 virtual UISessionState GetUISessionState() = 0; | |
189 | |
190 // Adds an observer to receive notifications of input method related | |
191 // changes as desribed in the Observer class above. | |
192 virtual void AddObserver(Observer* observer) = 0; | |
193 virtual void AddCandidateWindowObserver( | |
194 CandidateWindowObserver* observer) = 0; | |
195 virtual void RemoveObserver(Observer* observer) = 0; | |
196 virtual void RemoveCandidateWindowObserver( | |
197 CandidateWindowObserver* observer) = 0; | |
198 | |
199 // Returns all input methods that are supported, including ones not active. | |
200 // This function never returns NULL. Note that input method extensions are NOT | |
201 // included in the result. | |
202 virtual scoped_ptr<InputMethodDescriptors> | |
203 GetSupportedInputMethods() const = 0; | |
204 | |
205 // Activates the input method property specified by the |key|. | |
206 virtual void ActivateInputMethodMenuItem(const std::string& key) = 0; | |
207 | |
208 virtual bool IsISOLevel5ShiftUsedByCurrentInputMethod() const = 0; | |
209 | |
210 virtual bool IsAltGrUsedByCurrentInputMethod() const = 0; | |
211 | |
212 // Returns an X keyboard object which could be used to change the current XKB | |
213 // layout, change the caps lock status, and set the auto repeat rate/interval. | |
214 virtual ImeKeyboard* GetImeKeyboard() = 0; | |
215 | |
216 // Returns an InputMethodUtil object. | |
217 virtual InputMethodUtil* GetInputMethodUtil() = 0; | |
218 | |
219 // Returns a ComponentExtentionIMEManager object. | |
220 virtual ComponentExtensionIMEManager* GetComponentExtensionIMEManager() = 0; | |
221 | |
222 // If keyboard layout can be uset at login screen | |
223 virtual bool IsLoginKeyboard(const std::string& layout) const = 0; | |
224 | |
225 // Migrates the input method id to extension-based input method id. | |
226 virtual bool MigrateInputMethods( | |
227 std::vector<std::string>* input_method_ids) = 0; | |
228 | |
229 // Returns new empty state for the |profile|. | |
230 virtual scoped_refptr<State> CreateNewState(Profile* profile) = 0; | |
231 | |
232 // Returns active state. | |
233 virtual scoped_refptr<InputMethodManager::State> GetActiveIMEState() = 0; | |
234 | |
235 // Replaces active state. | |
236 virtual void SetState(scoped_refptr<State> state) = 0; | |
237 }; | |
238 | |
239 } // namespace input_method | |
240 } // namespace chromeos | |
241 | |
242 #endif // UI_BASE_IME_CHROMEOS_INPUT_METHOD_MANAGER_H_ | |
OLD | NEW |