| /* |
| * 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(); |
| } |
| } |