/*
|
* Copyright (C) 2006 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 com.basic.security.widget.hlistview;
|
|
import android.annotation.TargetApi;
|
import android.content.Context;
|
import android.content.res.TypedArray;
|
import android.graphics.Canvas;
|
import android.graphics.Rect;
|
import android.graphics.drawable.Drawable;
|
import android.os.Build;
|
import android.os.Parcel;
|
import android.os.Parcelable;
|
import android.util.AttributeSet;
|
import android.view.ContextMenu;
|
import android.view.ContextMenu.ContextMenuInfo;
|
import android.view.Gravity;
|
import android.view.SoundEffectConstants;
|
import android.view.View;
|
import android.view.accessibility.AccessibilityEvent;
|
import android.view.accessibility.AccessibilityNodeInfo;
|
import android.widget.ExpandableListAdapter;
|
import android.widget.ListAdapter;
|
|
import com.basic.security.R;
|
|
import java.util.ArrayList;
|
|
|
/**
|
* A view that shows items in a vertically scrolling two-level list. This
|
* differs from the {@link HListView} by allowing two levels: groups which can
|
* individually be expanded to show its children. The items come from the
|
* {@link android.widget.ExpandableListAdapter} associated with this view.
|
* <p/>
|
* Expandable lists are able to show an indicator beside each item to display
|
* the item's current state (the states are usually one of expanded group,
|
* collapsed group, child, or last child). Use
|
* {@link #setChildIndicator(Drawable)} or {@link #setGroupIndicator(Drawable)}
|
* (or the corresponding XML attributes) to set these indicators (see the docs
|
* for each method to see additional state that each Drawable can have). The
|
* default style for an {@link ExpandableHListView} provides indicators which
|
* will be shown next to Views given to the {@link ExpandableHListView}. The
|
* layouts android.R.layout.simple_expandable_list_item_1 and
|
* android.R.layout.simple_expandable_list_item_2 (which should be used with
|
* {@link android.widget.SimpleCursorTreeAdapter}) contain the preferred position information
|
* for indicators.
|
* <p/>
|
* The context menu information set by an {@link ExpandableHListView} will be a
|
* {@link ExpandableListContextMenuInfo} object with
|
* {@link ExpandableListContextMenuInfo#packedPosition} being a packed position
|
* that can be used with {@link #getPackedPositionType(long)} and the other
|
* similar methods.
|
* <p/>
|
* <em><b>Note:</b></em> You cannot use the value <code>wrap_content</code>
|
* for the <code>android:layout_height</code> attribute of a
|
* ExpandableListView in XML if the parent's size is also not strictly specified
|
* (for example, if the parent were ScrollView you could not specify
|
* wrap_content since it also can be any length. However, you can use
|
* wrap_content if the ExpandableListView parent has a specific size, such as
|
* 100 pixels.
|
*
|
* @attr ref android.R.styleable#ExpandableListView_groupIndicator
|
* @attr ref android.R.styleable#ExpandableListView_indicatorLeft
|
* @attr ref android.R.styleable#ExpandableListView_indicatorRight
|
* @attr ref android.R.styleable#ExpandableListView_childIndicator
|
* @attr ref android.R.styleable#ExpandableListView_childIndicatorLeft
|
* @attr ref android.R.styleable#ExpandableListView_childIndicatorRight
|
* @attr ref android.R.styleable#ExpandableListView_childDivider
|
* @attr ref android.R.styleable#ExpandableListView_indicatorStart
|
* @attr ref android.R.styleable#ExpandableListView_indicatorEnd
|
* @attr ref android.R.styleable#ExpandableListView_childIndicatorStart
|
* @attr ref android.R.styleable#ExpandableListView_childIndicatorEnd
|
*/
|
public class ExpandableHListView extends HListView {
|
|
/**
|
* The packed position represents a group.
|
*/
|
public static final int PACKED_POSITION_TYPE_GROUP = 0;
|
|
/**
|
* The packed position represents a child.
|
*/
|
public static final int PACKED_POSITION_TYPE_CHILD = 1;
|
|
/**
|
* The packed position represents a neither/null/no preference.
|
*/
|
public static final int PACKED_POSITION_TYPE_NULL = 2;
|
|
/**
|
* The value for a packed position that represents neither/null/no
|
* preference. This value is not otherwise possible since a group type
|
* (first bit 0) should not have a child position filled.
|
*/
|
public static final long PACKED_POSITION_VALUE_NULL = 0x00000000FFFFFFFFL;
|
|
/** The mask (in packed position representation) for the child */
|
private static final long PACKED_POSITION_MASK_CHILD = 0x00000000FFFFFFFFL;
|
|
/** The mask (in packed position representation) for the group */
|
private static final long PACKED_POSITION_MASK_GROUP = 0x7FFFFFFF00000000L;
|
|
/** The mask (in packed position representation) for the type */
|
private static final long PACKED_POSITION_MASK_TYPE = 0x8000000000000000L;
|
|
/** The shift amount (in packed position representation) for the group */
|
private static final long PACKED_POSITION_SHIFT_GROUP = 32;
|
|
/** The shift amount (in packed position representation) for the type */
|
private static final long PACKED_POSITION_SHIFT_TYPE = 63;
|
|
/** The mask (in integer child position representation) for the child */
|
private static final long PACKED_POSITION_INT_MASK_CHILD = 0xFFFFFFFF;
|
|
/** The mask (in integer group position representation) for the group */
|
private static final long PACKED_POSITION_INT_MASK_GROUP = 0x7FFFFFFF;
|
|
/** Serves as the glue/translator between a ListView and an ExpandableListView */
|
private ExpandableHListConnector mConnector;
|
|
/** Gives us Views through group+child positions */
|
private ExpandableListAdapter mAdapter;
|
|
/** Left bound for drawing the indicator. */
|
private int mIndicatorTop;
|
|
/** Right bound for drawing the indicator. */
|
private int mIndicatorLeft;
|
|
/** Group indicator gravity */
|
private int mIndicatorGravity;
|
|
/** Child indicator gravity */
|
private int mChildIndicatorGravity;
|
|
private int mChildIndicatorTop;
|
|
private int mChildIndicatorLeft;
|
|
/**
|
* Denotes when a child indicator should inherit this bound from the generic
|
* indicator bounds
|
*/
|
public static final int CHILD_INDICATOR_INHERIT = - 1;
|
|
/**
|
* Denotes an undefined value for an indicator
|
*/
|
private static final int INDICATOR_UNDEFINED = - 2;
|
|
/** The indicator drawn next to a group. */
|
private Drawable mGroupIndicator;
|
|
/** The indicator drawn next to a child. */
|
private Drawable mChildIndicator;
|
|
private static final int[] EMPTY_STATE_SET = { };
|
|
/** State indicating the group is expanded. */
|
private static final int[] GROUP_EXPANDED_STATE_SET = { android.R.attr.state_expanded };
|
|
/** State indicating the group is empty (has no children). */
|
private static final int[] GROUP_EMPTY_STATE_SET = { android.R.attr.state_empty };
|
|
/** State indicating the group is expanded and empty (has no children). */
|
private static final int[] GROUP_EXPANDED_EMPTY_STATE_SET = { android.R.attr.state_expanded, android.R.attr.state_empty };
|
|
/** States for the group where the 0th bit is expanded and 1st bit is empty. */
|
private static final int[][] GROUP_STATE_SETS = { EMPTY_STATE_SET, // 00
|
GROUP_EXPANDED_STATE_SET, // 01
|
GROUP_EMPTY_STATE_SET, // 10
|
GROUP_EXPANDED_EMPTY_STATE_SET // 11
|
};
|
|
/** State indicating the child is the last within its group. */
|
private static final int[] CHILD_LAST_STATE_SET = { android.R.attr.state_last };
|
|
/** Drawable to be used as a divider when it is adjacent to any children */
|
private Drawable mChildDivider;
|
|
// Bounds of the indicator to be drawn
|
private final Rect mIndicatorRect = new Rect();
|
|
private final Rect mTempRect = new Rect();
|
|
private int mGroupIndicatorWidth;
|
private int mGroupIndicatorHeight;
|
private int mChildIndicatorWidth;
|
private int mChildIndicatorHeight;
|
|
public ExpandableHListView( Context context ) {
|
this( context, null );
|
}
|
|
public ExpandableHListView( Context context, AttributeSet attrs ) {
|
this( context, attrs, R.attr.hlv_expandableListViewStyle );
|
}
|
|
public ExpandableHListView( Context context, AttributeSet attrs, int defStyle ) {
|
super( context, attrs, defStyle );
|
|
TypedArray a = context.obtainStyledAttributes( attrs, R.styleable.ExpandableHListView, defStyle, 0 );
|
|
setGroupIndicator( a.getDrawable( R.styleable.ExpandableHListView_hlv_groupIndicator ) );
|
setChildIndicator( a.getDrawable( R.styleable.ExpandableHListView_hlv_childIndicator ) );
|
|
mIndicatorLeft = a.getDimensionPixelSize( R.styleable.ExpandableHListView_hlv_indicatorPaddingLeft, 0 );
|
mIndicatorTop = a.getDimensionPixelSize( R.styleable.ExpandableHListView_hlv_indicatorPaddingTop, 0 );
|
|
mIndicatorGravity = a.getInt( R.styleable.ExpandableHListView_hlv_indicatorGravity, Gravity.NO_GRAVITY );
|
mChildIndicatorGravity = a.getInt( R.styleable.ExpandableHListView_hlv_childIndicatorGravity, Gravity.NO_GRAVITY );
|
|
mChildIndicatorLeft = a.getDimensionPixelSize( R.styleable.ExpandableHListView_hlv_childIndicatorPaddingLeft, 0 );
|
mChildIndicatorTop = a.getDimensionPixelSize( R.styleable.ExpandableHListView_hlv_childIndicatorPaddingTop, 0 );
|
|
mChildDivider = a.getDrawable( R.styleable.ExpandableHListView_hlv_childDivider );
|
a.recycle();
|
}
|
|
public void onRtlPropertiesChanged( int layoutDirection ) {
|
resolveIndicator();
|
resolveChildIndicator();
|
}
|
|
/**
|
* Resolve start/end indicator. start/end indicator always takes precedence over left/right
|
* indicator when defined.
|
*/
|
private void resolveIndicator() {
|
if( null != mGroupIndicator ) {
|
mGroupIndicatorWidth = mGroupIndicator.getIntrinsicWidth();
|
mGroupIndicatorHeight = mGroupIndicator.getIntrinsicHeight();
|
}
|
else {
|
mGroupIndicatorWidth = 0;
|
mGroupIndicatorHeight = 0;
|
}
|
}
|
|
/**
|
* Resolve start/end child indicator. start/end child indicator always takes precedence over
|
* left/right child indicator when defined.
|
*/
|
private void resolveChildIndicator() {
|
if( null != mChildIndicator ) {
|
mChildIndicatorWidth = mChildIndicator.getIntrinsicWidth();
|
mChildIndicatorHeight = mChildIndicator.getIntrinsicHeight();
|
}
|
else {
|
mChildIndicatorWidth = 0;
|
mChildIndicatorHeight = 0;
|
}
|
}
|
|
|
@Override
|
protected void dispatchDraw( Canvas canvas ) {
|
// Draw children, etc.
|
super.dispatchDraw( canvas );
|
|
// If we have any indicators to draw, we do it here
|
if( ( mChildIndicator == null ) && ( mGroupIndicator == null ) ) {
|
return;
|
}
|
|
int saveCount = 0;
|
|
final int headerViewsCount = getHeaderViewsCount();
|
|
final int lastChildFlPos = mItemCount - getFooterViewsCount() - headerViewsCount - 1;
|
|
final int myRight = getRight();
|
|
ExpandableHListConnector.PositionMetadata pos;
|
View item;
|
Drawable indicator;
|
int left, right;
|
|
// Start at a value that is neither child nor group
|
int lastItemType = ~ ( ExpandableHListPosition.CHILD | ExpandableHListPosition.GROUP );
|
|
final Rect indicatorRect = mIndicatorRect;
|
|
// The "child" mentioned in the following two lines is this
|
// View's child, not referring to an expandable list's
|
// notion of a child (as opposed to a group)
|
final int childCount = getChildCount();
|
for( int i = 0, childFlPos = mFirstPosition - headerViewsCount; i < childCount; i++, childFlPos++ ) {
|
|
if( childFlPos < 0 ) {
|
// This child is header
|
continue;
|
}
|
else if( childFlPos > lastChildFlPos ) {
|
// This child is footer, so are all subsequent children
|
break;
|
}
|
|
item = getChildAt( i );
|
left = item.getLeft();
|
right = item.getRight();
|
|
// This item isn't on the screen
|
if( ( right < 0 ) || ( left > myRight ) ) continue;
|
|
// Get more expandable list-related info for this item
|
pos = mConnector.getUnflattenedPos( childFlPos );
|
|
// If this item type and the previous item type are different, then we need to change
|
// the left & right bounds
|
if( pos.position.type != lastItemType ) {
|
if( pos.position.type == ExpandableHListPosition.CHILD ) {
|
indicatorRect.top = item.getTop() + mChildIndicatorTop;
|
indicatorRect.bottom = item.getBottom() + mChildIndicatorTop;
|
}
|
else {
|
indicatorRect.top = item.getTop() + mIndicatorTop;
|
indicatorRect.bottom = item.getBottom() + mIndicatorTop;
|
}
|
|
lastItemType = pos.position.type;
|
}
|
|
if( indicatorRect.top != indicatorRect.bottom ) {
|
if( pos.position.type == ExpandableHListPosition.CHILD ) {
|
indicatorRect.left = left + mChildIndicatorLeft;
|
indicatorRect.right = right + mChildIndicatorLeft;
|
}
|
else {
|
indicatorRect.left = left + mIndicatorLeft;
|
indicatorRect.right = right + mIndicatorLeft;
|
}
|
|
|
// Get the indicator (with its state set to the item's state)
|
indicator = getIndicator( pos );
|
if( indicator != null ) {
|
|
if( pos.position.type == ExpandableHListPosition.CHILD ) {
|
Gravity.apply( mChildIndicatorGravity, mChildIndicatorWidth, mChildIndicatorHeight, indicatorRect, mTempRect );
|
}
|
else {
|
Gravity.apply( mIndicatorGravity, mGroupIndicatorWidth, mGroupIndicatorHeight, indicatorRect, mTempRect );
|
}
|
|
// Draw the indicator
|
indicator.setBounds( mTempRect );
|
indicator.draw( canvas );
|
}
|
}
|
pos.recycle();
|
}
|
}
|
|
/**
|
* Gets the indicator for the item at the given position. If the indicator
|
* is stateful, the state will be given to the indicator.
|
*
|
* @param pos The flat list position of the item whose indicator
|
* should be returned.
|
* @return The indicator in the proper state.
|
*/
|
private Drawable getIndicator( ExpandableHListConnector.PositionMetadata pos ) {
|
Drawable indicator;
|
|
if( pos.position.type == ExpandableHListPosition.GROUP ) {
|
indicator = mGroupIndicator;
|
|
if( indicator != null && indicator.isStateful() ) {
|
// Empty check based on availability of data. If the groupMetadata isn't null,
|
// we do a check on it. Otherwise, the group is collapsed so we consider it
|
// empty for performance reasons.
|
boolean isEmpty = ( pos.groupMetadata == null ) || ( pos.groupMetadata.lastChildFlPos == pos.groupMetadata.flPos );
|
|
final int stateSetIndex = ( pos.isExpanded() ? 1 : 0 ) | // Expanded?
|
( isEmpty ? 2 : 0 ); // Empty?
|
indicator.setState( GROUP_STATE_SETS[stateSetIndex] );
|
}
|
}
|
else {
|
indicator = mChildIndicator;
|
|
if( indicator != null && indicator.isStateful() ) {
|
// No need for a state sets array for the child since it only has two states
|
final int stateSet[] = pos.position.flatListPos == pos.groupMetadata.lastChildFlPos ? CHILD_LAST_STATE_SET : EMPTY_STATE_SET;
|
indicator.setState( stateSet );
|
}
|
}
|
|
return indicator;
|
}
|
|
/**
|
* Sets the drawable that will be drawn adjacent to every child in the list. This will
|
* be drawn using the same height as the normal divider ({@link #setDivider(Drawable)}) or
|
* if it does not have an intrinsic height, the height set by {@link #setDividerWidth(int)}.
|
*
|
* @param childDivider The drawable to use.
|
*/
|
public void setChildDivider( Drawable childDivider ) {
|
mChildDivider = childDivider;
|
}
|
|
@Override
|
void drawDivider( Canvas canvas, Rect bounds, int childIndex ) {
|
int flatListPosition = childIndex + mFirstPosition;
|
|
// Only proceed as possible child if the divider isn't above all items (if it is above
|
// all items, then the item below it has to be a group)
|
if( flatListPosition >= 0 ) {
|
final int adjustedPosition = getFlatPositionForConnector( flatListPosition );
|
ExpandableHListConnector.PositionMetadata pos = mConnector.getUnflattenedPos( adjustedPosition );
|
// If this item is a child, or it is a non-empty group that is expanded
|
if( ( pos.position.type == ExpandableHListPosition.CHILD ) || ( pos.isExpanded() && pos.groupMetadata.lastChildFlPos != pos.groupMetadata.flPos ) ) {
|
// These are the cases where we draw the child divider
|
final Drawable divider = mChildDivider;
|
divider.setBounds( bounds );
|
divider.draw( canvas );
|
pos.recycle();
|
return;
|
}
|
pos.recycle();
|
}
|
|
// Otherwise draw the default divider
|
super.drawDivider( canvas, bounds, flatListPosition );
|
}
|
|
/**
|
* This overloaded method should not be used, instead use
|
* {@link #setAdapter(ExpandableListAdapter)}.
|
* <p/>
|
* {@inheritDoc}
|
*/
|
@Override
|
public void setAdapter( ListAdapter adapter ) {
|
throw new RuntimeException( "For ExpandableListView, use setAdapter(ExpandableListAdapter) instead of " + "setAdapter(ListAdapter)" );
|
}
|
|
/**
|
* This method should not be used, use {@link #getExpandableListAdapter()}.
|
*/
|
@Override
|
public ListAdapter getAdapter() {
|
/*
|
* The developer should never really call this method on an
|
* ExpandableListView, so it would be nice to throw a RuntimeException,
|
* but AdapterView calls this
|
*/
|
return super.getAdapter();
|
}
|
|
/**
|
* Register a callback to be invoked when an item has been clicked and the
|
* caller prefers to receive a ListView-style position instead of a group
|
* and/or child position. In most cases, the caller should use
|
* {@link #setOnGroupClickListener} and/or {@link #setOnChildClickListener}.
|
* <p/>
|
* {@inheritDoc}
|
*/
|
@Override
|
public void setOnItemClickListener( OnItemClickListener l ) {
|
super.setOnItemClickListener( l );
|
}
|
|
/**
|
* Sets the adapter that provides data to this view.
|
*
|
* @param adapter The adapter that provides data to this view.
|
*/
|
public void setAdapter( ExpandableListAdapter adapter ) {
|
// Set member variable
|
mAdapter = adapter;
|
|
if( adapter != null ) {
|
// Create the connector
|
mConnector = new ExpandableHListConnector( adapter );
|
}
|
else {
|
mConnector = null;
|
}
|
|
// Link the ListView (superclass) to the expandable list data through the connector
|
super.setAdapter( mConnector );
|
}
|
|
/**
|
* Gets the adapter that provides data to this view.
|
*
|
* @return The adapter that provides data to this view.
|
*/
|
public ExpandableListAdapter getExpandableListAdapter() {
|
return mAdapter;
|
}
|
|
/**
|
* @param position An absolute (including header and footer) flat list position.
|
* @return true if the position corresponds to a header or a footer item.
|
*/
|
private boolean isHeaderOrFooterPosition( int position ) {
|
final int footerViewsStart = mItemCount - getFooterViewsCount();
|
return ( position < getHeaderViewsCount() || position >= footerViewsStart );
|
}
|
|
/**
|
* Converts an absolute item flat position into a group/child flat position, shifting according
|
* to the number of header items.
|
*
|
* @param flatListPosition The absolute flat position
|
* @return A group/child flat position as expected by the connector.
|
*/
|
private int getFlatPositionForConnector( int flatListPosition ) {
|
return flatListPosition - getHeaderViewsCount();
|
}
|
|
/**
|
* Converts a group/child flat position into an absolute flat position, that takes into account
|
* the possible headers.
|
*
|
* @param flatListPosition The child/group flat position
|
* @return An absolute flat position.
|
*/
|
private int getAbsoluteFlatPosition( int flatListPosition ) {
|
return flatListPosition + getHeaderViewsCount();
|
}
|
|
@Override
|
public boolean performItemClick( View v, int position, long id ) {
|
// Ignore clicks in header/footers
|
if( isHeaderOrFooterPosition( position ) ) {
|
// Clicked on a header/footer, so ignore pass it on to super
|
return super.performItemClick( v, position, id );
|
}
|
|
// Internally handle the item click
|
final int adjustedPosition = getFlatPositionForConnector( position );
|
return handleItemClick( v, adjustedPosition, id );
|
}
|
|
/**
|
* This will either expand/collapse groups (if a group was clicked) or pass
|
* on the click to the proper child (if a child was clicked)
|
*
|
* @param position The flat list position. This has already been factored to
|
* remove the header/footer.
|
* @param id The ListAdapter ID, not the group or child ID.
|
*/
|
boolean handleItemClick( View v, int position, long id ) {
|
final ExpandableHListConnector.PositionMetadata posMetadata = mConnector.getUnflattenedPos( position );
|
|
id = getChildOrGroupId( posMetadata.position );
|
|
boolean returnValue;
|
if( posMetadata.position.type == ExpandableHListPosition.GROUP ) {
|
/* It's a group, so handle collapsing/expanding */
|
|
/* It's a group click, so pass on event */
|
if( mOnGroupClickListener != null ) {
|
if( mOnGroupClickListener.onGroupClick( this, v, posMetadata.position.groupPos, id ) ) {
|
posMetadata.recycle();
|
return true;
|
}
|
}
|
|
if( posMetadata.isExpanded() ) {
|
/* Collapse it */
|
mConnector.collapseGroup( posMetadata );
|
|
playSoundEffect( SoundEffectConstants.CLICK );
|
|
if( mOnGroupCollapseListener != null ) {
|
mOnGroupCollapseListener.onGroupCollapse( posMetadata.position.groupPos );
|
}
|
}
|
else {
|
/* Expand it */
|
mConnector.expandGroup( posMetadata );
|
|
playSoundEffect( SoundEffectConstants.CLICK );
|
|
if( mOnGroupExpandListener != null ) {
|
mOnGroupExpandListener.onGroupExpand( posMetadata.position.groupPos );
|
}
|
|
final int groupPos = posMetadata.position.groupPos;
|
final int groupFlatPos = posMetadata.position.flatListPos;
|
|
final int shiftedGroupPosition = groupFlatPos + getHeaderViewsCount();
|
smoothScrollToPosition( shiftedGroupPosition + mAdapter.getChildrenCount( groupPos ), shiftedGroupPosition );
|
}
|
|
returnValue = true;
|
}
|
else {
|
/* It's a child, so pass on event */
|
if( mOnChildClickListener != null ) {
|
playSoundEffect( SoundEffectConstants.CLICK );
|
return mOnChildClickListener.onChildClick( this, v, posMetadata.position.groupPos, posMetadata.position.childPos, id );
|
}
|
|
returnValue = false;
|
}
|
|
posMetadata.recycle();
|
|
return returnValue;
|
}
|
|
/**
|
* Expand a group in the grouped list view
|
*
|
* @param groupPos the group to be expanded
|
* @return True if the group was expanded, false otherwise (if the group
|
* was already expanded, this will return false)
|
*/
|
public boolean expandGroup( int groupPos ) {
|
return expandGroup( groupPos, false );
|
}
|
|
/**
|
* Expand a group in the grouped list view
|
*
|
* @param groupPos the group to be expanded
|
* @param animate true if the expanding group should be animated in
|
* @return True if the group was expanded, false otherwise (if the group
|
* was already expanded, this will return false)
|
*/
|
public boolean expandGroup( int groupPos, boolean animate ) {
|
ExpandableHListPosition elGroupPos = ExpandableHListPosition.obtain( ExpandableHListPosition.GROUP, groupPos, - 1, - 1 );
|
ExpandableHListConnector.PositionMetadata pm = mConnector.getFlattenedPos( elGroupPos );
|
elGroupPos.recycle();
|
boolean retValue = mConnector.expandGroup( pm );
|
|
if( mOnGroupExpandListener != null ) {
|
mOnGroupExpandListener.onGroupExpand( groupPos );
|
}
|
|
if( animate ) {
|
final int groupFlatPos = pm.position.flatListPos;
|
|
final int shiftedGroupPosition = groupFlatPos + getHeaderViewsCount();
|
smoothScrollToPosition( shiftedGroupPosition + mAdapter.getChildrenCount( groupPos ), shiftedGroupPosition );
|
}
|
pm.recycle();
|
|
return retValue;
|
}
|
|
/**
|
* Collapse a group in the grouped list view
|
*
|
* @param groupPos position of the group to collapse
|
* @return True if the group was collapsed, false otherwise (if the group
|
* was already collapsed, this will return false)
|
*/
|
public boolean collapseGroup( int groupPos ) {
|
boolean retValue = mConnector.collapseGroup( groupPos );
|
|
if( mOnGroupCollapseListener != null ) {
|
mOnGroupCollapseListener.onGroupCollapse( groupPos );
|
}
|
|
return retValue;
|
}
|
|
/** Used for being notified when a group is collapsed */
|
public interface OnGroupCollapseListener {
|
/**
|
* Callback method to be invoked when a group in this expandable list has
|
* been collapsed.
|
*
|
* @param groupPosition The group position that was collapsed
|
*/
|
void onGroupCollapse( int groupPosition );
|
}
|
|
private OnGroupCollapseListener mOnGroupCollapseListener;
|
|
public void setOnGroupCollapseListener(
|
OnGroupCollapseListener onGroupCollapseListener ) {
|
mOnGroupCollapseListener = onGroupCollapseListener;
|
}
|
|
/** Used for being notified when a group is expanded */
|
public interface OnGroupExpandListener {
|
/**
|
* Callback method to be invoked when a group in this expandable list has
|
* been expanded.
|
*
|
* @param groupPosition The group position that was expanded
|
*/
|
void onGroupExpand( int groupPosition );
|
}
|
|
private OnGroupExpandListener mOnGroupExpandListener;
|
|
public void setOnGroupExpandListener(
|
OnGroupExpandListener onGroupExpandListener ) {
|
mOnGroupExpandListener = onGroupExpandListener;
|
}
|
|
/**
|
* Interface definition for a callback to be invoked when a group in this
|
* expandable list has been clicked.
|
*/
|
public interface OnGroupClickListener {
|
/**
|
* Callback method to be invoked when a group in this expandable list has
|
* been clicked.
|
*
|
* @param parent The ExpandableHListConnector where the click happened
|
* @param v The view within the expandable list/ListView that was clicked
|
* @param groupPosition The group position that was clicked
|
* @param id The row id of the group that was clicked
|
* @return True if the click was handled
|
*/
|
boolean onGroupClick(
|
ExpandableHListView parent, View v, int groupPosition, long id );
|
}
|
|
private OnGroupClickListener mOnGroupClickListener;
|
|
public void setOnGroupClickListener( OnGroupClickListener onGroupClickListener ) {
|
mOnGroupClickListener = onGroupClickListener;
|
}
|
|
/**
|
* Interface definition for a callback to be invoked when a child in this
|
* expandable list has been clicked.
|
*/
|
public interface OnChildClickListener {
|
/**
|
* Callback method to be invoked when a child in this expandable list has
|
* been clicked.
|
*
|
* @param parent The ExpandableListView where the click happened
|
* @param v The view within the expandable list/ListView that was clicked
|
* @param groupPosition The group position that contains the child that
|
* was clicked
|
* @param childPosition The child position within the group
|
* @param id The row id of the child that was clicked
|
* @return True if the click was handled
|
*/
|
boolean onChildClick(
|
ExpandableHListView parent, View v, int groupPosition, int childPosition, long id );
|
}
|
|
private OnChildClickListener mOnChildClickListener;
|
|
public void setOnChildClickListener( OnChildClickListener onChildClickListener ) {
|
mOnChildClickListener = onChildClickListener;
|
}
|
|
/**
|
* Converts a flat list position (the raw position of an item (child or group)
|
* in the list) to a group and/or child position (represented in a
|
* packed position). This is useful in situations where the caller needs to
|
* use the underlying {@link android.widget.ListView}'s methods. Use
|
* {@link ExpandableHListView#getPackedPositionType} ,
|
* {@link ExpandableHListView#getPackedPositionChild},
|
* {@link ExpandableHListView#getPackedPositionGroup} to unpack.
|
*
|
* @param flatListPosition The flat list position to be converted.
|
* @return The group and/or child position for the given flat list position
|
* in packed position representation. #PACKED_POSITION_VALUE_NULL if
|
* the position corresponds to a header or a footer item.
|
*/
|
public long getExpandableListPosition( int flatListPosition ) {
|
if( isHeaderOrFooterPosition( flatListPosition ) ) {
|
return PACKED_POSITION_VALUE_NULL;
|
}
|
|
final int adjustedPosition = getFlatPositionForConnector( flatListPosition );
|
ExpandableHListConnector.PositionMetadata pm = mConnector.getUnflattenedPos( adjustedPosition );
|
long packedPos = pm.position.getPackedPosition();
|
pm.recycle();
|
return packedPos;
|
}
|
|
/**
|
* Converts a group and/or child position to a flat list position. This is
|
* useful in situations where the caller needs to use the underlying
|
* {@link android.widget.ListView}'s methods.
|
*
|
* @param packedPosition The group and/or child positions to be converted in
|
* packed position representation. Use
|
* {@link #getPackedPositionForChild(int, int)} or
|
* {@link #getPackedPositionForGroup(int)}.
|
* @return The flat list position for the given child or group.
|
*/
|
public int getFlatListPosition( long packedPosition ) {
|
ExpandableHListPosition elPackedPos = ExpandableHListPosition.obtainPosition( packedPosition );
|
ExpandableHListConnector.PositionMetadata pm = mConnector.getFlattenedPos( elPackedPos );
|
elPackedPos.recycle();
|
final int flatListPosition = pm.position.flatListPos;
|
pm.recycle();
|
return getAbsoluteFlatPosition( flatListPosition );
|
}
|
|
/**
|
* Gets the position of the currently selected group or child (along with
|
* its type). Can return {@link #PACKED_POSITION_VALUE_NULL} if no selection.
|
*
|
* @return A packed position containing the currently selected group or
|
* child's position and type. #PACKED_POSITION_VALUE_NULL if no selection
|
* or if selection is on a header or a footer item.
|
*/
|
public long getSelectedPosition() {
|
final int selectedPos = getSelectedItemPosition();
|
|
// The case where there is no selection (selectedPos == -1) is also handled here.
|
return getExpandableListPosition( selectedPos );
|
}
|
|
/**
|
* Gets the ID of the currently selected group or child. Can return -1 if no
|
* selection.
|
*
|
* @return The ID of the currently selected group or child. -1 if no
|
* selection.
|
*/
|
public long getSelectedId() {
|
long packedPos = getSelectedPosition();
|
if( packedPos == PACKED_POSITION_VALUE_NULL ) return - 1;
|
|
int groupPos = getPackedPositionGroup( packedPos );
|
|
if( getPackedPositionType( packedPos ) == PACKED_POSITION_TYPE_GROUP ) {
|
// It's a group
|
return mAdapter.getGroupId( groupPos );
|
}
|
else {
|
// It's a child
|
return mAdapter.getChildId( groupPos, getPackedPositionChild( packedPos ) );
|
}
|
}
|
|
/**
|
* Sets the selection to the specified group.
|
*
|
* @param groupPosition The position of the group that should be selected.
|
*/
|
public void setSelectedGroup( int groupPosition ) {
|
ExpandableHListPosition elGroupPos = ExpandableHListPosition.obtainGroupPosition( groupPosition );
|
ExpandableHListConnector.PositionMetadata pm = mConnector.getFlattenedPos( elGroupPos );
|
elGroupPos.recycle();
|
final int absoluteFlatPosition = getAbsoluteFlatPosition( pm.position.flatListPos );
|
super.setSelection( absoluteFlatPosition );
|
pm.recycle();
|
}
|
|
/**
|
* Sets the selection to the specified child. If the child is in a collapsed
|
* group, the group will only be expanded and child subsequently selected if
|
* shouldExpandGroup is set to true, otherwise the method will return false.
|
*
|
* @param groupPosition The position of the group that contains the child.
|
* @param childPosition The position of the child within the group.
|
* @param shouldExpandGroup Whether the child's group should be expanded if
|
* it is collapsed.
|
* @return Whether the selection was successfully set on the child.
|
*/
|
public boolean setSelectedChild( int groupPosition, int childPosition, boolean shouldExpandGroup ) {
|
ExpandableHListPosition elChildPos = ExpandableHListPosition.obtainChildPosition( groupPosition, childPosition );
|
ExpandableHListConnector.PositionMetadata flatChildPos = mConnector.getFlattenedPos( elChildPos );
|
|
if( flatChildPos == null ) {
|
// The child's group isn't expanded
|
|
// Shouldn't expand the group, so return false for we didn't set the selection
|
if( ! shouldExpandGroup ) return false;
|
|
expandGroup( groupPosition );
|
|
flatChildPos = mConnector.getFlattenedPos( elChildPos );
|
|
// Sanity check
|
if( flatChildPos == null ) {
|
throw new IllegalStateException( "Could not find child" );
|
}
|
}
|
|
int absoluteFlatPosition = getAbsoluteFlatPosition( flatChildPos.position.flatListPos );
|
super.setSelection( absoluteFlatPosition );
|
|
elChildPos.recycle();
|
flatChildPos.recycle();
|
|
return true;
|
}
|
|
/**
|
* Whether the given group is currently expanded.
|
*
|
* @param groupPosition The group to check.
|
* @return Whether the group is currently expanded.
|
*/
|
public boolean isGroupExpanded( int groupPosition ) {
|
return mConnector.isGroupExpanded( groupPosition );
|
}
|
|
/**
|
* Gets the type of a packed position. See
|
* {@link #getPackedPositionForChild(int, int)}.
|
*
|
* @param packedPosition The packed position for which to return the type.
|
* @return The type of the position contained within the packed position,
|
* either {@link #PACKED_POSITION_TYPE_CHILD}, {@link #PACKED_POSITION_TYPE_GROUP}, or
|
* {@link #PACKED_POSITION_TYPE_NULL}.
|
*/
|
public static int getPackedPositionType( long packedPosition ) {
|
if( packedPosition == PACKED_POSITION_VALUE_NULL ) {
|
return PACKED_POSITION_TYPE_NULL;
|
}
|
|
return ( packedPosition & PACKED_POSITION_MASK_TYPE ) == PACKED_POSITION_MASK_TYPE ? PACKED_POSITION_TYPE_CHILD : PACKED_POSITION_TYPE_GROUP;
|
}
|
|
/**
|
* Gets the group position from a packed position. See
|
* {@link #getPackedPositionForChild(int, int)}.
|
*
|
* @param packedPosition The packed position from which the group position
|
* will be returned.
|
* @return The group position portion of the packed position. If this does
|
* not contain a group, returns -1.
|
*/
|
public static int getPackedPositionGroup( long packedPosition ) {
|
// Null
|
if( packedPosition == PACKED_POSITION_VALUE_NULL ) return - 1;
|
|
return (int) ( ( packedPosition & PACKED_POSITION_MASK_GROUP ) >> PACKED_POSITION_SHIFT_GROUP );
|
}
|
|
/**
|
* Gets the child position from a packed position that is of
|
* {@link #PACKED_POSITION_TYPE_CHILD} type (use {@link #getPackedPositionType(long)}).
|
* To get the group that this child belongs to, use
|
* {@link #getPackedPositionGroup(long)}. See
|
* {@link #getPackedPositionForChild(int, int)}.
|
*
|
* @param packedPosition The packed position from which the child position
|
* will be returned.
|
* @return The child position portion of the packed position. If this does
|
* not contain a child, returns -1.
|
*/
|
public static int getPackedPositionChild( long packedPosition ) {
|
// Null
|
if( packedPosition == PACKED_POSITION_VALUE_NULL ) return - 1;
|
|
// Group since a group type clears this bit
|
if( ( packedPosition & PACKED_POSITION_MASK_TYPE ) != PACKED_POSITION_MASK_TYPE ) return - 1;
|
|
return (int) ( packedPosition & PACKED_POSITION_MASK_CHILD );
|
}
|
|
/**
|
* Returns the packed position representation of a child's position.
|
* <p/>
|
* In general, a packed position should be used in
|
* situations where the position given to/returned from an
|
* {@link ExpandableListAdapter} or {@link ExpandableHListView} method can
|
* either be a child or group. The two positions are packed into a single
|
* long which can be unpacked using
|
* {@link #getPackedPositionChild(long)},
|
* {@link #getPackedPositionGroup(long)}, and
|
* {@link #getPackedPositionType(long)}.
|
*
|
* @param groupPosition The child's parent group's position.
|
* @param childPosition The child position within the group.
|
* @return The packed position representation of the child (and parent group).
|
*/
|
public static long getPackedPositionForChild( int groupPosition, int childPosition ) {
|
return ( ( (long) PACKED_POSITION_TYPE_CHILD ) << PACKED_POSITION_SHIFT_TYPE ) |
|
( ( ( (long) groupPosition ) & PACKED_POSITION_INT_MASK_GROUP ) << PACKED_POSITION_SHIFT_GROUP ) | ( childPosition & PACKED_POSITION_INT_MASK_CHILD );
|
}
|
|
/**
|
* Returns the packed position representation of a group's position. See
|
* {@link #getPackedPositionForChild(int, int)}.
|
*
|
* @param groupPosition The child's parent group's position.
|
* @return The packed position representation of the group.
|
*/
|
public static long getPackedPositionForGroup( int groupPosition ) {
|
// No need to OR a type in because PACKED_POSITION_GROUP == 0
|
return ( ( ( (long) groupPosition ) & PACKED_POSITION_INT_MASK_GROUP ) << PACKED_POSITION_SHIFT_GROUP );
|
}
|
|
@Override
|
ContextMenuInfo createContextMenuInfo( View view, int flatListPosition, long id ) {
|
if( isHeaderOrFooterPosition( flatListPosition ) ) {
|
// Return normal info for header/footer view context menus
|
return new AdapterContextMenuInfo( view, flatListPosition, id );
|
}
|
|
final int adjustedPosition = getFlatPositionForConnector( flatListPosition );
|
ExpandableHListConnector.PositionMetadata pm = mConnector.getUnflattenedPos( adjustedPosition );
|
ExpandableHListPosition pos = pm.position;
|
|
id = getChildOrGroupId( pos );
|
long packedPosition = pos.getPackedPosition();
|
|
pm.recycle();
|
|
return new ExpandableListContextMenuInfo( view, packedPosition, id );
|
}
|
|
/**
|
* Gets the ID of the group or child at the given <code>position</code>.
|
* This is useful since there is no ListAdapter ID -> ExpandableListAdapter
|
* ID conversion mechanism (in some cases, it isn't possible).
|
*
|
* @param position The position of the child or group whose ID should be
|
* returned.
|
*/
|
private long getChildOrGroupId( ExpandableHListPosition position ) {
|
if( position.type == ExpandableHListPosition.CHILD ) {
|
return mAdapter.getChildId( position.groupPos, position.childPos );
|
}
|
else {
|
return mAdapter.getGroupId( position.groupPos );
|
}
|
}
|
|
/**
|
* Sets the indicator to be drawn next to a child.
|
*
|
* @param childIndicator The drawable to be used as an indicator. If the
|
* child is the last child for a group, the state
|
* {@link android.R.attr#state_last} will be set.
|
*/
|
public void setChildIndicator( Drawable childIndicator ) {
|
mChildIndicator = childIndicator;
|
resolveChildIndicator();
|
}
|
|
/**
|
* Sets the indicator to be drawn next to a group.
|
*
|
* @param groupIndicator The drawable to be used as an indicator. If the
|
* group is empty, the state {@link android.R.attr#state_empty} will be
|
* set. If the group is expanded, the state
|
* {@link android.R.attr#state_expanded} will be set.
|
*/
|
public void setGroupIndicator( Drawable groupIndicator ) {
|
mGroupIndicator = groupIndicator;
|
resolveIndicator();
|
}
|
|
/**
|
* Extra menu information specific to an {@link ExpandableHListView} provided
|
* to the
|
* {@link android.view.View.OnCreateContextMenuListener#onCreateContextMenu(ContextMenu, View, ContextMenuInfo) }
|
* callback when a context menu is brought up for this AdapterView.
|
*/
|
public static class ExpandableListContextMenuInfo implements ContextMenu.ContextMenuInfo {
|
|
public ExpandableListContextMenuInfo( View targetView, long packedPosition, long id ) {
|
this.targetView = targetView;
|
this.packedPosition = packedPosition;
|
this.id = id;
|
}
|
|
/**
|
* The view for which the context menu is being displayed. This
|
* will be one of the children Views of this {@link ExpandableHListView}.
|
*/
|
public View targetView;
|
|
/**
|
* The packed position in the list represented by the adapter for which
|
* the context menu is being displayed. Use the methods
|
* {@link ExpandableHListView#getPackedPositionType},
|
* {@link ExpandableHListView#getPackedPositionChild}, and
|
* {@link ExpandableHListView#getPackedPositionGroup} to unpack this.
|
*/
|
public long packedPosition;
|
|
/**
|
* The ID of the item (group or child) for which the context menu is
|
* being displayed.
|
*/
|
public long id;
|
}
|
|
static class SavedState extends BaseSavedState {
|
ArrayList<ExpandableHListConnector.GroupMetadata> expandedGroupMetadataList;
|
|
/**
|
* Constructor called from {@link ExpandableHListView#onSaveInstanceState()}
|
*/
|
SavedState(
|
Parcelable superState, ArrayList<ExpandableHListConnector.GroupMetadata> expandedGroupMetadataList ) {
|
super( superState );
|
this.expandedGroupMetadataList = expandedGroupMetadataList;
|
}
|
|
/**
|
* Constructor called from {@link #CREATOR}
|
*/
|
private SavedState( Parcel in ) {
|
super( in );
|
expandedGroupMetadataList = new ArrayList<ExpandableHListConnector.GroupMetadata>();
|
in.readList( expandedGroupMetadataList, ExpandableHListConnector.class.getClassLoader() );
|
}
|
|
@Override
|
public void writeToParcel( Parcel out, int flags ) {
|
super.writeToParcel( out, flags );
|
out.writeList( expandedGroupMetadataList );
|
}
|
|
public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
|
public SavedState createFromParcel( Parcel in ) {
|
return new SavedState( in );
|
}
|
|
public SavedState[] newArray( int size ) {
|
return new SavedState[size];
|
}
|
};
|
}
|
|
@Override
|
public Parcelable onSaveInstanceState() {
|
Parcelable superState = super.onSaveInstanceState();
|
return new SavedState( superState, mConnector != null ? mConnector.getExpandedGroupMetadataList() : null );
|
}
|
|
@Override
|
public void onRestoreInstanceState( Parcelable state ) {
|
if( ! ( state instanceof SavedState ) ) {
|
super.onRestoreInstanceState( state );
|
return;
|
}
|
|
SavedState ss = (SavedState) state;
|
super.onRestoreInstanceState( ss.getSuperState() );
|
|
if( mConnector != null && ss.expandedGroupMetadataList != null ) {
|
mConnector.setExpandedGroupMetadataList( ss.expandedGroupMetadataList );
|
}
|
}
|
|
@Override
|
public void onInitializeAccessibilityEvent( AccessibilityEvent event ) {
|
super.onInitializeAccessibilityEvent( event );
|
event.setClassName( ExpandableHListView.class.getName() );
|
}
|
|
@TargetApi( Build.VERSION_CODES.ICE_CREAM_SANDWICH )
|
@Override
|
public void onInitializeAccessibilityNodeInfo( AccessibilityNodeInfo info ) {
|
super.onInitializeAccessibilityNodeInfo( info );
|
info.setClassName( ExpandableHListView.class.getName() );
|
}
|
}
|
