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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
// Copyright (c) 2011 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 CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_UTIL_H_
#define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_UTIL_H_
#pragma once
#include <cstddef>
#include <map>
#include <string>
#include <vector>
#include "base/string16.h"
#include "base/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/chromeos/input_method/ibus_controller.h"
namespace chromeos {
namespace input_method {
// The list of language that do not have associated input methods in IBus.
// For these languages, we associate input methods here.
struct ExtraLanguage {
const char* language_code;
const char* input_method_id;
};
extern const ExtraLanguage kExtraLanguages[];
extern const size_t kExtraLanguagesLength;
enum InputMethodType {
kKeyboardLayoutsOnly,
kAllInputMethods,
};
// A class which provides miscellaneous input method utility functions.
class InputMethodUtil {
public:
// |supported_input_methods| is a list of all input methods supported,
// including ones not active. The list is used to initialize member variables
// in this class. The class takes ownership of |supported_input_methods|.
explicit InputMethodUtil(InputMethodDescriptors* supported_input_methods);
~InputMethodUtil();
// Converts a string sent from IBus IME engines, which is written in English,
// into Chrome's string ID, then pulls internationalized resource string from
// the resource bundle and returns it. These functions are not thread-safe.
// Non-UI threads are not allowed to call them.
string16 TranslateString(const std::string& english_string) const;
// Normalizes the language code and returns the normalized version. The
// function normalizes the given language code to be compatible with the
// one used in Chrome's application locales. Otherwise, returns the
// given language code as-is.
//
// Examples:
//
// - "zh_CN" => "zh-CN" (Use - instead of _)
// - "jpn" => "ja" (Use two-letter code)
// - "t" => "t" (Return as-is if unknown)
std::string NormalizeLanguageCode(const std::string& language_code) const;
// Gets the language code from the given input method descriptor. This
// encapsulates differences between the language codes used in
// InputMethodDescriptor and Chrome's application locale codes.
std::string GetLanguageCodeFromDescriptor(
const InputMethodDescriptor& descriptor) const;
// Gets the keyboard layout name from the given input method ID.
// If the ID is invalid, an empty string will be returned.
// This function only supports xkb layouts.
//
// Examples:
//
// "xkb:us::eng" => "us"
// "xkb:us:dvorak:eng" => "us(dvorak)"
// "xkb:gb::eng" => "gb"
// "pinyin" => "us" (because Pinyin uses US keyboard layout)
std::string GetKeyboardLayoutName(const std::string& input_method_id) const;
// Converts an input method ID to a language code of the IME. Returns "Eng"
// when |input_method_id| is unknown.
// Example: "hangul" => "ko"
std::string GetLanguageCodeFromInputMethodId(
const std::string& input_method_id) const;
// Converts an input method ID to a display name of the IME. Returns
// an empty strng when |input_method_id| is unknown.
// Examples: "pinyin" => "Pinyin"
std::string GetInputMethodDisplayNameFromId(
const std::string& input_method_id) const;
// Converts an input method ID to an input method descriptor. Returns NULL
// when |input_method_id| is unknown.
// Example: "pinyin" => { id: "pinyin", display_name: "Pinyin",
// keyboard_layout: "us", language_code: "zh" }
const InputMethodDescriptor* GetInputMethodDescriptorFromId(
const std::string& input_method_id) const;
// Converts an XKB layout ID to an input method descriptor. Returns NULL when
// |xkb_id| is unknown.
// Example: "us(dvorak)" => {
// id: "xkb:us:dvorak:eng", display_name: "US Dvorak",
// keyboard_layout: "us(dvorak)", language_code: "eng"
// }
const InputMethodDescriptor* GetInputMethodDescriptorFromXkbId(
const std::string& xkb_id) const;
// Gets input method IDs that belong to |language_code|.
// If |type| is |kKeyboardLayoutsOnly|, the function does not return input
// methods that are not for keybord layout switching. Returns true on success.
// Note that the function might return false or |language_code| is unknown.
//
// The retured input method IDs are sorted by populalirty per
// chromeos/platform/assets/input_methods/whitelist.txt.
bool GetInputMethodIdsFromLanguageCode(
const std::string& language_code,
InputMethodType type,
std::vector<std::string>* out_input_method_ids) const;
// Gets the input method IDs suitable for the first user login, based on
// the given language code (UI language), and the descriptor of the
// current input method.
void GetFirstLoginInputMethodIds(
const std::string& language_code,
const InputMethodDescriptor& current_input_method,
std::vector<std::string>* out_input_method_ids) const;
// Gets the language codes associated with the given input method IDs.
// The returned language codes won't have duplicates.
void GetLanguageCodesFromInputMethodIds(
const std::vector<std::string>& input_method_ids,
std::vector<std::string>* out_language_codes) const;
// Returns the input method ID of the hardware keyboard.
std::string GetHardwareInputMethodId() const;
// This function should be called when Chrome's application locale is
// changed, so that the internal maps of this library is reloaded.
void OnLocaleChanged();
// Returns true if the given input method id is for a keyboard layout.
static bool IsKeyboardLayout(const std::string& input_method_id);
// Converts a language code to a language display name, using the
// current application locale. MaybeRewriteLanguageName() is called
// internally.
// Examples: "fi" => "Finnish"
// "en-US" => "English (United States)"
static string16 GetLanguageDisplayNameFromCode(
const std::string& language_code);
// Converts a language code to a language native display name.
// MaybeRewriteLanguageName() is called internally.
// Examples: "fi" => "suomi" (rather than Finnish)
// "en-US" => "English (United States)"
static string16 GetLanguageNativeDisplayNameFromCode(
const std::string& language_code);
protected:
// This method is ONLY for unit testing. Returns true if the given string is
// supported (i.e. the string is associated with a resource ID). protected:
// for testability.
bool StringIsSupported(const std::string& english_string) const;
// protected: for unit testing as well.
bool GetInputMethodIdsFromLanguageCodeInternal(
const std::multimap<std::string, std::string>& language_code_to_ids,
const std::string& normalized_language_code,
InputMethodType type,
std::vector<std::string>* out_input_method_ids) const;
// protected: for unit testing as well.
void ReloadInternalMaps();
// Sorts the given language codes by their corresponding language names, using
// the unicode string comparator. Uses unstable sorting. protected: for unit
// testing as well.
static void SortLanguageCodesByNames(
std::vector<std::string>* language_codes);
private:
bool TranslateStringInternal(const std::string& english_string,
string16 *out_string) const;
// All input methods that are supported, including ones not active.
scoped_ptr<InputMethodDescriptors> supported_input_methods_;
// Map from language code to associated input method IDs, etc.
typedef std::multimap<std::string, std::string> LanguageCodeToIdsMap;
// Map from input method ID to associated input method descriptor.
typedef std::map<
std::string, InputMethodDescriptor> InputMethodIdToDescriptorMap;
// Map from XKB layout ID to associated input method descriptor.
typedef std::map<std::string, InputMethodDescriptor> XkbIdToDescriptorMap;
LanguageCodeToIdsMap language_code_to_ids_;
std::map<std::string, std::string> id_to_language_code_;
InputMethodIdToDescriptorMap id_to_descriptor_;
XkbIdToDescriptorMap xkb_id_to_descriptor_;
typedef base::hash_map<std::string, int> HashType;
HashType english_to_resource_id_;
};
} // namespace input_method
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_UTIL_H_
|
