Home | History | Annotate | Download | only in internal 
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
      5  * use this file except in compliance with the License. You may obtain a copy of
      6  * 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, WITHOUT
     12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
     13  * License for the specific language governing permissions and limitations under
     14  * the License.
     15  */
     16 
     17 package com.android.inputmethod.keyboard.internal;
     18 
     19 import android.util.Log;
     20 
     21 import com.android.inputmethod.keyboard.KeyboardSwitcher;
     22 
     23 public class KeyboardShiftState {
     24     private static final String TAG = KeyboardShiftState.class.getSimpleName();
     25     private static final boolean DEBUG = KeyboardSwitcher.DEBUG_STATE;
     26 
     27     private static final int NORMAL = 0;
     28     private static final int MANUAL_SHIFTED = 1;
     29     private static final int MANUAL_SHIFTED_FROM_AUTO = 2;
     30     private static final int AUTO_SHIFTED = 3;
     31     private static final int SHIFT_LOCKED = 4;
     32     private static final int SHIFT_LOCK_SHIFTED = 5;
     33 
     34     private int mState = NORMAL;
     35 
     36     public boolean setShifted(boolean newShiftState) {
     37         final int oldState = mState;
     38         if (newShiftState) {
     39             switch (oldState) {
     40             case NORMAL:
     41                 mState = MANUAL_SHIFTED;
     42                 break;
     43             case AUTO_SHIFTED:
     44                 mState = MANUAL_SHIFTED_FROM_AUTO;
     45                 break;
     46             case SHIFT_LOCKED:
     47                 mState = SHIFT_LOCK_SHIFTED;
     48                 break;
     49             }
     50         } else {
     51             switch (oldState) {
     52             case MANUAL_SHIFTED:
     53             case MANUAL_SHIFTED_FROM_AUTO:
     54             case AUTO_SHIFTED:
     55                 mState = NORMAL;
     56                 break;
     57             case SHIFT_LOCK_SHIFTED:
     58                 mState = SHIFT_LOCKED;
     59                 break;
     60             }
     61         }
     62         if (DEBUG)
     63             Log.d(TAG, "setShifted(" + newShiftState + "): " + toString(oldState) + " > " + this);
     64         return mState != oldState;
     65     }
     66 
     67     public void setShiftLocked(boolean newShiftLockState) {
     68         final int oldState = mState;
     69         if (newShiftLockState) {
     70             switch (oldState) {
     71             case NORMAL:
     72             case MANUAL_SHIFTED:
     73             case MANUAL_SHIFTED_FROM_AUTO:
     74             case AUTO_SHIFTED:
     75                 mState = SHIFT_LOCKED;
     76                 break;
     77             }
     78         } else {
     79             switch (oldState) {
     80             case SHIFT_LOCKED:
     81             case SHIFT_LOCK_SHIFTED:
     82                 mState = NORMAL;
     83                 break;
     84             }
     85         }
     86         if (DEBUG)
     87             Log.d(TAG, "setShiftLocked(" + newShiftLockState + "): " + toString(oldState)
     88                     + " > " + this);
     89     }
     90 
     91     public void setAutomaticTemporaryUpperCase() {
     92         final int oldState = mState;
     93         mState = AUTO_SHIFTED;
     94         if (DEBUG)
     95             Log.d(TAG, "setAutomaticTemporaryUpperCase: " + toString(oldState) + " > " + this);
     96     }
     97 
     98     public boolean isShiftedOrShiftLocked() {
     99         return mState != NORMAL;
    100     }
    101 
    102     public boolean isShiftLocked() {
    103         return mState == SHIFT_LOCKED || mState == SHIFT_LOCK_SHIFTED;
    104     }
    105 
    106     public boolean isShiftLockShifted() {
    107         return mState == SHIFT_LOCK_SHIFTED;
    108     }
    109 
    110     public boolean isAutomaticTemporaryUpperCase() {
    111         return mState == AUTO_SHIFTED;
    112     }
    113 
    114     public boolean isManualTemporaryUpperCase() {
    115         return mState == MANUAL_SHIFTED || mState == MANUAL_SHIFTED_FROM_AUTO
    116                 || mState == SHIFT_LOCK_SHIFTED;
    117     }
    118 
    119     public boolean isManualTemporaryUpperCaseFromAuto() {
    120         return mState == MANUAL_SHIFTED_FROM_AUTO;
    121     }
    122 
    123     @Override
    124     public String toString() {
    125         return toString(mState);
    126     }
    127 
    128     private static String toString(int state) {
    129         switch (state) {
    130         case NORMAL: return "NORMAL";
    131         case MANUAL_SHIFTED: return "MANUAL_SHIFTED";
    132         case MANUAL_SHIFTED_FROM_AUTO: return "MANUAL_SHIFTED_FROM_AUTO";
    133         case AUTO_SHIFTED: return "AUTO_SHIFTED";
    134         case SHIFT_LOCKED: return "SHIFT_LOCKED";
    135         case SHIFT_LOCK_SHIFTED: return "SHIFT_LOCK_SHIFTED";
    136         default: return "UKNOWN";
    137         }
    138     }
    139 }
    140