protected void drawLegend(Canvas canvas, float height, float width) {
    float textSize = paint.getTextSize();
    int spacing = getGraphViewStyle().getLegendSpacing();
    int border = getGraphViewStyle().getLegendBorder();
    int legendWidth = getGraphViewStyle().getLegendWidth();

    int shapeSize = (int) (textSize * 0.8d);
    Log.d("GraphView", "draw legend size: " + paint.getTextSize());

    // rect
    paint.setARGB(180, 100, 100, 100);
    float legendHeight = (shapeSize + spacing) * graphSeries.size() + 2 * border - spacing;
    float lLeft = width - legendWidth - border * 2;
    float lTop;
    switch (legendAlign) {
      case TOP:
        lTop = 0;
        break;
      case MIDDLE:
        lTop = height / 2 - legendHeight / 2;
        break;
      default:
        lTop =
            height
                - GraphViewConfig.BORDER
                - legendHeight
                - getGraphViewStyle().getLegendMarginBottom();
    }
    float lRight = lLeft + legendWidth;
    float lBottom = lTop + legendHeight;
    canvas.drawRoundRect(new RectF(lLeft, lTop, lRight, lBottom), 8, 8, paint);

    for (int i = 0; i < graphSeries.size(); i++) {
      paint.setColor(graphSeries.get(i).style.color);
      canvas.drawRect(
          new RectF(
              lLeft + border,
              lTop + border + (i * (shapeSize + spacing)),
              lLeft + border + shapeSize,
              lTop + border + (i * (shapeSize + spacing)) + shapeSize),
          paint);
      if (graphSeries.get(i).description != null) {
        paint.setColor(Color.WHITE);
        paint.setTextAlign(Align.LEFT);
        canvas.drawText(
            graphSeries.get(i).description,
            lLeft + border + shapeSize + spacing,
            lTop + border + shapeSize + (i * (shapeSize + spacing)),
            paint);
      }
    }
  }
 private void drawTradeMark(Canvas canvas) {
   Rect framingRect = getFramingRect();
   float tradeMarkTop;
   float tradeMarkLeft;
   if (framingRect != null) {
     tradeMarkTop = framingRect.bottom + PAINT.getTextSize() + 10;
     tradeMarkLeft = framingRect.left;
   } else {
     tradeMarkTop = 10;
     tradeMarkLeft = canvas.getHeight() - PAINT.getTextSize() - 10;
   }
   canvas.drawText(TRADE_MARK_TEXT, tradeMarkLeft, tradeMarkTop, PAINT);
 }
Esempio n. 3
0
 void drawTestBox(Canvas cv, RectF r, float rot, String text) {
   cv.save();
   cv.translate(r.centerX(), r.centerY());
   cv.rotate((float) (rot * 180 / Math.PI));
   RectF rs = new RectF(-r.width() / 2, -r.height() / 2, r.width() / 2, r.height() / 2);
   cv.drawRect(rs, paintIcon);
   if (text != null) {
     paintText.setTextSize(paintText.getTextSize() - 4);
     cv.drawText(text, rs.centerX(), rs.centerY(), paintText);
     paintText.setTextSize(paintText.getTextSize() + 4);
   }
   cv.restore();
 }
  @Override
  public void draw(Canvas canvas, MapView mapView, boolean shadow) {
    // Get the map projection to convert lat/long to screen coordinates
    Projection projection = mapView.getProjection();

    Point lPoint = new Point();
    projection.toPixels(locationPoint, lPoint);

    // Draw the overlay
    if (shadow == false) {
      if (friendLocations.size() > 0) {
        Iterator<String> e = friendLocations.keySet().iterator();
        do {
          // Get the name and location of each contact
          String name = e.next();
          Location location = friendLocations.get(name);

          // Convert the lat / long to a Geopoint
          Double latitude = location.getLatitude() * 1E6;
          Double longitude = location.getLongitude() * 1E6;
          GeoPoint geopoint = new GeoPoint(latitude.intValue(), longitude.intValue());

          // Ensure each contact is within 10km
          float dist = location.distanceTo(getLocation());
          if (dist < 10000) {
            Point point = new Point();
            projection.toPixels(geopoint, point);

            // Draw a line connecting the contact to your current location.
            canvas.drawLine(lPoint.x, lPoint.y, point.x, point.y, paint);

            // Draw a marker at the contact's location.
            RectF oval =
                new RectF(
                    point.x - markerRadius,
                    point.y - markerRadius,
                    point.x + markerRadius,
                    point.y + markerRadius);

            canvas.drawOval(oval, backPaint);
            oval.inset(2, 2);
            canvas.drawOval(oval, paint);

            // Draw the contact's name next to their position.
            float textWidth = paint.measureText(name);
            float textHeight = paint.getTextSize();
            RectF textRect =
                new RectF(
                    point.x + markerRadius,
                    point.y - textHeight,
                    point.x + markerRadius + 8 + textWidth,
                    point.y + 4);
            canvas.drawRoundRect(textRect, 3, 3, backPaint);
            canvas.drawText(name, point.x + markerRadius + 4, point.y, paint);
          }
        } while (e.hasNext());
      }
    }
    super.draw(canvas, mapView, shadow);
  }
Esempio n. 5
0
  /**
   * Generates bitmap used for drawing button.
   *
   * @param radius Radius of button in pixels.
   */
  @Override
  void generateBitmap() {
    super.generateBitmap();
    // Size and shape
    buttonShape.setShape(new OvalShape());
    buttonShape.setBounds(
        new Rect(PADDING, PADDING, (int) radius * 2 - PADDING, (int) radius * 2 - PADDING));

    // Create button bitmap and render shape
    buttonBitmap = Bitmap.createBitmap((int) radius * 2, (int) radius * 2, Bitmap.Config.ARGB_4444);
    Canvas handleCanvas = new Canvas(buttonBitmap);
    buttonShape.getPaint().set(parent.fillPaint);
    buttonShape.draw(handleCanvas);

    // Set text style
    textPaint.setStyle(Paint.Style.FILL);
    textPaint.setTypeface(Typeface.DEFAULT_BOLD);
    textPaint.setTextAlign(Paint.Align.CENTER);
    textPaint.setColor(Color.BLACK);
    // Set size (one character has a standard design, more has dynamic size)
    if (label.length() == 1) textPaint.setTextSize(radius);
    else textPaint.setTextSize(radius / label.length() * 2.5f);

    // Set paint to clear text from button
    textPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));

    // Render the button
    handleCanvas.drawText(label, radius, radius + (textPaint.getTextSize() * .33333f), textPaint);
  }
  @Override
  protected void onDraw(Canvas canvas) {
    int width = getWidth() - getPaddingLeft() - getPaddingRight();
    int height = getHeight() - getPaddingTop() - getPaddingBottom();

    if (backgroundDrawable != null) {
      int dw = backgroundDrawable.getIntrinsicWidth();
      int left = getPaddingLeft() + (width - dw) / 2;
      int top = getPaddingTop();
      int right = left + dw;
      int bottom = height + getPaddingTop();
      backgroundDrawable.setBounds(left, top, right, bottom);
      backgroundDrawable.draw(canvas);
    }

    if (progressDrawable != null) {
      int dw = progressDrawable.getIntrinsicWidth();
      int left = getPaddingLeft() + (width - dw) / 2;
      int top = getPaddingTop();
      int right = left + dw;
      int bottom = height + getPaddingTop();
      progressDrawable.setBounds(left, top, right, bottom);
      progressDrawable.setLevel((int) (10000 * progress.percentage()));
      progressDrawable.draw(canvas);
    }

    int textWidth = (int) paint.measureText(progress.toString());
    int x = (width - textWidth) / 2 + getPaddingLeft();
    int y = height / 2 + getPaddingTop() - (int) (paint.getTextSize() / 2);
    canvas.drawText(progress.toString(), x, y, paint);
  }
  /**
   * @param textview
   * @return
   */
  private String adjustTextLength(TextView tv) {
    if (tv == null) {
      return "";
    }
    String input = tv.getText().toString();
    String result = input;
    String newtext = input;
    int lastSpaceIndex = 0;
    ViewGroup.LayoutParams lp = (ViewGroup.LayoutParams) tv.getLayoutParams();
    Paint p = tv.getPaint();
    Rect bound = new Rect();
    p.getTextBounds(input, 0, input.length() - 1, bound);
    float textHeight = p.getTextSize();
    float multiLine = (((lp.height - tv.getPaddingTop() - tv.getPaddingBottom()) / textHeight));
    float availableW = (lp.width - tv.getPaddingLeft() - tv.getPaddingRight()) * (multiLine + 0.2f);

    do {

      newtext = (String) TextUtils.ellipsize(result, tv.getPaint(), availableW, TruncateAt.END);
      if (!newtext.equals(result)) {
        lastSpaceIndex = newtext.lastIndexOf(" ");
        if (lastSpaceIndex > 0) {
          result = newtext.substring(0, lastSpaceIndex) + "...";
        } else {
          break;
        }
      } else {
        break;
      }
    } while (false);

    GKIMLog.lf(null, 0, TAG + "=>adjust title from: " + input + " to: " + result);
    tv.setText(result);
    return result;
  }
Esempio n. 8
0
  /**
   * * Allocate the paint object and figuring out how large the instrument is on the display based
   * upon the text size in the source paint object
   *
   * @param textPaint Used to figure out our overall size
   */
  public void setSize(Paint textPaint) {
    // A total of 11 bars
    mBarCount = 11;

    // The width of each bar is the basis for the entire instrument size
    mBarWidth = textPaint.getTextSize() * (float) 0.5;

    // Height is 1/4 of the width
    mBarHeight = mBarWidth / 4;

    // Space between bars is 3x the height of the bar
    mBarSpace = 3 * mBarHeight;

    // Height of the entire instrument
    mInstHeight =
        mBarCount * mBarHeight
            + // The bars themselves
            (mBarCount - 1) * mBarSpace
            + // Space between the bars
            2 * mBarHeight; // Space to the top and bottom of the end bars

    // Width of the entire instrument
    mInstWidth =
        mBarWidth
            + // The main bar itself
            mBarWidth / 2
            + // The triangle indicator height
            mBarHeight * 3; // Border padding at left/right/middle

    // Allocate the paint object to save time during draw cycle
    mVNAVPaint = new Paint(textPaint);
  }
Esempio n. 9
0
    @Override
    public void onDraw(final Canvas c) {
      // Draw the alpha pattern
      mAlphaPattern.draw(c);

      // Draw the shader that shows how transparent a colors looks at a given alpha on top of the
      // alpha pattern
      shaderPaint.setShader(
          new LinearGradient(
              borderSize, 0, this.getWidth() - borderSize, 0, 0, color, TileMode.CLAMP));
      c.drawRect(
          borderSize,
          borderSize,
          this.getWidth() - borderSize,
          this.getHeight() - borderSize,
          shaderPaint);

      // Draw the transparency label on top of that stuff
      c.drawText(
          "Transparency",
          this.getWidth() / 2,
          this.getHeight() / 2 + labelPaint.getTextSize() / 2.0f,
          labelPaint);

      // Draw the alpha tracker on top of everything else
      final float xPos = alphaToXPos(alpha);
      final float rectWidth = 2 * mDensity;
      final RectF r = new RectF();
      r.left = xPos - rectWidth;
      r.right = xPos + rectWidth;
      r.top = 0;
      r.bottom = this.getHeight();
      c.drawRoundRect(r, rectWidth, rectWidth, trackerPaint);
    }
Esempio n. 10
0
  protected void onDrawCell(Canvas canvas, Cell cell) {
    if (cell.text == null && cell.bgColor == null && cell.rtDrawable == null)
      return; // 如果无内容,且无背景色不进行绘制
    Rect rect = this.getCellRectInView(cell);
    if (cell.bgColor != null) {

      canvas.drawColor(cell.bgColor);
    }

    if (cell.ballColor != null) {
      painter.setColor(cell.ballColor);
      canvas.drawCircle(rect.centerX(), rect.centerY(), rect.height() / 2 - 1 * dp, painter);
    }
    if (cell.textColor != null) painter.setColor(cell.textColor);
    if (cell.text != null) {
      if (cell.textSize > 0) painter.setTextSize(cell.textSize);
      else painter.setTextSize(this.textSize);
      painter.setTextAlign(cell.aligin);
      int cx = rect.centerX();
      if (cell.aligin == Align.LEFT) cx = rect.left;
      else if (cell.aligin == Align.RIGHT) cx = rect.right;
      int cy = rect.centerY() + (int) (painter.getTextSize() * 2 / 5 + 0.5f);
      if (cell.fixedTextX) cx -= offX;
      if (cell.fixedTextY) cy -= offY;

      canvas.drawText(cell.text, cx, cy, painter);
    }
    if (cell.rtDrawable != null) {
      int minWidth = cell.rtDrawable.getMinimumWidth();
      if (minWidth > rect.width() / 2) minWidth = rect.width() / 2;
      cell.rtDrawable.setBounds(
          new Rect(rect.right - minWidth, rect.top, rect.right, rect.top + minWidth));
      cell.rtDrawable.draw(canvas);
    }
  }
Esempio n. 11
0
 // 设置字体大小
 public final void setTextSize(float size) {
   if (size != paint.getTextSize()) {
     mFontSize = size;
     if (mTextHeight > 0) {
       GetTextInfo();
     }
   }
 }
Esempio n. 12
0
  @Override
  public void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    // Translate the canvas to account for the view padding
    canvas.translate(mCanvasXPadding, mCanvasYPadding);

    // Outside box
    mCacheRectF.set(0, 0, mWidth, mHeight);
    canvas.drawRect(mCacheRectF, mStrokeColor);

    final float centerY = mHeight / 2;
    final float ticMargin = mHeight / mScrollToRange;
    final int start = (int) (mScrollTo - mScrollToRange / 2);
    final int end = (int) (mScrollTo + mScrollToRange / 2);
    final float ticStart = mHandedness == Handedness.LEFT ? mWidth : 0;
    final float ticEnd =
        mHandedness == Handedness.LEFT ? ticStart - mTicWidth : ticStart + mTicWidth;
    final float textStart =
        mHandedness == Handedness.LEFT ? mWidth - mTextHorizontalMargin : mTextHorizontalMargin;
    final float textOffset = mStrokeColor.getTextSize() / 2 + mTextVerticalMargin;

    for (int a = start; a <= end; a++) {
      if (a % 5 == 0) {
        float lineHeight = centerY - ticMargin * (a - mScrollTo);
        canvas.drawLine(ticStart, lineHeight, ticEnd, lineHeight, mStrokeColor);
        canvas.drawText(String.valueOf(a), textStart, lineHeight + textOffset, mStrokeColor);
      }
    }

    // Arrow with current speed
    final int borderWidth = Math.round(mArrowStrokeColor.getStrokeWidth());
    final float arrowStickX, arrowBaseX, arrowPointX;
    if (mHandedness == Handedness.LEFT) {
      arrowStickX = -borderWidth;
      arrowBaseX = mWidth - mArrowHeight / 4 - borderWidth;
      arrowPointX = mWidth - borderWidth;
    } else {
      arrowStickX = mWidth + borderWidth;
      arrowBaseX = mArrowHeight / 4 + borderWidth;
      arrowPointX = borderWidth;
    }

    final float arrowStartY = centerY - mArrowHeight / 2;
    final float arrowEndY = centerY + mArrowHeight / 2;

    mCachePath.reset();
    Path arrow = mCachePath;
    arrow.moveTo(arrowStickX, arrowStartY);
    arrow.lineTo(arrowBaseX, arrowStartY);
    arrow.lineTo(arrowPointX, centerY);
    arrow.lineTo(arrowBaseX, arrowEndY);
    arrow.lineTo(arrowStickX, arrowEndY);
    canvas.drawPath(arrow, mArrowBgColor);
    canvas.drawPath(arrow, mArrowStrokeColor);
    canvas.drawText(String.valueOf((int) mScrollTo), textStart, centerY + textOffset, mStrokeColor);
  }
Esempio n. 13
0
 private void adjustSayingText(Paint mSayingPaint, String textToMeasure) {
   if (mSayingPaint.measureText(textToMeasure, 0, textToMeasure.length())
       <= getDisplayMetrics().widthPixels) {
     return;
   } else {
     mSayingPaint.setTextSize(mSayingPaint.getTextSize() - 0.1f);
     adjustSayingText(mSayingPaint, textToMeasure);
   }
 }
Esempio n. 14
0
 private void adjustSayingTextRound(Paint mSayingPaint, String textToMeasure) {
   if (mSayingPaint.measureText(textToMeasure, 0, textToMeasure.length())
       <= boundary.getRectWidth()) {
     return;
   } else {
     mSayingPaint.setTextSize(mSayingPaint.getTextSize() - 0.1f);
     adjustSayingTextRound(mSayingPaint, textToMeasure);
   }
 }
Esempio n. 15
0
 private void drawFocusRect(RectF rect, int color) {
   canvas = holderTransparent.lockCanvas();
   canvas.drawColor(0, PorterDuff.Mode.CLEAR);
   // border's properties
   Paint paint = new Paint();
   paint.setStyle(Paint.Style.STROKE);
   paint.setColor(color);
   paint.setStrokeWidth(3);
   paint.setTextSize(paint.getTextSize() * 7);
   canvas.drawRect(rect, paint);
   holderTransparent.unlockCanvasAndPost(canvas);
 }
Esempio n. 16
0
        @Override
        public void handleTile(
            final Canvas pCanvas,
            final int pTileSizePx,
            final MapTile pTile,
            final int pX,
            final int pY) {
          // no overflow detected here Log.d(IMapView.LOGTAG, "handleTile " + pTile.toString() +
          // ","+pX + "," + pY);
          Drawable currentMapTile = mTileProvider.getMapTile(pTile);
          boolean isReusable = currentMapTile instanceof ReusableBitmapDrawable;
          final ReusableBitmapDrawable reusableBitmapDrawable =
              isReusable ? (ReusableBitmapDrawable) currentMapTile : null;
          if (currentMapTile == null) {
            currentMapTile = getLoadingTile();
          }

          if (currentMapTile != null) {
            mTilePoint.set(pX * pTileSizePx, pY * pTileSizePx);
            mTileRect.set(
                mTilePoint.x, mTilePoint.y, mTilePoint.x + pTileSizePx, mTilePoint.y + pTileSizePx);
            if (isReusable) {
              reusableBitmapDrawable.beginUsingDrawable();
            }
            try {
              if (isReusable && !((ReusableBitmapDrawable) currentMapTile).isBitmapValid()) {
                currentMapTile = getLoadingTile();
                isReusable = false;
              }
              onTileReadyToDraw(pCanvas, currentMapTile, mTileRect);
            } finally {
              if (isReusable) reusableBitmapDrawable.finishUsingDrawable();
            }
          }

          if (DEBUGMODE) {
            mTileRect.set(
                pX * pTileSizePx,
                pY * pTileSizePx,
                pX * pTileSizePx + pTileSizePx,
                pY * pTileSizePx + pTileSizePx);
            pCanvas.drawText(
                pTile.toString(),
                mTileRect.left + 1,
                mTileRect.top + mDebugPaint.getTextSize(),
                mDebugPaint);
            pCanvas.drawLine(
                mTileRect.left, mTileRect.top, mTileRect.right, mTileRect.top, mDebugPaint);
            pCanvas.drawLine(
                mTileRect.left, mTileRect.top, mTileRect.left, mTileRect.bottom, mDebugPaint);
          }
        }
Esempio n. 17
0
  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int measuredWidth = resolveSize(50, widthMeasureSpec);

    // Get the desired height of the icon menu view (last row of items does
    // not have a divider below)
    Rect padding = new Rect();
    mSelectionHighlight.getPadding(padding);
    final int desiredHeight =
        ((int) mPaint.getTextSize()) + mVerticalPadding + padding.top + padding.bottom;

    // Maximum possible width and desired height
    setMeasuredDimension(measuredWidth, resolveSize(desiredHeight, heightMeasureSpec));
  }
Esempio n. 18
0
 protected void drawAxesLabels(Canvas canvas) {
   canvas.drawText(
       mXAxisLabel,
       mLeftPadding + graphWidth / 2 - mAxisLabelPaint.measureText(mXAxisLabel) / 2,
       mTopPadding + graphHeight + mBottomPadding - mXAxisLabelOffset,
       mAxisLabelPaint);
   canvas.rotate(-90, 0, 0);
   canvas.drawText(
       mYAxisLabel,
       -(mTopPadding + graphHeight / 2 + mAxisLabelPaint.measureText(mYAxisLabel) / 2),
       mAxisLabelPaint.getTextSize() + mYAxisLabelOffset,
       mAxisLabelPaint);
   canvas.rotate(90, 0, 0);
 }
Esempio n. 19
0
  @Override
  protected void onDraw(Canvas canvas) {
    float textShowWidth = getWidth();

    Paint textPaint = getPaint();
    float textSize = textPaint.getTextSize();

    int lineCount; // 当前行数
    float oneX; // 当前一个汉字绘制的x坐标
    float oneY = 0; // 当前一个汉字绘制的y坐标

    String text = this.getText().toString();
    if (TextUtils.isEmpty(text)) {
      return;
    }
    char[] textCharArray = text.toCharArray();
    if (logCount == 1) {
      Log.i("TAG", "textShowWidth---" + textShowWidth);
      Log.i("TAG", "textCharArray---" + textCharArray.length);
      logCount = 2;
    }

    ArrayList<LineModel> lineList =
        getCalculateLineList(
            textPaint, textCharArray, textShowWidth, isGravityCenter, oneMarginLeft);

    if (logCount == 2) {
      Log.i("TAG", "lineList---" + lineList.toString());
      logCount = 3;
    }

    float charWidth;
    for (int j = 0; j < lineList.size(); j++) {
      LineModel model = lineList.get(j);
      lineCount = model.getLineCount();
      oneX = model.getStartX();
      if (model.getLineCount() == 1) {
        oneY = textSize;
      }
      if (model.getLineCount() >= 2) {
        oneY = (lineCount * textSize + (lineCount - 1) * lineSpace);
      }
      for (int k = model.getStartIndex(); k < model.getEndIndex() + 1; k++) {
        charWidth = textPaint.measureText(textCharArray, k, 1);
        canvas.drawText(textCharArray, k, 1, oneX, oneY, textPaint);
        oneX = charWidth + oneMarginLeft + oneX;
      }
    }
    setHeight((int) (oneY + bottomSpace));
  }
Esempio n. 20
0
  protected void drawAxes(Canvas canvas) {
    float textHoriOffset;
    float textVertOffset = -(2 * mAxesPaint.getTextSize() - mAxesPaint.getFontSpacing()) / 2;

    Path axesPath = new Path();
    axesPath.moveTo(mLeftPadding, mTopPadding - mGridlinesPaint.getStrokeWidth() / 2);
    axesPath.lineTo(mLeftPadding, mTopPadding + graphHeight);
    axesPath.lineTo(
        mLeftPadding + graphWidth + mGridlinesPaint.getStrokeWidth() / 2,
        mTopPadding + graphHeight);
    mAxesPaint.setStyle(Paint.Style.STROKE);
    mAxesPaint.setAntiAlias(false);
    canvas.drawPath(axesPath, mAxesPaint);
    mAxesPaint.setAntiAlias(mAxesPaintAntiAlias);
    mAxesPaint.setStyle(Paint.Style.FILL);

    for (int i = 0; i < mYAxisLabels.length; i++) {
      textHoriOffset = mAxesPaint.measureText(mYAxisLabels[i]) + mGridlineLabelHoriSpacing;
      canvas.drawText(
          mYAxisLabels[i],
          mLeftPadding - textHoriOffset,
          mTopPadding - textVertOffset + (1.00f - mYAxisLabelPositions[i]) * graphHeight,
          mAxesPaint);
    }

    textVertOffset =
        (2 * mAxesPaint.getTextSize() - mAxesPaint.getFontSpacing()) + mGridlineLabelVertSpacing;

    for (int i = 0; i < mXAxisLabels.length; i++) {
      textHoriOffset = mAxesPaint.measureText(mXAxisLabels[i]) / 2;
      canvas.drawText(
          mXAxisLabels[i],
          mLeftPadding - textHoriOffset + mXAxisLabelPositions[i] * graphWidth,
          mTopPadding + graphHeight + textVertOffset,
          mAxesPaint);
    }
  }
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    paint.setTypeface(Typeface.create("", Typeface.BOLD));

    paint.setTextSize((int) (textSize * BaseActivity.screen_width));
    paint.setAntiAlias(true);
    paint.setColor(Color.rgb(100, 100, 100));

    float x = Utils.measureX(paint, AVAILABLE_BALANCE_TITLE, maxwidth);
    canvas.drawText(AVAILABLE_BALANCE_TITLE, x, (float) (availableY * maxHeight), paint);

    x = Utils.measureX(paint, ACCOUNT_BALANCE_TITLE, maxwidth);
    canvas.drawText(ACCOUNT_BALANCE_TITLE, x, (float) ((accountY) * maxHeight), paint);
    x = Utils.measureX(paint, ACCOUNT_BALANCE_TITLE, maxwidth);
    canvas.drawText(ACCOUNT_BALANCE_TITLE, x, (float) ((accountY) * maxHeight), paint);

    paint.setColor(Color.BLACK);
    x = Utils.measureX(paint, getAvailableBalanceValue(), maxwidth);
    canvas.drawText(
        getAvailableBalanceValue(), x, (float) ((availableY + line) * maxHeight), paint);

    x = Utils.measureX(paint, getAccountBalanceValue(), maxwidth);
    canvas.drawText(getAccountBalanceValue(), x, (float) ((accountY + line) * maxHeight), paint);

    x = (float) (maxwidth / 2 - paint.measureText(DEPOSIT_TITLE) - placeholderLineDrawableWidth);
    canvas.drawText(DEPOSIT_TITLE, x, (float) ((depositY) * maxHeight), paint);

    x = (float) (maxwidth / 2 + placeholderLineDrawableWidth);
    canvas.drawText(WITHDRAWALS_TITLE, x, (float) ((depositY) * maxHeight), paint);

    x =
        (float)
            (maxwidth / 2 - paint.measureText(getDepositValue()) - placeholderLineDrawableWidth);
    canvas.drawText(getDepositValue(), x, (float) ((depositY + line) * maxHeight), paint);

    x = (float) (maxwidth / 2 + placeholderLineDrawableWidth);

    canvas.drawText(getWidthdrawalsValue(), x, (float) ((depositY + line) * maxHeight), paint);

    if (placeholderLineDrawable != null) {
      canvas.save();
      // canvas.scale((float)xx, (float)xx);
      canvas.translate((float) (o_x), (float) ((depositY) * maxHeight) - paint.getTextSize());
      placeholderLineDrawable.draw(canvas);
      canvas.restore();
    }
  }
Esempio n. 22
0
  /**
   * 绘制文字
   *
   * @param canvas
   * @param text
   * @param x
   * @param y
   * @param paint
   * @param angle
   * @param zoom
   */
  protected void drawText(
      Canvas canvas, String text, float x, float y, Paint paint, float angle, float zoom) {

    // 缩放
    Paint textPaint = new Paint(paint);
    textPaint.setTextSize(paint.getTextSize() * zoom);

    // 旋转
    canvas.save();
    canvas.rotate(angle, x, y);
    x -= (getFontWidth(textPaint, text) - getFontWidth(paint, text)) / 2;
    y += (getFontHeight(textPaint) - getFontHeight(paint)) / 2;
    canvas.drawText(text, x, y, textPaint);
    canvas.restore();
  }
Esempio n. 23
0
  /**
   * * The main display is telling us what paint it is using. Make a copy of it and adjust it for
   * what we need it to do. Perform some size calculations here instead of at draw time
   *
   * @param paint
   */
  public void setPaint(Paint paint) {
    // Allocate our own paint based upon what is in use
    mPaint = new Paint(paint);

    // Set our desired attributes
    mPaint.setTextSize(mPaint.getTextSize() / (float) 2.5);
    mPaint.setTextAlign(Align.LEFT);

    // Find out how big our shadow needs to be
    mPaint.getTextBounds("000", 0, 3, mTextBounds);

    // Determine the margin pixel values
    mTextWidth = mTextBounds.width();
    mTextHeight = mTextBounds.height();
    mBgndWidth = (int) (mTextWidth * 1.4);
    mLeftMargin = (int) (mTextWidth * 0.2);
    mBgndHeight = (int) (mTextHeight * 1.4);
    mBotmMargin = (int) (mTextHeight * 1.2);
  }
Esempio n. 24
0
  /**
   * Helper to draw this square in its current color (whichever that is).
   *
   * <p>This method does not modify any settings of the Paint object passed to it.
   *
   * @param canvas Canvas object to draw to
   * @param paint Paint object to use for the drawing
   */
  public void draw(Canvas canvas, Paint paint) {
    int oldColor = paint.getColor();
    paint.setColor(this.color);
    canvas.drawRect(this.xpos, this.ypos, this.xpos + this.width, this.ypos + this.height, paint);

    if (text != null) {
      Paint.Align oldAlign = paint.getTextAlign();
      float oldSize = paint.getTextSize();
      paint.setTextAlign(Paint.Align.CENTER);
      paint.setColor(textColor);
      paint.setTextSize(0.8f * this.height);
      canvas.drawText(
          this.text, this.xpos + this.width / 2, this.ypos + 4 * this.height / 5, paint);
      paint.setTextAlign(oldAlign);
      paint.setTextSize(oldSize);
    }

    paint.setColor(oldColor);
  }
  /**
   * Applies the specified text appearance resource to a paint, returning the text color if one is
   * set in the text appearance.
   *
   * @param p the paint to modify
   * @param resId the resource ID of the text appearance
   * @return the text color, if available
   */
  private ColorStateList applyTextAppearance(Paint p, int resId) {
    final TypedArray ta =
        mContext.obtainStyledAttributes(null, R.styleable.TextAppearance, 0, resId);

    final String fontFamily = ta.getString(R.styleable.TextAppearance_fontFamily);
    if (fontFamily != null) {
      p.setTypeface(Typeface.create(fontFamily, 0));
    }

    p.setTextSize(
        ta.getDimensionPixelSize(R.styleable.TextAppearance_textSize, (int) p.getTextSize()));

    final ColorStateList textColor = ta.getColorStateList(R.styleable.TextAppearance_textColor);
    if (textColor != null) {
      final int enabledColor = textColor.getColorForState(ENABLED_STATE_SET, 0);
      p.setColor(enabledColor);
    }

    ta.recycle();

    return textColor;
  }
Esempio n. 26
0
    @Override
    protected void onDraw(Canvas canvas) {
      super.onDraw(canvas);
      Log.i(
          "tonghu",
          "Xfermoders.SampleView-onDraw :" + canvas.getWidth() + ", " + canvas.getHeight());
      canvas.drawColor(Color.WHITE);
      canvas.translate(15, 35);
      int x = 0;
      int y = 0;

      for (int i = 0; i < sModes.length; i++) {
        paint.setShader(null);
        paint.setColor(Color.BLACK);
        paint.setStyle(Style.STROKE);
        canvas.drawRect(x - 0.5f, y - 0.5f, x + W + 0.5f, y + H + 0.5f, paint);

        paint.setShader(bg);
        paint.setStyle(Style.FILL);
        canvas.drawRect(x, y, x + W, y + H, paint);

        paint.setShader(null);
        int saveLayer = canvas.saveLayer(x, y, x + W, y + H, paint, Canvas.ALL_SAVE_FLAG);
        canvas.drawBitmap(dstB, x, y, paint);
        paint.setXfermode(sModes[i]);
        canvas.drawBitmap(srcB, x, y, paint);
        canvas.drawText(labels[i], x + W / 2, y - labelP.getTextSize() / 2, labelP);
        paint.setXfermode(null);
        canvas.restoreToCount(saveLayer);

        x += W + 10;
        if ((i % ROW_MAX) == ROW_MAX - 1) {
          x = 0;
          y += H + 30;
        }
      }
    }
  // Workaround to fix missing text on Lollipop and above,
  // and probably some rendering issues with Jelly Bean and above
  // Modified from http://stackoverflow.com/a/14989037/746068
  public static void drawTextOnCanvasWithMagnifier(
      Canvas canvas, String text, float x, float y, Paint paint) {
    if (android.os.Build.VERSION.SDK_INT <= 15) {
      // draw normally
      canvas.drawText(text, x, y, paint);
    } else {
      // workaround
      float originalStrokeWidth = paint.getStrokeWidth();
      float originalTextSize = paint.getTextSize();
      final float magnifier = 1000f;

      canvas.save();
      canvas.scale(1f / magnifier, 1f / magnifier);

      paint.setTextSize(originalTextSize * magnifier);
      paint.setStrokeWidth(originalStrokeWidth * magnifier);

      canvas.drawText(text, x * magnifier, y * magnifier, paint);
      canvas.restore();

      paint.setTextSize(originalTextSize);
      paint.setStrokeWidth(originalStrokeWidth);
    }
  }
  @Override
  protected void dispatchDraw(Canvas canvas) {
    if (showcaseX < 0 || showcaseY < 0 || isRedundant) {
      super.dispatchDraw(canvas);
      return;
    }

    Bitmap b =
        Bitmap.createBitmap(getMeasuredWidth(), getMeasuredHeight(), Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(b);

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

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

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

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

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

    canvas.drawBitmap(b, 0, 0, null);

    // Clean up, as we no longer require these items.
    try {
      c.setBitmap(null);
    } catch (NullPointerException npe) {
      // TODO why does this NPE happen?
      npe.printStackTrace();
    }
    b.recycle();
    b = null;

    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.save();
        float width = mPaintTitle.measureText(mTitleText);
        canvas.rotate(
            mOrientation,
            mBestTextPosition[0] + width / 2.0f,
            mBestTextPosition[1] + mPaintTitle.getTextSize() / 2.0f);
        canvas.drawText(mTitleText, mBestTextPosition[0], mBestTextPosition[1], mPaintTitle);
        canvas.restore();
      }

      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);

        if (mOrientation % 180 == 0) {
          canvas.translate(mBestTextPosition[0], mBestTextPosition[1]);
        } else {
          canvas.rotate(
              mOrientation,
              mDynamicDetailLayout.getWidth() / 2,
              mDynamicDetailLayout.getHeight() / 2);
        }

        mDynamicDetailLayout.draw(canvas);
        canvas.restore();
      }
    }

    super.dispatchDraw(canvas);
  }
Esempio n. 29
0
  /**
   * If the canvas is null, then only touch calculations are performed to pick the target candidate.
   */
  @Override
  protected void onDraw(Canvas canvas) {
    // public void draw(Canvas canvas) {
    if (canvas != null) {
      super.onDraw(canvas);
      // super.draw(canvas);
    }
    mTotalWidth = 0;
    if (mSuggestions == null) return;

    if (mBgPadding == null) {
      mBgPadding = new Rect(0, 0, 0, 0);
      if (getBackground() != null) {
        getBackground().getPadding(mBgPadding);
      }
    }
    int x = 0;
    final int count = mSuggestions.size();
    final int height = getHeight();
    final Rect bgPadding = mBgPadding;
    final Paint paint = mPaint;
    final int touchX = mTouchX;
    final int scrollX = getScrollX();
    final boolean scrolled = mScrolled;
    final boolean typedWordValid = mTypedWordValid;
    final int y = (int) (((height - mPaint.getTextSize()) / 2) - mPaint.ascent());

    for (int i = 0; i < count; i++) {
      String suggestion = mSuggestions.get(i);
      float textWidth = paint.measureText(suggestion);
      final int wordWidth = (int) textWidth + X_GAP * 2;

      mWordX[i] = x;
      mWordWidth[i] = wordWidth;
      paint.setColor(mColorNormal);
      if (touchX + scrollX >= x && touchX + scrollX < x + wordWidth && !scrolled) {
        if (canvas != null) {
          canvas.translate(x, 0);
          mSelectionHighlight.setBounds(0, bgPadding.top, wordWidth, height);
          mSelectionHighlight.draw(canvas);
          canvas.translate(-x, 0);
        }
        mSelectedIndex = i;
      }

      if (canvas != null) {
        if ((i == 1 && !typedWordValid) || (i == 0 && typedWordValid)) {
          paint.setFakeBoldText(true);
          paint.setColor(mColorRecommended);
        } else if (i != 0) {
          paint.setColor(mColorOther);
        }
        canvas.drawText(suggestion, x + X_GAP, y, paint);
        paint.setColor(mColorOther);
        canvas.drawLine(
            x + wordWidth + 0.5f, bgPadding.top, x + wordWidth + 0.5f, height + 1, paint);
        paint.setFakeBoldText(false);
      }
      x += wordWidth;
    }
    mTotalWidth = x;
    if (mTargetScrollX != getScrollX()) {
      scrollToTarget();
    }
  }
 public float getTextSize() {
   return mPaintText.getTextSize();
 }