zoukankan      html  css  js  c++  java
  • 怎样在android实现uc和墨迹天气那样的左右拖动效果

    import android.app.Activity;
    import android.os.Bundle;
    
    import android.content.Context;
    import android.graphics.Color;
    import android.util.Log;
    import android.view.Gravity;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.ViewGroup;
    import android.view.View.OnClickListener;
    import android.widget.ArrayAdapter;
    import android.widget.Button;
    import android.widget.CheckBox;
    import android.widget.EditText;
    import android.widget.LinearLayout;
    import android.widget.TableLayout;
    import android.widget.TextView;
    
    public class FlingGalleryActivity extends Activity
    {
    	private final int color_red = Color.argb(100, 200, 0, 0);
    	private final int color_green = Color.argb(100, 0, 200, 0);
    	private final int color_blue = Color.argb(100, 0, 0, 200);
    	private final int color_yellow = Color.argb(100, 200, 200, 0);
    	private final int color_purple = Color.argb(100, 200, 0, 200);
    
        private final String[] mLabelArray = {"View1", "View2", "View3", "View4", "View5"};
        private final int[] mColorArray = {color_red, color_green, color_blue, color_yellow, color_purple};
    
    	private FlingGallery mGallery;
    	private CheckBox mCheckBox;
    
        // Note: The following handler is critical to correct function of
        // the FlingGallery class. This enables the FlingGallery class to
        // detect when the motion event has ended by finger being lifted
    
        @Override
        public boolean onTouchEvent(MotionEvent event)
    	{
            return mGallery.onGalleryTouchEvent(event);
        }
    
        public void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
    
            mGallery = new FlingGallery(this);
            mGallery.setPaddingWidth(5);
            mGallery.setAdapter(new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, mLabelArray)
            {
            	@Override
            	public View getView(int position, View convertView, ViewGroup parent)
            	{
            		Log.d("111", "count="+position);
    //            	if (convertView != null && convertView instanceof GalleryViewItem)
    //                {
    //            		GalleryViewItem galleryView = (GalleryViewItem) convertView;
    //
    //            		galleryView.mEdit1.setText("");
    //            		galleryView.mText1.setText(mLabelArray[position]);
    //            		galleryView.mText1.setBackgroundColor(mColorArray[position]);
    //            		galleryView.mText2.setText(mLabelArray[position]);
    //            		galleryView.mText2.setBackgroundColor(mColorArray[position]);
    //            		
    //            		Log.d("111", "count="+position);
    //            		
    //            		return galleryView;
    //            		
    //                }
                	
                	return new GalleryViewItem(getApplicationContext(), position);
            	}
            });
    
            LinearLayout layout = new LinearLayout(getApplicationContext());
            layout.setOrientation(LinearLayout.VERTICAL);
    
    		LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(
    				LinearLayout.LayoutParams.MATCH_PARENT,
    				LinearLayout.LayoutParams.MATCH_PARENT);
    
    		layoutParams.setMargins(10, 10, 10, 10);
    		layoutParams.weight = 1.0f;
      
            layout.addView(mGallery, layoutParams);
    	    
            mCheckBox = new CheckBox(getApplicationContext());
            mCheckBox.setText("Gallery is Circular");
            mCheckBox.setText("Gallery is Circular");
            mCheckBox.setPadding(50, 10, 0, 10);
            mCheckBox.setTextSize(30);
            mCheckBox.setChecked(true);
            mCheckBox.setOnClickListener(new OnClickListener()
            {
    			@Override
    			public void onClick(View view)
    			{
    				mGallery.setIsGalleryCircular(mCheckBox.isChecked());
    			}
            });
    
            layout.addView(mCheckBox, new LinearLayout.LayoutParams(
    	    		LinearLayout.LayoutParams.MATCH_PARENT,
    	    		LinearLayout.LayoutParams.WRAP_CONTENT));
    	    
            setContentView(layout);
        }	
    
    	private class GalleryViewItem extends TableLayout
    	{
    		private EditText mEdit1;
    		private TextView mText1;
    		private TextView mText2;
    		private Button mButton1;
    		private Button mButton2;
    
    		public GalleryViewItem(Context context, int position)
    		{
    			super(context);
    
    			this.setOrientation(LinearLayout.VERTICAL);
    
        		this.setLayoutParams(new LinearLayout.LayoutParams(
        				LinearLayout.LayoutParams.MATCH_PARENT,
        				LinearLayout.LayoutParams.MATCH_PARENT));
        		
        		mEdit1 = new EditText(context);
    
        		this.addView(mEdit1, new LinearLayout.LayoutParams(
                		LinearLayout.LayoutParams.MATCH_PARENT,
                		LinearLayout.LayoutParams.WRAP_CONTENT)); 
    
                mText1 = new TextView(context);
                mText1.setText(mLabelArray[position]);
                mText1.setTextSize(30);
                mText1.setGravity(Gravity.LEFT);
                mText1.setBackgroundColor(mColorArray[position]);
    
        		this.addView(mText1, new LinearLayout.LayoutParams(
                		LinearLayout.LayoutParams.MATCH_PARENT,
                		LinearLayout.LayoutParams.WRAP_CONTENT)); 
    
                mButton1 = new Button(context);
                mButton1.setText("<<");
                mButton1.setGravity(Gravity.LEFT);
                mButton1.setOnClickListener(new OnClickListener()
                {
    				@Override
    				public void onClick(View view)
    				{
    					mGallery.movePrevious();
    				}
                });
                
                this.addView(mButton1, new LinearLayout.LayoutParams(
                		LinearLayout.LayoutParams.MATCH_PARENT,
                		LinearLayout.LayoutParams.WRAP_CONTENT)); 
    
                mButton2 = new Button(context);
                mButton2.setText(">>");
                mButton2.setGravity(Gravity.RIGHT);
                mButton2.setOnClickListener(new OnClickListener()
                {
    				@Override
    				public void onClick(View view)
    				{
    					mGallery.moveNext();
    				}
                });
                
                this.addView(mButton2, new LinearLayout.LayoutParams(
                		LinearLayout.LayoutParams.MATCH_PARENT,
                		LinearLayout.LayoutParams.WRAP_CONTENT)); 
    
                mText2 = new TextView(context);
                mText2.setText(mLabelArray[position]);
        		mText2.setTextSize(30);
        		mText2.setGravity(Gravity.RIGHT);
        		mText2.setBackgroundColor(mColorArray[position]);
    
        		this.addView(mText2, new LinearLayout.LayoutParams(
                		LinearLayout.LayoutParams.MATCH_PARENT,
                		LinearLayout.LayoutParams.MATCH_PARENT, 1)); 
    		}
    	}
    }
    
    
    
    
    
    

    . [代码]FlingGallery   

    import android.content.Context;
    import android.view.GestureDetector;
    import android.view.KeyEvent;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.animation.Animation;
    import android.view.animation.AnimationUtils;
    import android.view.animation.Interpolator;
    import android.view.animation.Transformation;
    import android.widget.Adapter;
    import android.widget.FrameLayout;
    import android.widget.LinearLayout;
    
    // TODO:
    
    // 1. In order to improve performance Cache screen bitmap and use for animation
    // 2. Establish superfluous memory allocations and delay or replace with reused objects
    //	  Probably need to make sure we are not allocating objects (strings, etc.) in loops
    
    public class FlingGallery extends FrameLayout
    {
    	// Constants
    	
    	private final int swipe_min_distance = 120;
        private final int swipe_max_off_path = 250;
        private final int swipe_threshold_veloicty = 400;
    
        // Properties
        
    	private int mViewPaddingWidth = 0;
        private int mAnimationDuration = 250;
        private float mSnapBorderRatio = 0.5f;
        private boolean mIsGalleryCircular = true;
    
        // Members
    
        private int mGalleryWidth = 0;
        private boolean mIsTouched = false;
        private boolean mIsDragging = false;
        private float mCurrentOffset = 0.0f;
        private long mScrollTimestamp = 0;
        private int mFlingDirection = 0;
        private int mCurrentPosition = 0;
        private int mCurrentViewNumber = 0;
    
        private Context mContext;
        private Adapter mAdapter;
        private FlingGalleryView[] mViews;
        private FlingGalleryAnimation mAnimation;
        private GestureDetector mGestureDetector;
        private Interpolator mDecelerateInterpolater;
    
        public FlingGallery(Context context)
    	{
    		super(context);
    
    		mContext = context;
    		mAdapter = null;
    		
            mViews = new FlingGalleryView[3];
            mViews[0] = new FlingGalleryView(0, this);
            mViews[1] = new FlingGalleryView(1, this);
            mViews[2] = new FlingGalleryView(2, this);
    
    		mAnimation = new FlingGalleryAnimation();
    		mGestureDetector = new GestureDetector(new FlingGestureDetector());
    		mDecelerateInterpolater = AnimationUtils.loadInterpolator(mContext, android.R.anim.decelerate_interpolator);
    	}
    
    	public void setPaddingWidth(int viewPaddingWidth)
    	{
    		mViewPaddingWidth = viewPaddingWidth;
    	}
    
    	public void setAnimationDuration(int animationDuration)
    	{
    		mAnimationDuration = animationDuration;
    	}
    	
    	public void setSnapBorderRatio(float snapBorderRatio)
    	{
    		mSnapBorderRatio = snapBorderRatio;
    	}
    
    	public void setIsGalleryCircular(boolean isGalleryCircular) 
    	{
    		if (mIsGalleryCircular != isGalleryCircular)
    		{
    			mIsGalleryCircular = isGalleryCircular;
    	
    			if (mCurrentPosition == getFirstPosition())
    			{
    				// We need to reload the view immediately to the left to change it to circular view or blank
    		    	mViews[getPrevViewNumber(mCurrentViewNumber)].recycleView(getPrevPosition(mCurrentPosition));			
    			}
    	
    			if (mCurrentPosition == getLastPosition())
    			{
    				// We need to reload the view immediately to the right to change it to circular view or blank
    		    	mViews[getNextViewNumber(mCurrentViewNumber)].recycleView(getNextPosition(mCurrentPosition));			
    			}
    		}
    	}
    
    	public int getGalleryCount()
    	{
    		return (mAdapter == null) ? 0 : mAdapter.getCount();
    	}
    
    	public int getFirstPosition()
    	{
    		return 0;
    	}
    
    	public int getLastPosition()
    	{
    		return (getGalleryCount() == 0) ? 0 : getGalleryCount() - 1;
    	}
    
    	private int getPrevPosition(int relativePosition)
    	{
    		int prevPosition = relativePosition - 1;
    
    		if (prevPosition < getFirstPosition())
    		{
    			prevPosition = getFirstPosition() - 1;
    
    			if (mIsGalleryCircular == true)
    			{
    				prevPosition = getLastPosition();
    			}
    		}
    
    		return prevPosition;
    	}
    
    	private int getNextPosition(int relativePosition)
    	{
    		int nextPosition = relativePosition + 1;
    
    		if (nextPosition > getLastPosition())
    		{
    			nextPosition = getLastPosition() + 1;
    
    			if (mIsGalleryCircular == true)
    			{
    				nextPosition = getFirstPosition();
    			}
    		}
    
    		return nextPosition;
    	}
    
    	private int getPrevViewNumber(int relativeViewNumber)
    	{
    		return (relativeViewNumber == 0) ? 2 : relativeViewNumber - 1;
    	}
    
    	private int getNextViewNumber(int relativeViewNumber)
    	{
    		return (relativeViewNumber == 2) ? 0 : relativeViewNumber + 1;
    	}
    	
    	@Override
    	protected void onLayout(boolean changed, int left, int top, int right, int bottom)
    	{
    		super.onLayout(changed, left, top, right, bottom);
    
    		// Calculate our view width
    		mGalleryWidth = right - left;
    
    		if (changed == true)
    		{
    	    	// Position views at correct starting offsets
    	    	mViews[0].setOffset(0, 0, mCurrentViewNumber);
    	    	mViews[1].setOffset(0, 0, mCurrentViewNumber);
    	    	mViews[2].setOffset(0, 0, mCurrentViewNumber);
    	    }
    	}
    
    	public void setAdapter(Adapter adapter)
        {
        	mAdapter = adapter;
        	mCurrentPosition = 0;
            mCurrentViewNumber = 0;
    
            // Load the initial views from adapter
            mViews[0].recycleView(mCurrentPosition);
        	mViews[1].recycleView(getNextPosition(mCurrentPosition));
        	mViews[2].recycleView(getPrevPosition(mCurrentPosition));
    
        	// Position views at correct starting offsets
        	mViews[0].setOffset(0, 0, mCurrentViewNumber);
        	mViews[1].setOffset(0, 0, mCurrentViewNumber);
        	mViews[2].setOffset(0, 0, mCurrentViewNumber);
        }
    
    	private int getViewOffset(int viewNumber, int relativeViewNumber)
    	{
    		// Determine width including configured padding width
    		int offsetWidth = mGalleryWidth + mViewPaddingWidth;
    
    		// Position the previous view one measured width to left
    		if (viewNumber == getPrevViewNumber(relativeViewNumber))
    		{
    			return offsetWidth;
    		}
    
    		// Position the next view one measured width to the right
    		if (viewNumber == getNextViewNumber(relativeViewNumber))
    		{
    			return offsetWidth * -1;
    		}
    
    		return 0;
    	}
    
    	void movePrevious()
    	{
    		// Slide to previous view
    		mFlingDirection = 1;
    		processGesture();
    	}
    
    	void moveNext()
    	{
    		// Slide to next view
    		mFlingDirection = -1;
    		processGesture();
    	}
    
    	 @Override
    	 public boolean onKeyDown(int keyCode, KeyEvent event)
    	 {
    	    switch (keyCode)
    	    {
    	    case KeyEvent.KEYCODE_DPAD_LEFT:
    	        movePrevious();
    	        return true;
    	
    	    case KeyEvent.KEYCODE_DPAD_RIGHT:
    	        moveNext();
    	        return true;
    	
    	    case KeyEvent.KEYCODE_DPAD_CENTER:
    	    case KeyEvent.KEYCODE_ENTER:
    	    }
    
    	    return super.onKeyDown(keyCode, event);
    	}
    
    	public boolean onGalleryTouchEvent(MotionEvent event)
    	{
    		boolean consumed = mGestureDetector.onTouchEvent(event);
    		
    		if (event.getAction() == MotionEvent.ACTION_UP)
    		{
    			if (mIsTouched || mIsDragging)
    			{
    				processScrollSnap();
    				processGesture();
    			}
    		}
    		
            return consumed;
        }
    
    	void processGesture()
    	{
    		int newViewNumber = mCurrentViewNumber;
    		int reloadViewNumber = 0;
    		int reloadPosition = 0;
    
    		mIsTouched = false;
    		mIsDragging = false;
    
    		if (mFlingDirection > 0)
    		{
    			if (mCurrentPosition > getFirstPosition() || mIsGalleryCircular == true)
    			{
    				// Determine previous view and outgoing view to recycle
    				newViewNumber = getPrevViewNumber(mCurrentViewNumber);
    				mCurrentPosition = getPrevPosition(mCurrentPosition);
    				reloadViewNumber = getNextViewNumber(mCurrentViewNumber); 
    				reloadPosition = getPrevPosition(mCurrentPosition);
    			}
    		}
    
    		if (mFlingDirection < 0)
    		{
    			if (mCurrentPosition < getLastPosition() || mIsGalleryCircular == true)
    			{
    				// Determine the next view and outgoing view to recycle
    				newViewNumber = getNextViewNumber(mCurrentViewNumber);
    				mCurrentPosition = getNextPosition(mCurrentPosition);
    				reloadViewNumber = getPrevViewNumber(mCurrentViewNumber);
    				reloadPosition = getNextPosition(mCurrentPosition);
    			}
    		}
    
    		if (newViewNumber != mCurrentViewNumber)
    		{
    			mCurrentViewNumber = newViewNumber; 
    
    			// Reload outgoing view from adapter in new position
    			mViews[reloadViewNumber].recycleView(reloadPosition);
    		}
    
    		// Ensure input focus on the current view
    		mViews[mCurrentViewNumber].requestFocus();
    
    		// Run the slide animations for view transitions
    		mAnimation.prepareAnimation(mCurrentViewNumber);
    		this.startAnimation(mAnimation);
    
    		// Reset fling state
    		mFlingDirection = 0;
    	}
    
    	void processScrollSnap()
    	{
    		// Snap to next view if scrolled passed snap position
    		float rollEdgeWidth = mGalleryWidth * mSnapBorderRatio;
    		int rollOffset = mGalleryWidth - (int) rollEdgeWidth;
    		int currentOffset = mViews[mCurrentViewNumber].getCurrentOffset();
    
    		if (currentOffset <= rollOffset * -1)
    		{
    			// Snap to previous view
    			mFlingDirection = 1;
    		}
    
    		if (currentOffset >= rollOffset)
    		{
    			// Snap to next view
    			mFlingDirection = -1;
    		}
    	}
    
    	private class FlingGalleryView
    	{
    		private int mViewNumber;
    		private FrameLayout mParentLayout;
    		
    		private FrameLayout mInvalidLayout = null;
    		private LinearLayout mInternalLayout = null;
    		private View mExternalView = null;
    
    		public FlingGalleryView(int viewNumber, FrameLayout parentLayout)
    		{
    			mViewNumber = viewNumber;
    			mParentLayout = parentLayout;
    
    			// Invalid layout is used when outside gallery
    			mInvalidLayout = new FrameLayout(mContext);
    			mInvalidLayout.setLayoutParams(new LinearLayout.LayoutParams( 
    	                LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
    
    			// Internal layout is permanent for duration
    			mInternalLayout = new LinearLayout(mContext);
    			mInternalLayout.setLayoutParams(new LinearLayout.LayoutParams( 
    	                LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
    
    			mParentLayout.addView(mInternalLayout);
    		}
    
    		public void recycleView(int newPosition)
    		{
    			if (mExternalView != null)
    			{
    				mInternalLayout.removeView(mExternalView);
    			}
    
    			if (mAdapter != null)
    			{
    				if (newPosition >= getFirstPosition() && newPosition <= getLastPosition())
    				{
    					mExternalView = mAdapter.getView(newPosition, mExternalView, mInternalLayout);
    				}
    				else
    				{
    					mExternalView = mInvalidLayout;
    				}
    			}
    
    			if (mExternalView != null)
    			{
    				mInternalLayout.addView(mExternalView, new LinearLayout.LayoutParams( 
    	                LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
    			}
    		}
    
    		public void setOffset(int xOffset, int yOffset, int relativeViewNumber)
    		{
    			// Scroll the target view relative to its own position relative to currently displayed view
    			mInternalLayout.scrollTo(getViewOffset(mViewNumber, relativeViewNumber) + xOffset, yOffset);
    		}
    		
    		public int getCurrentOffset()
    		{
    			// Return the current scroll position
    			return mInternalLayout.getScrollX();
    		}
    
    		public void requestFocus()
    		{
    			mInternalLayout.requestFocus();
    		}
    	}
    
        private class FlingGalleryAnimation extends Animation
        {
        	private boolean mIsAnimationInProgres;
        	private int mRelativeViewNumber;
        	private int mInitialOffset;
        	private int mTargetOffset;
        	private int mTargetDistance;   	
     
        	public FlingGalleryAnimation()
        	{
        		mIsAnimationInProgres = false;
        		mRelativeViewNumber = 0;
            	mInitialOffset = 0;
            	mTargetOffset = 0;
            	mTargetDistance = 0;
        	}
     
        	public void prepareAnimation(int relativeViewNumber)
        	{
        		// If we are animating relative to a new view
        		if (mRelativeViewNumber != relativeViewNumber)
        		{
    				if (mIsAnimationInProgres == true)
    				{
    					// We only have three views so if requested again to animate in same direction we must snap 
    					int newDirection = (relativeViewNumber == getPrevViewNumber(mRelativeViewNumber)) ? 1 : -1;
    	    			int animDirection = (mTargetDistance < 0) ? 1 : -1; 
    
    	    			// If animation in same direction
    	    			if (animDirection == newDirection)
    	    			{
    		        		// Ran out of time to animate so snap to the target offset
    		        		mViews[0].setOffset(mTargetOffset, 0, mRelativeViewNumber);
    						mViews[1].setOffset(mTargetOffset, 0, mRelativeViewNumber);
    						mViews[2].setOffset(mTargetOffset, 0, mRelativeViewNumber);	
    	    			}
    				}
    	
    				// Set relative view number for animation
    	    		mRelativeViewNumber = relativeViewNumber;
        		}
    
    			// Note: In this implementation the targetOffset will always be zero
        		// as we are centering the view; but we include the calculations of
    			// targetOffset and targetDistance for use in future implementations
    
    			mInitialOffset = mViews[mRelativeViewNumber].getCurrentOffset();
    			mTargetOffset = getViewOffset(mRelativeViewNumber, mRelativeViewNumber);
    			mTargetDistance = mTargetOffset - mInitialOffset;
    
    			// Configure base animation properties
    			this.setDuration(mAnimationDuration);
    			this.setInterpolator(mDecelerateInterpolater);
    
    			// Start/continued animation
    			mIsAnimationInProgres = true;
    		}
    
            @Override
            protected void applyTransformation(float interpolatedTime, Transformation transformation)
            {
            	// Ensure interpolatedTime does not over-shoot then calculate new offset
            	interpolatedTime = (interpolatedTime > 1.0f) ? 1.0f : interpolatedTime;
    			int offset = mInitialOffset + (int) (mTargetDistance * interpolatedTime);
    
    			for (int viewNumber = 0; viewNumber < 3; viewNumber++)
    			{
    				// Only need to animate the visible views as the other view will always be off-screen
    				if ((mTargetDistance > 0 && viewNumber != getNextViewNumber(mRelativeViewNumber)) ||
    					(mTargetDistance < 0 && viewNumber != getPrevViewNumber(mRelativeViewNumber)))
    				{
    					mViews[viewNumber].setOffset(offset, 0, mRelativeViewNumber);
    				}
    			}
            }
    
            @Override
            public boolean getTransformation(long currentTime, Transformation outTransformation)
            {
            	if (super.getTransformation(currentTime, outTransformation) == false)
            	{
            		// Perform final adjustment to offsets to cleanup animation
            		mViews[0].setOffset(mTargetOffset, 0, mRelativeViewNumber);
    				mViews[1].setOffset(mTargetOffset, 0, mRelativeViewNumber);
    				mViews[2].setOffset(mTargetOffset, 0, mRelativeViewNumber);
    
    				// Reached the animation target
    				mIsAnimationInProgres = false;
    
    				return false;
            	}
     
            	// Cancel if the screen touched
            	if (mIsTouched || mIsDragging)
            	{
            		// Note that at this point we still consider ourselves to be animating
            		// because we have not yet reached the target offset; its just that the
            		// user has temporarily interrupted the animation with a touch gesture
    
            		return false;
            	}
    
            	return true;
            }
        }
    
    	private class FlingGestureDetector extends GestureDetector.SimpleOnGestureListener
        {
        	@Override
        	public boolean onDown(MotionEvent e)
        	{
        		// Stop animation
        		mIsTouched = true;
    
        		// Reset fling state
        		mFlingDirection = 0;
                return true;
        	}
    
        	@Override
        	public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
        	{
        		if (e2.getAction() == MotionEvent.ACTION_MOVE)
            	{
    	    		if (mIsDragging == false)
    	    		{
    	        		// Stop animation
    	    			mIsTouched = true;
    	 
    	    			// Reconfigure scroll
    	    			mIsDragging = true;
    	    			mFlingDirection = 0;
    	    			mScrollTimestamp = System.currentTimeMillis();
    	    			mCurrentOffset = mViews[mCurrentViewNumber].getCurrentOffset();
    	    		}
    
            	    float maxVelocity = mGalleryWidth / (mAnimationDuration / 1000.0f);
            		long timestampDelta = System.currentTimeMillis() - mScrollTimestamp;
            		float maxScrollDelta = maxVelocity * (timestampDelta / 1000.0f); 
            		float currentScrollDelta = e1.getX() - e2.getX();
    
            		if (currentScrollDelta < maxScrollDelta * -1) currentScrollDelta = maxScrollDelta * -1;
            		if (currentScrollDelta > maxScrollDelta) currentScrollDelta = maxScrollDelta;
    	        	int scrollOffset = Math.round(mCurrentOffset + currentScrollDelta);
    
            		// We can't scroll more than the width of our own frame layout
            		if (scrollOffset >= mGalleryWidth) scrollOffset = mGalleryWidth;
            		if (scrollOffset <= mGalleryWidth * -1) scrollOffset = mGalleryWidth * -1;
            		
            		mViews[0].setOffset(scrollOffset, 0, mCurrentViewNumber);
        			mViews[1].setOffset(scrollOffset, 0, mCurrentViewNumber);
        			mViews[2].setOffset(scrollOffset, 0, mCurrentViewNumber);
            	}
    
                return false;
        	}
    
        	@Override
        	public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
        	{
                if (Math.abs(e1.getY() - e2.getY()) <= swipe_max_off_path)
                {
                    if (e2.getX() - e1.getX() > swipe_min_distance && Math.abs(velocityX) > swipe_threshold_veloicty)
                    {
                    	movePrevious();
                    }
    
                    if(e1.getX() - e2.getX() > swipe_min_distance && Math.abs(velocityX) > swipe_threshold_veloicty)
                    {
                    	moveNext();
                    }
                }
    
                return false;
        	}
    
        	@Override
        	public void onLongPress(MotionEvent e)
        	{
        		// Finalise scrolling
        		mFlingDirection = 0;
                processGesture();
        	}
    
        	@Override
        	public void onShowPress(MotionEvent e)
        	{
        	}
    
        	@Override
        	public boolean onSingleTapUp(MotionEvent e)
        	{
        		// Reset fling state
        		mFlingDirection = 0;
                return false;
        	}
        }
    }
    


  • 相关阅读:
    [转]Asp.NET MVC Widget开发
    [转]让Windows Server 2008 + IIS 7+ ASP.NET 支持10万并发请求
    [转]jquery Fancybox丰富的弹出层效果
    [转]响应式网页设计:rem、em设置网页字体大小自适应
    [转]jQuery Popup Login and Contact Form
    [转][ASP.NET MVC 小牛之路]12
    [转]jQuery插件实现模拟alert和confirm
    [转]Ionic 实现双击返回键退出功能
    [转]Ionic – Mobile UI Framework for PhoneGap/Cordova Developers
    [转]VS2015 cordova尝试-camera
  • 原文地址:https://www.cnblogs.com/snake-hand/p/3153490.html
Copyright © 2011-2022 走看看