content: /*
   * Copyright (C) 2008 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.text;
  
  /**
   * Bit definitions for an integer defining the basic content type of text
   * held in an {@link Editable} object. Supported classes may be combined
   * with variations and flags to indicate desired behaviors.
   *
   * <h3>Examples</h3>
   *
   * <dl>
   * <dt>A password field with the password visible to the user:
   * <dd>inputType = TYPE_CLASS_TEXT |
   *     TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
   *
   * <dt>A multi-line postal address with automatic capitalization:
   * <dd>inputType = TYPE_CLASS_TEXT |
   *     TYPE_TEXT_VARIATION_POSTAL_ADDRESS |
   *     TYPE_TEXT_FLAG_MULTI_LINE
   *
   * <dt>A time field:
   * <dd>inputType = TYPE_CLASS_DATETIME |
   *     TYPE_DATETIME_VARIATION_TIME
   * </dl>
   */
  public interface InputType {
      /**
       * Mask of bits that determine the overall class
       * of text being given.  Currently supported classes are:
       * {@link #TYPE_CLASS_TEXT}, {@link #TYPE_CLASS_NUMBER},
       * {@link #TYPE_CLASS_PHONE}, {@link #TYPE_CLASS_DATETIME}.
       * <p>IME authors: If the class is not one you
       * understand, assume {@link #TYPE_CLASS_TEXT} with NO variation
       * or flags.<p>
       */
      public static final int TYPE_MASK_CLASS = 0x0000000f;
  
      /**
       * Mask of bits that determine the variation of
       * the base content class.
       */
      public static final int TYPE_MASK_VARIATION = 0x00000ff0;
  
      /**
       * Mask of bits that provide addition bit flags
       * of options.
       */
      public static final int TYPE_MASK_FLAGS = 0x00fff000;
  
      /**
       * Special content type for when no explicit type has been specified.
       * This should be interpreted to mean that the target input connection
       * is not rich, it can not process and show things like candidate text nor
       * retrieve the current text, so the input method will need to run in a
       * limited "generate key events" mode, if it supports it. Note that some
       * input methods may not support it, for example a voice-based input
       * method will likely not be able to generate key events even if this
       * flag is set.
       */
      public static final int TYPE_NULL = 0x00000000;
  
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
  
      /**
       * Class for normal text.  This class supports the following flags (only
       * one of which should be set):
       * {@link #TYPE_TEXT_FLAG_CAP_CHARACTERS},
       * {@link #TYPE_TEXT_FLAG_CAP_WORDS}, and.
       * {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}.  It also supports the
       * following variations:
       * {@link #TYPE_TEXT_VARIATION_NORMAL}, and
       * {@link #TYPE_TEXT_VARIATION_URI}.  If you do not recognize the
       * variation, normal should be assumed.
       */
      public static final int TYPE_CLASS_TEXT = 0x00000001;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: capitalize all characters.  Overrides
       * {@link #TYPE_TEXT_FLAG_CAP_WORDS} and
       * {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}.  This value is explicitly defined
       * to be the same as {@link TextUtils#CAP_MODE_CHARACTERS}. Of course,
       * this only affects languages where there are upper-case and lower-case letters.
       */
      public static final int TYPE_TEXT_FLAG_CAP_CHARACTERS = 0x00001000;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of
       * every word.  Overrides {@link #TYPE_TEXT_FLAG_CAP_SENTENCES}.  This
       * value is explicitly defined
       * to be the same as {@link TextUtils#CAP_MODE_WORDS}. Of course,
       * this only affects languages where there are upper-case and lower-case letters.
       */
      public static final int TYPE_TEXT_FLAG_CAP_WORDS = 0x00002000;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: capitalize the first character of
       * each sentence.  This value is explicitly defined
       * to be the same as {@link TextUtils#CAP_MODE_SENTENCES}. For example
       * in English it means to capitalize after a period and a space (note that other
       * languages may have different characters for period, or not use spaces,
       * or use different grammatical rules). Of course,
       * this only affects languages where there are upper-case and lower-case letters.
       */
      public static final int TYPE_TEXT_FLAG_CAP_SENTENCES = 0x00004000;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: the user is entering free-form
       * text that should have auto-correction applied to it. Without this flag,
       * the IME will not try to correct typos. You should always set this flag
       * unless you really expect users to type non-words in this field, for
       * example to choose a name for a character in a game.
       * Contrast this with {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE} and
       * {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:
       * {@code TYPE_TEXT_FLAG_AUTO_CORRECT} means that the IME will try to
       * auto-correct typos as the user is typing, but does not define whether
       * the IME offers an interface to show suggestions.
       */
      public static final int TYPE_TEXT_FLAG_AUTO_CORRECT = 0x00008000;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: the text editor (which means
       * the application) is performing auto-completion of the text being entered
       * based on its own semantics, which it will present to the user as they type.
       * This generally means that the input method should not be showing
       * candidates itself, but can expect the editor to supply its own
       * completions/candidates from
       * {@link android.view.inputmethod.InputMethodSession#displayCompletions
       * InputMethodSession.displayCompletions()} as a result of the editor calling
       * {@link android.view.inputmethod.InputMethodManager#displayCompletions
       * InputMethodManager.displayCompletions()}.
       * Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and
       * {@link #TYPE_TEXT_FLAG_NO_SUGGESTIONS}:
       * {@code TYPE_TEXT_FLAG_AUTO_COMPLETE} means the editor should show an
       * interface for displaying suggestions, but instead of supplying its own
       * it will rely on the Editor to pass completions/corrections.
       */
      public static final int TYPE_TEXT_FLAG_AUTO_COMPLETE = 0x00010000;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: multiple lines of text can be
       * entered into the field.  If this flag is not set, the text field
       * will be constrained to a single line. The IME may also choose not to
       * display an enter key when this flag is not set, as there should be no
       * need to create new lines.
       */
      public static final int TYPE_TEXT_FLAG_MULTI_LINE = 0x00020000;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: the regular text view associated
       * with this should not be multi-line, but when a fullscreen input method
       * is providing text it should use multiple lines if it can.
       */
      public static final int TYPE_TEXT_FLAG_IME_MULTI_LINE = 0x00040000;
  
      /**
       * Flag for {@link #TYPE_CLASS_TEXT}: the input method does not need to
       * display any dictionary-based candidates. This is useful for text views that
       * do not contain words from the language and do not benefit from any
       * dictionary-based completions or corrections. It overrides the
       * {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} value when set.
       * Please avoid using this unless you are certain this is what you want.
       * Many input methods need suggestions to work well, for example the ones
       * based on gesture typing. Consider clearing
       * {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} instead if you just do not
       * want the IME to correct typos.
       * Note the contrast with {@link #TYPE_TEXT_FLAG_AUTO_CORRECT} and
       * {@link #TYPE_TEXT_FLAG_AUTO_COMPLETE}:
       * {@code TYPE_TEXT_FLAG_NO_SUGGESTIONS} means the IME does not need to
       * show an interface to display suggestions. Most IMEs will also take this to
       * mean they do not need to try to auto-correct what the user is typing.
       */
      public static final int TYPE_TEXT_FLAG_NO_SUGGESTIONS = 0x00080000;
  
      // ----------------------------------------------------------------------
  
      /**
       * Default variation of {@link #TYPE_CLASS_TEXT}: plain old normal text.
       */
      public static final int TYPE_TEXT_VARIATION_NORMAL = 0x00000000;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering a URI.
       */
      public static final int TYPE_TEXT_VARIATION_URI = 0x00000010;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering an e-mail address.
       */
      public static final int TYPE_TEXT_VARIATION_EMAIL_ADDRESS = 0x00000020;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering the subject line of
       * an e-mail.
       */
      public static final int TYPE_TEXT_VARIATION_EMAIL_SUBJECT = 0x00000030;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering a short, possibly informal
       * message such as an instant message or a text message.
       */
      public static final int TYPE_TEXT_VARIATION_SHORT_MESSAGE = 0x00000040;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering the content of a long, possibly
       * formal message such as the body of an e-mail.
       */
      public static final int TYPE_TEXT_VARIATION_LONG_MESSAGE = 0x00000050;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering the name of a person.
       */
      public static final int TYPE_TEXT_VARIATION_PERSON_NAME = 0x00000060;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering a postal mailing address.
       */
      public static final int TYPE_TEXT_VARIATION_POSTAL_ADDRESS = 0x00000070;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering a password.
       */
      public static final int TYPE_TEXT_VARIATION_PASSWORD = 0x00000080;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering a password, which should
       * be visible to the user.
       */
      public static final int TYPE_TEXT_VARIATION_VISIBLE_PASSWORD = 0x00000090;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering text inside of a web form.
       */
      public static final int TYPE_TEXT_VARIATION_WEB_EDIT_TEXT = 0x000000a0;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering text to filter contents
       * of a list etc.
       */
      public static final int TYPE_TEXT_VARIATION_FILTER = 0x000000b0;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering text for phonetic
       * pronunciation, such as a phonetic name field in contacts. This is mostly
       * useful for languages where one spelling may have several phonetic
       * readings, like Japanese.
       */
      public static final int TYPE_TEXT_VARIATION_PHONETIC = 0x000000c0;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering e-mail address inside
       * of a web form.  This was added in
       * {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An IME must target
       * this API version or later to see this input type; if it doesn't, a request
       * for this type will be seen as {@link #TYPE_TEXT_VARIATION_EMAIL_ADDRESS}
       * when passed through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
       * EditorInfo.makeCompatible(int)}.
       */
      public static final int TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS = 0x000000d0;
  
      /**
       * Variation of {@link #TYPE_CLASS_TEXT}: entering password inside
       * of a web form.  This was added in
       * {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An IME must target
       * this API version or later to see this input type; if it doesn't, a request
       * for this type will be seen as {@link #TYPE_TEXT_VARIATION_PASSWORD}
       * when passed through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
       * EditorInfo.makeCompatible(int)}.
       */
      public static final int TYPE_TEXT_VARIATION_WEB_PASSWORD = 0x000000e0;
  
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
  
      /**
       * Class for numeric text.  This class supports the following flags:
       * {@link #TYPE_NUMBER_FLAG_SIGNED} and
       * {@link #TYPE_NUMBER_FLAG_DECIMAL}.  It also supports the following
       * variations: {@link #TYPE_NUMBER_VARIATION_NORMAL} and
       * {@link #TYPE_NUMBER_VARIATION_PASSWORD}.
       * <p>IME authors: If you do not recognize
       * the variation, normal should be assumed.</p>
       */
      public static final int TYPE_CLASS_NUMBER = 0x00000002;
  
      /**
       * Flag of {@link #TYPE_CLASS_NUMBER}: the number is signed, allowing
       * a positive or negative sign at the start.
       */
      public static final int TYPE_NUMBER_FLAG_SIGNED = 0x00001000;
  
      /**
       * Flag of {@link #TYPE_CLASS_NUMBER}: the number is decimal, allowing
       * a decimal point to provide fractional values.
       */
      public static final int TYPE_NUMBER_FLAG_DECIMAL = 0x00002000;
  
      // ----------------------------------------------------------------------
  
      /**
       * Default variation of {@link #TYPE_CLASS_NUMBER}: plain normal
       * numeric text.  This was added in
       * {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An IME must target
       * this API version or later to see this input type; if it doesn't, a request
       * for this type will be dropped when passed through
       * {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
       * EditorInfo.makeCompatible(int)}.
       */
      public static final int TYPE_NUMBER_VARIATION_NORMAL = 0x00000000;
  
      /**
       * Variation of {@link #TYPE_CLASS_NUMBER}: entering a numeric password.
       * This was added in {@link android.os.Build.VERSION_CODES#HONEYCOMB}.  An
       * IME must target this API version or later to see this input type; if it
       * doesn't, a request for this type will be dropped when passed
       * through {@link android.view.inputmethod.EditorInfo#makeCompatible(int)
       * EditorInfo.makeCompatible(int)}.
       */
      public static final int TYPE_NUMBER_VARIATION_PASSWORD = 0x00000010;
  
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
  
      /**
       * Class for a phone number.  This class currently supports no variations
       * or flags.
       */
      public static final int TYPE_CLASS_PHONE = 0x00000003;
  
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
      // ----------------------------------------------------------------------
  
      /**
       * Class for dates and times.  It supports the
       * following variations:
       * {@link #TYPE_DATETIME_VARIATION_NORMAL}
       * {@link #TYPE_DATETIME_VARIATION_DATE}, and
       * {@link #TYPE_DATETIME_VARIATION_TIME}.
       */
      public static final int TYPE_CLASS_DATETIME = 0x00000004;
  
      /**
       * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
       * both a date and time.
       */
      public static final int TYPE_DATETIME_VARIATION_NORMAL = 0x00000000;
  
      /**
       * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
       * only a date.
       */
      public static final int TYPE_DATETIME_VARIATION_DATE = 0x00000010;
  
      /**
       * Default variation of {@link #TYPE_CLASS_DATETIME}: allows entering
       * only a time.
       */
      public static final int TYPE_DATETIME_VARIATION_TIME = 0x00000020;
  }
  