// ==============================================================================
  public final int[] renderGlyph(
      char glyph, Paint paint, android.graphics.Matrix matrix, Rect bounds) {
    Path p = new Path();
    paint.getTextPath(String.valueOf(glyph), 0, 1, 0.0f, 0.0f, p);

    RectF boundsF = new RectF();
    p.computeBounds(boundsF, true);
    matrix.mapRect(boundsF);

    boundsF.roundOut(bounds);
    bounds.left--;
    bounds.right++;

    final int w = bounds.width();
    final int h = bounds.height();

    Bitmap bm = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);

    Canvas c = new Canvas(bm);
    matrix.postTranslate(-bounds.left, -bounds.top);
    c.setMatrix(matrix);
    c.drawPath(p, paint);

    final int sizeNeeded = w * h;
    if (cachedRenderArray.length < sizeNeeded) cachedRenderArray = new int[sizeNeeded];

    bm.getPixels(cachedRenderArray, 0, w, 0, 0, w, h);
    bm.recycle();
    return cachedRenderArray;
  }
Пример #2
0
    public void onDraw(Canvas canvas) {
      // 검정색 배경으로 지운다. 빈 화면이면 지우기만 하고 리턴
      canvas.drawColor(Color.BLACK);
      if (status == BLANK) {
        return;
      }

      // 도형 목록을 순회하면서 도형 정보대로 출력한다.
      int idx;
      for (idx = 0; idx < arShape.size(); idx++) {
        Paint Pnt = new Paint();
        Pnt.setAntiAlias(true);
        Pnt.setColor(arShape.get(idx).color);

        Rect rt = arShape.get(idx).rt;
        switch (arShape.get(idx).what) {
          case Shape.RECT:
            canvas.drawRect(rt, Pnt);
            break;
          case Shape.CIRCLE:
            canvas.drawCircle(
                rt.left + rt.width() / 2, rt.top + rt.height() / 2, rt.width() / 2, Pnt);
            break;
          case Shape.TRIANGLE:
            Path path = new Path();
            path.moveTo(rt.left + rt.width() / 2, rt.top);
            path.lineTo(rt.left, rt.bottom);
            path.lineTo(rt.right, rt.bottom);
            canvas.drawPath(path, Pnt);
            break;
        }
      }
    }
Пример #3
0
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    // Draw the shadow
    canvas.drawOval(mShadowBounds, mShadowPaint);

    // TODO 0 Slices
    String label = "";
    //        if(mData.size() > 0)
    label = mData.get(mCurrentItem).mLabel;
    //        else
    //        	label = NO_DATA_SLICE;

    // Draw the label text
    if (getShowText()) {
      canvas.drawText(label, mTextX, mTextY, mTextPaint);
    }

    // If the API level is less than 11, we can't rely on the view animation system to
    // do the scrolling animation. Need to tick it here and call postInvalidate() until the
    // scrolling is done.
    if (Build.VERSION.SDK_INT < 11) {
      tickScrollAnimation();
      if (!mScroller.isFinished()) {
        postInvalidate();
      }
    }
  }
Пример #4
0
 void myDraw() {
   float width, height;
   width = getMeasuredWidth();
   height = getMeasuredHeight();
   canvas = holder.lockCanvas();
   canvas.drawColor(Color.GREEN);
   canvas.drawPath(path, paint);
   holder.unlockCanvasAndPost(canvas);
 }
Пример #5
0
    public void onDraw(Canvas canvas) {
      canvas.drawColor(Color.LTGRAY);
      Paint Pnt = new Paint();
      String str = "Custom Font Test";

      Pnt.setAntiAlias(true);
      Pnt.setTypeface(mFont);
      Pnt.setTextSize(30);
      canvas.drawText(str, 10, 40, Pnt);
    }
Пример #6
0
  @Override
  protected void dispatchDraw(Canvas canvas) {
    if (showcaseX < 0 || showcaseY < 0 || isRedundant) {
      super.dispatchDraw(canvas);
      return;
    }

    // Draw the semi-transparent background
    canvas.drawColor(backColor);

    // Draw to the scale specified
    Matrix mm = new Matrix();
    mm.postScale(scaleMultiplier, scaleMultiplier, showcaseX, showcaseY);
    canvas.setMatrix(mm);

    // Erase the area for the ring
    canvas.drawCircle(showcaseX, showcaseY, showcaseRadius, mEraser);

    boolean recalculateText = makeVoidedRect() || mAlteredText;
    mAlteredText = false;

    showcase.setBounds(voidedArea);
    showcase.draw(canvas);

    canvas.setMatrix(new Matrix());

    if (!TextUtils.isEmpty(mTitleText) || !TextUtils.isEmpty(mSubText)) {
      if (recalculateText)
        mBestTextPosition = getBestTextPosition(canvas.getWidth(), canvas.getHeight());

      if (!TextUtils.isEmpty(mTitleText)) {
        // TODO: use a dynamic detail layout
        canvas.drawText(mTitleText, mBestTextPosition[0], mBestTextPosition[1], mPaintTitle);
      }

      if (!TextUtils.isEmpty(mSubText)) {
        canvas.save();
        if (recalculateText)
          mDynamicDetailLayout =
              new DynamicLayout(
                  mSubText,
                  mPaintDetail,
                  ((Number) mBestTextPosition[2]).intValue(),
                  Layout.Alignment.ALIGN_NORMAL,
                  1.2f,
                  1.0f,
                  true);
        canvas.translate(mBestTextPosition[0], mBestTextPosition[1] + 12 * metricScale);
        mDynamicDetailLayout.draw(canvas);
        canvas.restore();
      }
    }

    super.dispatchDraw(canvas);
  }
Пример #7
0
 /**
  * ************************************************************** put text in figure coordinates
  * (0,0) is bottom left side. **************************************************************
  */
 private void textFigure(String txt, float x, float y, float deg, Canvas canvas) {
   mPlotPaint.setStrokeWidth(0);
   if (deg != 0) {
     canvas.save();
     canvas.rotate(deg, x, y);
   }
   canvas.drawText(txt, x, y, mPlotPaint);
   if (deg != 0) {
     canvas.restore();
   }
 }
Пример #8
0
 /**
  * 画左右侧的边界区域(将超出的chart图形覆盖)
  *
  * @param canvas
  */
 private void drawLimitRect(Canvas canvas) {
   Paint paint = new Paint();
   paint.setColor(backColor);
   paint.setStyle(Style.FILL);
   canvas.drawRect(0, 0, leftPadding + yTextWidth, height - bottomPadding, paint);
   canvas.drawRect(width - rightPadding, 0, width, height - bottomPadding, paint);
 }
Пример #9
0
  private void drawFooter(Canvas canvas) {
    final ZLView view = ZLApplication.Instance().getCurrentView();
    final ZLView.FooterArea footer = view.getFooterArea();

    if (footer == null) {
      myFooterBitmap = null;
      return;
    }

    if (myFooterBitmap != null
        && (myFooterBitmap.getWidth() != getWidth()
            || myFooterBitmap.getHeight() != footer.getHeight())) {
      myFooterBitmap = null;
    }
    if (myFooterBitmap == null) {
      myFooterBitmap = Bitmap.createBitmap(getWidth(), footer.getHeight(), Bitmap.Config.RGB_565);
    }
    final ZLAndroidPaintContext context =
        new ZLAndroidPaintContext(
            new Canvas(myFooterBitmap),
            getWidth(),
            footer.getHeight(),
            view.isScrollbarShown() ? getVerticalScrollbarWidth() : 0);
    footer.paint(context);
    canvas.drawBitmap(myFooterBitmap, 0, getHeight() - footer.getHeight(), myPaint);
  }
Пример #10
0
  /**
   * 画整体chart图
   *
   * @param translatX chart图偏移量
   */
  public void refreshChart(int translatX) {
    synchronized (holder) {
      translationChart(translatX);

      if (holder != null) {
        Canvas canvas = holder.lockCanvas();
        if (canvas != null) {
          canvas.drawColor(backColor);
          drawGridLine(canvas);
          drawChartLine(canvas);
          drawLimitRect(canvas);
          drawAxesLine(canvas);
          drawYValueText(canvas);
          holder.unlockCanvasAndPost(canvas);
        }
      }
    }
  }
Пример #11
0
  public void mDraw() {

    mCanvas = mHolder.lockCanvas(); // 获得画布对象,开始对画布画画

    mCanvas.drawColor(++i); // 设置画布颜色为黑色

    canvasMethod(mCanvas); // 调用自定义的方法,主要是在传进去的画布对象上画画

    mHolder.unlockCanvasAndPost(mCanvas); // 把画布显示在屏幕上
  }
Пример #12
0
 /**
  * 画X,Y轴和边框
  *
  * @param canvas
  */
 private void drawAxesLine(Canvas canvas) {
   XYpaint = new Paint();
   XYpaint.setColor(axesLineColor);
   XYpaint.setAntiAlias(true);
   XYpaint.setStyle(Style.FILL_AND_STROKE);
   XYpaint.setStrokeWidth(chartFrameLineSize);
   // 左侧Y轴
   canvas.drawLine(
       leftPadding + yTextWidth,
       topPadding + topTextHeight,
       leftPadding + yTextWidth,
       height - bottomPadding - xTextHeight,
       XYpaint);
   // 三角箭头
   Path yTriangle = new Path();
   yTriangle.moveTo(leftPadding + yTextWidth - 10, topPadding + topTextHeight);
   yTriangle.lineTo(leftPadding + yTextWidth, topPadding + topTextHeight - 20);
   yTriangle.lineTo(leftPadding + yTextWidth + 10, topPadding + topTextHeight);
   yTriangle.close();
   canvas.drawPath(yTriangle, XYpaint);
   // 下方X轴
   canvas.drawLine(
       leftPadding + yTextWidth,
       height - bottomPadding - xTextHeight,
       width - rightPadding,
       height - bottomPadding - xTextHeight,
       XYpaint);
   // 三角箭头
   Path xTriangle = new Path();
   xTriangle.moveTo(width - rightPadding, height - bottomPadding - xTextHeight + 10);
   xTriangle.lineTo(width - rightPadding + 15, height - bottomPadding - xTextHeight);
   xTriangle.lineTo(width - rightPadding, height - bottomPadding - xTextHeight - 10);
   xTriangle.close();
   canvas.drawPath(xTriangle, XYpaint);
   // 上方封顶
   // canvas.drawLine(leftPadding + xTextHeight, topPadding + topTextHeight, width - rightPadding,
   // topPadding + topTextHeight, XYpaint);
   // 右侧封边
   // canvas.drawLine(width - rightPadding, topPadding + topTextHeight, width - rightPadding,
   // height - bottomPadding - xTextHeight, XYpaint);
 }
Пример #13
0
 /**
  * Y周的刻度值
  *
  * @param canvas
  */
 private void drawYValueText(Canvas canvas) {
   Paint paint = new Paint();
   paint.setColor(axesLineColor);
   paint.setAntiAlias(true);
   paint.setSubpixelText(true);
   paint.setTypeface(Typeface.MONOSPACE);
   paint.setTextSize(leftTextSize);
   paint.setTextAlign(Align.RIGHT);
   /*int yHeight = height - topPadding - bottomPadding - topTextHeight;
         int spaceLength = yHeight / yNum;
   int spaceValue = (yMaxValue - yMinValue) / yNum;
   for (int i = 0; i < 6; i++) {
   	canvas.drawText((yMinValue + spaceValue * i) + "", leftPadding + yTextWidth - 5, height - bottomPadding - yTextWidth - (spaceLength * i),
   			paint);
   }*/
   canvas.drawText(
       "优秀",
       leftPadding + (yTextWidth + leftTextSize) / 2,
       height - bottomPadding - xTextHeight - (spaceYLength * 5) + leftTextSize / 2,
       paint);
   canvas.drawText(
       "良好",
       leftPadding + (yTextWidth + leftTextSize) / 2,
       height - bottomPadding - xTextHeight - (spaceYLength * 4) + leftTextSize / 2,
       paint);
   canvas.drawText(
       "一般",
       leftPadding + (yTextWidth + leftTextSize) / 2,
       height - bottomPadding - xTextHeight - (spaceYLength * 3) + leftTextSize / 2,
       paint);
   canvas.drawText(
       "差劲",
       leftPadding + (yTextWidth + leftTextSize) / 2,
       height - bottomPadding - xTextHeight - (spaceYLength * 2) + leftTextSize / 2,
       paint);
   canvas.drawText(
       "恶劣",
       leftPadding + (yTextWidth + leftTextSize) / 2,
       height - bottomPadding - xTextHeight - (spaceYLength * 1) + leftTextSize / 2,
       paint);
 }
Пример #14
0
  protected void onDraw(Canvas cs) {
    super.onDraw(cs);

    // 描画方法の設定
    Paint p = new Paint();
    p.setColor(Color.BLACK);
    p.setStyle(Paint.Style.FILL);
    p.setStrokeWidth(8);

    // 円の描画
    cs.drawCircle(x, y, 50, p);
  }
Пример #15
0
  // 그리기
  void Draw(Canvas canvas) {
    Paint pnt = new Paint();
    pnt.setAntiAlias(true);

    int r;
    int alpha;

    for (r = rad, alpha = 1; r > 4; r--, alpha += 5) {
      pnt.setColor(Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color)));
      canvas.drawCircle(x, y, r, pnt);
    }
  }
Пример #16
0
    @Override
    protected void onDraw(Canvas canvas) {
      super.onDraw(canvas);

      if (Build.VERSION.SDK_INT < 11) {
        mTransform.set(canvas.getMatrix());
        mTransform.preRotate(mRotation, mPivot.x, mPivot.y);
        canvas.setMatrix(mTransform);
      }

      for (Item it : mData) {
        mPiePaint.setShader(it.mItemShader);
        cSlicePaint.setShader(it.cSliceShader);
        //                Log.d(TAG, "mBounds: " +mBounds);
        canvas.drawArc(mBounds, 360 - it.mEndAngle, it.mEndAngle - it.mStartAngle, true, mPiePaint);
        Log.d(TAG, "Item Being Built: " + it.mLabel);
        Log.d(TAG, "RectF: " + it.cSliceBounds);
        Log.d(TAG, "StartAngle> " + it.mStartAngle + " EndAngle> " + it.mEndAngle);
        canvas.drawArc(
            it.cSliceBounds, 360 - it.mEndAngle, it.mEndAngle - it.mStartAngle, true, cSlicePaint);
        //                Log.d(TAG, "StartAngle> "+it.mStartAngle+" EndAngle> "+it.mEndAngle);
      }
    }
 @Override
 protected void onDraw(Canvas canvas) {
   super.onDraw(canvas);
   if (paint == null) {
     paint = new Paint();
     luar =
         new LinearGradient(
             0.f, 0.f, 0.f, this.getMeasuredHeight(), 0xffffffff, 0xff000000, TileMode.CLAMP);
   }
   int rgb = Color.HSVToColor(color);
   Shader dalam =
       new LinearGradient(0.f, 0.f, this.getMeasuredWidth(), 0.f, 0xffffffff, rgb, TileMode.CLAMP);
   ComposeShader shader = new ComposeShader(luar, dalam, PorterDuff.Mode.MULTIPLY);
   paint.setShader(shader);
   canvas.drawRect(0.f, 0.f, this.getMeasuredWidth(), this.getMeasuredHeight(), paint);
 }
Пример #18
0
 /**
  * 背景画网格的横线
  *
  * @param canvas
  */
 private void drawGridLine(Canvas canvas) {
   Paint paint = new Paint();
   paint.setColor(gridLineColor);
   paint.setAntiAlias(true);
   paint.setStyle(Style.STROKE);
   paint.setStrokeWidth(gridLineSize);
   paint.setPathEffect(new DashPathEffect(new float[] {10, 20}, 0));
   for (int i = 1; i <= yNum; i++) {
     // 画网格的横线
     canvas.drawLine(
         leftPadding + yTextWidth,
         height - bottomPadding - xTextHeight - (spaceYLength * i),
         width - rightPadding,
         height - bottomPadding - xTextHeight - (spaceYLength * i),
         paint);
   }
 }
Пример #19
0
 private void onDrawStatic(final Canvas canvas) {
   myBitmapManager.setSize(getWidth(), getMainAreaHeight());
   canvas.drawBitmap(myBitmapManager.getBitmap(ZLView.PageIndex.current), 0, 0, myPaint);
   drawFooter(canvas);
   new Thread() {
     @Override
     public void run() {
       final ZLView view = ZLApplication.Instance().getCurrentView();
       final ZLAndroidPaintContext context =
           new ZLAndroidPaintContext(
               canvas,
               getWidth(),
               getMainAreaHeight(),
               view.isScrollbarShown() ? getVerticalScrollbarWidth() : 0);
       view.preparePage(context, ZLView.PageIndex.next);
     }
   }.start();
 }
Пример #20
0
 public void onDraw(Canvas canvas) {
   canvas.drawColor(Color.LTGRAY);
   Paint Pnt = new Paint();
   int y = 1;
   Pnt.setAntiAlias(true);
   Pnt.setTextSize(30);
   Pnt.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.NORMAL));
   canvas.drawText("Font:Default", 10, y++ * 40, Pnt);
   Pnt.setTypeface(Typeface.create(Typeface.DEFAULT_BOLD, Typeface.NORMAL));
   canvas.drawText("Font:Default Bold", 10, y++ * 40, Pnt);
   Pnt.setTypeface(Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL));
   canvas.drawText("Font:Monospace", 10, y++ * 40, Pnt);
   Pnt.setTypeface(Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL));
   canvas.drawText("Font:Sans Serif", 10, y++ * 40, Pnt);
   Pnt.setTypeface(Typeface.create(Typeface.SERIF, Typeface.NORMAL));
   canvas.drawText("Font:Serif", 10, y++ * 40, Pnt);
 }
Пример #21
0
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    // draw border
    mPlotPaint.setStyle(Paint.Style.STROKE);
    mPlotPaint.setColor(Color.BLACK);
    canvas.drawRect(mPlotBounds, mPlotPaint);
    // draw grid
    mPlotPaint.setColor(gridColor);
    // x grid
    if (xTicks != null) {
      for (float tick : xTicks) {
        int x = calcX(tick);
        canvas.drawLine(x, mPlotBounds.bottom, x, mPlotBounds.top, mPlotPaint);
      }
    }
    if (yTicks != null) {
      for (float tick : yTicks) {
        int y = calcY(tick);
        canvas.drawLine(mPlotBounds.left, y, mPlotBounds.right, y, mPlotPaint);
      }
    }
    /* *************************
     *  draw the data
     ***************************/
    for (Seria s : mData) {
      stroke(s, canvas);
    }

    // draw rectangles that hide out of bounds lines
    mPlotPaint.setStyle(Style.FILL);
    mPlotPaint.setColor(Color.WHITE);
    // left
    canvas.drawRect(0, 0, mPlotBounds.left, this.getBottom(), mPlotPaint);
    // bottom
    canvas.drawRect(0, mPlotBounds.bottom + 1, this.getRight(), this.getBottom(), mPlotPaint);
    // right
    canvas.drawRect(mPlotBounds.right + 1, 0, this.getRight(), this.getBottom(), mPlotPaint);
    // top
    canvas.drawRect(0, 0, this.getRight(), mPlotBounds.top, mPlotPaint);

    // x ticks
    mPlotPaint.setStyle(Paint.Style.STROKE);
    mPlotPaint.setTextAlign(Align.CENTER);
    mPlotPaint.setTextSize(xTickTextHeight);
    mPlotPaint.setColor(xTickColor);
    if (xTicks != null) {
      for (float tick : xTicks) {
        textFigure(
            xTickFormat.format(tick).toString(),
            calcX(tick),
            mPlotBounds.bottom + xTickTextHeight,
            canvas);
      }
    }
    mPlotPaint.setTextSize(labelTextHeight);
    mPlotPaint.setTextAlign(Align.RIGHT);
    if (labelX != null) {
      textFigure(labelX, mPlotBounds.right, mPlotBounds.bottom + axisXSpacing, canvas);
    }

    // y ticks
    mPlotPaint.setTextAlign(Align.CENTER);
    mPlotPaint.setTextSize(yTickTextHeight);
    mPlotPaint.setColor(yTickColor);
    if (yTicks != null) {
      for (float tick : yTicks) {
        textFigure(
            yTickFormat.format(tick).toString(),
            mPlotBounds.left - yTickTextHeight,
            calcY(tick),
            90,
            canvas);
      }
    }
    mPlotPaint.setTextSize(labelTextHeight);
    mPlotPaint.setTextAlign(Align.RIGHT);
    if (labelX != null) {
      textFigure(labelX, mPlotBounds.right, mPlotBounds.bottom + axisXSpacing, canvas);
    }
    mPlotPaint.setTextAlign(Align.LEFT);
    if (labelY != null) {
      textFigure(labelY, mPlotBounds.left - axisYSpacing, mPlotBounds.top, 90, canvas);
    }
  }
  @Override
  protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
    final boolean ret;

    final Integer row = (Integer) child.getTag(R.id.tag_row);
    final Integer column = (Integer) child.getTag(R.id.tag_column);
    // row == null => Shadow view
    if (row == null || (row == -1 && column == -1)) {
      ret = super.drawChild(canvas, child, drawingTime);
    } else {
      canvas.save();
      if (row == -1) {
        canvas.clipRect(widths[0], 0, canvas.getWidth(), canvas.getHeight());
      } else if (column == -1) {
        canvas.clipRect(0, heights[0], canvas.getWidth(), canvas.getHeight());
      } else {
        canvas.clipRect(widths[0], heights[0], canvas.getWidth(), canvas.getHeight());
      }

      ret = super.drawChild(canvas, child, drawingTime);
      canvas.restore();
    }
    return ret;
  }
Пример #23
0
  /**
   * 自定义的方法,简单绘制一些基本图形
   *
   * @param mCanvas 把图形画在mCanvas上
   */
  public void canvasMethod(Canvas mCanvas) {

    // 创建对应坐标的矩形区域
    RectF mArc = new RectF(mX, mY - 70, mX + 50, mY - 20);
    // 画填充弧,在矩形区域内,从弧的最右边开始,画270度,然后再通过连接圆心来填充
    mCanvas.drawArc(mArc, 0, 270, true, mPaint);

    // 获得icon的Bitmap对象
    Bitmap mBitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
    // 画图片
    mCanvas.drawBitmap(mBitmap, mX, mY, mPaint);

    // 画圆,(x轴,y轴,半径,画笔)
    mCanvas.drawCircle(mX + 10, mY + 60, 10, mPaint);

    // 画一条线,(起点横坐标,起点纵坐标,终点横坐标,终点纵坐标,画笔)
    mCanvas.drawLine(mX, mY + 75, mX + 20, mY + 75, mPaint);
    // 画多条线,(坐标数组,画笔)坐标数组里每四个值构成一条线
    mCanvas.drawLines(
        new float[] {mX + 50, mY + 45, mX + 50, mY + 75, mX + 60, mY + 45, mX + 60, mY + 75},
        mPaint);

    // 创建对应矩形区域
    RectF mOval = new RectF(mX, mY + 80, mX + 60, mY + 110);
    // 画椭圆
    mCanvas.drawOval(mOval, mPaint);

    /*
     * Paint qPaint = new Paint(); qPaint.setColor(Color.RED);
     * mCanvas.drawPaint(qPaint);
     */

    // 重置Path里的所有路径
    mPath.reset();
    // 设置Path的起点
    mPath.moveTo(mX, mY + 120);
    // 第二个点
    mPath.lineTo(screenW - 10, mY + 120);
    // 第三个点
    mPath.lineTo(screenW - 10, mY + 150);
    // 画出路径,这里画的是三角形
    mCanvas.drawPath(mPath, mPaint);

    // 重置Path里的所有路径
    qPath.reset();
    // 设置Path的起点
    qPath.moveTo(qStartX, qStartY);
    // 设置贝塞尔曲线的控制点坐标和终点坐标
    qPath.quadTo(qControlX, qCOntrolY, qEndX, qEndY);
    // 画出贝塞尔曲线
    mCanvas.drawPath(qPath, qPaint);

    // 画点
    mCanvas.drawPoint(mX, mY + 155, qPaint);
    // 画多个点,坐标数组每两个值代表一个点的坐标
    mCanvas.drawPoints(new float[] {mX, mY + 160, mX + 5, mY + 160, mX + 5, mY + 160}, qPaint);

    // 画矩形
    mCanvas.drawRect(mX, mY + 170, mX + 100, mY + 220, mPaint);

    // 设置矩形区域
    RectF mRect = new RectF(mX, mY + 230, mX + 100, mY + 260);
    // 画圆角矩形,这个方法的第二第三个参数在后面有图讲解
    mCanvas.drawRoundRect(mRect, 10, 10, mPaint);

    // 画文本
    mCanvas.drawText("drawText", mX, mY + 290, mPaint);
    // 画文本,数组里每两个值代表文本的一个字符的坐标,数组的坐标可以比字符串里的字符多,但不可以少
    mCanvas.drawPosText(
        "哈哈你好",
        new float[] {mX, mY + 310, mX + 20, mY + 310, mX + 40, mY + 310, mX + 60, mY + 310},
        mPaint);

    // 重置Path
    tPath.reset();
    // 添加一个圆形路径,坐标,半径,方向(顺时针还是逆时针)
    tPath.addCircle(mX + 10, mY + 340, 10, Path.Direction.CW);
    // 画出路径
    mCanvas.drawPath(tPath, qPaint);
    // 把文本画在路径上,但不会画出路径
    mCanvas.drawTextOnPath("draw", tPath, 30, 0, mPaint);
  }
Пример #24
0
  /**
   * 画折线图,网格竖线,X坐标值
   *
   * @param canvas
   */
  private void drawChartLine(Canvas canvas) {
    Paint paintChart = new Paint();
    paintChart.setColor(chartLineColor);
    paintChart.setAntiAlias(true);
    paintChart.setStyle(Style.STROKE);
    paintChart.setStrokeWidth(chartLineSize);

    Paint paintGrid = new Paint();
    paintGrid.setColor(gridLineColor);
    paintGrid.setAntiAlias(true);
    paintGrid.setStyle(Style.STROKE);
    paintGrid.setStrokeWidth(gridLineSize);

    Paint paintTopText = new Paint();
    paintTopText.setColor(axesLineColor);
    paintTopText.setAntiAlias(true);
    paintTopText.setSubpixelText(true);
    paintTopText.setTypeface(Typeface.MONOSPACE);
    paintTopText.setTextSize(topTextSize);
    paintTopText.setTextAlign(Align.CENTER);

    Paint paintBottomText = new Paint();
    paintBottomText.setColor(axesLineColor);
    paintBottomText.setAntiAlias(true);
    paintBottomText.setSubpixelText(true);
    paintBottomText.setTypeface(Typeface.MONOSPACE);
    paintBottomText.setTextSize(bottomTextSize);
    paintBottomText.setTextAlign(Align.CENTER);

    Paint paintPoint = new Paint();
    paintPoint.setColor(pointColor);
    paintPoint.setAntiAlias(true);
    paintPoint.setStyle(Style.FILL);

    pressedPaint = new Paint();
    pressedPaint.setColor(pressedColor);
    pressedPaint.setAntiAlias(true);
    pressedPaint.setStyle(Style.FILL);

    Paint paintShape = new Paint();
    paintShape.setStyle(Style.FILL);
    paintShape.setColor(shapeColor);
    paintShape.setAlpha(shapeAlpha);

    if (axesData.size() > 0) {
      for (int i = 0; i < axesData.size(); i++) {
        if (i < axesData.size() - 1) {
          // 画折线
          canvas.drawLine(
              axesData.get(i).X,
              axesData.get(i).Y,
              axesData.get(i + 1).X,
              axesData.get(i + 1).Y,
              paintChart);
          if (isShapeShow) {
            // 画阴影
            Path path = new Path();
            path.moveTo(axesData.get(i).X, height - bottomPadding - xTextHeight);
            path.lineTo(axesData.get(i).X, axesData.get(i).Y + chartLineSize / 2);
            path.lineTo(axesData.get(i + 1).X, axesData.get(i + 1).Y + chartLineSize / 2);
            path.lineTo(axesData.get(i + 1).X, height - bottomPadding - xTextHeight);
            canvas.drawPath(path, paintShape);
          }
        }
        // 画网格竖线
        // canvas.drawLine(axesData.get(i).X, height - bottomPadding - xTextHeight,
        // axesData.get(i).X, topPadding + topTextHeight, paintGrid);
        // 写X轴坐标的刻度值
        if (!TextUtils.isEmpty(axesData.get(i).getxText())) {
          setTextSizeForWidth(
              paintBottomText, spaceXLength - 10, axesData.get(i).getxText()); // 10为相邻日期文字间隔
          canvas.drawText(
              axesData.get(i).getxText(),
              axesData.get(i).X,
              height - bottomPadding - xTextHeight / 2,
              paintBottomText);
        }
        // 写顶部的刻度值
        if (!TextUtils.isEmpty(axesData.get(i).getTopText())) {
          // 取消了顶部隔年显示的数据
          //					canvas.drawText(axesData.get(i).getTopText(), axesData.get(i).X, topPadding,
          // paintTopText);
        }
        // 画数据点
        if (pointBitmap == null) {
          canvas.drawCircle(axesData.get(i).X, axesData.get(i).Y, pointSize + 1, paintChart);
          canvas.drawCircle(axesData.get(i).X, axesData.get(i).Y, pointSize, paintPoint);
        } else {
          Matrix matrix = new Matrix();
          canvas.drawBitmap(pointBitmap, matrix, paintPoint);
        }
      }

      // 画最后一个数据的网格竖线
      // canvas.drawLine(axesData.get(axesData.size() - 1).X, height - bottomPadding - xTextHeight,
      // axesData.get(axesData.size() - 1).X,
      //        topPadding + topTextHeight, paintGrid);
      // 写X轴坐标的最后一个值的刻度值
      /*
       * canvas.drawText(axesData.get(axesData.size() - 1).X + "",
       * axesData.get(axesData.size() - 1).X, height - bottomPadding -
       * xTextHeight / 2, paintBottomText);
       */
      // 写顶部的最后一个刻度值
      // canvas.drawText("2014", axesData.get(axesData.size() - 1).X,
      // topPadding, paintTopText);
      // 画数最后一个据点
      if (pointBitmap == null) {
        // canvas.drawCircle(axesData.get(axesData.size() - 1).X,
        // axesData.get(axesData.size() - 1).Y, pointSize + 1,
        // paintChart);
        // canvas.drawCircle(axesData.get(axesData.size() - 1).X,
        // axesData.get(axesData.size() - 1).Y, pointSize, paintPoint);
      } else {
        Matrix matrix = new Matrix();
        canvas.drawBitmap(pointBitmap, matrix, paintPoint);
      }
    }

    if (currentPressedPoint != null) {
      // canvas.drawCircle(currentPressedPoint.X, currentPressedPoint.Y, pointSize, pressedPaint);
    }
  }
Пример #25
0
 // 화면 그리기
 public void onDraw(Canvas canvas) {
   canvas.drawBitmap(mBack, 0, 0, null);
   for (int idx = 0; idx < arBall.size(); idx++) {
     arBall.get(idx).Draw(canvas);
   }
 }
Пример #26
0
 public void onDraw(Canvas canvas) {
   Paint p = new Paint();
   p.setColor(Color.GREEN);
   canvas.drawCircle(x, y, 16, p);
 }
Пример #27
0
 @Override
 protected void onDraw(Canvas canvas) {
   canvas.drawLine(mTextX, mPointerY, mPointerX, mPointerY, mTextPaint);
   canvas.drawCircle(mPointerX, mPointerY, mPointerRadius, mTextPaint);
 }
Пример #28
0
  private void stroke(Seria s, Canvas canvas) {
    mPlotPaint.setStyle(Paint.Style.STROKE);
    // draw line
    if (s.mWidth > 0) {
      // create the path
      mPath.reset();
      mPath.moveTo(calcX(s.x[0]), calcY(s.y[0]));
      for (int i = 1; i < s.sz(); i++) {
        mPath.lineTo(calcX(s.x[i]), calcY(s.y[i]));
      }
      // draw the path
      mPlotPaint.setColor(s.mColor);
      mPlotPaint.setStrokeWidth(s.mWidth);
      mPlotPaint.setPathEffect(s.mEffect);
      canvas.drawPath(mPath, mPlotPaint);
    }

    // draw images seria
    if (s.bms != null) {
      for (int i = 0; i < s.sz(); i++) {
        Bitmap bm;
        if (s.bms.length > 1) {
          bm = s.bms[i];
        } else {
          bm = s.bms[0];
        }
        float left = calcX(s.x[i]);
        float top = calcY(s.y[i]);
        if (s.hAlign == HALIGN.CENTER) {
          left -= bm.getWidth() / 2;
        } else if (s.hAlign == HALIGN.RIGHT) {
          left -= bm.getWidth();
        }
        if (s.vAlign == VALIGN.CENTER) {
          top -= bm.getHeight() / 2;
        } else if (s.vAlign == VALIGN.BOTTOM) {
          top -= bm.getHeight();
        }
        canvas.drawBitmap(s.bms[i], left, top, mPlotPaint);
      }
    }
    if (s.texts != null) {
      Align align = Align.CENTER;
      switch (s.hAlign) {
        case LEFT:
          align = Align.RIGHT;
        case RIGHT:
          align = Align.LEFT;
      }

      mPlotPaint.setTextAlign(align);
      mPlotPaint.setStrokeWidth(0);
      mPlotPaint.setColor(s.mColor);
      for (int i = 0; i < s.sz(); i++) {
        float x = calcX(s.x[i]);
        float y = calcY(s.y[i]);
        switch (s.vAlign) {
          case TOP:
            y -= mPlotPaint.getTextSize();
          case CENTER:
            y -= 0.5 * mPlotPaint.getTextSize();
        }
        if (s.deg != 0) {
          canvas.save();
          canvas.rotate(s.deg, x, y);
        }
        canvas.drawText(s.texts[i], x, y, mPlotPaint);
        if (s.deg != 0) {
          canvas.restore();
        }
      }
    }
  }
Пример #29
0
    @Override
    protected void onDraw(Canvas canvas) {

      mDrawable.setBounds(mRect);

      float r = 16;

      canvas.save();
      canvas.translate(10, 10);
      mDrawable.setGradientType(GradientDrawable.LINEAR_GRADIENT);
      setCornerRadii(mDrawable, r, r, 0, 0);
      mDrawable.draw(canvas);
      canvas.restore();

      canvas.save();
      canvas.translate(10 + mRect.width() + 10, 10);
      mDrawable.setGradientType(GradientDrawable.RADIAL_GRADIENT);
      setCornerRadii(mDrawable, 0, 0, r, r);
      mDrawable.draw(canvas);
      canvas.restore();

      canvas.translate(0, mRect.height() + 10);

      canvas.save();
      canvas.translate(10, 10);
      mDrawable.setGradientType(GradientDrawable.SWEEP_GRADIENT);
      setCornerRadii(mDrawable, 0, r, r, 0);
      mDrawable.draw(canvas);
      canvas.restore();

      canvas.save();
      canvas.translate(10 + mRect.width() + 10, 10);
      mDrawable.setGradientType(GradientDrawable.LINEAR_GRADIENT);
      setCornerRadii(mDrawable, r, 0, 0, r);
      mDrawable.draw(canvas);
      canvas.restore();

      canvas.translate(0, mRect.height() + 10);

      canvas.save();
      canvas.translate(10, 10);
      mDrawable.setGradientType(GradientDrawable.RADIAL_GRADIENT);
      setCornerRadii(mDrawable, r, 0, r, 0);
      mDrawable.draw(canvas);
      canvas.restore();

      canvas.save();
      canvas.translate(10 + mRect.width() + 10, 10);
      mDrawable.setGradientType(GradientDrawable.SWEEP_GRADIENT);
      setCornerRadii(mDrawable, 0, r, 0, r);
      mDrawable.draw(canvas);
      canvas.restore();
    }
  @Override
  protected void onDraw(Canvas canvas) {
    float ringWidth = textHeight + 4;
    int height = getMeasuredHeight();
    int width = getMeasuredWidth();

    int px = width / 2;
    int py = height / 2;
    Point center = new Point(px, py);

    int radius = Math.min(px, py) - 2;

    RectF boundingBox =
        new RectF(center.x - radius, center.y - radius, center.x + radius, center.y + radius);

    RectF innerBoundingBox =
        new RectF(
            center.x - radius + ringWidth,
            center.y - radius + ringWidth,
            center.x + radius - ringWidth,
            center.y + radius - ringWidth);

    float innerRadius = innerBoundingBox.height() / 2;
    RadialGradient borderGradient =
        new RadialGradient(
            px, py, radius, borderGradientColors, borderGradientPositions, TileMode.CLAMP);

    Paint pgb = new Paint();
    pgb.setShader(borderGradient);

    Path outerRingPath = new Path();
    outerRingPath.addOval(boundingBox, Direction.CW);

    canvas.drawPath(outerRingPath, pgb);
    LinearGradient skyShader =
        new LinearGradient(
            center.x,
            innerBoundingBox.top,
            center.x,
            innerBoundingBox.bottom,
            skyHorizonColorFrom,
            skyHorizonColorTo,
            TileMode.CLAMP);

    Paint skyPaint = new Paint();
    skyPaint.setShader(skyShader);

    LinearGradient groundShader =
        new LinearGradient(
            center.x,
            innerBoundingBox.top,
            center.x,
            innerBoundingBox.bottom,
            groundHorizonColorFrom,
            groundHorizonColorTo,
            TileMode.CLAMP);

    Paint groundPaint = new Paint();
    groundPaint.setShader(groundShader);
    float tiltDegree = pitch;
    while (tiltDegree > 90 || tiltDegree < -90) {
      if (tiltDegree > 90) tiltDegree = -90 + (tiltDegree - 90);
      if (tiltDegree < -90) tiltDegree = 90 - (tiltDegree + 90);
    }

    float rollDegree = roll;
    while (rollDegree > 180 || rollDegree < -180) {
      if (rollDegree > 180) rollDegree = -180 + (rollDegree - 180);
      if (rollDegree < -180) rollDegree = 180 - (rollDegree + 180);
    }
    Path skyPath = new Path();
    skyPath.addArc(innerBoundingBox, -rollDegree, (180 + (2 * rollDegree)));
    canvas.rotate(-tiltDegree, px, py);
    canvas.drawOval(innerBoundingBox, groundPaint);
    canvas.drawPath(skyPath, skyPaint);
    canvas.drawPath(skyPath, markerPaint);
    int markWidth = radius / 3;
    int startX = center.x - markWidth;
    int endX = center.x + markWidth;

    Log.d("PAARV ", "Roll " + String.valueOf(rollDegree));
    Log.d("PAARV ", "Pitch " + String.valueOf(tiltDegree));

    double h = innerRadius * Math.cos(Math.toRadians(90 - tiltDegree));
    double justTiltX = center.x - h;

    float pxPerDegree = (innerBoundingBox.height() / 2) / 45f;
    for (int i = 90; i >= -90; i -= 10) {
      double ypos = justTiltX + i * pxPerDegree;

      if ((ypos < (innerBoundingBox.top + textHeight))
          || (ypos > innerBoundingBox.bottom - textHeight)) continue;

      canvas.drawLine(startX, (float) ypos, endX, (float) ypos, markerPaint);
      int displayPos = (int) (tiltDegree - i);
      String displayString = String.valueOf(displayPos);
      float stringSizeWidth = textPaint.measureText(displayString);
      canvas.drawText(
          displayString, (int) (center.x - stringSizeWidth / 2), (int) (ypos) + 1, textPaint);
    }
    markerPaint.setStrokeWidth(2);
    canvas.drawLine(
        center.x - radius / 2,
        (float) justTiltX,
        center.x + radius / 2,
        (float) justTiltX,
        markerPaint);
    markerPaint.setStrokeWidth(1);

    Path rollArrow = new Path();
    rollArrow.moveTo(center.x - 3, (int) innerBoundingBox.top + 14);
    rollArrow.lineTo(center.x, (int) innerBoundingBox.top + 10);
    rollArrow.moveTo(center.x + 3, innerBoundingBox.top + 14);
    rollArrow.lineTo(center.x, innerBoundingBox.top + 10);
    canvas.drawPath(rollArrow, markerPaint);
    String rollText = String.valueOf(rollDegree);
    double rollTextWidth = textPaint.measureText(rollText);
    canvas.drawText(
        rollText,
        (float) (center.x - rollTextWidth / 2),
        innerBoundingBox.top + textHeight + 2,
        textPaint);
    canvas.restore();

    canvas.save();
    canvas.rotate(180, center.x, center.y);
    for (int i = -180; i < 180; i += 10) {
      if (i % 30 == 0) {
        String rollString = String.valueOf(i * -1);
        float rollStringWidth = textPaint.measureText(rollString);
        PointF rollStringCenter =
            new PointF(center.x - rollStringWidth / 2, innerBoundingBox.top + 1 + textHeight);
        canvas.drawText(rollString, rollStringCenter.x, rollStringCenter.y, textPaint);
      } else {
        canvas.drawLine(
            center.x,
            (int) innerBoundingBox.top,
            center.x,
            (int) innerBoundingBox.top + 5,
            markerPaint);
      }

      canvas.rotate(10, center.x, center.y);
    }
    canvas.restore();
    canvas.save();
    canvas.rotate(-1 * (bearing), px, py);

    double increment = 22.5;

    for (double i = 0; i < 360; i += increment) {
      CompassDirection cd = CompassDirection.values()[(int) (i / 22.5)];
      String headString = cd.toString();

      float headStringWidth = textPaint.measureText(headString);
      PointF headStringCenter =
          new PointF(center.x - headStringWidth / 2, boundingBox.top + 1 + textHeight);

      if (i % increment == 0)
        canvas.drawText(headString, headStringCenter.x, headStringCenter.y, textPaint);
      else
        canvas.drawLine(
            center.x, (int) boundingBox.top, center.x, (int) boundingBox.top + 3, markerPaint);

      canvas.rotate((int) increment, center.x, center.y);
    }
    canvas.restore();
    RadialGradient glassShader =
        new RadialGradient(
            px, py, (int) innerRadius, glassGradientColors, glassGradientPositions, TileMode.CLAMP);
    Paint glassPaint = new Paint();
    glassPaint.setShader(glassShader);

    canvas.drawOval(innerBoundingBox, glassPaint);
    canvas.drawOval(boundingBox, circlePaint);

    circlePaint.setStrokeWidth(2);
    canvas.drawOval(innerBoundingBox, circlePaint);

    canvas.restore();
  }