Home | History | Annotate | Download | only in configurations 
      1 /*
      2  * Copyright (C) 2007 The Android Open Source Project
      3  *
      4  * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php
      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 com.android.ide.eclipse.adt.internal.resources.configurations;
     18 
     19 import com.android.ide.eclipse.adt.internal.editors.IconFactory;
     20 import com.android.sdklib.IAndroidTarget;
     21 
     22 import org.eclipse.swt.graphics.Image;
     23 
     24 
     25 /**
     26  * Resource Qualifier for Touch Screen type.
     27  */
     28 public final class TouchScreenQualifier extends ResourceQualifier {
     29 
     30     public static final String NAME = "Touch Screen";
     31 
     32     private TouchScreenType mValue;
     33 
     34     /**
     35      * Screen Orientation enum.
     36      */
     37     public static enum TouchScreenType {
     38         NOTOUCH("notouch", "No Touch"), //$NON-NLS-1$
     39         STYLUS("stylus", "Stylus"), //$NON-NLS-1$
     40         FINGER("finger", "Finger"); //$NON-NLS-1$
     41 
     42         private String mValue;
     43         private String mDisplayValue;
     44 
     45         private TouchScreenType(String value, String displayValue) {
     46             mValue = value;
     47             mDisplayValue = displayValue;
     48         }
     49 
     50         /**
     51          * Returns the enum for matching the provided qualifier value.
     52          * @param value The qualifier value.
     53          * @return the enum for the qualifier value or null if no matching was found.
     54          */
     55         public static TouchScreenType getEnum(String value) {
     56             for (TouchScreenType orient : values()) {
     57                 if (orient.mValue.equals(value)) {
     58                     return orient;
     59                 }
     60             }
     61 
     62             return null;
     63         }
     64 
     65         public String getValue() {
     66             return mValue;
     67         }
     68 
     69         public String getDisplayValue() {
     70             return mDisplayValue;
     71         }
     72 
     73         public static int getIndex(TouchScreenType touch) {
     74             int i = 0;
     75             for (TouchScreenType t : values()) {
     76                 if (t == touch) {
     77                     return i;
     78                 }
     79 
     80                 i++;
     81             }
     82 
     83             return -1;
     84         }
     85 
     86         public static TouchScreenType getByIndex(int index) {
     87             int i = 0;
     88             for (TouchScreenType value : values()) {
     89                 if (i == index) {
     90                     return value;
     91                 }
     92                 i++;
     93             }
     94 
     95             return null;
     96         }
     97     }
     98 
     99     public TouchScreenQualifier() {
    100         // pass
    101     }
    102 
    103     public TouchScreenQualifier(TouchScreenType touchValue) {
    104         mValue = touchValue;
    105     }
    106 
    107     public TouchScreenType getValue() {
    108         return mValue;
    109     }
    110 
    111     @Override
    112     public String getName() {
    113         return NAME;
    114     }
    115 
    116     @Override
    117     public String getShortName() {
    118         return NAME;
    119     }
    120 
    121     @Override
    122     public Image getIcon() {
    123         return IconFactory.getInstance().getIcon("touch"); //$NON-NLS-1$
    124     }
    125 
    126     @Override
    127     public boolean isValid() {
    128         return mValue != null;
    129     }
    130 
    131     @Override
    132     public boolean checkAndSet(String value, FolderConfiguration config) {
    133         TouchScreenType type = TouchScreenType.getEnum(value);
    134         if (type != null) {
    135             TouchScreenQualifier qualifier = new TouchScreenQualifier();
    136             qualifier.mValue = type;
    137             config.setTouchTypeQualifier(qualifier);
    138             return true;
    139         }
    140 
    141         return false;
    142     }
    143 
    144     @Override
    145     public boolean equals(Object qualifier) {
    146         if (qualifier instanceof TouchScreenQualifier) {
    147             return mValue == ((TouchScreenQualifier)qualifier).mValue;
    148         }
    149         return false;
    150     }
    151 
    152     @Override
    153     public int hashCode() {
    154         if (mValue != null) {
    155             return mValue.hashCode();
    156         }
    157 
    158         return 0;
    159     }
    160 
    161     /**
    162      * Returns the string used to represent this qualifier in the folder name.
    163      */
    164     @Override
    165     public String getFolderSegment(IAndroidTarget target) {
    166         if (mValue != null) {
    167             return mValue.getValue();
    168         }
    169 
    170         return ""; //$NON-NLS-1$
    171     }
    172 
    173     @Override
    174     public String getStringValue() {
    175         if (mValue != null) {
    176             return mValue.getDisplayValue();
    177         }
    178 
    179         return ""; //$NON-NLS-1$
    180     }
    181 }
    182