This repository has been archived by the owner on Nov 8, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 6.2k
/
EditText.java
282 lines (250 loc) · 9.43 KB
/
EditText.java
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
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
/*
* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.widget;
import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.text.Editable;
import android.text.Selection;
import android.text.Spannable;
import android.text.TextUtils;
import android.text.method.ArrowKeyMovementMethod;
import android.text.method.MovementMethod;
import android.text.style.SpanUtils;
import android.util.AttributeSet;
import android.view.KeyEvent;
/*
* This is supposed to be a *very* thin veneer over TextView.
* Do not make any changes here that do anything that a TextView
* with a key listener and a movement method wouldn't do!
*/
/**
* A user interface element for entering and modifying text.
* When you define an edit text widget, you must specify the
* {@link android.R.styleable#TextView_inputType}
* attribute. For example, for plain text input set inputType to "text":
* <p>
* <pre>
* <EditText
* android:id="@+id/plain_text_input"
* android:layout_height="wrap_content"
* android:layout_width="match_parent"
* android:inputType="text"/></pre>
*
* Choosing the input type configures the keyboard type that is shown, acceptable characters,
* and appearance of the edit text.
* For example, if you want to accept a secret number, like a unique pin or serial number,
* you can set inputType to "numericPassword".
* An inputType of "numericPassword" results in an edit text that accepts numbers only,
* shows a numeric keyboard when focused, and masks the text that is entered for privacy.
* <p>
* See the <a href="{@docRoot}guide/topics/ui/controls/text.html">Text Fields</a>
* guide for examples of other
* {@link android.R.styleable#TextView_inputType} settings.
* </p>
* <p>You also can receive callbacks as a user changes text by
* adding a {@link android.text.TextWatcher} to the edit text.
* This is useful when you want to add auto-save functionality as changes are made,
* or validate the format of user input, for example.
* You add a text watcher using the {@link TextView#addTextChangedListener} method.
* </p>
* <p>
* This widget does not support auto-sizing text.
* <p>
* <b>XML attributes</b>
* <p>
* See {@link android.R.styleable#EditText EditText Attributes},
* {@link android.R.styleable#TextView TextView Attributes},
* {@link android.R.styleable#View View Attributes}
*
* @attr ref android.R.styleable#EditText_enableTextStylingShortcuts
*/
public class EditText extends TextView {
// True if the style shortcut is enabled.
private boolean mStyleShortcutsEnabled = false;
private static final int ID_BOLD = android.R.id.bold;
private static final int ID_ITALIC = android.R.id.italic;
private static final int ID_UNDERLINE = android.R.id.underline;
public EditText(Context context) {
this(context, null);
}
public EditText(Context context, AttributeSet attrs) {
this(context, attrs, com.android.internal.R.attr.editTextStyle);
}
public EditText(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public EditText(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
final Resources.Theme theme = context.getTheme();
final TypedArray a = theme.obtainStyledAttributes(attrs,
com.android.internal.R.styleable.EditText, defStyleAttr, defStyleRes);
final int n = a.getIndexCount();
for (int i = 0; i < n; ++i) {
int attr = a.getIndex(i);
switch (attr) {
case com.android.internal.R.styleable.EditText_enableTextStylingShortcuts:
mStyleShortcutsEnabled = a.getBoolean(attr, false);
break;
}
}
}
@Override
public boolean getFreezesText() {
return true;
}
@Override
protected boolean getDefaultEditable() {
return true;
}
@Override
protected MovementMethod getDefaultMovementMethod() {
return ArrowKeyMovementMethod.getInstance();
}
@Override
public Editable getText() {
CharSequence text = super.getText();
// This can only happen during construction.
if (text == null) {
return null;
}
if (text instanceof Editable) {
return (Editable) text;
}
super.setText(text, BufferType.EDITABLE);
return (Editable) super.getText();
}
@Override
public void setText(CharSequence text, BufferType type) {
super.setText(text, BufferType.EDITABLE);
}
/**
* Convenience for {@link Selection#setSelection(Spannable, int, int)}.
*/
public void setSelection(int start, int stop) {
Selection.setSelection(getText(), start, stop);
}
/**
* Convenience for {@link Selection#setSelection(Spannable, int)}.
*/
public void setSelection(int index) {
Selection.setSelection(getText(), index);
}
/**
* Convenience for {@link Selection#selectAll}.
*/
public void selectAll() {
Selection.selectAll(getText());
}
/**
* Convenience for {@link Selection#extendSelection}.
*/
public void extendSelection(int index) {
Selection.extendSelection(getText(), index);
}
/**
* Causes words in the text that are longer than the view's width to be ellipsized instead of
* broken in the middle. {@link TextUtils.TruncateAt#MARQUEE
* TextUtils.TruncateAt#MARQUEE} is not supported.
*
* @param ellipsis Type of ellipsis to be applied.
* @throws IllegalArgumentException When the value of <code>ellipsis</code> parameter is
* {@link TextUtils.TruncateAt#MARQUEE}.
* @see TextView#setEllipsize(TextUtils.TruncateAt)
*/
@Override
public void setEllipsize(TextUtils.TruncateAt ellipsis) {
if (ellipsis == TextUtils.TruncateAt.MARQUEE) {
throw new IllegalArgumentException("EditText cannot use the ellipsize mode "
+ "TextUtils.TruncateAt.MARQUEE");
}
super.setEllipsize(ellipsis);
}
@Override
public CharSequence getAccessibilityClassName() {
return EditText.class.getName();
}
/** @hide */
@Override
protected boolean supportsAutoSizeText() {
return false;
}
@Override
public boolean onKeyShortcut(int keyCode, KeyEvent event) {
if (event.hasModifiers(KeyEvent.META_CTRL_ON)) {
// Handle Ctrl-only shortcuts.
switch (keyCode) {
case KeyEvent.KEYCODE_B:
if (mStyleShortcutsEnabled && hasSelection()) {
return onTextContextMenuItem(ID_BOLD);
}
break;
case KeyEvent.KEYCODE_I:
if (mStyleShortcutsEnabled && hasSelection()) {
return onTextContextMenuItem(ID_ITALIC);
}
break;
case KeyEvent.KEYCODE_U:
if (mStyleShortcutsEnabled && hasSelection()) {
return onTextContextMenuItem(ID_UNDERLINE);
}
break;
}
}
return super.onKeyShortcut(keyCode, event);
}
@Override
public boolean onTextContextMenuItem(int id) {
// TODO: Move to switch-case once the resource ID is finalized.
if (id == ID_BOLD || id == ID_ITALIC || id == ID_UNDERLINE) {
return performStylingAction(id);
}
return super.onTextContextMenuItem(id);
}
private boolean performStylingAction(int actionId) {
final int selectionStart = getSelectionStart();
final int selectionEnd = getSelectionEnd();
if (selectionStart < 0 || selectionEnd < 0) {
return false; // There is no selection.
}
int min = Math.min(selectionStart, selectionEnd);
int max = Math.max(selectionStart, selectionEnd);
Spannable spannable = getText();
if (actionId == ID_BOLD) {
return SpanUtils.toggleBold(spannable, min, max);
} else if (actionId == ID_ITALIC) {
return SpanUtils.toggleItalic(spannable, min, max);
} else if (actionId == ID_UNDERLINE) {
return SpanUtils.toggleUnderline(spannable, min, max);
}
return false;
}
/**
* Enables styls shortcuts, e.g. Ctrl+B for making text bold.
*
* @param enabled true for enabled, false for disabled.
*/
public void setStyleShortcutsEnabled(boolean enabled) {
mStyleShortcutsEnabled = enabled;
}
/**
* Return true if style shortcut is enabled, otherwise returns false.
* @return true if style shortcut is enabled, otherwise returns false.
*/
public boolean isStyleShortcutEnabled() {
return mStyleShortcutsEnabled;
}
}