Hi, I has a question for canvas. When I used canvas to do the picture
zoom in and move is ok, but when rotation before zoom in,
after zoom in to move has lag phenomenon, what's wrong? The
following is my code:

1. I was custom a view for canvas
       public class DrawImage extends View {
               public DrawImage(Context context) {
                       super(context);
                       photo = new BitmapDrawable(bmp);
                       setFocusable(false);
               }

               public void setBitmap(Bitmap bitmap){
                       photo = new BitmapDrawable(bitmap);
               }

               @Override
               protected void onDraw(Canvas canvas) {
                       super.onDraw(canvas);
                       Log.d(TAG,"onDraw");

                       photo.setBounds(getWidth()/2-zoomControler1,
getHeight()/2-
zoomControler2, getWidth()/2+zoomControler1, getHeight()/
2+zoomControler2);
                       canvas.translate(distanceX, distanceY);
                       canvas.rotate(degree, getWidth()/2, getHeight()/
2);
                       try{
                               photo.draw(canvas);
                       }catch(Exception e){
                               e.printStackTrace();
                       }
               }
       }


2. turn right function
       private void turn_right(){
               int temp;
               degree += 90;
               n++;
               if(degree % 180 == 0 ){
                       rotate_flag = true;
               }
               else{
                       rotate_flag = false;
               }
               degreeNum = degree/90;
               if(degreeNum == n){
                       temp = intScreenX;
                       intScreenX = intScreenY;
                       intScreenY = temp;
                       if(degreeNum%2 == 0){
                               displayPhoto(bmp);
                               flag = true;
                       }else{
                               rotatePhoto(bmp);
                               flag = false;
                       }
                       zoomControler1 = displayWidth/2;
                       zoomControler2 = displayHeight/2;

                       distanceX -= distanceX;
                       distanceY -= distanceY;
               }
       }

3.displayPhoto() and  rotatePhoto is compute the image boundarys

4. to do zoom in, I use onDoubleTap (intScreenX is screen width,
intScreenY is screen height
   bmp is loading the image, x_cent and y_cent is the screen central
point, image is custom view)

     @Override
     public boolean onDoubleTap(MotionEvent e)
     {
         if(bmp != null){
                 if(touch_double){
                         big();
                         downX = e.getX();
                         downY = e.getY();
                         if(rotate_flag == true){
                                 x_cent = ((intScreenX/
2+zoomControler1)-(intScreenX/2-
zoomControler1))/2 + (intScreenX/2-zoomControler1);
                                 y_cent = ((intScreenY/
2+zoomControler2)-(intScreenY/2-
zoomControler2))/2 + (intScreenY/2-zoomControler2);
                         }
                         else{
                                 y_cent = ((intScreenX/
2+zoomControler1)-(intScreenX/2-
zoomControler1))/2 + (intScreenX/2-zoomControler1);
                                 x_cent = ((intScreenY/
2+zoomControler2)-(intScreenY/2-
zoomControler2))/2 + (intScreenY/2-zoomControler2);
                         }
                         image.invalidate();
                         touch_double = false;
                         isMove = true;
                 }
                 else{
                         small();
                         touch_double = true;
                         isMove = false;
                 }
         }
         return false;
     }

5. big function (min_dist_t is top boundary, min_dist_d is down
boundary, min_dist_l is left boundary, min_dist_r is right boundary)
   private void big()
   {
               scalewidth = 1;
               scaleheight = 1;

               zoomControler_x = zoomControler1;
               zoomControler_y = zoomControler2;

               zoomControler1 = (int)(scalewidth*bmp.getWidth())/2;
               zoomControler2 = (int)(scaleheight*bmp.getHeight())/2;

               zoomControler_x = zoomControler1 / zoomControler_x;
               zoomControler_y = zoomControler2 / zoomControler_y;

               if(rotate_flag == true){
                       min_dist_t = (zoomControler2*2 - intScreenY)/2;
                       min_dist_d = (zoomControler2*2 - intScreenY)/2;
                       min_dist_l = (zoomControler1*2 - intScreenX)/2;
                       min_dist_r = (zoomControler1*2 - intScreenX)/2;
               }
               else{
                       min_dist_t = (zoomControler1*2 - intScreenX)/2;
                       min_dist_d = (zoomControler1*2 - intScreenX)/2;
                       min_dist_l = (zoomControler2*2 - intScreenY)/2;
                       min_dist_r = (zoomControler2*2 - intScreenY)/2;
               }
   }

6.move function (int this, the downX and downY is get touch event by
MotionEvent.ACTION_DOWN
moveX and moveY is get touch event by MotionEvent.ACTION_MOVE)


sorry, it's look a little disorderly, because I don't know how to ask!
Can anyone help me or tell me how solve after rotate to do zoom in and
move has lag?

-- 
You received this message because you are subscribed to the Google
Groups "Android Developers" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/android-developers?hl=en

Reply via email to