Java tutorial
/* * Copyright (C) 2007 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.util; import com.android.internal.R; /** * State sets are arrays of positive ints where each element * represents the state of a {@link android.view.View} (e.g. focused, * selected, visible, etc.). A {@link android.view.View} may be in * one or more of those states. * * A state spec is an array of signed ints where each element * represents a required (if positive) or an undesired (if negative) * {@link android.view.View} state. * * Utils dealing with state sets. * * In theory we could encapsulate the state set and state spec arrays * and not have static methods here but there is some concern about * performance since these methods are called during view drawing. */ public class StateSet { /** * The order here is very important to * {@link android.view.View#getDrawableState()} */ private static final int[][] VIEW_STATE_SETS; /** @hide */ public static final int VIEW_STATE_WINDOW_FOCUSED = 1; /** @hide */ public static final int VIEW_STATE_SELECTED = 1 << 1; /** @hide */ public static final int VIEW_STATE_FOCUSED = 1 << 2; /** @hide */ public static final int VIEW_STATE_ENABLED = 1 << 3; /** @hide */ public static final int VIEW_STATE_PRESSED = 1 << 4; /** @hide */ public static final int VIEW_STATE_ACTIVATED = 1 << 5; /** @hide */ public static final int VIEW_STATE_ACCELERATED = 1 << 6; /** @hide */ public static final int VIEW_STATE_HOVERED = 1 << 7; /** @hide */ public static final int VIEW_STATE_DRAG_CAN_ACCEPT = 1 << 8; /** @hide */ public static final int VIEW_STATE_DRAG_HOVERED = 1 << 9; static final int[] VIEW_STATE_IDS = new int[] { R.attr.state_window_focused, VIEW_STATE_WINDOW_FOCUSED, R.attr.state_selected, VIEW_STATE_SELECTED, R.attr.state_focused, VIEW_STATE_FOCUSED, R.attr.state_enabled, VIEW_STATE_ENABLED, R.attr.state_pressed, VIEW_STATE_PRESSED, R.attr.state_activated, VIEW_STATE_ACTIVATED, R.attr.state_accelerated, VIEW_STATE_ACCELERATED, R.attr.state_hovered, VIEW_STATE_HOVERED, R.attr.state_drag_can_accept, VIEW_STATE_DRAG_CAN_ACCEPT, R.attr.state_drag_hovered, VIEW_STATE_DRAG_HOVERED }; static { if ((VIEW_STATE_IDS.length / 2) != R.styleable.ViewDrawableStates.length) { throw new IllegalStateException( "VIEW_STATE_IDs array length does not match ViewDrawableStates style array"); } final int[] orderedIds = new int[VIEW_STATE_IDS.length]; for (int i = 0; i < R.styleable.ViewDrawableStates.length; i++) { final int viewState = R.styleable.ViewDrawableStates[i]; for (int j = 0; j < VIEW_STATE_IDS.length; j += 2) { if (VIEW_STATE_IDS[j] == viewState) { orderedIds[i * 2] = viewState; orderedIds[i * 2 + 1] = VIEW_STATE_IDS[j + 1]; } } } final int NUM_BITS = VIEW_STATE_IDS.length / 2; VIEW_STATE_SETS = new int[1 << NUM_BITS][]; for (int i = 0; i < VIEW_STATE_SETS.length; i++) { final int numBits = Integer.bitCount(i); final int[] set = new int[numBits]; int pos = 0; for (int j = 0; j < orderedIds.length; j += 2) { if ((i & orderedIds[j + 1]) != 0) { set[pos++] = orderedIds[j]; } } VIEW_STATE_SETS[i] = set; } } /** @hide */ public static int[] get(int mask) { if (mask >= VIEW_STATE_SETS.length) { throw new IllegalArgumentException("Invalid state set mask"); } return VIEW_STATE_SETS[mask]; } /** @hide */ public StateSet() { } /** * A state specification that will be matched by all StateSets. */ public static final int[] WILD_CARD = new int[0]; /** * A state set that does not contain any valid states. */ public static final int[] NOTHING = new int[] { 0 }; /** * Return whether the stateSetOrSpec is matched by all StateSets. * * @param stateSetOrSpec a state set or state spec. */ public static boolean isWildCard(int[] stateSetOrSpec) { return stateSetOrSpec.length == 0 || stateSetOrSpec[0] == 0; } /** * Return whether the stateSet matches the desired stateSpec. * * @param stateSpec an array of required (if positive) or * prohibited (if negative) {@link android.view.View} states. * @param stateSet an array of {@link android.view.View} states */ public static boolean stateSetMatches(int[] stateSpec, int[] stateSet) { if (stateSet == null) { return (stateSpec == null || isWildCard(stateSpec)); } int stateSpecSize = stateSpec.length; int stateSetSize = stateSet.length; for (int i = 0; i < stateSpecSize; i++) { int stateSpecState = stateSpec[i]; if (stateSpecState == 0) { // We've reached the end of the cases to match against. return true; } final boolean mustMatch; if (stateSpecState > 0) { mustMatch = true; } else { // We use negative values to indicate must-NOT-match states. mustMatch = false; stateSpecState = -stateSpecState; } boolean found = false; for (int j = 0; j < stateSetSize; j++) { final int state = stateSet[j]; if (state == 0) { // We've reached the end of states to match. if (mustMatch) { // We didn't find this must-match state. return false; } else { // Continue checking other must-not-match states. break; } } if (state == stateSpecState) { if (mustMatch) { found = true; // Continue checking other other must-match states. break; } else { // Any match of a must-not-match state returns false. return false; } } } if (mustMatch && !found) { // We've reached the end of states to match and we didn't // find a must-match state. return false; } } return true; } /** * Return whether the state matches the desired stateSpec. * * @param stateSpec an array of required (if positive) or * prohibited (if negative) {@link android.view.View} states. * @param state a {@link android.view.View} state */ public static boolean stateSetMatches(int[] stateSpec, int state) { int stateSpecSize = stateSpec.length; for (int i = 0; i < stateSpecSize; i++) { int stateSpecState = stateSpec[i]; if (stateSpecState == 0) { // We've reached the end of the cases to match against. return true; } if (stateSpecState > 0) { if (state != stateSpecState) { return false; } } else { // We use negative values to indicate must-NOT-match states. if (state == -stateSpecState) { // We matched a must-not-match case. return false; } } } return true; } /** * Check whether a list of state specs has an attribute specified. * @param stateSpecs a list of state specs we're checking. * @param attr an attribute we're looking for. * @return {@code true} if the attribute is contained in the state specs. * @hide */ public static boolean containsAttribute(int[][] stateSpecs, int attr) { if (stateSpecs != null) { for (int[] spec : stateSpecs) { if (spec == null) { break; } for (int specAttr : spec) { if (specAttr == attr || -specAttr == attr) { return true; } } } } return false; } public static int[] trimStateSet(int[] states, int newSize) { if (states.length == newSize) { return states; } int[] trimmedStates = new int[newSize]; System.arraycopy(states, 0, trimmedStates, 0, newSize); return trimmedStates; } public static String dump(int[] states) { StringBuilder sb = new StringBuilder(); int count = states.length; for (int i = 0; i < count; i++) { switch (states[i]) { case R.attr.state_window_focused: sb.append("W "); break; case R.attr.state_pressed: sb.append("P "); break; case R.attr.state_selected: sb.append("S "); break; case R.attr.state_focused: sb.append("F "); break; case R.attr.state_enabled: sb.append("E "); break; case R.attr.state_checked: sb.append("C "); break; case R.attr.state_activated: sb.append("A "); break; } } return sb.toString(); } }