{
+ private final K key;
+
+ private V value;
+
+ public XYEntry(K key, V value) {
+ this.key = key;
+ this.value = value;
+ }
+
+ public K getKey() {
+ return key;
+ }
+
+ public V getValue() {
+ return value;
+ }
+
+ public V setValue(V object) {
+ this.value = object;
+ return this.value;
+ }
+}
\ No newline at end of file
diff --git a/src/org/achartengine/util/package.html b/src/org/achartengine/util/package.html
new file mode 100644
index 0000000..a322b2d
--- /dev/null
+++ b/src/org/achartengine/util/package.html
@@ -0,0 +1,6 @@
+
+AChartEngine
+
+Utility classes that provide helper methods used by most of the other packages.
+
+
\ No newline at end of file
diff --git a/src/zrc/util/APIUtil.java b/src/zrc/util/APIUtil.java
new file mode 100644
index 0000000..d6ee5b2
--- /dev/null
+++ b/src/zrc/util/APIUtil.java
@@ -0,0 +1,9 @@
+package zrc.util;
+
+import android.os.Build;
+
+public class APIUtil {
+ public static boolean isSupport(int apiNo){
+ return Build.VERSION.SDK_INT >= apiNo;
+ }
+}
diff --git a/src/zrc/widget/Footable.java b/src/zrc/widget/Footable.java
new file mode 100644
index 0000000..e38d096
--- /dev/null
+++ b/src/zrc/widget/Footable.java
@@ -0,0 +1,9 @@
+package zrc.widget;
+
+import android.graphics.Canvas;
+
+public interface Footable {
+ boolean draw(Canvas canvas, int left, int top, int right, int bottom);
+
+ int getHeight();
+}
diff --git a/src/zrc/widget/Headable.java b/src/zrc/widget/Headable.java
new file mode 100644
index 0000000..37c1376
--- /dev/null
+++ b/src/zrc/widget/Headable.java
@@ -0,0 +1,23 @@
+package zrc.widget;
+
+import android.content.Context;
+import android.graphics.Canvas;
+
+public interface Headable {
+ public static final int STATE_REST = 0;
+ public static final int STATE_LOADING = 1;
+ public static final int STATE_SUCCESS = 2;
+ public static final int STATE_FAIL = 3;
+ public static final int STATE_PULL = 4;
+ public static final int STATE_RELEASE = 5;
+
+ void stateChange(int state, String msg);
+
+ int getState();
+
+ boolean draw(Canvas canvas, int left, int top, int right, int bottom);
+
+ void toastResultInOtherWay(Context context, int state);
+
+ int getHeight();
+}
diff --git a/src/zrc/widget/HeaderViewListAdapter.java b/src/zrc/widget/HeaderViewListAdapter.java
new file mode 100644
index 0000000..ff90cf4
--- /dev/null
+++ b/src/zrc/widget/HeaderViewListAdapter.java
@@ -0,0 +1,271 @@
+/*
+ * 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 zrc.widget;
+
+import java.util.ArrayList;
+
+import android.database.DataSetObserver;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ListAdapter;
+import android.widget.WrapperListAdapter;
+
+/**
+ * ListAdapter used when a ListView has header views. This ListAdapter wraps
+ * another one and also keeps track of the header views and their associated
+ * data objects.
+ *
+ * This is intended as a base class; you will probably not need to use this
+ * class directly in your own code.
+ */
+public class HeaderViewListAdapter implements WrapperListAdapter {
+
+ private final ListAdapter mAdapter;
+
+ // These two ArrayList are assumed to NOT be null.
+ // They are indeed created when declared in ListView and then shared.
+ ArrayList mHeaderViewInfos;
+ ArrayList mFooterViewInfos;
+
+ // Used as a placeholder in case the provided info views are indeed null.
+ // Currently only used by some CTS tests, which may be removed.
+ static final ArrayList EMPTY_INFO_LIST = new ArrayList();
+
+ boolean mAreAllFixedViewsSelectable;
+
+ public HeaderViewListAdapter(ArrayList headerViewInfos,
+ ArrayList footerViewInfos, ListAdapter adapter) {
+ mAdapter = adapter;
+
+ if (headerViewInfos == null) {
+ mHeaderViewInfos = EMPTY_INFO_LIST;
+ } else {
+ mHeaderViewInfos = headerViewInfos;
+ }
+
+ if (footerViewInfos == null) {
+ mFooterViewInfos = EMPTY_INFO_LIST;
+ } else {
+ mFooterViewInfos = footerViewInfos;
+ }
+
+ mAreAllFixedViewsSelectable = areAllListInfosSelectable(mHeaderViewInfos)
+ && areAllListInfosSelectable(mFooterViewInfos);
+ }
+
+ public int getHeadersCount() {
+ return mHeaderViewInfos.size();
+ }
+
+ public int getFootersCount() {
+ return mFooterViewInfos.size();
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return mAdapter == null || mAdapter.isEmpty();
+ }
+
+ private boolean areAllListInfosSelectable(ArrayList infos) {
+ if (infos != null) {
+ for (ZrcListView.FixedViewInfo info : infos) {
+ if (!info.isSelectable) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ public boolean removeHeader(View v) {
+ for (int i = 0; i < mHeaderViewInfos.size(); i++) {
+ ZrcListView.FixedViewInfo info = mHeaderViewInfos.get(i);
+ if (info.view == v) {
+ mHeaderViewInfos.remove(i);
+
+ mAreAllFixedViewsSelectable = areAllListInfosSelectable(mHeaderViewInfos)
+ && areAllListInfosSelectable(mFooterViewInfos);
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public boolean removeFooter(View v) {
+ for (int i = 0; i < mFooterViewInfos.size(); i++) {
+ ZrcListView.FixedViewInfo info = mFooterViewInfos.get(i);
+ if (info.view == v) {
+ mFooterViewInfos.remove(i);
+
+ mAreAllFixedViewsSelectable = areAllListInfosSelectable(mHeaderViewInfos)
+ && areAllListInfosSelectable(mFooterViewInfos);
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ @Override
+ public int getCount() {
+ if (mAdapter != null) {
+ return getFootersCount() + getHeadersCount() + mAdapter.getCount();
+ } else {
+ return getFootersCount() + getHeadersCount();
+ }
+ }
+
+ @Override
+ public boolean areAllItemsEnabled() {
+ if (mAdapter != null) {
+ return mAreAllFixedViewsSelectable && mAdapter.areAllItemsEnabled();
+ } else {
+ return true;
+ }
+ }
+
+ @Override
+ public boolean isEnabled(int position) {
+ // Header (negative positions will throw an IndexOutOfBoundsException)
+ int numHeaders = getHeadersCount();
+ if (position < numHeaders) {
+ return mHeaderViewInfos.get(position).isSelectable;
+ }
+
+ // Adapter
+ final int adjPosition = position - numHeaders;
+ int adapterCount = 0;
+ if (mAdapter != null) {
+ adapterCount = mAdapter.getCount();
+ if (adjPosition < adapterCount) {
+ return mAdapter.isEnabled(adjPosition);
+ }
+ }
+
+ // Footer (off-limits positions will throw an IndexOutOfBoundsException)
+ return mFooterViewInfos.get(adjPosition - adapterCount).isSelectable;
+ }
+
+ @Override
+ public Object getItem(int position) {
+ // Header (negative positions will throw an IndexOutOfBoundsException)
+ int numHeaders = getHeadersCount();
+ if (position < numHeaders) {
+ return mHeaderViewInfos.get(position).data;
+ }
+
+ // Adapter
+ final int adjPosition = position - numHeaders;
+ int adapterCount = 0;
+ if (mAdapter != null) {
+ adapterCount = mAdapter.getCount();
+ if (adjPosition < adapterCount) {
+ return mAdapter.getItem(adjPosition);
+ }
+ }
+
+ // Footer (off-limits positions will throw an IndexOutOfBoundsException)
+ return mFooterViewInfos.get(adjPosition - adapterCount).data;
+ }
+
+ @Override
+ public long getItemId(int position) {
+ int numHeaders = getHeadersCount();
+ if (mAdapter != null && position >= numHeaders) {
+ int adjPosition = position - numHeaders;
+ int adapterCount = mAdapter.getCount();
+ if (adjPosition < adapterCount) {
+ return mAdapter.getItemId(adjPosition);
+ }
+ }
+ return -1;
+ }
+
+ @Override
+ public boolean hasStableIds() {
+ if (mAdapter != null) {
+ return mAdapter.hasStableIds();
+ }
+ return false;
+ }
+
+ @Override
+ public View getView(int position, View convertView, ViewGroup parent) {
+ // Header (negative positions will throw an IndexOutOfBoundsException)
+ int numHeaders = getHeadersCount();
+ if (position < numHeaders) {
+ return mHeaderViewInfos.get(position).view;
+ }
+
+ // Adapter
+ final int adjPosition = position - numHeaders;
+ int adapterCount = 0;
+ if (mAdapter != null) {
+ adapterCount = mAdapter.getCount();
+ if (adjPosition < adapterCount) {
+ return mAdapter.getView(adjPosition, convertView, parent);
+ }
+ }
+
+ // Footer (off-limits positions will throw an IndexOutOfBoundsException)
+ return mFooterViewInfos.get(adjPosition - adapterCount).view;
+ }
+
+ @Override
+ public int getItemViewType(int position) {
+ int numHeaders = getHeadersCount();
+ if (mAdapter != null && position >= numHeaders) {
+ int adjPosition = position - numHeaders;
+ int adapterCount = mAdapter.getCount();
+ if (adjPosition < adapterCount) {
+ return mAdapter.getItemViewType(adjPosition);
+ }
+ }
+
+ return ZrcAdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER;
+ }
+
+ @Override
+ public int getViewTypeCount() {
+ if (mAdapter != null) {
+ return mAdapter.getViewTypeCount();
+ }
+ return 1;
+ }
+
+ @Override
+ public void registerDataSetObserver(DataSetObserver observer) {
+ if (mAdapter != null) {
+ mAdapter.registerDataSetObserver(observer);
+ }
+ }
+
+ @Override
+ public void unregisterDataSetObserver(DataSetObserver observer) {
+ if (mAdapter != null) {
+ mAdapter.unregisterDataSetObserver(observer);
+ }
+ }
+
+ @Override
+ public ListAdapter getWrappedAdapter() {
+ return mAdapter;
+ }
+}
diff --git a/src/zrc/widget/SimpleFooter.java b/src/zrc/widget/SimpleFooter.java
new file mode 100644
index 0000000..ce55796
--- /dev/null
+++ b/src/zrc/widget/SimpleFooter.java
@@ -0,0 +1,60 @@
+package zrc.widget;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.Paint.Style;
+import android.util.TypedValue;
+
+public class SimpleFooter implements Footable {
+ private float PI = (float) Math.PI;
+ private int mPice = 6;
+ private Paint mPaint;
+ private int mTime = 0;
+ private int mCircleColor;
+ private int mHeight;
+
+ public SimpleFooter(Context context) {
+ mPaint = new Paint();
+ mPaint.setAntiAlias(true);
+ mPaint.setStyle(Style.FILL);
+ int fontSize = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 20, context.getResources()
+ .getDisplayMetrics());
+ mPaint.setTextSize(fontSize);
+ mPaint.setTextAlign(Align.CENTER);
+ mCircleColor = 0xffffffff;
+ mHeight = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 30, context.getResources()
+ .getDisplayMetrics());
+ }
+
+ public void setCircleColor(int color) {
+ mCircleColor = color;
+ }
+
+ @Override
+ public boolean draw(Canvas canvas, int left, int top, int right, int bottom) {
+ final int width = right - left;
+ final int height = mHeight;
+ final int viewHeight = bottom - top;
+ canvas.save();
+ canvas.clipRect(left + 5, top + 1, right + 5, bottom - 1);
+ mPaint.setColor(mCircleColor);
+ for (int i = 0; i < mPice; i++) {
+ int angleParam = mTime * 5;
+ float angle = -(i * (360 / mPice) - angleParam) * PI / 180;
+ float radius = height / 4;
+ float x = (float) (width / 2 + radius * Math.cos(angle));
+ float y = (float) (top + Math.max(height, viewHeight) / 2 + radius * Math.sin(angle));
+ canvas.drawCircle(x, y, height / 15, mPaint);
+ }
+ mTime++;
+ canvas.restore();
+ return true;
+ }
+
+ @Override
+ public int getHeight() {
+ return mHeight;
+ }
+}
diff --git a/src/zrc/widget/SimpleHeader.java b/src/zrc/widget/SimpleHeader.java
new file mode 100644
index 0000000..46c4ab6
--- /dev/null
+++ b/src/zrc/widget/SimpleHeader.java
@@ -0,0 +1,191 @@
+package zrc.widget;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.Paint.Style;
+import android.util.TypedValue;
+import android.widget.Toast;
+
+public class SimpleHeader implements Headable {
+ private float PI = (float) Math.PI;
+ private int mState = STATE_REST;
+ private int mPice = 6;
+ private Paint mPaint;
+ private int mHeight = 0;
+ private int mTime = 0;
+ private int mTextColor;
+ private int mPointColor;
+ private float mPointRadius = 0;
+ private float mCircleRadius = 0;
+ private float mFontOffset;
+ private String mMsg;
+ private boolean isClipCanvas = true;
+
+ public SimpleHeader(Context context) {
+ mPaint = new Paint();
+ mPaint.setAntiAlias(true);
+ mPaint.setStyle(Style.FILL);
+ int fontSize = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 20, context.getResources()
+ .getDisplayMetrics());
+ mPaint.setTextSize(fontSize);
+ mPaint.setTextAlign(Align.CENTER);
+ mTextColor = 0xffffffff;
+ mPointColor = 0xffffffff;
+ mFontOffset = -(mPaint.getFontMetrics().top + mPaint.getFontMetrics().bottom) / 2;
+ mHeight = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 45, context.getResources()
+ .getDisplayMetrics());
+ mPointRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 2.5f, context.getResources()
+ .getDisplayMetrics());
+ mCircleRadius = mPointRadius * 3.5f;
+ }
+
+ public void setTextColor(int color) {
+ mTextColor = color;
+ }
+
+ public void setCircleColor(int color) {
+ mPointColor = color;
+ }
+
+ public void setIsClipCanvas(boolean bool) {
+ isClipCanvas = bool;
+ }
+
+ @Override
+ public void stateChange(int state, String msg) {
+ if (mState != state) {
+ mTime = 0;
+ }
+ mState = state;
+ this.mMsg = msg;
+ }
+
+ @Override
+ public int getState() {
+ return mState;
+ }
+
+ @Override
+ public boolean draw(Canvas canvas, int left, int top, int right, int bottom) {
+ boolean more = false;
+ final int width = right - left;
+ final int height = mHeight;
+ final int offset = bottom - top;
+ canvas.save();
+ if (isClipCanvas) {
+ canvas.clipRect(left + 5, 1, right + 5, bottom - 1);
+ }
+ switch (mState) {
+ case STATE_REST:
+ break;
+ case STATE_PULL:
+ case STATE_RELEASE:
+ if (offset < 10) {
+ break;
+ }
+ mPaint.setColor(mPointColor);
+ for (int i = 0; i < mPice; i++) {
+ // else paint.setColor(Color.rgb(50, 50, 50));
+ int angleParam;
+ if (offset < height * 3 / 4) {
+ angleParam = offset * 16 / height - 3;// 每1%转0.16度;
+ } else {
+ angleParam = offset * 300 / height - 217;// 每1%转3度;
+ }
+ float angle = -(i * (360 / mPice) - angleParam) * PI / 180;
+ float radiusParam;
+ if (offset <= height) {
+ radiusParam = offset / (float) height;
+ radiusParam = 1 - radiusParam;
+ radiusParam *= radiusParam;
+ radiusParam = 1 - radiusParam;
+ } else {
+ radiusParam = 1;
+ }
+ float radius = width / 2 - radiusParam * (width / 2 - mCircleRadius);
+ float x = (float) (width / 2 + radius * Math.cos(angle));
+ float y = (float) (offset / 2 + radius * Math.sin(angle));
+ canvas.drawCircle(x, y + top, mPointRadius, mPaint);
+ }
+ break;
+ case STATE_LOADING:
+ more = true;
+ mPaint.setColor(mPointColor);
+ for (int i = 0; i < mPice; i++) {
+ int angleParam = mTime * 5;
+ float angle = -(i * (360 / mPice) - angleParam) * PI / 180;
+ float radius = mCircleRadius;
+ float x = (float) (width / 2 + radius * Math.cos(angle));
+ float y;
+ if (offset < height) {
+ y = (float) (offset - height / 2 + radius * Math.sin(angle));
+ } else {
+ y = (float) (offset / 2 + radius * Math.sin(angle));
+ }
+ canvas.drawCircle(x, y + top, mPointRadius, mPaint);
+ }
+ mTime++;
+ break;
+ case STATE_SUCCESS:
+ case STATE_FAIL:
+ more = true;
+ final int time = mTime;
+ if (time < 30) {
+ mPaint.setColor(mPointColor);
+ for (int i = 0; i < mPice; i++) {
+ int angleParam = mTime * 10;
+ float angle = -(i * (360 / mPice) - angleParam) * PI / 180;
+ float radius = mCircleRadius + time * mCircleRadius;
+ float x = (float) (width / 2 + radius * Math.cos(angle));
+ float y;
+ if (offset < height) {
+ y = (float) (offset - height / 2 + radius * Math.sin(angle));
+ } else {
+ y = (float) (offset / 2 + radius * Math.sin(angle));
+ }
+ canvas.drawCircle(x, y + top, mPointRadius, mPaint);
+ }
+ mPaint.setColor(mTextColor);
+ mPaint.setAlpha(time * 255 / 30);
+ String text = mMsg != null ? mMsg : mState == STATE_SUCCESS ? "加载成功" : "加载失败";
+ float y;
+ if (offset < height) {
+ y = offset - height / 2;
+ } else {
+ y = offset / 2;
+ }
+ canvas.drawText(text, width / 2, y + top + mFontOffset, mPaint);
+ } else {
+ mPaint.setColor(mTextColor);
+ String text = mMsg != null ? mMsg : mState == STATE_SUCCESS ? "加载成功" : "加载失败";
+ float y;
+ if (offset < height) {
+ y = offset - height / 2;
+ mPaint.setAlpha(offset * 255 / height);
+ } else {
+ y = offset / 2;
+ }
+ canvas.drawText(text, width / 2, y + top + mFontOffset, mPaint);
+ }
+ mTime++;
+ break;
+ }
+ canvas.restore();
+ return more;
+ }
+
+ @Override
+ public void toastResultInOtherWay(Context context, int state) {
+ if (state == Headable.STATE_SUCCESS) {
+ } else if (state == Headable.STATE_FAIL) {
+ Toast.makeText(context, mMsg != null ? mMsg : "加载失败", Toast.LENGTH_SHORT).show();
+ }
+ }
+
+ @Override
+ public int getHeight() {
+ return mHeight;
+ }
+}
diff --git a/src/zrc/widget/ZrcAbsListView.java b/src/zrc/widget/ZrcAbsListView.java
new file mode 100644
index 0000000..10efbbe
--- /dev/null
+++ b/src/zrc/widget/ZrcAbsListView.java
@@ -0,0 +1,2443 @@
+package zrc.widget;
+
+import java.util.ArrayList;
+import java.util.List;
+
+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.graphics.drawable.TransitionDrawable;
+import android.os.Build;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.support.v4.util.LongSparseArray;
+import android.support.v4.util.SparseArrayCompat;
+import android.support.v4.view.ViewCompat;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.HapticFeedbackConstants;
+import android.view.InputDevice;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewDebug;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.view.ViewTreeObserver;
+import android.view.animation.Interpolator;
+import android.widget.ListAdapter;
+import android.widget.Scroller;
+
+import zrc.util.APIUtil;
+import zrc.widget.ZrcListView.OnScrollListener;
+import zrc.widget.ZrcListView.OnScrollStateListener;
+import zrc.widget.ZrcListView.OnStartListener;
+
+abstract class ZrcAbsListView extends ZrcAdapterView implements ViewTreeObserver.OnTouchModeChangeListener {
+ public static final int TRANSCRIPT_MODE_DISABLED = 0;
+ public static final int TRANSCRIPT_MODE_NORMAL = 1;
+ public static final int TRANSCRIPT_MODE_ALWAYS_SCROLL = 2;
+ static final int TOUCH_MODE_INVALID = -2;
+ static final int TOUCH_MODE_REST = -1;
+ static final int TOUCH_MODE_DOWN = 0;
+ static final int TOUCH_MODE_TAP = 1;
+ static final int TOUCH_MODE_DONE_WAITING = 2;
+ static final int TOUCH_MODE_SCROLL = 3;
+ static final int TOUCH_MODE_FLING = 4;
+ static final int TOUCH_MODE_RESCROLL = 5;
+ static final int LAYOUT_NORMAL = 0;
+ static final int LAYOUT_FORCE_TOP = 1;
+ static final int LAYOUT_FORCE_BOTTOM = 3;
+ int mLayoutMode = LAYOUT_NORMAL;
+ AdapterDataSetObserver mDataSetObserver;
+ ListAdapter mAdapter;
+ boolean mAdapterHasStableIds;
+ boolean mDrawSelectorOnTop = false;
+ Drawable mSelector;
+ int mSelectorPosition = INVALID_POSITION;
+ Rect mSelectorRect = new Rect();
+ final RecycleBin mRecycler = new RecycleBin();
+ Rect mListPadding = new Rect();
+ int mWidthMeasureSpec = 0;
+ View mScrollUp;
+ View mScrollDown;
+ boolean mCachingStarted;
+ boolean mCachingActive;
+ int mMotionPosition;
+ int mMotionX;
+ int mMotionY;
+ int mTouchMode = TOUCH_MODE_REST;
+ int mLastY;
+ int mMotionCorrection;
+ private VelocityTracker mVelocityTracker;
+ private FlingRunnable mFlingRunnable;
+ boolean mScrollingCacheEnabled;
+ private OnScrollListener mOnScrollListener;
+ private boolean mSmoothScrollbarEnabled = true;
+ private Rect mTouchFrame;
+ private static final int TOUCH_MODE_UNKNOWN = -1;
+ private static final int TOUCH_MODE_ON = 0;
+ private static final int TOUCH_MODE_OFF = 1;
+ private int mLastTouchMode = TOUCH_MODE_UNKNOWN;
+ private ZrcAbsListView.PerformClick mPerformClick;
+ private Runnable mPendingCheckForTap;
+ private Runnable mTouchModeReset;
+ private int mTranscriptMode;
+ private int mCacheColorHint;
+ private boolean mIsChildViewEnabled;
+ private int mLastScrollState = OnScrollListener.SCROLL_STATE_IDLE;
+ private int mTouchSlop;
+ private Runnable mClearScrollingCache;
+ Runnable mPositionScrollAfterLayout;
+ private int mMinimumVelocity;
+ private int mMaximumVelocity;
+ private float mVelocityScale = 1.0f;
+ final boolean[] mIsScrap = new boolean[1];
+ private int mActivePointerId = INVALID_POINTER;
+ private static final int INVALID_POINTER = -1;
+ protected boolean mIsAttached;
+ private Headable mZrcHeader;
+ private Footable mZrcFooter;
+ private OnStartListener onRefreshStart;
+ private OnStartListener onLoadMoreStart;
+ private OnScrollStateListener onScrollStateListener;
+ private int mScrollState = OnScrollStateListener.EDGE;
+ protected boolean showHeader = false;
+ private boolean isLoadingMore = false;
+ private boolean isLoadMoreOn = false;
+ private boolean isRefreshing = false;
+ protected int mFirstTopOffset = 0;
+ protected int mLastBottomOffset = 0;
+ protected float mDensity = 0;
+
+ private Runnable mResetRunnable = new Runnable() {
+ @Override
+ public void run() {
+ mZrcHeader.stateChange(Headable.STATE_REST, null);
+ }
+ };
+
+ public ZrcAbsListView(Context context) {
+ super(context);
+ initAbsListView();
+ }
+
+ public ZrcAbsListView(Context context, AttributeSet attrs) {
+ this(context, attrs, android.R.attr.absListViewStyle);
+ }
+
+ public ZrcAbsListView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ initAbsListView();
+ TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ZrcAbsListView, defStyle, 0);
+ Drawable d = a.getDrawable(R.styleable.ZrcAbsListView_android_listSelector);
+ if (d != null) {
+ setSelector(d);
+ }
+ mDrawSelectorOnTop = a.getBoolean(R.styleable.ZrcAbsListView_android_drawSelectorOnTop, false);
+ boolean scrollingCacheEnabled = a.getBoolean(R.styleable.ZrcAbsListView_android_scrollingCache, true);
+ setScrollingCacheEnabled(scrollingCacheEnabled);
+ int transcriptMode = a.getInt(R.styleable.ZrcAbsListView_android_transcriptMode, TRANSCRIPT_MODE_DISABLED);
+ setTranscriptMode(transcriptMode);
+ int color = a.getColor(R.styleable.ZrcAbsListView_android_cacheColorHint, 0);
+ setCacheColorHint(color);
+ boolean smoothScrollbar = a.getBoolean(R.styleable.ZrcAbsListView_android_smoothScrollbar, true);
+ setSmoothScrollbarEnabled(smoothScrollbar);
+ a.recycle();
+ }
+
+ @TargetApi(Build.VERSION_CODES.GINGERBREAD)
+ private void initAbsListView() {
+ setClickable(true);
+ setFocusableInTouchMode(true);
+ setWillNotDraw(false);
+ setAlwaysDrawnWithCacheEnabled(false);
+ setScrollingCacheEnabled(true);
+ final ViewConfiguration configuration = ViewConfiguration.get(getContext());
+ mTouchSlop = configuration.getScaledTouchSlop();
+ mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
+ mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
+ mDensity = getResources().getDisplayMetrics().density;
+ }
+
+ @Override
+ public void setAdapter(ListAdapter adapter) {
+ if (adapter != null) {
+ mAdapterHasStableIds = mAdapter.hasStableIds();
+ }
+ }
+
+ @Override
+ public boolean performItemClick(View view, int position, long id) {
+ boolean handled = false;
+ boolean dispatchItemClick = true;
+ if (dispatchItemClick) {
+ handled |= super.performItemClick(view, position, id);
+ }
+ return handled;
+ }
+
+ public void setSmoothScrollbarEnabled(boolean enabled) {
+ mSmoothScrollbarEnabled = enabled;
+ }
+
+ @ViewDebug.ExportedProperty
+ public boolean isSmoothScrollbarEnabled() {
+ return mSmoothScrollbarEnabled;
+ }
+
+ public void setOnScrollListener(OnScrollListener l) {
+ mOnScrollListener = l;
+ invokeOnItemScrollListener();
+ }
+
+ void invokeOnItemScrollListener() {
+ if (mOnScrollListener != null) {
+ mOnScrollListener.onScroll(this, mFirstPosition, getChildCount(), mItemCount);
+ }
+ onScrollChanged(0, 0, 0, 0);
+ }
+
+ @ViewDebug.ExportedProperty
+ public boolean isScrollingCacheEnabled() {
+ return mScrollingCacheEnabled;
+ }
+
+ public void setScrollingCacheEnabled(boolean enabled) {
+ if (mScrollingCacheEnabled && !enabled) {
+ clearScrollingCache();
+ }
+ mScrollingCacheEnabled = enabled;
+ }
+
+ @Override
+ public void getFocusedRect(Rect r) {
+ super.getFocusedRect(r);
+ }
+
+ private void useDefaultSelector() {
+ setSelector(getResources().getDrawable(android.R.drawable.list_selector_background));
+ }
+
+ void requestLayoutIfNecessary() {
+ if (getChildCount() > 0) {
+ resetList();
+ requestLayout();
+ invalidate();
+ }
+ }
+
+ @Override
+ protected void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
+ super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+ if (gainFocus && !isInTouchMode()) {
+ if (!mIsAttached && mAdapter != null) {
+ mDataChanged = true;
+ mOldItemCount = mItemCount;
+ mItemCount = mAdapter.getCount();
+ }
+ }
+ }
+
+ @Override
+ public void requestLayout() {
+ if (!mBlockLayoutRequests && !mInLayout) {
+ super.requestLayout();
+ }
+ }
+
+ void resetList() {
+ removeAllViewsInLayout();
+ mFirstPosition = 0;
+ mFirstTop = mFirstTopOffset + mListPadding.top;
+ mDataChanged = false;
+ mPositionScrollAfterLayout = null;
+ mSelectorPosition = INVALID_POSITION;
+ mSelectorRect.setEmpty();
+ invalidate();
+ }
+
+ @Override
+ protected int computeVerticalScrollExtent() {
+ final int count = getChildCount();
+ if (count > 0) {
+ if (mSmoothScrollbarEnabled) {
+ final int range = (getHeight() - mFirstTopOffset - mLastBottomOffset) * 10;
+ final int cnt = mItemCount;
+ int extent = count * range / cnt;
+ View view = getChildAt(0);
+ final int top = view.getTop();
+ int height = view.getHeight();
+ if (height > 0 && top < 0) {
+ extent += (top * range) / height / cnt;
+ }
+ view = getChildAt(count - 1);
+ final int bottom = view.getBottom();
+ height = view.getHeight();
+ if (height > 0 && bottom > getHeight()) {
+ extent -= ((bottom - getHeight()) * range) / height / cnt;
+ }
+ return extent;
+ } else {
+ return 1;
+ }
+ }
+ return 0;
+ }
+
+ @Override
+ protected int computeVerticalScrollOffset() {
+ final int firstPosition = mFirstPosition;
+ final int childCount = getChildCount();
+ final int mScrollY = getScrollY();
+ if (firstPosition >= 0 && childCount > 0) {
+ if (mSmoothScrollbarEnabled) {
+ final View view = getChildAt(0);
+ final int top = view.getTop() - mFirstTopOffset;
+ int height = view.getHeight();
+ final int range = (getHeight() - mFirstTopOffset - mLastBottomOffset) * 10;
+ final int count = mItemCount;
+ if (height > 0) {
+ return Math.max((firstPosition * range - top * range / height) / count + mFirstTopOffset * 10
+ + mScrollY * 10, mFirstTopOffset * 10);
+ }
+ } else {
+ int index;
+ final int count = mItemCount;
+ if (firstPosition == 0) {
+ index = 0;
+ } else if (firstPosition + childCount == count) {
+ index = count;
+ } else {
+ index = firstPosition + childCount / 2;
+ }
+ return (int) (firstPosition + childCount * (index / (float) count));
+ }
+ }
+ return 0;
+ }
+
+ @Override
+ protected int computeVerticalScrollRange() {
+ int result;
+ if (mSmoothScrollbarEnabled) {
+ result = Math.max(getHeight() * 10, 0);
+ } else {
+ result = mItemCount;
+ }
+ return result;
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ if (mSelector == null) {
+ useDefaultSelector();
+ }
+ final Rect listPadding = mListPadding;
+ listPadding.left = getPaddingLeft();
+ listPadding.top = getPaddingTop();
+ listPadding.right = getPaddingRight();
+ listPadding.bottom = getPaddingBottom();
+ }
+
+ @Override
+ protected void onLayout(boolean changed, int l, int t, int r, int b) {
+ mInLayout = true;
+ if (changed) {
+ int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ getChildAt(i).forceLayout();
+ }
+ mRecycler.markChildrenDirty();
+ }
+ layoutChildren();
+ mInLayout = false;
+ }
+
+ protected void layoutChildren() {
+ }
+
+ void updateScrollIndicators() {
+ if (mScrollUp != null) {
+ boolean canScrollUp;
+ canScrollUp = mFirstPosition > 0;
+ if (!canScrollUp) {
+ if (getChildCount() > 0) {
+ View child = getChildAt(0);
+ canScrollUp = child.getTop() < mListPadding.top;
+ }
+ }
+ mScrollUp.setVisibility(canScrollUp ? View.VISIBLE : View.INVISIBLE);
+ }
+ if (mScrollDown != null) {
+ boolean canScrollDown;
+ int count = getChildCount();
+ canScrollDown = (mFirstPosition + count) < mItemCount;
+ if (!canScrollDown && count > 0) {
+ View child = getChildAt(count - 1);
+ canScrollDown = child.getBottom() > getBottom() - mListPadding.bottom;
+ }
+ mScrollDown.setVisibility(canScrollDown ? View.VISIBLE : View.INVISIBLE);
+ }
+ }
+
+ public int getListPaddingTop() {
+ return mListPadding.top;
+ }
+
+ public int getListPaddingBottom() {
+ return mListPadding.bottom;
+ }
+
+ public int getListPaddingLeft() {
+ return mListPadding.left;
+ }
+
+ public int getListPaddingRight() {
+ return mListPadding.right;
+ }
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+ View obtainView(int position, boolean[] isScrap) {
+ isScrap[0] = false;
+ View scrapView;
+ scrapView = mRecycler.getTransientStateView(position);
+ if (scrapView == null) {
+ scrapView = mRecycler.getScrapView(position);
+ }
+ View child;
+ if (scrapView != null) {
+ child = mAdapter.getView(position, scrapView, this);
+ if (child != scrapView) {
+ mRecycler.addScrapView(scrapView, position);
+ if (mCacheColorHint != 0) {
+ child.setDrawingCacheBackgroundColor(mCacheColorHint);
+ }
+ } else {
+ isScrap[0] = true;
+ }
+ } else {
+ child = mAdapter.getView(position, null, this);
+ if (mCacheColorHint != 0) {
+ child.setDrawingCacheBackgroundColor(mCacheColorHint);
+ }
+ }
+ if (mAdapterHasStableIds) {
+ final ViewGroup.LayoutParams vlp = child.getLayoutParams();
+ LayoutParams lp;
+ if (vlp == null) {
+ lp = (LayoutParams) generateDefaultLayoutParams();
+ } else if (!checkLayoutParams(vlp)) {
+ lp = (LayoutParams) generateLayoutParams(vlp);
+ } else {
+ lp = (LayoutParams) vlp;
+ }
+ lp.itemId = mAdapter.getItemId(position);
+ child.setLayoutParams(lp);
+ }
+ return child;
+ }
+
+ void positionSelector(int position, View sel) {
+ if (position != INVALID_POSITION) {
+ mSelectorPosition = position;
+ }
+ final Rect selectorRect = mSelectorRect;
+ invalidate(selectorRect);
+ selectorRect.set(sel.getLeft(), sel.getTop(), sel.getRight(), sel.getBottom());
+ invalidate(selectorRect);
+ final boolean isChildViewEnabled = mIsChildViewEnabled;
+ if (sel.isEnabled() != isChildViewEnabled) {
+ mIsChildViewEnabled = !isChildViewEnabled;
+ }
+ }
+
+ @Override
+ protected void dispatchDraw(Canvas canvas) {
+ final Headable zrcHeader = mZrcHeader;
+ final int childCount = getChildCount();
+ if (zrcHeader != null) {
+ final int firstPosition = mFirstPosition;
+ final int firstTop = childCount == 0 ? mFirstTop : getChildAt(0).getTop();
+ final Rect listPadding = mListPadding;
+ final int viewTop = listPadding.top;
+ final boolean needShowHeader = (firstPosition == 0 && firstTop >= viewTop);
+ if (needShowHeader) {
+ boolean more = zrcHeader.draw(canvas, listPadding.left, viewTop + mFirstTopOffset, getWidth()
+ - listPadding.right, firstTop);
+
+ if (more) {
+ postInvalidate(listPadding.left, listPadding.top, getWidth() - listPadding.right, firstTop);
+ }
+ }
+ }
+ final Footable footer = mZrcFooter;
+ if (childCount > 0 && isLoadingMore) {
+ final int firstPosition = mFirstPosition;
+
+ if (firstPosition + childCount == mItemCount) {
+ final int lastBottom = getChildAt(childCount - 1).getBottom();
+ final Rect listPadding = mListPadding;
+ final boolean isTooShort = childCount == mItemCount
+ && lastBottom - mFirstTop - mFirstTopOffset < getHeight();
+ final int viewBottom = getHeight() - listPadding.bottom;
+ if (lastBottom < viewBottom) {
+ boolean more = footer.draw(canvas, listPadding.left, lastBottom, getWidth() - listPadding.right,
+ isTooShort ? lastBottom + footer.getHeight() : viewBottom - mLastBottomOffset);
+ if (more) {
+ postInvalidate(listPadding.left, listPadding.top, getWidth() - listPadding.right, viewBottom
+ - mLastBottomOffset);
+ }
+ }
+ }
+ }
+ final boolean drawSelectorOnTop = mDrawSelectorOnTop;
+ if (!drawSelectorOnTop) {
+ drawSelector(canvas);
+ }
+
+ super.dispatchDraw(canvas);
+ if (drawSelectorOnTop) {
+ drawSelector(canvas);
+ }
+ }
+
+ @Override
+ protected int getLeftPaddingOffset() {
+ return getPaddingLeft();
+ }
+
+ @Override
+ protected int getTopPaddingOffset() {
+ return getPaddingTop();
+ }
+
+ @Override
+ protected int getRightPaddingOffset() {
+ return getPaddingRight();
+ }
+
+ @Override
+ protected int getBottomPaddingOffset() {
+ return getPaddingBottom();
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ if (getChildCount() > 0) {
+ mDataChanged = true;
+ }
+ }
+
+ boolean touchModeDrawsInPressedState() {
+ switch (mTouchMode) {
+ case TOUCH_MODE_TAP:
+ case TOUCH_MODE_DONE_WAITING:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ boolean shouldShowSelector() {
+ return (!isInTouchMode()) || (touchModeDrawsInPressedState() && isPressed());
+ }
+
+ private void drawSelector(Canvas canvas) {
+ if (!mSelectorRect.isEmpty()) {
+ final Drawable selector = mSelector;
+ selector.setBounds(mSelectorRect);
+ selector.draw(canvas);
+ }
+ }
+
+ public void setDrawSelectorOnTop(boolean onTop) {
+ mDrawSelectorOnTop = onTop;
+ }
+
+ public void setSelector(int resID) {
+ setSelector(getResources().getDrawable(resID));
+ }
+
+ public void setSelector(Drawable sel) {
+ if (mSelector != null) {
+ mSelector.setCallback(null);
+ unscheduleDrawable(mSelector);
+ }
+ mSelector = sel;
+ sel.setCallback(this);
+ updateSelectorState();
+ }
+
+ public Drawable getSelector() {
+ return mSelector;
+ }
+
+ public void setScrollIndicators(View up, View down) {
+ mScrollUp = up;
+ mScrollDown = down;
+ }
+
+ public static final int[] NOTHING = new int[] {0};
+
+ void updateSelectorState() {
+ if (mSelector != null) {
+ if (shouldShowSelector()) {
+ mSelector.setState(getDrawableState());
+ } else {
+ mSelector.setState(NOTHING);
+ }
+ }
+ }
+
+ @Override
+ protected void drawableStateChanged() {
+ super.drawableStateChanged();
+ updateSelectorState();
+ }
+
+ @Override
+ protected int[] onCreateDrawableState(int extraSpace) {
+ if (mIsChildViewEnabled) {
+ return super.onCreateDrawableState(extraSpace);
+ }
+ final int enabledState = ENABLED_STATE_SET[0];
+ int[] state = super.onCreateDrawableState(extraSpace + 1);
+ int enabledPos = -1;
+ for (int i = state.length - 1; i >= 0; i--) {
+ if (state[i] == enabledState) {
+ enabledPos = i;
+ break;
+ }
+ }
+ if (enabledPos >= 0) {
+ System.arraycopy(state, enabledPos + 1, state, enabledPos, state.length - enabledPos - 1);
+ }
+ return state;
+ }
+
+ @Override
+ public boolean verifyDrawable(Drawable dr) {
+ return mSelector == dr || super.verifyDrawable(dr);
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ @Override
+ public void jumpDrawablesToCurrentState() {
+ super.jumpDrawablesToCurrentState();
+ if (APIUtil.isSupport(11) && mSelector != null) {
+ mSelector.jumpToCurrentState();
+ }
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+ if (mAdapter != null && mDataSetObserver == null) {
+ mDataSetObserver = new AdapterDataSetObserver();
+ mAdapter.registerDataSetObserver(mDataSetObserver);
+ mDataChanged = true;
+ mOldItemCount = mItemCount;
+ mItemCount = mAdapter.getCount();
+ }
+ setPressed(false);
+ mIsAttached = true;
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ mRecycler.clear();
+ if (mAdapter != null && mDataSetObserver != null) {
+ mAdapter.unregisterDataSetObserver(mDataSetObserver);
+ mDataSetObserver = null;
+ }
+ if (mClearScrollingCache != null) {
+ removeCallbacks(mClearScrollingCache);
+ }
+ if (mPerformClick != null) {
+ removeCallbacks(mPerformClick);
+ }
+ if (mTouchModeReset != null) {
+ removeCallbacks(mTouchModeReset);
+ mTouchModeReset.run();
+ }
+ mIsAttached = false;
+ }
+
+ @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+ @Override
+ public void onWindowFocusChanged(boolean hasWindowFocus) {
+ super.onWindowFocusChanged(hasWindowFocus);
+ final int touchMode = isInTouchMode() ? TOUCH_MODE_ON : TOUCH_MODE_OFF;
+ if (!hasWindowFocus) {
+ setChildrenDrawingCacheEnabled(false);
+ } else {
+ if (touchMode != mLastTouchMode && mLastTouchMode != TOUCH_MODE_UNKNOWN) {
+ if (touchMode == TOUCH_MODE_OFF) {
+ } else {
+ mLayoutMode = LAYOUT_NORMAL;
+ layoutChildren();
+ }
+ }
+ }
+ mLastTouchMode = touchMode;
+ }
+
+ @Override
+ public void onCancelPendingInputEvents() {
+ super.onCancelPendingInputEvents();
+ if (mPerformClick != null) {
+ removeCallbacks(mPerformClick);
+ }
+ }
+
+ private class WindowRunnnable {
+ private int mOriginalAttachCount;
+
+ public void rememberWindowAttachCount() {
+ mOriginalAttachCount = getWindowAttachCount();
+ }
+
+ public boolean sameWindow() {
+ return getWindowAttachCount() == mOriginalAttachCount;
+ }
+ }
+
+ private class PerformClick extends WindowRunnnable implements Runnable {
+ int mClickMotionPosition;
+
+ @Override
+ public void run() {
+ if (mDataChanged) {
+ return;
+ }
+ final ListAdapter adapter = mAdapter;
+ final int motionPosition = mClickMotionPosition;
+ if (adapter != null && mItemCount > 0 && motionPosition != INVALID_POSITION
+ && motionPosition < adapter.getCount() && sameWindow()) {
+ final View view = getChildAt(motionPosition - mFirstPosition);
+ if (view != null) {
+ performItemClick(view, motionPosition, adapter.getItemId(motionPosition));
+ }
+ }
+ }
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ boolean performLongPress(final View child, final int longPressPosition, final long longPressId) {
+ boolean handled = false;
+ if (mOnItemLongClickListener != null) {
+ handled = mOnItemLongClickListener.onItemLongClick((ZrcListView) this, child, longPressPosition,
+ longPressId);
+ }
+ if (handled) {
+ performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+ }
+ return handled;
+ }
+
+ @Override
+ protected void dispatchSetPressed(boolean pressed) {
+ }
+
+ public int pointToPosition(int x, int y) {
+ Rect frame = mTouchFrame;
+ if (frame == null) {
+ mTouchFrame = new Rect();
+ frame = mTouchFrame;
+ }
+ final int count = getChildCount();
+ for (int i = count - 1; i >= 0; i--) {
+ final View child = getChildAt(i);
+ if (child.getVisibility() == View.VISIBLE) {
+ child.getHitRect(frame);
+ if (frame.contains(x, y)) {
+ return mFirstPosition + i;
+ }
+ }
+ }
+ return INVALID_POSITION;
+ }
+
+ public long pointToRowId(int x, int y) {
+ int position = pointToPosition(x, y);
+ if (position >= 0) {
+ return mAdapter.getItemId(position);
+ }
+ return INVALID_ROW_ID;
+ }
+
+ final class CheckForTap implements Runnable {
+ @Override
+ public void run() {
+ if (mTouchMode == TOUCH_MODE_DOWN) {
+ mTouchMode = TOUCH_MODE_TAP;
+ final View child = getChildAt(mMotionPosition - mFirstPosition);
+ if (child != null && !child.hasFocusable()) {
+ mLayoutMode = LAYOUT_NORMAL;
+ if (!mDataChanged) {
+ child.setPressed(true);
+ positionSelector(mMotionPosition, child);
+ setPressed(true);
+ refreshDrawableState();
+ final int longPressTimeout = ViewConfiguration.getLongPressTimeout();
+ final boolean longClickable = isLongClickable();
+ if (mSelector != null) {
+ Drawable d = mSelector.getCurrent();
+ if (d != null && d instanceof TransitionDrawable) {
+ if (longClickable) {
+ ((TransitionDrawable) d).startTransition(longPressTimeout);
+ } else {
+ ((TransitionDrawable) d).resetTransition();
+ }
+ }
+ }
+ mTouchMode = TOUCH_MODE_DONE_WAITING;
+ } else {
+ mTouchMode = TOUCH_MODE_DONE_WAITING;
+ }
+ }
+ }
+ }
+ }
+
+ private boolean startScrollIfNeeded(int x, int y) {
+ final int deltaX = x - mMotionX;
+ final int distanceX = Math.abs(deltaX);
+ final int deltaY = y - mMotionY;
+ final int distanceY = Math.abs(deltaY);
+ if (distanceX > mTouchSlop || distanceY > mTouchSlop) {
+ if (distanceY > distanceX * 2) {
+ createScrollingCache();
+ mTouchMode = TOUCH_MODE_SCROLL;
+ mMotionCorrection = deltaY > 0 ? mTouchSlop : -mTouchSlop;
+ setPressed(false);
+ if(getChildCount()>0){
+ final View motionView = getChildAt(mMotionPosition - mFirstPosition);
+ if (motionView != null) {
+ motionView.setPressed(false);
+ }
+ }
+ mSelectorPosition = INVALID_POSITION;
+ reportScrollStateChange(OnScrollListener.SCROLL_STATE_TOUCH_SCROLL);
+ final ViewParent parent = getParent();
+ if (parent != null) {
+ parent.requestDisallowInterceptTouchEvent(true);
+ }
+ scrollIfNeeded(x, y);
+ return true;
+ } else {
+ mTouchMode = TOUCH_MODE_INVALID;
+ }
+ }
+ return false;
+ }
+
+ @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+ private void scrollIfNeeded(int x, int y) {
+ final int rawDeltaY = y - mMotionY;
+ final int deltaY = rawDeltaY - mMotionCorrection;
+ int incrementalDeltaY = mLastY != Integer.MIN_VALUE ? y - mLastY : deltaY;
+ if (mTouchMode == TOUCH_MODE_SCROLL) {
+ if (y != mLastY) {
+ if (Math.abs(rawDeltaY) > mTouchSlop) {
+ final ViewParent parent = getParent();
+ if (parent != null) {
+ parent.requestDisallowInterceptTouchEvent(true);
+ }
+ }
+ boolean atEdge = false;
+ if (incrementalDeltaY != 0) {
+ atEdge = trackMotionScroll(deltaY, incrementalDeltaY);
+ }
+ if (atEdge) {
+ if (mVelocityTracker != null) {
+ mVelocityTracker.clear();
+ }
+ }
+ mMotionX = x;
+ mMotionY = y;
+ mLastY = y;
+ }
+ }
+ }
+
+ @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+ @Override
+ public void onTouchModeChanged(boolean isInTouchMode) {
+ if (isInTouchMode) {
+ if (getHeight() > 0 && getChildCount() > 0) {
+ layoutChildren();
+ }
+ updateSelectorState();
+ }
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ if (!isEnabled()) {
+ return isClickable() || isLongClickable();
+ }
+ if (!mIsAttached) {
+ return false;
+ }
+ initVelocityTrackerIfNotExists();
+ mVelocityTracker.addMovement(ev);
+ final int actionMasked = ev.getActionMasked();
+ switch (actionMasked) {
+ case MotionEvent.ACTION_DOWN: {
+ onTouchDown(ev);
+ break;
+ }
+ case MotionEvent.ACTION_MOVE: {
+ onTouchMove(ev);
+ break;
+ }
+ case MotionEvent.ACTION_UP: {
+ onTouchUp(ev);
+ break;
+ }
+ case MotionEvent.ACTION_CANCEL: {
+ onTouchCancel();
+ break;
+ }
+ case MotionEvent.ACTION_POINTER_UP: {
+ onSecondaryPointerUp(ev);
+ final int x = mMotionX;
+ final int y = mMotionY;
+ final int motionPosition = pointToPosition(x, y);
+ if (motionPosition >= 0) {
+ mMotionPosition = motionPosition;
+ }
+ mLastY = y;
+ break;
+ }
+ case MotionEvent.ACTION_POINTER_DOWN: {
+ final int index = ev.getActionIndex();
+ final int id = ev.getPointerId(index);
+ final int x = (int) ev.getX(index);
+ final int y = (int) ev.getY(index);
+ mMotionCorrection = 0;
+ mActivePointerId = id;
+ mMotionX = x;
+ mMotionY = y;
+ final int motionPosition = pointToPosition(x, y);
+ if (motionPosition >= 0) {
+ mMotionPosition = motionPosition;
+ }
+ mLastY = y;
+ break;
+ }
+ }
+ return true;
+ }
+
+ private void onTouchDown(MotionEvent ev) {
+ mActivePointerId = ev.getPointerId(0);
+ final int x = (int) ev.getX();
+ final int y = (int) ev.getY();
+ int motionPosition = pointToPosition(x, y);
+ if (!mDataChanged) {
+ if (mTouchMode == TOUCH_MODE_FLING || mTouchMode == TOUCH_MODE_RESCROLL) {
+ createScrollingCache();
+ mFlingRunnable.mScroller.abortAnimation();
+ mTouchMode = TOUCH_MODE_SCROLL;
+ mMotionCorrection = 0;
+ motionPosition = findMotionRow(y);
+ } else if ((motionPosition >= 0) && getAdapter().isEnabled(motionPosition)) {
+ mTouchMode = TOUCH_MODE_DOWN;
+ if (mPendingCheckForTap == null) {
+ mPendingCheckForTap = new CheckForTap();
+ }
+ postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
+ } else {
+ createScrollingCache();
+ mTouchMode = TOUCH_MODE_SCROLL;
+ mMotionCorrection = 0;
+ motionPosition = findMotionRow(y);
+ }
+ }
+ mMotionX = x;
+ mMotionY = y;
+ mMotionPosition = motionPosition;
+ mLastY = Integer.MIN_VALUE;
+ }
+
+ private void onTouchMove(MotionEvent ev) {
+ if (mTouchMode == TOUCH_MODE_INVALID) {
+ mTouchMode = TOUCH_MODE_SCROLL;
+ }
+ int pointerIndex = ev.findPointerIndex(mActivePointerId);
+ if (pointerIndex == -1) {
+ pointerIndex = 0;
+ mActivePointerId = ev.getPointerId(pointerIndex);
+ }
+ if (mDataChanged) {
+ layoutChildren();
+ }
+ final int x = (int) ev.getX(pointerIndex);
+ final int y = (int) ev.getY(pointerIndex);
+ switch (mTouchMode) {
+ case TOUCH_MODE_DOWN:
+ case TOUCH_MODE_TAP:
+ case TOUCH_MODE_DONE_WAITING:
+ startScrollIfNeeded(x, y);
+ break;
+ case TOUCH_MODE_SCROLL:
+ scrollIfNeeded(x, y);
+ break;
+ }
+ }
+
+ private void onTouchUp(MotionEvent ev) {
+ switch (mTouchMode) {
+ case TOUCH_MODE_DOWN:
+ case TOUCH_MODE_TAP:
+ case TOUCH_MODE_DONE_WAITING:
+ final int motionPosition = mMotionPosition;
+ final View child = getChildCount()==0 ? null : getChildAt(motionPosition - mFirstPosition);
+ if (child != null) {
+ if (mTouchMode != TOUCH_MODE_DOWN) {
+ child.setPressed(false);
+ }
+ final float x = ev.getX();
+ final boolean inList = x > mListPadding.left && x < getWidth() - mListPadding.right;
+ if (inList && !child.hasFocusable()) {
+ if (mPerformClick == null) {
+ mPerformClick = new PerformClick();
+ }
+ final ZrcAbsListView.PerformClick performClick = mPerformClick;
+ performClick.mClickMotionPosition = motionPosition;
+ performClick.rememberWindowAttachCount();
+ if (mTouchMode == TOUCH_MODE_DOWN || mTouchMode == TOUCH_MODE_TAP) {
+ mLayoutMode = LAYOUT_NORMAL;
+ if (!mDataChanged && mAdapter.isEnabled(motionPosition)) {
+ mTouchMode = TOUCH_MODE_TAP;
+ child.setPressed(true);
+ positionSelector(mMotionPosition, child);
+ setPressed(true);
+ if (mSelector != null) {
+ Drawable d = mSelector.getCurrent();
+ if (d != null && d instanceof TransitionDrawable) {
+ ((TransitionDrawable) d).resetTransition();
+ }
+ }
+ if (mTouchModeReset != null) {
+ removeCallbacks(mTouchModeReset);
+ }
+ mTouchModeReset = new Runnable() {
+ @Override
+ public void run() {
+ mTouchModeReset = null;
+ mTouchMode = TOUCH_MODE_REST;
+ child.setPressed(false);
+ setPressed(false);
+ invalidate();
+ if (!mDataChanged && mIsAttached) {
+ performClick.run();
+ }
+ }
+ };
+ postDelayed(mTouchModeReset, ViewConfiguration.getPressedStateDuration());
+ } else {
+ mTouchMode = TOUCH_MODE_REST;
+ updateSelectorState();
+ }
+ return;
+ } else if (!mDataChanged && mAdapter.isEnabled(motionPosition)) {
+ performClick.run();
+ }
+ }
+ }
+ mTouchMode = TOUCH_MODE_REST;
+ updateSelectorState();
+ break;
+ case TOUCH_MODE_SCROLL:
+ if (mFlingRunnable == null) {
+ mFlingRunnable = new FlingRunnable();
+ }
+ if (!mFlingRunnable.scrollToAdjustViewsUpOrDown()) {
+ final VelocityTracker velocityTracker = mVelocityTracker;
+ velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
+ final int initialVelocity = (int) (velocityTracker.getYVelocity(mActivePointerId) * mVelocityScale);
+ if (Math.abs(initialVelocity) > mMinimumVelocity) {
+ if (mFlingRunnable == null) {
+ mFlingRunnable = new FlingRunnable();
+ }
+ reportScrollStateChange(OnScrollListener.SCROLL_STATE_FLING);
+ mFlingRunnable.start(-initialVelocity);
+ } else {
+ mTouchMode = TOUCH_MODE_REST;
+ reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
+ if (mFlingRunnable != null) {
+ mFlingRunnable.endFling();
+ }
+ }
+ }
+ break;
+ }
+ setPressed(false);
+ invalidate();
+ recycleVelocityTracker();
+ mActivePointerId = INVALID_POINTER;
+ }
+
+ private void onTouchCancel() {
+ switch (mTouchMode) {
+ default:
+ mTouchMode = TOUCH_MODE_REST;
+ setPressed(false);
+ final View motionView = getChildCount() == 0 ? null : this.getChildAt(mMotionPosition - mFirstPosition);
+ if (motionView != null) {
+ motionView.setPressed(false);
+ }
+ clearScrollingCache();
+ recycleVelocityTracker();
+ }
+ mSelectorPosition = INVALID_POSITION;
+ invalidate();
+ mActivePointerId = INVALID_POINTER;
+ }
+
+ protected void invalidateParentIfNeeded() {
+ if (getParent() instanceof View) {
+ ((View) getParent()).invalidate();
+ }
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1)
+ @Override
+ public boolean onGenericMotionEvent(MotionEvent event) {
+ if (APIUtil.isSupport(12)) {
+ if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_SCROLL: {
+ if (mTouchMode == TOUCH_MODE_REST) {
+ final float vscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
+ if (vscroll != 0) {
+ final int delta = (int) (vscroll * getVerticalScrollFactor());
+ if (!trackMotionScroll(delta, delta)) {
+ return true;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return super.onGenericMotionEvent(event);
+ }
+
+ private float mVerticalScrollFactor;
+
+ protected float getVerticalScrollFactor() {
+ if (mVerticalScrollFactor == 0) {
+ mVerticalScrollFactor = 64 * getResources().getDisplayMetrics().density;
+ }
+ return mVerticalScrollFactor;
+ }
+
+ @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+ @Override
+ public void setScrollY(int y) {
+ if (APIUtil.isSupport(14)) {
+ super.setScrollY(y);
+ } else {
+ scrollTo(getScrollX(), y);
+ }
+ }
+
+ private void initOrResetVelocityTracker() {
+ if (mVelocityTracker == null) {
+ mVelocityTracker = VelocityTracker.obtain();
+ } else {
+ mVelocityTracker.clear();
+ }
+ }
+
+ private void initVelocityTrackerIfNotExists() {
+ if (mVelocityTracker == null) {
+ mVelocityTracker = VelocityTracker.obtain();
+ }
+ }
+
+ private void recycleVelocityTracker() {
+ if (mVelocityTracker != null) {
+ mVelocityTracker.recycle();
+ mVelocityTracker = null;
+ }
+ }
+
+ @Override
+ public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
+ if (disallowIntercept) {
+ recycleVelocityTracker();
+ }
+ super.requestDisallowInterceptTouchEvent(disallowIntercept);
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ int action = ev.getAction();
+ if (!mIsAttached) {
+ return false;
+ }
+ switch (action & MotionEvent.ACTION_MASK) {
+ case MotionEvent.ACTION_DOWN: {
+ int touchMode = mTouchMode;
+ final int x = (int) ev.getX();
+ final int y = (int) ev.getY();
+ mActivePointerId = ev.getPointerId(0);
+ int motionPosition = findMotionRow(y);
+ if (touchMode != TOUCH_MODE_FLING && touchMode != TOUCH_MODE_RESCROLL && motionPosition >= 0) {
+ mMotionPosition = motionPosition;
+ mTouchMode = TOUCH_MODE_DOWN;
+ clearScrollingCache();
+ }
+ mMotionX = x;
+ mMotionY = y;
+ mLastY = y;
+ initOrResetVelocityTracker();
+ mVelocityTracker.addMovement(ev);
+ if (touchMode == TOUCH_MODE_FLING || touchMode == TOUCH_MODE_RESCROLL) {
+ return true;
+ }
+ break;
+ }
+ case MotionEvent.ACTION_MOVE: {
+ if (mTouchMode == TOUCH_MODE_INVALID) {
+ return false;
+ }
+ switch (mTouchMode) {
+ case TOUCH_MODE_DOWN:
+ int pointerIndex = ev.findPointerIndex(mActivePointerId);
+ if (pointerIndex == -1) {
+ pointerIndex = 0;
+ mActivePointerId = ev.getPointerId(pointerIndex);
+ }
+ final int x = (int) ev.getX(pointerIndex);
+ final int y = (int) ev.getY(pointerIndex);
+ initVelocityTrackerIfNotExists();
+ mVelocityTracker.addMovement(ev);
+ if (startScrollIfNeeded(x, y)) {
+ return true;
+ }
+ break;
+ }
+ break;
+ }
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP: {
+ mTouchMode = TOUCH_MODE_REST;
+ mActivePointerId = INVALID_POINTER;
+ recycleVelocityTracker();
+ reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
+ break;
+ }
+ case MotionEvent.ACTION_POINTER_UP: {
+ onSecondaryPointerUp(ev);
+ break;
+ }
+ }
+ return false;
+ }
+
+ private void onSecondaryPointerUp(MotionEvent ev) {
+ final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+ final int pointerId = ev.getPointerId(pointerIndex);
+ if (pointerId == mActivePointerId) {
+ final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
+ mMotionX = (int) ev.getX(newPointerIndex);
+ mMotionY = (int) ev.getY(newPointerIndex);
+ mMotionCorrection = 0;
+ mActivePointerId = ev.getPointerId(newPointerIndex);
+ }
+ }
+
+ @Override
+ public void addTouchables(ArrayList views) {
+ final int count = getChildCount();
+ final int firstPosition = mFirstPosition;
+ final ListAdapter adapter = mAdapter;
+ if (adapter == null) {
+ return;
+ }
+ for (int i = 0; i < count; i++) {
+ final View child = getChildAt(i);
+ if (adapter.isEnabled(firstPosition + i)) {
+ views.add(child);
+ }
+ child.addTouchables(views);
+ }
+ }
+
+ void reportScrollStateChange(int newState) {
+ if (newState != mLastScrollState) {
+ if (mOnScrollListener != null) {
+ mLastScrollState = newState;
+ mOnScrollListener.onScrollStateChanged(this, newState);
+ }
+ }
+ }
+
+ protected void scrollToAdjustViewsUpOrDown() {
+ if (mFlingRunnable != null) {
+ mFlingRunnable.scrollToAdjustViewsUpOrDown();
+ }
+ }
+
+ private class FlingRunnable implements Runnable {
+ private final Scroller mScroller;
+ private int mLastFlingY;
+
+ FlingRunnable() {
+ mScroller = new Scroller(getContext(), new Interpolator() {
+ @Override
+ public float getInterpolation(float t) {
+ t -= 1;
+ return t * t * t * t * t + 1;
+ }
+ });
+ }
+
+ void start(int initialVelocity) {
+ if (!mScroller.isFinished()) {
+ mScroller.abortAnimation();
+ }
+ int initialY = initialVelocity < 0 ? Integer.MAX_VALUE : 0;
+ mLastFlingY = initialY;
+ mScroller.fling(0, initialY, 0, initialVelocity, 0, Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
+ mTouchMode = TOUCH_MODE_FLING;
+ ViewCompat.postOnAnimation(ZrcAbsListView.this, this);
+ }
+
+ void startScroll(int distance, int duration, boolean linear) {
+ if (!mScroller.isFinished()) {
+ mScroller.abortAnimation();
+ }
+ int initialY = distance < 0 ? Integer.MAX_VALUE : 0;
+ mLastFlingY = initialY;
+ mScroller.startScroll(0, initialY, 0, distance, duration);
+ mTouchMode = TOUCH_MODE_FLING;
+ ViewCompat.postOnAnimation(ZrcAbsListView.this, this);
+ }
+
+ void endFling() {
+ int oldTouchMode = mTouchMode;
+ mTouchMode = TOUCH_MODE_REST;
+ removeCallbacks(this);
+ reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
+ clearScrollingCache();
+ mScroller.abortAnimation();
+
+ if (mZrcHeader != null && oldTouchMode == TOUCH_MODE_RESCROLL
+ && mZrcHeader.getState() == Headable.STATE_RELEASE) {
+ scrollToAdjustViewsUpOrDown();
+ }
+ }
+
+ boolean scrollToAdjustViewsUpOrDown() {
+ final int firstPosition = mFirstPosition;
+ final int childCount = getChildCount();
+ final int firstTop = childCount == 0 ? mFirstTop : getChildAt(0).getTop();
+ int lastBottom = childCount == 0 ? firstTop : getChildAt(childCount - 1).getBottom();
+ if (firstPosition + childCount >= mItemCount - 1) {
+ if (!isRefreshing && !isLoadingMore && isLoadMoreOn && onLoadMoreStart != null) {
+ isLoadingMore = true;
+ onLoadMoreStart.onStart();
+ }
+ }
+ if (isLoadingMore) {
+ lastBottom += mZrcFooter.getHeight();
+ }
+ final Rect listPadding = mListPadding;
+ final Headable zrcHeader = mZrcHeader;
+ final boolean isOnLoading = zrcHeader != null && zrcHeader.getState() == Headable.STATE_LOADING;
+ final int topOffset = firstTop
+ - (listPadding.top + mFirstTopOffset + (showHeader ? zrcHeader.getHeight() : 0));
+ final boolean cannotScrollDown = (firstPosition == 0 && topOffset > 0);
+ final boolean isTooShort = childCount == mItemCount && lastBottom - firstTop < getHeight();
+ final int bottomOffset = isTooShort ? firstTop - listPadding.top - mFirstTopOffset : lastBottom
+ - getHeight() + listPadding.bottom + mLastBottomOffset;
+ final boolean cannotScrollUp = firstPosition + childCount == mItemCount && bottomOffset < 0;
+ if (cannotScrollDown) {
+ int duration = mFirstTopOffset + listPadding.top - firstTop;
+ if ((zrcHeader != null && onRefreshStart != null && zrcHeader.getState() == Headable.STATE_RELEASE)
+ || showHeader) {
+ if (!isOnLoading) {
+ isRefreshing = true;
+ showHeader = true;
+ zrcHeader.stateChange(Headable.STATE_LOADING, null);
+ onRefreshStart.onStart();
+ }
+ duration += zrcHeader.getHeight();
+ }
+ startScroll(-duration, (int) Math.abs(duration / mDensity) + 50, true);
+ mTouchMode = TOUCH_MODE_RESCROLL;
+ } else if (cannotScrollUp) {
+ int duration = bottomOffset;
+ startScroll(duration, (int) Math.abs(duration / mDensity) + 50, true);
+ mTouchMode = TOUCH_MODE_RESCROLL;
+ } else {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public void run() {
+ switch (mTouchMode) {
+ default:
+ endFling();
+ return;
+ case TOUCH_MODE_SCROLL:
+ if (mScroller.isFinished()) {
+ return;
+ }
+ case TOUCH_MODE_RESCROLL:
+ case TOUCH_MODE_FLING: {
+ if (mDataChanged) {
+ layoutChildren();
+ }
+ final Scroller scroller = mScroller;
+ boolean more = scroller.computeScrollOffset();
+ final int y = scroller.getCurrY();
+ final int mPaddingBottom = getPaddingBottom();
+ final int mPaddingTop = getPaddingTop();
+ int delta = mLastFlingY - y;
+ if (delta > 0) {
+ mMotionPosition = mFirstPosition;
+ delta = Math.min(getHeight() - mPaddingBottom - mPaddingTop - 1, delta);
+ } else {
+ int offsetToLast = getChildCount() - 1;
+ mMotionPosition = mFirstPosition + offsetToLast;
+ delta = Math.max(-(getHeight() - mPaddingBottom - mPaddingTop - 1), delta);
+ }
+ final boolean atEdge = trackMotionScroll(delta, delta);
+ final boolean atEnd = atEdge && (delta != 0);
+ final int touchMode = mTouchMode;
+ if (atEnd) {
+ endFling();
+ if (touchMode == TOUCH_MODE_FLING) {
+ scrollToAdjustViewsUpOrDown();
+ }
+ break;
+ }
+ if (more && !atEnd) {
+ mLastFlingY = y;
+ ViewCompat.postOnAnimation(ZrcAbsListView.this, this);
+ } else {
+ endFling();
+ if (touchMode == TOUCH_MODE_FLING) {
+ scrollToAdjustViewsUpOrDown();
+ }
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ public void setFriction(float friction) {
+ if (mFlingRunnable == null) {
+ mFlingRunnable = new FlingRunnable();
+ }
+ mFlingRunnable.mScroller.setFriction(friction);
+ }
+
+ public void setVelocityScale(float scale) {
+ mVelocityScale = scale;
+ }
+
+ public void smoothScrollBy(int distance, int duration) {
+ smoothScrollBy(distance, duration, false);
+ }
+
+ void smoothScrollBy(int distance, int duration, boolean linear) {
+ if (mFlingRunnable == null) {
+ mFlingRunnable = new FlingRunnable();
+ }
+ final int firstPos = mFirstPosition;
+ final int childCount = getChildCount();
+ final int lastPos = firstPos + childCount;
+ final int topLimit = getPaddingTop();
+ final int bottomLimit = getHeight() - getPaddingBottom();
+ if (distance == 0 || mItemCount == 0 || childCount == 0
+ || (firstPos == 0 && getChildAt(0).getTop() == topLimit && distance < 0)
+ || (lastPos == mItemCount && getChildAt(childCount - 1).getBottom() == bottomLimit && distance > 0)) {
+ mFlingRunnable.endFling();
+ } else {
+ reportScrollStateChange(OnScrollListener.SCROLL_STATE_FLING);
+ mFlingRunnable.startScroll(distance, duration, linear);
+ }
+ }
+
+ private void createScrollingCache() {
+ if (mScrollingCacheEnabled && !mCachingStarted && !isSupportHardwareAccelerated()) {
+ setChildrenDrawnWithCacheEnabled(true);
+ setChildrenDrawingCacheEnabled(true);
+ mCachingStarted = mCachingActive = true;
+ }
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ private void clearScrollingCache() {
+ if (!isSupportHardwareAccelerated()) {
+ if (mClearScrollingCache == null) {
+ mClearScrollingCache = new Runnable() {
+ @Override
+ public void run() {
+ if (mCachingStarted) {
+ mCachingStarted = mCachingActive = false;
+ setChildrenDrawnWithCacheEnabled(false);
+ if ((getPersistentDrawingCache() & PERSISTENT_SCROLLING_CACHE) == 0) {
+ setChildrenDrawingCacheEnabled(false);
+ }
+ if (!isAlwaysDrawnWithCacheEnabled()) {
+ invalidate();
+ }
+ }
+ }
+ };
+ }
+ post(mClearScrollingCache);
+ }
+ }
+
+ public void scrollListBy(int y) {
+ trackMotionScroll(-y, -y);
+ }
+
+ public boolean canScrollList(int direction) {
+ final int childCount = getChildCount();
+ if (childCount == 0) {
+ return false;
+ }
+ final int firstPosition = mFirstPosition;
+ final Rect listPadding = mListPadding;
+ if (direction > 0) {
+ final int lastBottom = getChildAt(childCount - 1).getBottom();
+ final int lastPosition = firstPosition + childCount;
+ return lastPosition < mItemCount || lastBottom > getHeight() - listPadding.bottom - mLastBottomOffset;
+ } else {
+ final int firstTop = getChildAt(0).getTop();
+ return firstPosition > 0 || firstTop < listPadding.top + mFirstTopOffset;
+ }
+ }
+
+ boolean trackMotionScroll(int deltaY, int incrementalDeltaY) {
+ final int childCount = getChildCount();
+ final int firstPosition = mFirstPosition;
+ final int firstTop = childCount == 0 ? mFirstTop : getChildAt(0).getTop();
+ int lastBottom = childCount == 0 ? firstTop : getChildAt(childCount - 1).getBottom();
+ if (firstPosition + childCount >= mItemCount - 1) {
+ if (!isRefreshing && !isLoadingMore && isLoadMoreOn && onLoadMoreStart != null) {
+ isLoadingMore = true;
+ onLoadMoreStart.onStart();
+ }
+ }
+ if (isLoadingMore) {
+ lastBottom += mZrcFooter.getHeight();
+ }
+ final int mPaddingBottom = getPaddingBottom();
+ final int mPaddingTop = getPaddingTop();
+ final Rect listPadding = mListPadding;
+ int effectivePaddingTop = 0;
+ int effectivePaddingBottom = 0;
+ final int spaceAbove = effectivePaddingTop - firstTop;
+ final int end = getHeight() - effectivePaddingBottom;
+ final int spaceBelow = lastBottom - end;
+ final int height = getHeight() - mPaddingBottom - mPaddingTop;
+ if (incrementalDeltaY < 0) {
+ incrementalDeltaY = Math.max(-(height - 1), incrementalDeltaY);
+ } else {
+ incrementalDeltaY = Math.min(height - 1, incrementalDeltaY);
+ }
+ final Headable zrcHeader = mZrcHeader;
+ final boolean isTooShort = childCount == mItemCount && lastBottom - firstTop < getHeight();
+ final int topOffset = firstTop - (listPadding.top + mFirstTopOffset + (showHeader ? zrcHeader.getHeight() : 0));
+ final int bottomOffset = isTooShort ? firstTop - listPadding.top : lastBottom - getHeight()
+ + listPadding.bottom + mLastBottomOffset;
+ final boolean isOutOfTop = firstPosition == 0 && topOffset > 0;
+ final boolean isOutOfBottom = firstPosition + childCount == mItemCount && bottomOffset < 0;
+ final boolean cannotScrollDown = (isOutOfTop && incrementalDeltaY > 0);
+ final boolean cannotScrollUp = (isOutOfBottom && incrementalDeltaY <= 0);
+ if (isTooShort && cannotScrollDown && mTouchMode == TOUCH_MODE_RESCROLL) {
+ mTouchMode = TOUCH_MODE_FLING;
+ return true;
+ }
+ Log.d("zz", showHeader +"?");
+ if (isOutOfTop || isOutOfBottom) {
+ if (mTouchMode == TOUCH_MODE_SCROLL) {
+ incrementalDeltaY /= 1.7f;
+ final int state = zrcHeader.getState();
+ if (zrcHeader != null && isOutOfTop) {
+ if (topOffset >= zrcHeader.getHeight()) {
+ if (state == Headable.STATE_PULL) {
+ zrcHeader.stateChange(Headable.STATE_RELEASE, null);
+ }
+ } else {
+ if (state == Headable.STATE_RELEASE || state == Headable.STATE_REST) {
+ zrcHeader.stateChange(Headable.STATE_PULL, null);
+ }
+ }
+ }
+ }
+ if (mTouchMode == TOUCH_MODE_RESCROLL) {
+ if (isOutOfTop && zrcHeader != null) {
+ final int state = zrcHeader.getState();
+ if (topOffset < 10 && (state == Headable.STATE_SUCCESS || state == Headable.STATE_FAIL)) {
+ zrcHeader.stateChange(Headable.STATE_REST, null);
+ removeCallbacks(mResetRunnable);
+ }
+ }
+ }
+ if (mTouchMode == TOUCH_MODE_FLING) {
+ if (cannotScrollDown) {
+ incrementalDeltaY /= 1.7f;
+ int duration = firstTop - listPadding.top;
+ if (duration > getHeight() / 6) {
+ return true;
+ }
+ } else if (cannotScrollUp && !isOutOfTop) {
+ incrementalDeltaY /= 1.7f;
+ int duration = bottomOffset;
+ if (duration < -getHeight() / 6) {
+ return true;
+ }
+ }
+ } else {
+ if (incrementalDeltaY > 0) {
+ int duration = firstTop - listPadding.top;
+ if (duration > getHeight() / 2) {
+ return true;
+ }
+ } else if (incrementalDeltaY < 0 && !isOutOfTop) {
+ int duration = bottomOffset;
+ if (duration < -getHeight() / 2) {
+ return true;
+ }
+ }
+ }
+ if (onScrollStateListener != null) {
+ if (mScrollState != OnScrollStateListener.EDGE) {
+ mScrollState = OnScrollStateListener.EDGE;
+ onScrollStateListener.onChange(OnScrollStateListener.EDGE);
+ }
+ }
+ } else {
+ if (zrcHeader != null) {
+ if (zrcHeader.getState() == Headable.STATE_PULL) {
+ zrcHeader.stateChange(Headable.STATE_REST, null);
+ }
+ }
+ if (incrementalDeltaY > 5) {
+ if (onScrollStateListener != null) {
+ if (mScrollState != OnScrollStateListener.UP) {
+ mScrollState = OnScrollStateListener.UP;
+ onScrollStateListener.onChange(OnScrollStateListener.UP);
+ }
+ }
+ } else if (incrementalDeltaY < -5) {
+ if (onScrollStateListener != null) {
+ if (mScrollState != OnScrollStateListener.DOWN) {
+ mScrollState = OnScrollStateListener.DOWN;
+ onScrollStateListener.onChange(OnScrollStateListener.DOWN);
+ }
+ }
+ }
+ }
+ final boolean down = incrementalDeltaY < 0;
+ final int headerViewsCount = getHeaderViewsCount();
+ final int footerViewsStart = mItemCount - getFooterViewsCount();
+ int start = 0;
+ int count = 0;
+ if (down) {
+ int top = -incrementalDeltaY;
+ for (int i = 0; i < childCount; i++) {
+ final View child = getChildAt(i);
+ if (child.getBottom() >= top + Math.min(0, bottomOffset)) {
+ break;
+ } else {
+ count++;
+ int position = firstPosition + i;
+ if (position >= headerViewsCount && position < footerViewsStart) {
+ mRecycler.addScrapView(child, position);
+ }
+ }
+ }
+ } else {
+ int bottom = getHeight() - incrementalDeltaY;
+ for (int i = childCount - 1; i >= 0; i--) {
+ final View child = getChildAt(i);
+ if (child.getTop() <= bottom + Math.max(0, topOffset)) {
+ break;
+ } else {
+ start = i;
+ count++;
+ int position = firstPosition + i;
+ if (position >= headerViewsCount && position < footerViewsStart) {
+ mRecycler.addScrapView(child, position);
+ }
+ }
+ }
+ }
+ mBlockLayoutRequests = true;
+ if (count > 0) {
+ detachViewsFromParent(start, count);
+ mRecycler.removeSkippedScrap();
+ }
+ if (!awakenScrollBars()) {
+ invalidate();
+ }
+ offsetChildrenTopAndBottom(incrementalDeltaY);
+ if (down) {
+ mFirstPosition += count;
+ }
+ final int absIncrementalDeltaY = Math.abs(incrementalDeltaY);
+ if (spaceAbove < absIncrementalDeltaY || spaceBelow < absIncrementalDeltaY) {
+ fillGap(down);
+ }
+
+ mFirstTop = childCount == 0 ? mFirstTop + incrementalDeltaY : getChildAt(0).getTop();
+ if (mSelectorPosition != INVALID_POSITION) {
+ final int childIndex = mSelectorPosition - mFirstPosition;
+ if (childIndex >= 0 && childIndex < getChildCount()) {
+ positionSelector(INVALID_POSITION, getChildAt(childIndex));
+ }
+ } else {
+ mSelectorRect.setEmpty();
+ }
+ mBlockLayoutRequests = false;
+ invokeOnItemScrollListener();
+ return false;
+ }
+
+ public void offsetChildrenTopAndBottom(int offset) {
+ final int count = getChildCount();
+ for (int i = 0; i < count; i++) {
+ final View v = getChildAt(i);
+ v.offsetTopAndBottom(offset);
+ }
+ }
+
+ int getHeaderViewsCount() {
+ return 0;
+ }
+
+ int getFooterViewsCount() {
+ return 0;
+ }
+
+ abstract void fillGap(boolean down);
+
+ abstract int findMotionRow(int y);
+
+ int findClosestMotionRow(int y) {
+ final int childCount = getChildCount();
+ if (childCount == 0) {
+ return INVALID_POSITION;
+ }
+ final int motionRow = findMotionRow(y);
+ return motionRow != INVALID_POSITION ? motionRow : mFirstPosition + childCount - 1;
+ }
+
+ public void invalidateViews() {
+ mDataChanged = true;
+ requestLayout();
+ invalidate();
+ }
+
+ protected void handleDataChanged() {
+ mRecycler.clearTransientStateViews();
+ // mLayoutMode = mStackFromBottom ? LAYOUT_FORCE_BOTTOM :
+ // LAYOUT_FORCE_TOP;
+ mSelectorPosition = INVALID_POSITION;
+ }
+
+ static int getDistance(Rect source, Rect dest, int direction) {
+ int sX, sY;
+ int dX, dY;
+ switch (direction) {
+ case View.FOCUS_RIGHT:
+ sX = source.right;
+ sY = source.top + source.height() / 2;
+ dX = dest.left;
+ dY = dest.top + dest.height() / 2;
+ break;
+ case View.FOCUS_DOWN:
+ sX = source.left + source.width() / 2;
+ sY = source.bottom;
+ dX = dest.left + dest.width() / 2;
+ dY = dest.top;
+ break;
+ case View.FOCUS_LEFT:
+ sX = source.left;
+ sY = source.top + source.height() / 2;
+ dX = dest.right;
+ dY = dest.top + dest.height() / 2;
+ break;
+ case View.FOCUS_UP:
+ sX = source.left + source.width() / 2;
+ sY = source.top;
+ dX = dest.left + dest.width() / 2;
+ dY = dest.bottom;
+ break;
+ case View.FOCUS_FORWARD:
+ case View.FOCUS_BACKWARD:
+ sX = source.right + source.width() / 2;
+ sY = source.top + source.height() / 2;
+ dX = dest.left + dest.width() / 2;
+ dY = dest.top + dest.height() / 2;
+ break;
+ default:
+ throw new IllegalArgumentException("direction must be one of "
+ + "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT, " + "FOCUS_FORWARD, FOCUS_BACKWARD}.");
+ }
+ int deltaX = dX - sX;
+ int deltaY = dY - sY;
+ return deltaY * deltaY + deltaX * deltaX;
+ }
+
+ @Override
+ protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
+ return new ZrcAbsListView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.WRAP_CONTENT, 0);
+ }
+
+ @Override
+ protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
+ return new ZrcAbsListView.LayoutParams(p);
+ }
+
+ @Override
+ public LayoutParams generateLayoutParams(AttributeSet attrs) {
+ return new ZrcAbsListView.LayoutParams(getContext(), attrs);
+ }
+
+ @Override
+ protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
+ return p instanceof ZrcAbsListView.LayoutParams;
+ }
+
+ public void setTranscriptMode(int mode) {
+ mTranscriptMode = mode;
+ }
+
+ public int getTranscriptMode() {
+ return mTranscriptMode;
+ }
+
+ @Override
+ public int getSolidColor() {
+ return mCacheColorHint;
+ }
+
+ public void setCacheColorHint(int color) {
+ if (color != mCacheColorHint) {
+ mCacheColorHint = color;
+ int count = getChildCount();
+ for (int i = 0; i < count; i++) {
+ getChildAt(i).setDrawingCacheBackgroundColor(color);
+ }
+ mRecycler.setCacheColorHint(color);
+ }
+ }
+
+ @ViewDebug.ExportedProperty(category = "drawing")
+ public int getCacheColorHint() {
+ return mCacheColorHint;
+ }
+
+ @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+ public void reclaimViews(List views) {
+ int childCount = getChildCount();
+ RecyclerListener listener = mRecycler.mRecyclerListener;
+ for (int i = 0; i < childCount; i++) {
+ View child = getChildAt(i);
+ ZrcAbsListView.LayoutParams lp = (ZrcAbsListView.LayoutParams) child.getLayoutParams();
+ if (lp != null && mRecycler.shouldRecycleViewType(lp.viewType)) {
+ views.add(child);
+ if (listener != null) {
+ listener.onMovedToScrapHeap(child);
+ }
+ }
+ }
+ mRecycler.reclaimScrapViews(views);
+ removeAllViewsInLayout();
+ }
+
+ public void startLoadMore() {
+ isLoadingMore = false;
+ isLoadMoreOn = true;
+ }
+
+ public void setLoadMoreSuccess() {
+ isLoadingMore = false;
+ }
+
+ public void stopLoadMore() {
+ isLoadingMore = false;
+ isLoadMoreOn = false;
+ if (mFlingRunnable != null) {
+ mFlingRunnable.scrollToAdjustViewsUpOrDown();
+ }
+ }
+
+ public void refresh() {
+ post(new Runnable() {
+ @Override
+ public void run() {
+ if (mZrcHeader == null || mZrcHeader.getState() == Headable.STATE_LOADING || onRefreshStart == null
+ || mTouchMode != TOUCH_MODE_REST) {
+ return;
+ }
+ if (mFirstPosition == 0) {
+ int newTop = mZrcHeader.getHeight() + mFirstTopOffset;
+ if (mFlingRunnable == null) {
+ mFlingRunnable = new FlingRunnable();
+ }
+ isRefreshing = true;
+ onRefreshStart.onStart();
+ showHeader = true;
+ mZrcHeader.stateChange(Headable.STATE_LOADING, null);
+ mFlingRunnable.startScroll(mFirstTop - newTop,
+ (int) (Math.abs(newTop - mFirstTop) / mDensity) + 50, true);
+ mTouchMode = TOUCH_MODE_RESCROLL;
+ }
+ }
+ });
+ }
+
+ protected void setRecyclerListener(RecyclerListener listener) {
+ mRecycler.mRecyclerListener = listener;
+ }
+
+ public void setOnRefreshStartListener(OnStartListener onStart) {
+ this.onRefreshStart = onStart;
+ }
+
+ public void setOnLoadMoreStartListener(OnStartListener onStart) {
+ this.onLoadMoreStart = onStart;
+ }
+
+ public void setOnScrollStateListener(OnScrollStateListener onScrollListener) {
+ this.onScrollStateListener = onScrollListener;
+ }
+
+ public void setRefreshSuccess() {
+ setRefreshSuccess("刷新成功");
+ }
+
+ public void setRefreshSuccess(String msg) {
+ setRefreshDone(msg, Headable.STATE_SUCCESS);
+ }
+
+ public void setRefreshFail(){
+ setRefreshFail("刷新失败");
+ }
+
+ public void setRefreshFail(String msg){
+ setRefreshDone(msg, Headable.STATE_FAIL);
+ }
+
+ private void setRefreshDone(String msg, int state) {
+ final Headable zrcHeader = mZrcHeader;
+ if (zrcHeader != null && zrcHeader.getState() == Headable.STATE_LOADING) {
+ isRefreshing = false;
+ zrcHeader.stateChange(state, msg);
+ final int childCount = getChildCount();
+ final int firstTop = childCount == 0 ? mFirstTop : getChildAt(0).getTop();
+ final boolean unShownState = mFirstPosition != 0
+ || firstTop < mListPadding.top + mFirstTopOffset + zrcHeader.getHeight();
+ postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ if (mFlingRunnable != null && mTouchMode != TOUCH_MODE_SCROLL) {
+ showHeader = false;
+ boolean hasScroll = mFlingRunnable.scrollToAdjustViewsUpOrDown();
+ if (!hasScroll) {
+ zrcHeader.stateChange(Headable.STATE_REST, null);
+ } else {
+ postDelayed(mResetRunnable, 500);
+ }
+ } else {
+ postDelayed(mResetRunnable, 500);
+ }
+ }
+ }, 1000);
+ if (unShownState) {
+ zrcHeader.toastResultInOtherWay(getContext(), state);
+ }
+ }
+ }
+
+ public void setHeadable(Headable header) {
+ this.mZrcHeader = header;
+ }
+
+ public void setFootable(Footable footer) {
+ this.mZrcFooter = footer;
+ }
+
+ public Headable getHeadable() {
+ return mZrcHeader;
+ }
+
+ public Footable getFootable() {
+ return mZrcFooter;
+ }
+
+ public void setFirstTopOffset(int offset) {
+ this.mFirstTopOffset = offset;
+ }
+
+ public void setLastBottomOffset(int offset) {
+ this.mLastBottomOffset = offset;
+ }
+
+ @Override
+ public Parcelable onSaveInstanceState() {
+ Parcelable superState = super.onSaveInstanceState();
+ SavedState ss = new SavedState(superState);
+ ss.mFirstPosition = mFirstPosition;
+ return ss;
+ }
+
+ @Override
+ public void onRestoreInstanceState(Parcelable state) {
+ SavedState ss = (SavedState) state;
+ super.onRestoreInstanceState(ss.getSuperState());
+ mFirstPosition = ss.mFirstPosition;
+ requestLayout();
+ if (mFlingRunnable != null) {
+ mFlingRunnable.scrollToAdjustViewsUpOrDown();
+ }
+ }
+
+ static class SavedState extends BaseSavedState {
+ private int mFirstPosition;
+
+ public SavedState(Parcelable arg0) {
+ super(arg0);
+ }
+
+ private SavedState(Parcel in) {
+ super(in);
+ mFirstPosition = in.readInt();
+ // mFirstTop = in.readInt();
+ }
+
+ @Override
+ public void writeToParcel(Parcel out, int flags) {
+ super.writeToParcel(out, flags);
+ out.writeInt(mFirstPosition);
+ // out.writeInt(mFirstTop);
+ }
+
+ @Override
+ public String toString() {
+ return "AbsListView.SavedState{" + Integer.toHexString(System.identityHashCode(this)) + " firstPosition="
+ + mFirstPosition
+ /* + " firstTop=" + mFirstTop */+ "}";
+ }
+
+ public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
+ @Override
+ public SavedState createFromParcel(Parcel in) {
+ return new SavedState(in);
+ }
+
+ @Override
+ public SavedState[] newArray(int size) {
+ return new SavedState[size];
+ }
+ };
+ }
+
+ class AdapterDataSetObserver extends ZrcAdapterView.AdapterDataSetObserver {
+ @Override
+ public void onChanged() {
+ // if(mFlingRunnable!=null){
+ // mFlingRunnable.endFling();
+ // }
+ super.onChanged();
+ }
+
+ @Override
+ public void onInvalidated() {
+ // if(mFlingRunnable!=null){
+ // mFlingRunnable.endFling();
+ // }
+ super.onInvalidated();
+ }
+ }
+
+ public static class LayoutParams extends ViewGroup.LayoutParams {
+ int viewType;
+ boolean recycledHeaderFooter;
+ boolean forceAdd;
+ int scrappedFromPosition;
+ long itemId = -1;
+
+ public LayoutParams(Context c, AttributeSet attrs) {
+ super(c, attrs);
+ }
+
+ public LayoutParams(int w, int h) {
+ super(w, h);
+ }
+
+ public LayoutParams(int w, int h, int viewType) {
+ super(w, h);
+ this.viewType = viewType;
+ }
+
+ public LayoutParams(ViewGroup.LayoutParams source) {
+ super(source);
+ }
+ }
+
+ public static interface RecyclerListener {
+ void onMovedToScrapHeap(View view);
+ }
+
+ class RecycleBin {
+ private RecyclerListener mRecyclerListener;
+ private int mFirstActivePosition;
+ private View[] mActiveViews = new View[0];
+ private ArrayList[] mScrapViews;
+ private int mViewTypeCount;
+ private ArrayList mCurrentScrap;
+ private ArrayList mSkippedScrap;
+ private SparseArrayCompat mTransientStateViews;
+ private LongSparseArray mTransientStateViewsById;
+
+ @SuppressWarnings("unchecked")
+ public void setViewTypeCount(int viewTypeCount) {
+ if (viewTypeCount < 1) {
+ throw new IllegalArgumentException("Can't have a viewTypeCount < 1");
+ }
+ ArrayList[] scrapViews = new ArrayList[viewTypeCount];
+ for (int i = 0; i < viewTypeCount; i++) {
+ scrapViews[i] = new ArrayList();
+ }
+ mViewTypeCount = viewTypeCount;
+ mCurrentScrap = scrapViews[0];
+ mScrapViews = scrapViews;
+ }
+
+ public void markChildrenDirty() {
+ if (mViewTypeCount == 1) {
+ final ArrayList scrap = mCurrentScrap;
+ final int scrapCount = scrap.size();
+ for (int i = 0; i < scrapCount; i++) {
+ scrap.get(i).forceLayout();
+ }
+ } else {
+ final int typeCount = mViewTypeCount;
+ for (int i = 0; i < typeCount; i++) {
+ final ArrayList scrap = mScrapViews[i];
+ final int scrapCount = scrap.size();
+ for (int j = 0; j < scrapCount; j++) {
+ scrap.get(j).forceLayout();
+ }
+ }
+ }
+ if (mTransientStateViews != null) {
+ final int count = mTransientStateViews.size();
+ for (int i = 0; i < count; i++) {
+ mTransientStateViews.valueAt(i).forceLayout();
+ }
+ }
+ if (mTransientStateViewsById != null) {
+ final int count = mTransientStateViewsById.size();
+ for (int i = 0; i < count; i++) {
+ mTransientStateViewsById.valueAt(i).forceLayout();
+ }
+ }
+ }
+
+ public boolean shouldRecycleViewType(int viewType) {
+ return viewType >= 0;
+ }
+
+ void clear() {
+ if (mViewTypeCount == 1) {
+ final ArrayList scrap = mCurrentScrap;
+ final int scrapCount = scrap.size();
+ for (int i = 0; i < scrapCount; i++) {
+ removeDetachedView(scrap.remove(scrapCount - 1 - i), false);
+ }
+ } else {
+ final int typeCount = mViewTypeCount;
+ for (int i = 0; i < typeCount; i++) {
+ final ArrayList scrap = mScrapViews[i];
+ final int scrapCount = scrap.size();
+ for (int j = 0; j < scrapCount; j++) {
+ removeDetachedView(scrap.remove(scrapCount - 1 - j), false);
+ }
+ }
+ }
+ if (mTransientStateViews != null) {
+ mTransientStateViews.clear();
+ }
+ if (mTransientStateViewsById != null) {
+ mTransientStateViewsById.clear();
+ }
+ }
+
+ void fillActiveViews(int childCount, int firstActivePosition) {
+ if (mActiveViews.length < childCount) {
+ mActiveViews = new View[childCount];
+ }
+ mFirstActivePosition = firstActivePosition;
+ final View[] activeViews = mActiveViews;
+ for (int i = 0; i < childCount; i++) {
+ View child = getChildAt(i);
+ ZrcAbsListView.LayoutParams lp = (ZrcAbsListView.LayoutParams) child.getLayoutParams();
+ if (lp != null && lp.viewType != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
+ activeViews[i] = child;
+ }
+ }
+ }
+
+ View getActiveView(int position) {
+ int index = position - mFirstActivePosition;
+ final View[] activeViews = mActiveViews;
+ if (index >= 0 && index < activeViews.length) {
+ final View match = activeViews[index];
+ activeViews[index] = null;
+ return match;
+ }
+ return null;
+ }
+
+ View getTransientStateView(int position) {
+ if (mAdapter != null && mAdapterHasStableIds && mTransientStateViewsById != null) {
+ long id = mAdapter.getItemId(position);
+ View result = mTransientStateViewsById.get(id);
+ mTransientStateViewsById.remove(id);
+ return result;
+ }
+ if (mTransientStateViews != null) {
+ final int index = mTransientStateViews.indexOfKey(position);
+ if (index >= 0) {
+ View result = mTransientStateViews.valueAt(index);
+ mTransientStateViews.removeAt(index);
+ return result;
+ }
+ }
+ return null;
+ }
+
+ void clearTransientStateViews() {
+ if (mTransientStateViews != null) {
+ mTransientStateViews.clear();
+ }
+ if (mTransientStateViewsById != null) {
+ mTransientStateViewsById.clear();
+ }
+ }
+
+ View getScrapView(int position) {
+ if (mViewTypeCount == 1) {
+ return retrieveFromScrap(mCurrentScrap, position);
+ } else {
+ int whichScrap = mAdapter.getItemViewType(position);
+ if (whichScrap >= 0 && whichScrap < mScrapViews.length) {
+ return retrieveFromScrap(mScrapViews[whichScrap], position);
+ }
+ }
+ return null;
+ }
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+ void addScrapView(View scrap, int position) {
+ final ZrcAbsListView.LayoutParams lp = (ZrcAbsListView.LayoutParams) scrap.getLayoutParams();
+ if (lp == null) {
+ return;
+ }
+ lp.scrappedFromPosition = position;
+ final int viewType = lp.viewType;
+ if (!shouldRecycleViewType(viewType)) {
+ return;
+ }
+ final boolean scrapHasTransientState = android.os.Build.VERSION.SDK_INT >= 16 ? scrap.hasTransientState()
+ : false;
+ if (scrapHasTransientState) {
+ if (mAdapter != null && mAdapterHasStableIds) {
+ if (mTransientStateViewsById == null) {
+ mTransientStateViewsById = new LongSparseArray();
+ }
+ mTransientStateViewsById.put(lp.itemId, scrap);
+ } else if (!mDataChanged) {
+ if (mTransientStateViews == null) {
+ mTransientStateViews = new SparseArrayCompat();
+ }
+ mTransientStateViews.put(position, scrap);
+ } else {
+ if (mSkippedScrap == null) {
+ mSkippedScrap = new ArrayList();
+ }
+ mSkippedScrap.add(scrap);
+ }
+ } else {
+ if (mViewTypeCount == 1) {
+ mCurrentScrap.add(scrap);
+ } else {
+ mScrapViews[viewType].add(scrap);
+ }
+ if (mRecyclerListener != null) {
+ mRecyclerListener.onMovedToScrapHeap(scrap);
+ }
+ }
+ }
+
+ void removeSkippedScrap() {
+ if (mSkippedScrap == null) {
+ return;
+ }
+ final int count = mSkippedScrap.size();
+ for (int i = 0; i < count; i++) {
+ removeDetachedView(mSkippedScrap.get(i), false);
+ }
+ mSkippedScrap.clear();
+ }
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+ void scrapActiveViews() {
+ final View[] activeViews = mActiveViews;
+ final boolean hasListener = mRecyclerListener != null;
+ final boolean multipleScraps = mViewTypeCount > 1;
+ ArrayList scrapViews = mCurrentScrap;
+ final int count = activeViews.length;
+ for (int i = count - 1; i >= 0; i--) {
+ final View victim = activeViews[i];
+ if (victim != null) {
+ final ZrcAbsListView.LayoutParams lp = (ZrcAbsListView.LayoutParams) victim.getLayoutParams();
+ int whichScrap = lp.viewType;
+ activeViews[i] = null;
+ final boolean scrapHasTransientState = android.os.Build.VERSION.SDK_INT >= 16 ? victim
+ .hasTransientState() : false;
+ if (!shouldRecycleViewType(whichScrap) || scrapHasTransientState) {
+ if (whichScrap != ITEM_VIEW_TYPE_HEADER_OR_FOOTER && scrapHasTransientState) {
+ removeDetachedView(victim, false);
+ }
+ if (scrapHasTransientState) {
+ if (mAdapter != null && mAdapterHasStableIds) {
+ if (mTransientStateViewsById == null) {
+ mTransientStateViewsById = new LongSparseArray();
+ }
+ long id = mAdapter.getItemId(mFirstActivePosition + i);
+ mTransientStateViewsById.put(id, victim);
+ } else {
+ if (mTransientStateViews == null) {
+ mTransientStateViews = new SparseArrayCompat();
+ }
+ mTransientStateViews.put(mFirstActivePosition + i, victim);
+ }
+ }
+ continue;
+ }
+ if (multipleScraps) {
+ scrapViews = mScrapViews[whichScrap];
+ }
+ victim.onStartTemporaryDetach();
+ lp.scrappedFromPosition = mFirstActivePosition + i;
+ scrapViews.add(victim);
+ if (hasListener) {
+ mRecyclerListener.onMovedToScrapHeap(victim);
+ }
+ }
+ }
+ pruneScrapViews();
+ }
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+ private void pruneScrapViews() {
+ final int maxViews = mActiveViews.length;
+ final int viewTypeCount = mViewTypeCount;
+ final ArrayList[] scrapViews = mScrapViews;
+ for (int i = 0; i < viewTypeCount; ++i) {
+ final ArrayList scrapPile = scrapViews[i];
+ int size = scrapPile.size();
+ final int extras = size - maxViews;
+ size--;
+ for (int j = 0; j < extras; j++) {
+ removeDetachedView(scrapPile.remove(size--), false);
+ }
+ }
+ if (mTransientStateViews != null) {
+ for (int i = 0; i < mTransientStateViews.size(); i++) {
+ final View v = mTransientStateViews.valueAt(i);
+ if (!v.hasTransientState()) {
+ mTransientStateViews.removeAt(i);
+ i--;
+ }
+ }
+ }
+ }
+
+ void reclaimScrapViews(List views) {
+ if (mViewTypeCount == 1) {
+ views.addAll(mCurrentScrap);
+ } else {
+ final int viewTypeCount = mViewTypeCount;
+ final ArrayList[] scrapViews = mScrapViews;
+ for (int i = 0; i < viewTypeCount; ++i) {
+ final ArrayList scrapPile = scrapViews[i];
+ views.addAll(scrapPile);
+ }
+ }
+ }
+
+ void setCacheColorHint(int color) {
+ if (mViewTypeCount == 1) {
+ final ArrayList scrap = mCurrentScrap;
+ final int scrapCount = scrap.size();
+ for (int i = 0; i < scrapCount; i++) {
+ scrap.get(i).setDrawingCacheBackgroundColor(color);
+ }
+ } else {
+ final int typeCount = mViewTypeCount;
+ for (int i = 0; i < typeCount; i++) {
+ final ArrayList scrap = mScrapViews[i];
+ final int scrapCount = scrap.size();
+ for (int j = 0; j < scrapCount; j++) {
+ scrap.get(j).setDrawingCacheBackgroundColor(color);
+ }
+ }
+ }
+ final View[] activeViews = mActiveViews;
+ final int count = activeViews.length;
+ for (int i = 0; i < count; ++i) {
+ final View victim = activeViews[i];
+ if (victim != null) {
+ victim.setDrawingCacheBackgroundColor(color);
+ }
+ }
+ }
+ }
+
+ static View retrieveFromScrap(ArrayList scrapViews, int position) {
+ int size = scrapViews.size();
+ if (size > 0) {
+ for (int i = 0; i < size; i++) {
+ View view = scrapViews.get(i);
+ if (((ZrcAbsListView.LayoutParams) view.getLayoutParams()).scrappedFromPosition == position) {
+ scrapViews.remove(i);
+ return view;
+ }
+ }
+ return scrapViews.remove(size - 1);
+ } else {
+ return null;
+ }
+ }
+}
diff --git a/src/zrc/widget/ZrcAdapterView.java b/src/zrc/widget/ZrcAdapterView.java
new file mode 100644
index 0000000..7234521
--- /dev/null
+++ b/src/zrc/widget/ZrcAdapterView.java
@@ -0,0 +1,273 @@
+package zrc.widget;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.database.DataSetObserver;
+import android.os.Build;
+import android.os.Parcelable;
+import android.util.AttributeSet;
+import android.util.SparseArray;
+import android.view.SoundEffectConstants;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Adapter;
+
+import zrc.util.APIUtil;
+import zrc.widget.ZrcListView.OnItemClickListener;
+import zrc.widget.ZrcListView.OnItemLongClickListener;
+
+abstract class ZrcAdapterView extends ViewGroup {
+ public static final int ITEM_VIEW_TYPE_IGNORE = -1;
+ public static final int ITEM_VIEW_TYPE_HEADER_OR_FOOTER = -2;
+ int mFirstPosition = 0;
+ int mFirstTop = 0;
+ boolean mInLayout = false;
+ OnItemClickListener mOnItemClickListener;
+ OnItemLongClickListener mOnItemLongClickListener;
+ boolean mDataChanged;
+ private View mEmptyView;
+ int mItemCount;
+ int mOldItemCount;
+ public static final int INVALID_POSITION = -1;
+ public static final long INVALID_ROW_ID = Long.MIN_VALUE;
+ private boolean mDesiredFocusableState;
+ private boolean mDesiredFocusableInTouchModeState;
+
+ boolean mBlockLayoutRequests = false;
+
+ public ZrcAdapterView(Context context) {
+ super(context);
+ }
+
+ public ZrcAdapterView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ public ZrcAdapterView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ }
+
+ public void setOnItemClickListener(OnItemClickListener listener) {
+ mOnItemClickListener = listener;
+ }
+
+ public final OnItemClickListener getOnItemClickListener() {
+ return mOnItemClickListener;
+ }
+
+ public boolean performItemClick(View view, int position, long id) {
+ if (mOnItemClickListener != null) {
+ playSoundEffect(SoundEffectConstants.CLICK);
+ mOnItemClickListener.onItemClick((ZrcListView)this, view, position, id);
+ return true;
+ }
+ return false;
+ }
+
+ public void setOnItemLongClickListener(OnItemLongClickListener listener) {
+ if (!isLongClickable()) {
+ setLongClickable(true);
+ }
+ mOnItemLongClickListener = listener;
+ }
+
+ public final OnItemLongClickListener getOnItemLongClickListener() {
+ return mOnItemLongClickListener;
+ }
+
+ public abstract T getAdapter();
+
+ public abstract void setAdapter(T adapter);
+
+ @Override
+ public void addView(View child) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addView(View child, int index) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addView(View child, LayoutParams params) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addView(View child, int index, LayoutParams params) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void removeView(View child) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void removeViewAt(int index) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void removeAllViews() {
+ throw new UnsupportedOperationException();
+ }
+
+ public int getCount() {
+ return mItemCount;
+ }
+
+ public int getPositionForView(View view) {
+ View listItem = view;
+ try {
+ View v;
+ while (!(v = (View) listItem.getParent()).equals(this)) {
+ listItem = v;
+ }
+ } catch (ClassCastException e) {
+ // We made it up to the window without find this list view
+ return INVALID_POSITION;
+ }
+
+ // Search the children for the list item
+ final int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ if (getChildAt(i).equals(listItem)) {
+ return mFirstPosition + i;
+ }
+ }
+ return INVALID_POSITION;
+ }
+
+ public int getFirstVisiblePosition() {
+ return mFirstPosition;
+ }
+
+ public int getLastVisiblePosition() {
+ return mFirstPosition + getChildCount() - 1;
+ }
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+ public void setEmptyView(View emptyView) {
+ mEmptyView = emptyView;
+
+ final T adapter = getAdapter();
+ final boolean empty = ((adapter == null) || adapter.isEmpty());
+ updateEmptyStatus(empty);
+ }
+
+ public View getEmptyView() {
+ return mEmptyView;
+ }
+
+ @Override
+ public void setFocusable(boolean focusable) {
+ final T adapter = getAdapter();
+ final boolean empty = adapter == null || adapter.getCount() == 0;
+
+ mDesiredFocusableState = focusable;
+ if (!focusable) {
+ mDesiredFocusableInTouchModeState = false;
+ }
+ super.setFocusable(focusable && (!empty));
+ }
+
+ @Override
+ public void setFocusableInTouchMode(boolean focusable) {
+ final T adapter = getAdapter();
+ final boolean empty = adapter == null || adapter.getCount() == 0;
+ mDesiredFocusableInTouchModeState = focusable;
+ if (focusable) {
+ mDesiredFocusableState = true;
+ }
+ super.setFocusableInTouchMode(focusable && (!empty));
+ }
+
+ void checkFocus() {
+ final T adapter = getAdapter();
+ final boolean empty = adapter == null || adapter.getCount() == 0;
+ final boolean focusable = !empty;
+ super.setFocusableInTouchMode(focusable && mDesiredFocusableInTouchModeState);
+ super.setFocusable(focusable && mDesiredFocusableState);
+ if (mEmptyView != null) {
+ updateEmptyStatus((adapter == null) || adapter.isEmpty());
+ }
+ }
+
+ private void updateEmptyStatus(boolean empty) {
+ if (empty) {
+ if (mEmptyView != null) {
+ mEmptyView.setVisibility(View.VISIBLE);
+ setVisibility(View.GONE);
+ } else {
+ setVisibility(View.VISIBLE);
+ }
+ } else {
+ if (mEmptyView != null) {
+ mEmptyView.setVisibility(View.GONE);
+ }
+ setVisibility(View.VISIBLE);
+ }
+ }
+
+ public Object getItemAtPosition(int position) {
+ T adapter = getAdapter();
+ return (adapter == null || position < 0) ? null : adapter.getItem(position);
+ }
+
+ public long getItemIdAtPosition(int position) {
+ T adapter = getAdapter();
+ return (adapter == null || position < 0) ? INVALID_ROW_ID : adapter.getItemId(position);
+ }
+
+ @Override
+ public void setOnClickListener(OnClickListener l) {
+ throw new RuntimeException();
+ }
+
+ @Override
+ protected void dispatchSaveInstanceState(SparseArray container) {
+ dispatchFreezeSelfOnly(container);
+ }
+
+ @Override
+ protected void dispatchRestoreInstanceState(SparseArray container) {
+ dispatchThawSelfOnly(container);
+ }
+
+ class AdapterDataSetObserver extends DataSetObserver {
+ @Override
+ public void onChanged() {
+ mDataChanged = true;
+ mOldItemCount = mItemCount;
+ mItemCount = getAdapter().getCount();
+ checkFocus();
+ requestLayout();
+ }
+
+ @Override
+ public void onInvalidated() {
+ mDataChanged = true;
+ mOldItemCount = mItemCount;
+ mItemCount = 0;
+ checkFocus();
+ requestLayout();
+ }
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ }
+
+ @Override
+ protected boolean canAnimate() {
+ return super.canAnimate() && mItemCount > 0;
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ protected boolean isSupportHardwareAccelerated(){
+ return APIUtil.isSupport(11) && isHardwareAccelerated();
+ }
+}
diff --git a/src/zrc/widget/ZrcListView.java b/src/zrc/widget/ZrcListView.java
new file mode 100644
index 0000000..5179281
--- /dev/null
+++ b/src/zrc/widget/ZrcListView.java
@@ -0,0 +1,1165 @@
+package zrc.widget;
+
+import java.util.ArrayList;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.AnimationUtils;
+import android.widget.ListAdapter;
+
+import zrc.util.APIUtil;
+
+/**
+ * @author Zaric
+ *
+ */
+public class ZrcListView extends ZrcAbsListView {
+ static final int NO_POSITION = -1;
+ private static final float MAX_SCROLL_FACTOR = 0.33f;
+
+ public class FixedViewInfo {
+ public View view;
+ public Object data;
+ public boolean isSelectable;
+ }
+
+ private ArrayList mHeaderViewInfos = new ArrayList();
+ private ArrayList mFooterViewInfos = new ArrayList();
+ Drawable mDivider;
+ int mDividerHeight;
+ private boolean mIsCacheColorOpaque;
+ private boolean mDividerIsOpaque;
+ private boolean mHeaderDividersEnabled;
+ private boolean mFooterDividersEnabled;
+ private boolean mAreAllItemsSelectable = true;
+ private boolean mItemsCanFocus = false;
+ private final Rect mTempRect = new Rect();
+ private Paint mDividerPaint;
+ private int mItemAnimForTopIn;
+ private int mItemAnimForBottomIn;
+
+ public ZrcListView(Context context) {
+ this(context, null);
+ }
+
+ public ZrcListView(Context context, AttributeSet attrs) {
+ this(context, attrs, android.R.attr.listViewStyle);
+ }
+
+ public ZrcListView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ListView, defStyle, 0);
+ final Drawable d = a.getDrawable(R.styleable.ListView_android_divider);
+ if (d != null) {
+ setDivider(d);
+ }
+ final int dividerHeight = a.getDimensionPixelSize(R.styleable.ListView_android_dividerHeight, 0);
+ if (dividerHeight != 0) {
+ setDividerHeight(dividerHeight);
+ }
+ mHeaderDividersEnabled = a.getBoolean(R.styleable.ListView_android_headerDividersEnabled, true);
+ mFooterDividersEnabled = a.getBoolean(R.styleable.ListView_android_footerDividersEnabled, true);
+ mItemAnimForTopIn = 0;
+ mItemAnimForBottomIn = 0;
+ a.recycle();
+ }
+
+ public int getMaxScrollAmount() {
+ return (int) (MAX_SCROLL_FACTOR * (getBottom() - getTop()));
+ }
+
+ private void adjustViewsUp() {
+ final int childCount = getChildCount();
+ int delta;
+ if (childCount > 0) {
+ View child;
+ child = getChildAt(0);
+ delta = child.getTop() - mListPadding.top - mFirstTopOffset;
+ if (mFirstPosition != 0) {
+ delta -= mDividerHeight;
+ }
+ if (delta < 0) {
+ delta = 0;
+ }
+ if (delta != 0) {
+ offsetChildrenTopAndBottom(-delta);
+ }
+ }
+ }
+
+ public void addHeaderView(View v, Object data, boolean isSelectable) {
+ final FixedViewInfo info = new FixedViewInfo();
+ info.view = v;
+ info.data = data;
+ info.isSelectable = isSelectable;
+ mHeaderViewInfos.add(info);
+ if (mAdapter != null) {
+ if (!(mAdapter instanceof HeaderViewListAdapter)) {
+ mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, mAdapter);
+ }
+ if (mDataSetObserver != null) {
+ mDataSetObserver.onChanged();
+ }
+ }
+ }
+
+ public void addHeaderView(View v) {
+ addHeaderView(v, null, true);
+ }
+
+ @Override
+ public int getHeaderViewsCount() {
+ return mHeaderViewInfos.size();
+ }
+
+ public boolean removeHeaderView(View v) {
+ if (mHeaderViewInfos.size() > 0) {
+ boolean result = false;
+ if (mAdapter != null && ((HeaderViewListAdapter) mAdapter).removeHeader(v)) {
+ if (mDataSetObserver != null) {
+ mDataSetObserver.onChanged();
+ }
+ result = true;
+ }
+ removeFixedViewInfo(v, mHeaderViewInfos);
+ return result;
+ }
+ return false;
+ }
+
+ private void removeFixedViewInfo(View v, ArrayList where) {
+ int len = where.size();
+ for (int i = 0; i < len; ++i) {
+ FixedViewInfo info = where.get(i);
+ if (info.view == v) {
+ where.remove(i);
+ break;
+ }
+ }
+ }
+
+ public void addFooterView(View v, Object data, boolean isSelectable) {
+ final FixedViewInfo info = new FixedViewInfo();
+ info.view = v;
+ info.data = data;
+ info.isSelectable = isSelectable;
+ mFooterViewInfos.add(info);
+
+ // Wrap the adapter if it wasn't already wrapped.
+ if (mAdapter != null) {
+ if (!(mAdapter instanceof HeaderViewListAdapter)) {
+ mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, mAdapter);
+ }
+ if (mDataSetObserver != null) {
+ mDataSetObserver.onChanged();
+ }
+ }
+ }
+
+ public void addFooterView(View v) {
+ addFooterView(v, null, true);
+ }
+
+ @Override
+ public int getFooterViewsCount() {
+ return mFooterViewInfos.size();
+ }
+
+ public boolean removeFooterView(View v) {
+ if (mFooterViewInfos.size() > 0) {
+ boolean result = false;
+ if (mAdapter != null && ((HeaderViewListAdapter) mAdapter).removeFooter(v)) {
+ if (mDataSetObserver != null) {
+ mDataSetObserver.onChanged();
+ }
+ result = true;
+ }
+ removeFixedViewInfo(v, mFooterViewInfos);
+ return result;
+ }
+ return false;
+ }
+
+ @Override
+ public ListAdapter getAdapter() {
+ return mAdapter;
+ }
+
+ @Override
+ public void setAdapter(ListAdapter adapter) {
+ if (mAdapter != null && mDataSetObserver != null) {
+ mAdapter.unregisterDataSetObserver(mDataSetObserver);
+ }
+ resetList();
+ mRecycler.clear();
+
+ if (mHeaderViewInfos.size() > 0 || mFooterViewInfos.size() > 0) {
+ mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);
+ } else {
+ mAdapter = adapter;
+ }
+ // AbsListView#setAdapter will update choice mode states.
+ super.setAdapter(adapter);
+
+ if (mAdapter != null) {
+ mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
+ mOldItemCount = mItemCount;
+ mItemCount = mAdapter.getCount();
+ checkFocus();
+
+ mDataSetObserver = new AdapterDataSetObserver();
+ mAdapter.registerDataSetObserver(mDataSetObserver);
+
+ mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
+ } else {
+ mAreAllItemsSelectable = true;
+ checkFocus();
+ }
+
+ requestLayout();
+ }
+
+ @Override
+ void resetList() {
+ clearRecycledState(mHeaderViewInfos);
+ clearRecycledState(mFooterViewInfos);
+ super.resetList();
+ mLayoutMode = LAYOUT_NORMAL;
+ }
+
+ private void clearRecycledState(ArrayList infos) {
+ if (infos != null) {
+ final int count = infos.size();
+
+ for (int i = 0; i < count; i++) {
+ final View child = infos.get(i).view;
+ final LayoutParams p = (LayoutParams) child.getLayoutParams();
+ if (p != null) {
+ p.recycledHeaderFooter = false;
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean requestChildRectangleOnScreen(View child, Rect rect, boolean immediate) {
+ rect.offset(child.getLeft(), child.getTop());
+ rect.offset(-child.getScrollX(), -child.getScrollY());
+
+ final int height = getHeight();
+ int listUnfadedTop = getScrollY();
+ int listUnfadedBottom = listUnfadedTop + height;
+
+ int childCount = getChildCount();
+ int bottomOfBottomChild = getChildAt(childCount - 1).getBottom();
+
+ int scrollYDelta = 0;
+
+ if (rect.bottom > listUnfadedBottom && rect.top > listUnfadedTop) {
+ // need to MOVE DOWN to get it in view: move down just enough so
+ // that the entire rectangle is in view (or at least the first
+ // screen size chunk).
+
+ if (rect.height() > height) {
+ // just enough to get screen size chunk on
+ scrollYDelta += (rect.top - listUnfadedTop);
+ } else {
+ // get entire rect at bottom of screen
+ scrollYDelta += (rect.bottom - listUnfadedBottom);
+ }
+
+ // make sure we aren't scrolling beyond the end of our children
+ int distanceToBottom = bottomOfBottomChild - listUnfadedBottom;
+ scrollYDelta = Math.min(scrollYDelta, distanceToBottom);
+ } else if (rect.top < listUnfadedTop && rect.bottom < listUnfadedBottom) {
+ // need to MOVE UP to get it in view: move up just enough so that
+ // entire rectangle is in view (or at least the first screen
+ // size chunk of it).
+
+ if (rect.height() > height) {
+ // screen size chunk
+ scrollYDelta -= (listUnfadedBottom - rect.bottom);
+ } else {
+ // entire rect at top
+ scrollYDelta -= (listUnfadedTop - rect.top);
+ }
+
+ // make sure we aren't scrolling any further than the top our
+ // children
+ int top = getChildAt(0).getTop();
+ int deltaToTop = top - listUnfadedTop;
+ scrollYDelta = Math.max(scrollYDelta, deltaToTop);
+ }
+
+ final boolean scroll = scrollYDelta != 0;
+ if (scroll) {
+ scrollListItemsBy(-scrollYDelta);
+ positionSelector(INVALID_POSITION, child);
+ invalidate();
+ }
+ return scroll;
+ }
+
+ @Override
+ void fillGap(boolean down) {
+ final int count = getChildCount();
+ if (down) {
+
+ final int startOffset = count > 0 ? getChildAt(count - 1).getBottom() + mDividerHeight : mFirstTop
+ + mListPadding.top + mFirstTopOffset;
+ fillDown(mFirstPosition + count, startOffset, true);
+ // correctTooHigh(getChildCount());
+ } else {
+ int paddingBottom = 0;
+
+ final int startOffset = count > 0 ? getChildAt(0).getTop() - mDividerHeight : getHeight() - paddingBottom
+ - mLastBottomOffset;
+ fillUp(mFirstPosition - 1, startOffset, true);
+ // correctTooLow(getChildCount());
+ }
+ }
+
+ private void fillDown(int pos, int nextTop, boolean isAnim) {
+ int end = (getBottom() - getTop());
+ while (nextTop < end && pos < mItemCount) {
+ View child = makeAndAddView(pos, nextTop, true, mListPadding.left, false);
+ nextTop = child.getBottom() + mDividerHeight;
+ if (isAnim && mItemAnimForBottomIn != 0 && child.getVisibility() == View.VISIBLE) {
+ child.startAnimation(AnimationUtils.loadAnimation(getContext(), mItemAnimForBottomIn));
+ }
+ pos++;
+ }
+ }
+
+ private void fillUp(int pos, int nextBottom, boolean isAnim) {
+ int end = 0;
+
+ while (nextBottom > end && pos >= 0) {
+ View child = makeAndAddView(pos, nextBottom, false, mListPadding.left, false);
+ nextBottom = child.getTop() - mDividerHeight;
+ if (isAnim && mItemAnimForTopIn != 0 && child.getVisibility() == View.VISIBLE) {
+ child.startAnimation(AnimationUtils.loadAnimation(getContext(), mItemAnimForTopIn));
+ }
+ pos--;
+ }
+ mFirstPosition = pos + 1;
+ }
+
+ private void fillFromTop(int nextTop) {
+ mFirstPosition = Math.min(mFirstPosition, mItemCount - 1);
+ if (mFirstPosition < 0) {
+ mFirstPosition = 0;
+ }
+ fillDown(mFirstPosition, nextTop, false);
+ }
+
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ // Sets up mListPadding
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+ int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+ int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+ int widthSize = MeasureSpec.getSize(widthMeasureSpec);
+ int heightSize = MeasureSpec.getSize(heightMeasureSpec);
+
+ int childWidth = 0;
+ int childHeight = 0;
+ int childState = 0;
+
+ mItemCount = mAdapter == null ? 0 : mAdapter.getCount();
+ if (mItemCount > 0 && (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED)) {
+ final View child = obtainView(0, mIsScrap);
+
+ measureScrapChild(child, 0, widthMeasureSpec);
+
+ childWidth = child.getMeasuredWidth();
+ childHeight = child.getMeasuredHeight();
+ childState = combineMeasuredStates(childState, child.getMeasuredState());
+
+ if (recycleOnMeasure()
+ && mRecycler.shouldRecycleViewType(((LayoutParams) child.getLayoutParams()).viewType)) {
+ mRecycler.addScrapView(child, -1);
+ }
+ }
+
+ if (widthMode == MeasureSpec.UNSPECIFIED) {
+ widthSize = mListPadding.left + mListPadding.right + childWidth + getVerticalScrollbarWidth();
+ } else {
+ widthSize |= (childState & MEASURED_STATE_MASK);
+ }
+
+ if (heightMode == MeasureSpec.UNSPECIFIED) {
+ heightSize = mListPadding.top + mListPadding.bottom + childHeight + mFirstTopOffset + mLastBottomOffset;
+ }
+
+ if (heightMode == MeasureSpec.AT_MOST) {
+ heightSize = measureHeightOfChildren(widthMeasureSpec, 0, NO_POSITION, heightSize, -1);
+ }
+
+ setMeasuredDimension(widthSize, heightSize);
+ mWidthMeasureSpec = widthMeasureSpec;
+ }
+
+ private void measureScrapChild(View child, int position, int widthMeasureSpec) {
+ LayoutParams p = (LayoutParams) child.getLayoutParams();
+ if (p == null) {
+ p = (ZrcAbsListView.LayoutParams) generateDefaultLayoutParams();
+ child.setLayoutParams(p);
+ }
+ p.viewType = mAdapter.getItemViewType(position);
+ p.forceAdd = true;
+
+ int childWidthSpec = ViewGroup.getChildMeasureSpec(widthMeasureSpec, mListPadding.left + mListPadding.right,
+ p.width);
+ int lpHeight = p.height;
+ int childHeightSpec;
+ if (lpHeight > 0) {
+ childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);
+ } else {
+ childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+ }
+ child.measure(childWidthSpec, childHeightSpec);
+ }
+
+ protected boolean recycleOnMeasure() {
+ return true;
+ }
+
+ final int measureHeightOfChildren(int widthMeasureSpec, int startPosition, int endPosition, final int maxHeight,
+ int disallowPartialChildPosition) {
+ final ListAdapter adapter = mAdapter;
+ if (adapter == null) {
+ return mListPadding.top + mListPadding.bottom + mFirstTopOffset + mLastBottomOffset;
+ }
+
+ // Include the padding of the list
+ int returnedHeight = mListPadding.top + mListPadding.bottom + mFirstTopOffset + mLastBottomOffset;
+ final int dividerHeight = ((mDividerHeight > 0) && mDivider != null) ? mDividerHeight : 0;
+ // The previous height value that was less than maxHeight and contained
+ // no partial children
+ int prevHeightWithoutPartialChild = 0;
+ int i;
+ View child;
+
+ // mItemCount - 1 since endPosition parameter is inclusive
+ endPosition = (endPosition == NO_POSITION) ? adapter.getCount() - 1 : endPosition;
+ final ZrcAbsListView.RecycleBin recycleBin = mRecycler;
+ final boolean recyle = recycleOnMeasure();
+ final boolean[] isScrap = mIsScrap;
+
+ for (i = startPosition; i <= endPosition; ++i) {
+ child = obtainView(i, isScrap);
+
+ measureScrapChild(child, i, widthMeasureSpec);
+
+ if (i > 0) {
+ // Count the divider for all but one child
+ returnedHeight += dividerHeight;
+ }
+
+ // Recycle the view before we possibly return from the method
+ if (recyle && recycleBin.shouldRecycleViewType(((LayoutParams) child.getLayoutParams()).viewType)) {
+ recycleBin.addScrapView(child, -1);
+ }
+
+ returnedHeight += child.getMeasuredHeight();
+
+ if (returnedHeight >= maxHeight) {
+ // We went over, figure out which height to return. If
+ // returnedHeight > maxHeight,
+ // then the i'th position did not fit completely.
+ return (disallowPartialChildPosition >= 0) // Disallowing is
+ // enabled (> -1)
+ && (i > disallowPartialChildPosition) // We've past the
+ // min pos
+ && (prevHeightWithoutPartialChild > 0) // We have a prev
+ // height
+ && (returnedHeight != maxHeight) // i'th child did not
+ // fit completely
+ ? prevHeightWithoutPartialChild : maxHeight;
+ }
+
+ if ((disallowPartialChildPosition >= 0) && (i >= disallowPartialChildPosition)) {
+ prevHeightWithoutPartialChild = returnedHeight;
+ }
+ }
+
+ // At this point, we went through the range of children, and they each
+ // completely fit, so return the returnedHeight
+ return returnedHeight;
+ }
+
+ @Override
+ int findMotionRow(int y) {
+ int childCount = getChildCount();
+ if (childCount > 0) {
+ for (int i = 0; i < childCount; i++) {
+ View v = getChildAt(i);
+ if (y <= v.getBottom()) {
+ return mFirstPosition + i;
+ }
+ }
+ }
+ return INVALID_POSITION;
+ }
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+ @Override
+ protected void layoutChildren() {
+ final boolean blockLayoutRequests = mBlockLayoutRequests;
+ if (blockLayoutRequests) {
+ return;
+ }
+ mBlockLayoutRequests = true;
+ try {
+ super.layoutChildren();
+ invalidate();
+ final int childrenTop = mListPadding.top + mFirstTopOffset;
+ final int childrenBottom = getBottom() - getTop() - mListPadding.bottom - mLastBottomOffset;
+ final int childCount = getChildCount();
+
+ boolean dataChanged = mDataChanged;
+ if (dataChanged) {
+ handleDataChanged();
+ }
+
+ // Handle the empty set by removing all views that are visible
+ // and calling it a day
+ if (mAdapter!=null && mItemCount != mAdapter.getCount()) {
+ throw new IllegalStateException("The content of the adapter has changed but "
+ + "ListView did not receive a notification. Make sure the content of "
+ + "your adapter is not modified from a background thread, but only from "
+ + "the UI thread. Make sure your adapter calls notifyDataSetChanged() "
+ + "when its content changes. [in ListView(" + getId() + ", " + getClass() + ") with Adapter("
+ + mAdapter.getClass() + ")]");
+ }
+
+ // Ensure the child containing focus, if any, has transient state.
+ // If the list data hasn't changed, or if the adapter has stable
+ // IDs, this will maintain focus.
+ final View focusedChild = getFocusedChild();
+ if (focusedChild != null) {
+ focusedChild.setHasTransientState(true);
+ }
+
+ // Pull all children into the RecycleBin.
+ // These views will be reused if possible
+ final int firstPosition = mFirstPosition;
+ final int firstTop = mFirstTop;
+ final RecycleBin recycleBin = mRecycler;
+ if (dataChanged) {
+ for (int i = 0; i < childCount; i++) {
+ recycleBin.addScrapView(getChildAt(i), firstPosition + i);
+ }
+ } else {
+ recycleBin.fillActiveViews(childCount, firstPosition);
+ }
+
+ // Clear out old views
+ detachAllViewsFromParent();
+ recycleBin.removeSkippedScrap();
+ switch (mLayoutMode) {
+ case LAYOUT_FORCE_BOTTOM:
+ fillUp(mItemCount - 1, childrenBottom, false);
+ adjustViewsUp();
+ break;
+ case LAYOUT_FORCE_TOP:
+ mFirstPosition = 0;
+ fillFromTop(childrenTop);
+ break;
+ default:
+ if(mItemCount==0){
+ if(mTouchMode!=TOUCH_MODE_SCROLL){
+ scrollToAdjustViewsUpOrDown();
+ }
+ }else if(firstPosition >= mItemCount){
+ mFirstPosition = mItemCount - 1;
+ View child = makeAndAddView(mFirstPosition, 1, false, mListPadding.left, false);
+ if (mItemAnimForTopIn != 0 && child.getVisibility() == View.VISIBLE) {
+ child.startAnimation(AnimationUtils.loadAnimation(getContext(), mItemAnimForTopIn));
+ }
+ scrollToAdjustViewsUpOrDown();
+ }else{
+ fillDown(firstPosition, firstTop, false);
+ if(mTouchMode!=TOUCH_MODE_SCROLL){
+ scrollToAdjustViewsUpOrDown();
+ }
+ }
+ break;
+ }
+
+ // Flush any cached views that did not get reused above
+ recycleBin.scrapActiveViews();
+ // If the user's finger is down, select the motion position.
+ // Otherwise, clear selection.
+ if (mTouchMode == TOUCH_MODE_TAP || mTouchMode == TOUCH_MODE_DONE_WAITING) {
+ final View child = getChildAt(mMotionPosition - mFirstPosition);
+ if (child != null) {
+ positionSelector(mMotionPosition, child);
+ }
+ } else {
+ mSelectorRect.setEmpty();
+ }
+
+ mLayoutMode = LAYOUT_NORMAL;
+ mDataChanged = false;
+ if (mPositionScrollAfterLayout != null) {
+ post(mPositionScrollAfterLayout);
+ mPositionScrollAfterLayout = null;
+ }
+ updateScrollIndicators();
+
+ invokeOnItemScrollListener();
+ } finally {
+ if (!blockLayoutRequests) {
+ mBlockLayoutRequests = false;
+ }
+ }
+ }
+
+ /**
+ * Obtain the view and add it to our list of children. The view can be made
+ * fresh, converted from an unused view, or used as is if it was in the
+ * recycle bin.
+ *
+ * @param position Logical position in the list
+ * @param y Top or bottom edge of the view to add
+ * @param flow If flow is true, align top edge to y. If false, align bottom
+ * edge to y.
+ * @param childrenLeft Left edge where children should be positioned
+ * @param selected Is this position selected?
+ * @return View that was added
+ */
+ private View makeAndAddView(int position, int y, boolean flow, int childrenLeft, boolean selected) {
+ View child;
+
+ if (!mDataChanged) {
+ // Try to use an existing view for this position
+ child = mRecycler.getActiveView(position);
+ if (child != null) {
+ // Found it -- we're using an existing child
+ // This just needs to be positioned
+ setupChild(child, position, y, flow, childrenLeft, selected, true);
+
+ return child;
+ }
+ }
+
+ // Make a new view for this position, or convert an unused view if
+ // possible
+ child = obtainView(position, mIsScrap);
+
+ // This needs to be positioned and measured
+ setupChild(child, position, y, flow, childrenLeft, selected, mIsScrap[0]);
+
+ return child;
+ }
+
+ /**
+ * Add a view as a child and make sure it is measured (if necessary) and
+ * positioned properly.
+ *
+ * @param child The view to add
+ * @param position The position of this child
+ * @param y The y position relative to which this view will be positioned
+ * @param flowDown If true, align top edge to y. If false, align bottom edge
+ * to y.
+ * @param childrenLeft Left edge where children should be positioned
+ * @param selected Is this position selected?
+ * @param recycled Has this view been pulled from the recycle bin? If so it
+ * does not need to be remeasured.
+ */
+ @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+ private void setupChild(View child, int position, int y, boolean flowDown, int childrenLeft, boolean selected,
+ boolean recycled) {
+ final boolean isSelected = selected && shouldShowSelector();
+ final boolean updateChildSelected = isSelected != child.isSelected();
+ final int mode = mTouchMode;
+ final boolean isPressed = mode > TOUCH_MODE_DOWN && mode < TOUCH_MODE_SCROLL && mMotionPosition == position;
+ final boolean updateChildPressed = isPressed != child.isPressed();
+ final boolean needToMeasure = !recycled || updateChildSelected || child.isLayoutRequested();
+
+ // Respect layout params that are already in the view. Otherwise make
+ // some up...
+ // noinspection unchecked
+ ZrcAbsListView.LayoutParams p = (ZrcAbsListView.LayoutParams) child.getLayoutParams();
+ if (p == null) {
+ p = (ZrcAbsListView.LayoutParams) generateDefaultLayoutParams();
+ }
+ p.viewType = mAdapter.getItemViewType(position);
+
+ if ((recycled && !p.forceAdd)
+ || (p.recycledHeaderFooter && p.viewType == ZrcAdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER)) {
+ attachViewToParent(child, flowDown ? -1 : 0, p);
+ } else {
+ p.forceAdd = false;
+ if (p.viewType == ZrcAdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
+ p.recycledHeaderFooter = true;
+ }
+ addViewInLayout(child, flowDown ? -1 : 0, p, true);
+ }
+
+ if (updateChildSelected) {
+ child.setSelected(isSelected);
+ }
+
+ if (updateChildPressed) {
+ child.setPressed(isPressed);
+ }
+
+ if (needToMeasure) {
+ int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec, mListPadding.left
+ + mListPadding.right, p.width);
+ int lpHeight = p.height;
+ int childHeightSpec;
+ if (lpHeight > 0) {
+ childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);
+ } else {
+ childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+ }
+ child.measure(childWidthSpec, childHeightSpec);
+ } else {
+ cleanupLayoutState(child);
+ }
+
+ final int w = child.getMeasuredWidth();
+ final int h = child.getMeasuredHeight();
+ final int childTop = flowDown ? y : y - h;
+
+ if (needToMeasure) {
+ final int childRight = childrenLeft + w;
+ final int childBottom = childTop + h;
+ child.layout(childrenLeft, childTop, childRight, childBottom);
+ } else {
+ child.offsetLeftAndRight(childrenLeft - child.getLeft());
+ child.offsetTopAndBottom(childTop - child.getTop());
+ }
+
+ if (mCachingStarted && !child.isDrawingCacheEnabled()) {
+ child.setDrawingCacheEnabled(true);
+ }
+
+ if (recycled && (((ZrcAbsListView.LayoutParams) child.getLayoutParams()).scrappedFromPosition) != position) {
+ if (APIUtil.isSupport(11)) {
+ child.jumpDrawablesToCurrentState();
+ }
+ }
+ }
+
+ @Override
+ protected boolean canAnimate() {
+ return super.canAnimate() && mItemCount > 0;
+ }
+
+ /**
+ * Scroll the children by amount, adding a view at the end and removing
+ * views that fall off as necessary.
+ *
+ * @param amount The amount (positive or negative) to scroll.
+ */
+ private void scrollListItemsBy(int amount) {
+ offsetChildrenTopAndBottom(amount);
+
+ final int listBottom = getHeight() - mListPadding.bottom - mLastBottomOffset;
+ final int listTop = mListPadding.top + mFirstTopOffset;
+ final ZrcAbsListView.RecycleBin recycleBin = mRecycler;
+
+ if (amount < 0) {
+ // shifted items up
+
+ // may need to pan views into the bottom space
+ int numChildren = getChildCount();
+ View last = getChildAt(numChildren - 1);
+ while (last.getBottom() < listBottom) {
+ final int lastVisiblePosition = mFirstPosition + numChildren - 1;
+ if (lastVisiblePosition < mItemCount - 1) {
+ last = addViewBelow(last, lastVisiblePosition);
+ numChildren++;
+ } else {
+ break;
+ }
+ }
+
+ // may have brought in the last child of the list that is skinnier
+ // than the fading edge, thereby leaving space at the end. need
+ // to shift back
+ if (last.getBottom() < listBottom) {
+ // offsetChildrenTopAndBottom(listBottom - last.getBottom());
+ }
+
+ // top views may be panned off screen
+ View first = getChildAt(0);
+ while (first.getBottom() < listTop) {
+ ZrcAbsListView.LayoutParams layoutParams = (LayoutParams) first.getLayoutParams();
+ if (recycleBin.shouldRecycleViewType(layoutParams.viewType)) {
+ recycleBin.addScrapView(first, mFirstPosition);
+ }
+ detachViewFromParent(first);
+ first = getChildAt(0);
+ mFirstPosition++;
+ }
+ } else {
+ // shifted items down
+ View first = getChildAt(0);
+
+ // may need to pan views into top
+ while ((first.getTop() > listTop) && (mFirstPosition > 0)) {
+ first = addViewAbove(first, mFirstPosition);
+ mFirstPosition--;
+ }
+
+ // may have brought the very first child of the list in too far and
+ // need to shift it back
+ if (first.getTop() > listTop) {
+ // offsetChildrenTopAndBottom(listTop - first.getTop());
+ }
+
+ int lastIndex = getChildCount() - 1;
+ View last = getChildAt(lastIndex);
+
+ // bottom view may be panned off screen
+ while (last.getTop() > listBottom) {
+ ZrcAbsListView.LayoutParams layoutParams = (LayoutParams) last.getLayoutParams();
+ if (recycleBin.shouldRecycleViewType(layoutParams.viewType)) {
+ recycleBin.addScrapView(last, mFirstPosition + lastIndex);
+ }
+ detachViewFromParent(last);
+ last = getChildAt(--lastIndex);
+ }
+ }
+ }
+
+ private View addViewAbove(View theView, int position) {
+ int abovePosition = position - 1;
+ View view = obtainView(abovePosition, mIsScrap);
+ int edgeOfNewChild = theView.getTop() - mDividerHeight;
+ setupChild(view, abovePosition, edgeOfNewChild, false, mListPadding.left, false, mIsScrap[0]);
+ return view;
+ }
+
+ private View addViewBelow(View theView, int position) {
+ int belowPosition = position + 1;
+ View view = obtainView(belowPosition, mIsScrap);
+ int edgeOfNewChild = theView.getBottom() + mDividerHeight;
+ setupChild(view, belowPosition, edgeOfNewChild, true, mListPadding.left, false, mIsScrap[0]);
+ return view;
+ }
+
+ /**
+ * Indicates that the views created by the ListAdapter can contain focusable
+ * items.
+ *
+ * @param itemsCanFocus true if items can get focus, false otherwise
+ */
+ public void setItemsCanFocus(boolean itemsCanFocus) {
+ mItemsCanFocus = itemsCanFocus;
+ if (!itemsCanFocus) {
+ setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
+ }
+ }
+
+ /**
+ * @return Whether the views created by the ListAdapter can contain
+ * focusable items.
+ */
+ public boolean getItemsCanFocus() {
+ return mItemsCanFocus;
+ }
+
+ @Override
+ public boolean isOpaque() {
+ boolean retValue = (mCachingActive && mIsCacheColorOpaque && mDividerIsOpaque) || super.isOpaque();
+ if (retValue) {
+ // only return true if the list items cover the entire area of the
+ // view
+ final int listTop = mListPadding != null ? mListPadding.top + mFirstTopOffset : getPaddingTop();
+ View first = getChildAt(0);
+ if (first == null || first.getTop() > listTop) {
+ return false;
+ }
+ final int listBottom = getHeight()
+ - (mListPadding != null ? mListPadding.bottom + mLastBottomOffset : getPaddingBottom());
+ View last = getChildAt(getChildCount() - 1);
+ if (last == null || last.getBottom() < listBottom) {
+ return false;
+ }
+ }
+ return retValue;
+ }
+
+ @Override
+ public void setCacheColorHint(int color) {
+ final boolean opaque = (color >>> 24) == 0xFF;
+ mIsCacheColorOpaque = opaque;
+ if (opaque) {
+ if (mDividerPaint == null) {
+ mDividerPaint = new Paint();
+ }
+ mDividerPaint.setColor(color);
+ }
+ super.setCacheColorHint(color);
+ }
+
+ @Override
+ protected void dispatchDraw(Canvas canvas) {
+ if (mCachingStarted) {
+ mCachingActive = true;
+ }
+ // Draw the dividers
+ final int dividerHeight = mDividerHeight;
+ final boolean drawDividers = dividerHeight > 0 && mDivider != null;
+
+ if (drawDividers) {
+ // Only modify the top and bottom in the loop, we set the left and
+ // right here
+ final Rect bounds = mTempRect;
+ bounds.left = getPaddingLeft();
+ bounds.right = getRight() - getLeft() - getPaddingRight();
+
+ final int mBottom = getBottom();
+ final int mTop = getTop();
+ final int mScrollY = getScrollY();
+ final int count = getChildCount();
+ final int headerCount = mHeaderViewInfos.size();
+ final int itemCount = mItemCount;
+ final int footerLimit = (itemCount - mFooterViewInfos.size());
+ final boolean headerDividers = mHeaderDividersEnabled;
+ final boolean footerDividers = mFooterDividersEnabled;
+ final int first = mFirstPosition;
+ final boolean areAllItemsSelectable = mAreAllItemsSelectable;
+ final ListAdapter adapter = mAdapter;
+ // If the list is opaque *and* the background is not, we want to
+ // fill a rect where the dividers would be for non-selectable items
+ // If the list is opaque and the background is also opaque, we don't
+ // need to draw anything since the background will do it for us
+ final boolean fillForMissingDividers = isOpaque() && !super.isOpaque();
+
+ if (fillForMissingDividers && mDividerPaint == null && mIsCacheColorOpaque) {
+ mDividerPaint = new Paint();
+ mDividerPaint.setColor(getCacheColorHint());
+ }
+ final Paint paint = mDividerPaint;
+
+ int effectivePaddingBottom = 0;
+
+ final int listBottom = mBottom - mTop - effectivePaddingBottom + mScrollY;
+ int bottom = 0;
+
+ if(getChildCount()>0){
+ final int firstTop = getChildAt(0).getTop();
+ if(firstTop > 0){
+ bounds.top = firstTop - dividerHeight;
+ bounds.bottom = firstTop;
+ drawDivider(canvas, bounds, 0);
+ }
+ }
+ for (int i = 0; i < count; i++) {
+ final int itemIndex = (first + i);
+ final boolean isHeader = (itemIndex < headerCount);
+ final boolean isFooter = (itemIndex >= footerLimit);
+ if ((headerDividers || !isHeader) && (footerDividers || !isFooter)) {
+ final View child = getChildAt(i);
+ bottom = child.getBottom();
+ final boolean isLastItem = (i == (count - 1));
+
+ if (drawDividers && (bottom < listBottom)) {
+ final int nextIndex = (itemIndex + 1);
+ // Draw dividers between enabled items, headers and/or
+ // footers when enabled, and the end of the list.
+ if (areAllItemsSelectable
+ || ((adapter.isEnabled(itemIndex) || (headerDividers && isHeader) || (footerDividers && isFooter)) && (isLastItem
+ || adapter.isEnabled(nextIndex)
+ || (headerDividers && (nextIndex < headerCount)) || (footerDividers && (nextIndex >= footerLimit))))) {
+ bounds.top = bottom;
+ bounds.bottom = bottom + dividerHeight;
+ drawDivider(canvas, bounds, i);
+ } else if (fillForMissingDividers) {
+ bounds.top = bottom;
+ bounds.bottom = bottom + dividerHeight;
+ canvas.drawRect(bounds, paint);
+ }
+ }
+ }
+ }
+ }
+ super.dispatchDraw(canvas);
+ }
+
+ @Override
+ protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
+ boolean more = super.drawChild(canvas, child, drawingTime);
+ if (mCachingActive) {
+ mCachingActive = false;
+ }
+ return more;
+ }
+
+ void drawDivider(Canvas canvas, Rect bounds, int childIndex) {
+ final Drawable divider = mDivider;
+ divider.setBounds(bounds);
+ divider.draw(canvas);
+ }
+
+ public Drawable getDivider() {
+ return mDivider;
+ }
+
+ public void setDivider(Drawable divider) {
+ if (divider != null) {
+ mDividerHeight = divider.getIntrinsicHeight();
+ } else {
+ mDividerHeight = 0;
+ }
+ mDivider = divider;
+ mDividerIsOpaque = divider == null || divider.getOpacity() == PixelFormat.OPAQUE;
+ requestLayout();
+ invalidate();
+ }
+
+ public int getDividerHeight() {
+ return mDividerHeight;
+ }
+
+ public void setDividerHeight(int height) {
+ mDividerHeight = height;
+ requestLayout();
+ invalidate();
+ }
+
+ public void setHeaderDividersEnabled(boolean headerDividersEnabled) {
+ mHeaderDividersEnabled = headerDividersEnabled;
+ invalidate();
+ }
+
+ public boolean areHeaderDividersEnabled() {
+ return mHeaderDividersEnabled;
+ }
+
+ public void setFooterDividersEnabled(boolean footerDividersEnabled) {
+ mFooterDividersEnabled = footerDividersEnabled;
+ invalidate();
+ }
+
+ public boolean areFooterDividersEnabled() {
+ return mFooterDividersEnabled;
+ }
+
+ @Override
+ protected void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
+ super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+
+ final ListAdapter adapter = mAdapter;
+ if (adapter != null && gainFocus && previouslyFocusedRect != null) {
+ previouslyFocusedRect.offset(getScrollX(), getScrollY());
+
+ // Don't cache the result of getChildCount or mFirstPosition here,
+ // it could change in layoutChildren.
+ if (adapter.getCount() < getChildCount() + mFirstPosition) {
+ mLayoutMode = LAYOUT_NORMAL;
+ layoutChildren();
+ }
+
+ // figure out which item should be selected based on previously
+ // focused rect
+ Rect otherRect = mTempRect;
+ int minDistance = Integer.MAX_VALUE;
+ final int childCount = getChildCount();
+ final int firstPosition = mFirstPosition;
+
+ for (int i = 0; i < childCount; i++) {
+ // only consider selectable views
+ if (!adapter.isEnabled(firstPosition + i)) {
+ continue;
+ }
+
+ View other = getChildAt(i);
+ other.getDrawingRect(otherRect);
+ offsetDescendantRectToMyCoords(other, otherRect);
+ int distance = getDistance(previouslyFocusedRect, otherRect, direction);
+
+ if (distance < minDistance) {
+ minDistance = distance;
+ }
+ }
+ }
+
+ requestLayout();
+ }
+
+ /**
+ * convert all views to header view
+ */
+ @Override
+ protected void onFinishInflate() {
+ super.onFinishInflate();
+ int count = getChildCount();
+ if (count > 0) {
+ for (int i = 0; i < count; ++i) {
+ addHeaderView(getChildAt(i));
+ }
+ removeAllViews();
+ }
+ }
+
+ /**
+ * 设置由顶部进入视图的列表项动画，当animId = 0时，为取消动画。
+ * @param animId
+ */
+ public void setItemAnimForTopIn(int animId) {
+ mItemAnimForTopIn = animId;
+ }
+
+ /**
+ * 设置由底部进入视图的列表项动画，当animId = 0时，为取消动画。
+ * @param animId
+ */
+ public void setItemAnimForBottomIn(int animId) {
+ mItemAnimForBottomIn = animId;
+ }
+
+ public void setSelection(int i) {
+ mFirstPosition = i;
+ mFirstTop = 0;
+ layoutChildren();
+ }
+
+ public static interface OnStartListener {
+ void onStart();
+ }
+
+ public static interface OnScrollStateListener{
+ public static final int EDGE = 0;
+ public static final int DOWN = 1;
+ public static final int UP = 2;
+ void onChange(int state);
+ }
+
+ public static interface OnScrollListener {
+ public static int SCROLL_STATE_IDLE = 0;
+ public static int SCROLL_STATE_TOUCH_SCROLL = 1;
+ public static int SCROLL_STATE_FLING = 2;
+ public void onScrollStateChanged(ZrcAbsListView view, int scrollState);
+ public void onScroll(ZrcAbsListView view, int firstVisibleItem, int visibleItemCount,
+ int totalItemCount);
+ }
+
+ public interface OnItemClickListener {
+ void onItemClick(ZrcListView parent, View view, int position, long id);
+ }
+
+ public interface OnItemLongClickListener {
+ boolean onItemLongClick(ZrcListView parent, View view, int position, long id);
+ }
+}