1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_BASE_IME_CHROMEOS_IME_BRIDGE_H_
#define UI_BASE_IME_CHROMEOS_IME_BRIDGE_H_
#include <string>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/strings/string16.h"
#include "ui/base/ime/text_input_mode.h"
#include "ui/base/ime/text_input_type.h"
#include "ui/base/ui_base_export.h"
namespace gfx {
class Rect;
} // namespace gfx
namespace ui {
class CandidateWindow;
class KeyEvent;
} // namespace ui
namespace chromeos {
class CompositionText;
class UI_BASE_EXPORT IMEInputContextHandlerInterface {
public:
// Called when the engine commit a text.
virtual void CommitText(const std::string& text) = 0;
// Called when the engine updates composition text.
virtual void UpdateCompositionText(const CompositionText& text,
uint32 cursor_pos,
bool visible) = 0;
// Called when the engine request deleting surrounding string.
virtual void DeleteSurroundingText(int32 offset, uint32 length) = 0;
};
// A interface to handle the engine handler method call.
class UI_BASE_EXPORT IMEEngineHandlerInterface {
public:
typedef base::Callback<void (bool consumed)> KeyEventDoneCallback;
// A information about a focused text input field.
// A type of each member is based on the html spec, but InputContext can be
// used to specify about a non html text field like Omnibox.
struct InputContext {
InputContext(ui::TextInputType type_, ui::TextInputMode mode_) :
type(type_), mode(mode_) {}
// An attribute of the field defined at
// http://www.w3.org/TR/html401/interact/forms.html#input-control-types.
ui::TextInputType type;
// An attribute of the field defined at
// http://www.whatwg.org/specs/web-apps/current-work/multipage/
// association-of-controls-and-forms.html#input-modalities
// :-the-inputmode-attribute.
ui::TextInputMode mode;
};
virtual ~IMEEngineHandlerInterface() {}
// Called when the Chrome input field get the focus.
virtual void FocusIn(const InputContext& input_context) = 0;
// Called when the Chrome input field lose the focus.
virtual void FocusOut() = 0;
// Called when the IME is enabled.
virtual void Enable() = 0;
// Called when the IME is disabled.
virtual void Disable() = 0;
// Called when a property is activated or changed.
virtual void PropertyActivate(const std::string& property_name) = 0;
// Called when the IME is reset.
virtual void Reset() = 0;
// Called when the key event is received.
// Actual implementation must call |callback| after key event handling.
virtual void ProcessKeyEvent(const ui::KeyEvent& key_event,
const KeyEventDoneCallback& callback) = 0;
// Called when the candidate in lookup table is clicked. The |index| is 0
// based candidate index in lookup table.
virtual void CandidateClicked(uint32 index) = 0;
// Called when a new surrounding text is set. The |text| is surrounding text
// and |cursor_pos| is 0 based index of cursor position in |text|. If there is
// selection range, |anchor_pos| represents opposite index from |cursor_pos|.
// Otherwise |anchor_pos| is equal to |cursor_pos|.
virtual void SetSurroundingText(const std::string& text, uint32 cursor_pos,
uint32 anchor_pos) = 0;
protected:
IMEEngineHandlerInterface() {}
};
// A interface to handle the candidate window related method call.
class UI_BASE_EXPORT IMECandidateWindowHandlerInterface {
public:
virtual ~IMECandidateWindowHandlerInterface() {}
// Called when the IME updates the lookup table.
virtual void UpdateLookupTable(const ui::CandidateWindow& candidate_window,
bool visible) = 0;
// Called when the IME updates the preedit text. The |text| is given in
// UTF-16 encoding.
virtual void UpdatePreeditText(const base::string16& text,
uint32 cursor_pos,
bool visible) = 0;
// Called when the application changes its caret bounds.
virtual void SetCursorBounds(const gfx::Rect& cursor_bounds,
const gfx::Rect& composition_head) = 0;
// Called when the text field's focus state is changed.
// |is_focused| is true when the text field gains the focus.
virtual void FocusStateChanged(bool is_focused) {}
protected:
IMECandidateWindowHandlerInterface() {}
};
// IMEBridge provides access of each IME related handler. This class
// is used for IME implementation.
class UI_BASE_EXPORT IMEBridge {
public:
virtual ~IMEBridge();
// Allocates the global instance. Must be called before any calls to Get().
static void Initialize();
// Releases the global instance.
static void Shutdown();
// Returns IMEBridge global instance. Initialize() must be called first.
static IMEBridge* Get();
// Returns current InputContextHandler. This function returns NULL if input
// context is not ready to use.
virtual IMEInputContextHandlerInterface* GetInputContextHandler() const = 0;
// Updates current InputContextHandler. If there is no active input context,
// pass NULL for |handler|. Caller must release |handler|.
virtual void SetInputContextHandler(
IMEInputContextHandlerInterface* handler) = 0;
// Updates current EngineHandler. If there is no active engine service, pass
// NULL for |handler|. Caller must release |handler|.
virtual void SetCurrentEngineHandler(IMEEngineHandlerInterface* handler) = 0;
// Returns current EngineHandler. This function returns NULL if current engine
// is not ready to use.
virtual IMEEngineHandlerInterface* GetCurrentEngineHandler() const = 0;
// Returns current CandidateWindowHandler. This function returns NULL if
// current candidate window is not ready to use.
virtual IMECandidateWindowHandlerInterface* GetCandidateWindowHandler()
const = 0;
// Updates current CandidatWindowHandler. If there is no active candidate
// window service, pass NULL for |handler|. Caller must release |handler|.
virtual void SetCandidateWindowHandler(
IMECandidateWindowHandlerInterface* handler) = 0;
// Updates current text input type.
virtual void SetCurrentTextInputType(ui::TextInputType input_type) = 0;
// Returns the current text input type.
virtual ui::TextInputType GetCurrentTextInputType() const = 0;
protected:
IMEBridge();
private:
DISALLOW_COPY_AND_ASSIGN(IMEBridge);
};
} // namespace chromeos
#endif // UI_BASE_IME_CHROMEOS_IME_BRIDGE_H_
|
