HorizontalListView

/*
 * HorizontalListView.java v1.5
 *
 * 
 * The MIT License
 * Copyright (c) 2011 Paul Soucy (paul@dev-smart.com)
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

package com.icangqu.cangqu.widget;

import java.util.LinkedList;
import java.util.Queue;

import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.GestureDetector.OnGestureListener;
import android.view.MotionEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ListAdapter;
import android.widget.Scroller;

public class HorizontalListView extends AdapterView<ListAdapter> {

   public boolean mAlwaysOverrideTouch = true;
   protected ListAdapter mAdapter;
   private int mLeftViewIndex = -1;
   private int mRightViewIndex = 0;
   protected int mCurrentX;
   protected int mNextX;
   private int mMaxX = Integer.MAX_VALUE;
   private int mDisplayOffset = 0;
   protected Scroller mScroller;
   private GestureDetector mGesture;
   private Queue<View> mRemovedViewQueue = new LinkedList<View>();
   private OnItemSelectedListener mOnItemSelected;
   private OnItemClickListener mOnItemClicked;
   private OnItemLongClickListener mOnItemLongClicked;
   private boolean mDataChanged = false;
   

   public HorizontalListView(Context context, AttributeSet attrs) {
      super(context, attrs);
      initView();
   }
   
   private synchronized void initView() {
      mLeftViewIndex = -1;
      mRightViewIndex = 0;
      mDisplayOffset = 0;
      mCurrentX = 0;
      mNextX = 0;
      mMaxX = Integer.MAX_VALUE;
      mScroller = new Scroller(getContext());
      mGesture = new GestureDetector(getContext(), mOnGesture);
   }
   
   @Override
   public void setOnItemSelectedListener(AdapterView.OnItemSelectedListener listener) {
      mOnItemSelected = listener;
   }
   
   @Override
   public void setOnItemClickListener(AdapterView.OnItemClickListener listener){
      mOnItemClicked = listener;
   }
   
   @Override
   public void setOnItemLongClickListener(AdapterView.OnItemLongClickListener listener) {
      mOnItemLongClicked = listener;
   }

   private DataSetObserver mDataObserver = new DataSetObserver() {

      @Override
      public void onChanged() {
         synchronized(HorizontalListView.this){
            mDataChanged = true;
         }
         invalidate();
         requestLayout();
      }

      @Override
      public void onInvalidated() {
         reset();
         invalidate();
         requestLayout();
      }
      
   };

   @Override
   public ListAdapter getAdapter() {
      return mAdapter;
   }

   @Override
   public View getSelectedView() {
      //TODO: implement
      return null;
   }

   @Override
   public void setAdapter(ListAdapter adapter) {
      if(mAdapter != null) {
         mAdapter.unregisterDataSetObserver(mDataObserver);
      }
      mAdapter = adapter;
      mAdapter.registerDataSetObserver(mDataObserver);
      reset();
   }
   
   private synchronized void reset(){
      initView();
      removeAllViewsInLayout();
        requestLayout();
   }

   @Override
   public void setSelection(int position) {
      //TODO: implement
   }
   
   private void addAndMeasureChild(final View child, int viewPos) {
      LayoutParams params = child.getLayoutParams();
      if(params == null) {
         params = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
      }

      addViewInLayout(child, viewPos, params, true);
      child.measure(MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.AT_MOST),
            MeasureSpec.makeMeasureSpec(getHeight(), MeasureSpec.AT_MOST));
   }
   
   

   @Override
   protected synchronized void onLayout(boolean changed, int left, int top, int right, int bottom) {
      super.onLayout(changed, left, top, right, bottom);

      if(mAdapter == null){
         return;
      }
      
      if(mDataChanged){
         int oldCurrentX = mCurrentX;
         initView();
         removeAllViewsInLayout();
         mNextX = oldCurrentX;
         mDataChanged = false;
      }

      if(mScroller.computeScrollOffset()){
         int scrollx = mScroller.getCurrX();
         mNextX = scrollx;
      }
      
      if(mNextX <= 0){
         mNextX = 0;
         mScroller.forceFinished(true);
      }
      if(mNextX >= mMaxX) {
         mNextX = mMaxX;
         mScroller.forceFinished(true);
      }
      
      int dx = mCurrentX - mNextX;
      
      removeNonVisibleItems(dx);
      fillList(dx);
      positionItems(dx);
      
      mCurrentX = mNextX;
      
      if(!mScroller.isFinished()){
         post(new Runnable(){
            @Override
            public void run() {
               requestLayout();
            }
         });
         
      }
   }
   
   private void fillList(final int dx) {
      int edge = 0;
      View child = getChildAt(getChildCount()-1);
      if(child != null) {
         edge = child.getRight();
      }
      fillListRight(edge, dx);
      
      edge = 0;
      child = getChildAt(0);
      if(child != null) {
         edge = child.getLeft();
      }
      fillListLeft(edge, dx);
      
      
   }
   
   private void fillListRight(int rightEdge, final int dx) {
      while(rightEdge + dx < getWidth() && mRightViewIndex < mAdapter.getCount()) {
         
         View child = mAdapter.getView(mRightViewIndex, mRemovedViewQueue.poll(), this);
         addAndMeasureChild(child, -1);
         rightEdge += child.getMeasuredWidth();
         
         if(mRightViewIndex == mAdapter.getCount()-1) {
            mMaxX = mCurrentX + rightEdge - getWidth();
         }
         
         if (mMaxX < 0) {
            mMaxX = 0;
         }
         mRightViewIndex++;
      }
      
   }
   
   private void fillListLeft(int leftEdge, final int dx) {
      while(leftEdge + dx > 0 && mLeftViewIndex >= 0) {
         View child = mAdapter.getView(mLeftViewIndex, mRemovedViewQueue.poll(), this);
         addAndMeasureChild(child, 0);
         leftEdge -= child.getMeasuredWidth();
         mLeftViewIndex--;
         mDisplayOffset -= child.getMeasuredWidth();
      }
   }
   
   private void removeNonVisibleItems(final int dx) {
      View child = getChildAt(0);
      while(child != null && child.getRight() + dx <= 0) {
         mDisplayOffset += child.getMeasuredWidth();
         mRemovedViewQueue.offer(child);
         removeViewInLayout(child);
         mLeftViewIndex++;
         child = getChildAt(0);
         
      }
      
      child = getChildAt(getChildCount()-1);
      while(child != null && child.getLeft() + dx >= getWidth()) {
         mRemovedViewQueue.offer(child);
         removeViewInLayout(child);
         mRightViewIndex--;
         child = getChildAt(getChildCount()-1);
      }
   }
   
   private void positionItems(final int dx) {
      if(getChildCount() > 0){
         mDisplayOffset += dx;
         int left = mDisplayOffset;
         for(int i=0;i<getChildCount();i++){
            View child = getChildAt(i);
            int childWidth = child.getMeasuredWidth();
            child.layout(left, 0, left + childWidth, child.getMeasuredHeight());
            left += childWidth + child.getPaddingRight();
         }
      }
   }
   
   public synchronized void scrollTo(int x) {
      mScroller.startScroll(mNextX, 0, x - mNextX, 0);
      requestLayout();
   }
   
   @Override
   public boolean dispatchTouchEvent(MotionEvent ev) {
      boolean handled = super.dispatchTouchEvent(ev);
      handled |= mGesture.onTouchEvent(ev);
      return handled;
   }
   
   protected boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
            float velocityY) {
      synchronized(HorizontalListView.this){
         mScroller.fling(mNextX, 0, (int)-velocityX, 0, 0, mMaxX, 0, 0);
      }
      requestLayout();
      
      return true;
   }
   
   protected boolean onDown(MotionEvent e) {
      mScroller.forceFinished(true);
      return true;
   }
   
   private OnGestureListener mOnGesture = new GestureDetector.SimpleOnGestureListener() {

      @Override
      public boolean onDown(MotionEvent e) {
         return HorizontalListView.this.onDown(e);
      }

      @Override
      public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
            float velocityY) {
         return HorizontalListView.this.onFling(e1, e2, velocityX, velocityY);
      }

      @Override
      public boolean onScroll(MotionEvent e1, MotionEvent e2,
            float distanceX, float distanceY) {
         
         synchronized(HorizontalListView.this){
            mNextX += (int)distanceX;
         }
         requestLayout();
         
         return true;
      }

      @Override
      public boolean onSingleTapConfirmed(MotionEvent e) {
         for(int i=0;i<getChildCount();i++){
            View child = getChildAt(i);
            if (isEventWithinView(e, child)) {
               if(mOnItemClicked != null){
                  mOnItemClicked.onItemClick(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId( mLeftViewIndex + 1 + i ));
               }
               if(mOnItemSelected != null){
                  mOnItemSelected.onItemSelected(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId( mLeftViewIndex + 1 + i ));
               }
               break;
            }
            
         }
         return true;
      }
      
      @Override
      public void onLongPress(MotionEvent e) {
         int childCount = getChildCount();
         for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            if (isEventWithinView(e, child)) {
               if (mOnItemLongClicked != null) {
                  mOnItemLongClicked.onItemLongClick(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId(mLeftViewIndex + 1 + i));
               }
               break;
            }

         }
      }

      private boolean isEventWithinView(MotionEvent e, View child) {
            Rect viewRect = new Rect();
            int[] childPosition = new int[2];
            child.getLocationOnScreen(childPosition);
            int left = childPosition[0];
            int right = left + child.getWidth();
            int top = childPosition[1];
            int bottom = top + child.getHeight();
            viewRect.set(left, top, right, bottom);
            return viewRect.contains((int) e.getRawX(), (int) e.getRawY());
        }
   };

   

}