/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package sk.baka.ambient.views;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.BitSet;
  import java.util.List;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.commons.Interval;
  import android.content.Context;
  import android.content.res.TypedArray;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.graphics.Canvas;
  import android.graphics.ColorMatrix;
  import android.graphics.ColorMatrixColorFilter;
  import android.graphics.Paint;
  import android.graphics.Point;
  import android.graphics.Rect;
  import android.util.AttributeSet;
  import android.view.KeyEvent;
  import android.view.MotionEvent;
  import android.view.View;
  import android.widget.AbsoluteLayout;
  import android.widget.AdapterView.OnItemClickListener;
  
  /***
   * A very simple, naive and inefficient implementation of the
   * apple-launchbar-like button bar.
   * 
   * @author Martin Vysny
   */
  public final class ButtonBar extends View {
  	/***
  	 * Constructor. This version is only needed if you will be instantiating the
  	 * object manually (not from a layout XML file).
  	 * 
  	 * @param context
  	 * @param rootId
  	 *            Denotes root absolute layout id.
  	 * @param textHintColor
  	 *            text hint color, default white.
  	 * @param textHintBgColor
  	 *            text background color, default 50% transparent black.
  	 * @param extendDown
  	 *            If <code>true</code> (the default) then hovered buttons are
  	 *            extended downwards. If <code>false</code> then buttons are
  	 *            extended upwards.
  	 */
  	public ButtonBar(Context context, final int rootId,
  			final Integer textHintColor, final Integer textHintBgColor,
  			final Boolean extendDown) {
  		super(context);
  		initView();
  		this.rootId = rootId;
  		textPaint.setColor(textHintColor == null ? 0xFFFFFFFF : textHintColor);
  		textBgPaint.setColor(textHintBgColor == null ? 0x88000000
  				: textHintBgColor);
  		this.extendDown = extendDown == null ? true : extendDown;
  		checkValues();
  	}
  
  	/***
  	 * If <code>true</code> (the default) then hovered buttons are extended
  	 * downwards. If <code>false</code> then buttons are extended upwards.
  	 */
  	private boolean extendDown;
  
  	/***
  	 * Denotes root absolute layout id.
  	 */
  	private int rootId;
  
  	/***
  	 * @param context
  	 * @param attrs
  	 * @param defStyle
  	 */
  	public ButtonBar(Context context, AttributeSet attrs, int defStyle) {
  		super(context, attrs, defStyle);
  		init(attrs);
 	}
 
 	/***
 	 * @param context
 	 * @param attrs
 	 */
 	public ButtonBar(Context context, AttributeSet attrs) {
 		super(context, attrs);
 		init(attrs);
 	}
 
 	private void init(final AttributeSet attrs) {
 		initView();
 		final TypedArray a = getContext().obtainStyledAttributes(
 				attrs, R.styleable.ButtonBar);
 		rootId = a.getResourceId(R.styleable.ButtonBar_rootId, -1);
 		textPaint.setColor(a.getColor(R.styleable.ButtonBar_textHintColor,
 				0xFFFFFFFF));
 		textBgPaint.setColor(a.getColor(R.styleable.ButtonBar_textHintBgColor,
 				0x88000000));
 		extendDown = a.getBoolean(R.styleable.ButtonBar_extendDown, true);
 		checkValues();
 	}
 
 	private void checkValues() {
 		if (rootId < 0) {
 			throw new IllegalArgumentException("The rootId attribute missing");
 		}
 	}
 
 	private final void initView() {
 		selectedPaint = new Paint();
 		selectedPaint.setFilterBitmap(true);
 		final ColorMatrix cm = new ColorMatrix();
 		cm.setSaturation(-1f);
 		selectedPaint.setColorFilter(new ColorMatrixColorFilter(cm));
 		normalPaint = new Paint();
 		normalPaint.setFilterBitmap(true);
 		setFocusable(true);
 		setFocusableInTouchMode(false);
 		textPaint.setAntiAlias(true);
 	}
 
 	/***
 	 * The root layout. Floating view will be created as a child of this layout.
 	 */
 	private AbsoluteLayout root = null;
 
 	/***
 	 * A floating image of the button bar. Used to show the bar contents when
 	 * the bar is selected and widened.
 	 * 
 	 * @author Martin Vysny
 	 */
 	private class FloatingImage extends View {
 		private FloatingImage(Context context) {
 			super(context);
 		}
 
 		@Override
 		protected void onDraw(Canvas canvas) {
 			drawOn(canvas);
 		}
 
 		/***
 		 * @see android.view.View#measure(int, int)
 		 */
 		@Override
 		protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 			// we will always be told the exact size
 			setMeasuredDimension(MeasureSpec.getSize(widthMeasureSpec),
 					MeasureSpec.getSize(heightMeasureSpec));
 		}
 	}
 
 	/***
 	 * A floating image of the button bar. Used to show the bar contents when
 	 * the bar is selected and widened. If non-<code>null</code> it is being
 	 * shown on screen.
 	 */
 	private FloatingImage floatingGhost = null;
 
 	@Override
 	protected void onAttachedToWindow() {
 		super.onAttachedToWindow();
 		root = (AbsoluteLayout) getRootView().findViewById(rootId);
 		if (root == null) {
 			throw new IllegalArgumentException("No view with ID " + rootId);
 		}
 		checkMark = BitmapFactory.decodeResource(getResources(),
 				android.R.drawable.checkbox_on_background);
 		createBitmaps();
 	}
 
 	private Bitmap checkMark = null;
 	
 	@Override
 	protected void onDetachedFromWindow() {
 		super.onDetachedFromWindow();
 		destroyGhost();
 		ViewUtils.recycleBitmaps(bitmaps);
 		root = null;
 		if (checkMark != null) {
 			checkMark.recycle();
 			checkMark = null;
 		}
 	}
 
 	private void createGhost(final AbsoluteLayout.LayoutParams lp) {
 		if (root != null) {
 			if (floatingGhost != null)
 				throw new IllegalStateException("Ghost already created");
 			floatingGhost = new FloatingImage(getContext());
 			floatingGhost.setLayoutParams(lp != null ? lp
 					: new AbsoluteLayout.LayoutParams(0, 0, 0, 0));
 			root.addView(floatingGhost);
 			floatingGhost.bringToFront();
 			floatingGhost.setVisibility(View.VISIBLE);
 		}
 	}
 
 	private void destroyGhost() {
 		if ((root != null) && (floatingGhost != null)) {
 			floatingGhost.setVisibility(View.INVISIBLE);
 			root.removeView(floatingGhost);
 			floatingGhost = null;
 		}
 	}
 
 	/***
 	 * Sets a new set of images to be shown.
 	 * 
 	 * @param bitmapResources
 	 *            the drawables to show
 	 * @param activityName
 	 *            the activity captions. If <code>-1</code> then the caption
 	 *            is not shown for the item. May be <code>null</code> if no
 	 *            captions are required to be shown.
 	 * @param bitmapSize
 	 *            the size of all bitmaps. Here the {@link Point} class is not
 	 *            used as a point, it denotes dimension instead.
 	 * @param hoveredBitmapSize
 	 *            the size of hovered bitmap. Here the {@link Point} class is
 	 *            not used as a point, it denotes dimension instead.
 	 */
 	public void setBitmaps(final int[] bitmapResources,
 			final int[] activityName, final Point bitmapSize,
 			final Point hoveredBitmapSize) {
 		createBitmapsIfNeeded(bitmapResources);
 		activityNames.clear();
 		for (int i = 0; i < bitmapResources.length; i++) {
 			final int stringId = activityName == null ? -1 : activityName[i];
 			final String name = stringId < 0 ? null : getResources().getString(
 					stringId);
 			activityNames.add(name);
 		}
 		this.bitmapSize = ViewUtils.clone(bitmapSize);
 		this.hoveredBitmapSize = ViewUtils.clone(hoveredBitmapSize);
 		// clear and recompute internal caches
 		imageXOffsets = null;
 		imageHeights = null;
 		computeZoomFunctionValues();
 		requestLayout();
 		invalidate();
 	}
 
 	private void createBitmapsIfNeeded(int[] bitmapResources) {
 		if ((bitmaps.size() == bitmapResources.length)
 				&& (this.bitmapResources != null)
 				&& Arrays.equals(bitmapResources, this.bitmapResources)) {
 			// prevent unnecessary bitmap creation. This should help prevent
 			// OutOfMemory: bitmap size exceeds VM budget errors
 			return;
 		}
 		this.bitmapResources = bitmapResources.clone();
 		createBitmaps();
 	}
 
 	private void createBitmaps() {
 		ViewUtils.recycleBitmaps(bitmaps);
 		for (int i = 0; i < bitmapResources.length; i++) {
 			bitmaps.add(BitmapFactory.decodeResource(getResources(),
 					bitmapResources[i]));
 		}
 	}
 	
 	/***
 	 * Images resources shown by the button bar.
 	 */
 	private int[] bitmapResources;
 	
 	/***
 	 * Bitmaps loaded by resolving {@link #bitmapResources}.
 	 */
 	private final List<Bitmap> bitmaps = new ArrayList<Bitmap>();
 
 	private final List<String> activityNames = new ArrayList<String>();
 
 	/***
 	 * All bitmaps will be scaled to this size. Here the {@link Point} class is
 	 * not used as a point, it denotes dimension instead.
 	 */
 	private Point bitmapSize = new Point(32, 32);
 
 	/***
 	 * The hovered (the cursor is over this bitmap) bitmap size. Here the
 	 * {@link Point} class is not used as a point, it denotes dimension instead.
 	 */
 	private Point hoveredBitmapSize = new Point(48, 48);
 
 	/***
 	 * The computed view width.
 	 * 
 	 * @return computed view width in pixels.
 	 */
 	private int getViewWidth() {
 		return hoverX >= 0 ? (bitmaps.size() - 1) * bitmapSize.x
 				+ hoveredBitmapSize.x : bitmaps.size() * bitmapSize.x;
 	}
 
 	/***
 	 * Computes the view height.
 	 * 
 	 * @return the view height, depending on current {@link #hoverX} value.
 	 */
 	private int getViewHeight() {
 		return bitmapSize.y;
 	}
 
 	/***
 	 * @see android.view.View#measure(int, int)
 	 */
 	@Override
 	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 		setMeasuredDimension(measureWidth(widthMeasureSpec),
 				measureHeight(heightMeasureSpec));
 	}
 
 	/***
 	 * Determines the width of this view
 	 * 
 	 * @param measureSpec
 	 *            A measureSpec packed into an integer
 	 * @return The width of the view, honoring constraints from measureSpec
 	 */
 	private int measureWidth(int measureSpec) {
 		int specMode = MeasureSpec.getMode(measureSpec);
 		int specSize = MeasureSpec.getSize(measureSpec);
 		if (specMode == MeasureSpec.EXACTLY) {
 			// We were told how big to be
 			return specSize;
 		}
 		return getViewWidth();
 	}
 
 	/***
 	 * Determines the height of this view
 	 * 
 	 * @param measureSpec
 	 *            A measureSpec packed into an integer
 	 * @return The height of the view, honoring constraints from measureSpec
 	 */
 	private int measureHeight(int measureSpec) {
 		int specMode = MeasureSpec.getMode(measureSpec);
 		int specSize = MeasureSpec.getSize(measureSpec);
 		if (specMode == MeasureSpec.EXACTLY) {
 			// We were told how big to be
 			return specSize;
 		}
 		return getViewHeight();
 	}
 
 	/***
 	 * The X coordinate of the hovering cursor.
 	 */
 	private int hoverX = -1;
 
 	/***
 	 * The Y coordinate of the hovering cursor.
 	 */
 	private int hoverY = -1;
 
 	/***
 	 * If <code>true</code> then the cursor is hovering over the view.
 	 */
 	private boolean isHovering;
 
 	/***
 	 * Briefly flash the selected image with this paint.
 	 */
 	private Paint selectedPaint;
 
 	/***
 	 * Paint for regular (non-selected) images.
 	 */
 	private Paint normalPaint;
 
 	/***
 	 * The selected image index.
 	 */
 	private int selectedIndex = -1;
 
 	/***
 	 * Describes the image zoom function. The value in the middle of the array
 	 * denotes the size of the fully zoomed image. Here the {@link Point} class
 	 * is not used as a point, it denotes dimension instead.
 	 */
 	private Point[] zoomFunctionValues;
 
 	private void computeZoomFunctionValues() {
 		final int max = hoveredBitmapSize.x;
 		zoomFunctionValues = new Point[max * 2];
 		for (int i = 0; i < max * 2; i++) {
 			final double angle = Math.PI * i / max / 2;
 			final double sin = Math.sin(angle);
 			final int sizeDiffX = (int) (sin * (hoveredBitmapSize.x - bitmapSize.x));
 			final int sizeDiffY = (int) (sin * (hoveredBitmapSize.y - bitmapSize.y));
 			zoomFunctionValues[i] = new Point(sizeDiffX + bitmapSize.x,
 					sizeDiffY + bitmapSize.y);
 		}
 	}
 
 	/***
 	 * Computes the image size, depending on the destination from the cursor
 	 * center.
 	 * 
 	 * @param delta
 	 *            the delta from the cursor center.
 	 * @return the image size. Must not be modified!
 	 */
 	private Point getSizes(final int delta) {
 		final int absDelta = Math.abs(delta);
 		if (absDelta >= hoveredBitmapSize.x) {
 			return bitmapSize;
 		}
 		final int i = hoveredBitmapSize.x - absDelta;
 		return zoomFunctionValues[i];
 	}
 
 	/***
 	 * Offsets of images in pixels from the left corner of the canvas. Used by
 	 * the drawing algorithm to draw the images correctly.
 	 */
 	private int[] imageXOffsets;
 	/***
 	 * Height of images in pixels. Used by the drawing algorithm to draw the
 	 * images correctly.
 	 */
 	private int[] imageHeights;
 
 	private void computeImageXOffsets() {
 		final int width = getWidth();
 		int hoverX = this.hoverX;
 		if (!isHovering || (hoverY < 0) || (hoverY >= getHeight())) {
 			hoverX = -1000;
 		}
 		if (imageXOffsets == null) {
 			imageXOffsets = new int[bitmaps.size() + 1];
 			imageHeights = new int[bitmaps.size() + 1];
 		}
 		// two-pass algorithm - first recompute the sizes, then offset them to
 		// make the images centered.
 		final int initialX = (width - getViewWidth()) / 2;
 		// some icons might obscured. Scroll if necessary
 		int scrollOffset = 0;
 		if (initialX < 0 && hoverX >= 0 && width > 0) {
 			scrollOffset = initialX * hoverX * 2 / width - initialX;
 			hoverX -= scrollOffset;
 		}
 		int x = initialX;
 		final int bitmapCount = bitmaps.size();
 		final int bitmapSizeDiv2 = bitmapSize.x / 2;
 		int maxSize = 0;
 		int maxSizeIndex = -1;
 		for (int i = 0; i < bitmapCount; i++) {
 			final int imgCenter = x + bitmapSizeDiv2;
 			final Point size = getSizes(hoverX - imgCenter);
 			imageXOffsets[i] = x;
 			imageHeights[i] = size.y;
 			x += size.x;
 			if (maxSize < size.x) {
 				maxSize = size.x;
 				maxSizeIndex = i;
 			}
 		}
 		selectedIndex = maxSize == bitmapSize.x ? -1 : maxSizeIndex;
 		imageXOffsets[bitmaps.size()] = x;
 		// second pass
 		final int expectedEnd = (width + x - initialX) / 2;
 		int delta = expectedEnd - x;
 		delta += scrollOffset;
 		if (delta != 0) {
 			for (int i = 0; i <= bitmapCount; i++) {
 				imageXOffsets[i] += delta;
 			}
 		}
 	}
 
 	/***
 	 * Used to paint hint text.
 	 */
 	private final Paint textPaint = new Paint();
 	/***
 	 * Used to paint hint background.
 	 */
 	private final Paint textBgPaint = new Paint();
 
 	/***
 	 * The view utility instance.
 	 */
 	private final ViewUtils utils = new ViewUtils();
 
 	/***
 	 * A cached rectangle instance used by the {@link #drawOn(Canvas)} method.
 	 */
 	private final Rect drawRect = new Rect();
 
 	@Override
 	protected void onDraw(Canvas canvas) {
 		super.onDraw(canvas);
 		if (floatingGhost != null) {
 			// do nothing, the component contents is actually being painted on
 			// the floating ghost component
 			return;
 		}
 		drawOn(canvas);
 	}
 
 	private final Rect drawCheckedRect = new Rect();
 	
 	private void drawOn(final Canvas canvas) {
 		computeImageXOffsets();
 		drawRect.top = 0;
 		drawRect.bottom = hoveredBitmapSize.y;
 		final int bitmapCount = bitmaps.size();
 		for (int i = 0; i < bitmapCount; i++) {
 			final int size = imageXOffsets[i + 1] - imageXOffsets[i];
 			drawRect.left = imageXOffsets[i];
 			if (extendDown) {
 				drawRect.bottom = imageHeights[i];
 			} else {
 				drawRect.top = hoveredBitmapSize.y - imageHeights[i];
 			}
 			drawRect.right = drawRect.left + size;
 			if (highlight.contains(i)) {
 				// highlight the button
 				canvas.drawRect(drawRect, textBgPaint);
 			}
 			canvas.drawBitmap(bitmaps.get(i), null, drawRect,
 					(i == selectedIndex) ? selectedPaint : normalPaint);
 			if (checked.get(i)) {
 				drawCheckedRect.bottom = drawRect.bottom;
 				drawCheckedRect.right = drawRect.right;
 				drawCheckedRect.left = drawRect.right - checkMark.getWidth();
 				drawCheckedRect.top = drawRect.bottom - checkMark.getHeight();
 				canvas
 						.drawBitmap(checkMark, null, drawCheckedRect,
 								normalPaint);
 			}
 		}
 		// draw the activity name on top of the bitmap.
 		if (selectedIndex >= 0) {
 			final String text = activityNames.get(selectedIndex);
 			if (text != null) {
 				utils.measureTextCache(textPaint, text);
 				drawRect.top = 2;
 				drawRect.bottom = drawRect.top + 4 + utils.measuredText.y;
 				drawRect.left = hoverX - (utils.measuredText.x / 2) - 2;
 				drawRect.right = drawRect.left + 4 + utils.measuredText.x;
 				canvas.drawRect(drawRect, textBgPaint);
 				canvas.drawText(text, drawRect.left + 2, drawRect.top + 2
 						- textPaint.getFontMetricsInt().top, textPaint);
 			}
 		}
 	}
 
 	@Override
 	protected void onLayout(boolean changed, final int left, final int top,
 			final int right, final int bottom) {
 		super.onLayout(changed, left, top, right, bottom);
 		AmbientApplication.getHandler().post(new Runnable() {
 			public void run() {
 				// hide under the floating ghost if needed
 				if (floatingGhost != null) {
 					utils.translateCoordinates(new Point(left, top),
 							(View) getParent(), root);
 					final AbsoluteLayout.LayoutParams lp = (AbsoluteLayout.LayoutParams) floatingGhost
 							.getLayoutParams();
 					lp.width = right - left;
 					lp.height = hoveredBitmapSize.y;
 					lp.x = utils.translated.x;
 					lp.y = utils.translated.y;
 					floatingGhost.setLayoutParams(lp);
 				}
 			}
 		});
 	}
 
 	@Override
 	public boolean onTouchEvent(MotionEvent event) {
 		switch (event.getAction()) {
 		case MotionEvent.ACTION_DOWN:
 			doStart((int) event.getX(), (int) event.getY());
 			break;
 		case MotionEvent.ACTION_UP:
 			doButtonPress(false);
 			break;
 		case MotionEvent.ACTION_CANCEL:
 			doCancel();
 			break;
 		case MotionEvent.ACTION_MOVE:
 			doMove((int) event.getX(), (int) event.getY());
 			break;
 		}
 		return true;
 	}
 
 	private class KeyHandler extends KeyEventHandler {
 		protected KeyHandler() {
 			super();
 		}
 
 		@Override
 		protected boolean onConfirm() {
 			doButtonPress(true);
 			return true;
 		}
 
 		@Override
 		protected boolean onDown() {
 			moveFocus(ButtonBar.this, false);
 			return true;
 		}
 
 		@Override
 		protected boolean onLeft() {
 			move(-bitmapSize.x);
 			return true;
 		}
 
 		@Override
 		protected boolean onRight() {
 			move(bitmapSize.x);
 			return true;
 		}
 
 		@Override
 		protected boolean onUp() {
 			moveFocus(ButtonBar.this, true);
 			return true;
 		}
 		
 		private void move(int delta) {
 			int x = hoverX;
 			if (((delta < 0) && (x > 0)) || ((delta > 0) && (x < getWidth()))) {
 				x += delta;
 			}
 			doMove(x, hoverY);
 		}
 	}
 	
 	private final KeyEventHandler handler=new KeyHandler();
 	
 	@Override
 	public boolean onKeyDown(int keyCode, KeyEvent event) {
 		return handler.onKeyDown(keyCode, event);
 	}
 
 	@Override
 	public boolean onKeyUp(int keyCode, KeyEvent event) {
 		return handler.onKeyUp(keyCode, event);
 	}
 
 	@Override
 	public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
 		return handler.onKeyMultiple(keyCode, repeatCount, event);
 	}
 
 	@Override
 	protected void onFocusChanged(boolean gainFocus, int direction,
 			Rect previouslyFocusedRect) {
 		if (gainFocus) {
 			int startX = getWidth() / 2;
 			if (bitmaps.size() % 2 == 0) {
 				startX += bitmapSize.x / 2;
 			}
 			doStart(startX, 0);
 		} else {
 			doCancel();
 		}
 	}
 
 	private void doMove(final int x, final int y) {
 		if (!isHovering)
 			return;
 		hoverX = x;
 		hoverY = y;
 		invalidate(false);
 	}
 
 	/***
 	 * Activates the button bar.
 	 * 
 	 * @param x
 	 * @param y
 	 */
 	private void doStart(final int x, final int y) {
 		hoverX = x;
 		hoverY = y;
 		if (!isHovering) {
 			isHovering = true;
 			createGhost(null);
 			requestLayout();
 		}
 	}
 
 	/***
 	 * Cancels the button pressing.
 	 */
 	private void doCancel() {
 		if (isHovering) {
 			destroyGhost();
 			hoverX = -1000;
 			isHovering = false;
 			requestLayout();
 		}
 	}
 
 	/***
 	 * Highlighted buttons.
 	 */
 	private Interval highlight = Interval.EMPTY;
 
 	private final static BitSet EMPTY = new BitSet();
 	
 	/***
 	 * Checked buttons.
 	 */
 	private BitSet checked = EMPTY;
 
 	/***
 	 * Highlights given buttons.
 	 * 
 	 * @param interval
 	 *            highlighted buttons. May be <code>null</code> - in this case
 	 *            the interval is empty.
 	 * @param checked
 	 *            a set of checked items.
 	 */
 	public void highlight(final Interval interval, final BitSet checked) {
 		final Interval h = interval == null ? Interval.EMPTY : interval;
 		final BitSet c = checked == null ? EMPTY : checked;
 		if (highlight.equals(h) && c.equals(this.checked)) {
 			return;
 		}
 		highlight = h;
 		this.checked = (BitSet) c.clone();
 		invalidate(true);
 	}
 
 	/***
 	 * Returns the highlight interval.
 	 * 
 	 * @return the highlight interval, never <code>null</code>
 	 */
 	public Interval getHighlight() {
 		return highlight;
 	}
 
 	/***
 	 * Presses a button.
 	 * 
 	 * @param stayHovered
 	 *            if <code>true</code> then the component stays in hover mode.
 	 */
 	private void doButtonPress(final boolean stayHovered) {
 		if (!isHovering) {
 			return;
 		}
 		post(new Runnable() {
 			public void run() {
 				if ((listener != null) && (selectedIndex >= 0)) {
 					listener.onItemClick(null, ButtonBar.this, selectedIndex,
 							selectedIndex);
 				}
 				if (!stayHovered) {
 					destroyGhost();
 					hoverX = -1000;
 					isHovering = false;
 					requestLayout();
 				}
 				invalidate(true);
 			}
 		});
 	}
 
 	/***
 	 * The ONCLICK listener. Both the position and the id fields will hold index
 	 * of image being clicked.
 	 */
 	public OnItemClickListener listener;
 
 	private void invalidate(boolean both) {
 		if (floatingGhost != null) {
 			floatingGhost.invalidate();
 		}
 		if ((floatingGhost == null) || both) {
 			invalidate();
 		}
 	}
 
 	/***
 	 * Returns the current check state.
 	 * 
 	 * @return checked state of the buttons, never <code>null</code>.
 	 */
 	public BitSet getChecked() {
 		return (BitSet) checked.clone();
 	}
 }