Android控件开发之Gallery3D效果

Android控件开发之Gallery3D效果

 package  xiaosi.GalleryFlow;

 import  android.app.Activity;
 import  android.os.Bundle;

 public   class  GalleryFlowActivity  extends  Activity {
     public   void  onCreate(Bundle savedInstanceState) {
         super .onCreate(savedInstanceState);


         setContentView(R.layout.main);

         Integer[] images = { R.drawable.a, R.drawable.b,
                 R.drawable.c, R.drawable.d, R.drawable.e,
                 };

         ImageAdapter adapter = new  ImageAdapter( this , images);
         adapter.createReflectedImages();

         GalleryFlow galleryFlow = (GalleryFlow) findViewById(R.id.Gallery01);
         galleryFlow.setAdapter(adapter);

 }
 }

ImageAdapter.java

 package  xiaosi.GalleryFlow;

 import  android.content.Context;
 import  android.content.res.Resources;
 import  android.graphics.Bitmap;
 import  android.graphics.BitmapFactory;
 import  android.graphics.Canvas;
 import  android.graphics.LinearGradient;
 import  android.graphics.Matrix;
 import  android.graphics.Paint;
 import  android.graphics.PorterDuffXfermode;
 import  android.graphics.Bitmap.Config;
 import  android.graphics.PorterDuff.Mode;
 import  android.graphics.Shader.TileMode;
 import  android.view.View;
 import  android.view.ViewGroup;
 import  android.widget.BaseAdapter;
 import  android.widget.ImageView;
 import  android.widget.ImageView.ScaleType;

 public   class  ImageAdapter  extends  BaseAdapter
 {

      int  mGalleryItemBackground;
      private  Context    mContext;
      private  Integer[]  mImageIds;
      private  ImageView[] mImages;

      public  ImageAdapter(Context c, Integer[] ImageIds)
      {
          mContext  = c;
          mImageIds = ImageIds;
          mImages   = new  ImageView[mImageIds.length];
      }

      public   boolean  createReflectedImages()
      {
          final   int  reflectionGap =  4 ;
          int  index =  0 ;

          for  ( int  imageId : mImageIds)
          {
              Bitmap originalImage = BitmapFactory.decodeResource(mContext.getResources(), imageId);
              int  width  = originalImage.getWidth();
              int  height = originalImage.getHeight();

              Matrix matrix = new  Matrix();
              matrix.preScale(1 , - 1 );

              Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0 , height /  2 , width, height /  2 , matrix,  false );

              Bitmap bitmapWithReflection = Bitmap.createBitmap(width, (height + height / 2 ), Config.ARGB_8888);

              Canvas canvas = new  Canvas(bitmapWithReflection);

              canvas.drawBitmap(originalImage, 0 ,  0 ,  null );

              Paint deafaultPaint = new  Paint();
              canvas.drawRect(0 , height, width, height + reflectionGap, deafaultPaint);

              canvas.drawBitmap(reflectionImage, 0 , height + reflectionGap,  null );

              Paint paint = new  Paint();
              LinearGradient shader = new  LinearGradient( 0 , originalImage.getHeight(),  0 , bitmapWithReflection.getHeight()
                                                         + reflectionGap, 0x70ffffff ,  0x00ffffff , TileMode.CLAMP);

              paint.setShader(shader);

              paint.setXfermode(new  PorterDuffXfermode(Mode.DST_IN));

              canvas.drawRect(0 , height, width, bitmapWithReflection.getHeight() + reflectionGap, paint);

              ImageView imageView = new  ImageView(mContext);
              imageView.setImageBitmap(bitmapWithReflection);
              imageView.setLayoutParams(new  GalleryFlow.LayoutParams( 250 ,  340 ));
              imageView.setScaleType(ScaleType.FIT_XY);
              mImages[index++] = imageView;
          }
          return   true ;
      }

      private  Resources getResources()
      {
          // TODO Auto-generated method stub
          return   null ;
      }

      public   int  getCount()
      {
          return  mImageIds.length;
      }

      public  Object getItem( int  position)
      {
          return  position;
      }

      public   long  getItemId( int  position)
      {
          return  position;
      }

      public  View getView( int  position, View convertView, ViewGroup parent)
      {
          return  mImages[position];
      }

      public   float  getScale( boolean  focused,  int  offset)
      {
          return  Math.max( 0 ,  1 .0f / ( float ) Math.pow( 2 , Math.abs(offset)));
      }
 }

 

GalleryFlow.java

 package  xiaosi.GalleryFlow;

 import  android.content.Context;
 import  android.graphics.Camera;
 import  android.graphics.Matrix;
 import  android.util.AttributeSet;
 import  android.view.View;
 import  android.view.animation.Transformation;
 import  android.widget.Gallery;
 import  android.widget.ImageView;

 public   class  GalleryFlow  extends  Gallery {

     private  Camera mCamera =  new  Camera();
     private   int  mMaxRotationAngle =  60 ;
     private   int  mMaxZoom = - 120 ;
     private   int  mCoveflowCenter;

     public  GalleryFlow(Context context) {
             super (context);
             this .setStaticTransformationsEnabled( true );
     }

     public  GalleryFlow(Context context, AttributeSet attrs) {
             super (context, attrs);
             this .setStaticTransformationsEnabled( true );
     }

     public  GalleryFlow(Context context, AttributeSet attrs,  int  defStyle) {
             super (context, attrs, defStyle);
             this .setStaticTransformationsEnabled( true );
     }

     public   int  getMaxRotationAngle() {
             return  mMaxRotationAngle;
     }

     public   void  setMaxRotationAngle( int  maxRotationAngle) {
             mMaxRotationAngle = maxRotationAngle;
     }

     public   int  getMaxZoom() {
             return  mMaxZoom;
     }

     public   void  setMaxZoom( int  maxZoom) {
             mMaxZoom = maxZoom;
     }

     private   int  getCenterOfCoverflow() {
             return  (getWidth() - getPaddingLeft() - getPaddingRight()) /  2
                             + getPaddingLeft();
     }

     private   static   int  getCenterOfView(View view) {
             return  view.getLeft() + view.getWidth() /  2 ;
     }

     protected   boolean  getChildStaticTransformation(View child, Transformation t) {

             final   int  childCenter = getCenterOfView(child);
             final   int  childWidth = child.getWidth();
             int  rotationAngle =  0 ;

             t.clear();
             t.setTransformationType(Transformation.TYPE_MATRIX);

             if  (childCenter == mCoveflowCenter) {
                     transformImageBitmap((ImageView) child, t, 0 );
             } else  {
                     rotationAngle = (int ) ((( float ) (mCoveflowCenter - childCenter) / childWidth) * mMaxRotationAngle);
                     if  (Math.abs(rotationAngle) > mMaxRotationAngle) {
                             rotationAngle = (rotationAngle < 0 ) ? -mMaxRotationAngle
                                             : mMaxRotationAngle;
                     }
                     transformImageBitmap((ImageView) child, t, rotationAngle);
             }

             return   true ;
     }

     protected   void  onSizeChanged( int  w,  int  h,  int  oldw,  int  oldh) {
             mCoveflowCenter = getCenterOfCoverflow();
             super .onSizeChanged(w, h, oldw, oldh);
     }

     private   void  transformImageBitmap(ImageView child, Transformation t,
                     int  rotationAngle) {
             mCamera.save();
             final  Matrix imageMatrix = t.getMatrix();
             final   int  imageHeight = child.getLayoutParams().height;
             final   int  imageWidth = child.getLayoutParams().width;
             final   int  rotation = Math.abs(rotationAngle);

             // 在Z轴上正向移动camera的视角，实际效果为放大图片。
             // 如果在Y轴上移动，则图片上下移动；X轴上对应图片左右移动。
             mCamera.translate(0 .0f,  0 .0f,  100 .0f);

             // As the angle of the view gets less, zoom in
             if  (rotation < mMaxRotationAngle) {
                     float  zoomAmount = ( float ) (mMaxZoom + (rotation *  1.5 ));
                     mCamera.translate(0 .0f,  0 .0f, zoomAmount);
             }

             // 在Y轴上旋转，对应图片竖向向里翻转。
             // 如果在X轴上旋转，则对应图片横向向里翻转。
             mCamera.rotateY(rotationAngle);
             mCamera.getMatrix(imageMatrix);
             imageMatrix.preTranslate(-(imageWidth / 2 ), -(imageHeight /  2 ));
             imageMatrix.postTranslate((imageWidth / 2 ), (imageHeight /  2 ));
             mCamera.restore();
     }
 }

 

源代码：点击打开链接

 

 

原文链接：http://blog.csdn.net/sjf0115/article/details/7264552