精华内容
下载资源
问答
  • 功能演示: GIF: 生成的png透明图片: ...功能描述: ...手写板基于UGUI实现,可定制大小和位置;...可调节手写粗细,颜色,笔刷;...可一键清除手写内容;...可一键保存手写内容为png;...项目工程下载 unitypackage ...

    功能演示:

     

    GIF:

     

     

    生成的png透明图片:

     

     

     

    项目来源:项目根据原来的大神写的修改的

     

    功能描述:

    手写板基于UGUI实现,可定制大小和位置;

    可调节手写粗细,颜色,笔刷;

    可一键清除手写内容;

    可一键保存手写内容为png;

     

    项目工程下载

    unitypackage

     

    展开全文
  • 本项目是一个仿有道云笔记的原笔迹手写功能的app应用源码,有四种默认的笔直径,和四种默认的笔类型,以及30种色彩,可以随意涂鸦撤销清除并且可以保存图片到设备中,代码老外写的有部分英文注释。
  • android 电子签名 手写签名 功能实现

    万次阅读 2017-09-15 17:19:30
    android 电子签名 手写签名 功能实现

    android 电子签名  手写签名 功能实现





    这个手写的效果 就是一个 重写的的自定义的view  代码如下:

    package com.example.hand.views;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import android.content.Context;
    import android.content.res.Resources;
    import android.content.res.TypedArray;
    import android.graphics.Bitmap;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Matrix;
    import android.graphics.Paint;
    import android.graphics.Path;
    import android.graphics.RectF;
    import android.util.AttributeSet;
    import android.util.DisplayMetrics;
    import android.view.MotionEvent;
    import android.view.View;
    
    import com.example.hand.R;
    import com.example.hand.utils.Bezier;
    import com.example.hand.utils.ControlTimedPoints;
    import com.example.hand.utils.TimedPoint;
    
    public class SignatureView extends View {
    	// View state
    	private List<TimedPoint> mPoints;
    	private boolean mIsEmpty;
    	private float mLastTouchX;
    	private float mLastTouchY;
    	private float mLastVelocity;
    	private float mLastWidth;
    	private RectF mDirtyRect;
    
    	// Configurable parameters
    	private int mMinWidth;
    	private int mMaxWidth;
    	private float mVelocityFilterWeight;
    	private OnSignedListener mOnSignedListener;
    
    	private Paint mPaint = new Paint();
    	private Path mPath = new Path();
    	private Bitmap mSignatureBitmap = null;
    	private Canvas mSignatureBitmapCanvas = null;
    
    	public SignatureView(Context context, AttributeSet attrs) {
    		super(context, attrs);
    
    		TypedArray a = context.getTheme().obtainStyledAttributes(attrs, R.styleable.SignatureView, 0, 0);
    
    		// Configurable parameters
    		try {
    			mMinWidth = a.getDimensionPixelSize(R.styleable.SignatureView_minWidth, convertDpToPx(3));
    			mMaxWidth = a.getDimensionPixelSize(R.styleable.SignatureView_maxWidth, convertDpToPx(7));
    			mVelocityFilterWeight = a.getFloat(R.styleable.SignatureView_velocityFilterWeight, 0.9f);
    			mPaint.setColor(a.getColor(R.styleable.SignatureView_penColor, Color.BLACK));
    		} finally {
    			a.recycle();
    		}
    
    		// Fixed parameters
    		mPaint.setAntiAlias(true);
    		mPaint.setStyle(Paint.Style.STROKE);
    		mPaint.setStrokeCap(Paint.Cap.ROUND);
    		mPaint.setStrokeJoin(Paint.Join.ROUND);
    
    		// Dirty rectangle to update only the changed portion of the view
    		mDirtyRect = new RectF();
    
    		clear();
    	}
    
    	/**
    	 * Set the pen color from a given resource. If the resource is not found,
    	 * {@link android.graphics.Color#BLACK} is assumed.
    	 * 
    	 * @param colorRes
    	 *            the color resource.
    	 */
    	public void setPenColorRes(int colorRes) {
    		try {
    			setPenColor(getResources().getColor(colorRes));
    		} catch (Resources.NotFoundException ex) {
    			setPenColor(getResources().getColor(Color.BLACK));
    		}
    	}
    
    	/**
    	 * Set the pen color from a given color.
    	 * 
    	 * @param color
    	 *            the color.
    	 */
    	public void setPenColor(int color) {
    		mPaint.setColor(color);
    	}
    
    	/**
    	 * Set the minimum width of the stroke in pixel.
    	 * 
    	 * @param minWidth
    	 *            the width in dp.
    	 */
    	public void setMinWidth(float minWidth) {
    		mMinWidth = convertDpToPx(minWidth);
    	}
    
    	/**
    	 * Set the maximum width of the stroke in pixel.
    	 * 
    	 * @param maxWidth
    	 *            the width in dp.
    	 */
    	public void setMaxWidth(float maxWidth) {
    		mMaxWidth = convertDpToPx(maxWidth);
    	}
    
    	/**
    	 * Set the velocity filter weight.
    	 * 
    	 * @param velocityFilterWeight
    	 *            the weight.
    	 */
    	public void setVelocityFilterWeight(float velocityFilterWeight) {
    		mVelocityFilterWeight = velocityFilterWeight;
    	}
    
    	public void clear() {
    		mPoints = new ArrayList<TimedPoint>();
    		mLastVelocity = 0;
    		mLastWidth = (mMinWidth + mMaxWidth) / 2;
    		mPath.reset();
    
    		if (mSignatureBitmap != null) {
    			mSignatureBitmap = null;
    			ensureSignatureBitmap();
    		}
    
    		setIsEmpty(true);
    
    		invalidate();
    	}
    
    	@Override
    	public boolean onTouchEvent(MotionEvent event) {
    		if (!isEnabled())
    			return false;
    
    		float eventX = event.getX();
    		float eventY = event.getY();
    
    		switch (event.getAction()) {
    		case MotionEvent.ACTION_DOWN:
    			getParent().requestDisallowInterceptTouchEvent(true);
    			mPoints.clear();
    			mPath.moveTo(eventX, eventY);
    			mLastTouchX = eventX;
    			mLastTouchY = eventY;
    			addPoint(new TimedPoint(eventX, eventY));
    
    		case MotionEvent.ACTION_MOVE:
    			resetDirtyRect(eventX, eventY);
    			addPoint(new TimedPoint(eventX, eventY));
    			break;
    
    		case MotionEvent.ACTION_UP:
    			resetDirtyRect(eventX, eventY);
    			addPoint(new TimedPoint(eventX, eventY));
    			getParent().requestDisallowInterceptTouchEvent(true);
    			setIsEmpty(false);
    			break;
    
    		default:
    			return false;
    		}
    
    		// invalidate();
    		invalidate((int) (mDirtyRect.left - mMaxWidth), (int) (mDirtyRect.top - mMaxWidth),
    				(int) (mDirtyRect.right + mMaxWidth), (int) (mDirtyRect.bottom + mMaxWidth));
    
    		return true;
    	}
    
    	@Override
    	protected void onDraw(Canvas canvas) {
    		if (mSignatureBitmap != null) {
    			canvas.drawBitmap(mSignatureBitmap, 0, 0, mPaint);
    		}
    	}
    
    	public void setOnSignedListener(OnSignedListener listener) {
    		mOnSignedListener = listener;
    	}
    
    	public boolean isEmpty() {
    		return mIsEmpty;
    	}
    
    	public Bitmap getSignatureBitmap() {
    		Bitmap originalBitmap = getTransparentSignatureBitmap();
    		Bitmap whiteBgBitmap = Bitmap.createBitmap(originalBitmap.getWidth(), originalBitmap.getHeight(),
    				Bitmap.Config.ARGB_8888);
    		Canvas canvas = new Canvas(whiteBgBitmap);
    		canvas.drawColor(Color.WHITE);
    		canvas.drawBitmap(originalBitmap, 0, 0, null);
    		return whiteBgBitmap;
    	}
    
    	public void setSignatureBitmap(Bitmap signature) {
    		clear();
    		ensureSignatureBitmap();
    
    		RectF tempSrc = new RectF();
    		RectF tempDst = new RectF();
    
    		int dWidth = signature.getWidth();
    		int dHeight = signature.getHeight();
    		int vWidth = getWidth();
    		int vHeight = getHeight();
    
    		// Generate the required transform.
    		tempSrc.set(0, 0, dWidth, dHeight);
    		tempDst.set(0, 0, vWidth, vHeight);
    
    		Matrix drawMatrix = new Matrix();
    		drawMatrix.setRectToRect(tempSrc, tempDst, Matrix.ScaleToFit.CENTER);
    
    		Canvas canvas = new Canvas(mSignatureBitmap);
    		canvas.drawBitmap(signature, drawMatrix, null);
    		setIsEmpty(false);
    		invalidate();
    	}
    
    	public Bitmap getTransparentSignatureBitmap() {
    		ensureSignatureBitmap();
    		return mSignatureBitmap;
    	}
    
    	public Bitmap getTransparentSignatureBitmap(boolean trimBlankSpace) {
    
    		if (!trimBlankSpace) {
    			return getTransparentSignatureBitmap();
    		}
    
    		ensureSignatureBitmap();
    
    		int imgHeight = mSignatureBitmap.getHeight();
    		int imgWidth = mSignatureBitmap.getWidth();
    
    		int backgroundColor = Color.TRANSPARENT;
    
    		int xMin = Integer.MAX_VALUE, xMax = Integer.MIN_VALUE, yMin = Integer.MAX_VALUE, yMax = Integer.MIN_VALUE;
    
    		boolean foundPixel = false;
    
    		// Find xMin
    		for (int x = 0; x < imgWidth; x++) {
    			boolean stop = false;
    			for (int y = 0; y < imgHeight; y++) {
    				if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {
    					xMin = x;
    					stop = true;
    					foundPixel = true;
    					break;
    				}
    			}
    			if (stop)
    				break;
    		}
    
    		// Image is empty...
    		if (!foundPixel)
    			return null;
    
    		// Find yMin
    		for (int y = 0; y < imgHeight; y++) {
    			boolean stop = false;
    			for (int x = xMin; x < imgWidth; x++) {
    				if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {
    					yMin = y;
    					stop = true;
    					break;
    				}
    			}
    			if (stop)
    				break;
    		}
    
    		// Find xMax
    		for (int x = imgWidth - 1; x >= xMin; x--) {
    			boolean stop = false;
    			for (int y = yMin; y < imgHeight; y++) {
    				if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {
    					xMax = x;
    					stop = true;
    					break;
    				}
    			}
    			if (stop)
    				break;
    		}
    
    		// Find yMax
    		for (int y = imgHeight - 1; y >= yMin; y--) {
    			boolean stop = false;
    			for (int x = xMin; x <= xMax; x++) {
    				if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {
    					yMax = y;
    					stop = true;
    					break;
    				}
    			}
    			if (stop)
    				break;
    		}
    
    		return Bitmap.createBitmap(mSignatureBitmap, xMin, yMin, xMax - xMin, yMax - yMin);
    	}
    
    	private void addPoint(TimedPoint newPoint) {
    		mPoints.add(newPoint);
    		if (mPoints.size() > 2) {
    			// To reduce the initial lag make it work with 3 mPoints
    			// by copying the first point to the beginning.
    			if (mPoints.size() == 3)
    				mPoints.add(0, mPoints.get(0));
    
    			ControlTimedPoints tmp = calculateCurveControlPoints(mPoints.get(0), mPoints.get(1), mPoints.get(2));
    			TimedPoint c2 = tmp.c2;
    			tmp = calculateCurveControlPoints(mPoints.get(1), mPoints.get(2), mPoints.get(3));
    			TimedPoint c3 = tmp.c1;
    			Bezier curve = new Bezier(mPoints.get(1), c2, c3, mPoints.get(2));
    
    			TimedPoint startPoint = curve.startPoint;
    			TimedPoint endPoint = curve.endPoint;
    
    			float velocity = endPoint.velocityFrom(startPoint);
    			velocity = Float.isNaN(velocity) ? 0.0f : velocity;
    
    			velocity = mVelocityFilterWeight * velocity + (1 - mVelocityFilterWeight) * mLastVelocity;
    
    			// The new width is a function of the velocity. Higher velocities
    			// correspond to thinner strokes.
    			float newWidth = strokeWidth(velocity);
    
    			// The Bezier's width starts out as last curve's final width, and
    			// gradually changes to the stroke width just calculated. The new
    			// width calculation is based on the velocity between the Bezier's
    			// start and end mPoints.
    			addBezier(curve, mLastWidth, newWidth);
    
    			mLastVelocity = velocity;
    			mLastWidth = newWidth;
    
    			// Remove the first element from the list,
    			// so that we always have no more than 4 mPoints in mPoints array.
    			mPoints.remove(0);
    		}
    	}
    
    	private void addBezier(Bezier curve, float startWidth, float endWidth) {
    		ensureSignatureBitmap();
    		float originalWidth = mPaint.getStrokeWidth();
    		float widthDelta = endWidth - startWidth;
    		float drawSteps = (float) Math.floor(curve.length());
    
    		for (int i = 0; i < drawSteps; i++) {
    			// Calculate the Bezier (x, y) coordinate for this step.
    			float t = ((float) i) / drawSteps;
    			float tt = t * t;
    			float ttt = tt * t;
    			float u = 1 - t;
    			float uu = u * u;
    			float uuu = uu * u;
    
    			float x = uuu * curve.startPoint.x;
    			x += 3 * uu * t * curve.control1.x;
    			x += 3 * u * tt * curve.control2.x;
    			x += ttt * curve.endPoint.x;
    
    			float y = uuu * curve.startPoint.y;
    			y += 3 * uu * t * curve.control1.y;
    			y += 3 * u * tt * curve.control2.y;
    			y += ttt * curve.endPoint.y;
    
    			// Set the incremental stroke width and draw.
    			mPaint.setStrokeWidth(startWidth + ttt * widthDelta);
    			mSignatureBitmapCanvas.drawPoint(x, y, mPaint);
    			expandDirtyRect(x, y);
    		}
    
    		mPaint.setStrokeWidth(originalWidth);
    	}
    
    	private ControlTimedPoints calculateCurveControlPoints(TimedPoint s1, TimedPoint s2, TimedPoint s3) {
    		float dx1 = s1.x - s2.x;
    		float dy1 = s1.y - s2.y;
    		float dx2 = s2.x - s3.x;
    		float dy2 = s2.y - s3.y;
    
    		TimedPoint m1 = new TimedPoint((s1.x + s2.x) / 2.0f, (s1.y + s2.y) / 2.0f);
    		TimedPoint m2 = new TimedPoint((s2.x + s3.x) / 2.0f, (s2.y + s3.y) / 2.0f);
    
    		float l1 = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1);
    		float l2 = (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);
    
    		float dxm = (m1.x - m2.x);
    		float dym = (m1.y - m2.y);
    		float k = l2 / (l1 + l2);
    		TimedPoint cm = new TimedPoint(m2.x + dxm * k, m2.y + dym * k);
    
    		float tx = s2.x - cm.x;
    		float ty = s2.y - cm.y;
    
    		return new ControlTimedPoints(new TimedPoint(m1.x + tx, m1.y + ty), new TimedPoint(m2.x + tx, m2.y + ty));
    	}
    
    	private float strokeWidth(float velocity) {
    		return Math.max(mMaxWidth / (velocity + 1), mMinWidth);
    	}
    
    	/**
    	 * Called when replaying history to ensure the dirty region includes all
    	 * mPoints.
    	 * 
    	 * @param historicalX
    	 *            the previous x coordinate.
    	 * @param historicalY
    	 *            the previous y coordinate.
    	 */
    	private void expandDirtyRect(float historicalX, float historicalY) {
    		if (historicalX < mDirtyRect.left) {
    			mDirtyRect.left = historicalX;
    		} else if (historicalX > mDirtyRect.right) {
    			mDirtyRect.right = historicalX;
    		}
    		if (historicalY < mDirtyRect.top) {
    			mDirtyRect.top = historicalY;
    		} else if (historicalY > mDirtyRect.bottom) {
    			mDirtyRect.bottom = historicalY;
    		}
    	}
    
    	/**
    	 * Resets the dirty region when the motion event occurs.
    	 * 
    	 * @param eventX
    	 *            the event x coordinate.
    	 * @param eventY
    	 *            the event y coordinate.
    	 */
    	private void resetDirtyRect(float eventX, float eventY) {
    
    		// The mLastTouchX and mLastTouchY were set when the ACTION_DOWN motion
    		// event occurred.
    		mDirtyRect.left = Math.min(mLastTouchX, eventX);
    		mDirtyRect.right = Math.max(mLastTouchX, eventX);
    		mDirtyRect.top = Math.min(mLastTouchY, eventY);
    		mDirtyRect.bottom = Math.max(mLastTouchY, eventY);
    	}
    
    	private void setIsEmpty(boolean newValue) {
    		mIsEmpty = newValue;
    		if (mOnSignedListener != null) {
    			if (mIsEmpty) {
    				mOnSignedListener.onClear();
    			} else {
    				mOnSignedListener.onSigned();
    			}
    		}
    	}
    
    	private void ensureSignatureBitmap() {
    		if (mSignatureBitmap == null) {
    			mSignatureBitmap = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
    			mSignatureBitmapCanvas = new Canvas(mSignatureBitmap);
    		}
    	}
    
    	private int convertDpToPx(float dp) {
    		return Math.round(dp * (getResources().getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));
    	}
    
    	public interface OnSignedListener {
    		public void onSigned();
    
    		public void onClear();
    	}
    }
    

    Demo源码下载链接

    最后我集成到项目里面的效果图 如上图

    如果大家有其他问题 欢迎加入我的qq群讨论  开发一群:454430053开发二群:537532956







    展开全文
  • H5移动端项目实现手写签名功能 vue实现手写签名

    千次阅读 多人点赞 2021-02-05 21:29:04
    vue 移动端实现手写签名效果,功能很完美,保存时保存为base64格式。 base64转file文件格式 vue中将base64转file文件格式 刚好项目用到此功能,就网上找了一下,清理了无用代码,简单方便,因为项目中多个地方...

    H5移动端项目实现手写签名功能 vue实现手写签名

    vue 移动端实现手写签名效果,功能很完美,保存时保存为base64格式。

    base64转file文件格式 vue中将base64转file文件格式

     

    刚好项目用到此功能,就网上找了一下,清理了无用代码,简单方便,因为项目中多个地方需要使用,所以我将它整理为组件,通过ref和传值控制,下面代码我单独整理出来,可自行封装组件(只支持移动端,不支持pc端)。

    代码中,css自行修改一下宽高,背景之类即可。

    代码如下

    <template>
      <!-- 手写签名组件 -->
      <div class="page sign-page">
        <div class="content">
          <div class="sign-wrap" id="signWrap">
            <canvas id="myCanvas" width="100%" height="100%"></canvas>
          </div>
        </div>
        <div class="con-btn">
          <span class="staging-btn size14" @click="clearArea()">清除签名</span>
          <span class="submit-btn size14" @click="saveSign()">确认签名</span>
        </div>
      </div>
    </template>
    <script>
    export default {
      name: "signature",
      data() {
        return {
          image: "",
          mousePressed: false,
          c: "",
          ctx: "",
          lastX: 0,
          lastY: 0,
        };
      },
      mounted() {
        this.image = "";
        this.mousePressed = false;
        var lastX, lastY;
        this.ctx = document.getElementById("myCanvas").getContext("2d");
        this.c = document.getElementById("myCanvas");
        var signWrap = document.getElementById("signWrap");
        this.c.width = signWrap.clientWidth; // 设置宽度
        this.c.height = signWrap.clientHeight; // 设置高度
        // 监听touchstart事件,touchmove事件,touchend事件等事件
        this.InitThis();
      },
      methods: {
        InitThis() {
          // 触摸屏
          var that = this;
          this.c.addEventListener(
            "touchstart",
            function (event) {
              if (event.targetTouches.length == 1) {
                event.preventDefault(); // 阻止浏览器默认事件,重要
                var touch = event.targetTouches[0];
                this.mousePressed = true;
                that.Draw(
                  touch.pageX - this.offsetLeft,
                  touch.pageY - this.offsetTop,
                  false
                );
              }
            },
            false
          );
          this.c.addEventListener(
            "touchmove",
            function (event) {
              if (event.targetTouches.length == 1) {
                event.preventDefault(); // 阻止浏览器默认事件,重要
                var touch = event.targetTouches[0];
                if (this.mousePressed) {
                  that.Draw(
                    touch.pageX - this.offsetLeft,
                    touch.pageY - this.offsetTop,
                    true
                  );
                }
              }
            },
            false
          );
          this.c.addEventListener(
            "touchend",
            function (event) {
              if (event.targetTouches.length == 1) {
                event.preventDefault(); // 阻止浏览器默认事件,防止手写的时候拖动屏幕,重要
                this.mousePressed = false;
              }
            },
            false
          );
          // 鼠标
          this.c.onmousedown = function (event) {
            this.mousePressed = true;
            that.Draw(
              event.pageX - this.offsetLeft,
              event.pageY - this.offsetTop,
              false
            );
          };
          this.c.onmousemove = function (event) {
            if (this.mousePressed) {
              that.Draw(
                event.pageX - this.offsetLeft,
                event.pageY - this.offsetTop,
                true
              );
            }
          };
          this.c.onmouseup = function (event) {
            this.mousePressed = false;
          };
        },
        Draw(x, y, isDown) {
          if (isDown) {
            this.ctx.beginPath();
            this.ctx.strokeStyle = "#000"; // 颜色
            this.ctx.lineWidth = 3; // 线宽
            this.ctx.lineJoin = "round";
            this.ctx.lineMax = 10; // 设置画笔最大线宽
            this.ctx.lineMin = 3; // 设置画笔最小线宽
            this.ctx.linePressure = 1.2; // 设置画笔笔触压力
            this.ctx.smoothness = 30; // 设置画笔笔触大小变化的平滑度
            this.ctx.moveTo(this.lastX, this.lastY);
            this.ctx.lineTo(x, y);
            this.ctx.closePath();
            this.ctx.stroke();
          }
          this.lastX = x;
          this.lastY = y;
        },
        // 清空画板
        clearArea() {
          this.ctx.setTransform(1, 0, 0, 1, 0, 0);
          this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
        },
        // 提交签名
        saveSign() {
          this.checkEmpty(); // 调用 表单非空验证
        },
        checkEmpty() {
          var c = document.getElementById("myCanvas"); // 获取html的canvas对象,我这个id="myCanvas"
          if (this.isCanvasBlank(c)) {
            alert("请在签名区域签名后再次确认");
            return;
          } else {
            var image = this.c.toDataURL("image/png"); // 得到生成后的签名base64位  url 地址
            console.log(image); // 打印图片base64 url
          }
        },
        // 验证canvas画布是否为空函数
        isCanvasBlank(canvas) {
          var blank = document.createElement("canvas"); // 系统获取一个空canvas对象
          blank.width = canvas.width;
          blank.height = canvas.height;
          return canvas.toDataURL() == blank.toDataURL(); // 比较值相等则为空
        },
      },
    };
    </script>
    <style lang="scss" scoped>
    .page {
      width: 100%;
      .content {
        width: 100%;
        height: 1.7rem;
        background: url(../assets/img/photo_qmq.png) no-repeat;
        background-size: 100% 100%;
        background-position: center center;
        .sign-wrap {
          width: 100%;
          height: 100%;
        }
      }
      .con-btn {
        width: 100%;
        display: flex;
        align-content: center;
        justify-content: space-between;
        opacity: 0.75;
        span {
          font-size: 0.14rem;
          width: 100%;
          height: 0.48rem;
          display: flex;
          align-items: center;
          justify-content: center;
        }
        .staging-btn {
          color: #4154ff;
          background: #fff;
        }
        .submit-btn {
          color: #fff;
          background: #4154ff;
        }
      }
    }
    
    </style>

    原文围观地址 http://www.sharedblog.cn/post/217.html

    个人博客http://sharedblog.cn/

    软件下载http://iqzhan.com/

     

    展开全文
  • 在自己笔记本上实现完全的手写功能,将触控板改为手写板,辨字能力90%,很棒。使用方法:打开文本工具,打开手写输入,即可写入。练字练笔,给老用键盘,提笔忘字的人一个好工具
  • 如何使MSN7.0拥有手写功能

    千次阅读 2005-03-18 09:34:00
    有的人装了MSN7.0后没有手写功能,而有的人有。一些网友说可以装了Office2003以后就有了。也有网友说装了日记查看器(就是那个微软的journal viewer)就可以了。可是有必要为了一个手写功能而装那么大的OFFice吗?而且...

    有的人装了MSN7.0后没有手写功能,而有的人有。

    一些网友说可以装了Office2003以后就有了。

    也有网友说装了日记查看器(就是那个微软的journal viewer)就可以了。

    可是有必要为了一个手写功能而装那么大的OFFice吗?
    而且现在日记查看器要在微软下载的话需要验证正版,弄得我都不敢从微软网站下东西了。

    经过本人研究发现,MSN7.0所带的手写功能的实现,与3个文件有关INKOBJ.DLL 、TPCPS.DLL、WISPTIS.EXE。另外,2000系统下要使用的话,需要GDI+的支持,也就是再多一个文件GDIplus.dll。

    INKOBJ.DLL 、TPCPS.DLL这两个文件需要用Regsvr32命令注册一下,WISPTIS.EXE是自注册的,也就是运行一下就注册好了。

    以上几个文件的取得,可以从网上搜,也可以让好友传给你,因为空间问题我这里就不提供了。

    展开全文
  • 说明: 本次的任务是将等待下载的文件放在非Web目录下(在web.xml中配置),使客户端无法直接访问待下载 文件。然后通过一个servlet进行...若果待下载的文件是jpg,则直接在浏览器显示该图片,还有一个功能就是列出web.x
  • 1、文件上传下载功能; 2、文件转换功能,将word文件转换成可手写文件; 2、像传统手写一样全文手写批注功能,并能够保留批注痕迹; 3、word在线编辑,保留每个人修改痕迹,并以不同颜色区分; 4、手写意见的功能,...
  • iOS 手写汉字,文字转语音,专注力训练功能实现 下载地址https://apps.apple.com/cn/app/%E9%9A%8F%E8%AE%B0%E5%AD%A6%E6%B1%89%E5%AD%97/id1556386282 开放源码
  • 在完成此功能过程中,在线签合同时,签名图片自动生成并展示在页面,存到数据库的为base64编码数据,在下载合同到本地的时候遇到的问题,签名图片显示乱码,在线解析数据库里存的base64编码的数据库可以显示出图片,...
  • ,这个动画为大家展示了MSN手写功能的一些设置,分别是:手写笔刷粗细、橡皮尺寸、后退、恢复、手写板颜色、网格等。      动画演示:MSN8.5手写设置   ·选择手写文本的大小(设置手写笔划粗细)  ...
  • 可以说jSignature是一个H5基于canvas画布得一个插件可以用于手机,浏览器进行手写签名功能实现啦 Jsignature使用效果展示 本插件最新版是支持IE8的,测试请放在本地服务器上测试,不要直接打开,因为一些js的...
  • 手写一个微型下载资源网站【Java实现用户注册、登陆、下载功能】 一、技术栈 语言:Java Web:html + css + js +bootstrap 数据库:MySQL8.2 服务器:Tomcat 开发环境:JDK–1.8 、Servlet–3.0 、ntelliJ IDEA、...
  • 手写springboot

    千次阅读 2018-09-23 15:22:40
    手写 Springboot,我们先要了解 Springboot 完成了哪些核心功能: 1)SpringBoot 能够快速整合第三方框架,原理:Maven 继承依赖关系 2)SpringBoot 无需配置本地服务器,原理:内嵌 tomcat-embed-core 3)...
  • 手写连笔王217336驱动是一款的手写板驱动软件。可以帮助用户解决手写板设备不能正常输入、启动等问题。这个驱动程序支持多个产品...手写连笔王217336驱动功能介绍基本功能:·可提供语音校正·可显示五彩,欢迎下载体验
  • 友基手写板驱动是一款比较常用的手写板驱动工具,可快速连接手写板工具,手写参数设置调节绘图信息传输导入等多种功能。快下载体验吧!友基手写板驱动功能1.鼠标功能:压感笔可以完全取代鼠标以控制计算机屏幕上的...
  • 千彩手写识别系统是一款手写板驱动程序,用户通过安装该驱动程序,就可以轻易转换成全屏幕输入,这款手写版驱动程序功能十分强大,感兴趣的朋友欢迎下载使用。千彩手写识别系统功能介绍˙广阔手写区域相较过去的手写...
  • 清华同方手写板万能驱动是一款多功能的驱动程序,手写功能和键盘类似,支持符号、图形、文字等内容的输入,该驱动可以帮助更好地连接电脑和手写板,使用更贴心,有需要者欢迎下载!清华同方手写系统介绍清华同方...
  • 银光小蒙恬手写笔特色功能简介:繁简合一辨识核心可辨认繁简体中文23000多字、香港4941字HKSCS2001、英数字、符号、日文平假名及片假名。人工智慧辨认核心可以学习个人书写笔迹,成为个人化的手写系统,越写越聪明。...
  • 手写TomCat服务器

    2021-04-16 12:42:49
    在工作中,我们经常会把写好的代码打包放在Tomcat里并启动,然后在浏览器里就能愉快的调用我们写的代码来实现相应的功能了,那么Tomcat是如何工作的?   通过手写Tomcat服务器,让学员了解服务器的底层代码,...
  • 大将军连笔王手写板驱动是专为这款手写板打造设计的,有了这款驱动软件,用户就可以轻松解决手写板不能正常写字的问题,...功能特色:惠普电脑促销赠品大礼包里的大将军连笔王手写板TP609的驱动程序,看,欢迎下载体验
  • ziddo紫貂手写板驱动是适用于该手写板使用的一款驱动程序,安装驱动后可将手写板连接电脑,手写板...ziddo紫貂手写板介绍紫貂电脑手写板流畅迅速,软件界面操作简洁明了,功能全面。该版本驱动支持连笔书,欢迎下载体验
  • 清华紫光清风C6500手写板写字驱动是一款转为电脑写字功能打造的驱动程序,方便用户轻松使用电脑写字程序,安装完成之后可以更好的完成电脑功能的使用,需要的用户就下载吧!清华紫光清风C6500手写板写字驱动简介:...
  • 兴泰星御笔手写识别系统即御笔手写板驱动程序,很多用户把光盘丢失了,电脑缺少驱动无法正常使用御笔手写版产品,...使用说明下载解压缩兴泰星御笔手写识别系统根据提示安装完全或定制功能御笔手写板驱动,欢迎下载体验
  • 小编以前在电脑城工作的时候,很多人购买电脑的时候都会购买手写板,主要是那些不会使用电脑键盘输入文字的用户买的,不过随着电脑的普及,应该手写板会慢慢淘汰吧,或者像手机一样,直接面板集成手写功能哦。...
  • 支持汉王小龙女系列的有线和无线手写板。汉王小龙女手写板虽然小,但是他拥有最新自由手写识别技术,不需要学习适应就可以用工整、...同时还支持多颜色笔触以及强大的记忆功能。汉王笔有线小龙女 驱动光盘,欢迎下载体验
  • 前言之前项目中有关app的现在和更新相关工具类一直用的是Android系统下载管理DownloadManager功能。如果随着Android系统的不断提升再加上Android开源性 手机厂家 对此作恶部分改动。导致一些系统自带的工具类出现...
  • 网页手写留痕插件

    2008-03-24 13:50:27
    网页手写留痕插件, 1.手写留痕的基本功能,包括:手写、修改笔画颜色、线宽、Undo、Redo; 2.为支持b/s系统,提供了支持留痕的上传、下载功能的接口;
  • 汉王5012HD驱动能有效帮助用户更好的使用该手写板,能使手写板更好的与电脑...汉王5012HD手写板介绍汉王5012HD是一款多功能绘图板,安装有高分辨率屏幕,不仅具有绘画功能,还可以接驳电脑作为第二个显示,欢迎下载体验
  • 联想天骄一代手写板驱动是由联想官方推出的一款手写板驱动软件,是专门用于适配这个型号的手写板的,有了这款驱动软件,就可以帮助用户解决电脑与手写板之间连接不正常的问题,欢迎大家下载使用。联想天骄一代驱动...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,513
精华内容 9,805
关键字:

下载手写功能