ArrowKeyMovementMethod.java revision ab9289320f598509cf358523ba173d69178a55ea 
1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.text.method;
18
19import android.util.Log;
20import android.view.KeyEvent;
21import android.graphics.Rect;
22import android.text.*;
23import android.widget.TextView;
24import android.view.View;
25import android.view.ViewConfiguration;
26import android.view.MotionEvent;
27
28// XXX this doesn't extend MetaKeyKeyListener because the signatures
29// don't match.  Need to figure that out.  Meanwhile the meta keys
30// won't work in fields that don't take input.
31
32public class
33ArrowKeyMovementMethod
34implements MovementMethod
35{
36    private boolean up(TextView widget, Spannable buffer) {
37        boolean cap = (MetaKeyKeyListener.getMetaState(buffer,
38                        KeyEvent.META_SHIFT_ON) == 1) ||
39                      (MetaKeyKeyListener.getMetaState(buffer,
40                        MetaKeyKeyListener.META_SELECTING) != 0);
41        boolean alt = MetaKeyKeyListener.getMetaState(buffer,
42                        KeyEvent.META_ALT_ON) == 1;
43        Layout layout = widget.getLayout();
44
45        if (cap) {
46            if (alt) {
47                Selection.extendSelection(buffer, 0);
48                return true;
49            } else {
50                return Selection.extendUp(buffer, layout);
51            }
52        } else {
53            if (alt) {
54                Selection.setSelection(buffer, 0);
55                return true;
56            } else {
57                return Selection.moveUp(buffer, layout);
58            }
59        }
60    }
61
62    private boolean down(TextView widget, Spannable buffer) {
63        boolean cap = (MetaKeyKeyListener.getMetaState(buffer,
64                        KeyEvent.META_SHIFT_ON) == 1) ||
65                      (MetaKeyKeyListener.getMetaState(buffer,
66                        MetaKeyKeyListener.META_SELECTING) != 0);
67        boolean alt = MetaKeyKeyListener.getMetaState(buffer,
68                        KeyEvent.META_ALT_ON) == 1;
69        Layout layout = widget.getLayout();
70
71        if (cap) {
72            if (alt) {
73                Selection.extendSelection(buffer, buffer.length());
74                return true;
75            } else {
76                return Selection.extendDown(buffer, layout);
77            }
78        } else {
79            if (alt) {
80                Selection.setSelection(buffer, buffer.length());
81                return true;
82            } else {
83                return Selection.moveDown(buffer, layout);
84            }
85        }
86    }
87
88    private boolean left(TextView widget, Spannable buffer) {
89        boolean cap = (MetaKeyKeyListener.getMetaState(buffer,
90                        KeyEvent.META_SHIFT_ON) == 1) ||
91                      (MetaKeyKeyListener.getMetaState(buffer,
92                        MetaKeyKeyListener.META_SELECTING) != 0);
93        boolean alt = MetaKeyKeyListener.getMetaState(buffer,
94                        KeyEvent.META_ALT_ON) == 1;
95        Layout layout = widget.getLayout();
96
97        if (cap) {
98            if (alt) {
99                return Selection.extendToLeftEdge(buffer, layout);
100            } else {
101                return Selection.extendLeft(buffer, layout);
102            }
103        } else {
104            if (alt) {
105                return Selection.moveToLeftEdge(buffer, layout);
106            } else {
107                return Selection.moveLeft(buffer, layout);
108            }
109        }
110    }
111
112    private boolean right(TextView widget, Spannable buffer) {
113        boolean cap = (MetaKeyKeyListener.getMetaState(buffer,
114                        KeyEvent.META_SHIFT_ON) == 1) ||
115                      (MetaKeyKeyListener.getMetaState(buffer,
116                        MetaKeyKeyListener.META_SELECTING) != 0);
117        boolean alt = MetaKeyKeyListener.getMetaState(buffer,
118                        KeyEvent.META_ALT_ON) == 1;
119        Layout layout = widget.getLayout();
120
121        if (cap) {
122            if (alt) {
123                return Selection.extendToRightEdge(buffer, layout);
124            } else {
125                return Selection.extendRight(buffer, layout);
126            }
127        } else {
128            if (alt) {
129                return Selection.moveToRightEdge(buffer, layout);
130            } else {
131                return Selection.moveRight(buffer, layout);
132            }
133        }
134    }
135
136    private int getOffset(int x, int y, TextView widget){
137      // Converts the absolute X,Y coordinates to the character offset for the
138      // character whose position is closest to the specified
139      // horizontal position.
140      x -= widget.getTotalPaddingLeft();
141      y -= widget.getTotalPaddingTop();
142
143      // Clamp the position to inside of the view.
144      if (x < 0) {
145          x = 0;
146      } else if (x >= (widget.getWidth()-widget.getTotalPaddingRight())) {
147          x = widget.getWidth()-widget.getTotalPaddingRight() - 1;
148      }
149      if (y < 0) {
150          y = 0;
151      } else if (y >= (widget.getHeight()-widget.getTotalPaddingBottom())) {
152          y = widget.getHeight()-widget.getTotalPaddingBottom() - 1;
153      }
154
155      x += widget.getScrollX();
156      y += widget.getScrollY();
157
158      Layout layout = widget.getLayout();
159      int line = layout.getLineForVertical(y);
160
161      int offset = layout.getOffsetForHorizontal(line, x);
162      return offset;
163    }
164
165    public boolean onKeyDown(TextView widget, Spannable buffer, int keyCode, KeyEvent event) {
166        if (executeDown(widget, buffer, keyCode)) {
167            MetaKeyKeyListener.adjustMetaAfterKeypress(buffer);
168            MetaKeyKeyListener.resetLockedMeta(buffer);
169            return true;
170        }
171
172        return false;
173    }
174
175    private boolean executeDown(TextView widget, Spannable buffer, int keyCode) {
176        boolean handled = false;
177
178        switch (keyCode) {
179        case KeyEvent.KEYCODE_DPAD_UP:
180            handled |= up(widget, buffer);
181            break;
182
183        case KeyEvent.KEYCODE_DPAD_DOWN:
184            handled |= down(widget, buffer);
185            break;
186
187        case KeyEvent.KEYCODE_DPAD_LEFT:
188            handled |= left(widget, buffer);
189            break;
190
191        case KeyEvent.KEYCODE_DPAD_RIGHT:
192            handled |= right(widget, buffer);
193            break;
194
195        case KeyEvent.KEYCODE_DPAD_CENTER:
196            if (MetaKeyKeyListener.getMetaState(buffer, MetaKeyKeyListener.META_SELECTING) != 0) {
197                if (widget.showContextMenu()) {
198                    handled = true;
199                }
200            }
201        }
202
203        if (handled) {
204            MetaKeyKeyListener.adjustMetaAfterKeypress(buffer);
205            MetaKeyKeyListener.resetLockedMeta(buffer);
206        }
207
208        return handled;
209    }
210
211    public boolean onKeyUp(TextView widget, Spannable buffer, int keyCode, KeyEvent event) {
212        return false;
213    }
214
215    public boolean onKeyOther(TextView view, Spannable text, KeyEvent event) {
216        int code = event.getKeyCode();
217        if (code != KeyEvent.KEYCODE_UNKNOWN
218                && event.getAction() == KeyEvent.ACTION_MULTIPLE) {
219            int repeat = event.getRepeatCount();
220            boolean handled = false;
221            while ((--repeat) > 0) {
222                handled |= executeDown(view, text, code);
223            }
224            return handled;
225        }
226        return false;
227    }
228
229    public boolean onTrackballEvent(TextView widget, Spannable text,
230            MotionEvent event) {
231        return false;
232    }
233
234    public boolean onTouchEvent(TextView widget, Spannable buffer,
235                                MotionEvent event) {
236        int initialScrollX = -1, initialScrollY = -1;
237        if (event.getAction() == MotionEvent.ACTION_UP) {
238            initialScrollX = Touch.getInitialScrollX(widget, buffer);
239            initialScrollY = Touch.getInitialScrollY(widget, buffer);
240        }
241
242        boolean handled = Touch.onTouchEvent(widget, buffer, event);
243
244        if (widget.isFocused() && !widget.didTouchFocusSelect()) {
245            if (event.getAction() == MotionEvent.ACTION_DOWN) {
246              boolean cap = (MetaKeyKeyListener.getMetaState(buffer,
247                              KeyEvent.META_SHIFT_ON) == 1) ||
248                            (MetaKeyKeyListener.getMetaState(buffer,
249                              MetaKeyKeyListener.META_SELECTING) != 0);
250              if (cap) {
251                  int x = (int) event.getX();
252                  int y = (int) event.getY();
253                  int offset = getOffset(x, y, widget);
254
255                  buffer.setSpan(LAST_TAP_DOWN, offset, offset,
256                                 Spannable.SPAN_POINT_POINT);
257
258                  // Disallow intercepting of the touch events, so that
259                  // users can scroll and select at the same time.
260                  // without this, users would get booted out of select
261                  // mode once the view detected it needed to scroll.
262                  widget.getParent().requestDisallowInterceptTouchEvent(true);
263              }
264            } else if (event.getAction() == MotionEvent.ACTION_MOVE ) {
265              boolean cap = (MetaKeyKeyListener.getMetaState(buffer,
266                              KeyEvent.META_SHIFT_ON) == 1) ||
267                            (MetaKeyKeyListener.getMetaState(buffer,
268                              MetaKeyKeyListener.META_SELECTING) != 0);
269
270              if (cap) {
271                // Update selection as we're moving the selection area.
272
273                // Get the current touch position
274                int x = (int) event.getX();
275                int y = (int) event.getY();
276                int offset = getOffset(x, y, widget);
277
278                // Get the last down touch position (the position at which the
279                // user started the selection)
280                int lastDownOffset = buffer.getSpanStart(LAST_TAP_DOWN);
281
282                // Compute the selection boundries
283                int spanstart;
284                int spanend;
285                if (offset >= lastDownOffset) {
286                  // Expand from word start of the original tap to new word
287                  // end, since we are selecting "forwards"
288                  spanstart = findWordStart(buffer, lastDownOffset);
289                  spanend = findWordEnd(buffer, offset);
290                } else {
291                  // Expand to from new word start to word end of the original
292                  // tap since we are selecting "backwards".
293                  // The spanend will always need to be associated with the touch
294                  // up position, so that refining the selection with the
295                  // trackball will work as expected.
296                  spanstart = findWordEnd(buffer, lastDownOffset);
297                  spanend = findWordStart(buffer, offset);
298                }
299
300                Selection.setSelection(buffer, spanstart, spanend);
301                return true;
302              }
303            } else if (event.getAction() == MotionEvent.ACTION_UP) {
304                // If we have scrolled, then the up shouldn't move the cursor,
305                // but we do need to make sure the cursor is still visible at
306                // the current scroll offset to avoid the scroll jumping later
307                // to show it.
308                if ((initialScrollY >= 0 && initialScrollY != widget.getScrollY()) ||
309                        (initialScrollX >= 0 && initialScrollX != widget.getScrollX())) {
310                    widget.moveCursorToVisibleOffset();
311                    return true;
312                }
313
314                int x = (int) event.getX();
315                int y = (int) event.getY();
316                int off = getOffset(x, y, widget);
317
318                // XXX should do the same adjust for x as we do for the line.
319
320                boolean cap = (MetaKeyKeyListener.getMetaState(buffer,
321                                KeyEvent.META_SHIFT_ON) == 1) ||
322                              (MetaKeyKeyListener.getMetaState(buffer,
323                                MetaKeyKeyListener.META_SELECTING) != 0);
324
325                DoubleTapState[] tap = buffer.getSpans(0, buffer.length(),
326                                                       DoubleTapState.class);
327                boolean doubletap = false;
328
329                if (tap.length > 0) {
330                    if (event.getEventTime() - tap[0].mWhen <=
331                        ViewConfiguration.getDoubleTapTimeout()) {
332                        if (sameWord(buffer, off, Selection.getSelectionEnd(buffer))) {
333                            doubletap = true;
334                        }
335                    }
336
337                    tap[0].mWhen = event.getEventTime();
338                } else {
339                    DoubleTapState newtap = new DoubleTapState();
340                    newtap.mWhen = event.getEventTime();
341                    buffer.setSpan(newtap, 0, buffer.length(),
342                                   Spannable.SPAN_INCLUSIVE_INCLUSIVE);
343                }
344
345                if (cap) {
346                    buffer.removeSpan(LAST_TAP_DOWN);
347                } else if (doubletap) {
348                    Selection.setSelection(buffer,
349                                           findWordStart(buffer, off),
350                                           findWordEnd(buffer, off));
351                } else {
352                    Selection.setSelection(buffer, off);
353                }
354
355                MetaKeyKeyListener.adjustMetaAfterKeypress(buffer);
356                MetaKeyKeyListener.resetLockedMeta(buffer);
357
358                return true;
359            }
360        }
361
362        return handled;
363    }
364
365    private static class DoubleTapState implements NoCopySpan {
366        long mWhen;
367    }
368
369    private static boolean sameWord(CharSequence text, int one, int two) {
370        int start = findWordStart(text, one);
371        int end = findWordEnd(text, one);
372
373        if (end == start) {
374            return false;
375        }
376
377        return start == findWordStart(text, two) &&
378               end == findWordEnd(text, two);
379    }
380
381    // TODO: Unify with TextView.getWordForDictionary()
382    private static int findWordStart(CharSequence text, int start) {
383        for (; start > 0; start--) {
384            char c = text.charAt(start - 1);
385            int type = Character.getType(c);
386
387            if (c != '\'' &&
388                type != Character.UPPERCASE_LETTER &&
389                type != Character.LOWERCASE_LETTER &&
390                type != Character.TITLECASE_LETTER &&
391                type != Character.MODIFIER_LETTER &&
392                type != Character.DECIMAL_DIGIT_NUMBER) {
393                break;
394            }
395        }
396
397        return start;
398    }
399
400    // TODO: Unify with TextView.getWordForDictionary()
401    private static int findWordEnd(CharSequence text, int end) {
402        int len = text.length();
403
404        for (; end < len; end++) {
405            char c = text.charAt(end);
406            int type = Character.getType(c);
407
408            if (c != '\'' &&
409                type != Character.UPPERCASE_LETTER &&
410                type != Character.LOWERCASE_LETTER &&
411                type != Character.TITLECASE_LETTER &&
412                type != Character.MODIFIER_LETTER &&
413                type != Character.DECIMAL_DIGIT_NUMBER) {
414                break;
415            }
416        }
417
418        return end;
419    }
420
421    public boolean canSelectArbitrarily() {
422        return true;
423    }
424
425    public void initialize(TextView widget, Spannable text) {
426        Selection.setSelection(text, 0);
427    }
428
429    public void onTakeFocus(TextView view, Spannable text, int dir) {
430        if ((dir & (View.FOCUS_FORWARD | View.FOCUS_DOWN)) != 0) {
431            Layout layout = view.getLayout();
432
433            if (layout == null) {
434                /*
435                 * This shouldn't be null, but do something sensible if it is.
436                 */
437                Selection.setSelection(text, text.length());
438            } else {
439                /*
440                 * Put the cursor at the end of the first line, which is
441                 * either the last offset if there is only one line, or the
442                 * offset before the first character of the second line
443                 * if there is more than one line.
444                 */
445                if (layout.getLineCount() == 1) {
446                    Selection.setSelection(text, text.length());
447                } else {
448                    Selection.setSelection(text, layout.getLineStart(1) - 1);
449                }
450            }
451        } else {
452            Selection.setSelection(text, text.length());
453        }
454    }
455
456    public static MovementMethod getInstance() {
457        if (sInstance == null)
458            sInstance = new ArrowKeyMovementMethod();
459
460        return sInstance;
461    }
462
463
464    private static final Object LAST_TAP_DOWN = new Object();
465    private static ArrowKeyMovementMethod sInstance;
466}
467