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

评论

1 楼 yun2223 2012-09-17  

对楼主表示感谢