How to zoom a textview in android?

Question

Can anyone guide me to perform zoom in&out operations on multiple views in android ? I need to perform zoom in&out operations on touch of image, text views . What should be my parent layout? Here is the code to zoom an image on touch of imageview. How do i zoom a textview? Please help me.

   // These matrices will be used to scale points of the image
Matrix matrix = new Matrix();
Matrix savedMatrix = new Matrix();

// The 3 states (events) which the user is trying to perform   
static final int NONE = 0;
static final int DRAG = 1;
static final int ZOOM = 2;
int mode = NONE;

// these PointF objects are used to record the point(s) the user is touching
PointF start = new PointF();
PointF mid = new PointF();
float oldDist = 1f;

private void zoom(View v, MotionEvent event) 
{
    ImageView view = (ImageView) v;
    view.setScaleType(ImageView.ScaleType.MATRIX);
    float scale;

    //  dumpEvent(event);
    // Handle touch events here...

    switch (event.getAction() & MotionEvent.ACTION_MASK) 
    {
    case MotionEvent.ACTION_DOWN:  
        // first finger down only
        savedMatrix.set(matrix);
        start.set(event.getX(), event.getY());

        mode = DRAG;
        break;

    case MotionEvent.ACTION_UP: // first finger lifted

    case MotionEvent.ACTION_POINTER_UP: // second finger lifted

        mode = NONE;   

        break;

    case MotionEvent.ACTION_POINTER_DOWN: // first and second finger down

        oldDist = spacing(event);

        if (oldDist > 5f)
        {
            savedMatrix.set(matrix);
            midPoint(mid, event);
            mode = ZOOM;

        }
        break;

    case MotionEvent.ACTION_MOVE:

        if (mode == DRAG) 
        { 
            matrix.set(savedMatrix);
            matrix.postTranslate(event.getX() - start.x, event.getY() - start.y); // create the transformation in the matrix  of points
        } 
        else if (mode == ZOOM) 
        { 
            // pinch zooming
            float newDist = spacing(event);

            if (newDist > 5f) 
            {
                matrix.set(savedMatrix);
                scale = newDist / oldDist; // setting the scaling of the
                // matrix...if scale > 1 means
                // zoom in...if scale < 1 means
                // zoom out
                matrix.postScale(scale, scale, mid.x, mid.y);
            }
        }
        break;  
    }

    view.setImageMatrix(matrix); // display the transformation on screen

}

/*
 * --------------------------------------------------------------------------
 * Method: spacing Parameters: MotionEvent Returns: float Description:
 * 
 * checks the spacing between the two fingers on touch
 * ----------------------------------------------------
 */

private float spacing(MotionEvent event) 
{
    float x = event.getX(0) - event.getX(1);
    float y = event.getY(0) - event.getY(1);
    return FloatMath.sqrt(x * x + y * y);
}

/*
 * --------------------------------------------------------------------------
 * Method: midPoint Parameters: PointF object, MotionEvent Returns: void
 * Description: calculates the midpoint between the two fingers
 * ------------------------------------------------------------
 */   

private void midPoint(PointF point, MotionEvent event) 
{
    float x = event.getX(0) + event.getX(1);
    float y = event.getY(0) + event.getY(1);
    point.set(x / 2, y / 2);
}

Answer 1

I found a very simple solution to implement zoom in/out on text view. Maybe it helps someone

package com.app;

import android.os.Bundle;
import android.util.TypedValue;
import android.view.MotionEvent;
import android.widget.TextView;
import android.support.v7.app.AppCompatActivity;
import android.view.View;


public class MyActivity extends AppCompatActivity implements View.OnTouchListener{

    public static final int TEXT_MAX_SIZE = 140;
    public static final int TEXT_MIN_SIZE = 40;
    private static final int STEP = 4;

    private int mBaseDistZoomIn;
    private int mBaseDistZoomOut;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.my_activity);

        .
        .
        .
        TextView viewById = (TextView) findViewById(R.id.some_text_view);
        viewById.setOnTouchListener(this);
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if (event.getPointerCount() == 2) {
            TextView viewById = (TextView) findViewById(R.id.some_text_view);
            int action = event.getAction();
            int pure = action & MotionEvent.ACTION_MASK;

            if (pure == MotionEvent.ACTION_POINTER_DOWN
                    && viewById.getTextSize() <= TEXT_MAX_SIZE
                    && viewById.getTextSize() >= TEXT_MIN_SIZE) {

                mBaseDistZoomIn = getDistanceFromEvent(event);
                mBaseDistZoomOut = getDistanceFromEvent(event);

            } else {
                int currentDistance = getDistanceFromEvent(event);
                if (currentDistance > mBaseDistZoomIn) {
                    float finalSize = viewById.getTextSize() + STEP;
                    if (finalSize > TEXT_MAX_SIZE) {
                        finalSize = TEXT_MAX_SIZE;
                    }
                    viewById.setTextSize(TypedValue.COMPLEX_UNIT_PX, finalSize);
                } else {
                    if (currentDistance < mBaseDistZoomOut) {
                        float finalSize = viewById.getTextSize() - STEP;
                        if (finalSize < TEXT_MIN_SIZE) {
                            finalSize = TEXT_MIN_SIZE;
                        }
                        viewById.setTextSize(TypedValue.COMPLEX_UNIT_PX, finalSize);
                    }
                }
            }
            return true;
        }
        return false;
    }


    // good function to get the distance between the multiple touch
    int getDistanceFromEvent(MotionEvent event) {
        int dx = (int) (event.getX(0) - event.getX(1));
        int dy = (int) (event.getY(0) - event.getY(1));
        return (int) (Math.sqrt(dx * dx + dy * dy));
    }
}

Answer 2

first you should convert Textview to imageview.Next you should apply sample image view drag functionality.
    -----------------------------



            TextView tv = new TextView(this);
            FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(
                    FrameLayout.LayoutParams.FILL_PARENT,
                    FrameLayout.LayoutParams.FILL_PARENT);

            tv.setLayoutParams(layoutParams);
            tv.setText("Text");
            tv.setTextColor(Color.BLACK);
            tv.setBackgroundColor(Color.TRANSPARENT);

            Bitmap testB;

            testB = Bitmap.createBitmap(80, 100, Bitmap.Config.ARGB_8888);
            Canvas c = new Canvas(testB);
            tv.layout(30, 40, 200, 100);
            tv.draw(c);

            ImageView iv = (ImageView) findViewById(R.id.imageView);
            iv.setLayoutParams(layoutParams);
            iv.setBackgroundColor(Color.GRAY);`enter code here`
            iv.setImageBitmap(testB);
            iv.setMaxHeight(80);
            iv.setMaxWidth(200);

            iv.setOnTouchListener(this);

Answer 3

To zoom textview, you can use the same code which you have to zoom an image. But you should change textview to an imageview and then perform zoom operations. Here is the link to convert textview to imageview Converting a TextView->Bitmap->ImageView, and nothing's showing up

Answer 4

The above is ok but you to it as below ::

In oncreate() you must instialize your textview and set ontouch event on it as below

TextView tv = (TextView)findViewById(R.id.name);
tv.setText("text");
tv.setOnTouchListener(this);

here is the complete code including your code:::

public class MyTextView extends Activity implements OnTouchListener{
     private static final String TAG = "Touch";
        @SuppressWarnings("unused")
        private static final float MIN_ZOOM = 1f,MAX_ZOOM = 1f;

        // These matrices will be used to scale points of the image
        Matrix matrix = new Matrix();
        Matrix savedMatrix = new Matrix();

        // The 3 states (events) which the user is trying to perform
        static final int NONE = 0;
        static final int DRAG = 1;
        static final int ZOOM = 2;
        int mode = NONE;

        // these PointF objects are used to record the point(s) the user is touching
        PointF start = new PointF();
        PointF mid = new PointF();
        float oldDist = 1f;
@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    TextView iv = new TextView(this);
    iv.setText("text");
    iv.setOnTouchListener(this);
    setContentView(iv);
}
@Override
public boolean onTouch(View v, MotionEvent event) {
    // TODO Auto-generated method stub
     ImageView view = (ImageView) v;
     view.setScaleType(ImageView.ScaleType.MATRIX);
     float scale;

     dumpEvent(event);
     // Handle touch events here...

     switch (event.getAction() & 255) 
     {
         case MotionEvent.ACTION_DOWN:   // first finger down only
                                             savedMatrix.set(matrix);
                                             start.set(event.getX(), event.getY());
                                             Log.d(TAG, "mode=DRAG"); // write to LogCat
                                             mode = DRAG;
                                             break;

         case MotionEvent.ACTION_UP: // first finger lifted

         case 6: // second finger lifted

                                             mode = NONE;
                                             Log.d(TAG, "mode=NONE");
                                             break;

         case 5: // first and second finger down

                                             oldDist = spacing(event);
                                             Log.d(TAG, "oldDist=" + oldDist);
                                             if (oldDist > 5f) {
                                                 savedMatrix.set(matrix);
                                                 midPoint(mid, event);
                                                 mode = ZOOM;
                                                 Log.d(TAG, "mode=ZOOM");
                                             }
                                             break;

         case MotionEvent.ACTION_MOVE:

                                             if (mode == DRAG) 
                                             { 
                                                 matrix.set(savedMatrix);
                                                 matrix.postTranslate(event.getX() - start.x, event.getY() - start.y); // create the transformation in the matrix  of points
                                             } 
                                             else if (mode == ZOOM) 
                                             { 
                                                 // pinch zooming
                                                 float newDist = spacing(event);
                                                 Log.d(TAG, "newDist=" + newDist);
                                                 if (newDist > 5f) 
                                                 {
                                                     matrix.set(savedMatrix);
                                                     scale = newDist / oldDist; // setting the scaling of the
                                                                                 // matrix...if scale > 1 means
                                                                                 // zoom in...if scale < 1 means
                                                                                 // zoom out
                                                     matrix.postScale(scale, scale, mid.x, mid.y);
                                                 }
                                             }
                                             break;
     }

     view.setImageMatrix(matrix); // display the transformation on screen

     return true; // indicate event was handled
}
private float spacing(MotionEvent event) 
{
    float x = event.getX(0) - event.getX(1);
    float y = event.getY(0) - event.getY(1);
    return FloatMath.sqrt(x * x + y * y);
}

/*
 * --------------------------------------------------------------------------
 * Method: midPoint Parameters: PointF object, MotionEvent Returns: void
 * Description: calculates the midpoint between the two fingers
 * ------------------------------------------------------------
 */

private void midPoint(PointF point, MotionEvent event) 
{
    float x = event.getX(0) + event.getX(1);
    float y = event.getY(0) + event.getY(1);
    point.set(x / 2, y / 2);
}

/** Show an event in the LogCat view, for debugging */
private void dumpEvent(MotionEvent event) 
{
    String names[] = { "DOWN", "UP", "MOVE", "CANCEL", "OUTSIDE","POINTER_DOWN", "POINTER_UP", "7?", "8?", "9?" };
    StringBuilder sb = new StringBuilder();
    int action = event.getAction();
    int actionCode = action & MotionEvent.ACTION_MASK;
    sb.append("event ACTION_").append(names[actionCode]);

    if (actionCode == MotionEvent.ACTION_POINTER_DOWN || actionCode == MotionEvent.ACTION_POINTER_UP) 
    {
        sb.append("(pid ").append(action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
        sb.append(")");
    }

    sb.append("[");
    for (int i = 0; i < event.getPointerCount(); i++) 
    {
        sb.append("#").append(i);
        sb.append("(pid ").append(event.getPointerId(i));
        sb.append(")=").append((int) event.getX(i));
        sb.append(",").append((int) event.getY(i));
        if (i + 1 < event.getPointerCount())
            sb.append(";");
    }

    sb.append("]");
    Log.d("Touch Events ---------", sb.toString());
}
}