Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
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
  
17
  package android.widget;
18
  
21
  
23
  
39
  import android.os.Bundle;
42
  import android.os.Parcel;
85
  import android.util.Log;
93
  import android.view.View;
112
 
Displays text to the user and optionally allows them to edit it. A TextView is a complete text editor, however the basic class is configured to not allow editing; see EditText for a subclass that configures the text view for editing.

XML attributes

See TextView Attributes, View Attributes

Attr:
ref android.R.styleable#TextView_text
Attr:
ref android.R.styleable#TextView_bufferType
Attr:
ref android.R.styleable#TextView_hint
Attr:
ref android.R.styleable#TextView_textColor
Attr:
ref android.R.styleable#TextView_textColorHighlight
Attr:
ref android.R.styleable#TextView_textColorHint
Attr:
ref android.R.styleable#TextView_textAppearance
Attr:
ref android.R.styleable#TextView_textColorLink
Attr:
ref android.R.styleable#TextView_textSize
Attr:
ref android.R.styleable#TextView_textScaleX
Attr:
ref android.R.styleable#TextView_typeface
Attr:
ref android.R.styleable#TextView_textStyle
Attr:
ref android.R.styleable#TextView_cursorVisible
Attr:
ref android.R.styleable#TextView_maxLines
Attr:
ref android.R.styleable#TextView_maxHeight
Attr:
ref android.R.styleable#TextView_lines
Attr:
ref android.R.styleable#TextView_height
Attr:
ref android.R.styleable#TextView_minLines
Attr:
ref android.R.styleable#TextView_minHeight
Attr:
ref android.R.styleable#TextView_maxEms
Attr:
ref android.R.styleable#TextView_maxWidth
Attr:
ref android.R.styleable#TextView_ems
Attr:
ref android.R.styleable#TextView_width
Attr:
ref android.R.styleable#TextView_minEms
Attr:
ref android.R.styleable#TextView_minWidth
Attr:
ref android.R.styleable#TextView_gravity
Attr:
ref android.R.styleable#TextView_scrollHorizontally
Attr:
ref android.R.styleable#TextView_password
Attr:
ref android.R.styleable#TextView_singleLine
Attr:
ref android.R.styleable#TextView_selectAllOnFocus
Attr:
ref android.R.styleable#TextView_includeFontPadding
Attr:
ref android.R.styleable#TextView_maxLength
Attr:
ref android.R.styleable#TextView_shadowColor
Attr:
ref android.R.styleable#TextView_shadowDx
Attr:
ref android.R.styleable#TextView_shadowDy
Attr:
ref android.R.styleable#TextView_shadowRadius
Attr:
ref android.R.styleable#TextView_autoLink
Attr:
ref android.R.styleable#TextView_linksClickable
Attr:
ref android.R.styleable#TextView_numeric
Attr:
ref android.R.styleable#TextView_digits
Attr:
ref android.R.styleable#TextView_phoneNumber
Attr:
ref android.R.styleable#TextView_inputMethod
Attr:
ref android.R.styleable#TextView_capitalize
Attr:
ref android.R.styleable#TextView_autoText
Attr:
ref android.R.styleable#TextView_editable
Attr:
ref android.R.styleable#TextView_freezesText
Attr:
ref android.R.styleable#TextView_ellipsize
Attr:
ref android.R.styleable#TextView_drawableTop
Attr:
ref android.R.styleable#TextView_drawableBottom
Attr:
ref android.R.styleable#TextView_drawableRight
Attr:
ref android.R.styleable#TextView_drawableLeft
Attr:
ref android.R.styleable#TextView_drawablePadding
Attr:
ref android.R.styleable#TextView_lineSpacingExtra
Attr:
ref android.R.styleable#TextView_lineSpacingMultiplier
Attr:
ref android.R.styleable#TextView_marqueeRepeatLimit
Attr:
ref android.R.styleable#TextView_inputType
Attr:
ref android.R.styleable#TextView_imeOptions
Attr:
ref android.R.styleable#TextView_privateImeOptions
Attr:
ref android.R.styleable#TextView_imeActionLabel
Attr:
ref android.R.styleable#TextView_imeActionId
Attr:
ref android.R.styleable#TextView_editorExtras
190
 
192
 public class TextView extends View implements ViewTreeObserver.OnPreDrawListener {
193
     static final String LOG_TAG = "TextView";
194
     static final boolean DEBUG_EXTRACT = false;
195
     
196
     private static int PRIORITY = 100;
197
 
198
     final int[] mTempCoords = new int[2];
199
     Rect mTempRect;
200
 
201
     private ColorStateList mTextColor;
202
     private int mCurTextColor;
203
     private ColorStateList mHintTextColor;
204
     private ColorStateList mLinkTextColor;
205
     private int mCurHintTextColor;
206
     private boolean mFreezesText;
207
     private boolean mFrozenWithFocus;
208
     private boolean mTemporaryDetach;
209
     private boolean mDispatchTemporaryDetach;
210
 
211
     private boolean mEatTouchRelease = false;
212
     private boolean mScrolled = false;
213
 
214
     private Editable.Factory mEditableFactory = Editable.Factory.getInstance();
215
     private Spannable.Factory mSpannableFactory = Spannable.Factory.getInstance();
216
 
217
     private float mShadowRadius, mShadowDx, mShadowDy;
218
 
219
     private static final int PREDRAW_NOT_REGISTERED = 0;
220
     private static final int PREDRAW_PENDING = 1;
221
     private static final int PREDRAW_DONE = 2;
222
     private int mPreDrawState = ;
223
 
224
     private TextUtils.TruncateAt mEllipsize = null;
225
 
226
     // Enum for the "typeface" XML parameter.
227
     // TODO: How can we get this from the XML instead of hardcoding it here?
228
     private static final int SANS = 1;
229
     private static final int SERIF = 2;
230
     private static final int MONOSPACE = 3;
231
 
232
     // Bitfield for the "numeric" XML parameter.
233
     // TODO: How can we get this from the XML instead of hardcoding it here?
234
     private static final int SIGNED = 2;
235
     private static final int DECIMAL = 4;
236
 
237
     class Drawables {
238
         final Rect mCompoundRect = new Rect();
242
         int mDrawablePadding;
243
     }
244
     private Drawables mDrawables;
245
 
246
     private CharSequence mError;
247
     private boolean mErrorWasChanged;
248
     private ErrorPopup mPopup;
    
This flag is set if the TextView tries to display an error before it is attached to the window (so its position is still unknown). It causes the error to be shown later, when onAttachedToWindow() is called. 
254
 
255
     private boolean mShowErrorAfterAttach;
256
 
257
     private CharWrapper mCharWrapper = null;
258
 
259
     private boolean mSelectionMoved = false;
260
     private boolean mTouchFocusSelected = false;
261
 
262
     private Marquee mMarquee;
263
     private boolean mRestartMarquee;
264
 
265
     private int mMarqueeRepeatLimit = 3;
266
 
267
     class InputContentType {
268
         int imeOptions = .;
269
         String privateImeOptions;
270
         CharSequence imeActionLabel;
271
         int imeActionId;
272
         Bundle extras;
274
         boolean enterDown;
275
     }
277
 
278
     class InputMethodState {
279
         Rect mCursorRectInWindow = new Rect();
280
         RectF mTmpRectF = new RectF();
281
         float[] mTmpOffset = new float[2];
283
         final ExtractedText mTmpExtracted = new ExtractedText();
284
         int mBatchEditNesting;
285
         boolean mCursorChanged;
286
         boolean mSelectionModeChanged;
287
         boolean mContentChanged;
288
         int mChangedStart, mChangedEnd, mChangedDelta;
289
     }
291
 
294
     int mTextSelectHandleRes;
295
 
299
 
300
     /*
301
      * Kick-start the font cache for the zygote process (to pay the cost of
302
      * initializing freetype for our default font only once).
303
      */
304
     static {
305
         Paint p = new Paint();
306
         p.setAntiAlias(true);
307
         // We don't care about the result, just the side-effect of measuring.
308
         p.measureText("H");
309
     }

    
Interface definition for a callback to be invoked when an action is performed on the editor. 
314
 
315
     public interface OnEditorActionListener {
        
Called when an action is being performed.

Parameters:
v The view that was clicked.
actionId Identifier of the action. This will be either the identifier you supplied, or EditorInfo.IME_NULL if being called due to the enter key being pressed.
event If triggered by an enter key, this is the event; otherwise, this is null.
Returns:
Return true if you have consumed the action, else false.
327
 
328
         boolean onEditorAction(TextView v, int actionId, KeyEvent event);
329
     }
330
     
331
     public TextView(Context context) {
332
         this(context, null);
333
     }
334
 
335
     public TextView(Context context,
336
                     AttributeSet attrs) {
337
         this(context, attrs, .....);
338
     }
339
 
340
     @SuppressWarnings("deprecation")
341
     public TextView(Context context,
342
                     AttributeSet attrs,
343
                     int defStyle) {
344
         super(context, attrs, defStyle);
345
          = "";
346
 
347
          = new TextPaint(.);
350
                 getResources().getCompatibilityInfo().);
351
         
352
         // If we get the paint from the skin, we should set it to left, since
353
         // the layout always wants it to be left.
354
         // mTextPaint.setTextAlign(Paint.Align.LEFT);
355
 
356
          = new Paint(.);
358
                 getResources().getCompatibilityInfo().);
359
 
360
          = getDefaultMovementMethod();
361
          = null;
362
 
363
         TypedArray a =
364
             context.obtainStyledAttributes(
365
                 attrs, ....., defStyle, 0);
366
 
367
         int textColorHighlight = 0;
368
         ColorStateList textColor = null;
369
         ColorStateList textColorHint = null;
370
         ColorStateList textColorLink = null;
371
         int textSize = 15;
372
         int typefaceIndex = -1;
373
         int styleIndex = -1;
374
 
375
         /*
376
          * Look the appearance up without checking first if it exists because
377
          * almost every TextView has one and it greatly simplifies the logic
378
          * to be able to parse the appearance first and then let specific tags
379
          * for this View override it.
380
          */
381
         TypedArray appearance = null;
382
         int ap = a.getResourceId(....., -1);
383
         if (ap != -1) {
384
             appearance = context.obtainStyledAttributes(ap,
385
                                 .....
386
                                 );
387
         }
388
         if (appearance != null) {
389
             int n = appearance.getIndexCount();
390
             for (int i = 0; i < n; i++) {
391
                 int attr = appearance.getIndex(i);
392
 
393
                 switch (attr) {
394
                 case .....:
395
                     textColorHighlight = appearance.getColor(attr, textColorHighlight);
396
                     break;
397
 
398
                 case .....:
399
                     textColor = appearance.getColorStateList(attr);
400
                     break;
401
 
402
                 case .....:
403
                     textColorHint = appearance.getColorStateList(attr);
404
                     break;
405
 
406
                 case .....:
407
                     textColorLink = appearance.getColorStateList(attr);
408
                     break;
409
 
410
                 case .....:
411
                     textSize = appearance.getDimensionPixelSize(attr, textSize);
412
                     break;
413
 
414
                 case .....:
415
                     typefaceIndex = appearance.getInt(attr, -1);
416
                     break;
417
 
418
                 case .....:
419
                     styleIndex = appearance.getInt(attr, -1);
420
                     break;
421
                 }
422
             }
423
 
424
             appearance.recycle();
425
         }
426
 
427
         boolean editable = getDefaultEditable();
428
         CharSequence inputMethod = null;
429
         int numeric = 0;
430
         CharSequence digits = null;
431
         boolean phone = false;
432
         boolean autotext = false;
433
         int autocap = -1;
434
         int buffertype = 0;
435
         boolean selectallonfocus = false;
436
         Drawable drawableLeft = null, drawableTop = null, drawableRight = null,
437
             drawableBottom = null;
438
         int drawablePadding = 0;
439
         int ellipsize = -1;
440
         boolean singleLine = false;
441
         int maxlength = -1;
442
         CharSequence text = "";
443
         CharSequence hint = null;
444
         int shadowcolor = 0;
445
         float dx = 0, dy = 0, r = 0;
446
         boolean password = false;
447
         int inputType = .;
448
 
449
         int n = a.getIndexCount();
450
         for (int i = 0; i < n; i++) {
451
             int attr = a.getIndex(i);
452
 
453
             switch (attr) {
454
             case .....:
455
                 editable = a.getBoolean(attr, editable);
456
                 break;
457
 
458
             case .....:
459
                 inputMethod = a.getText(attr);
460
                 break;
461
 
462
             case .....:
463
                 numeric = a.getInt(attr, numeric);
464
                 break;
465
 
466
             case .....:
467
                 digits = a.getText(attr);
468
                 break;
469
 
470
             case .....:
471
                 phone = a.getBoolean(attr, phone);
472
                 break;
473
 
474
             case .....:
475
                 autotext = a.getBoolean(attr, autotext);
476
                 break;
477
 
478
             case .....:
479
                 autocap = a.getInt(attr, autocap);
480
                 break;
481
 
482
             case .....:
483
                 buffertype = a.getInt(attr, buffertype);
484
                 break;
485
 
486
             case .....:
487
                 selectallonfocus = a.getBoolean(attr, selectallonfocus);
488
                 break;
489
 
490
             case .....:
491
                  = a.getInt(attr, 0);
492
                 break;
493
 
494
             case .....:
495
                  = a.getBoolean(attr, true);
496
                 break;
497
 
498
             case .....:
499
                 drawableLeft = a.getDrawable(attr);
500
                 break;
501
 
502
             case .....:
503
                 drawableTop = a.getDrawable(attr);
504
                 break;
505
 
506
             case .....:
507
                 drawableRight = a.getDrawable(attr);
508
                 break;
509
 
510
             case .....:
511
                 drawableBottom = a.getDrawable(attr);
512
                 break;
513
 
514
             case .....:
515
                 drawablePadding = a.getDimensionPixelSize(attr, drawablePadding);
516
                 break;
517
 
518
             case .....:
519
                 setMaxLines(a.getInt(attr, -1));
520
                 break;
521
 
522
             case .....:
523
                 setMaxHeight(a.getDimensionPixelSize(attr, -1));
524
                 break;
525
 
526
             case .....:
527
                 setLines(a.getInt(attr, -1));
528
                 break;
529
 
530
             case .....:
531
                 setHeight(a.getDimensionPixelSize(attr, -1));
532
                 break;
533
 
534
             case .....:
535
                 setMinLines(a.getInt(attr, -1));
536
                 break;
537
 
538
             case .....:
539
                 setMinHeight(a.getDimensionPixelSize(attr, -1));
540
                 break;
541
 
542
             case .....:
543
                 setMaxEms(a.getInt(attr, -1));
544
                 break;
545
 
546
             case .....:
547
                 setMaxWidth(a.getDimensionPixelSize(attr, -1));
548
                 break;
549
 
550
             case .....:
551
                 setEms(a.getInt(attr, -1));
552
                 break;
553
 
554
             case .....:
555
                 setWidth(a.getDimensionPixelSize(attr, -1));
556
                 break;
557
 
558
             case .....:
559
                 setMinEms(a.getInt(attr, -1));
560
                 break;
561
 
562
             case .....:
563
                 setMinWidth(a.getDimensionPixelSize(attr, -1));
564
                 break;
565
 
566
             case .....:
567
                 setGravity(a.getInt(attr, -1));
568
                 break;
569
 
570
             case .....:
571
                 hint = a.getText(attr);
572
                 break;
573
 
574
             case .....:
575
                 text = a.getText(attr);
576
                 break;
577
 
579
                 if (a.getBoolean(attr, false)) {
580
                     setHorizontallyScrolling(true);
581
                 }
582
                 break;
583
 
584
             case .....:
585
                 singleLine = a.getBoolean(attr, singleLine);
586
                 break;
587
 
588
             case .....:
589
                 ellipsize = a.getInt(attr, ellipsize);
590
                 break;
591
 
593
                 setMarqueeRepeatLimit(a.getInt(attr, ));
594
                 break;
595
 
597
                 if (!a.getBoolean(attr, true)) {
598
                     setIncludeFontPadding(false);
599
                 }
600
                 break;
601
 
602
             case .....:
603
                 if (!a.getBoolean(attr, true)) {
604
                     setCursorVisible(false);
605
                 }
606
                 break;
607
 
608
             case .....:
609
                 maxlength = a.getInt(attr, -1);
610
                 break;
611
 
612
             case .....:
613
                 setTextScaleX(a.getFloat(attr, 1.0f));
614
                 break;
615
 
616
             case .....:
617
                  = a.getBoolean(attr, false);
618
                 break;
619
 
620
             case .....:
621
                 shadowcolor = a.getInt(attr, 0);
622
                 break;
623
 
624
             case .....:
625
                 dx = a.getFloat(attr, 0);
626
                 break;
627
 
628
             case .....:
629
                 dy = a.getFloat(attr, 0);
630
                 break;
631
 
632
             case .....:
633
                 r = a.getFloat(attr, 0);
634
                 break;
635
 
636
             case .....:
637
                 setEnabled(a.getBoolean(attr, isEnabled()));
638
                 break;
639
 
641
                 textColorHighlight = a.getColor(attr, textColorHighlight);
642
                 break;
643
 
644
             case .....:
645
                 textColor = a.getColorStateList(attr);
646
                 break;
647
 
648
             case .....:
649
                 textColorHint = a.getColorStateList(attr);
650
                 break;
651
 
652
             case .....:
653
                 textColorLink = a.getColorStateList(attr);
654
                 break;
655
 
656
             case .....:
657
                 textSize = a.getDimensionPixelSize(attr, textSize);
658
                 break;
659
 
660
             case .....:
661
                 typefaceIndex = a.getInt(attr, typefaceIndex);
662
                 break;
663
 
664
             case .....:
665
                 styleIndex = a.getInt(attr, styleIndex);
666
                 break;
667
 
668
             case .....:
669
                 password = a.getBoolean(attr, password);
670
                 break;
671
 
672
             case .....:
673
                  = a.getDimensionPixelSize(attr, (int) );
674
                 break;
675
 
677
                  = a.getFloat(attr, );
678
                 break;
679
 
680
             case .....:
681
                 inputType = a.getInt(attr, );
682
                 break;
683
 
684
             case .....:
685
                 if ( == null) {
686
                      = new InputContentType();
687
                 }
688
                 . = a.getInt(attr,
689
                         .);
690
                 break;
691
 
692
             case .....:
693
                 if ( == null) {
694
                      = new InputContentType();
695
                 }
696
                 . = a.getText(attr);
697
                 break;
698
 
699
             case .....:
700
                 if ( == null) {
701
                      = new InputContentType();
702
                 }
703
                 . = a.getInt(attr,
704
                         .);
705
                 break;
706
 
707
             case .....:
708
                 setPrivateImeOptions(a.getString(attr));
709
                 break;
710
 
711
             case .....:
712
                 try {
713
                     setInputExtras(a.getResourceId(attr, 0));
714
                 } catch (XmlPullParserException e) {
715
                     Log.w(, "Failure reading input extras", e);
716
                 } catch (IOException e) {
717
                     Log.w(, "Failure reading input extras", e);
718
                 }
719
                 break;
720
 
722
                  = a.getResourceId(attr, 0);
723
                 break;
724
 
726
                  = a.getResourceId(attr, 0);
727
                 break;
728
 
729
             case .....:
730
                  = a.getResourceId(attr, 0);
731
                 break;
732
             }
733
         }
734
         a.recycle();
735
 
736
         BufferType bufferType = .;
737
 
738
         if ((inputType & (. | .))
739
                 == (. | .)) {
740
             password = true;
741
         }
742
 
743
         if (inputMethod != null) {
744
             Class<?> c;
745
 
746
             try {
747
                 c = Class.forName(inputMethod.toString());
748
             } catch (ClassNotFoundException ex) {
749
                 throw new RuntimeException(ex);
750
             }
751
 
752
             try {
753
                  = (KeyListener) c.newInstance();
754
             } catch (InstantiationException ex) {
755
                 throw new RuntimeException(ex);
756
             } catch (IllegalAccessException ex) {
757
                 throw new RuntimeException(ex);
758
             }
759
             try {
760
                  = inputType != .
761
                         ? inputType
762
                         : .getInputType();
763
             } catch (IncompatibleClassChangeError e) {
764
                  = .;
765
             }
766
         } else if (digits != null) {
767
              = DigitsKeyListener.getInstance(digits.toString());
768
             // If no input type was specified, we will default to generic
769
             // text, since we can't tell the IME about the set of digits
770
             // that was selected.
771
              = inputType != .
772
                     ? inputType : .;
773
         } else if (inputType != .) {
774
             setInputType(inputType, true);
775
             singleLine = (inputType&(.
776
                             | .)) !=
777
                     (.
778
                             | .);
779
         } else if (phone) {
780
              = DialerKeyListener.getInstance();
781
              = inputType = .;
782
         } else if (numeric != 0) {
783
              = DigitsKeyListener.getInstance((numeric & ) != 0,
784
                                                    (numeric & ) != 0);
785
             inputType = .;
786
             if ((numeric & ) != 0) {
787
                 inputType |= .;
788
             }
789
             if ((numeric & ) != 0) {
790
                 inputType |= .;
791
             }
792
              = inputType;
793
         } else if (autotext || autocap != -1) {
794
             TextKeyListener.Capitalize cap;
795
 
796
             inputType = .;
797
             if (!singleLine) {
798
                 inputType |= .;
799
             }
800
 
801
             switch (autocap) {
802
             case 1:
803
                 cap = ..;
804
                 inputType |= .;
805
                 break;
806
 
807
             case 2:
808
                 cap = ..;
809
                 inputType |= .;
810
                 break;
811
 
812
             case 3:
813
                 cap = ..;
814
                 inputType |= .;
815
                 break;
816
 
817
             default:
818
                 cap = ..;
819
                 break;
820
             }
821
 
822
              = TextKeyListener.getInstance(autotext, cap);
823
              = inputType;
824
         } else if (editable) {
825
              = TextKeyListener.getInstance();
826
              = .;
827
             if (!singleLine) {
828
                  |= .;
829
             }
830
         } else {
831
              = null;
832
 
833
             switch (buffertype) {
834
                 case 0:
835
                     bufferType = .;
836
                     break;
837
                 case 1:
838
                     bufferType = .;
839
                     break;
840
                 case 2:
841
                     bufferType = .;
842
                     break;
843
             }
844
         }
845
 
846
         if (password && (&.)
847
                 == .) {
848
              = ( & ~(.))
849
                 | .;
850
         }
851
 
852
         if (selectallonfocus) {
853
              = true;
854
 
855
             if (bufferType == .)
856
                 bufferType = .;
857
         }
858
 
860
             drawableLeft, drawableTop, drawableRight, drawableBottom);
861
         setCompoundDrawablePadding(drawablePadding);
862
 
863
         if (singleLine) {
864
             setSingleLine();
865
 
866
             if ( == null && ellipsize < 0) {
867
                 ellipsize = 3; // END
868
             }
869
         }
870
 
871
         switch (ellipsize) {
872
             case 1:
873
                 setEllipsize(..);
874
                 break;
875
             case 2:
876
                 setEllipsize(..);
877
                 break;
878
             case 3:
879
                 setEllipsize(..);
880
                 break;
881
             case 4:
882
                 setHorizontalFadingEdgeEnabled(true);
883
                 setEllipsize(..);
884
                 break;
885
         }
886
 
887
         setTextColor(textColor != null ? textColor : ColorStateList.valueOf(0xFF000000));
888
         setHintTextColor(textColorHint);
889
         setLinkTextColor(textColorLink);
890
         if (textColorHighlight != 0) {
891
             setHighlightColor(textColorHighlight);
892
         }
893
         setRawTextSize(textSize);
894
 
895
         if (password) {
896
             setTransformationMethod(PasswordTransformationMethod.getInstance());
897
             typefaceIndex = ;
898
         } else if ((&(.
899
                 |.))
900
                 == (.
901
                         |.)) {
902
             typefaceIndex = ;
903
         }
904
 
905
         setTypefaceByIndex(typefaceIndex, styleIndex);
906
 
907
         if (shadowcolor != 0) {
908
             setShadowLayer(r, dx, dy, shadowcolor);
909
         }
910
 
911
         if (maxlength >= 0) {
912
             setFilters(new InputFilter[] { new InputFilter.LengthFilter(maxlength) });
913
         } else {
914
             setFilters();
915
         }
916
 
917
         setText(text, bufferType);
918
         if (hint != null) setHint(hint);
919
 
920
         /*
921
          * Views are not normally focusable unless specified to be.
922
          * However, TextViews that have input or movement methods *are*
923
          * focusable by default.
924
          */
925
         a = context.obtainStyledAttributes(attrs,
926
                                            .....,
927
                                            defStyle, 0);
928
 
929
         boolean focusable =  != null ||  != null;
930
         boolean clickable = focusable;
931
         boolean longClickable = focusable;
932
 
933
         n = a.getIndexCount();
934
         for (int i = 0; i < n; i++) {
935
             int attr = a.getIndex(i);
936
 
937
             switch (attr) {
938
             case .....:
939
                 focusable = a.getBoolean(attr, focusable);
940
                 break;
941
 
942
             case .....:
943
                 clickable = a.getBoolean(attr, clickable);
944
                 break;
945
 
946
             case .....:
947
                 longClickable = a.getBoolean(attr, longClickable);
948
                 break;
949
             }
950
         }
951
         a.recycle();
952
 
953
         setFocusable(focusable);
954
         setClickable(clickable);
955
         setLongClickable(longClickable);
956
 
957
         prepareCursorControllers();
958
     }
959
 
960
     private void setTypefaceByIndex(int typefaceIndex, int styleIndex) {
961
         Typeface tf = null;
962
         switch (typefaceIndex) {
963
             case :
964
                 tf = .;
965
                 break;
966
 
967
             case :
968
                 tf = .;
969
                 break;
970
 
971
             case :
972
                 tf = .;
973
                 break;
974
         }
975
 
976
         setTypeface(tf, styleIndex);
977
     }

    
Sets the typeface and style in which the text should be displayed, and turns on the fake bold and italic bits in the Paint if the Typeface that you provided does not have all the bits in the style that you specified.

Attr:
ref android.R.styleable#TextView_typeface
Attr:
ref android.R.styleable#TextView_textStyle
987
 
988
     public void setTypeface(Typeface tf, int style) {
989
         if (style > 0) {
990
             if (tf == null) {
991
                 tf = Typeface.defaultFromStyle(style);
992
             } else {
993
                 tf = Typeface.create(tf, style);
994
             }
995
 
996
             setTypeface(tf);
997
             // now compute what (if any) algorithmic styling is needed
998
             int typefaceStyle = tf != null ? tf.getStyle() : 0;
999
             int need = style & ~typefaceStyle;
1000
            .setFakeBoldText((need & .) != 0);
1001
            .setTextSkewX((need & .) != 0 ? -0.25f : 0);
1002
        } else {
1003
            .setFakeBoldText(false);
1004
            .setTextSkewX(0);
1005
            setTypeface(tf);
1006
        }
1007
    }

    
Subclasses override this to specify that they have a KeyListener by default even if not specifically called for in the XML options. 
1013
    protected boolean getDefaultEditable() {
1014
        return false;
1015
    }

    
Subclasses override this to specify a default movement method. 
1021
        return null;
1022
    }

    
Return the text the TextView is displaying. If setText() was called with an argument of BufferType.SPANNABLE or BufferType.EDITABLE, you can cast the return value from this method to Spannable or Editable, respectively. Note: The content of the return value should not be modified. If you want a modifiable one, you should make your own copy first. 
1033
    public CharSequence getText() {
1034
        return ;
1035
    }

    
Returns the length, in characters, of the text managed by this TextView 
1040
    public int length() {
1041
        return .length();
1042
    }

    
Return the text the TextView is displaying as an Editable object. If the text is not editable, null is returned.

See also:
getText()
1050
    public Editable getEditableText() {
1051
        return ( instanceof Editable) ? (Editable) : null;
1052
    }

    

Returns:
the height of one standard line in pixels. Note that markup within the text can cause individual lines to be taller or shorter than this height, and the layout may contain additional first- or last-line padding.
1060
    public int getLineHeight() {
1061
        return FastMath.round(.getFontMetricsInt(null) * 
1062
                          + );
1063
    }

    

Returns:
the Layout that is currently being used to display the text. This can be null if the text or width has recently changes.
1069
    public final Layout getLayout() {
1070
        return ;
1071
    }

    

Returns:
the current key listener for this TextView. This will frequently be null for non-EditText TextViews.
1077
    public final KeyListener getKeyListener() {
1078
        return ;
1079
    }

    
Sets the key listener to be used with this TextView. This can be null to disallow user input. Note that this method has significant and subtle interactions with soft keyboards and other input method: see KeyListener.getContentType() for important details. Calling this method will replace the current content type of the text view with the content type returned by the key listener.

Be warned that if you want a TextView with a key listener or movement method not to be focusable, or if you want a TextView without a key listener or movement method to be focusable, you must call android.view.View.setFocusable(boolean) again after calling this to get the focusability back the way you want it.

Attr:
ref android.R.styleable#TextView_numeric
Attr:
ref android.R.styleable#TextView_digits
Attr:
ref android.R.styleable#TextView_phoneNumber
Attr:
ref android.R.styleable#TextView_inputMethod
Attr:
ref android.R.styleable#TextView_capitalize
Attr:
ref android.R.styleable#TextView_autoText
1103
    public void setKeyListener(KeyListener input) {
1104
        setKeyListenerOnly(input);
1107
        if (input != null) {
1108
            try {
1109
                 = .getInputType();
1110
            } catch (IncompatibleClassChangeError e) {
1111
                 = .;
1112
            }
1113
            if ((&.)
1114
                    == .) {
1115
                if () {
1116
                     &= ~.;
1117
                } else {
1118
                     |= .;
1119
                }
1120
            }
1121
        } else {
1122
             = .;
1123
        }
1125
        InputMethodManager imm = InputMethodManager.peekInstance();
1126
        if (imm != null) imm.restartInput(this);
1127
    }
1129
    private void setKeyListenerOnly(KeyListener input) {
1130
         = input;
1131
        if ( != null && !( instanceof Editable))
1132
            setText();
1134
        setFilters((Editable) , );
1135
    }

    

Returns:
the movement method being used for this TextView. This will frequently be null for non-EditText TextViews.
1141
    public final MovementMethod getMovementMethod() {
1142
        return ;
1143
    }

    
Sets the movement method (arrow key handler) to be used for this TextView. This can be null to disallow using the arrow keys to move the cursor or scroll the view.

Be warned that if you want a TextView with a key listener or movement method not to be focusable, or if you want a TextView without a key listener or movement method to be focusable, you must call android.view.View.setFocusable(boolean) again after calling this to get the focusability back the way you want it. 

1156
    public final void setMovementMethod(MovementMethod movement) {
1157
         = movement;
1159
        if ( != null && !( instanceof Spannable))
1160
            setText();
1164
        // SelectionModifierCursorController depends on textCanBeSelected, which depends on mMovement
1165
        prepareCursorControllers();
1166
    }
1168
    private void fixFocusableAndClickableSettings() {
1169
        if (( != null) ||  != null) {
1170
            setFocusable(true);
1171
            setClickable(true);
1172
            setLongClickable(true);
1173
        } else {
1174
            setFocusable(false);
1175
            setClickable(false);
1176
            setLongClickable(false);
1177
        }
1178
    }

    

Returns:
the current transformation method for this TextView. This will frequently be null except for single-line and password fields.
1186
        return ;
1187
    }

    
Sets the transformation that is applied to the text that this TextView is displaying.

Attr:
ref android.R.styleable#TextView_password
Attr:
ref android.R.styleable#TextView_singleLine
1196
    public final void setTransformationMethod(TransformationMethod method) {
1197
        if (method == ) {
1198
            // Avoid the setText() below if the transformation is
1199
            // the same.
1200
            return;
1201
        }
1202
        if ( != null) {
1203
            if ( instanceof Spannable) {
1204
                ((Spannable) ).removeSpan();
1205
            }
1206
        }
1208
         = method;
1210
        setText();
1211
    }

    
Returns the top padding of the view, plus space for the top Drawable if any. 
1217
    public int getCompoundPaddingTop() {
1218
        final Drawables dr = ;
1219
        if (dr == null || dr.mDrawableTop == null) {
1220
            return ;
1221
        } else {
1222
            return  + dr.mDrawablePadding + dr.mDrawableSizeTop;
1223
        }
1224
    }

    
Returns the bottom padding of the view, plus space for the bottom Drawable if any. 
1230
    public int getCompoundPaddingBottom() {
1231
        final Drawables dr = ;
1232
        if (dr == null || dr.mDrawableBottom == null) {
1233
            return ;
1234
        } else {
1235
            return  + dr.mDrawablePadding + dr.mDrawableSizeBottom;
1236
        }
1237
    }

    
Returns the left padding of the view, plus space for the left Drawable if any. 
1243
    public int getCompoundPaddingLeft() {
1244
        final Drawables dr = ;
1245
        if (dr == null || dr.mDrawableLeft == null) {
1246
            return ;
1247
        } else {
1248
            return  + dr.mDrawablePadding + dr.mDrawableSizeLeft;
1249
        }
1250
    }

    
Returns the right padding of the view, plus space for the right Drawable if any. 
1256
    public int getCompoundPaddingRight() {
1257
        final Drawables dr = ;
1258
        if (dr == null || dr.mDrawableRight == null) {
1259
            return ;
1260
        } else {
1261
            return  + dr.mDrawablePadding + dr.mDrawableSizeRight;
1262
        }
1263
    }

    
Returns the extended top padding of the view, including both the top Drawable if any and any extra space to keep more than maxLines of text from showing. It is only valid to call this after measuring. 
1270
    public int getExtendedPaddingTop() {
1271
        if ( != ) {
1272
            return getCompoundPaddingTop();
1273
        }
1275
        if (.getLineCount() <= ) {
1276
            return getCompoundPaddingTop();
1277
        }
1279
        int top = getCompoundPaddingTop();
1280
        int bottom = getCompoundPaddingBottom();
1281
        int viewht = getHeight() - top - bottom;
1282
        int layoutht = .getLineTop();
1284
        if (layoutht >= viewht) {
1285
            return top;
1286
        }
1288
        final int gravity =  & .;
1289
        if (gravity == .) {
1290
            return top;
1291
        } else if (gravity == .) {
1292
            return top + viewht - layoutht;
1293
        } else { // (gravity == Gravity.CENTER_VERTICAL)
1294
            return top + (viewht - layoutht) / 2;
1295
        }
1296
    }

    
Returns the extended bottom padding of the view, including both the bottom Drawable if any and any extra space to keep more than maxLines of text from showing. It is only valid to call this after measuring. 
1303
    public int getExtendedPaddingBottom() {
1304
        if ( != ) {
1305
            return getCompoundPaddingBottom();
1306
        }
1308
        if (.getLineCount() <= ) {
1309
            return getCompoundPaddingBottom();
1310
        }
1312
        int top = getCompoundPaddingTop();
1313
        int bottom = getCompoundPaddingBottom();
1314
        int viewht = getHeight() - top - bottom;
1315
        int layoutht = .getLineTop();
1317
        if (layoutht >= viewht) {
1318
            return bottom;
1319
        }
1321
        final int gravity =  & .;
1322
        if (gravity == .) {
1323
            return bottom + viewht - layoutht;
1324
        } else if (gravity == .) {
1325
            return bottom;
1326
        } else { // (gravity == Gravity.CENTER_VERTICAL)
1327
            return bottom + (viewht - layoutht) / 2;
1328
        }
1329
    }

    
Returns the total left padding of the view, including the left Drawable if any. 
1335
    public int getTotalPaddingLeft() {
1336
        return getCompoundPaddingLeft();
1337
    }

    
Returns the total right padding of the view, including the right Drawable if any. 
1343
    public int getTotalPaddingRight() {
1344
        return getCompoundPaddingRight();
1345
    }

    
Returns the total top padding of the view, including the top Drawable if any, the extra space to keep more than maxLines from showing, and the vertical offset for gravity, if any. 
1352
    public int getTotalPaddingTop() {
1353
        return getExtendedPaddingTop() + getVerticalOffset(true);
1354
    }

    
Returns the total bottom padding of the view, including the bottom Drawable if any, the extra space to keep more than maxLines from showing, and the vertical offset for gravity, if any. 
1361
    public int getTotalPaddingBottom() {
1362
        return getExtendedPaddingBottom() + getBottomVerticalOffset(true);
1363
    }

    
Sets the Drawables (if any) to appear to the left of, above, to the right of, and below the text. Use null if you do not want a Drawable there. The Drawables must already have had android.graphics.drawable.Drawable.setBounds(android.graphics.Rect) called.

Attr:
ref android.R.styleable#TextView_drawableLeft
Attr:
ref android.R.styleable#TextView_drawableTop
Attr:
ref android.R.styleable#TextView_drawableRight
Attr:
ref android.R.styleable#TextView_drawableBottom
1376
    public void setCompoundDrawables(Drawable left, Drawable top,
1377
                                     Drawable right, Drawable bottom) {
1378
        Drawables dr = ;
1380
        final boolean drawables = left != null || top != null
1381
                || right != null || bottom != null;
1383
        if (!drawables) {
1384
            // Clearing drawables...  can we free the data structure?
1385
            if (dr != null) {
1386
                if (dr.mDrawablePadding == 0) {
1387
                     = null;
1388
                } else {
1389
                    // We need to retain the last set padding, so just clear
1390
                    // out all of the fields in the existing structure.
1391
                    if (dr.mDrawableLeft != null) dr.mDrawableLeft.setCallback(null);
1392
                    dr.mDrawableLeft = null;
1393
                    if (dr.mDrawableTop != null) dr.mDrawableTop.setCallback(null);
1394
                    dr.mDrawableTop = null;
1395
                    if (dr.mDrawableRight != null) dr.mDrawableRight.setCallback(null);
1396
                    dr.mDrawableRight = null;
1397
                    if (dr.mDrawableBottom != null) dr.mDrawableBottom.setCallback(null);
1398
                    dr.mDrawableBottom = null;
1399
                    dr.mDrawableSizeLeft = dr.mDrawableHeightLeft = 0;
1400
                    dr.mDrawableSizeRight = dr.mDrawableHeightRight = 0;
1401
                    dr.mDrawableSizeTop = dr.mDrawableWidthTop = 0;
1402
                    dr.mDrawableSizeBottom = dr.mDrawableWidthBottom = 0;
1403
                }
1404
            }
1405
        } else {
1406
            if (dr == null) {
1407
                 = dr = new Drawables();
1408
            }
1410
            if (dr.mDrawableLeft != left && dr.mDrawableLeft != null) {
1411
                dr.mDrawableLeft.setCallback(null);
1412
            }
1413
            dr.mDrawableLeft = left;
1415
            if (dr.mDrawableTop != top && dr.mDrawableTop != null) {
1416
                dr.mDrawableTop.setCallback(null);
1417
            }
1418
            dr.mDrawableTop = top;
1420
            if (dr.mDrawableRight != right && dr.mDrawableRight != null) {
1421
                dr.mDrawableRight.setCallback(null);
1422
            }
1423
            dr.mDrawableRight = right;
1425
            if (dr.mDrawableBottom != bottom && dr.mDrawableBottom != null) {
1426
                dr.mDrawableBottom.setCallback(null);
1427
            }
1428
            dr.mDrawableBottom = bottom;
1430
            final Rect compoundRect = dr.mCompoundRect;
1431
            int[] state;
1433
            state = getDrawableState();
1435
            if (left != null) {
1436
                left.setState(state);
1437
                left.copyBounds(compoundRect);
1438
                left.setCallback(this);
1439
                dr.mDrawableSizeLeft = compoundRect.width();
1440
                dr.mDrawableHeightLeft = compoundRect.height();
1441
            } else {
1442
                dr.mDrawableSizeLeft = dr.mDrawableHeightLeft = 0;
1443
            }
1445
            if (right != null) {
1446
                right.setState(state);
1447
                right.copyBounds(compoundRect);
1448
                right.setCallback(this);
1449
                dr.mDrawableSizeRight = compoundRect.width();
1450
                dr.mDrawableHeightRight = compoundRect.height();
1451
            } else {
1452
                dr.mDrawableSizeRight = dr.mDrawableHeightRight = 0;
1453
            }
1455
            if (top != null) {
1456
                top.setState(state);
1457
                top.copyBounds(compoundRect);
1458
                top.setCallback(this);
1459
                dr.mDrawableSizeTop = compoundRect.height();
1460
                dr.mDrawableWidthTop = compoundRect.width();
1461
            } else {
1462
                dr.mDrawableSizeTop = dr.mDrawableWidthTop = 0;
1463
            }
1465
            if (bottom != null) {
1466
                bottom.setState(state);
1467
                bottom.copyBounds(compoundRect);
1468
                bottom.setCallback(this);
1469
                dr.mDrawableSizeBottom = compoundRect.height();
1470
                dr.mDrawableWidthBottom = compoundRect.width();
1471
            } else {
1472
                dr.mDrawableSizeBottom = dr.mDrawableWidthBottom = 0;
1473
            }
1474
        }
1476
        invalidate();
1477
        requestLayout();
1478
    }

    
Sets the Drawables (if any) to appear to the left of, above, to the right of, and below the text. Use 0 if you do not want a Drawable there. The Drawables' bounds will be set to their intrinsic bounds.

Parameters:
left Resource identifier of the left Drawable.
top Resource identifier of the top Drawable.
right Resource identifier of the right Drawable.
bottom Resource identifier of the bottom Drawable.
Attr:
ref android.R.styleable#TextView_drawableLeft
Attr:
ref android.R.styleable#TextView_drawableTop
Attr:
ref android.R.styleable#TextView_drawableRight
Attr:
ref android.R.styleable#TextView_drawableBottom
1496
    public void setCompoundDrawablesWithIntrinsicBounds(int left, int top, int right, int bottom) {
1497
        final Resources resources = getContext().getResources();
1498
        setCompoundDrawablesWithIntrinsicBounds(left != 0 ? resources.getDrawable(left) : null,
1499
                top != 0 ? resources.getDrawable(top) : null,
1500
                right != 0 ? resources.getDrawable(right) : null,
1501
                bottom != 0 ? resources.getDrawable(bottom) : null);
1502
    }

    
Sets the Drawables (if any) to appear to the left of, above, to the right of, and below the text. Use null if you do not want a Drawable there. The Drawables' bounds will be set to their intrinsic bounds.

Attr:
ref android.R.styleable#TextView_drawableLeft
Attr:
ref android.R.styleable#TextView_drawableTop
Attr:
ref android.R.styleable#TextView_drawableRight
Attr:
ref android.R.styleable#TextView_drawableBottom
1516
            Drawable right, Drawable bottom) {
1518
        if (left != null) {
1519
            left.setBounds(0, 0, left.getIntrinsicWidth(), left.getIntrinsicHeight());
1520
        }
1521
        if (right != null) {
1522
            right.setBounds(0, 0, right.getIntrinsicWidth(), right.getIntrinsicHeight());
1523
        }
1524
        if (top != null) {
1525
            top.setBounds(0, 0, top.getIntrinsicWidth(), top.getIntrinsicHeight());
1526
        }
1527
        if (bottom != null) {
1528
            bottom.setBounds(0, 0, bottom.getIntrinsicWidth(), bottom.getIntrinsicHeight());
1529
        }
1530
        setCompoundDrawables(left, top, right, bottom);
1531
    }

    
Returns drawables for the left, top, right, and bottom borders. 
1536
    public Drawable[] getCompoundDrawables() {
1537
        final Drawables dr = ;
1538
        if (dr != null) {
1539
            return new Drawable[] {
1540
                dr.mDrawableLeft, dr.mDrawableTop, dr.mDrawableRight, dr.mDrawableBottom
1541
            };
1542
        } else {
1543
            return new Drawable[] { null, null, null, null };
1544
        }
1545
    }

    
Sets the size of the padding between the compound drawables and the text.

Attr:
ref android.R.styleable#TextView_drawablePadding
1553
    public void setCompoundDrawablePadding(int pad) {
1554
        Drawables dr = ;
1555
        if (pad == 0) {
1556
            if (dr != null) {
1557
                dr.mDrawablePadding = pad;
1558
            }
1559
        } else {
1560
            if (dr == null) {
1561
                 = dr = new Drawables();
1562
            }
1563
            dr.mDrawablePadding = pad;
1564
        }
1566
        invalidate();
1567
        requestLayout();
1568
    }

    
Returns the padding between the compound drawables and the text. 
1573
    public int getCompoundDrawablePadding() {
1574
        final Drawables dr = ;
1575
        return dr != null ? dr.mDrawablePadding : 0;
1576
    }
1578
    @Override
1579
    public void setPadding(int left, int top, int right, int bottom) {
1580
        if (left !=  ||
1581
            right !=  ||
1582
            top !=  ||
1583
            bottom != ) {
1584
            nullLayouts();
1585
        }
1587
        // the super call will requestLayout()
1588
        super.setPadding(left, top, right, bottom);
1589
        invalidate();
1590
    }

    
Gets the autolink mask of the text. See android.text.util.Linkify.ALL and peers for possible values.

Attr:
ref android.R.styleable#TextView_autoLink
1599
    public final int getAutoLinkMask() {
1600
        return ;
1601
    }

    
Sets the text color, size, style, hint color, and highlight color from the specified TextAppearance resource. 
1607
    public void setTextAppearance(Context context, int resid) {
1608
        TypedArray appearance =
1609
            context.obtainStyledAttributes(resid,
1610
                                           .....);
1612
        int color;
1613
        ColorStateList colors;
1614
        int ts;
1616
        color = appearance.getColor(....., 0);
1617
        if (color != 0) {
1618
            setHighlightColor(color);
1619
        }
1621
        colors = appearance.getColorStateList(.....
1622
                                              );
1623
        if (colors != null) {
1624
            setTextColor(colors);
1625
        }
1627
        ts = appearance.getDimensionPixelSize(.....
1628
                                              , 0);
1629
        if (ts != 0) {
1630
            setRawTextSize(ts);
1631
        }
1633
        colors = appearance.getColorStateList(.....
1634
                                              );
1635
        if (colors != null) {
1636
            setHintTextColor(colors);
1637
        }
1639
        colors = appearance.getColorStateList(.....
1640
                                              );
1641
        if (colors != null) {
1642
            setLinkTextColor(colors);
1643
        }
1645
        int typefaceIndex, styleIndex;
1647
        typefaceIndex = appearance.getInt(.....
1648
                                          , -1);
1649
        styleIndex = appearance.getInt(.....
1650
                                       , -1);
1652
        setTypefaceByIndex(typefaceIndex, styleIndex);
1653
        appearance.recycle();
1654
    }

    

Returns:
the size (in pixels) of the default text size in this TextView.
1659
    public float getTextSize() {
1660
        return .getTextSize();
1661
    }

    
Set the default text size to the given value, interpreted as "scaled pixel" units. This size is adjusted based on the current density and user font size preference.

Parameters:
size The scaled pixel size.
Attr:
ref android.R.styleable#TextView_textSize
1673
    public void setTextSize(float size) {
1674
        setTextSize(., size);
1675
    }

    
Set the default text size to a given unit and value. See android.util.TypedValue for the possible dimension units.

Parameters:
unit The desired dimension unit.
size The desired size in the given units.
Attr:
ref android.R.styleable#TextView_textSize
1686
    public void setTextSize(int unit, float size) {
1687
        Context c = getContext();
1688
        Resources r;
1690
        if (c == null)
1691
            r = Resources.getSystem();
1692
        else
1693
            r = c.getResources();
1695
        setRawTextSize(TypedValue.applyDimension(
1696
            unit, size, r.getDisplayMetrics()));
1697
    }
1699
    private void setRawTextSize(float size) {
1700
        if (size != .getTextSize()) {
1701
            .setTextSize(size);
1703
            if ( != null) {
1704
                nullLayouts();
1705
                requestLayout();
1706
                invalidate();
1707
            }
1708
        }
1709
    }

    

Returns:
the extent by which text is currently being stretched horizontally. This will usually be 1.
1715
    public float getTextScaleX() {
1716
        return .getTextScaleX();
1717
    }

    
Sets the extent by which text should be stretched horizontally.

Attr:
ref android.R.styleable#TextView_textScaleX
1725
    public void setTextScaleX(float size) {
1726
        if (size != .getTextScaleX()) {
1727
             = true;
1728
            .setTextScaleX(size);
1730
            if ( != null) {
1731
                nullLayouts();
1732
                requestLayout();
1733
                invalidate();
1734
            }
1735
        }
1736
    }

    
Sets the typeface and style in which the text should be displayed. Note that not all Typeface families actually have bold and italic variants, so you may need to use setTypeface(android.graphics.Typeface,int) to get the appearance that you actually want.

Attr:
ref android.R.styleable#TextView_typeface
Attr:
ref android.R.styleable#TextView_textStyle
1748
    public void setTypeface(Typeface tf) {
1749
        if (.getTypeface() != tf) {
1750
            .setTypeface(tf);
1752
            if ( != null) {
1753
                nullLayouts();
1754
                requestLayout();
1755
                invalidate();
1756
            }
1757
        }
1758
    }

    

Returns:
the current typeface and style in which the text is being displayed.
1764
    public Typeface getTypeface() {
1765
        return .getTypeface();
1766
    }

    
Sets the text color for all the states (normal, selected, focused) to be this color.

Attr:
ref android.R.styleable#TextView_textColor
1775
    public void setTextColor(int color) {
1776
         = ColorStateList.valueOf(color);
1777
        updateTextColors();
1778
    }

    
Sets the text color.

Attr:
ref android.R.styleable#TextView_textColor
1785
    public void setTextColor(ColorStateList colors) {
1786
        if (colors == null) {
1787
            throw new NullPointerException();
1788
        }
1790
         = colors;
1791
        updateTextColors();
1792
    }

    
Return the set of text colors.

Returns:
Returns the set of text colors.
1799
    public final ColorStateList getTextColors() {
1800
        return ;
1801
    }

    

Return the current color selected for normal text.

Returns:
Returns the current text color.
1808
    public final int getCurrentTextColor() {
1809
        return ;
1810
    }

    
Sets the color used to display the selection highlight.

Attr:
ref android.R.styleable#TextView_textColorHighlight
1818
    public void setHighlightColor(int color) {
1819
        if ( != color) {
1820
             = color;
1821
            invalidate();
1822
        }
1823
    }

    
Gives the text a shadow of the specified radius and color, the specified distance from its normal position.

Attr:
ref android.R.styleable#TextView_shadowColor
Attr:
ref android.R.styleable#TextView_shadowDx
Attr:
ref android.R.styleable#TextView_shadowDy
Attr:
ref android.R.styleable#TextView_shadowRadius
1834
    public void setShadowLayer(float radius, float dx, float dy, int color) {
1835
        .setShadowLayer(radius, dx, dy, color);
1837
         = radius;
1838
         = dx;
1839
         = dy;
1841
        invalidate();
1842
    }

    

Returns:
the base paint used for the text. Please use this only to consult the Paint's properties and not to change them.
1848
    public TextPaint getPaint() {
1849
        return ;
1850
    }

    
Sets the autolink mask of the text. See android.text.util.Linkify.ALL and peers for possible values.

Attr:
ref android.R.styleable#TextView_autoLink
1860
    public final void setAutoLinkMask(int mask) {
1861
         = mask;
1862
    }

    
Sets whether the movement method will automatically be set to android.text.method.LinkMovementMethod if setAutoLinkMask(int) has been set to nonzero and links are detected in setText(java.lang.CharSequence). The default is true.

Attr:
ref android.R.styleable#TextView_linksClickable
1873
    public final void setLinksClickable(boolean whether) {
1874
         = whether;
1875
    }

    
Returns whether the movement method will automatically be set to android.text.method.LinkMovementMethod if setAutoLinkMask(int) has been set to nonzero and links are detected in setText(java.lang.CharSequence). The default is true.

Attr:
ref android.R.styleable#TextView_linksClickable
1885
    public final boolean getLinksClickable() {
1886
        return ;
1887
    }

    
Returns the list of URLSpans attached to the text (by android.text.util.Linkify or otherwise) if any. You can call android.text.style.URLSpan.getURL() on them to find where they link to or use android.text.Spanned.getSpanStart(java.lang.Object) and android.text.Spanned.getSpanEnd(java.lang.Object) to find the region of the text they are attached to. 
1896
    public URLSpan[] getUrls() {
1897
        if ( instanceof Spanned) {
1898
            return ((Spanned) ).getSpans(0, .length(), URLSpan.class);
1899
        } else {
1900
            return new URLSpan[0];
1901
        }
1902
    }

    
Sets the color of the hint text.

Attr:
ref android.R.styleable#TextView_textColorHint
1910
    public final void setHintTextColor(int color) {
1911
         = ColorStateList.valueOf(color);
1912
        updateTextColors();
1913
    }

    
Sets the color of the hint text.

Attr:
ref android.R.styleable#TextView_textColorHint
1920
    public final void setHintTextColor(ColorStateList colors) {
1921
         = colors;
1922
        updateTextColors();
1923
    }

    

Return the color used to paint the hint text.

Returns:
Returns the list of hint text colors.
1930
    public final ColorStateList getHintTextColors() {
1931
        return ;
1932
    }

    

Return the current color selected to paint the hint text.

Returns:
Returns the current hint text color.
1939
    public final int getCurrentHintTextColor() {
1940
        return  != null ?  : ;
1941
    }

    
Sets the color of links in the text.

Attr:
ref android.R.styleable#TextView_textColorLink
1949
    public final void setLinkTextColor(int color) {
1950
         = ColorStateList.valueOf(color);
1951
        updateTextColors();
1952
    }

    
Sets the color of links in the text.

Attr:
ref android.R.styleable#TextView_textColorLink
1959
    public final void setLinkTextColor(ColorStateList colors) {
1960
         = colors;
1961
        updateTextColors();
1962
    }

    

Returns the color used to paint links in the text.

Returns:
Returns the list of link text colors.
1969
    public final ColorStateList getLinkTextColors() {
1970
        return ;
1971
    }

    
Sets the horizontal alignment of the text and the vertical gravity that will be used when there is extra space in the TextView beyond what is required for the text itself.

See also:
android.view.Gravity
Attr:
ref android.R.styleable#TextView_gravity
1981
    public void setGravity(int gravity) {
1982
        if ((gravity & .) == 0) {
1983
            gravity |= .;
1984
        }
1985
        if ((gravity & .) == 0) {
1986
            gravity |= .;
1987
        }
1989
        boolean newLayout = false;
1991
        if ((gravity & .) !=
1992
            ( & .)) {
1993
            newLayout = true;
1994
        }
1996
        if (gravity != ) {
1997
            invalidate();
1998
        }
2000
         = gravity;
2002
        if ( != null && newLayout) {
2003
            // XXX this is heavy-handed because no actual content changes.
2004
            int want = .getWidth();
2005
            int hintWant =  == null ? 0 : .getWidth();
2007
            makeNewLayout(want, hintWant, , ,
2008
                           -  - getCompoundPaddingLeft() -
2009
                          getCompoundPaddingRight(), true);
2010
        }
2011
    }

    
Returns the horizontal and vertical alignment of this TextView.

See also:
android.view.Gravity
Attr:
ref android.R.styleable#TextView_gravity
2019
    public int getGravity() {
2020
        return ;
2021
    }

    

Returns:
the flags on the Paint being used to display the text.
See also:
android.graphics.Paint.getFlags()
2027
    public int getPaintFlags() {
2028
        return .getFlags();
2029
    }

    
Sets flags on the Paint being used to display the text and reflows the text if they are different from the old flags.

See also:
android.graphics.Paint.setFlags(int)
2037
    public void setPaintFlags(int flags) {
2038
        if (.getFlags() != flags) {
2039
            .setFlags(flags);
2041
            if ( != null) {
2042
                nullLayouts();
2043
                requestLayout();
2044
                invalidate();
2045
            }
2046
        }
2047
    }

    
Sets whether the text should be allowed to be wider than the View is. If false, it will be wrapped to the width of the View.

Attr:
ref android.R.styleable#TextView_scrollHorizontally
2055
    public void setHorizontallyScrolling(boolean whether) {
2056
         = whether;
2058
        if ( != null) {
2059
            nullLayouts();
2060
            requestLayout();
2061
            invalidate();
2062
        }
2063
    }

    
Makes the TextView at least this many lines tall

Attr:
ref android.R.styleable#TextView_minLines
2071
    public void setMinLines(int minlines) {
2072
         = minlines;
2073
         = ;
2075
        requestLayout();
2076
        invalidate();
2077
    }

    
Makes the TextView at least this many pixels tall

Attr:
ref android.R.styleable#TextView_minHeight
2085
    public void setMinHeight(int minHeight) {
2086
         = minHeight;
2087
         = ;
2089
        requestLayout();
2090
        invalidate();
2091
    }

    
Makes the TextView at most this many lines tall

Attr:
ref android.R.styleable#TextView_maxLines
2099
    public void setMaxLines(int maxlines) {
2100
         = maxlines;
2101
         = ;
2103
        requestLayout();
2104
        invalidate();
2105
    }

    
Makes the TextView at most this many pixels tall

Attr:
ref android.R.styleable#TextView_maxHeight
2113
    public void setMaxHeight(int maxHeight) {
2114
         = maxHeight;
2115
         = ;
2117
        requestLayout();
2118
        invalidate();
2119
    }

    
Makes the TextView exactly this many lines tall

Attr:
ref android.R.styleable#TextView_lines
2127
    public void setLines(int lines) {
2128
         =  = lines;
2129
         =  = ;
2131
        requestLayout();
2132
        invalidate();
2133
    }

    
Makes the TextView exactly this many pixels tall. You could do the same thing by specifying this number in the LayoutParams.

Attr:
ref android.R.styleable#TextView_height
2143
    public void setHeight(int pixels) {
2144
         =  = pixels;
2145
         =  = ;
2147
        requestLayout();
2148
        invalidate();
2149
    }

    
Makes the TextView at least this many ems wide

Attr:
ref android.R.styleable#TextView_minEms
2157
    public void setMinEms(int minems) {
2158
         = minems;
2159
         = ;
2161
        requestLayout();
2162
        invalidate();
2163
    }

    
Makes the TextView at least this many pixels wide

Attr:
ref android.R.styleable#TextView_minWidth
2171
    public void setMinWidth(int minpixels) {
2172
         = minpixels;
2173
         = ;
2175
        requestLayout();
2176
        invalidate();
2177
    }

    
Makes the TextView at most this many ems wide

Attr:
ref android.R.styleable#TextView_maxEms
2185
    public void setMaxEms(int maxems) {
2186
         = maxems;
2187
         = ;
2189
        requestLayout();
2190
        invalidate();
2191
    }

    
Makes the TextView at most this many pixels wide

Attr:
ref android.R.styleable#TextView_maxWidth
2199
    public void setMaxWidth(int maxpixels) {
2200
         = maxpixels;
2201
         = ;
2203
        requestLayout();
2204
        invalidate();
2205
    }

    
Makes the TextView exactly this many ems wide

Attr:
ref android.R.styleable#TextView_ems
2213
    public void setEms(int ems) {
2214
         =  = ems;
2215
         =  = ;
2217
        requestLayout();
2218
        invalidate();
2219
    }

    
Makes the TextView exactly this many pixels wide. You could do the same thing by specifying this number in the LayoutParams.

Attr:
ref android.R.styleable#TextView_width
2229
    public void setWidth(int pixels) {
2230
         =  = pixels;
2231
         =  = ;
2233
        requestLayout();
2234
        invalidate();
2235
    }


    
Sets line spacing for this TextView. Each line will have its height multiplied by mult and have add added to it.

Attr:
ref android.R.styleable#TextView_lineSpacingExtra
Attr:
ref android.R.styleable#TextView_lineSpacingMultiplier
2245
    public void setLineSpacing(float add, float mult) {
2246
         = mult;
2247
         = add;
2249
        if ( != null) {
2250
            nullLayouts();
2251
            requestLayout();
2252
            invalidate();
2253
        }
2254
    }

    
Convenience method: Append the specified text to the TextView's display buffer, upgrading it to BufferType.EDITABLE if it was not already editable. 
2261
    public final void append(CharSequence text) {
2262
        append(text, 0, text.length());
2263
    }

    
Convenience method: Append the specified text slice to the TextView's display buffer, upgrading it to BufferType.EDITABLE if it was not already editable. 
2270
    public void append(CharSequence text, int start, int end) {
2271
        if (!( instanceof Editable)) {
2272
            setText(, .);
2273
        }
2275
        ((Editable) ).append(text, start, end);
2276
    }
2278
    private void updateTextColors() {
2279
        boolean inval = false;
2280
        int color = .getColorForState(getDrawableState(), 0);
2281
        if (color != ) {
2282
             = color;
2283
            inval = true;
2284
        }
2285
        if ( != null) {
2286
            color = .getColorForState(getDrawableState(), 0);
2287
            if (color != .) {
2288
                . = color;
2289
                inval = true;
2290
            }
2291
        }
2292
        if ( != null) {
2293
            color = .getColorForState(getDrawableState(), 0);
2294
            if (color !=  && .length() == 0) {
2295
                 = color;
2296
                inval = true;
2297
            }
2298
        }
2299
        if (inval) {
2300
            invalidate();
2301
        }
2302
    }
2304
    @Override
2305
    protected void drawableStateChanged() {
2306
        super.drawableStateChanged();
2307
        if ( != null && .isStateful()
2308
                || ( != null && .isStateful())
2309
                || ( != null && .isStateful())) {
2310
            updateTextColors();
2311
        }
2313
        final Drawables dr = ;
2314
        if (dr != null) {
2315
            int[] state = getDrawableState();
2316
            if (dr.mDrawableTop != null && dr.mDrawableTop.isStateful()) {
2317
                dr.mDrawableTop.setState(state);
2318
            }
2319
            if (dr.mDrawableBottom != null && dr.mDrawableBottom.isStateful()) {
2320
                dr.mDrawableBottom.setState(state);
2321
            }
2322
            if (dr.mDrawableLeft != null && dr.mDrawableLeft.isStateful()) {
2323
                dr.mDrawableLeft.setState(state);
2324
            }
2325
            if (dr.mDrawableRight != null && dr.mDrawableRight.isStateful()) {
2326
                dr.mDrawableRight.setState(state);
2327
            }
2328
        }
2329
    }

    
User interface state that is stored by TextView for implementing android.view.View.onSaveInstanceState(). 
2335
    public static class SavedState extends BaseSavedState {
2336
        int selStart;
2337
        int selEnd;
2338
        CharSequence text;
2339
        boolean frozenWithFocus;
2340
        CharSequence error;
2342
        SavedState(Parcelable superState) {
2343
            super(superState);
2344
        }
2346
        @Override
2347
        public void writeToParcel(Parcel out, int flags) {
2348
            super.writeToParcel(out, flags);
2349
            out.writeInt();
2350
            out.writeInt();
2351
            out.writeInt( ? 1 : 0);
2352
            TextUtils.writeToParcel(, out, flags);
2354
            if ( == null) {
2355
                out.writeInt(0);
2356
            } else {
2357
                out.writeInt(1);
2358
                TextUtils.writeToParcel(, out, flags);
2359
            }
2360
        }
2362
        @Override
2363
        public String toString() {
2364
            String str = "TextView.SavedState{"
2365
                    + Integer.toHexString(System.identityHashCode(this))
2366
                    + " start=" +  + " end=" + ;
2367
            if ( != null) {
2368
                str += " text=" + ;
2369
            }
2370
            return str + "}";
2371
        }
2373
        @SuppressWarnings("hiding")
2374
        public static final Parcelable.Creator<SavedState> CREATOR
2375
                = new Parcelable.Creator<SavedState>() {
2376
            public SavedState createFromParcel(Parcel in) {
2377
                return new SavedState(in);
2378
            }
2380
            public SavedState[] newArray(int size) {
2381
                return new SavedState[size];
2382
            }
2383
        };
2385
        private SavedState(Parcel in) {
2386
            super(in);
2387
             = in.readInt();
2388
             = in.readInt();
2389
             = (in.readInt() != 0);
2390
             = ..createFromParcel(in);
2392
            if (in.readInt() != 0) {
2393
                 = ..createFromParcel(in);
2394
            }
2395
        }
2396
    }
2398
    @Override
2399
    public Parcelable onSaveInstanceState() {
2400
        Parcelable superState = super.onSaveInstanceState();
2402
        // Save state if we are forced to
2403
        boolean save = ;
2404
        int start = 0;
2405
        int end = 0;
2407
        if ( != null) {
2408
            start = getSelectionStart();
2409
            end = getSelectionEnd();
2410
            if (start >= 0 || end >= 0) {
2411
                // Or save state if there is a selection
2412
                save = true;
2413
            }
2414
        }
2416
        if (save) {
2417
            SavedState ss = new SavedState(superState);
2418
            // XXX Should also save the current scroll position!
2419
            ss.selStart = start;
2420
            ss.selEnd = end;
2422
            if ( instanceof Spanned) {
2423
                /*
2424
                 * Calling setText() strips off any ChangeWatchers;
2425
                 * strip them now to avoid leaking references.
2426
                 * But do it to a copy so that if there are any
2427
                 * further changes to the text of this view, it
2428
                 * won't get into an inconsistent state.
2429
                 */
2431
                Spannable sp = new SpannableString();
2433
                for (ChangeWatcher cw :
2434
                     sp.getSpans(0, sp.length(), ChangeWatcher.class)) {
2435
                    sp.removeSpan(cw);
2436
                }
2438
                ss.text = sp;
2439
            } else {
2440
                ss.text = .toString();
2441
            }
2443
            if (isFocused() && start >= 0 && end >= 0) {
2444
                ss.frozenWithFocus = true;
2445
            }
2447
            ss.error = ;
2449
            return ss;
2450
        }
2452
        return superState;
2453
    }
2455
    @Override
2456
    public void onRestoreInstanceState(Parcelable state) {
2457
        if (!(state instanceof SavedState)) {
2458
            super.onRestoreInstanceState(state);
2459
            return;
2460
        }
2462
        SavedState ss = (SavedState)state;
2463
        super.onRestoreInstanceState(ss.getSuperState());
2465
        // XXX restore buffer type too, as well as lots of other stuff
2466
        if (ss.text != null) {
2467
            setText(ss.text);
2468
        }
2470
        if (ss.selStart >= 0 && ss.selEnd >= 0) {
2471
            if ( instanceof Spannable) {
2472
                int len = .length();
2474
                if (ss.selStart > len || ss.selEnd > len) {
2475
                    String restored = "";
2477
                    if (ss.text != null) {
2478
                        restored = "(restored) ";
2479
                    }
2481
                    Log.e(, "Saved cursor position " + ss.selStart +
2482
                          "/" + ss.selEnd + " out of range for " + restored +
2483
                          "text " + );
2484
                } else {
2485
                    Selection.setSelection((Spannable) , ss.selStart,
2486
                                           ss.selEnd);
2488
                    if (ss.frozenWithFocus) {
2489
                         = true;
2490
                    }
2491
                }
2492
            }
2493
        }
2495
        if (ss.error != null) {
2496
            final CharSequence error = ss.error;
2497
            // Display the error later, after the first layout pass
2498
            post(new Runnable() {
2499
                public void run() {
2500
                    setError(error);
2501
                }
2502
            });
2503
        }
2504
    }

    
Control whether this text view saves its entire text contents when freezing to an icicle, in addition to dynamic state such as cursor position. By default this is false, not saving the text. Set to true if the text in the text view is not being saved somewhere else in persistent storage (such as in a content provider) so that if the view is later thawed the user will not lose their data.

Parameters:
freezesText Controls whether a frozen icicle should include the entire text data: true to include it, false to not.
Attr:
ref android.R.styleable#TextView_freezesText
2520
    public void setFreezesText(boolean freezesText) {
2521
         = freezesText;
2522
    }

    
Return whether this text view is including its entire text contents in frozen icicles.

Returns:
Returns true if text is included, false if it isn't.
See also:
setFreezesText(boolean)
2532
    public boolean getFreezesText() {
2533
        return ;
2534
    }
2536
    ///////////////////////////////////////////////////////////////////////////
2537

    
Sets the Factory used to create new Editables. 
2541
    public final void setEditableFactory(Editable.Factory factory) {
2542
         = factory;
2543
        setText();
2544
    }

    
Sets the Factory used to create new Spannables. 
2549
    public final void setSpannableFactory(Spannable.Factory factory) {
2550
         = factory;
2551
        setText();
2552
    }

    
Sets the string value of the TextView. TextView does not accept HTML-like formatting, which you can do with text strings in XML resource files. To style your strings, attach android.text.style.* objects to a SpannableString, or see the Available Resource Types documentation for an example of setting formatted text in the XML resource file.

Attr:
ref android.R.styleable#TextView_text
2566
    public final void setText(CharSequence text) {
2567
        setText(text, );
2568
    }

    
Like setText(java.lang.CharSequence), except that the cursor position (if any) is retained in the new text.

Parameters:
text The new text to place in the text view.
See also:
setText(java.lang.CharSequence)
2579
    public final void setTextKeepState(CharSequence text) {
2580
        setTextKeepState(text, );
2581
    }

    
Sets the text that this TextView is to display (see setText(java.lang.CharSequence)) and also sets whether it is stored in a styleable/spannable buffer and whether it is editable.

Attr:
ref android.R.styleable#TextView_text
Attr:
ref android.R.styleable#TextView_bufferType
2591
    public void setText(CharSequence text, BufferType type) {
2592
        setText(text, type, true, 0);
2594
        if ( != null) {
2595
            . = null;
2596
        }
2597
    }
2599
    private void setText(CharSequence text, BufferType type,
2600
                         boolean notifyBefore, int oldlen) {
2601
        if (text == null) {
2602
            text = "";
2603
        }
2605
        if (!) .setTextScaleX(1.0f);
2607
        if (text instanceof Spanned &&
2608
            ((Spanned) text).getSpanStart(..) >= 0) {
2609
            setHorizontalFadingEdgeEnabled(true);
2610
            setEllipsize(..);
2611
        }
2613
        int n = .;
2614
        for (int i = 0; i < n; i++) {
2615
            CharSequence out = [i].filter(text, 0, text.length(),
2616
                                                  , 0, 0);
2617
            if (out != null) {
2618
                text = out;
2619
            }
2620
        }
2622
        if (notifyBefore) {
2623
            if ( != null) {
2624
                oldlen = .length();
2625
                sendBeforeTextChanged(, 0, oldlen, text.length());
2626
            } else {
2627
                sendBeforeTextChanged("", 0, 0, text.length());
2628
            }
2629
        }
2631
        boolean needEditableForNotification = false;
2633
        if ( != null && .size() != 0) {
2634
            needEditableForNotification = true;
2635
        }
2637
        if (type == . ||  != null ||
2638
            needEditableForNotification) {
2639
            Editable t = .newEditable(text);
2640
            text = t;
2641
            setFilters(t, );
2642
            InputMethodManager imm = InputMethodManager.peekInstance();
2643
            if (imm != null) imm.restartInput(this);
2644
        } else if (type == . ||  != null) {
2645
            text = .newSpannable(text);
2646
        } else if (!(text instanceof CharWrapper)) {
2647
            text = TextUtils.stringOrSpannedString(text);
2648
        }
2650
        if ( != 0) {
2651
            Spannable s2;
2653
            if (type == . || text instanceof Spannable) {
2654
                s2 = (Spannable) text;
2655
            } else {
2656
                s2 = .newSpannable(text);
2657
            }
2659
            if (Linkify.addLinks(s2, )) {
2660
                text = s2;
2661
                type = (type == .) ? . : .;
2663
                /*
2664
                 * We must go ahead and set the text before changing the
2665
                 * movement method, because setMovementMethod() may call
2666
                 * setText() again to try to upgrade the buffer type.
2667
                 */
2668
                 = text;
2670
                if () {
2671
                    setMovementMethod(LinkMovementMethod.getInstance());
2672
                }
2673
            }
2674
        }
2676
         = type;
2677
         = text;
2679
        if ( == null)
2680
             = text;
2681
        else
2682
             = .getTransformation(text, this);
2684
        final int textLength = text.length();
2686
        if (text instanceof Spannable) {
2687
            Spannable sp = (Spannable) text;
2689
            // Remove any ChangeWatchers that might have come
2690
            // from other TextViews.
2691
            final ChangeWatcher[] watchers = sp.getSpans(0, sp.length(), ChangeWatcher.class);
2692
            final int count = watchers.length;
2693
            for (int i = 0; i < count; i++)
2694
                sp.removeSpan(watchers[i]);
2696
            if ( == null)
2697
                 = new ChangeWatcher();
2699
            sp.setSpan(, 0, textLength, . |
2700
                       ( << .));
2702
            if ( != null) {
2703
                sp.setSpan(, 0, textLength, .);
2704
            }
2706
            if ( != null) {
2707
                sp.setSpan(, 0, textLength, .);
2709
            }
2711
            if ( != null) {
2712
                .initialize(this, (Spannable) text);
2714
                /*
2715
                 * Initializing the movement method will have set the
2716
                 * selection, so reset mSelectionMoved to keep that from
2717
                 * interfering with the normal on-focus selection-setting.
2718
                 */
2719
                 = false;
2720
            }
2721
        }
2723
        if ( != null) {
2724
            checkForRelayout();
2725
        }
2727
        sendOnTextChanged(text, 0, oldlen, textLength);
2728
        onTextChanged(text, 0, oldlen, textLength);
2730
        if (needEditableForNotification) {
2731
            sendAfterTextChanged((Editable) text);
2732
        }
2734
        // SelectionModifierCursorController depends on textCanBeSelected, which depends on text
2735
        prepareCursorControllers();
2736
    }

    
Sets the TextView to display the specified slice of the specified char array. You must promise that you will not change the contents of the array except for right before another call to setText(), since the TextView has no way to know that the text has changed and that it needs to invalidate and re-layout. 
2745
    public final void setText(char[] text, int start, int len) {
2746
        int oldlen = 0;
2748
        if (start < 0 || len < 0 || start + len > text.length) {
2749
            throw new IndexOutOfBoundsException(start + ", " + len);
2750
        }
2752
        /*
2753
         * We must do the before-notification here ourselves because if
2754
         * the old text is a CharWrapper we destroy it before calling
2755
         * into the normal path.
2756
         */
2757
        if ( != null) {
2758
            oldlen = .length();
2759
            sendBeforeTextChanged(, 0, oldlen, len);
2760
        } else {
2761
            sendBeforeTextChanged("", 0, 0, len);
2762
        }
2764
        if ( == null) {
2765
             = new CharWrapper(text, start, len);
2766
        } else {
2767
            .set(text, start, len);
2768
        }
2770
        setText(, , false, oldlen);
2771
    }
2773
    private static class CharWrapper
2774
            implements CharSequence, GetChars, GraphicsOperations {
2775
        private char[] mChars;
2776
        private int mStart, mLength;
2778
        public CharWrapper(char[] chars, int start, int len) {
2779
             = chars;
2780
             = start;
2781
             = len;
2782
        }
2784
        /* package */ void set(char[] chars, int start, int len) {
2785
             = chars;
2786
             = start;
2787
             = len;
2788
        }
2790
        public int length() {
2791
            return ;
2792
        }
2794
        public char charAt(int off) {
2795
            return [off + ];
2796
        }
2798
        @Override
2799
        public String toString() {
2800
            return new String(, , );
2801
        }
2803
        public CharSequence subSequence(int start, int end) {
2804
            if (start < 0 || end < 0 || start >  || end > ) {
2805
                throw new IndexOutOfBoundsException(start + ", " + end);
2806
            }
2808
            return new String(, start + , end - start);
2809
        }
2811
        public void getChars(int start, int end, char[] buf, int off) {
2812
            if (start < 0 || end < 0 || start >  || end > ) {
2813
                throw new IndexOutOfBoundsException(start + ", " + end);
2814
            }
2816
            System.arraycopy(, start + , buf, off, end - start);
2817
        }
2819
        public void drawText(Canvas c, int start, int end,
2820
                             float x, float y, Paint p) {
2821
            c.drawText(, start + , end - start, x, y, p);
2822
        }
2824
        public float measureText(int start, int end, Paint p) {
2825
            return p.measureText(, start + , end - start);
2826
        }
2828
        public int getTextWidths(int start, int end, float[] widths, Paint p) {
2829
            return p.getTextWidths(, start + , end - start, widths);
2830
        }
2831
    }

    
Like setText(java.lang.CharSequence,android.widget.TextView.BufferType), except that the cursor position (if any) is retained in the new text.

See also:
setText(java.lang.CharSequence,android.widget.TextView.BufferType)
2839
    public final void setTextKeepState(CharSequence text, BufferType type) {
2840
        int start = getSelectionStart();
2841
        int end = getSelectionEnd();
2842
        int len = text.length();
2844
        setText(text, type);
2846
        if (start >= 0 || end >= 0) {
2847
            if ( instanceof Spannable) {
2848
                Selection.setSelection((Spannable) ,
2849
                                       Math.max(0, Math.min(start, len)),
2850
                                       Math.max(0, Math.min(end, len)));
2851
            }
2852
        }
2853
    }
2856
    public final void setText(int resid) {
2857
        setText(getContext().getResources().getText(resid));
2858
    }
2860
    public final void setText(int resid, BufferType type) {
2861
        setText(getContext().getResources().getText(resid), type);
2862
    }

    
Sets the text to be displayed when the text of the TextView is empty. Null means to use the normal empty text. The hint does not currently participate in determining the size of the view.

Attr:
ref android.R.styleable#TextView_hint
2872
    public final void setHint(CharSequence hint) {
2873
         = TextUtils.stringOrSpannedString(hint);
2875
        if ( != null) {
2876
            checkForRelayout();
2877
        }
2879
        if (.length() == 0) {
2880
            invalidate();
2881
        }
2882
    }

    
Sets the text to be displayed when the text of the TextView is empty, from a resource.

Attr:
ref android.R.styleable#TextView_hint
2891
    public final void setHint(int resid) {
2892
        setHint(getContext().getResources().getText(resid));
2893
    }

    
Returns the hint that is displayed when the text of the TextView is empty.

Attr:
ref android.R.styleable#TextView_hint
2902
    public CharSequence getHint() {
2903
        return ;
2904
    }

    
Set the type of the content with a constant as defined for android.view.inputmethod.EditorInfo.inputType. This will take care of changing the key listener, by calling setKeyListener(android.text.method.KeyListener), to match the given content type. If the given content type is android.text.InputType.TYPE_NULL then a soft keyboard will not be displayed for this text view.

See also:
getInputType()
setRawInputType(int)
android.text.InputType
Attr:
ref android.R.styleable#TextView_inputType
2919
    public void setInputType(int type) {
2920
        final boolean wasPassword = isPasswordInputType();
2921
        final boolean wasVisiblePassword = isVisiblePasswordInputType();
2922
        setInputType(type, false);
2923
        final boolean isPassword = isPasswordInputType(type);
2924
        final boolean isVisiblePassword = isVisiblePasswordInputType(type);
2925
        boolean forceUpdate = false;
2926
        if (isPassword) {
2927
            setTransformationMethod(PasswordTransformationMethod.getInstance());
2928
            setTypefaceByIndex(, 0);
2929
        } else if (isVisiblePassword) {
2930
            if ( == PasswordTransformationMethod.getInstance()) {
2931
                forceUpdate = true;
2932
            }
2933
            setTypefaceByIndex(, 0);
2934
        } else if (wasPassword || wasVisiblePassword) {
2935
            // not in password mode, clean up typeface and transformation
2936
            setTypefaceByIndex(-1, -1);
2937
            if ( == PasswordTransformationMethod.getInstance()) {
2938
                forceUpdate = true;
2939
            }
2940
        }
2941
        
2942
        boolean multiLine = (type&(.
2943
                        | .)) ==
2944
                (.
2945
                        | .);
2946
        
2947
        // We need to update the single line mode if it has changed or we
2948
        // were previously in password mode.
2949
        if ( == multiLine || forceUpdate) {
2950
            // Change single line mode, but only change the transformation if
2951
            // we are not in password mode.
2952
            applySingleLine(!multiLine, !isPassword);
2953
        }
2954
        
2955
        InputMethodManager imm = InputMethodManager.peekInstance();
2956
        if (imm != null) imm.restartInput(this);
2957
    }

    
It would be better to rely on the input type for everything. A password inputType should have a password transformation. We should hence use isPasswordInputType instead of this method. We should: - Call setInputType in setKeyListener instead of changing the input type directly (which would install the correct transformation). - Refuse the installation of a non-password transformation in setTransformation if the input type is password. However, this is like this for legacy reasons and we cannot break existing apps. This method is useful since it matches what the user can see (obfuscated text or not).

Returns:
true if the current transformation method is of the password type.
2974
    private boolean hasPasswordTransformationMethod() {
2975
        return  instanceof PasswordTransformationMethod;
2976
    }
2978
    private boolean isPasswordInputType(int inputType) {
2979
        final int variation = inputType & (.
2980
                | .);
2981
        return variation
2982
                == (.
2983
                        | .);
2984
    }
2986
    private boolean isVisiblePasswordInputType(int inputType) {
2987
        final int variation = inputType & (.
2988
                | .);
2989
        return variation
2990
                == (.
2991
                        | .);
2992
    }

    
Directly change the content type integer of the text view, without modifying any other state.

See also:
setInputType(int)
android.text.InputType
Attr:
ref android.R.styleable#TextView_inputType
3001
    public void setRawInputType(int type) {
3002
         = type;
3003
    }
3005
    private void setInputType(int type, boolean direct) {
3006
        final int cls = type & .;
3007
        KeyListener input;
3008
        if (cls == .) {
3009
            boolean autotext = (type & .) != 0;
3010
            TextKeyListener.Capitalize cap;
3011
            if ((type & .) != 0) {
3012
                cap = ..;
3013
            } else if ((type & .) != 0) {
3014
                cap = ..;
3015
            } else if ((type & .) != 0) {
3016
                cap = ..;
3017
            } else {
3018
                cap = ..;
3019
            }
3020
            input = TextKeyListener.getInstance(autotext, cap);
3021
        } else if (cls == .) {
3022
            input = DigitsKeyListener.getInstance(
3023
                    (type & .) != 0,
3024
                    (type & .) != 0);
3025
        } else if (cls == .) {
3026
            switch (type & .) {
3027
                case .:
3028
                    input = DateKeyListener.getInstance();
3029
                    break;
3030
                case .:
3031
                    input = TimeKeyListener.getInstance();
3032
                    break;
3033
                default:
3034
                    input = DateTimeKeyListener.getInstance();
3035
                    break;
3036
            }
3037
        } else if (cls == .) {
3038
            input = DialerKeyListener.getInstance();
3039
        } else {
3040
            input = TextKeyListener.getInstance();
3041
        }
3042
        setRawInputType(type);
3043
        if (direct)  = input;
3044
        else {
3045
            setKeyListenerOnly(input);
3046
        }
3047
    }

    
Get the type of the content.

See also:
setInputType(int)
android.text.InputType
3055
    public int getInputType() {
3056
        return ;
3057
    }

    
Change the editor type integer associated with the text view, which will be reported to an IME with android.view.inputmethod.EditorInfo.imeOptions when it has focus.

See also:
getImeOptions()
android.view.inputmethod.EditorInfo
Attr:
ref android.R.styleable#TextView_imeOptions
3067
    public void setImeOptions(int imeOptions) {
3068
        if ( == null) {
3069
             = new InputContentType();
3070
        }
3071
        . = imeOptions;
3072
    }

    
Get the type of the IME editor.

See also:
setImeOptions(int)
android.view.inputmethod.EditorInfo
3080
    public int getImeOptions() {
3081
        return  != null
3082
                ? . : .;
3083
    }

    
Change the custom IME action associated with the text view, which will be reported to an IME with android.view.inputmethod.EditorInfo.actionLabel and android.view.inputmethod.EditorInfo.actionId when it has focus.

See also:
getImeActionLabel()
getImeActionId()
android.view.inputmethod.EditorInfo
Attr:
ref android.R.styleable#TextView_imeActionLabel
Attr:
ref android.R.styleable#TextView_imeActionId
3095
    public void setImeActionLabel(CharSequence label, int actionId) {
3096
        if ( == null) {
3097
             = new InputContentType();
3098
        }
3099
        . = label;
3100
        . = actionId;
3101
    }

    
Get the IME action label previous set with setImeActionLabel(java.lang.CharSequence,int).

See also:
setImeActionLabel(java.lang.CharSequence,int)
android.view.inputmethod.EditorInfo
3109
    public CharSequence getImeActionLabel() {
3110
        return  != null
3111
                ? . : null;
3112
    }

    
Get the IME action ID previous set with setImeActionLabel(java.lang.CharSequence,int).

See also:
setImeActionLabel(java.lang.CharSequence,int)
android.view.inputmethod.EditorInfo
3120
    public int getImeActionId() {
3121
        return  != null
3122
                ? . : 0;
3123
    }

    
Set a special listener to be called when an action is performed on the text view. This will be called when the enter key is pressed, or when an action supplied to the IME is selected by the user. Setting this means that the normal hard key event will not insert a newline into the text view, even if it is multi-line; holding down the ALT modifier will, however, allow the user to insert a newline character. 
3134
        if ( == null) {
3135
             = new InputContentType();
3136
        }
3138
    }
    
    
Called when an attached input method calls InputConnection.performEditorAction() for this text view. The default implementation will call your action listener supplied to setOnEditorActionListener(android.widget.TextView.OnEditorActionListener), or perform a standard operation for EditorInfo.IME_ACTION_NEXT or EditorInfo.IME_ACTION_DONE.

For backwards compatibility, if no IME options have been set and the text view would not normally advance focus on enter, then the NEXT and DONE actions received here will be turned into an enter key down/up pair to go through the normal key handling.

Parameters:
actionCode The code of the action being performed.
See also:
setOnEditorActionListener(android.widget.TextView.OnEditorActionListener)
3159
    public void onEditorAction(int actionCode) {
3160
        final InputContentType ict = ;
3161
        if (ict != null) {
3162
            if (ict.onEditorActionListener != null) {
3163
                if (ict.onEditorActionListener.onEditorAction(this,
3164
                        actionCode, null)) {
3165
                    return;
3166
                }
3167
            }
3168
            
3169
            // This is the handling for some default action.
3170
            // Note that for backwards compatibility we don't do this
3171
            // default handling if explicit ime options have not been given,
3172
            // instead turning this into the normal enter key codes that an
3173
            // app may be expecting.
3174
            if (actionCode == .) {
3175
                View v = focusSearch();
3176
                if (v != null) {
3177
                    if (!v.requestFocus()) {
3178
                        throw new IllegalStateException("focus search returned a view " +
3179
                                "that wasn't able to take focus!");
3180
                    }
3181
                }
3182
                return;
3183
                
3184
            } else if (actionCode == .) {
3185
                InputMethodManager imm = InputMethodManager.peekInstance();
3186
                if (imm != null) {
3187
                    imm.hideSoftInputFromWindow(getWindowToken(), 0);
3188
                }
3189
                return;
3190
            }
3191
        }
3192
        
3193
        Handler h = getHandler();
3194
        if (h != null) {
3195
            long eventTime = SystemClock.uptimeMillis();
3197
                    new KeyEvent(eventTime, eventTime,
3198
                    ., ., 0, 0, 0, 0,
3199
                    . | .
3200
                    | .)));
3202
                    new KeyEvent(SystemClock.uptimeMillis(), eventTime,
3203
                    ., ., 0, 0, 0, 0,
3204
                    . | .
3205
                    | .)));
3206
        }
3207
    }
    
    
Set the private content type of the text, which is the EditorInfo.privateImeOptions field that will be filled in when creating an input connection.

See also:
getPrivateImeOptions()
android.view.inputmethod.EditorInfo.privateImeOptions
Attr:
ref android.R.styleable#TextView_privateImeOptions
3218
    public void setPrivateImeOptions(String type) {
3219
        if ( == null)  = new InputContentType();
3220
        . = type;
3221
    }

    
Get the private type of the content.

See also:
setPrivateImeOptions(java.lang.String)
android.view.inputmethod.EditorInfo.privateImeOptions
3229
    public String getPrivateImeOptions() {
3230
        return  != null
3231
                ? . : null;
3232
    }

    
Set the extra input data of the text, which is the TextBoxAttribute.extras Bundle that will be filled in when creating an input connection. The given integer is the resource ID of an XML resource holding an <input-extras> XML tree.

See also:
getInputExtras(boolean)
android.view.inputmethod.EditorInfo.extras
Attr:
ref android.R.styleable#TextView_editorExtras
3245
    public void setInputExtras(int xmlResId)
3246
            throws XmlPullParserException, IOException {
3247
        XmlResourceParser parser = getResources().getXml(xmlResId);
3248
        if ( == null)  = new InputContentType();
3249
        . = new Bundle();
3251
    }

    
Retrieve the input extras currently associated with the text view, which can be viewed as well as modified.

Parameters:
create If true, the extras will be created if they don't already exist. Otherwise, null will be returned if none have been created.
See also:
setInputExtras(int)
android.view.inputmethod.EditorInfo.extras
Attr:
ref android.R.styleable#TextView_editorExtras
3263
    public Bundle getInputExtras(boolean create) {
3264
        if ( == null) {
3265
            if (!create) return null;
3266
             = new InputContentType();
3267
        }
3268
        if (. == null) {
3269
            if (!create) return null;
3270
            . = new Bundle();
3271
        }
3272
        return .;
3273
    }

    
Returns the error message that was set to be displayed with setError(java.lang.CharSequence), or null if no error was set or if it the error was cleared by the widget after user input. 
3280
    public CharSequence getError() {
3281
        return ;
3282
    }

    
Sets the right-hand compound drawable of the TextView to the "error" icon and sets an error message that will be displayed in a popup when the TextView has focus. The icon and error message will be reset to null when any key events cause changes to the TextView's text. If the error is null, the error message and icon will be cleared. 
3293
    public void setError(CharSequence error) {
3294
        if (error == null) {
3295
            setError(null, null);
3296
        } else {
3297
            Drawable dr = getContext().getResources().
3298
                getDrawable(.....
3299
                            );
3301
            dr.setBounds(0, 0, dr.getIntrinsicWidth(), dr.getIntrinsicHeight());
3302
            setError(error, dr);
3303
        }
3304
    }

    
Sets the right-hand compound drawable of the TextView to the specified icon and sets an error message that will be displayed in a popup when the TextView has focus. The icon and error message will be reset to null when any key events cause changes to the TextView's text. The drawable must already have had android.graphics.drawable.Drawable.setBounds(android.graphics.Rect) set on it. If the error is null, the error message will be cleared (and you should provide a null icon as well). 
3315
    public void setError(CharSequence error, Drawable icon) {
3316
        error = TextUtils.stringOrSpannedString(error);
3318
         = error;
3319
         = true;
3320
        final Drawables dr = ;
3321
        if (dr != null) {
3322
            setCompoundDrawables(dr.mDrawableLeft, dr.mDrawableTop,
3323
                                 icon, dr.mDrawableBottom);
3324
        } else {
3325
            setCompoundDrawables(null, null, icon, null);
3326
        }
3328
        if (error == null) {
3329
            if ( != null) {
3330
                if (.isShowing()) {
3331
                    .dismiss();
3332
                }
3334
                 = null;
3335
            }
3336
        } else {
3337
            if (isFocused()) {
3338
                showError();
3339
            }
3340
        }
3341
    }
3343
    private void showError() {
3344
        if (getWindowToken() == null) {
3345
             = true;
3346
            return;
3347
        }
3349
        if ( == null) {
3350
            LayoutInflater inflater = LayoutInflater.from(getContext());
3351
            final TextView err = (TextView) inflater.inflate(.....,
3352
                    null);
3354
            final float scale = getResources().getDisplayMetrics().;
3355
             = new ErrorPopup(err, (int) (200 * scale + 0.5f),
3356
                    (int) (50 * scale + 0.5f));
3357
            .setFocusable(false);
3358
            // The user is entering text, so the input method is needed.  We
3359
            // don't want the popup to be displayed on top of it.
3361
        }
3363
        TextView tv = (TextView) .getContentView();
3364
        chooseSize(, , tv);
3365
        tv.setText();
3367
        .showAsDropDown(this, getErrorX(), getErrorY());
3369
    }
3371
    private static class ErrorPopup extends PopupWindow {
3372
        private boolean mAbove = false;
3373
        private final TextView mView;
3375
        ErrorPopup(TextView v, int width, int height) {
3376
            super(v, width, height);
3377
             = v;
3378
        }
3380
        void fixDirection(boolean above) {
3381
             = above;
3383
            if (above) {
3385
            } else {
3387
            }
3388
        }
3390
        @Override
3391
        public void update(int x, int y, int w, int h, boolean force) {
3392
            super.update(x, y, w, h, force);
3394
            boolean above = isAboveAnchor();
3395
            if (above != ) {
3396
                fixDirection(above);
3397
            }
3398
        }
3399
    }

    
Returns the Y offset to make the pointy top of the error point at the middle of the error icon. 
3405
    private int getErrorX() {
3406
        /*
3407
         * The "25" is the distance between the point and the right edge
3408
         * of the background
3409
         */
3410
        final float scale = getResources().getDisplayMetrics().;
3412
        final Drawables dr = ;
3413
        return getWidth() - .getWidth()
3414
                - getPaddingRight()
3415
                - (dr != null ? dr.mDrawableSizeRight : 0) / 2 + (int) (25 * scale + 0.5f);
3416
    }

    
Returns the Y offset to make the pointy top of the error point at the bottom of the error icon. 
3422
    private int getErrorY() {
3423
        /*
3424
         * Compound, not extended, because the icon is not clipped
3425
         * if the text height is smaller.
3426
         */
3427
        int vspace =  -  -
3428
                     getCompoundPaddingBottom() - getCompoundPaddingTop();
3430
        final Drawables dr = ;
3431
        int icontop = getCompoundPaddingTop()
3432
                + (vspace - (dr != null ? dr.mDrawableHeightRight : 0)) / 2;
3434
        /*
3435
         * The "2" is the distance between the point and the top edge
3436
         * of the background.
3437
         */
3439
        return icontop + (dr != null ? dr.mDrawableHeightRight : 0)
3440
                - getHeight() - 2;
3441
    }
3443
    private void hideError() {
3444
        if ( != null) {
3445
            if (.isShowing()) {
3446
                .dismiss();
3447
            }
3448
        }
3450
         = false;
3451
    }
3453
    private void chooseSize(PopupWindow pop, CharSequence text, TextView tv) {
3454
        int wid = tv.getPaddingLeft() + tv.getPaddingRight();
3455
        int ht = tv.getPaddingTop() + tv.getPaddingBottom();
3457
        /*
3458
         * Figure out how big the text would be if we laid it out to the
3459
         * full width of this view minus the border.
3460
         */
3461
        int cap = getWidth() - wid;
3462
        if (cap < 0) {
3463
            cap = 200; // We must not be measured yet -- setFrame() will fix it.
3464
        }
3466
        Layout l = new StaticLayout(text, tv.getPaint(), cap,
3467
                                    .., 1, 0, true);
3468
        float max = 0;
3469
        for (int i = 0; i < l.getLineCount(); i++) {
3470
            max = Math.max(max, l.getLineWidth(i));
3471
        }
3473
        /*
3474
         * Now set the popup size to be big enough for the text plus the border.
3475
         */
3476
        pop.setWidth(wid + (int) Math.ceil(max));
3477
        pop.setHeight(ht + l.getHeight());
3478
    }
3481
    @Override
3482
    protected boolean setFrame(int l, int t, int r, int b) {
3483
        boolean result = super.setFrame(l, t, r, b);
3485
        if ( != null) {
3486
            TextView tv = (TextView) .getContentView();
3487
            chooseSize(, , tv);
3488
            .update(this, getErrorX(), getErrorY(),
3489
                          .getWidth(), .getHeight());
3490
        }
3492
        restartMarqueeIfNeeded();
3494
        return result;
3495
    }
3497
    private void restartMarqueeIfNeeded() {
3498
        if ( &&  == ..) {
3499
             = false;
3500
            startMarquee();
3501
        }
3502
    }

    
Sets the list of input filters that will be used if the buffer is Editable. Has no effect otherwise.

Attr:
ref android.R.styleable#TextView_maxLength
3510
    public void setFilters(InputFilter[] filters) {
3511
        if (filters == null) {
3512
            throw new IllegalArgumentException();
3513
        }
3515
         = filters;
3517
        if ( instanceof Editable) {
3518
            setFilters((Editable) , filters);
3519
        }
3520
    }

    
Sets the list of input filters on the specified Editable, and includes mInput in the list if it is an InputFilter. 
3526
    private void setFilters(Editable e, InputFilter[] filters) {
3527
        if ( instanceof InputFilter) {
3528
            InputFilter[] nf = new InputFilter[filters.length + 1];
3530
            System.arraycopy(filters, 0, nf, 0, filters.length);
3531
            nf[filters.length] = (InputFilter) ;
3533
            e.setFilters(nf);
3534
        } else {
3535
            e.setFilters(filters);
3536
        }
3537
    }

    
Returns the current list of input filters. 
3542
    public InputFilter[] getFilters() {
3543
        return ;
3544
    }
3546
    /////////////////////////////////////////////////////////////////////////
3548
    private int getVerticalOffset(boolean forceNormal) {
3549
        int voffset = 0;
3550
        final int gravity =  & .;
3552
        Layout l = ;
3553
        if (!forceNormal && .length() == 0 &&  != null) {
3554
            l = ;
3555
        }
3557
        if (gravity != .) {
3558
            int boxht;
3560
            if (l == ) {
3561
                boxht = getMeasuredHeight() - getCompoundPaddingTop() -
3562
                        getCompoundPaddingBottom();
3563
            } else {
3564
                boxht = getMeasuredHeight() - getExtendedPaddingTop() -
3565
                        getExtendedPaddingBottom();
3566
            }
3567
            int textht = l.getHeight();
3569
            if (textht < boxht) {
3570
                if (gravity == .)
3571
                    voffset = boxht - textht;
3572
                else // (gravity == Gravity.CENTER_VERTICAL)
3573
                    voffset = (boxht - textht) >> 1;
3574
            }
3575
        }
3576
        return voffset;
3577
    }
3579
    private int getBottomVerticalOffset(boolean forceNormal) {
3580
        int voffset = 0;
3581
        final int gravity =  & .;
3583
        Layout l = ;
3584
        if (!forceNormal && .length() == 0 &&  != null) {
3585
            l = ;
3586
        }
3588
        if (gravity != .) {
3589
            int boxht;
3591
            if (l == ) {
3592
                boxht = getMeasuredHeight() - getCompoundPaddingTop() -
3593
                        getCompoundPaddingBottom();
3594
            } else {
3595
                boxht = getMeasuredHeight() - getExtendedPaddingTop() -
3596
                        getExtendedPaddingBottom();
3597
            }
3598
            int textht = l.getHeight();
3600
            if (textht < boxht) {
3601
                if (gravity == .)
3602
                    voffset = boxht - textht;
3603
                else // (gravity == Gravity.CENTER_VERTICAL)
3604
                    voffset = (boxht - textht) >> 1;
3605
            }
3606
        }
3607
        return voffset;
3608
    }
3610
    private void invalidateCursorPath() {
3611
        if () {
3612
            invalidateCursor();
3613
        } else {
3614
            synchronized () {
3615
                /*
3616
                 * The reason for this concern about the thickness of the
3617
                 * cursor and doing the floor/ceil on the coordinates is that
3618
                 * some EditTexts (notably textfields in the Browser) have
3619
                 * anti-aliased text where not all the characters are
3620
                 * necessarily at integer-multiple locations.  This should
3621
                 * make sure the entire cursor gets invalidated instead of
3622
                 * sometimes missing half a pixel.
3623
                 */
3625
                float thick = FloatMath.ceil(.getStrokeWidth());
3626
                if (thick < 1.0f) {
3627
                    thick = 1.0f;
3628
                }
3630
                thick /= 2;
3632
                .computeBounds(, false);
3634
                int left = getCompoundPaddingLeft();
3635
                int top = getExtendedPaddingTop() + getVerticalOffset(true);
3637
                invalidate((int) FloatMath.floor(left + . - thick),
3638
                           (int) FloatMath.floor(top + . - thick),
3639
                           (int) FloatMath.ceil(left + . + thick),
3640
                           (int) FloatMath.ceil(top + . + thick));
3641
            }
3642
        }
3643
    }
3645
    private void invalidateCursor() {
3646
        int where = getSelectionEnd();
3648
        invalidateCursor(where, where, where);
3649
    }
3651
    private void invalidateCursor(int a, int b, int c) {
3652
        if ( == null) {
3653
            invalidate();
3654
        } else {
3655
            if (a >= 0 || b >= 0 || c >= 0) {
3656
                int first = Math.min(Math.min(a, b), c);
3657
                int last = Math.max(Math.max(a, b), c);
3659
                int line = .getLineForOffset(first);
3660
                int top = .getLineTop(line);
3662
                // This is ridiculous, but the descent from the line above
3663
                // can hang down into the line we really want to redraw,
3664
                // so we have to invalidate part of the line above to make
3665
                // sure everything that needs to be redrawn really is.
3666
                // (But not the whole line above, because that would cause
3667
                // the same problem with the descenders on the line above it!)
3668
                if (line > 0) {
3669
                    top -= .getLineDescent(line - 1);
3670
                }
3672
                int line2;
3674
                if (first == last)
3675
                    line2 = line;
3676
                else
3677
                    line2 = .getLineForOffset(last);
3679
                int bottom = .getLineTop(line2 + 1);
3680
                int voffset = getVerticalOffset(true);
3682
                int left = getCompoundPaddingLeft() + ;
3683
                invalidate(left, top + voffset + getExtendedPaddingTop(),
3684
                           left + getWidth() - getCompoundPaddingLeft() -
3685
                           getCompoundPaddingRight(),
3686
                           bottom + voffset + getExtendedPaddingTop());
3687
            }
3688
        }
3689
    }
3691
    private void registerForPreDraw() {
3692
        final ViewTreeObserver observer = getViewTreeObserver();
3693
        if (observer == null) {
3694
            return;
3695
        }
3697
        if ( == ) {
3698
            observer.addOnPreDrawListener(this);
3699
             = ;
3700
        } else if ( == ) {
3701
             = ;
3702
        }
3704
        // else state is PREDRAW_PENDING, so keep waiting.
3705
    }

    
3710
    public boolean onPreDraw() {
3711
        if ( != ) {
3712
            return true;
3713
        }
3715
        if ( == null) {
3716
            assumeLayout();
3717
        }
3719
        boolean changed = false;
3721
        SelectionModifierCursorController selectionController = null;
3722
        if ( != null) {
3723
            selectionController = (SelectionModifierCursorController)
3724
                ;
3725
        }
3728
        if ( != null) {
3729
            /* This code also provides auto-scrolling when a cursor is moved using a
3730
             * CursorController (insertion point or selection limits).
3731
             * For selection, ensure start or end is visible depending on controller's state.
3732
             */
3733
            int curs = getSelectionEnd();
3734
            if (selectionController != null && selectionController.isSelectionStartDragged()) {
3735
                curs = getSelectionStart();
3736
            }
3738
            /*
3739
             * TODO: This should really only keep the end in view if
3740
             * it already was before the text changed.  I'm not sure
3741
             * of a good way to tell from here if it was.
3742
             */
3743
            if (curs < 0 &&
3744
                  ( & .) == .) {
3745
                curs = .length();
3746
            }
3748
            if (curs >= 0) {
3749
                changed = bringPointIntoView(curs);
3750
            }
3751
        } else {
3752
            changed = bringTextIntoView();
3753
        }
3755
        // This has to be checked here since:
3756
        // - onFocusChanged cannot start it when focus is given to a view with selected text (after
3757
        //   a screen rotation) since layout is not yet initialized at that point.
3758
        // - ExtractEditText does not call onFocus when it is displayed. Fixing this issue would
3759
        //   allow to test for hasSelection in onFocusChanged, which would trigger a
3760
        //   startTextSelectionMode here. TODO
3761
        if (this instanceof ExtractEditText && selectionController != null && hasSelection()) {
3762
            startTextSelectionMode();
3763
        }
3765
         = ;
3766
        return !changed;
3767
    }
3769
    @Override
3770
    protected void onAttachedToWindow() {
3771
        super.onAttachedToWindow();
3773
         = false;
3774
        
3775
        if () {
3776
            showError();
3777
             = false;
3778
        }
3780
        final ViewTreeObserver observer = getViewTreeObserver();
3781
        if (observer != null) {
3782
            if ( != null) {
3783
                observer.addOnTouchModeChangeListener();
3784
            }
3785
            if ( != null) {
3786
                observer.addOnTouchModeChangeListener();
3787
            }
3788
        }
3789
    }
3791
    @Override
3792
    protected void onDetachedFromWindow() {
3793
        super.onDetachedFromWindow();
3795
        final ViewTreeObserver observer = getViewTreeObserver();
3796
        if (observer != null) {
3797
            if ( != ) {
3798
                observer.removeOnPreDrawListener(this);
3799
                 = ;
3800
            }
3801
            if ( != null) {
3802
                observer.removeOnTouchModeChangeListener();
3803
            }
3804
            if ( != null) {
3806
            }
3807
        }
3809
        if ( != null) {
3810
            hideError();
3811
        }
3813
        hideControllers();
3814
    }
3816
    @Override
3817
    protected boolean isPaddingOffsetRequired() {
3818
        return  != 0 ||  != null;
3819
    }
3821
    @Override
3822
    protected int getLeftPaddingOffset() {
3823
        return getCompoundPaddingLeft() -  +
3824
                (int) Math.min(0,  - );
3825
    }
3827
    @Override
3828
    protected int getTopPaddingOffset() {
3829
        return (int) Math.min(0,  - );
3830
    }
3832
    @Override
3833
    protected int getBottomPaddingOffset() {
3834
        return (int) Math.max(0,  + );
3835
    }
3837
    @Override
3838
    protected int getRightPaddingOffset() {
3839
        return -(getCompoundPaddingRight() - ) +
3840
                (int) Math.max(0,  + );
3841
    }
3843
    @Override
3844
    protected boolean verifyDrawable(Drawable who) {
3845
        final boolean verified = super.verifyDrawable(who);
3846
        if (!verified &&  != null) {
3847
            return who == . || who == . ||
3848
                    who == . || who == .;
3849
        }
3850
        return verified;
3851
    }
3853
    @Override
3854
    public void invalidateDrawable(Drawable drawable) {
3855
        if (verifyDrawable(drawable)) {
3856
            final Rect dirty = drawable.getBounds();
3857
            int scrollX = ;
3858
            int scrollY = ;
3860
            // IMPORTANT: The coordinates below are based on the coordinates computed
3861
            // for each compound drawable in onDraw(). Make sure to update each section
3862
            // accordingly.
3863
            final TextView.Drawables drawables = ;
3864
            if (drawables != null) {
3865
                if (drawable == drawables.mDrawableLeft) {
3866
                    final int compoundPaddingTop = getCompoundPaddingTop();
3867
                    final int compoundPaddingBottom = getCompoundPaddingBottom();
3868
                    final int vspace =  -  - compoundPaddingBottom - compoundPaddingTop;
3870
                    scrollX += ;
3871
                    scrollY += compoundPaddingTop + (vspace - drawables.mDrawableHeightLeft) / 2;
3872
                } else if (drawable == drawables.mDrawableRight) {
3873
                    final int compoundPaddingTop = getCompoundPaddingTop();
3874
                    final int compoundPaddingBottom = getCompoundPaddingBottom();
3875
                    final int vspace =  -  - compoundPaddingBottom - compoundPaddingTop;
3877
                    scrollX += ( -  -  - drawables.mDrawableSizeRight);
3878
                    scrollY += compoundPaddingTop + (vspace - drawables.mDrawableHeightRight) / 2;
3879
                } else if (drawable == drawables.mDrawableTop) {
3880
                    final int compoundPaddingLeft = getCompoundPaddingLeft();
3881
                    final int compoundPaddingRight = getCompoundPaddingRight();
3882
                    final int hspace =  -  - compoundPaddingRight - compoundPaddingLeft;
3884
                    scrollX += compoundPaddingLeft + (hspace - drawables.mDrawableWidthTop) / 2;
3885
                    scrollY += ;
3886
                } else if (drawable == drawables.mDrawableBottom) {
3887
                    final int compoundPaddingLeft = getCompoundPaddingLeft();
3888
                    final int compoundPaddingRight = getCompoundPaddingRight();
3889
                    final int hspace =  -  - compoundPaddingRight - compoundPaddingLeft;
3891
                    scrollX += compoundPaddingLeft + (hspace - drawables.mDrawableWidthBottom) / 2;
3892
                    scrollY += ( -  -  - drawables.mDrawableSizeBottom);
3893
                }
3894
            }
3896
            invalidate(dirty.left + scrollX, dirty.top + scrollY,
3897
                    dirty.right + scrollX, dirty.bottom + scrollY);
3898
        }
3899
    }
3901
    @Override
3902
    protected void onDraw(Canvas canvas) {
3903
        restartMarqueeIfNeeded();
3905
        // Draw the background for this view
3906
        super.onDraw(canvas);
3908
        final int compoundPaddingLeft = getCompoundPaddingLeft();
3909
        final int compoundPaddingTop = getCompoundPaddingTop();
3910
        final int compoundPaddingRight = getCompoundPaddingRight();
3911
        final int compoundPaddingBottom = getCompoundPaddingBottom();
3912
        final int scrollX = ;
3913
        final int scrollY = ;
3914
        final int right = ;
3915
        final int left = ;
3916
        final int bottom = ;
3917
        final int top = ;
3919
        final Drawables dr = ;
3920
        if (dr != null) {
3921
            /*
3922
             * Compound, not extended, because the icon is not clipped
3923
             * if the text height is smaller.
3924
             */
3926
            int vspace = bottom - top - compoundPaddingBottom - compoundPaddingTop;
3927
            int hspace = right - left - compoundPaddingRight - compoundPaddingLeft;
3929
            // IMPORTANT: The coordinates computed are also used in invalidateDrawable()
3930
            // Make sure to update invalidateDrawable() when changing this code.
3931
            if (dr.mDrawableLeft != null) {
3932
                canvas.save();
3933
                canvas.translate(scrollX + ,
3934
                                 scrollY + compoundPaddingTop +
3935
                                 (vspace - dr.mDrawableHeightLeft) / 2);
3936
                dr.mDrawableLeft.draw(canvas);
3937
                canvas.restore();
3938
            }
3940
            // IMPORTANT: The coordinates computed are also used in invalidateDrawable()
3941
            // Make sure to update invalidateDrawable() when changing this code.
3942
            if (dr.mDrawableRight != null) {
3943
                canvas.save();
3944
                canvas.translate(scrollX + right - left -  - dr.mDrawableSizeRight,
3945
                         scrollY + compoundPaddingTop + (vspace - dr.mDrawableHeightRight) / 2);
3946
                dr.mDrawableRight.draw(canvas);
3947
                canvas.restore();
3948
            }
3950
            // IMPORTANT: The coordinates computed are also used in invalidateDrawable()
3951
            // Make sure to update invalidateDrawable() when changing this code.
3952
            if (dr.mDrawableTop != null) {
3953
                canvas.save();
3954
                canvas.translate(scrollX + compoundPaddingLeft + (hspace - dr.mDrawableWidthTop) / 2,
3955
                        scrollY + );
3956
                dr.mDrawableTop.draw(canvas);
3957
                canvas.restore();
3958
            }
3960
            // IMPORTANT: The coordinates computed are also used in invalidateDrawable()
3961
            // Make sure to update invalidateDrawable() when changing this code.
3962
            if (dr.mDrawableBottom != null) {
3963
                canvas.save();
3964
                canvas.translate(scrollX + compoundPaddingLeft +
3965
                        (hspace - dr.mDrawableWidthBottom) / 2,
3966
                         scrollY + bottom - top -  - dr.mDrawableSizeBottom);
3967
                dr.mDrawableBottom.draw(canvas);
3968
                canvas.restore();
3969
            }
3970
        }
3972
        if ( == ) {
3973
            final ViewTreeObserver observer = getViewTreeObserver();
3974
            if (observer != null) {
3975
                observer.removeOnPreDrawListener(this);
3976
                 = ;
3977
            }
3978
        }
3980
        int color = ;
3982
        if ( == null) {
3983
            assumeLayout();
3984
        }
3986
        Layout layout = ;
3987
        int cursorcolor = color;
3989
        if ( != null && .length() == 0) {
3990
            if ( != null) {
3991
                color = ;
3992
            }
3994
            layout = ;
3995
        }
3997
        .setColor(color);
4000
        canvas.save();
4001
        /*  Would be faster if we didn't have to do this. Can we chop the
4002
            (displayable) text so that we don't need to do this ever?
4003
        */
4005
        int extendedPaddingTop = getExtendedPaddingTop();
4006
        int extendedPaddingBottom = getExtendedPaddingBottom();
4008
        float clipLeft = compoundPaddingLeft + scrollX;
4009
        float clipTop = extendedPaddingTop + scrollY;
4010
        float clipRight = right - left - compoundPaddingRight + scrollX;
4011
        float clipBottom = bottom - top - extendedPaddingBottom + scrollY;
4013
        if ( != 0) {
4014
            clipLeft += Math.min(0,  - );
4015
            clipRight += Math.max(0,  + );
4017
            clipTop += Math.min(0,  - );
4018
            clipBottom += Math.max(0,  + );
4019
        }
4021
        canvas.clipRect(clipLeft, clipTop, clipRight, clipBottom);
4023
        int voffsetText = 0;
4024
        int voffsetCursor = 0;
4026
        // translate in by our padding
4027
        {
4028
            /* shortcircuit calling getVerticaOffset() */
4029
            if (( & .) != .) {
4030
                voffsetText = getVerticalOffset(false);
4031
                voffsetCursor = getVerticalOffset(true);
4032
            }
4033
            canvas.translate(compoundPaddingLeft, extendedPaddingTop + voffsetText);
4034
        }
4036
        if ( == ..) {
4037
            if (! && getLineCount() == 1 && canMarquee() &&
4038
                    ( & .) != .) {
4039
                canvas.translate(.getLineRight(0) - ( -  -
4040
                        getCompoundPaddingLeft() - getCompoundPaddingRight()), 0.0f);
4041
            }
4043
            if ( != null && .isRunning()) {
4044
                canvas.translate(-., 0.0f);
4045
            }
4046
        }
4048
        Path highlight = null;
4049
        int selStart = -1, selEnd = -1;
4051
        //  If there is no movement method, then there can be no selection.
4052
        //  Check that first and attempt to skip everything having to do with
4053
        //  the cursor.
4054
        //  XXX This is not strictly true -- a program could set the
4055
        //  selection manually if it really wanted to.
4056
        if ( != null && (isFocused() || isPressed())) {
4057
            selStart = getSelectionStart();
4058
            selEnd = getSelectionEnd();
4060
            if ( && selStart >= 0 && isEnabled()) {
4061
                if ( == null)
4062
                     = new Path();
4064
                if (selStart == selEnd) {
4065
                    if ((SystemClock.uptimeMillis() - ) % (2 * ) < ) {
4066
                        if () {
4067
                            .reset();
4068
                            .getCursorPath(selStart, , );
4069
                             = false;
4070
                        }
4072
                        // XXX should pass to skin instead of drawing directly
4073
                        .setColor(cursorcolor);
4074
                        .setStyle(..);
4076
                        highlight = ;
4077
                    }
4078
                } else {
4079
                    if () {
4080
                        .reset();
4081
                        .getSelectionPath(selStart, selEnd, );
4082
                         = false;
4083
                    }
4085
                    // XXX should pass to skin instead of drawing directly
4086
                    .setColor();
4087
                    .setStyle(..);
4089
                    highlight = ;
4090
                }
4091
            }
4092
        }
4094
        /*  Comment out until we decide what to do about animations
4095
        boolean isLinearTextOn = false;
4096
        if (currentTransformation != null) {
4097
            isLinearTextOn = mTextPaint.isLinearTextOn();
4098
            Matrix m = currentTransformation.getMatrix();
4099
            if (!m.isIdentity()) {
4100
                // mTextPaint.setLinearTextOn(true);
4101
            }
4102
        }
4103
        */
4105
        final InputMethodState ims = ;
4106
        if (ims != null && ims.mBatchEditNesting == 0) {
4107
            InputMethodManager imm = InputMethodManager.peekInstance();
4108
            if (imm != null) {
4109
                if (imm.isActive(this)) {
4110
                    boolean reported = false;
4111
                    if (ims.mContentChanged || ims.mSelectionModeChanged) {
4112
                        // We are in extract mode and the content has changed
4113
                        // in some way... just report complete new text to the
4114
                        // input method.
4115
                        reported = reportExtractedText();
4116
                    }
4117
                    if (!reported && highlight != null) {
4118
                        int candStart = -1;
4119
                        int candEnd = -1;
4120
                        if ( instanceof Spannable) {
4121
                            Spannable sp = (Spannable);
4122
                            candStart = EditableInputConnection.getComposingSpanStart(sp);
4123
                            candEnd = EditableInputConnection.getComposingSpanEnd(sp);
4124
                        }
4125
                        imm.updateSelection(this, selStart, selEnd, candStart, candEnd);
4126
                    }
4127
                }
4128
                
4129
                if (imm.isWatchingCursor(this) && highlight != null) {
4130
                    highlight.computeBounds(ims.mTmpRectF, true);
4131
                    ims.mTmpOffset[0] = ims.mTmpOffset[1] = 0;
4132
    
4133
                    canvas.getMatrix().mapPoints(ims.mTmpOffset);
4134
                    ims.mTmpRectF.offset(ims.mTmpOffset[0], ims.mTmpOffset[1]);
4135
    
4136
                    ims.mTmpRectF.offset(0, voffsetCursor - voffsetText);
4137
    
4138
                    ims.mCursorRectInWindow.set((int)(ims.mTmpRectF.left + 0.5),
4139
                            (int)(ims.mTmpRectF.top + 0.5),
4140
                            (int)(ims.mTmpRectF.right + 0.5),
4141
                            (int)(ims.mTmpRectF.bottom + 0.5));
4142
    
4143
                    imm.updateCursor(this,
4144
                            ims.mCursorRectInWindow.left, ims.mCursorRectInWindow.top,
4145
                            ims.mCursorRectInWindow.right, ims.mCursorRectInWindow.bottom);
4146
                }
4147
            }
4148
        }
4150
        layout.draw(canvas, highlight, , voffsetCursor - voffsetText);
4152
        if ( != null && .shouldDrawGhost()) {
4153
            canvas.translate((int) .getGhostOffset(), 0.0f);
4154
            layout.draw(canvas, highlight, , voffsetCursor - voffsetText);
4155
        }
4157
        /*  Comment out until we decide what to do about animations
4158
        if (currentTransformation != null) {
4159
            mTextPaint.setLinearTextOn(isLinearTextOn);
4160
        }
4161
        */
4163
        canvas.restore();
4166
    }

    
Update the positions of the CursorControllers. Needed by WebTextView, which does not draw.

Hide:
4173
    protected void updateCursorControllerPositions() {
4174
        if ( != null &&
4175
                .isShowing()) {
4177
        }
4178
        if ( != null &&
4179
                .isShowing()) {
4181
        }
4182
    }
4184
    @Override
4185
    public void getFocusedRect(Rect r) {
4186
        if ( == null) {
4187
            super.getFocusedRect(r);
4188
            return;
4189
        }
4191
        int sel = getSelectionEnd();
4192
        if (sel < 0) {
4193
            super.getFocusedRect(r);
4194
            return;
4195
        }
4197
        int line = .getLineForOffset(sel);
4198
        r.top = .getLineTop(line);
4199
        r.bottom = .getLineBottom(line);
4201
        r.left = (int) .getPrimaryHorizontal(sel);
4202
        r.right = r.left + 1;
4204
        // Adjust for padding and gravity.
4205
        int paddingLeft = getCompoundPaddingLeft();
4206
        int paddingTop = getExtendedPaddingTop();
4207
        if (( & .) != .) {
4208
            paddingTop += getVerticalOffset(false);
4209
        }
4210
        r.offset(paddingLeft, paddingTop);
4211
    }

    
Return the number of lines of text, or 0 if the internal Layout has not been built. 
4217
    public int getLineCount() {
4218
        return  != null ? .getLineCount() : 0;
4219
    }

    
Return the baseline for the specified line (0...getLineCount() - 1) If bounds is not null, return the top, left, right, bottom extents of the specified line in it. If the internal Layout has not been built, return 0 and set bounds to (0, 0, 0, 0)

Parameters:
line which line to examine (0..getLineCount() - 1)
bounds Optional. If not null, it returns the extent of the line
Returns:
the Y-coordinate of the baseline
4230
    public int getLineBounds(int line, Rect bounds) {
4231
        if ( == null) {
4232
            if (bounds != null) {
4233
                bounds.set(0, 0, 0, 0);
4234
            }
4235
            return 0;
4236
        }
4237
        else {
4238
            int baseline = .getLineBounds(line, bounds);
4240
            int voffset = getExtendedPaddingTop();
4241
            if (( & .) != .) {
4242
                voffset += getVerticalOffset(true);
4243
            }
4244
            if (bounds != null) {
4245
                bounds.offset(getCompoundPaddingLeft(), voffset);
4246
            }
4247
            return baseline + voffset;
4248
        }
4249
    }
4251
    @Override
4252
    public int getBaseline() {
4253
        if ( == null) {
4254
            return super.getBaseline();
4255
        }
4257
        int voffset = 0;
4258
        if (( & .) != .) {
4259
            voffset = getVerticalOffset(true);
4260
        }
4262
        return getExtendedPaddingTop() + voffset + .getLineBaseline(0);
4263
    }
4265
    @Override
4266
    public boolean onKeyDown(int keyCode, KeyEvent event) {
4267
        int which = doKeyDown(keyCode, event, null);
4268
        if (which == 0) {
4269
            // Go through default dispatching.
4270
            return super.onKeyDown(keyCode, event);
4271
        }
4273
        return true;
4274
    }
4276
    @Override
4277
    public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
4278
        KeyEvent down = KeyEvent.changeAction(event, .);
4280
        int which = doKeyDown(keyCode, down, event);
4281
        if (which == 0) {
4282
            // Go through default dispatching.
4283
            return super.onKeyMultiple(keyCode, repeatCount, event);
4284
        }
4285
        if (which == -1) {
4286
            // Consumed the whole thing.
4287
            return true;
4288
        }
4290
        repeatCount--;
4291
        
4292
        // We are going to dispatch the remaining events to either the input
4293
        // or movement method.  To do this, we will just send a repeated stream
4294
        // of down and up events until we have done the complete repeatCount.
4295
        // It would be nice if those interfaces had an onKeyMultiple() method,
4296
        // but adding that is a more complicated change.
4297
        KeyEvent up = KeyEvent.changeAction(event, .);
4298
        if (which == 1) {
4299
            .onKeyUp(this, (Editable), keyCode, up);
4300
            while (--repeatCount > 0) {
4301
                .onKeyDown(this, (Editable), keyCode, down);
4302
                .onKeyUp(this, (Editable), keyCode, up);
4303
            }
4304
            if ( != null && !) {
4305
                setError(null, null);
4306
            }
4308
        } else if (which == 2) {
4309
            .onKeyUp(this, (Spannable), keyCode, up);
4310
            while (--repeatCount > 0) {
4311
                .onKeyDown(this, (Spannable), keyCode, down);
4312
                .onKeyUp(this, (Spannable), keyCode, up);
4313
            }
4314
        }
4316
        return true;
4317
    }

    
Returns true if pressing ENTER in this field advances focus instead of inserting the character. This is true mostly in single-line fields, but also in mail addresses and subjects which will display on multiple lines but where it doesn't make sense to insert newlines. 
4325
    private boolean shouldAdvanceFocusOnEnter() {
4326
        if ( == null) {
4327
            return false;
4328
        }
4330
        if () {
4331
            return true;
4332
        }
4335
            int variation =  & .;
4337
            if (variation == . ||
4338
                variation == .) {
4339
                return true;
4340
            }
4341
        }
4343
        return false;
4344
    }
4346
    private int doKeyDown(int keyCode, KeyEvent event, KeyEvent otherEvent) {
4347
        if (!isEnabled()) {
4348
            return 0;
4349
        }
4351
        switch (keyCode) {
4352
            case .:
4353
                 = true;
4354
                // If ALT modifier is held, then we always insert a
4355
                // newline character.
4356
                if ((event.getMetaState()&.) == 0) {
4357
                    
4358
                    // When mInputContentType is set, we know that we are
4359
                    // running in a "modern" cupcake environment, so don't need
4360
                    // to worry about the application trying to capture
4361
                    // enter key events.
4362
                    if ( != null) {
4363
                        
4364
                        // If there is an action listener, given them a
4365
                        // chance to consume the event.
4366
                        if (. != null &&
4367
                                ..onEditorAction(
4368
                                this, ., event)) {
4369
                            . = true;
4370
                            // We are consuming the enter key for them.
4371
                            return -1;
4372
                        }
4373
                    }
4374
                    
4375
                    // If our editor should move focus when enter is pressed, or
4376
                    // this is a generated event from an IME action button, then
4377
                    // don't let it be inserted into the text.
4378
                    if ((event.getFlags()&.) != 0
4379
                            || shouldAdvanceFocusOnEnter()) {
4380
                        return -1;
4381
                    }
4382
                }
4383
                break;
4384
                
4385
            case .:
4386
                 = true;
4387
                if (shouldAdvanceFocusOnEnter()) {
4388
                    return 0;
4389
                }
4390
                break;
4392
                // Has to be done on key down (and not on key up) to correctly be intercepted.
4393
            case .:
4394
                if () {
4395
                    stopTextSelectionMode();
4396
                    return -1;
4397
                }
4398
                break;
4399
        }
4401
        if ( != null) {
4402
            /*
4403
             * Keep track of what the error was before doing the input
4404
             * so that if an input filter changed the error, we leave
4405
             * that error showing.  Otherwise, we take down whatever
4406
             * error was showing when the user types something.
4407
             */
4408
             = false;
4410
            boolean doDown = true;
4411
            if (otherEvent != null) {
4412
                try {
4413
                    beginBatchEdit();
4414
                    boolean handled = .onKeyOther(this, (Editable) ,
4415
                            otherEvent);
4416
                    if ( != null && !) {
4417
                        setError(null, null);
4418
                    }
4419
                    doDown = false;
4420
                    if (handled) {
4421
                        return -1;
4422
                    }
4423
                } catch (AbstractMethodError e) {
4424
                    // onKeyOther was added after 1.0, so if it isn't
4425
                    // implemented we need to try to dispatch as a regular down.
4426
                } finally {
4427
                    endBatchEdit();
4428
                }
4429
            }
4430
            
4431
            if (doDown) {
4432
                beginBatchEdit();
4433
                if (.onKeyDown(this, (Editable) , keyCode, event)) {
4434
                    endBatchEdit();
4435
                    if ( != null && !) {
4436
                        setError(null, null);
4437
                    }
4438
                    return 1;
4439
                }
4440
                endBatchEdit();
4441
            }
4442
        }
4444
        // bug 650865: sometimes we get a key event before a layout.
4445
        // don't try to move around if we don't know the layout.
4447
        if ( != null &&  != null) {
4448
            boolean doDown = true;
4449
            if (otherEvent != null) {
4450
                try {
4451
                    boolean handled = .onKeyOther(this, (Spannable) ,
4452
                            otherEvent);
4453
                    doDown = false;
4454
                    if (handled) {
4455
                        return -1;
4456
                    }
4457
                } catch (AbstractMethodError e) {
4458
                    // onKeyOther was added after 1.0, so if it isn't
4459
                    // implemented we need to try to dispatch as a regular down.
4460
                }
4461
            }
4462
            if (doDown) {
4463
                if (.onKeyDown(this, (Spannable), keyCode, event))
4464
                    return 2;
4465
            }
4466
        }
4468
        return 0;
4469
    }
4471
    @Override
4472
    public boolean onKeyUp(int keyCode, KeyEvent event) {
4473
        if (!isEnabled()) {
4474
            return super.onKeyUp(keyCode, event);
4475
        }
4477
        hideControllers();
4478
        stopTextSelectionMode();
4480
        switch (keyCode) {
4481
            case .:
4482
                 = false;
4483
                /*
4484
                 * If there is a click listener, just call through to
4485
                 * super, which will invoke it.
4486
                 *
4487
                 * If there isn't a click listener, try to show the soft
4488
                 * input method.  (It will also
4489
                 * call performClick(), but that won't do anything in
4490
                 * this case.)
4491
                 */
4492
                if ( == null) {
4493
                    if ( != null &&  instanceof Editable
4494
                            &&  != null && onCheckIsTextEditor()) {
4495
                        InputMethodManager imm = (InputMethodManager)
4496
                                getContext().getSystemService(.);
4497
                        imm.showSoftInput(this, 0);
4498
                    }
4499
                }
4500
                return super.onKeyUp(keyCode, event);
4501
                
4502
            case .:
4503
                 = false;
4504
                if ( != null
4505
                        && . != null
4506
                        && .) {
4507
                    . = false;
4508
                    if (..onEditorAction(
4509
                            this, ., event)) {
4510
                        return true;
4511
                    }
4512
                }
4513
                
4514
                if ((event.getFlags()&.) != 0
4515
                        || shouldAdvanceFocusOnEnter()) {
4516
                    /*
4517
                     * If there is a click listener, just call through to
4518
                     * super, which will invoke it.
4519
                     *
4520
                     * If there isn't a click listener, try to advance focus,
4521
                     * but still call through to super, which will reset the
4522
                     * pressed state and longpress state.  (It will also
4523
                     * call performClick(), but that won't do anything in
4524
                     * this case.)
4525
                     */
4526
                    if ( == null) {
4527
                        View v = focusSearch();
4529
                        if (v != null) {
4530
                            if (!v.requestFocus()) {
4531
                                throw new IllegalStateException("focus search returned a view " +
4532
                                        "that wasn't able to take focus!");
4533
                            }
4535
                            /*
4536
                             * Return true because we handled the key; super
4537
                             * will return false because there was no click
4538
                             * listener.
4539
                             */
4540
                            super.onKeyUp(keyCode, event);
4541
                            return true;
4542
                        } else if ((event.getFlags()
4543
                                & .) != 0) {
4544
                            // No target for next focus, but make sure the IME
4545
                            // if this came from it.
4546
                            InputMethodManager imm = InputMethodManager.peekInstance();
4547
                            if (imm != null) {
4548
                                imm.hideSoftInputFromWindow(getWindowToken(), 0);
4549
                            }
4550
                        }
4551
                    }
4553
                    return super.onKeyUp(keyCode, event);
4554
                }
4555
                break;
4556
        }
4558
        if ( != null)
4559
            if (.onKeyUp(this, (Editable) , keyCode, event))
4560
                return true;
4562
        if ( != null &&  != null)
4563
            if (.onKeyUp(this, (Spannable) , keyCode, event))
4564
                return true;
4566
        return super.onKeyUp(keyCode, event);
4567
    }
4569
    @Override public boolean onCheckIsTextEditor() {
4570
        return  != .;
4571
    }
4572
    
4574
        if (onCheckIsTextEditor()) {
4575
            if ( == null) {
4576
                 = new InputMethodState();
4577
            }
4578
            outAttrs.inputType = ;
4579
            if ( != null) {
4580
                outAttrs.imeOptions = .;
4581
                outAttrs.privateImeOptions = .;
4582
                outAttrs.actionLabel = .;
4583
                outAttrs.actionId = .;
4584
                outAttrs.extras = .;
4585
            } else {
4586
                outAttrs.imeOptions = .;
4587
            }
4588
            if ((outAttrs.imeOptions&.)
4589
                    == .) {
4590
                if (focusSearch() != null) {
4591
                    // An action has not been set, but the enter key will move to
4592
                    // the next focus, so set the action to that.
4593
                    outAttrs.imeOptions |= .;
4594
                } else {
4595
                    // An action has not been set, and there is no focus to move
4596
                    // to, so let's just supply a "done" action.
4597
                    outAttrs.imeOptions |= .;
4598
                }
4599
                if (!shouldAdvanceFocusOnEnter()) {
4600
                    outAttrs.imeOptions |= .;
4601
                }
4602
            }
4603
            if ((outAttrs.inputType & (.
4604
                    | .))
4605
                    == (.
4606
                            | .)) {
4607
                // Multi-line text editors should always show an enter key.
4608
                outAttrs.imeOptions |= .;
4609
            }
4610
            outAttrs.hintText = ;
4611
            if ( instanceof Editable) {
4612
                InputConnection ic = new EditableInputConnection(this);
4613
                outAttrs.initialSelStart = getSelectionStart();
4614
                outAttrs.initialSelEnd = getSelectionEnd();
4615
                outAttrs.initialCapsMode = ic.getCursorCapsMode();
4616
                return ic;
4617
            }
4618
        }
4619
        return null;
4620
    }

    
If this TextView contains editable content, extract a portion of it based on the information in request in to outText.

Returns:
Returns true if the text was successfully extracted, else false.
4627
    public boolean extractText(ExtractedTextRequest request,
4628
            ExtractedText outText) {
4629
        return extractTextInternal(request, , ,
4630
                , outText);
4631
    }
4632
    
4633
    static final int EXTRACT_NOTHING = -2;
4634
    static final int EXTRACT_UNKNOWN = -1;
4635
    
4637
            int partialStartOffset, int partialEndOffset, int delta,
4638
            ExtractedText outText) {
4639
        final CharSequence content = ;
4640
        if (content != null) {
4641
            if (partialStartOffset != ) {
4642
                final int N = content.length();
4643
                if (partialStartOffset < 0) {
4644
                    outText.partialStartOffset = outText.partialEndOffset = -1;
4645
                    partialStartOffset = 0;
4646
                    partialEndOffset = N;
4647
                } else {
4648
                    // Adjust offsets to ensure we contain full spans.
4649
                    if (content instanceof Spanned) {
4650
                        Spanned spanned = (Spanned)content;
4651
                        Object[] spans = spanned.getSpans(partialStartOffset,
4652
                                partialEndOffset, ParcelableSpan.class);
4653
                        int i = spans.length;
4654
                        while (i > 0) {
4655
                            i--;
4656
                            int j = spanned.getSpanStart(spans[i]);
4657
                            if (j < partialStartOffset) partialStartOffset = j;
4658
                            j = spanned.getSpanEnd(spans[i]);
4659
                            if (j > partialEndOffset) partialEndOffset = j;
4660
                        }
4661
                    }
4662
                    outText.partialStartOffset = partialStartOffset;
4663
                    outText.partialEndOffset = partialEndOffset;
4664
                    // Now use the delta to determine the actual amount of text
4665
                    // we need.
4666
                    partialEndOffset += delta;
4667
                    if (partialStartOffset > N) {
4668
                        partialStartOffset = N;
4669
                    } else if (partialStartOffset < 0) {
4670
                        partialStartOffset = 0;
4671
                    }
4672
                    if (partialEndOffset > N) {
4673
                        partialEndOffset = N;
4674
                    } else if (partialEndOffset < 0) {
4675
                        partialEndOffset = 0;
4676
                    }
4677
                }
4678
                if ((request.flags&.) != 0) {
4679
                    outText.text = content.subSequence(partialStartOffset,
4680
                            partialEndOffset);
4681
                } else {
4682
                    outText.text = TextUtils.substring(content, partialStartOffset,
4683
                            partialEndOffset);
4684
                }
4685
            } else {
4686
                outText.partialStartOffset = 0;
4687
                outText.partialEndOffset = 0;
4688
                outText.text = "";
4689
            }
4690
            outText.flags = 0;
4691
            if (MetaKeyKeyListener.getMetaState(, .) != 0) {
4692
                outText.flags |= .;
4693
            }
4694
            if () {
4695
                outText.flags |= .;
4696
            }
4697
            outText.startOffset = 0;
4698
            outText.selectionStart = getSelectionStart();
4699
            outText.selectionEnd = getSelectionEnd();
4700
            return true;
4701
        }
4702
        return false;
4703
    }
4704
    
4705
    boolean reportExtractedText() {
4706
        final InputMethodState ims = ;
4707
        if (ims != null) {
4708
            final boolean contentChanged = ims.mContentChanged;
4709
            if (contentChanged || ims.mSelectionModeChanged) {
4710
                ims.mContentChanged = false;
4711
                ims.mSelectionModeChanged = false;
4712
                final ExtractedTextRequest req = .;
4713
                if (req != null) {
4714
                    InputMethodManager imm = InputMethodManager.peekInstance();
4715
                    if (imm != null) {
4716
                        if () Log.v(, "Retrieving extracted start="
4717
                                + ims.mChangedStart + " end=" + ims.mChangedEnd
4718
                                + " delta=" + ims.mChangedDelta);
4719
                        if (ims.mChangedStart < 0 && !contentChanged) {
4720
                            ims.mChangedStart = ;
4721
                        }
4722
                        if (extractTextInternal(req, ims.mChangedStart, ims.mChangedEnd,
4723
                                ims.mChangedDelta, ims.mTmpExtracted)) {
4724
                            if () Log.v(, "Reporting extracted start="
4725
                                    + ims.mTmpExtracted.partialStartOffset
4726
                                    + " end=" + ims.mTmpExtracted.partialEndOffset
4727
                                    + ": " + ims.mTmpExtracted.text);
4728
                            imm.updateExtractedText(this, req.token,
4729
                                    .);
4730
                            return true;
4731
                        }
4732
                    }
4733
                }
4734
            }
4735
        }
4736
        return false;
4737
    }
    
    
This is used to remove all style-impacting spans from text before new extracted text is being replaced into it, so that we don't have any lingering spans applied during the replace. 
4744
    static void removeParcelableSpans(Spannable spannable, int start, int end) {
4745
        Object[] spans = spannable.getSpans(start, end, ParcelableSpan.class);
4746
        int i = spans.length;
4747
        while (i > 0) {
4748
            i--;
4749
            spannable.removeSpan(spans[i]);
4750
        }
4751
    }
    
    
Apply to this text view the given extracted text, as previously returned by extractText(android.view.inputmethod.ExtractedTextRequest,android.view.inputmethod.ExtractedText). 
4757
    public void setExtractedText(ExtractedText text) {
4758
        Editable content = getEditableText();
4759
        if (text.text != null) {
4760
            if (content == null) {
4761
                setText(text.text, ..);
4762
            } else if (text.partialStartOffset < 0) {
4763
                removeParcelableSpans(content, 0, content.length());
4764
                content.replace(0, content.length(), text.text);
4765
            } else {
4766
                final int N = content.length();
4767
                int start = text.partialStartOffset;
4768
                if (start > N) start = N;
4769
                int end = text.partialEndOffset;
4770
                if (end > N) end = N;
4771
                removeParcelableSpans(content, start, end);
4772
                content.replace(start, end, text.text);
4773
            }
4774
        }
4775
        
4776
        // Now set the selection position...  make sure it is in range, to
4777
        // avoid crashes.  If this is a partial update, it is possible that
4778
        // the underlying text may have changed, causing us problems here.
4779
        // Also we just don't want to trust clients to do the right thing.
4780
        Spannable sp = (Spannable)getText();
4781
        final int N = sp.length();
4782
        int start = text.selectionStart;
4783
        if (start < 0) start = 0;
4784
        else if (start > N) start = N;
4785
        int end = text.selectionEnd;
4786
        if (end < 0) end = 0;
4787
        else if (end > N) end = N;
4788
        Selection.setSelection(sp, start, end);
4789
        
4790
        // Finally, update the selection mode.
4791
        if ((text.flags&.) != 0) {
4792
            MetaKeyKeyListener.startSelecting(this, sp);
4793
        } else {
4794
            MetaKeyKeyListener.stopSelecting(this, sp);
4795
        }
4796
    }
    
    

Hide:
4801
    public void setExtracting(ExtractedTextRequest req) {
4802
        if ( != null) {
4803
            . = req;
4804
        }
4805
        hideControllers();
4806
    }
    
    
Called by the framework in response to a text completion from the current input method, provided by it calling InputConnection.commitCompletion(). The default implementation does nothing; text views that are supporting auto-completion should override this to do their desired behavior.

Parameters:
text The auto complete text the user has selected.
4818
    public void onCommitCompletion(CompletionInfo text) {
4819
    }
4821
    public void beginBatchEdit() {
4822
         = true;
4823
        final InputMethodState ims = ;
4824
        if (ims != null) {
4825
            int nesting = ++ims.mBatchEditNesting;
4826
            if (nesting == 1) {
4827
                ims.mCursorChanged = false;
4828
                ims.mChangedDelta = 0;
4829
                if (ims.mContentChanged) {
4830
                    // We already have a pending change from somewhere else,
4831
                    // so turn this into a full update.
4832
                    ims.mChangedStart = 0;
4833
                    ims.mChangedEnd = .length();
4834
                } else {
4835
                    ims.mChangedStart = ;
4836
                    ims.mChangedEnd = ;
4837
                    ims.mContentChanged = false;
4838
                }
4839
                onBeginBatchEdit();
4840
            }
4841
        }
4842
    }
4843
    
4844
    public void endBatchEdit() {
4845
         = false;
4846
        final InputMethodState ims = ;
4847
        if (ims != null) {
4848
            int nesting = --ims.mBatchEditNesting;
4849
            if (nesting == 0) {
4850
                finishBatchEdit(ims);
4851
            }
4852
        }
4853
    }
4854
    
4855
    void ensureEndedBatchEdit() {
4856
        final InputMethodState ims = ;
4857
        if (ims != null && ims.mBatchEditNesting != 0) {
4858
            ims.mBatchEditNesting = 0;
4859
            finishBatchEdit(ims);
4860
        }
4861
    }
4862
    
4863
    void finishBatchEdit(final InputMethodState ims) {
4864
        onEndBatchEdit();
4865
        
4866
        if (ims.mContentChanged || ims.mSelectionModeChanged) {
4867
            updateAfterEdit();
4868
            reportExtractedText();
4869
        } else if (ims.mCursorChanged) {
4870
            // Cheezy way to get us to report the current cursor location.
4871
            invalidateCursor();
4872
        }
4873
    }
4874
    
4875
    void updateAfterEdit() {
4876
        invalidate();
4877
        int curs = getSelectionStart();
4879
        if (curs >= 0 || ( & .) ==
4880
                             .) {
4881
            registerForPreDraw();
4882
        }
4884
        if (curs >= 0) {
4885
             = true;
4887
            if (isFocused()) {
4888
                 = SystemClock.uptimeMillis();
4889
                makeBlink();
4890
            }
4891
        }
4892
        
4893
        checkForResize();
4894
    }
    
    
Called by the framework in response to a request to begin a batch of edit operations through a call to link beginBatchEdit(). 
4900
    public void onBeginBatchEdit() {
4901
    }
    
    
Called by the framework in response to a request to end a batch of edit operations through a call to link endBatchEdit(). 
4907
    public void onEndBatchEdit() {
4908
    }
    
    
Called by the framework in response to a private command from the current method, provided by it calling InputConnection.performPrivateCommand().

Parameters:
action The action name of the command.
data Any additional data for the command. This may be null.
Returns:
Return true if you handled the command, else false.
4920
    public boolean onPrivateIMECommand(String action, Bundle data) {
4921
        return false;
4922
    }
4924
    private void nullLayouts() {
4925
        if ( instanceof BoringLayout &&  == null) {
4926
             = (BoringLayout) ;
4927
        }
4928
        if ( instanceof BoringLayout &&  == null) {
4929
             = (BoringLayout) ;
4930
        }
4932
         =  = null;
4933
    }

    
Make a new Layout based on the already-measured size of the view, on the assumption that it was measured correctly at some point. 
4939
    private void assumeLayout() {
4940
        int width =  -  - getCompoundPaddingLeft() - getCompoundPaddingRight();
4942
        if (width < 1) {
4943
            width = 0;
4944
        }
4946
        int physicalWidth = width;
4948
        if () {
4949
            width = ;
4950
        }
4952
        makeNewLayout(width, physicalWidth, , ,
4953
                      physicalWidth, false);
4954
    }

    
The width passed in is now the desired layout width, not the full view width with padding. 
4961
    protected void makeNewLayout(int w, int hintWidth,
4962
                                 BoringLayout.Metrics boring,
4963
                                 BoringLayout.Metrics hintBoring,
4964
                                 int ellipsisWidth, boolean bringIntoView) {
4965
        stopMarquee();
4967
         = true;
4969
        if (w < 0) {
4970
            w = 0;
4971
        }
4972
        if (hintWidth < 0) {
4973
            hintWidth = 0;
4974
        }
4976
        Layout.Alignment alignment;
4977
        switch ( & .) {
4978
            case .:
4979
                alignment = ..;
4980
                break;
4982
            case .:
4983
                alignment = ..;
4984
                break;
4986
            default:
4987
                alignment = ..;
4988
        }
4990
        boolean shouldEllipsize =  != null &&  == null;
4992
        if ( instanceof Spannable) {
4993
             = new DynamicLayout(, , , w,
4994
                    alignment, ,
4995
                    , ,  == null ?  : null,
4996
                    ellipsisWidth);
4997
        } else {
4998
            if (boring == ) {
4999
                boring = BoringLayout.isBoring(, ,
5000
                                               );
5001
                if (boring != null) {
5002
                     = boring;
5003
                }
5004
            }
5006
            if (boring != null) {
5007
                if (boring.width <= w &&
5008
                    ( == null || boring.width <= ellipsisWidth)) {
5009
                    if ( != null) {
5010
                         = .
5011
                                replaceOrMake(, ,
5012
                                w, alignment, , ,
5013
                                boring, );
5014
                    } else {
5015
                         = BoringLayout.make(, ,
5016
                                w, alignment, , ,
5017
                                boring, );
5018
                    }
5020
                     = (BoringLayout) ;
5021
                } else if (shouldEllipsize && boring.width <= w) {
5022
                    if ( != null) {
5023
                         = .
5024
                                replaceOrMake(, ,
5025
                                w, alignment, , ,
5026
                                boring, , ,
5027
                                ellipsisWidth);
5028
                    } else {
5029
                         = BoringLayout.make(, ,
5030
                                w, alignment, , ,
5031
                                boring, , ,
5032
                                ellipsisWidth);
5033
                    }
5034
                } else if (shouldEllipsize) {
5035
                     = new StaticLayout(,
5036
                                0, .length(),
5037
                                , w, alignment, ,
5038
                                , , ,
5039
                                ellipsisWidth);
5040
                } else {
5041
                     = new StaticLayout(, ,
5042
                            w, alignment, , ,
5043
                            );
5044
                }
5045
            } else if (shouldEllipsize) {
5046
                 = new StaticLayout(,
5047
                            0, .length(),
5048
                            , w, alignment, ,
5049
                            , , ,
5050
                            ellipsisWidth);
5051
            } else {
5052
                 = new StaticLayout(, ,
5053
                        w, alignment, , ,
5054
                        );
5055
            }
5056
        }
5058
        shouldEllipsize =  != null;
5059
         = null;
5061
        if ( != null) {
5062
            if (shouldEllipsize) hintWidth = w;
5064
            if (hintBoring == ) {
5065
                hintBoring = BoringLayout.isBoring(, ,
5066
                                                   );
5067
                if (hintBoring != null) {
5068
                     = hintBoring;
5069
                }
5070
            }
5072
            if (hintBoring != null) {
5073
                if (hintBoring.width <= hintWidth &&
5074
                    (!shouldEllipsize || hintBoring.width <= ellipsisWidth)) {
5075
                    if ( != null) {
5076
                         = .
5077
                                replaceOrMake(, ,
5078
                                hintWidth, alignment, , ,
5079
                                hintBoring, );
5080
                    } else {
5081
                         = BoringLayout.make(, ,
5082
                                hintWidth, alignment, , ,
5083
                                hintBoring, );
5084
                    }
5086
                     = (BoringLayout) ;
5087
                } else if (shouldEllipsize && hintBoring.width <= hintWidth) {
5088
                    if ( != null) {
5089
                         = .
5090
                                replaceOrMake(, ,
5091
                                hintWidth, alignment, , ,
5092
                                hintBoring, , ,
5093
                                ellipsisWidth);
5094
                    } else {
5095
                         = BoringLayout.make(, ,
5096
                                hintWidth, alignment, , ,
5097
                                hintBoring, , ,
5098
                                ellipsisWidth);
5099
                    }
5100
                } else if (shouldEllipsize) {
5101
                     = new StaticLayout(,
5102
                                0, .length(),
5103
                                , hintWidth, alignment, ,
5104
                                , , ,
5105
                                ellipsisWidth);
5106
                } else {
5107
                     = new StaticLayout(, ,
5108
                            hintWidth, alignment, , ,
5109
                            );
5110
                }
5111
            } else if (shouldEllipsize) {
5112
                 = new StaticLayout(,
5113
                            0, .length(),
5114
                            , hintWidth, alignment, ,
5115
                            , , ,
5116
                            ellipsisWidth);
5117
            } else {
5118
                 = new StaticLayout(, ,
5119
                        hintWidth, alignment, , ,
5120
                        );
5121
            }
5122
        }
5124
        if (bringIntoView) {
5125
            registerForPreDraw();
5126
        }
5128
        if ( == ..) {
5129
            if (!compressText(ellipsisWidth)) {
5130
                final int height = .;
5131
                // If the size of the view does not depend on the size of the text, try to
5132
                // start the marquee immediately
5133
                if (height != . && height != .) {
5134
                    startMarquee();
5135
                } else {
5136
                    // Defer the start of the marquee until we know our width (see setFrame())
5137
                     = true;
5138
                }
5139
            }
5140
        }
5142
        // CursorControllers need a non-null mLayout
5143
        prepareCursorControllers();
5144
    }
5146
    private boolean compressText(float width) {
5147
        // Only compress the text if it hasn't been compressed by the previous pass
5148
        if (width > 0.0f &&  != null && getLineCount() == 1 && ! &&
5149
                .getTextScaleX() == 1.0f) {
5150
            final float textWidth = .getLineWidth(0);
5151
            final float overflow = (textWidth + 1.0f - width) / width;
5152
            if (overflow > 0.0f && overflow <= .) {
5153
                .setTextScaleX(1.0f - overflow - 0.005f);
5154
                post(new Runnable() {
5155
                    public void run() {
5156
                        requestLayout();
5157
                    }
5158
                });
5159
                return true;
5160
            }
5161
        }
5163
        return false;
5164
    }
5166
    private static int desired(Layout layout) {
5167
        int n = layout.getLineCount();
5168
        CharSequence text = layout.getText();
5169
        float max = 0;
5171
        // if any line was wrapped, we can't use it.
5172
        // but it's ok for the last line not to have a newline
5174
        for (int i = 0; i < n - 1; i++) {
5175
            if (text.charAt(layout.getLineEnd(i) - 1) != '\n')
5176
                return -1;
5177
        }
5179
        for (int i = 0; i < n; i++) {
5180
            max = Math.max(max, layout.getLineWidth(i));
5181
        }
5183
        return (int) FloatMath.ceil(max);
5184
    }

    
Set whether the TextView includes extra top and bottom padding to make room for accents that go above the normal ascent and descent. The default is true.

Attr:
ref android.R.styleable#TextView_includeFontPadding
5193
    public void setIncludeFontPadding(boolean includepad) {
5194
         = includepad;
5196
        if ( != null) {
5197
            nullLayouts();
5198
            requestLayout();
5199
            invalidate();
5200
        }
5201
    }
5203
    private static final BoringLayout.Metrics UNKNOWN_BORING = new BoringLayout.Metrics();
5205
    @Override
5206
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
5207
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
5208
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
5209
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
5210
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
5212
        int width;
5213
        int height;
5215
        BoringLayout.Metrics boring = ;
5216
        BoringLayout.Metrics hintBoring = ;
5218
        int des = -1;
5219
        boolean fromexisting = false;
5221
        if (widthMode == .) {
5222
            // Parent has told us how big to be. So be it.
5223
            width = widthSize;
5224
        } else {
5225
            if ( != null &&  == null) {
5226
                des = desired();
5227
            }
5229
            if (des < 0) {
5230
                boring = BoringLayout.isBoring(, , );
5231
                if (boring != null) {
5232
                     = boring;
5233
                }
5234
            } else {
5235
                fromexisting = true;
5236
            }
5238
            if (boring == null || boring == ) {
5239
                if (des < 0) {
5240
                    des = (int) FloatMath.ceil(Layout.getDesiredWidth(, ));
5241
                }
5243
                width = des;
5244
            } else {
5245
                width = boring.width;
5246
            }
5248
            final Drawables dr = ;
5249
            if (dr != null) {
5250
                width = Math.max(width, dr.mDrawableWidthTop);
5251
                width = Math.max(width, dr.mDrawableWidthBottom);
5252
            }
5254
            if ( != null) {
5255
                int hintDes = -1;
5256
                int hintWidth;
5258
                if ( != null &&  == null) {
5259
                    hintDes = desired();
5260
                }
5262
                if (hintDes < 0) {
5263
                    hintBoring = BoringLayout.isBoring(, , );
5264
                    if (hintBoring != null) {
5265
                         = hintBoring;
5266
                    }
5267
                }
5269
                if (hintBoring == null || hintBoring == ) {
5270
                    if (hintDes < 0) {
5271
                        hintDes = (int) FloatMath.ceil(
5272
                                Layout.getDesiredWidth(, ));
5273
                    }
5275
                    hintWidth = hintDes;
5276
                } else {
5277
                    hintWidth = hintBoring.width;
5278
                }
5280
                if (hintWidth > width) {
5281
                    width = hintWidth;
5282
                }
5283
            }
5285
            width += getCompoundPaddingLeft() + getCompoundPaddingRight();
5287
            if ( == ) {
5288
                width = Math.min(width,  * getLineHeight());
5289
            } else {
5290
                width = Math.min(width, );
5291
            }
5293
            if ( == ) {
5294
                width = Math.max(width,  * getLineHeight());
5295
            } else {
5296
                width = Math.max(width, );
5297
            }
5299
            // Check against our minimum width
5300
            width = Math.max(width, getSuggestedMinimumWidth());
5302
            if (widthMode == .) {
5303
                width = Math.min(widthSize, width);
5304
            }
5305
        }
5307
        int want = width - getCompoundPaddingLeft() - getCompoundPaddingRight();
5308
        int unpaddedWidth = want;
5309
        int hintWant = want;
5311
        if ()
5312
            want = ;
5314
        int hintWidth =  == null ? hintWant : .getWidth();
5316
        if ( == null) {
5317
            makeNewLayout(want, hintWant, boring, hintBoring,
5318
                          width - getCompoundPaddingLeft() - getCompoundPaddingRight(), false);
5319
        } else if ((.getWidth() != want) || (hintWidth != hintWant) ||
5320
                   (.getEllipsizedWidth() !=
5321
                        width - getCompoundPaddingLeft() - getCompoundPaddingRight())) {
5322
            if ( == null &&  == null &&
5323
                    want > .getWidth() &&
5324
                    ( instanceof BoringLayout ||
5325
                            (fromexisting && des >= 0 && des <= want))) {
5326
                .increaseWidthTo(want);
5327
            } else {
5328
                makeNewLayout(want, hintWant, boring, hintBoring,
5329
                              width - getCompoundPaddingLeft() - getCompoundPaddingRight(), false);
5330
            }
5331
        } else {
5332
            // Width has not changed.
5333
        }
5335
        if (heightMode == .) {
5336
            // Parent has told us how big to be. So be it.
5337
            height = heightSize;
5338
             = -1;
5339
        } else {
5340
            int desired = getDesiredHeight();
5342
            height = desired;
5343
             = desired;
5345
            if (heightMode == .) {
5346
                height = Math.min(desired, heightSize);
5347
            }
5348
        }
5350
        int unpaddedHeight = height - getCompoundPaddingTop() - getCompoundPaddingBottom();
5351
        if ( ==  && .getLineCount() > ) {
5352
            unpaddedHeight = Math.min(unpaddedHeight, .getLineTop());
5353
        }
5355
        /*
5356
         * We didn't let makeNewLayout() register to bring the cursor into view,
5357
         * so do it here if there is any possibility that it is needed.
5358
         */
5359
        if ( != null ||
5360
            .getWidth() > unpaddedWidth ||
5361
            .getHeight() > unpaddedHeight) {
5362
            registerForPreDraw();
5363
        } else {
5364
            scrollTo(0, 0);
5365
        }
5367
        setMeasuredDimension(width, height);
5368
    }
5370
    private int getDesiredHeight() {
5371
        return Math.max(
5372
                getDesiredHeight(, true),
5373
                getDesiredHeight(,  != null));
5374
    }
5376
    private int getDesiredHeight(Layout layout, boolean cap) {
5377
        if (layout == null) {
5378
            return 0;
5379
        }
5381
        int linecount = layout.getLineCount();
5382
        int pad = getCompoundPaddingTop() + getCompoundPaddingBottom();
5383
        int desired = layout.getLineTop(linecount);
5385
        final Drawables dr = ;
5386
        if (dr != null) {
5387
            desired = Math.max(desired, dr.mDrawableHeightLeft);
5388
            desired = Math.max(desired, dr.mDrawableHeightRight);
5389
        }
5391
        desired += pad;
5393
        if ( == ) {
5394
            /*
5395
             * Don't cap the hint to a certain number of lines.
5396
             * (Do cap it, though, if we have a maximum pixel height.)
5397
             */
5398
            if (cap) {
5399
                if (linecount > ) {
5400
                    desired = layout.getLineTop() +
5401
                              layout.getBottomPadding();
5403
                    if (dr != null) {
5404
                        desired = Math.max(desired, dr.mDrawableHeightLeft);
5405
                        desired = Math.max(desired, dr.mDrawableHeightRight);
5406
                    }
5408
                    desired += pad;
5409
                    linecount = ;
5410
                }
5411
            }
5412
        } else {
5413
            desired = Math.min(desired, );
5414
        }
5416
        if ( == ) {
5417
            if (linecount < ) {
5418
                desired += getLineHeight() * ( - linecount);
5419
            }
5420
        } else {
5421
            desired = Math.max(desired, );
5422
        }
5424
        // Check against our minimum height
5425
        desired = Math.max(desired, getSuggestedMinimumHeight());
5427
        return desired;
5428
    }

    
Check whether a change to the existing text layout requires a new view layout. 
5434
    private void checkForResize() {
5435
        boolean sizeChanged = false;
5437
        if ( != null) {
5438
            // Check if our width changed
5439
            if (. == .) {
5440
                sizeChanged = true;
5441
                invalidate();
5442
            }
5444
            // Check if our height changed
5445
            if (. == .) {
5446
                int desiredHeight = getDesiredHeight();
5448
                if (desiredHeight != this.getHeight()) {
5449
                    sizeChanged = true;
5450
                }
5451
            } else if (. == .) {
5452
                if ( >= 0) {
5453
                    int desiredHeight = getDesiredHeight();
5455
                    if (desiredHeight != ) {
5456
                        sizeChanged = true;
5457
                    }
5458
                }
5459
            }
5460
        }
5462
        if (sizeChanged) {
5463
            requestLayout();
5464
            // caller will have already invalidated
5465
        }
5466
    }

    
Check whether entirely new text requires a new view layout or merely a new text layout. 
5472
    private void checkForRelayout() {
5473
        // If we have a fixed width, we can just swap in a new text layout
5474
        // if the text height stays the same or if the view height is fixed.
5476
        if ((. != . ||
5477
                ( ==  &&  == )) &&
5478
                ( == null ||  != null) &&
5479
                ( -  - getCompoundPaddingLeft() - getCompoundPaddingRight() > 0)) {
5480
            // Static width, so try making a new text layout.
5482
            int oldht = .getHeight();
5483
            int want = .getWidth();
5484
            int hintWant =  == null ? 0 : .getWidth();
5486
            /*
5487
             * No need to bring the text into view, since the size is not
5488
             * changing (unless we do the requestLayout(), in which case it
5489
             * will happen at measure).
5490
             */
5491
            makeNewLayout(want, hintWant, , ,
5492
                           -  - getCompoundPaddingLeft() - getCompoundPaddingRight(),
5493
                          false);
5495
            if ( != ..) {
5496
                // In a fixed-height view, so use our new text layout.
5497
                if (. != . &&
5498
                    . != .) {
5499
                    invalidate();
5500
                    return;
5501
                }
5502
    
5503
                // Dynamic height, but height has stayed the same,
5504
                // so use our new text layout.
5505
                if (.getHeight() == oldht &&
5506
                    ( == null || .getHeight() == oldht)) {
5507
                    invalidate();
5508
                    return;
5509
                }
5510
            }
5512
            // We lose: the height has changed and we have a dynamic height.
5513
            // Request a new view layout using our new text layout.
5514
            requestLayout();
5515
            invalidate();
5516
        } else {
5517
            // Dynamic width, so we have no choice but to request a new
5518
            // view layout with a new text layout.
5520
            nullLayouts();
5521
            requestLayout();
5522
            invalidate();
5523
        }
5524
    }

    
Returns true if anything changed. 
5529
    private boolean bringTextIntoView() {
5530
        int line = 0;
5531
        if (( & .) == .) {
5532
            line = .getLineCount() - 1;
5533
        }
5535
        Layout.Alignment a = .getParagraphAlignment(line);
5536
        int dir = .getParagraphDirection(line);
5537
        int hspace =  -  - getCompoundPaddingLeft() - getCompoundPaddingRight();
5538
        int vspace =  -  - getExtendedPaddingTop() - getExtendedPaddingBottom();
5539
        int ht = .getHeight();
5541
        int scrollx, scrolly;
5543
        if (a == ..) {
5544
            /*
5545
             * Keep centered if possible, or, if it is too wide to fit,
5546
             * keep leading edge in view.
5547
             */
5549
            int left = (int) FloatMath.floor(.getLineLeft(line));
5550
            int right = (int) FloatMath.ceil(.getLineRight(line));
5552
            if (right - left < hspace) {
5553
                scrollx = (right + left) / 2 - hspace / 2;
5554
            } else {
5555
                if (dir < 0) {
5556
                    scrollx = right - hspace;
5557
                } else {
5558
                    scrollx = left;
5559
                }
5560
            }
5561
        } else if (a == ..) {
5562
            /*
5563
             * Keep leading edge in view.
5564
             */
5566
            if (dir < 0) {
5567
                int right = (int) FloatMath.ceil(.getLineRight(line));
5568
                scrollx = right - hspace;
5569
            } else {
5570
                scrollx = (int) FloatMath.floor(.getLineLeft(line));
5571
            }
5572
        } else /* a == Layout.Alignment.ALIGN_OPPOSITE */ {
5573
            /*
5574
             * Keep trailing edge in view.
5575
             */
5577
            if (dir < 0) {
5578
                scrollx = (int) FloatMath.floor(.getLineLeft(line));
5579
            } else {
5580
                int right = (int) FloatMath.ceil(.getLineRight(line));
5581
                scrollx = right - hspace;
5582
            }
5583
        }
5585
        if (ht < vspace) {
5586
            scrolly = 0;
5587
        } else {
5588
            if (( & .) == .) {
5589
                scrolly = ht - vspace;
5590
            } else {
5591
                scrolly = 0;
5592
            }
5593
        }
5595
        if (scrollx !=  || scrolly != ) {
5596
            scrollTo(scrollx, scrolly);
5597
            return true;
5598
        } else {
5599
            return false;
5600
        }
5601
    }

    
Move the point, specified by the offset, into the view if it is needed. This has to be called after layout. Returns true if anything changed. 
5607
    public boolean bringPointIntoView(int offset) {
5608
        boolean changed = false;
5610
        int line = .getLineForOffset(offset);
5612
        // FIXME: Is it okay to truncate this, or should we round?
5613
        final int x = (int).getPrimaryHorizontal(offset);
5614
        final int top = .getLineTop(line);
5615
        final int bottom = .getLineTop(line + 1);
5617
        int left = (int) FloatMath.floor(.getLineLeft(line));
5618
        int right = (int) FloatMath.ceil(.getLineRight(line));
5619
        int ht = .getHeight();
5621
        int grav;
5623
        switch (.getParagraphAlignment(line)) {
5624
            case :
5625
                grav = 1;
5626
                break;
5628
            case :
5629
                grav = -1;
5630
                break;
5632
            default:
5633
                grav = 0;
5634
        }
5636
        grav *= .getParagraphDirection(line);
5638
        int hspace =  -  - getCompoundPaddingLeft() - getCompoundPaddingRight();
5639
        int vspace =  -  - getExtendedPaddingTop() - getExtendedPaddingBottom();
5641
        int hslack = (bottom - top) / 2;
5642
        int vslack = hslack;
5644
        if (vslack > vspace / 4)
5645
            vslack = vspace / 4;
5646
        if (hslack > hspace / 4)
5647
            hslack = hspace / 4;
5649
        int hs = ;
5650
        int vs = ;
5652
        if (top - vs < vslack)
5653
            vs = top - vslack;
5654
        if (bottom - vs > vspace - vslack)
5655
            vs = bottom - (vspace - vslack);
5656
        if (ht - vs < vspace)
5657
            vs = ht - vspace;
5658
        if (0 - vs > 0)
5659
            vs = 0;
5661
        if (grav != 0) {
5662
            if (x - hs < hslack) {
5663
                hs = x - hslack;
5664
            }
5665
            if (x - hs > hspace - hslack) {
5666
                hs = x - (hspace - hslack);
5667
            }
5668
        }
5670
        if (grav < 0) {
5671
            if (left - hs > 0)
5672
                hs = left;
5673
            if (right - hs < hspace)
5674
                hs = right - hspace;
5675
        } else if (grav > 0) {
5676
            if (right - hs < hspace)
5677
                hs = right - hspace;
5678
            if (left - hs > 0)
5679
                hs = left;
5680
        } else /* grav == 0 */ {
5681
            if (right - left <= hspace) {
5682
                /*
5683
                 * If the entire text fits, center it exactly.
5684
                 */
5685
                hs = left - (hspace - (right - left)) / 2;
5686
            } else if (x > right - hslack) {
5687
                /*
5688
                 * If we are near the right edge, keep the right edge
5689
                 * at the edge of the view.
5690
                 */
5691
                hs = right - hspace;
5692
            } else if (x < left + hslack) {
5693
                /*
5694
                 * If we are near the left edge, keep the left edge
5695
                 * at the edge of the view.
5696
                 */
5697
                hs = left;
5698
            } else if (left > hs) {
5699
                /*
5700
                 * Is there whitespace visible at the left?  Fix it if so.
5701
                 */
5702
                hs = left;
5703
            } else if (right < hs + hspace) {
5704
                /*
5705
                 * Is there whitespace visible at the right?  Fix it if so.
5706
                 */
5707
                hs = right - hspace;
5708
            } else {
5709
                /*
5710
                 * Otherwise, float as needed.
5711
                 */
5712
                if (x - hs < hslack) {
5713
                    hs = x - hslack;
5714
                }
5715
                if (x - hs > hspace - hslack) {
5716
                    hs = x - (hspace - hslack);
5717
                }
5718
            }
5719
        }
5721
        if (hs !=  || vs != ) {
5722
            if ( == null) {
5723
                scrollTo(hs, vs);
5724
            } else {
5725
                long duration = AnimationUtils.currentAnimationTimeMillis() - ;
5726
                int dx = hs - ;
5727
                int dy = vs - ;
5729
                if (duration > ) {
5730
                    .startScroll(, , dx, dy);
5731
                    awakenScrollBars(.getDuration());
5732
                    invalidate();
5733
                } else {
5734
                    if (!.isFinished()) {
5735
                        .abortAnimation();
5736
                    }
5738
                    scrollBy(dx, dy);
5739
                }
5741
                 = AnimationUtils.currentAnimationTimeMillis();
5742
            }
5744
            changed = true;
5745
        }
5747
        if (isFocused()) {
5748
            // This offsets because getInterestingRect() is in terms of
5749
            // viewport coordinates, but requestRectangleOnScreen()
5750
            // is in terms of content coordinates.
5752
            Rect r = new Rect(x, top, x + 1, bottom);
5753
            getInterestingRect(r, line);
5754
            r.offset(, );
5756
            if (requestRectangleOnScreen(r)) {
5757
                changed = true;
5758
            }
5759
        }
5761
        return changed;
5762
    }

    
Move the cursor, if needed, so that it is at an offset that is visible to the user. This will not move the cursor if it represents more than one character (a selection range). This will only work if the TextView contains spannable text; otherwise it will do nothing.

Returns:
True if the cursor was actually moved, false otherwise.
5772
    public boolean moveCursorToVisibleOffset() {
5773
        if (!( instanceof Spannable)) {
5774
            return false;
5775
        }
5776
        int start = getSelectionStart();
5777
        int end = getSelectionEnd();
5778
        if (start != end) {
5779
            return false;
5780
        }
5781
        
5782
        // First: make sure the line is visible on screen:
5783
        
5784
        int line = .getLineForOffset(start);
5786
        final int top = .getLineTop(line);
5787
        final int bottom = .getLineTop(line + 1);
5788
        final int vspace =  -  - getExtendedPaddingTop() - getExtendedPaddingBottom();
5789
        int vslack = (bottom - top) / 2;
5790
        if (vslack > vspace / 4)
5791
            vslack = vspace / 4;
5792
        final int vs = ;
5794
        if (top < (vs+vslack)) {
5795
            line = .getLineForVertical(vs+vslack+(bottom-top));
5796
        } else if (bottom > (vspace+vs-vslack)) {
5797
            line = .getLineForVertical(vspace+vs-vslack-(bottom-top));
5798
        }
5799
        
5800
        // Next: make sure the character is visible on screen:
5801
        
5802
        final int hspace =  -  - getCompoundPaddingLeft() - getCompoundPaddingRight();
5803
        final int hs = ;
5804
        final int leftChar = .getOffsetForHorizontal(line, hs);
5805
        final int rightChar = .getOffsetForHorizontal(line, hspace+hs);
5806
        
5807
        int newStart = start;
5808
        if (newStart < leftChar) {
5809
            newStart = leftChar;
5810
        } else if (newStart > rightChar) {
5811
            newStart = rightChar;
5812
        }
5813
        
5814
        if (newStart != start) {
5815
            Selection.setSelection((Spannable), newStart);
5816
            return true;
5817
        }
5818
        
5819
        return false;
5820
    }
5822
    @Override
5823
    public void computeScroll() {
5824
        if ( != null) {
5825
            if (.computeScrollOffset()) {
5826
                 = .getCurrX();
5827
                 = .getCurrY();
5828
                postInvalidate();  // So we draw again
5829
            }
5830
        }
5831
    }
5833
    private void getInterestingRect(Rect r, int line) {
5836
        // Rectangle can can be expanded on first and last line to take
5837
        // padding into account.
5838
        // TODO Take left/right padding into account too?
5839
        if (line == 0) r.top -= getExtendedPaddingTop();
5840
        if (line == .getLineCount() - 1) r.bottom += getExtendedPaddingBottom();
5841
    }
5844
        final int horizontalOffset = viewportToContentHorizontalOffset();
5845
        r.left += horizontalOffset;
5846
        r.right += horizontalOffset;
5848
        final int verticalOffset = viewportToContentVerticalOffset();
5849
        r.top += verticalOffset;
5850
        r.bottom += verticalOffset;
5851
    }
5853
    private int viewportToContentHorizontalOffset() {
5854
        return getCompoundPaddingLeft() - ;
5855
    }
5857
    private int viewportToContentVerticalOffset() {
5858
        int offset = getExtendedPaddingTop() - ;
5859
        if (( & .) != .) {
5860
            offset += getVerticalOffset(false);
5861
        }
5862
        return offset;
5863
    }
5865
    @Override
5866
    public void debug(int depth) {
5867
        super.debug(depth);
5869
        String output = debugIndent(depth);
5870
        output += "frame={" +  + ", " +  + ", " + 
5871
                + ", " +  + "} scroll={" +  + ", " + 
5872
                + "} ";
5874
        if ( != null) {
5876
            output += "mText=\"" +  + "\" ";
5877
            if ( != null) {
5878
                output += "mLayout width=" + .getWidth()
5879
                        + " height=" + .getHeight();
5880
            }
5881
        } else {
5882
            output += "mText=NULL";
5883
        }
5884
        Log.d(, output);
5885
    }

    
Convenience for android.text.Selection.getSelectionStart(java.lang.CharSequence). 
5890
    @ViewDebug.ExportedProperty(category = "text")
5891
    public int getSelectionStart() {
5892
        return Selection.getSelectionStart(getText());
5893
    }

    
Convenience for android.text.Selection.getSelectionEnd(java.lang.CharSequence). 
5898
    @ViewDebug.ExportedProperty(category = "text")
5899
    public int getSelectionEnd() {
5900
        return Selection.getSelectionEnd(getText());
5901
    }

    
Return true iff there is a selection inside this text view. 
5906
    public boolean hasSelection() {
5907
        final int selectionStart = getSelectionStart();
5908
        final int selectionEnd = getSelectionEnd();
5910
        return selectionStart >= 0 && selectionStart != selectionEnd;
5911
    }

    
Sets the properties of this field (lines, horizontally scrolling, transformation method) to be for a single-line input.

Attr:
ref android.R.styleable#TextView_singleLine
5919
    public void setSingleLine() {
5920
        setSingleLine(true);
5921
    }

    
If true, sets the properties of this field (lines, horizontally scrolling, transformation method) to be for a single-line input; if false, restores these to the default conditions. Note that calling this with false restores default conditions, not necessarily those that were in effect prior to calling it with true.

Attr:
ref android.R.styleable#TextView_singleLine
5934
    public void setSingleLine(boolean singleLine) {
5936
                == .) {
5937
            if (singleLine) {
5938
                 &= ~.;
5939
            } else {
5940
                 |= .;
5941
            }
5942
        }
5943
        applySingleLine(singleLine, true);
5944
    }
5946
    private void applySingleLine(boolean singleLine, boolean applyTransformation) {
5947
         = singleLine;
5948
        if (singleLine) {
5949
            setLines(1);
5950
            setHorizontallyScrolling(true);
5951
            if (applyTransformation) {
5952
                setTransformationMethod(SingleLineTransformationMethod.
5953
                                        getInstance());
5954
            }
5955
        } else {
5956
            setMaxLines(.);
5957
            setHorizontallyScrolling(false);
5958
            if (applyTransformation) {
5959
                setTransformationMethod(null);
5960
            }
5961
        }
5962
    }
    
    
Causes words in the text that are longer than the view is wide to be ellipsized instead of broken in the middle. You may also want to setSingleLine() or setHorizontallyScrolling(boolean) to constrain the text to a single line. Use null to turn off ellipsizing.

Attr:
ref android.R.styleable#TextView_ellipsize
5973
    public void setEllipsize(TextUtils.TruncateAt where) {
5974
         = where;
5976
        if ( != null) {
5977
            nullLayouts();
5978
            requestLayout();
5979
            invalidate();
5980
        }
5981
    }

    
Sets how many times to repeat the marquee animation. Only applied if the TextView has marquee enabled. Set to -1 to repeat indefinitely.

Attr:
ref android.R.styleable#TextView_marqueeRepeatLimit
5989
    public void setMarqueeRepeatLimit(int marqueeLimit) {
5990
         = marqueeLimit;
5991
    }

    
Returns where, if anywhere, words that are longer than the view is wide should be ellipsized. 
5998
    public TextUtils.TruncateAt getEllipsize() {
5999
        return ;
6000
    }

    
Set the TextView so that when it takes focus, all the text is selected.

Attr:
ref android.R.styleable#TextView_selectAllOnFocus
6009
    public void setSelectAllOnFocus(boolean selectAllOnFocus) {
6010
         = selectAllOnFocus;
6012
        if (selectAllOnFocus && !( instanceof Spannable)) {
6013
            setText(, .);
6014
        }
6015
    }

    
Set whether the cursor is visible. The default is true.

Attr:
ref android.R.styleable#TextView_cursorVisible
6023
    public void setCursorVisible(boolean visible) {
6024
         = visible;
6025
        invalidate();
6027
        if (visible) {
6028
            makeBlink();
6029
        } else if ( != null) {
6030
            .removeCallbacks();
6031
        }
6033
        // InsertionPointCursorController depends on mCursorVisible
6034
        prepareCursorControllers();
6035
    }
6037
    private boolean canMarquee() {
6038
        int width = ( -  - getCompoundPaddingLeft() - getCompoundPaddingRight());
6039
        return width > 0 && .getLineWidth(0) > width;
6040
    }
6042
    private void startMarquee() {
6043
        // Do not ellipsize EditText
6044
        if ( != null) return;
6047
            return;
6048
        }
6050
        if (( == null || .isStopped()) && (isFocused() || isSelected()) &&
6051
                getLineCount() == 1 && canMarquee()) {
6053
            if ( == null)  = new Marquee(this);
6054
            .start();
6055
        }
6056
    }
6058
    private void stopMarquee() {
6059
        if ( != null && !.isStopped()) {
6060
            .stop();
6061
        }
6062
    }
6064
    private void startStopMarquee(boolean start) {
6065
        if ( == ..) {
6066
            if (start) {
6067
                startMarquee();
6068
            } else {
6069
                stopMarquee();
6070
            }
6071
        }
6072
    }
6074
    private static final class Marquee extends Handler {
6075
        // TODO: Add an option to configure this
6076
        private static final float MARQUEE_DELTA_MAX = 0.07f;
6077
        private static final int MARQUEE_DELAY = 1200;
6078
        private static final int MARQUEE_RESTART_DELAY = 1200;
6079
        private static final int MARQUEE_RESOLUTION = 1000 / 30;
6080
        private static final int MARQUEE_PIXELS_PER_SECOND = 30;
6082
        private static final byte MARQUEE_STOPPED = 0x0;
6083
        private static final byte MARQUEE_STARTING = 0x1;
6084
        private static final byte MARQUEE_RUNNING = 0x2;
6086
        private static final int MESSAGE_START = 0x1;
6087
        private static final int MESSAGE_TICK = 0x2;
6088
        private static final int MESSAGE_RESTART = 0x3;
6090
        private final WeakReference<TextView> mView;
6092
        private byte mStatus = ;
6093
        private final float mScrollUnit;
6094
        private float mMaxScroll;
6095
        float mMaxFadeScroll;
6096
        private float mGhostStart;
6097
        private float mGhostOffset;
6098
        private float mFadeStop;
6099
        private int mRepeatLimit;
6101
        float mScroll;
6103
        Marquee(TextView v) {
6104
            final float density = v.getContext().getResources().getDisplayMetrics().;
6105
             = ( * density) / ;
6106
             = new WeakReference<TextView>(v);
6107
        }
6109
        @Override
6110
        public void handleMessage(Message msg) {
6111
            switch (msg.what) {
6112
                case :
6113
                     = ;
6114
                    tick();
6115
                    break;
6116
                case :
6117
                    tick();
6118
                    break;
6119
                case :
6120
                    if ( == ) {
6121
                        if ( >= 0) {
6122
                            --;
6123
                        }
6124
                        start();
6125
                    }
6126
                    break;
6127
            }
6128
        }
6130
        void tick() {
6131
            if ( != ) {
6132
                return;
6133
            }
6135
            removeMessages();
6137
            final TextView textView = .get();
6138
            if (textView != null && (textView.isFocused() || textView.isSelected())) {
6139
                 += ;
6140
                if ( > ) {
6141
                     = ;
6142
                    sendEmptyMessageDelayed(, );
6143
                } else {
6144
                    sendEmptyMessageDelayed(, );
6145
                }
6146
                textView.invalidate();
6147
            }
6148
        }
6150
        void stop() {
6151
             = ;
6152
            removeMessages();
6153
            removeMessages();
6154
            removeMessages();
6155
            resetScroll();
6156
        }
6158
        private void resetScroll() {
6159
             = 0.0f;
6160
            final TextView textView = .get();
6161
            if (textView != null) textView.invalidate();
6162
        }
6164
        void start(int repeatLimit) {
6165
            if (repeatLimit == 0) {
6166
                stop();
6167
                return;
6168
            }
6169
             = repeatLimit;
6170
            final TextView textView = .get();
6171
            if (textView != null && textView.mLayout != null) {
6172
                 = ;
6173
                 = 0.0f;
6174
                final int textWidth = textView.getWidth() - textView.getCompoundPaddingLeft() -
6175
                        textView.getCompoundPaddingRight();
6176
                final float lineWidth = textView.mLayout.getLineWidth(0);
6177
                final float gap = textWidth / 3.0f;
6178
                 = lineWidth - textWidth + gap;
6179
                 =  + textWidth;
6180
                 = lineWidth + gap;
6181
                 = lineWidth + textWidth / 6.0f;
6182
                 =  + lineWidth + lineWidth;
6184
                textView.invalidate();
6185
                sendEmptyMessageDelayed(, );
6186
            }
6187
        }
6189
        float getGhostOffset() {
6190
            return ;
6191
        }
6193
        boolean shouldDrawLeftFade() {
6194
            return  <= ;
6195
        }
6197
        boolean shouldDrawGhost() {
6198
            return  ==  &&  > ;
6199
        }
6201
        boolean isRunning() {
6202
            return  == ;
6203
        }
6205
        boolean isStopped() {
6206
            return  == ;
6207
        }
6208
    }

    
This method is called when the text is changed, in case any subclasses would like to know.

Parameters:
text The text the TextView is displaying.
start The offset of the start of the range of the text that was modified.
before The offset of the former end of the range of the text that was modified. If text was simply inserted, this will be the same as start. If text was replaced with new text or deleted, the length of the old text was before-start.
after The offset of the end of the range of the text that was modified. If text was simply deleted, this will be the same as start. If text was replaced with new text or inserted, the length of the new text is after-start.
6228
    protected void onTextChanged(CharSequence text,
6229
                                 int start, int before, int after) {
6230
    }

    
This method is called when the selection has changed, in case any subclasses would like to know.

Parameters:
selStart The new selection start location.
selEnd The new selection end location.
6239
    protected void onSelectionChanged(int selStart, int selEnd) {
6240
    }
    
    
Adds a TextWatcher to the list of those whose methods are called whenever this TextView's text changes.

In 1.0, the android.text.TextWatcher.afterTextChanged(android.text.Editable) method was erroneously not called after setText(java.lang.CharSequence) calls. Now, doing setText(java.lang.CharSequence) if there are any text changed listeners forces the buffer type to Editable if it would not otherwise be and does call this method. 

6251
    public void addTextChangedListener(TextWatcher watcher) {
6252
        if ( == null) {
6253
             = new ArrayList<TextWatcher>();
6254
        }
6256
        .add(watcher);
6257
    }

    
Removes the specified TextWatcher from the list of those whose methods are called whenever this TextView's text changes. 
6264
    public void removeTextChangedListener(TextWatcher watcher) {
6265
        if ( != null) {
6266
            int i = .indexOf(watcher);
6268
            if (i >= 0) {
6269
                .remove(i);
6270
            }
6271
        }
6272
    }
6274
    private void sendBeforeTextChanged(CharSequence text, int start, int before,
6275
                                   int after) {
6276
        if ( != null) {
6277
            final ArrayList<TextWatcher> list = ;
6278
            final int count = list.size();
6279
            for (int i = 0; i < count; i++) {
6280
                list.get(i).beforeTextChanged(text, start, before, after);
6281
            }
6282
        }
6283
    }

    
Not private so it can be called from an inner class without going through a thunk. 
6289
    void sendOnTextChanged(CharSequence text, int start, int before,
6290
                                   int after) {
6291
        if ( != null) {
6292
            final ArrayList<TextWatcher> list = ;
6293
            final int count = list.size();
6294
            for (int i = 0; i < count; i++) {
6295
                list.get(i).onTextChanged(text, start, before, after);
6296
            }
6297
        }
6298
    }

    
Not private so it can be called from an inner class without going through a thunk. 
6304
    void sendAfterTextChanged(Editable text) {
6305
        if ( != null) {
6306
            final ArrayList<TextWatcher> list = ;
6307
            final int count = list.size();
6308
            for (int i = 0; i < count; i++) {
6309
                list.get(i).afterTextChanged(text);
6310
            }
6311
        }
6312
    }

    
Not private so it can be called from an inner class without going through a thunk. 
6318
    void handleTextChanged(CharSequence buffer, int start,
6319
            int before, int after) {
6320
        final InputMethodState ims = ;
6321
        if (ims == null || ims.mBatchEditNesting == 0) {
6322
            updateAfterEdit();
6323
        }
6324
        if (ims != null) {
6325
            ims.mContentChanged = true;
6326
            if (ims.mChangedStart < 0) {
6327
                ims.mChangedStart = start;
6328
                ims.mChangedEnd = start+before;
6329
            } else {
6330
                if (ims.mChangedStart > start) ims.mChangedStart = start;
6331
                if (ims.mChangedEnd < (start+before)) ims.mChangedEnd = start+before;
6332
            }
6333
            ims.mChangedDelta += after-before;
6334
        }
6335
        
6336
        sendOnTextChanged(buffer, start, before, after);
6337
        onTextChanged(buffer, start, before, after);
6339
        // Hide the controller if the amount of content changed
6340
        if (before != after) {
6341
            hideControllers();
6342
        }
6343
    }
    
    
Not private so it can be called from an inner class without going through a thunk. 
6349
    void spanChange(Spanned buf, Object what, int oldStart, int newStart,
6350
            int oldEnd, int newEnd) {
6351
        // XXX Make the start and end move together if this ends up
6352
        // spending too much time invalidating.
6354
        boolean selChanged = false;
6355
        int newSelStart=-1, newSelEnd=-1;
6356
        
6357
        final InputMethodState ims = ;
6358
        
6359
        if (what == .) {
6360
             = true;
6361
            selChanged = true;
6362
            newSelEnd = newStart;
6364
            if (!isFocused()) {
6365
                 = true;
6366
            }
6368
            if (oldStart >= 0 || newStart >= 0) {
6369
                invalidateCursor(Selection.getSelectionStart(buf), oldStart, newStart);
6370
                registerForPreDraw();
6372
                if (isFocused()) {
6373
                     = SystemClock.uptimeMillis();
6374
                    makeBlink();
6375
                }
6376
            }
6377
        }
6379
        if (what == .) {
6380
             = true;
6381
            selChanged = true;
6382
            newSelStart = newStart;
6384
            if (!isFocused()) {
6385
                 = true;
6386
            }
6388
            if (oldStart >= 0 || newStart >= 0) {
6389
                int end = Selection.getSelectionEnd(buf);
6390
                invalidateCursor(end, oldStart, newStart);
6391
            }
6392
        }
6394
        if (selChanged) {
6395
            if ((buf.getSpanFlags(what)&.) == 0) {
6396
                if (newSelStart < 0) {
6397
                    newSelStart = Selection.getSelectionStart(buf);
6398
                }
6399
                if (newSelEnd < 0) {
6400
                    newSelEnd = Selection.getSelectionEnd(buf);
6401
                }
6402
                onSelectionChanged(newSelStart, newSelEnd);
6403
            }
6404
        }
6405
        
6406
        if (what instanceof UpdateAppearance ||
6407
            what instanceof ParagraphStyle) {
6408
            if (ims == null || ims.mBatchEditNesting == 0) {
6409
                invalidate();
6410
                 = true;
6411
                checkForResize();
6412
            } else {
6413
                ims.mContentChanged = true;
6414
            }
6415
        }
6417
        if (MetaKeyKeyListener.isMetaTracker(buf, what)) {
6418
             = true;
6419
            if (ims != null && MetaKeyKeyListener.isSelectingMetaTracker(buf, what)) {
6420
                ims.mSelectionModeChanged = true;
6421
            }
6423
            if (Selection.getSelectionStart(buf) >= 0) {
6424
                if (ims == null || ims.mBatchEditNesting == 0) {
6425
                    invalidateCursor();
6426
                } else {
6427
                    ims.mCursorChanged = true;
6428
                }
6429
            }
6430
        }
6431
        
6432
        if (what instanceof ParcelableSpan) {
6433
            // If this is a span that can be sent to a remote process,
6434
            // the current extract editor would be interested in it.
6435
            if (ims != null && ims.mExtracting != null) {
6436
                if (ims.mBatchEditNesting != 0) {
6437
                    if (oldStart >= 0) {
6438
                        if (ims.mChangedStart > oldStart) {
6439
                            ims.mChangedStart = oldStart;
6440
                        }
6441
                        if (ims.mChangedStart > oldEnd) {
6442
                            ims.mChangedStart = oldEnd;
6443
                        }
6444
                    }
6445
                    if (newStart >= 0) {
6446
                        if (ims.mChangedStart > newStart) {
6447
                            ims.mChangedStart = newStart;
6448
                        }
6449
                        if (ims.mChangedStart > newEnd) {
6450
                            ims.mChangedStart = newEnd;
6451
                        }
6452
                    }
6453
                } else {
6454
                    if () Log.v(, "Span change outside of batch: "
6455
                            + oldStart + "-" + oldEnd + ","
6456
                            + newStart + "-" + newEnd + what);
6457
                    ims.mContentChanged = true;
6458
                }
6459
            }
6460
        }
6461
    }
6463
    private class ChangeWatcher
6464
    implements TextWatcher, SpanWatcher {
6466
        private CharSequence mBeforeText;
6468
        public void beforeTextChanged(CharSequence buffer, int start,
6469
                                      int before, int after) {
6470
            if () Log.v(, "beforeTextChanged start=" + start
6471
                    + " before=" + before + " after=" + after + ": " + buffer);
6473
            if (AccessibilityManager.getInstance().isEnabled()
6474
                    && !isPasswordInputType()) {
6475
                 = buffer.toString();
6476
            }
6478
            TextView.this.sendBeforeTextChanged(buffer, start, before, after);
6479
        }
6481
        public void onTextChanged(CharSequence buffer, int start,
6482
                                  int before, int after) {
6483
            if () Log.v(, "onTextChanged start=" + start
6484
                    + " before=" + before + " after=" + after + ": " + buffer);
6485
            TextView.this.handleTextChanged(buffer, start, before, after);
6487
            if (AccessibilityManager.getInstance().isEnabled() &&
6488
                    (isFocused() || isSelected() &&
6489
                    isShown())) {
6490
                sendAccessibilityEventTypeViewTextChanged(, start, before, after);
6491
                 = null;
6492
            }
6493
        }
6495
        public void afterTextChanged(Editable buffer) {
6496
            if () Log.v(, "afterTextChanged: " + buffer);
6497
            TextView.this.sendAfterTextChanged(buffer);
6499
            if (MetaKeyKeyListener.getMetaState(buffer,
6500
                                 .) != 0) {
6501
                MetaKeyKeyListener.stopSelecting(TextView.this, buffer);
6502
            }
6503
        }
6505
        public void onSpanChanged(Spannable buf,
6506
                                  Object what, int s, int e, int st, int en) {
6507
            if () Log.v(, "onSpanChanged s=" + s + " e=" + e
6508
                    + " st=" + st + " en=" + en + " what=" + what + ": " + buf);
6509
            TextView.this.spanChange(buf, what, s, st, e, en);
6510
        }
6512
        public void onSpanAdded(Spannable buf, Object what, int s, int e) {
6513
            if () Log.v(, "onSpanAdded s=" + s + " e=" + e
6514
                    + " what=" + what + ": " + buf);
6515
            TextView.this.spanChange(buf, what, -1, s, -1, e);
6516
        }
6518
        public void onSpanRemoved(Spannable buf, Object what, int s, int e) {
6519
            if () Log.v(, "onSpanRemoved s=" + s + " e=" + e
6520
                    + " what=" + what + ": " + buf);
6521
            TextView.this.spanChange(buf, what, s, -1, e, -1);
6522
        }
6523
    }
6525
    private void makeBlink() {
6526
        if (!) {
6527
            if ( != null) {
6528
                .removeCallbacks();
6529
            }
6531
            return;
6532
        }
6534
        if ( == null)
6535
             = new Blink(this);
6538
        .postAtTime(,  + );
6539
    }

    

Hide:
6544
    @Override
6545
    public void dispatchFinishTemporaryDetach() {
6546
         = true;
6547
        super.dispatchFinishTemporaryDetach();
6548
         = false;
6549
    }
6551
    @Override
6552
    public void onStartTemporaryDetach() {
6553
        super.onStartTemporaryDetach();
6554
        // Only track when onStartTemporaryDetach() is called directly,
6555
        // usually because this instance is an editable field in a list
6556
        if (!)  = true;
6557
    }
6558
    
6559
    @Override
6560
    public void onFinishTemporaryDetach() {
6561
        super.onFinishTemporaryDetach();
6562
        // Only track when onStartTemporaryDetach() is called directly,
6563
        // usually because this instance is an editable field in a list
6564
        if (!)  = false;
6565
    }
6566
    
6567
    @Override
6568
    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
6569
        if () {
6570
            // If we are temporarily in the detach state, then do nothing.
6571
            super.onFocusChanged(focused, direction, previouslyFocusedRect);
6572
            return;
6573
        }
6574
        
6575
         = SystemClock.uptimeMillis();
6577
        ensureEndedBatchEdit();
6579
        if (focused) {
6580
            int selStart = getSelectionStart();
6581
            int selEnd = getSelectionEnd();
6583
            if (! || (selStart < 0 || selEnd < 0)) {
6584
                // If a tap was used to give focus to that view, move cursor at tap position.
6585
                // Has to be done before onTakeFocus, which can be overloaded.
6586
                final int lastTapPosition = getLastTapPosition();
6587
                if (lastTapPosition >= 0) {
6588
                    Selection.setSelection((Spannable) , lastTapPosition);
6589
                }
6591
                if ( != null) {
6592
                    .onTakeFocus(this, (Spannable) , direction);
6593
                }
6595
                if () {
6596
                    Selection.setSelection((Spannable) , 0, .length());
6597
                }
6599
                // The DecorView does not have focus when the 'Done' ExtractEditText button is
6600
                // pressed. Since it is the ViewRoot's mView, it requests focus before
6601
                // ExtractEditText clears focus, which gives focus to the ExtractEditText.
6602
                // This special case ensure that we keep current selection in that case.
6603
                // It would be better to know why the DecorView does not have focus at that time.
6604
                if (((this instanceof ExtractEditText) || ) &&
6605
                        selStart >= 0 && selEnd >= 0) {
6606
                    /*
6607
                     * Someone intentionally set the selection, so let them
6608
                     * do whatever it is that they wanted to do instead of
6609
                     * the default on-focus behavior.  We reset the selection
6610
                     * here instead of just skipping the onTakeFocus() call
6611
                     * because some movement methods do something other than
6612
                     * just setting the selection in theirs and we still
6613
                     * need to go through that path.
6614
                     */
6615
                    Selection.setSelection((Spannable) , selStart, selEnd);
6616
                }
6617
                 = true;
6618
            }
6620
             = false;
6621
             = false;
6623
            if ( instanceof Spannable) {
6624
                Spannable sp = (Spannable) ;
6625
                MetaKeyKeyListener.resetMetaState(sp);
6626
            }
6628
            makeBlink();
6630
            if ( != null) {
6631
                showError();
6632
            }
6633
        } else {
6634
            if ( != null) {
6635
                hideError();
6636
            }
6637
            // Don't leave us in the middle of a batch edit.
6638
            onEndBatchEdit();
6640
            hideInsertionPointCursorController();
6641
            if (this instanceof ExtractEditText) {
6642
                // terminateTextSelectionMode would remove selection, which we want to keep when
6643
                // ExtractEditText goes out of focus.
6644
                 = false;
6645
            } else {
6646
                terminateTextSelectionMode();
6647
            }
6649
            if ( != null) {
6651
            }
6652
        }
6654
        startStopMarquee(focused);
6656
        if ( != null) {
6657
            .onFocusChanged(this, , focused, direction, previouslyFocusedRect);
6658
        }
6660
        super.onFocusChanged(focused, direction, previouslyFocusedRect);
6661
    }
6663
    private int getLastTapPosition() {
6664
        if ( != null) {
6665
            int lastTapPosition = ((SelectionModifierCursorController)
6666
                    ).getMinTouchOffset();
6667
            if (lastTapPosition >= 0) {
6668
                // Safety check, should not be possible.
6669
                if (lastTapPosition > .length()) {
6670
                    Log.e(, "Invalid tap focus position (" + lastTapPosition + " vs "
6671
                            + .length() + ")");
6672
                    lastTapPosition = .length();
6673
                }
6674
                return lastTapPosition;
6675
            }
6676
        }
6678
        return -1;
6679
    }
6681
    @Override
6682
    public void onWindowFocusChanged(boolean hasWindowFocus) {
6683
        super.onWindowFocusChanged(hasWindowFocus);
6685
        if (hasWindowFocus) {
6686
            if ( != null) {
6687
                .uncancel();
6689
                if (isFocused()) {
6690
                     = SystemClock.uptimeMillis();
6691
                    makeBlink();
6692
                }
6693
            }
6694
        } else {
6695
            if ( != null) {
6696
                .cancel();
6697
            }
6698
            // Don't leave us in the middle of a batch edit.
6699
            onEndBatchEdit();
6700
            if ( != null) {
6701
                . = false;
6702
            }
6703
            hideControllers();
6704
        }
6706
        startStopMarquee(hasWindowFocus);
6707
    }
6709
    @Override
6710
    protected void onVisibilityChanged(View changedView, int visibility) {
6711
        super.onVisibilityChanged(changedView, visibility);
6712
        if (visibility != ) {
6713
            hideControllers();
6714
        }
6715
    }

    
Use BaseInputConnection.removeComposingSpans() to remove any IME composing state from this text view. 
6722
    public void clearComposingText() {
6723
        if ( instanceof Spannable) {
6724
            BaseInputConnection.removeComposingSpans((Spannable));
6725
        }
6726
    }
6727
    
6728
    @Override
6729
    public void setSelected(boolean selected) {
6730
        boolean wasSelected = isSelected();
6732
        super.setSelected(selected);
6734
        if (selected != wasSelected &&  == ..) {
6735
            if (selected) {
6736
                startMarquee();
6737
            } else {
6738
                stopMarquee();
6739
            }
6740
        }
6741
    }
6743
    private void onTapUpEvent(int prevStart, int prevEnd) {
6744
        final int start = getSelectionStart();
6745
        final int end = getSelectionEnd();
6747
        if (start == end) {
6748
            if (start >= prevStart && start < prevEnd) {
6749
                // Restore previous selection
6750
                Selection.setSelection((Spannable), prevStart, prevEnd);
6752
                if (hasSelectionController() && !getSelectionController().isShowing()) {
6753
                    // If the anchors aren't showing, revive them.
6754
                    getSelectionController().show();
6755
                } else {
6756
                    // Tapping inside the selection displays the cut/copy/paste context menu
6757
                    // as long as the anchors are already showing.
6758
                    showContextMenu();
6759
                }
6760
                return;
6761
            } else {
6762
                // Tapping outside stops selection mode, if any
6763
                stopTextSelectionMode();
6765
                if (hasInsertionController() && .length() > 0) {
6766
                    getInsertionController().show();
6767
                }
6768
            }
6769
        } else if (hasSelection() && hasSelectionController()) {
6770
            getSelectionController().show();
6771
        }
6772
    }
6774
    class CommitSelectionReceiver extends ResultReceiver {
6775
        private final int mPrevStart, mPrevEnd;
6776
        
6777
        public CommitSelectionReceiver(int prevStart, int prevEnd) {
6778
            super(getHandler());
6779
             = prevStart;
6780
             = prevEnd;
6781
        }
6782
        
6783
        @Override
6784
        protected void onReceiveResult(int resultCode, Bundle resultData) {
6785
            // If this tap was actually used to show the IMM, leave cursor or selection unchanged
6786
            // by restoring its previous position.
6787
            if (resultCode == .) {
6788
                final int len = .length();
6789
                int start = Math.min(len, );
6790
                int end = Math.min(len, );
6791
                Selection.setSelection((Spannable), start, end);
6793
                if (hasSelection()) {
6794
                    startTextSelectionMode();
6795
                }
6796
            }
6797
        }
6798
    }
6799
    
6800
    @Override
6801
    public boolean onTouchEvent(MotionEvent event) {
6802
        final int action = event.getActionMasked();
6803
        if (action == .) {
6804
            if (hasInsertionController()) {
6805
                getInsertionController().onTouchEvent(event);
6806
            }
6807
            if (hasSelectionController()) {
6808
                getSelectionController().onTouchEvent(event);
6809
            }
6811
            // Reset this state; it will be re-set if super.onTouchEvent
6812
            // causes focus to move to the view.
6813
             = false;
6814
             = false;
6815
        }
6817
        final boolean superResult = super.onTouchEvent(event);
6819
        /*
6820
         * Don't handle the release after a long press, because it will
6821
         * move the selection away from whatever the menu action was
6822
         * trying to affect.
6823
         */
6824
        if ( && action == .) {
6825
             = false;
6826
            return superResult;
6827
        }
6829
        if (( != null || onCheckIsTextEditor()) &&  instanceof Spannable &&  != null) {
6830
            if (hasInsertionController()) {
6831
                getInsertionController().onTouchEvent(event);
6832
            }
6833
            if (hasSelectionController()) {
6834
                getSelectionController().onTouchEvent(event);
6835
            }
6837
            boolean handled = false;
6839
            // Save previous selection, in case this event is used to show the IME.
6840
            int oldSelStart = getSelectionStart();
6841
            int oldSelEnd = getSelectionEnd();
6843
            final int oldScrollX = ;
6844
            final int oldScrollY = ;
6845
            
6846
            if ( != null) {
6847
                handled |= .onTouchEvent(this, (Spannable) , event);
6848
            }
6850
            if (isTextEditable()) {
6851
                if ( != oldScrollX ||  != oldScrollY) {
6852
                    // Hide insertion anchor while scrolling. Leave selection.
6853
                    hideInsertionPointCursorController();
6854
                    if ( != null &&
6855
                            .isShowing()) {
6856
                        .updatePosition();
6857
                    }
6858
                }
6859
                if (action == . && isFocused() && !) {
6860
                    InputMethodManager imm = (InputMethodManager)
6861
                          getContext().getSystemService(.);
6863
                    CommitSelectionReceiver csr = null;
6864
                    if (getSelectionStart() != oldSelStart || getSelectionEnd() != oldSelEnd ||
6865
                            didTouchFocusSelect()) {
6866
                        csr = new CommitSelectionReceiver(oldSelStart, oldSelEnd);
6867
                    }
6869
                    handled |= imm.showSoftInput(this, 0, csr) && (csr != null);
6871
                    // Cannot be done by CommitSelectionReceiver, which might not always be called,
6872
                    // for instance when dealing with an ExtractEditText.
6873
                    onTapUpEvent(oldSelStart, oldSelEnd);
6874
                }
6875
            }
6877
            if (handled) {
6878
                return true;
6879
            }
6880
        }
6882
        return superResult;
6883
    }
6885
    private void prepareCursorControllers() {
6886
        boolean windowSupportsHandles = false;
6888
        ViewGroup.LayoutParams params = getRootView().getLayoutParams();
6889
        if (params instanceof WindowManager.LayoutParams) {
6890
            WindowManager.LayoutParams windowParams = (WindowManager.LayoutParams) params;
6891
            windowSupportsHandles = windowParams.type < ..
6892
                    || windowParams.type > ..;
6893
        }
6895
        // TODO Add an extra android:cursorController flag to disable the controller?
6896
         = windowSupportsHandles &&  &&  != null;
6897
         = windowSupportsHandles && textCanBeSelected() &&
6898
                 != null;
6900
        if (!) {
6901
             = null;
6902
        }
6904
        if (!) {
6905
            // Stop selection mode if the controller becomes unavailable.
6906
            stopTextSelectionMode();
6907
             = null;
6908
        }
6909
    }

    

Returns:
True iff this TextView contains a text that can be edited.
6914
    private boolean isTextEditable() {
6915
        return  instanceof Editable && onCheckIsTextEditor();
6916
    }

    
Returns true, only while processing a touch gesture, if the initial touch down event caused focus to move to the text view and as a result its selection changed. Only valid while processing the touch gesture of interest. 
6924
    public boolean didTouchFocusSelect() {
6925
        return ;
6926
    }
6927
    
6928
    @Override
6929
    public void cancelLongPress() {
6930
        super.cancelLongPress();
6931
         = true;
6932
    }
6933
    
6934
    @Override
6935
    public boolean onTrackballEvent(MotionEvent event) {
6936
        if ( != null &&  instanceof Spannable &&
6937
             != null) {
6938
            if (.onTrackballEvent(this, (Spannable) , event)) {
6939
                return true;
6940
            }
6941
        }
6943
        return super.onTrackballEvent(event);
6944
    }
6946
    public void setScroller(Scroller s) {
6947
         = s;
6948
    }
6950
    private static class Blink extends Handler implements Runnable {
6951
        private final WeakReference<TextView> mView;
6952
        private boolean mCancelled;
6954
        public Blink(TextView v) {
6955
             = new WeakReference<TextView>(v);
6956
        }
6958
        public void run() {
6959
            if () {
6960
                return;
6961
            }
6963
            removeCallbacks(Blink.this);
6965
            TextView tv = .get();
6967
            if (tv != null && tv.isFocused()) {
6968
                int st = tv.getSelectionStart();
6969
                int en = tv.getSelectionEnd();
6971
                if (st == en && st >= 0 && en >= 0) {
6972
                    if (tv.mLayout != null) {
6973
                        tv.invalidateCursorPath();
6974
                    }
6976
                    postAtTime(this, SystemClock.uptimeMillis() + );
6977
                }
6978
            }
6979
        }
6981
        void cancel() {
6982
            if (!) {
6983
                removeCallbacks(Blink.this);
6984
                 = true;
6985
            }
6986
        }
6988
        void uncancel() {
6989
             = false;
6990
        }
6991
    }
6993
    @Override
6994
    protected float getLeftFadingEdgeStrength() {
6995
        if ( == ..) {
6996
            if ( != null && !.isStopped()) {
6997
                final Marquee marquee = ;
6998
                if (marquee.shouldDrawLeftFade()) {
6999
                    return marquee.mScroll / getHorizontalFadingEdgeLength();
7000
                } else {
7001
                    return 0.0f;
7002
                }
7003
            } else if (getLineCount() == 1) {
7004
                switch ( & .) {
7005
                    case .:
7006
                        return 0.0f;
7007
                    case .:
7008
                        return (.getLineRight(0) - ( - ) -
7009
                                getCompoundPaddingLeft() - getCompoundPaddingRight() -
7010
                                .getLineLeft(0)) / getHorizontalFadingEdgeLength();
7011
                    case .:
7012
                        return 0.0f;
7013
                }
7014
            }
7015
        }
7016
        return super.getLeftFadingEdgeStrength();
7017
    }
7019
    @Override
7020
    protected float getRightFadingEdgeStrength() {
7021
        if ( == ..) {
7022
            if ( != null && !.isStopped()) {
7023
                final Marquee marquee = ;
7024
                return (marquee.mMaxFadeScroll - marquee.mScroll) / getHorizontalFadingEdgeLength();
7025
            } else if (getLineCount() == 1) {
7026
                switch ( & .) {
7027
                    case .:
7028
                        final int textWidth = ( - ) - getCompoundPaddingLeft() -
7029
                                getCompoundPaddingRight();
7030
                        final float lineWidth = .getLineWidth(0);
7031
                        return (lineWidth - textWidth) / getHorizontalFadingEdgeLength();
7032
                    case .:
7033
                        return 0.0f;
7034
                    case .:
7035
                        return (.getLineWidth(0) - (( - ) -
7036
                                getCompoundPaddingLeft() - getCompoundPaddingRight())) /
7037
                                getHorizontalFadingEdgeLength();
7038
                }
7039
            }
7040
        }
7041
        return super.getRightFadingEdgeStrength();
7042
    }
7044
    @Override
7045
    protected int computeHorizontalScrollRange() {
7046
        if ( != null)
7047
            return .getWidth();
7049
        return super.computeHorizontalScrollRange();
7050
    }
7052
    @Override
7053
    protected int computeVerticalScrollRange() {
7054
        if ( != null)
7055
            return .getHeight();
7057
        return super.computeVerticalScrollRange();
7058
    }
7060
    @Override
7061
    protected int computeVerticalScrollExtent() {
7062
        return getHeight() - getCompoundPaddingTop() - getCompoundPaddingBottom();
7063
    }
7064
    
7065
    public enum BufferType {
7066
        NORMAL, SPANNABLE, EDITABLE,
7067
    }

    
Returns the TextView_textColor attribute from the Resources.StyledAttributes, if set, or the TextAppearance_textColor from the TextView_textAppearance attribute, if TextView_textColor was not set directly. 
7075
    public static ColorStateList getTextColors(Context context, TypedArray attrs) {
7076
        ColorStateList colors;
7077
        colors = attrs.getColorStateList(.....
7078
                                         );
7080
        if (colors == null) {
7081
            int ap = attrs.getResourceId(.....
7082
                                         , -1);
7083
            if (ap != -1) {
7084
                TypedArray appearance;
7085
                appearance = context.obtainStyledAttributes(ap,
7086
                                            .....);
7087
                colors = appearance.getColorStateList(.....
7088
                                                  );
7089
                appearance.recycle();
7090
            }
7091
        }
7093
        return colors;
7094
    }

    
Returns the default color from the TextView_textColor attribute from the AttributeSet, if set, or the default color from the TextAppearance_textColor from the TextView_textAppearance attribute, if TextView_textColor was not set directly. 
7102
    public static int getTextColor(Context context,
7103
                                   TypedArray attrs,
7104
                                   int def) {
7105
        ColorStateList colors = getTextColors(context, attrs);
7107
        if (colors == null) {
7108
            return def;
7109
        } else {
7110
            return colors.getDefaultColor();
7111
        }
7112
    }
7114
    @Override
7115
    public boolean onKeyShortcut(int keyCode, KeyEvent event) {
7116
        switch (keyCode) {
7117
        case .:
7118
            if (canSelectText()) {
7119
                return onTextContextMenuItem();
7120
            }
7122
            break;
7124
        case .:
7125
            if (canCut()) {
7126
                return onTextContextMenuItem();
7127
            }
7129
            break;
7131
        case .:
7132
            if (canCopy()) {
7133
                return onTextContextMenuItem();
7134
            }
7136
            break;
7138
        case .:
7139
            if (canPaste()) {
7140
                return onTextContextMenuItem();
7141
            }
7143
            break;
7144
        }
7146
        return super.onKeyShortcut(keyCode, event);
7147
    }
7149
    private boolean canSelectText() {
7150
        return textCanBeSelected() && .length() != 0;
7151
    }
7153
    private boolean textCanBeSelected() {
7154
        // prepareCursorController() relies on this method.
7155
        // If you change this condition, make sure prepareCursorController is called anywhere
7156
        // the value of this condition might be changed.
7157
        return ( instanceof Spannable &&
7158
                 != null &&
7159
                .canSelectArbitrarily());
7160
    }
7162
    private boolean canCut() {
7163
        if (hasPasswordTransformationMethod()) {
7164
            return false;
7165
        }
7167
        if (.length() > 0 && hasSelection()) {
7168
            if ( instanceof Editable &&  != null) {
7169
                return true;
7170
            }
7171
        }
7173
        return false;
7174
    }
7176
    private boolean canCopy() {
7177
        if (hasPasswordTransformationMethod()) {
7178
            return false;
7179
        }
7181
        if (.length() > 0 && hasSelection()) {
7182
            return true;
7183
        }
7185
        return false;
7186
    }
7188
    private boolean canPaste() {
7189
        return ( instanceof Editable &&
7190
                 != null &&
7191
                getSelectionStart() >= 0 &&
7192
                getSelectionEnd() >= 0 &&
7194
                hasText());
7195
    }

    
Returns the offsets delimiting the 'word' located at position offset.

Parameters:
offset An offset in the text.
Returns:
The offsets for the start and end of the word located at offset. The two ints offsets are packed in a long, with the starting offset shifted by 32 bits. Returns a negative value if no valid word was found.
7205
    private long getWordLimitsAt(int offset) {
7206
        /*
7207
         * Quick return if the input type is one where adding words
7208
         * to the dictionary doesn't make any sense.
7209
         */
7210
        int klass =  & .;
7211
        if (klass == . ||
7212
            klass == . ||
7213
            klass == .) {
7214
            return -1;
7215
        }
7217
        int variation =  & .;
7218
        if (variation == . ||
7219
            variation == . ||
7220
            variation == . ||
7221
            variation == . ||
7222
            variation == .) {
7223
            return -1;
7224
        }
7226
        int len = .length();
7227
        int end = Math.min(offset, len);
7229
        if (end < 0) {
7230
            return -1;
7231
        }
7233
        int start = end;
7235
        for (; start > 0; start--) {
7236
            char c = .charAt(start - 1);
7237
            int type = Character.getType(c);
7239
            if (c != '\'' &&
7240
                type != . &&
7241
                type != . &&
7242
                type != . &&
7243
                type != . &&
7244
                type != .) {
7245
                break;
7246
            }
7247
        }
7249
        for (; end < len;