一个自定义截屏view的实现过程

最新推荐文章于 2023-04-28 14:37:03 发布
最新推荐文章于 2023-04-28 14:37:03 发布
阅读量355 收藏
点赞数
分类专栏： 安卓 文章标签： 截图 自定义view 移动截取区域 缩放
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35924482/article/details/81453562
版权

一个自定义view的实现过程,用于截屏功能的实现,结合 截屏使用,此段代码在项目中引用即可,此段代码可实现标记任意区域,并通过拖动实现标记区域的移动和缩放,文件下载位置看这里


package views;

import com.example.cutcapture.R;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Paint.Style;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;

public class DrawView extends View {

    private Context mContext;

    private int width = 0;

    private int height = 0;

    private int y = 0;

    private int x = 0;

    private int mX = 0;

    private int mY = 0;

    private Paint unMarkPaint;

    public Paint circlePaint;

    private int displayWidth;

    private int displayHeight;

    public Paint mBitPaint;

    private Bitmap okBitmap;

    private int okWidth;

    private int okHeight;

    private Bitmap cancleBitmap;

    private int cancleWidth;

    private int cancleHeight;

    private Rect okRect;

    private Rect cancleRect;

    private Rect okDisRect;

    private Rect cancleDisRect;

    private int pointLeft;

    private int pointTop;

    private ClickListenrInterface mClickListenerInterfate;

    private int[] areas;

    private int[] points;

    private int pointRight;

    private int pointBottom;

    private Rect markRect;

    private int starX;

    private int starY;

    private int pointULX;

    private int pointULY;

    private int pointUMX;

    private int pointUMY;

    private int pointURX;

    private int pointURY;

    private int pointMLX;

    private int pointMLY;

    private int pointMRX;

    private int pointMRY;

    private int pointDLX;

    private int pointDLY;

    private int pointDMX;

    private int pointDMY;

    private int pointDRX;

    private int pointDRY;

    private Rect uLRect;

    private Rect uMRect;

    private Rect uRRect;

    private Rect mLRect;

    private Rect mRRect;

    private Rect dLRect;

    private Rect dMRect;

    private Rect dRRect;

    private int xx;

    private int yy;

    private Bitmap zoomBitmap;

    private int zoomWidth;

    private int zoomHeith;

    private Rect zoomRect;

    private Rect zoomDisRect;

    private int[] drawAreas;

    private int[] drawPoints;

    public DrawView(Context context) {
        super(context, null);
        setWillNotDraw(false);
        this.mContext = context;
        init();
    }

    public DrawView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setWillNotDraw(false);
        this.mContext = context;
        init();
    }

    private void init() {
        WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        displayWidth = wm.getDefaultDisplay().getWidth();
        displayHeight = wm.getDefaultDisplay().getHeight();

        unMarkPaint = new Paint(Paint.FILTER_BITMAP_FLAG);
        unMarkPaint.setColor(Color.BLACK);

        circlePaint = new Paint(Paint.FILTER_BITMAP_FLAG);
        circlePaint.setColor(Color.WHITE);
        // circlePaint.setAlpha(90);
        circlePaint.setStrokeWidth(3);
        circlePaint.setAntiAlias(true);
        circlePaint.setStyle(Style.STROKE);

        mBitPaint = new Paint();
        mBitPaint.setFilterBitmap(true);
        mBitPaint.setDither(true);
        // mBitPaint.setAlpha(100);

        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;

        okBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.ok);
        okWidth = okBitmap.getWidth();
        okHeight = okBitmap.getHeight();
        cancleBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.cancle);
        cancleWidth = cancleBitmap.getWidth();
        cancleHeight = cancleBitmap.getHeight();
        zoomBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.zoomout);
        zoomWidth = zoomBitmap.getWidth();
        zoomHeith = zoomBitmap.getHeight();

        okRect = new Rect(0, 0, okWidth, okHeight);
        cancleRect = new Rect(0, 0, cancleWidth, cancleHeight);
        zoomRect = new Rect(0, 0, zoomWidth, zoomHeith);

        areas = new int[2]; // 截图区域宽高
        points = new int[4]; // 触摸松手后截图区域左上角和右下角坐标
        drawAreas = new int[2]; // 重绘后截图区域的宽高
        drawPoints = new int[4];// 重绘后截图区域的点的坐标

        markRect = new Rect();
        uLRect = new Rect();
        uMRect = new Rect();
        uRRect = new Rect();
        mLRect = new Rect();
        mRRect = new Rect();
        dLRect = new Rect();
        dMRect = new Rect();
        dRRect = new Rect();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            xx = (int) event.getX();
            yy = (int) event.getY();
            // 必须先对点击事件做判断,否则会执行到move中
            if (okDisRect.contains(xx, yy)) {
                mClickListenerInterfate.doConfirm();
                return false;
            } else if (cancleDisRect.contains(xx, yy)) {
                mClickListenerInterfate.doCancel();
                return false;
            } else if (zoomDisRect.contains(xx, yy)) {
                mClickListenerInterfate.doZoomOut();
                return false;
            } else if (markRect.contains(xx, yy) || uLRect.contains(xx, yy)
                    || uMRect.contains(xx, yy) || uRRect.contains(xx, yy)
                    || mLRect.contains(xx, yy) || mRRect.contains(xx, yy)
                    || dLRect.contains(xx, yy) || dMRect.contains(xx, yy)
                    || dRRect.contains(xx, yy)) {
                starX = (int) event.getX();
                starY = (int) event.getY();
            } else {
                x = (int) event.getX();
                y = (int) event.getY();
            }
        }

        if (event.getAction() == MotionEvent.ACTION_MOVE) {
            if (markRect.contains(xx, yy) || uLRect.contains(xx, yy) || uMRect.contains(xx, yy)
                    || uRRect.contains(xx, yy) || mLRect.contains(xx, yy)
                    || mRRect.contains(xx, yy) || dLRect.contains(xx, yy)
                    || dMRect.contains(xx, yy) || dRRect.contains(xx, yy)) {
                int endX = (int) event.getX();
                int endY = (int) event.getY();
                // 计算触摸点移动后的位置和移动距离
                if (uMRect.contains(starX, starY)) { // 上中
                    y = points[1] + endY - starY;
                } else if (mLRect.contains(starX, starY)) { // 中左
                    x = points[0] + endX - starX;
                } else if (mRRect.contains(starX, starY)) { // 中右
                    mX = points[2] + endX - starX;
                } else if (dMRect.contains(starX, starY)) { // 下中
                    mY = points[3] + endY - starY;
                } else if (dLRect.contains(starX, starY)) { // 下左
                    x = points[0] + endX - starX;
                    mY = points[3] + endY - starY;
                } else if (dRRect.contains(starX, starY)) { // 下右---
                    mX = points[2] + endX - starX;
                    mY = points[3] + endY - starY;
                } else if (uLRect.contains(starX, starY)) { // 上左
                    x = points[0] + endX - starX;
                    y = points[1] + endY - starY;
                } else if (uRRect.contains(starX, starY)) { // 上右---
                    y = points[1] + endY - starY;
                    mX = points[2] + endX - starX;
                } else if (markRect.contains(starX, starY)) { // 截图区
                    x = points[0] + endX - starX;
                    y = points[1] + endY - starY;
                    mX = points[2] + endX - starX;
                    mY = points[3] + endY - starY;
                }
                // 边界值
                if (mX > displayWidth) {
                    mX = displayWidth;
                }
                if (mX <= 0) {
                    mX = 0;
                }
                if (mY >= displayHeight) {
                    mY = displayHeight;
                }
                if (mY <= 0) {
                    mY = 0;
                }
                if (x >= displayWidth) {
                    x = displayWidth;
                }
                if (x <= 0) {
                    x = 0;
                }
                if (y >= displayHeight) {
                    y = displayHeight;
                }
                if (y <= 0) {
                    y = 0;
                }
            } else {
                mX = (int) event.getX();
                mY = (int) event.getY();
            }

            localOptions();
            postInvalidate();
        }

        if (event.getAction() == MotionEvent.ACTION_UP) {
            if (event.getX() > x) {
                width = (int) (event.getX() - x);
            } else {
                width = (int) (x - event.getX());
            }
            if (event.getY() > y) {
                height = (int) (event.getY() - y);
            } else {
                height = (int) (y - event.getY());
            }
            areas[0] = width;
            areas[1] = height;

            points[0] = pointLeft;
            points[1] = pointTop;
            points[2] = pointRight;
            points[3] = pointBottom;

            markRect = new Rect(pointLeft, pointTop, pointRight, pointBottom);
            uLRect = new Rect(pointULX - 20, pointULY - 10, pointULX, pointULY + 10);
            uMRect = new Rect(pointUMX - 10, pointUMY - 20, pointUMX + 10, pointUMY);
            uRRect = new Rect(pointURX, pointURY - 10, pointURX + 20, pointURY + 10);
            mLRect = new Rect(pointMLX - 20, pointMLY - 10, pointMLX, pointMLY + 10);
            mRRect = new Rect(pointMRX, pointMRY - 10, pointMRX + 20, pointMRY + 10);
            dLRect = new Rect(pointDLX - 10, pointDLY, pointDLX + 10, pointDLY + 20);
            dMRect = new Rect(pointDMX - 10, pointDMY, pointDMX + 10, pointDMY + 20);
            dRRect = new Rect(pointDRX - 10, pointDRY, pointDRX + 10, pointDRY + 20);
        }
        return true;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (x < mX && y < mY) { // 左上-->右下
            canvas.drawRect(new Rect(0, y, x, mY), unMarkPaint); // 左
            canvas.drawRect(new Rect(0, 0, displayWidth, y), unMarkPaint); // 上
            canvas.drawRect(new Rect(mX, y, displayWidth, mY), unMarkPaint); // 右
            canvas.drawRect(new Rect(0, mY, displayWidth, displayHeight), unMarkPaint); // 下

            drawCircle(canvas, x, y, circlePaint); // 上左
            drawCircle(canvas, Math.abs(mX - x) / 2 + x, y, circlePaint); // 上中
            drawCircle(canvas, mX, y, circlePaint); // 上右
            drawCircle(canvas, x, Math.abs(mY - y) / 2 + y, circlePaint); // 中左
            drawCircle(canvas, mX, Math.abs(mY - y) / 2 + y, circlePaint); // 中右
            drawCircle(canvas, x, mY, circlePaint); // 下左
            drawCircle(canvas, Math.abs(mX - x) / 2 + x, mY, circlePaint); // 下中
            drawCircle(canvas, mX, mY, circlePaint); // 下右
        } else if (x < mX && y > mY) { // 左下-->右上
            canvas.drawRect(new Rect(0, mY, x, y), unMarkPaint); // 左
            canvas.drawRect(new Rect(0, 0, displayWidth, mY), unMarkPaint); // 上
            canvas.drawRect(new Rect(mX, mY, displayWidth, y), unMarkPaint); // 右
            canvas.drawRect(new Rect(0, y, displayWidth, displayHeight), unMarkPaint); // 下

            drawCircle(canvas, x, mY, circlePaint); // 上左
            drawCircle(canvas, Math.abs(mX - x) / 2 + x, mY, circlePaint); // 上中
            drawCircle(canvas, mX, mY, circlePaint); // 上右
            drawCircle(canvas, x, Math.abs(mY - y) / 2 + mY, circlePaint); // 中左
            drawCircle(canvas, mX, Math.abs(mY - y) / 2 + mY, circlePaint); // 中右
            drawCircle(canvas, x, y, circlePaint); // 下左
            drawCircle(canvas, Math.abs(mX - x) / 2 + x, y, circlePaint); // 下中
            drawCircle(canvas, mX, y, circlePaint); // 下右
        } else if (x > mX && y < mY) { // 右上-->左下
            canvas.drawRect(new Rect(0, y, mX, mY), unMarkPaint); // 左
            canvas.drawRect(new Rect(0, 0, displayWidth, y), unMarkPaint); // 上
            canvas.drawRect(new Rect(x, y, displayWidth, mY), unMarkPaint); // 右
            canvas.drawRect(new Rect(0, mY, displayWidth, displayHeight), unMarkPaint); // 下

            drawCircle(canvas, mX, y, circlePaint); // 上左
            drawCircle(canvas, Math.abs(mX - x) / 2 + mX, y, circlePaint); // 上中
            drawCircle(canvas, x, y, circlePaint); // 上右
            drawCircle(canvas, mX, Math.abs(mY - y) / 2 + y, circlePaint); // 中左
            drawCircle(canvas, x, Math.abs(mY - y) / 2 + y, circlePaint); // 中右
            drawCircle(canvas, mX, mY, circlePaint); // 下左
            drawCircle(canvas, Math.abs(mX - x) / 2 + mX, mY, circlePaint); // 下中
            drawCircle(canvas, x, mY, circlePaint); // 下右
        } else if (x > mX && y > mY) { // 右下-->左上
            canvas.drawRect(new Rect(0, mY, mX, y), unMarkPaint); // 左
            canvas.drawRect(new Rect(0, 0, displayWidth, mY), unMarkPaint); // 上
            canvas.drawRect(new Rect(x, mY, displayWidth, y), unMarkPaint); // 右
            canvas.drawRect(new Rect(0, y, displayWidth, displayHeight), unMarkPaint); // 下

            drawCircle(canvas, mX, mY, circlePaint); // 上左
            drawCircle(canvas, Math.abs(mX - x) / 2 + mX, mY, circlePaint); // 上中
            drawCircle(canvas, x, mY, circlePaint); // 上右
            drawCircle(canvas, mX, Math.abs(mY - y) / 2 + mY, circlePaint); // 中左
            drawCircle(canvas, x, Math.abs(mY - y) / 2 + mY, circlePaint); // 中右
            drawCircle(canvas, mX, y, circlePaint); // 下左
            drawCircle(canvas, Math.abs(mX - x) / 2 + mX, y, circlePaint); // 下中
            drawCircle(canvas, x, y, circlePaint); // 下右
        } else {
            canvas.drawRect(new Rect(0, 0, displayWidth, displayHeight), unMarkPaint);
            okDisRect = new Rect(0, 0, 0, 0);
            cancleDisRect = new Rect(0, 0, 0, 0);
            zoomDisRect = new Rect(0, 0, 0, 0);
        }

        circlePoint();
        localOptions();

        canvas.drawBitmap(okBitmap, okRect, okDisRect, mBitPaint);
        canvas.drawBitmap(cancleBitmap, cancleRect, cancleDisRect, mBitPaint);
        canvas.drawBitmap(zoomBitmap, zoomRect, zoomDisRect, mBitPaint);
    }

    private void drawCircle(Canvas canvas, int x, int y, Paint paint) {
        canvas.drawCircle(x, y, 7, paint);
    }

    public void setBitmapPaint(int imgId) {
        zoomBitmap = BitmapFactory.decodeResource(getResources(), imgId);
        zoomWidth = zoomBitmap.getWidth();
        zoomHeith = zoomBitmap.getHeight();
    }

    public int[] getArea() {
        return areas;
    }

    // 重绘后
    public int[] getDrawArea() {
        return drawAreas;
    }

    public int[] getMarkPoint() {
        return points;
    }

    // 重绘后
    public int[] getDrawMarkPoint() {
        return drawPoints;
    }

    // 设置截图区域的坐标点
    public void setMarkPoint(int[] are) {
        x = are[0];
        y = are[1];
        mX = are[2];
        mY = are[3];
    }

    // 启动时,初始化截图区域
    public void initMarkArea(int[] are) {
        x = are[0];
        y = are[1];
        mX = are[2];
        mY = are[3];

        points[0] = x;
        points[1] = y;
        points[2] = mX;
        points[3] = mY;

        // 圆的坐标点
        pointULX = x;
        pointULY = y;

        pointUMX = Math.abs(mX - x) / 2 + x;
        pointUMY = y;

        pointURX = mX;
        pointURY = y;

        pointMLX = x;
        pointMLY = Math.abs(mY - y) / 2 + y;

        pointMRX = mX;
        pointMRY = Math.abs(mY - y) / 2 + y;

        pointDLX = x;
        pointDLY = mY;

        pointDMX = Math.abs(mX - x) / 2 + x;
        pointDMY = mY;

        pointDRX = mX;
        pointDRY = mY;

        markRect = new Rect(x, y, mX, mY);
        uLRect = new Rect(pointULX - 20, pointULY - 10, pointULX, pointULY + 10);
        uMRect = new Rect(pointUMX - 10, pointUMY - 20, pointUMX + 10, pointUMY);
        uRRect = new Rect(pointURX, pointURY - 10, pointURX + 20, pointURY + 10);
        mLRect = new Rect(pointMLX - 20, pointMLY - 10, pointMLX, pointMLY + 10);
        mRRect = new Rect(pointMRX, pointMRY - 10, pointMRX + 20, pointMRY + 10);
        dLRect = new Rect(pointDLX - 10, pointDLY, pointDLX + 10, pointDLY + 20);
        dMRect = new Rect(pointDMX - 10, pointDMY, pointDMX + 10, pointDMY + 20);
        dRRect = new Rect(pointDRX - 10, pointDRY, pointDRX + 10, pointDRY + 20);
    }

    private void localOptions() {
        // 按钮位置
        if (x < mX && y < mY) { // 左上-->右下
            if (displayHeight - mY >= 2 * okHeight) { // 底下
                okDisRect = new Rect(mX - 50, mY + 10, okWidth + mX - 50, okHeight + mY + 10);
                cancleDisRect = new Rect(mX - 120, mY + 10, cancleWidth + mX - 120, cancleHeight
                        + mY + 10);
                zoomDisRect = new Rect(mX - 190, mY + 10, zoomWidth + mX - 190, zoomHeith + mY + 10);
            } else if (y >= 3 * okHeight) { // 上面
                okDisRect = new Rect(mX - 50, y - 60, okWidth + mX - 50, okHeight + y - 60);
                cancleDisRect = new Rect(mX - 120, y - 60, cancleWidth + mX - 120, cancleHeight + y
                        - 60);
                zoomDisRect = new Rect(mX - 190, y - 60, zoomWidth + mX - 190, zoomHeith + y - 60);
            } else { // 截图区右下角
                okDisRect = new Rect(mX - 50, mY - 60, okWidth + mX - 50, okHeight + mY - 60);
                cancleDisRect = new Rect(mX - 120, mY - 60, cancleWidth + mX - 120, cancleHeight
                        + mY - 60);
                zoomDisRect = new Rect(mX - 190, mY - 60, zoomWidth + mX - 190, zoomHeith + mY - 60);
            }
        } else if (x < mX && y > mY) { // 左下-->右上
            if (displayHeight - y >= 2 * okHeight) {
                okDisRect = new Rect(mX - 50, y + 10, okWidth + mX - 50, okHeight + y + 10);
                cancleDisRect = new Rect(mX - 120, y + 10, cancleWidth + mX - 120, cancleHeight + y
                        + 10);
                zoomDisRect = new Rect(mX - 190, y + 10, zoomWidth + mX - 190, zoomHeith + y + 10);
            } else if (mY > 3 * okHeight) {
                okDisRect = new Rect(mX - 50, mY - 60, okWidth + mX - 50, okHeight + mY - 60);
                cancleDisRect = new Rect(mX - 120, mY - 60, cancleWidth + mX - 120, cancleHeight
                        + mY - 60);
                zoomDisRect = new Rect(mX - 190, mY - 60, zoomWidth + mX - 190, zoomHeith + mY - 60);
            } else {
                okDisRect = new Rect(mX - 50, y - 60, okWidth + mX - 50, okHeight + y - 60);
                cancleDisRect = new Rect(mX - 120, y - 60, cancleWidth + mX - 120, cancleHeight + y
                        - 60);
                zoomDisRect = new Rect(mX - 190, y - 60, zoomWidth + mX - 190, zoomHeith + y - 60);
            }

        } else if (x > mX && y < mY) { // 右上-->左下
            if (displayHeight - mY >= 2 * okHeight) {
                okDisRect = new Rect(x - 50, mY + 10, okWidth + x - 50, okHeight + mY + 10);
                cancleDisRect = new Rect(x - 120, mY + 10, cancleWidth + x - 120, cancleHeight + mY
                        + 10);
                zoomDisRect = new Rect(x - 190, mY + 10, zoomWidth + x - 190, zoomHeith + mY + 10);
            } else if (y >= 3 * okHeight) {
                okDisRect = new Rect(x - 50, y - 60, okWidth + x - 50, okHeight + y - 60);
                cancleDisRect = new Rect(x - 120, y - 60, cancleWidth + x - 120, cancleHeight + y
                        - 60);
                zoomDisRect = new Rect(x - 190, y - 60, zoomWidth + x - 190, zoomHeith + y - 60);
            } else {
                okDisRect = new Rect(x - 50, mY - 60, okWidth + x - 50, okHeight + mY - 60);
                cancleDisRect = new Rect(x - 120, mY - 60, cancleWidth + x - 120, cancleHeight + mY
                        - 60);
                zoomDisRect = new Rect(x - 190, mY - 60, zoomWidth + x - 190, zoomHeith + mY - 60);
            }
        } else if (x > mX && y > mY) { // 右下-->左上
            if (displayHeight - y > 2 * okHeight) {
                okDisRect = new Rect(x - 50, y + 10, okWidth + x - 50, okHeight + y + 10);
                cancleDisRect = new Rect(x - 120, y + 10, cancleWidth + x - 120, cancleHeight + y
                        + 10);
                zoomDisRect = new Rect(x - 190, y + 10, zoomWidth + x - 190, zoomHeith + y + 10);
            } else if (mY >= 3 * okHeight) {
                okDisRect = new Rect(x - 50, mY - 60, okWidth + x - 50, okHeight + mY - 60);
                cancleDisRect = new Rect(x - 120, mY - 60, cancleWidth + x - 120, cancleHeight + mY
                        - 60);
                zoomDisRect = new Rect(x - 190, mY - 60, zoomWidth + x - 190, zoomHeith + mY - 60);
            } else {
                okDisRect = new Rect(x - 50, y - 60, okWidth + x - 50, okHeight + y - 60);
                cancleDisRect = new Rect(x - 120, y - 60, cancleWidth + x - 120, cancleHeight + y
                        - 60);
                zoomDisRect = new Rect(x - 190, y - 60, zoomWidth + x - 190, zoomHeith + y - 60);
            }
        }
    }

    private void circlePoint() {
        if (x < mX && y < mY) { // 左上-->右下
            // 截图区域左上右下角
            pointLeft = x;
            pointTop = y;
            pointRight = mX;
            pointBottom = mY;

            // 圆的坐标点
            pointULX = x;
            pointULY = y;

            pointUMX = Math.abs(mX - x) / 2 + x;
            pointUMY = y;

            pointURX = mX;
            pointURY = y;

            pointMLX = x;
            pointMLY = Math.abs(mY - y) / 2 + y;

            pointMRX = mX;
            pointMRY = Math.abs(mY - y) / 2 + y;

            pointDLX = x;
            pointDLY = mY;

            pointDMX = Math.abs(mX - x) / 2 + x;
            pointDMY = mY;

            pointDRX = mX;
            pointDRY = mY;

            drawPoints[0] = pointLeft;
            drawPoints[1] = pointTop;
            drawPoints[2] = pointRight;
            drawPoints[3] = pointBottom;

            drawAreas[0] = mX - x;
            drawAreas[1] = mY - y;
        } else if (x > mX && y > mY) { // 右下-->左上
            pointLeft = mX;
            pointTop = mY;
            pointRight = x;
            pointBottom = y;

            // 圆的坐标点
            pointULX = mX;
            pointULY = mY;

            pointUMX = Math.abs(mX - x) / 2 + mX;
            pointUMY = mY;

            pointURX = x;
            pointURY = mY;

            pointMLX = x;
            pointMLY = Math.abs(mY - y) / 2 + mY;

            pointMRX = x;
            pointMRY = Math.abs(mY - y) / 2 + mY;

            pointDLX = mX;
            pointDLY = y;

            pointDMX = Math.abs(mX - x) / 2 + mX;
            pointDMY = y;

            pointDRX = x;
            pointDRY = y;

            drawPoints[0] = pointLeft;
            drawPoints[1] = pointTop;
            drawPoints[2] = pointRight;
            drawPoints[3] = pointBottom;

            drawAreas[0] = x - mX;
            drawAreas[1] = y - mY;
        } else if (x < mX && y > mY) { // 左下-->右上
            pointLeft = x;
            pointTop = mY;
            pointRight = mX;
            pointBottom = y;

            // 圆的坐标点
            pointULX = x;
            pointULY = mY;

            pointUMX = Math.abs(mX - x) / 2 + x;
            pointUMY = mY;

            pointURX = mX;
            pointURY = mY;

            pointMLX = x;
            pointMLY = Math.abs(mY - y) / 2 + mY;

            pointMRX = mX;
            pointMRY = Math.abs(mY - y) / 2 + mY;

            pointDLX = x;
            pointDLY = y;

            pointDMX = Math.abs(mX - x) / 2 + x;
            pointDMY = y;

            pointDRX = mX;
            pointDRY = y;

            drawPoints[0] = pointLeft;
            drawPoints[1] = pointTop;
            drawPoints[2] = pointRight;
            drawPoints[3] = pointBottom;

            drawAreas[0] = mX - x;
            drawAreas[1] = y - mY;
        } else if (x > mX && y < mY) { // 右上-->左下
            pointLeft = mX;
            pointTop = y;
            pointRight = x;
            pointBottom = mY;

            // 圆的坐标点
            pointULX = mX;
            pointULY = y;

            pointUMX = Math.abs(mX - x) / 2 + mX;
            pointUMY = y;

            pointURX = x;
            pointURY = y;

            pointMLX = mX;
            pointMLY = Math.abs(mY - y) / 2 + y;

            pointMRX = x;
            pointMRY = Math.abs(mY - y) / 2 + y;

            pointDLX = mX;
            pointDLY = mY;

            pointDMX = Math.abs(mX - x) / 2 + mX;
            pointDMY = mY;

            pointDRX = x;
            pointDRY = mY;

            drawPoints[0] = pointLeft;
            drawPoints[1] = pointTop;
            drawPoints[2] = pointRight;
            drawPoints[3] = pointBottom;

            drawAreas[0] = x - mX;
            drawAreas[1] = mY - y;
        }
    }

    public interface ClickListenrInterface {
        public void doConfirm();

        public void doZoomOut();

        public void doCancel();
    }

    public void setClickListener(ClickListenrInterface clickListener) {
        this.mClickListenerInterfate = clickListener;
    }
}

 

鱼塘的鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SwiftUI 绘图类精品项目大全之使用 SwiftUI 开发所见即所得的绘图应用程序 (教程含源码)
iCloudEnd的博客
04-27 687
本文探讨使用 SwiftUI 开发所见即所得 (WYSIWYG) 矢量绘图应用程序。所见即所得的矢量绘图应用程序可以被认为是在画布上呈现不同对象（例如矩形、椭圆形、文本或其他形状）的应用程序；通过拖动在画布周围移动对象；并通过点击对象来更改对象属性。这在下面的 iOS 应用程序的屏幕截图中进行了说明。具体来说，本文探讨了将SwiftUI 视图用作“绘图画布”，而不是使用 Core Graphics 画布或 SwiftUI 画布。 为什么要使用 SwiftUI View 作为绘图画布？ 在 Apple 生态
Android自定义View实现可拖拽缩放的矩形框
01-03
在开发项目中，需要一个矩形框来实现截屏功能，并且还需要可以任意拖拽和缩放，这就需要自定义View来实现了，具体功能如下： 1.自定义View package com.xinrui.screenshot.view; import android.content.Context; ...
SwiftUI将特定的view（非UIView）转为图片并分享（截图海报功能）
未来博客
10-26 2830
项目中有个需求要在App内生成海报并调用系统分享功能，原以为这个功能很常见所以不难，结果花了我好久查阅各种资料才做出来，现在分享给大家： 最主要的两个点： View需要先转为UIView然后用renderer转为图片。 需要先将图片保存在目录内，通过调用分享文件URL的功能进行分享，如果直接分享UIimage，分享框内是空白的。 上代码 import SwiftUI extension UIView { func asImage(rect: CGRect) -> UIImage {
Android 根据View生成截图
weixin_48488560的博客
04-28 264
这样就可以获取到该view的bitmap图片。
iOS中对指定UIView截图
发粪涂墙的星索
01-28 377
在iOS开发中，有时候会遇到需要对一个View进行截图的操作。具体该怎么实现呢？这里转发两段代码来实现这个功能。 //将整个UIView截图，返回图片 + (UIImage *)imageFromView: (UIView *) theView { UIGraphicsBeginImageContext(theView.frame.size); CGConte
Android自定义View实现照片裁剪框与照片裁剪功能
01-04
1：首先需要自定义一个ZoomImageView来显示我们需要的图片，这个View需要让图片能够以合适的位置展现在当前布局的图片展示区域内(合适的位置值的是：如果图片长度大于屏幕，则压缩图片长度至屏幕宽度，高度等比压缩...
Android自定义View实现带4圆角或者2圆角的效果
08-19
主要介绍了Android自定义View实现带4圆角或者2圆角的效果,本文通过实例代码截图给大家展示的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
自定义截图控件
08-06
拖动标记截取区域,可移动截图区域和缩放截图区域,将文件导入项目,在xml中引用即可
Android自定义view仿微信刷新旋转小风车
01-05
不太会录像，没办法，智能截图了 不多说了，直接上代码 package com.shipneg.demoysp.demo; import android.content.Context; import android.graphics.Bitmap; import android.graphics.Canvas; import android....
快速自定义尺寸截屏软件
03-11
款功能截屏软件，支持自定义屏幕截取，可以快速完成矩形屏幕截取
android 全屏截屏，以及自定义控件截屏
01-28
android 全屏截屏，以及自定义控件截屏。看了很多代码以及查找资料。截屏好的一般都要root权限。我的没有，有点缺点。我的博客地址：http://blog.csdn.net/qq_16064871?viewmode=list
自定义截图2
06-15
自定义截图2
自定义截图1
06-15
自定义截图1
Android 合并生成分享图片（View截图）
07-22
查看博客 http://blog.csdn.net/shallcheek/article/details/46998643 http://blog.csdn.net/shallcheek/article/details/44303197
自定义View之画图并截屏保存篇
会飞的小驴粪蛋
11-13 443
自定义View相信大家应该了解的很多了，但是一般只是涉及使用，很少有时间来自己写一个自定义View，最近在想如何在屏幕上签名然后截屏保存呢？那就来看下吧…… 先来一首歌陶冶下情操： 《你给我听好》 你看看大伙儿合照 就你一个人没有笑 是我们装傻 还是你真的 有很多普通人没有的困扰 我才懒得给你解药 反正你爱来这一套 为爱情折腰 难道不是你 一直以来戒不掉的癖好 你在想谁想到睡...
Android 指定View截屏,Android 获得View截屏最优方案
weixin_32327615的博客
05-27 277
/*** 获得View的截屏 Bitmap** @param view* @return*/public static Bitmap getMagicDrawingCache(Context context,View view,boolean quick_cache) {Bitmap bitmap = (Bitmap) view.getTag(R.id.cacheBitmapKey);Boolea...
自定义ImageView实现局部截图功能
HyHarden的博客
08-29 5690
1、前言 最近在做一个能够自选区域进行局部截图的功能，接下来，会给大家讲解，整个截图的实现过程。笔者这边实现的自选区域的形状是矩形，读者如果有需要，可以根据我给大家讲解的思路，修改成适合自己的截图工具。先来看看效果图 2、效果图 这里的图片是来自笔者对webView的截图产生的，读者可以根据自己的需要，替换上面的图片。 通过拖
Android View 截屏功能的实现
u012214750的博客
02-03 2706
Android中其实是可以用代码来实现截屏功能的，今天也是在这里无意中发现的（http://www.jianshu.com/p/4d21341f94ee），以前还真的不知道，记录一下以防忘记。     View rootView = getWindow().getDecorView().getRootView(); rootView.setDrawingCacheEnabled(true);
实现Web端自定义截屏
爱折腾的程序员
02-02 1824
前言 当客户在使用我们的产品过程中，遇到问题需要向我们反馈时，如果用纯文字的形式描述，我们很难懂客户的意思，要是能配上问题截图，这样我们就能很清楚的知道客户的问题了。 那么，我们就需要为我们的产品实现一个自定义截屏的功能，用户点完"截图"按钮后，框选任意区域，随后在框选的区域内进行圈选、画箭头、马赛克、直线、打字等操作，做完操作后用户可以选择保存框选区域的内容到本地或者直接发送给我们。 聪明的开发者可能已经猜到了，这是QQ/微信的截图功能，我的开源项目正好做到了截图功能，在做之前我找了很多资料，没有发现we
js实现自定义截图功能
最新发布
06-10
要实现自定义截图功能，可以使用 HTML5 中的 Canvas 和 JavaScript 来实现。下面是一个简单的实现方法： 1. 创建一个包含要截图的元素的 div。 2. 使用 HTML5 中的 Canvas 元素创建一个画布。 3. 使用 JavaScript...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值