自定义View之ListView实现幸运飞艇源码出售拖动排序效果

1.自定义View幸运飞艇源码出售Q1157880099

  1. <strong><span style="font-size:16px;">public class DragSortListView extends ListView {  
  2.   
  3.   
  4.     /** 
  5.      * The View that floats above the ListView and represents 
  6.      * the dragged item. 
  7.      */  
  8.     private View mFloatView;  
  9.   
  10.     /** 
  11.      * The float View location. First based on touch location 
  12.      * and given deltaX and deltaY. Then restricted by callback 
  13.      * to FloatViewManager.onDragFloatView(). Finally restricted 
  14.      * by bounds of DSLV. 
  15.      */  
  16.     private Point mFloatLoc = new Point();  
  17.   
  18.     private Point mTouchLoc = new Point();  
  19.   
  20.     /** 
  21.      * The middle (in the y-direction) of the floating View. 
  22.      */  
  23.     private int mFloatViewMid;  
  24.   
  25.     /** 
  26.      * Flag to make sure float View isn't measured twice 
  27.      */  
  28.     private boolean mFloatViewOnMeasured = false;  
  29.   
  30.     /** 
  31.      * Watch the Adapter for data changes. Cancel a drag if 
  32.      * coincident with a change. 
  33.      */  
  34.     private DataSetObserver mObserver;  
  35.   
  36.     /** 
  37.      * Transparency for the floating View (XML attribute). 
  38.      */  
  39.     private float mFloatAlpha = 1.0f;  
  40.     private float mCurrFloatAlpha = 1.0f;  
  41.   
  42.     /** 
  43.      * While drag-sorting, the current position of the floating 
  44.      * View. If dropped, the dragged item will land in this position. 
  45.      */  
  46.     private int mFloatPos;  
  47.   
  48.     /** 
  49.      * The first expanded ListView position that helps represent 
  50.      * the drop slot tracking the floating View. 
  51.      */  
  52.     private int mFirstExpPos;  
  53.   
  54.     /** 
  55.      * The second expanded ListView position that helps represent 
  56.      * the drop slot tracking the floating View. This can equal 
  57.      * mFirstExpPos if there is no slide shuffle occurring; otherwise 
  58.      * it is equal to mFirstExpPos + 1. 
  59.      */  
  60.     private int mSecondExpPos;  
  61.   
  62.     /** 
  63.      * Flag set if slide shuffling is enabled. 
  64.      */  
  65.     private boolean mAnimate = false;  
  66.   
  67.     /** 
  68.      * The user dragged from this position. 
  69.      */  
  70.     private int mSrcPos;  
  71.   
  72.     /** 
  73.      * Offset (in x) within the dragged item at which the user 
  74.      * picked it up (or first touched down with the digitalis). 
  75.      */  
  76.     private int mDragDeltaX;  
  77.   
  78.     /** 
  79.      * Offset (in y) within the dragged item at which the user 
  80.      * picked it up (or first touched down with the digitalis). 
  81.      */  
  82.     private int mDragDeltaY;  
  83.   
  84.   
  85.     /** 
  86.      * The difference (in x) between screen coordinates and coordinates 
  87.      * in this view. 
  88.      */  
  89.     private int mOffsetX;  
  90.   
  91.     /** 
  92.      * The difference (in y) between screen coordinates and coordinates 
  93.      * in this view. 
  94.      */  
  95.     private int mOffsetY;  
  96.   
  97.     /** 
  98.      * A listener that receives callbacks whenever the floating View 
  99.      * hovers over a new position. 
  100.      */  
  101.     private DragListener mDragListener;  
  102.   
  103.     /** 
  104.      * A listener that receives a callback when the floating View 
  105.      * is dropped. 
  106.      */  
  107.     private DropListener mDropListener;  
  108.   
  109.     /** 
  110.      * A listener that receives a callback when the floating View 
  111.      * (or more precisely the originally dragged item) is removed 
  112.      * by one of the provided gestures. 
  113.      */  
  114.     private RemoveListener mRemoveListener;  
  115.   
  116.     /** 
  117.      * Enable/Disable item dragging 
  118.      * 
  119.      * @attr name dslv:drag_enabled 
  120.      */  
  121.     private boolean mDragEnabled = true;  
  122.   
  123.     /** 
  124.      * Drag state enum. 
  125.      */  
  126.     private final static int IDLE = 0;  
  127.     private final static int REMOVING = 1;  
  128.     private final static int DROPPING = 2;  
  129.     private final static int STOPPED = 3;  
  130.     private final static int DRAGGING = 4;  
  131.   
  132.     private int mDragState = IDLE;  
  133.   
  134.     /** 
  135.      * Height in pixels to which the originally dragged item 
  136.      * is collapsed during a drag-sort. Currently, this value 
  137.      * must be greater than zero. 
  138.      */  
  139.     private int mItemHeightCollapsed = 1;  
  140.   
  141.     /** 
  142.      * Height of the floating View. Stored for the purpose of 
  143.      * providing the tracking drop slot. 
  144.      */  
  145.     private int mFloatViewHeight;  
  146.   
  147.     /** 
  148.      * Convenience member. See above. 
  149.      */  
  150.     private int mFloatViewHeightHalf;  
  151.   
  152.     /** 
  153.      * Save the given width spec for use in measuring children 
  154.      */  
  155.     private int mWidthMeasureSpec = 0;  
  156.   
  157.     /** 
  158.      * Sample Views ultimately used for calculating the height 
  159.      * of ListView items that are off-screen. 
  160.      */  
  161.     private View[] mSampleViewTypes = new View[1];  
  162.   
  163.     /** 
  164.      * Drag-scroll encapsulator! 
  165.      */  
  166.     private DragScroller mDragScroller;  
  167.   
  168.     /** 
  169.      * Determines the start of the upward drag-scroll region 
  170.      * at the top of the ListView. Specified by a fraction 
  171.      * of the ListView height, thus screen resolution agnostic. 
  172.      */  
  173.     private float mDragUpScrollStartFrac = 1.0f / 3.0f;  
  174.   
  175.     /** 
  176.      * Determines the start of the downward drag-scroll region 
  177.      * at the bottom of the ListView. Specified by a fraction 
  178.      * of the ListView height, thus screen resolution agnostic. 
  179.      */  
  180.     private float mDragDownScrollStartFrac = 1.0f / 3.0f;  
  181.   
  182.     /** 
  183.      * The following are calculated from the above fracs. 
  184.      */  
  185.     private int mUpScrollStartY;  
  186.     private int mDownScrollStartY;  
  187.     private float mDownScrollStartYF;  
  188.     private float mUpScrollStartYF;  
  189.   
  190.     /** 
  191.      * Calculated from above above and current ListView height. 
  192.      */  
  193.     private float mDragUpScrollHeight;  
  194.   
  195.     /** 
  196.      * Calculated from above above and current ListView height. 
  197.      */  
  198.     private float mDragDownScrollHeight;  
  199.   
  200.     /** 
  201.      * Maximum drag-scroll speed in pixels per ms. Only used with 
  202.      * default linear drag-scroll profile. 
  203.      */  
  204.     private float mMaxScrollSpeed = 0.5f;  
  205.   
  206.     /** 
  207.      * Defines the scroll speed during a drag-scroll. User can 
  208.      * provide their own; this default is a simple linear profile 
  209.      * where scroll speed increases linearly as the floating View 
  210.      * nears the top/bottom of the ListView. 
  211.      */  
  212.     private DragScrollProfile mScrollProfile = new DragScrollProfile() {  
  213.         @Override  
  214.         public float getSpeed(float w, long t) {  
  215.             return mMaxScrollSpeed * w;  
  216.         }  
  217.     };  
  218.   
  219.     /** 
  220.      * Current touch x. 
  221.      */  
  222.     private int mX;  
  223.   
  224.     /** 
  225.      * Current touch y. 
  226.      */  
  227.     private int mY;  
  228.   
  229.     /** 
  230.      * Last touch x. 
  231.      */  
  232.     private int mLastX;  
  233.   
  234.     /** 
  235.      * Last touch y. 
  236.      */  
  237.     private int mLastY;  
  238.   
  239.     /** 
  240.      * The touch y-coord at which drag started 
  241.      */  
  242.     private int mDragStartY;  
  243.   
  244.     /** 
  245.      * Drag flag bit. Floating View can move in the positive 
  246.      * x direction. 
  247.      */  
  248.     public final static int DRAG_POS_X = 0x1;  
  249.   
  250.     /** 
  251.      * Drag flag bit. Floating View can move in the negative 
  252.      * x direction. 
  253.      */  
  254.     public final static int DRAG_NEG_X = 0x2;  
  255.   
  256.     /** 
  257.      * Drag flag bit. Floating View can move in the positive 
  258.      * y direction. This is subtle. What this actually means is 
  259.      * that, if enabled, the floating View can be dragged below its starting 
  260.      * position. Remove in favor of upper-bounding item position? 
  261.      */  
  262.     public final static int DRAG_POS_Y = 0x4;  
  263.   
  264.     /** 
  265.      * Drag flag bit. Floating View can move in the negative 
  266.      * y direction. This is subtle. What this actually means is 
  267.      * that the floating View can be dragged above its starting 
  268.      * position. Remove in favor of lower-bounding item position? 
  269.      */  
  270.     public final static int DRAG_NEG_Y = 0x8;  
  271.   
  272.     /** 
  273.      * Flags that determine limits on the motion of the 
  274.      * floating View. See flags above. 
  275.      */  
  276.     private int mDragFlags = 0;  
  277.   
  278.     /** 
  279.      * Last call to an on*TouchEvent was a call to 
  280.      * onInterceptTouchEvent. 
  281.      */  
  282.     private boolean mLastCallWasIntercept = false;  
  283.   
  284.     /** 
  285.      * A touch event is in progress. 
  286.      */  
  287.     private boolean mInTouchEvent = false;  
  288.   
  289.     /** 
  290.      * Let the user customize the floating View. 
  291.      */  
  292.     private FloatViewManager mFloatViewManager = null;  
  293.   
  294.     /** 
  295.      * Given to ListView to cancel its action when a drag-sort 
  296.      * begins. 
  297.      */  
  298.     private MotionEvent mCancelEvent;  
  299.   
  300.     /** 
  301.      * Enum telling where to cancel the ListView action when a 
  302.      * drag-sort begins 
  303.      */  
  304.     private static final int NO_CANCEL = 0;  
  305.     private static final int ON_TOUCH_EVENT = 1;  
  306.     private static final int ON_INTERCEPT_TOUCH_EVENT = 2;  
  307.   
  308.     /** 
  309.      * Where to cancel the ListView action when a 
  310.      * drag-sort begins 
  311.      */  
  312.     private int mCancelMethod = NO_CANCEL;  
  313.   
  314.     /** 
  315.      * Determines when a slide shuffle animation starts. That is, 
  316.      * defines how close to the edge of the drop slot the floating 
  317.      * View must be to initiate the slide. 
  318.      */  
  319.     private float mSlideRegionFrac = 0.25f;  
  320.   
  321.     /** 
  322.      * Number between 0 and 1 indicating the relative location of 
  323.      * a sliding item (only used if drag-sort animations 
  324.      * are turned on). Nearly 1 means the item is 
  325.      * at the top of the slide region (nearly full blank item 
  326.      * is directly below). 
  327.      */  
  328.     private float mSlideFrac = 0.0f;  
  329.   
  330.     /** 
  331.      * Wraps the user-provided ListAdapter. This is used to wrap each 
  332.      * item View given by the user inside another View (currenly 
  333.      * a RelativeLayout) which 
  334.      * expands and collapses to simulate the item shuffling. 
  335.      */  
  336.     private AdapterWrapper mAdapterWrapper;  
  337.   
  338.     /** 
  339.      * Turn on custom debugger. 
  340.      */  
  341.     private boolean mTrackDragSort = false;  
  342.   
  343.     /** 
  344.      * Debugging class. 
  345.      */  
  346.     private DragSortTracker mDragSortTracker;  
  347.   
  348.     /** 
  349.      * Needed for adjusting item heights from within layoutChildren 
  350.      */  
  351.     private boolean mBlockLayoutRequests = false;  
  352.   
  353.     /** 
  354.      * Set to true when a down event happens during drag sort; 
  355.      * for example, when drag finish animations are 
  356.      * playing. 
  357.      */  
  358.     private boolean mIgnoreTouchEvent = false;  
  359.   
  360.     /** 
  361.      * Caches DragSortItemView child heights. Sometimes DSLV has to 
  362.      * know the height of an offscreen item. Since ListView virtualizes 
  363.      * these, DSLV must get the item from the ListAdapter to obtain 
  364.      * its height. That process can be expensive, but often the same 
  365.      * offscreen item will be requested many times in a row. Once an 
  366.      * offscreen item height is calculated, we cache it in this guy. 
  367.      * Actually, we cache the height of the child of the 
  368.      * DragSortItemView since the item height changes often during a 
  369.      * drag-sort. 
  370.      */  
  371.     private static final int sCacheSize = 3;  
  372.     private HeightCache mChildHeightCache = new HeightCache(sCacheSize);  
  373.   
  374.     private RemoveAnimator mRemoveAnimator;  
  375.   
  376.     private LiftAnimator mLiftAnimator;  
  377.   
  378.     private DropAnimator mDropAnimator;  
  379.   
  380.     private boolean mUseRemoveVelocity;  
  381.     private float mRemoveVelocityX = 0;  
  382.   
  383.     public DragSortListView(Context context, AttributeSet attrs) {  
  384.         super(context, attrs);  
  385.   
  386.         int defaultDuration = 150;  
  387.         int removeAnimDuration = defaultDuration; // ms  
  388.         int dropAnimDuration = defaultDuration; // ms  
  389.   
  390.         if (attrs != null) {  
  391.             TypedArray a = getContext().obtainStyledAttributes(attrs,  
  392.                     R.styleable.DragSortListView, 00);  
  393.   
  394.             mItemHeightCollapsed = Math.max(1, a.getDimensionPixelSize(  
  395.                     R.styleable.DragSortListView_collapsed_height, 1));  
  396.   
  397.             mTrackDragSort = a.getBoolean(  
  398.                     R.styleable.DragSortListView_track_drag_sort, false);  
  399.   
  400.             if (mTrackDragSort) {  
  401.                 mDragSortTracker = new DragSortTracker();  
  402.             }  
  403.   
  404.             // alpha between 0 and 255, 0=transparent, 255=opaque  
  405.             mFloatAlpha = a.getFloat(R.styleable.DragSortListView_float_alpha, mFloatAlpha);  
  406.             mCurrFloatAlpha = mFloatAlpha;  
  407.   
  408.             mDragEnabled = a.getBoolean(R.styleable.DragSortListView_drag_enabled, mDragEnabled);  
  409.   
  410.             mSlideRegionFrac = Math.max(0.0f,  
  411.                     Math.min(1.0f, 1.0f - a.getFloat(  
  412.                             R.styleable.DragSortListView_slide_shuffle_speed,  
  413.                             0.75f)));  
  414.   
  415.             mAnimate = mSlideRegionFrac > 0.0f;  
  416.   
  417.             float frac = a.getFloat(  
  418.                     R.styleable.DragSortListView_drag_scroll_start,  
  419.                     mDragUpScrollStartFrac);  
  420.   
  421.             setDragScrollStart(frac);  
  422.   
  423.             mMaxScrollSpeed = a.getFloat(  
  424.                     R.styleable.DragSortListView_max_drag_scroll_speed,  
  425.                     mMaxScrollSpeed);  
  426.   
  427.             removeAnimDuration = a.getInt(  
  428.                     R.styleable.DragSortListView_remove_animation_duration,  
  429.                     removeAnimDuration);  
  430.   
  431.             dropAnimDuration = a.getInt(  
  432.                     R.styleable.DragSortListView_drop_animation_duration,  
  433.                     dropAnimDuration);  
  434.   
  435.             boolean useDefault = a.getBoolean(  
  436.                     R.styleable.DragSortListView_use_default_controller,  
  437.                     true);  
  438.   
  439.             if (useDefault) {  
  440.                 boolean removeEnabled = a.getBoolean(  
  441.                         R.styleable.DragSortListView_remove_enabled,  
  442.                         false);  
  443.                 int removeMode = a.getInt(  
  444.                         R.styleable.DragSortListView_remove_mode,  
  445.                         DragSortController.FLING_REMOVE);  
  446.                 boolean sortEnabled = a.getBoolean(  
  447.                         R.styleable.DragSortListView_sort_enabled,  
  448.                         true);  
  449.                 int dragInitMode = a.getInt(  
  450.                         R.styleable.DragSortListView_drag_start_mode,  
  451.                         DragSortController.ON_DOWN);  
  452.                 int dragHandleId = a.getResourceId(  
  453.                         R.styleable.DragSortListView_drag_handle_id,  
  454.                         0);  
  455.                 int flingHandleId = a.getResourceId(  
  456.                         R.styleable.DragSortListView_fling_handle_id,  
  457.                         0);  
  458.                 int clickRemoveId = a.getResourceId(  
  459.                         R.styleable.DragSortListView_click_remove_id,  
  460.                         0);  
  461.                 int bgColor = a.getColor(  
  462.                         R.styleable.DragSortListView_float_background_color,  
  463.                         Color.BLACK);  
  464.   
  465.                 DragSortController controller = new DragSortController(  
  466.                         this, dragHandleId, dragInitMode, removeMode,  
  467.                         clickRemoveId, flingHandleId);  
  468.                 controller.setRemoveEnabled(removeEnabled);  
  469.                 controller.setSortEnabled(sortEnabled);  
  470.                 controller.setBackgroundColor(bgColor);  
  471.   
  472.                 mFloatViewManager = controller;  
  473.                 setOnTouchListener(controller);  
  474.             }  
  475.   
  476.             a.recycle();  
  477.         }  
  478.   
  479.         mDragScroller = new DragScroller();  
  480.   
  481.         float smoothness = 0.5f;  
  482.         if (removeAnimDuration > 0) {  
  483.             mRemoveAnimator = new RemoveAnimator(smoothness, removeAnimDuration);  
  484.         }  
  485.         // mLiftAnimator = new LiftAnimator(smoothness, 100);  
  486.         if (dropAnimDuration > 0) {  
  487.             mDropAnimator = new DropAnimator(smoothness, dropAnimDuration);  
  488.         }  
  489.   
  490.         mCancelEvent = MotionEvent.obtain(00, MotionEvent.ACTION_CANCEL, 0f, 0f, 0f, 0f, 0, 0f,  
  491.                 0f, 00);  
  492.   
  493.         // construct the dataset observer  
  494.         mObserver = new DataSetObserver() {  
  495.             private void cancel() {  
  496.                 if (mDragState == DRAGGING) {  
  497.                     cancelDrag();  
  498.                 }  
  499.             }  
  500.   
  501.             @Override  
  502.             public void onChanged() {  
  503.                 cancel();  
  504.             }  
  505.   
  506.             @Override  
  507.             public void onInvalidated() {  
  508.                 cancel();  
  509.             }  
  510.         };  
  511.     }  
  512.   
  513.     /** 
  514.      * Usually called from a FloatViewManager. The float alpha 
  515.      * will be reset to the xml-defined value every time a drag 
  516.      * is stopped. 
  517.      */  
  518.     public void setFloatAlpha(float alpha) {  
  519.         mCurrFloatAlpha = alpha;  
  520.     }  
  521.   
  522.     public float getFloatAlpha() {  
  523.         return mCurrFloatAlpha;  
  524.     }  
  525.   
  526.     /** 
  527.      * Set maximum drag scroll speed in positions/second. Only applies 
  528.      * if using default ScrollSpeedProfile. 
  529.      * 
  530.      * @param max Maximum scroll speed. 
  531.      */  
  532.     public void setMaxScrollSpeed(float max) {  
  533.         mMaxScrollSpeed = max;  
  534.     }  
  535.   
  536.     /** 
  537.      * For each DragSortListView Listener interface implemented by 
  538.      * <code>adapter</code>, this method calls the appropriate 
  539.      * set*Listener method with <code>adapter</code> as the argument. 
  540.      * 
  541.      * @param adapter The ListAdapter providing data to back 
  542.      * DragSortListView. 
  543.      * 
  544.      * @see android.widget.ListView#setAdapter(android.widget.ListAdapter) 
  545.      */  
  546.     @Override  
  547.     public void setAdapter(ListAdapter adapter) {  
  548.         if (adapter != null) {  
  549.             mAdapterWrapper = new AdapterWrapper(adapter);  
  550.             adapter.registerDataSetObserver(mObserver);  
  551.   
  552.             if (adapter instanceof DropListener) {  
  553.                 setDropListener((DropListener) adapter);  
  554.             }  
  555.             if (adapter instanceof DragListener) {  
  556.                 setDragListener((DragListener) adapter);  
  557.             }  
  558.             if (adapter instanceof RemoveListener) {  
  559.                 setRemoveListener((RemoveListener) adapter);  
  560.             }  
  561.         } else {  
  562.             mAdapterWrapper = null;  
  563.         }  
  564.   
  565.         super.setAdapter(mAdapterWrapper);  
  566.     }  
  567.   
  568.   
  569.     public ListAdapter getInputAdapter() {  
  570.         if (mAdapterWrapper == null) {  
  571.             return null;  
  572.         } else {  
  573.             return mAdapterWrapper.getAdapter();  
  574.         }  
  575.     }  
  576.   
  577.     private class AdapterWrapper extends BaseAdapter {  
  578.         private ListAdapter mAdapter;  
  579.   
  580.         public AdapterWrapper(ListAdapter adapter) {  
  581.             super();  
  582.             mAdapter = adapter;  
  583.   
  584.             mAdapter.registerDataSetObserver(new DataSetObserver() {  
  585.                 public void onChanged() {  
  586.                     notifyDataSetChanged();  
  587.                 }  
  588.   
  589.                 public void onInvalidated() {  
  590.                     notifyDataSetInvalidated();  
  591.                 }  
  592.             });  
  593.         }  
  594.   
  595.         public ListAdapter getAdapter() {  
  596.             return mAdapter;  
  597.         }  
  598.   
  599.         @Override  
  600.         public long getItemId(int position) {  
  601.             return mAdapter.getItemId(position);  
  602.         }  
  603.   
  604.         @Override  
  605.         public Object getItem(int position) {  
  606.             return mAdapter.getItem(position);  
  607.         }  
  608.   
  609.         @Override  
  610.         public int getCount() {  
  611.             return mAdapter.getCount();  
  612.         }  
  613.   
  614.         @Override  
  615.         public boolean areAllItemsEnabled() {  
  616.             return mAdapter.areAllItemsEnabled();  
  617.         }  
  618.   
  619.         @Override  
  620.         public boolean isEnabled(int position) {  
  621.             return mAdapter.isEnabled(position);  
  622.         }  
  623.   
  624.         @Override  
  625.         public int getItemViewType(int position) {  
  626.             return mAdapter.getItemViewType(position);  
  627.         }  
  628.   
  629.         @Override  
  630.         public int getViewTypeCount() {  
  631.             return mAdapter.getViewTypeCount();  
  632.         }  
  633.   
  634.         @Override  
  635.         public boolean hasStableIds() {  
  636.             return mAdapter.hasStableIds();  
  637.         }  
  638.   
  639.         @Override  
  640.         public boolean isEmpty() {  
  641.             return mAdapter.isEmpty();  
  642.         }  
  643.   
  644.   
  645.         @Override  
  646.         public View getView(int position, View convertView, ViewGroup parent) {  
  647.   
  648.             DragSortItemView v;  
  649.             View child;  
  650.             // Log.d("mobeta",  
  651.             // "getView: position="+position+" convertView="+convertView);  
  652.             if (convertView != null) {  
  653.                 v = (DragSortItemView) convertView;  
  654.                 View oldChild = v.getChildAt(0);  
  655.   
  656.                 child = mAdapter.getView(position, oldChild, DragSortListView.this);  
  657.                 if (child != oldChild) {  
  658.                     // shouldn't get here if user is reusing convertViews  
  659.                     // properly  
  660.                     if (oldChild != null) {  
  661.                         v.removeViewAt(0);  
  662.                     }  
  663.                     v.addView(child);  
  664.                 }  
  665.             } else {  
  666.                 child = mAdapter.getView(position, null, DragSortListView.this);  
  667.                 if (child instanceof Checkable) {  
  668.                     v = new DragSortItemViewCheckable(getContext());  
  669.                 } else {  
  670.                     v = new DragSortItemView(getContext());  
  671.                 }  
  672.                 v.setLayoutParams(new AbsListView.LayoutParams(  
  673.                         ViewGroup.LayoutParams.FILL_PARENT,  
  674.                         ViewGroup.LayoutParams.WRAP_CONTENT));  
  675.                 v.addView(child);  
  676.             }  
  677.   
  678.             // Set the correct item height given drag state; passed  
  679.             // View needs to be measured if measurement is required.  
  680.             adjustItem(position + getHeaderViewsCount(), v, true);  
  681.   
  682.             return v;  
  683.         }  
  684.     }  
  685.   
  686.     private void drawDivider(int expPosition, Canvas canvas) {  
  687.   
  688.         final Drawable divider = getDivider();  
  689.         final int dividerHeight = getDividerHeight();  
  690.         // Log.d("mobeta", "div="+divider+" divH="+dividerHeight);  
  691.   
  692.         if (divider != null && dividerHeight != 0) {  
  693.             final ViewGroup expItem = (ViewGroup) getChildAt(expPosition  
  694.                     - getFirstVisiblePosition());  
  695.             if (expItem != null) {  
  696.                 final int l = getPaddingLeft();  
  697.                 final int r = getWidth() - getPaddingRight();  
  698.                 final int t;  
  699.                 final int b;  
  700.   
  701.                 final int childHeight = expItem.getChildAt(0).getHeight();  
  702.   
  703.                 if (expPosition > mSrcPos) {  
  704.                     t = expItem.getTop() + childHeight;  
  705.                     b = t + dividerHeight;  
  706.                 } else {  
  707.                     b = expItem.getBottom() - childHeight;  
  708.                     t = b - dividerHeight;  
  709.                 }  
  710.                 // Log.d("mobeta", "l="+l+" t="+t+" r="+r+" b="+b);  
  711.   
  712.                 // Have to clip to support ColorDrawable on <= Gingerbread  
  713.                 canvas.save();  
  714.                 canvas.clipRect(l, t, r, b);  
  715.                 divider.setBounds(l, t, r, b);  
  716.                 divider.draw(canvas);  
  717.                 canvas.restore();  
  718.             }  
  719.         }  
  720.     }  
  721.   
  722.     @Override  
  723.     protected void dispatchDraw(Canvas canvas) {  
  724.         super.dispatchDraw(canvas);  
  725.   
  726.         if (mDragState != IDLE) {  
  727.             // draw the divider over the expanded item  
  728.             if (mFirstExpPos != mSrcPos) {  
  729.                 drawDivider(mFirstExpPos, canvas);  
  730.             }  
  731.             if (mSecondExpPos != mFirstExpPos && mSecondExpPos != mSrcPos) {  
  732.                 drawDivider(mSecondExpPos, canvas);  
  733.             }  
  734.         }  
  735.   
  736.         if (mFloatView != null) {  
  737.             // draw the float view over everything  
  738.             final int w = mFloatView.getWidth();  
  739.             final int h = mFloatView.getHeight();  
  740.   
  741.             int x = mFloatLoc.x;  
  742.   
  743.             int width = getWidth();  
  744.             if (x < 0)  
  745.                 x = -x;  
  746.             float alphaMod;  
  747.             if (x < width) {  
  748.                 alphaMod = ((float) (width - x)) / ((float) width);  
  749.                 alphaMod *= alphaMod;  
  750.             } else {  
  751.                 alphaMod = 0;  
  752.             }  
  753.   
  754.             final int alpha = (int) (255f * mCurrFloatAlpha * alphaMod);  
  755.   
  756.             canvas.save();  
  757.             // Log.d("mobeta", "clip rect bounds: " + canvas.getClipBounds());  
  758.             canvas.translate(mFloatLoc.x, mFloatLoc.y);  
  759.             canvas.clipRect(00, w, h);  
  760.   
  761.             // Log.d("mobeta", "clip rect bounds: " + canvas.getClipBounds());  
  762.             canvas.saveLayerAlpha(00, w, h, alpha, Canvas.ALL_SAVE_FLAG);  
  763.             mFloatView.draw(canvas);  
  764.             canvas.restore();  
  765.             canvas.restore();  
  766.         }  
  767.     }  
  768.   
  769.     private int getItemHeight(int position) {  
  770.         View v = getChildAt(position - getFirstVisiblePosition());  
  771.   
  772.         if (v != null) {  
  773.             // item is onscreen, just get the height of the View  
  774.             return v.getHeight();  
  775.         } else {  
  776.             // item is offscreen. get child height and calculate  
  777.             // item height based on current shuffle state  
  778.             return calcItemHeight(position, getChildHeight(position));  
  779.         }  
  780.     }  
  781.   
  782.     private void printPosData() {  
  783.         Log.d("mobeta""mSrcPos=" + mSrcPos + " mFirstExpPos=" + mFirstExpPos + " mSecondExpPos="  
  784.                 + mSecondExpPos);  
  785.     }  
  786.   
  787.     private class HeightCache {  
  788.   
  789.         private SparseIntArray mMap;  
  790.         private ArrayList<Integer> mOrder;  
  791.         private int mMaxSize;  
  792.   
  793.         public HeightCache(int size) {  
  794.             mMap = new SparseIntArray(size);  
  795.             mOrder = new ArrayList<Integer>(size);  
  796.             mMaxSize = size;  
  797.         }  
  798.   
  799.         /** 
  800.          * Add item height at position if doesn't already exist. 
  801.          */  
  802.         public void add(int position, int height) {  
  803.             int currHeight = mMap.get(position, -1);  
  804.             if (currHeight != height) {  
  805.                 if (currHeight == -1) {  
  806.                     if (mMap.size() == mMaxSize) {  
  807.                         // remove oldest entry  
  808.                         mMap.delete(mOrder.remove(0));  
  809.                     }  
  810.                 } else {  
  811.                     // move position to newest slot  
  812.                     mOrder.remove((Integer) position);  
  813.                 }  
  814.                 mMap.put(position, height);  
  815.                 mOrder.add(position);  
  816.             }  
  817.         }  
  818.   
  819.         public int get(int position) {  
  820.             return mMap.get(position, -1);  
  821.         }  
  822.   
  823.         public void clear() {  
  824.             mMap.clear();  
  825.             mOrder.clear();  
  826.         }  
  827.   
  828.     } 
阅读更多
想对作者说点什么? 我来说一句

php游戏:幸运飞艇源码下载

2016年07月20日 184KB 下载

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭