コード例 #1
0
ファイル: VEC_Element_TextOut.java プロジェクト: Utyff/pMetro
  @Override
  public void Draw(Canvas canvas, Paint paint) {

    Typeface tf = paint.getTypeface();
    paint.setUnderlineText(underline);
    paint.setTypeface(Typeface.create(tf, style));
    paint.setTextSize(size);
    paint.setStyle(Paint.Style.FILL);

    if (v.currBrushColor != -1) { // draw background rect
      int clr = paint.getColor();
      paint.setColor(v.currBrushColor + v.Opaque);
      canvas.drawRect(
          x - 1,
          y,
          x + paint.measureText(text) + 1,
          y - paint.ascent() + paint.descent() / 2,
          paint);
      paint.setColor(clr);
    }

    canvas.drawText(text, x, y - paint.ascent(), paint);

    paint.setStyle(Paint.Style.STROKE);
    paint.setUnderlineText(false);
    paint.setTypeface(tf);
  }
コード例 #2
0
  public void onRender(Canvas canvas) {
    float lineTop = -textPaint.ascent();
    float lineHeight = (-textPaint.ascent() + textPaint.descent()) * 1.1f;

    tick++;
    canvas.drawColor(Color.BLACK);

    canvas.drawText("Tick: " + tick, 0, lineTop, textPaint);
    canvas.drawText(
        "Screen = (" + width + ", " + height + ")", 0, lineTop + lineHeight * 1, textPaint);
    canvas.drawText("Azimuth = " + azimuth, 0, lineTop + lineHeight * 2, textPaint);
    canvas.drawText("Pitch = " + pitch, 0, lineTop + lineHeight * 3, textPaint);
    canvas.drawText("Roll = " + roll, 0, lineTop + lineHeight * 4, textPaint);

    //		canvas.drawLine(0, 0, 80, 80, linePaint);
    float centerX = width / 2;
    float centerY = height / 2;
    float length = 50;
    double rad = Math.toRadians(pitch);
    float offsetX = (float) (Math.cos(rad) * length);
    float offsetY = (float) (Math.sin(rad) * length);
    canvas.drawLine(centerX, centerY, centerX + offsetX, centerY - offsetY, linePaint);

    canvas.drawRect(80, 133, 120, 266.7f, rectPaint);
  }
コード例 #3
0
ファイル: eri.java プロジェクト: exe44/eri
  static int CreateTxtTexture(
      String txt, Typeface typeface, float font_size, boolean align_center) {

    Paint textPaint = new Paint();
    textPaint.setTypeface(typeface);
    textPaint.setTextSize(font_size);
    textPaint.setTextAlign(align_center ? Paint.Align.CENTER : Paint.Align.LEFT);
    textPaint.setAntiAlias(true);
    textPaint.setARGB(0xff, 0xFF, 0xFF, 0xFF);

    int width = 0;
    int height = 0;

    int line_height = (int) Math.ceil(-textPaint.ascent() + textPaint.descent());

    String[] lines = txt.split("\n");

    for (String line : lines) {
      int line_width = (int) Math.ceil(textPaint.measureText(line));
      if (line_width > width) width = line_width;

      height += line_height;
    }

    int power2_width = Integer.highestOneBit(width);
    if (power2_width < width) power2_width = power2_width << 1;
    int power2_height = Integer.highestOneBit(height);
    if (power2_height < height) power2_height = power2_height << 1;

    // Log.i(TAG, "CreateTxtTexture calculate w " + width + " h " + height +
    // " power2 w " + power2_width + " h " + power2_height);

    if (0 == power2_width || 0 == power2_height) return 0;

    Bitmap bitmap = Bitmap.createBitmap(power2_width, power2_height, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    bitmap.eraseColor(0);

    float origin_x = align_center ? (width / 2) : 0;
    float origin_y = -textPaint.ascent();

    for (String line : lines) {
      canvas.drawText(line, origin_x, origin_y, textPaint);
      origin_y += line_height;
    }

    // canvas.setBitmap(null);

    // Log.i(TAG, "CreateTxtTexture " + txt + " use " + font_name + " " + font_size);

    // Use the Android GLUtils to specify a two-dimensional texture image
    // from our bitmap
    GLUtils.texImage2D(GL11.GL_TEXTURE_2D, 0, bitmap, 0);

    // bitmap.recycle();

    return width + (height << 16);
  }
コード例 #4
0
 private void drawLeftAxisLabel(Canvas canvas, int position) {
   Paint axisLabelPaint = labelPaints[LEFT];
   String text = getLeftLabel(position);
   if (position == 0) {
     canvas.drawText(text, 0, -axisLabelPaint.ascent(), axisLabelPaint);
   } else if (position == HORIZONTAL_LINE_NUMBER) {
     float y =
         chartView.getContentHeight() + (axisLabelPaint.ascent() + axisLabelPaint.descent()) / 2;
     canvas.drawText(text, 0, y, axisLabelPaint);
   } else {
     float y = position / (float) HORIZONTAL_LINE_NUMBER * chartView.getContentHeight();
     y = y - (axisLabelPaint.ascent() + axisLabelPaint.descent()) / 2;
     canvas.drawText(text, 0, y, axisLabelPaint);
   }
 }
コード例 #5
0
  @Override
  protected synchronized void onDraw(Canvas canvas) {
    canvas.drawArc(mCircleBounds, 0, 360, false, mBackgroundColorPaint);

    int prog = getProgress();
    float scale = getMax() > 0 ? (float) prog / getMax() * 360 : 0;

    if (mHasShadow) mProgressColorPaint.setShadowLayer(3, 0, 1, mShadowColor);
    canvas.drawArc(mCircleBounds, 270, scale, false, mProgressColorPaint);

    if (!TextUtils.isEmpty(mTitle)) {
      int xPos = (int) (getMeasuredWidth() / 2 - mTitlePaint.measureText(mTitle) / 2);
      int yPos = (int) (getMeasuredHeight() / 2);

      float titleHeight = Math.abs(mTitlePaint.descent() + mTitlePaint.ascent());
      if (TextUtils.isEmpty(mSubTitle)) {
        yPos += titleHeight / 2;
      }
      canvas.drawText(mTitle, xPos, yPos, mTitlePaint);

      yPos += titleHeight;
      xPos = (int) (getMeasuredWidth() / 2 - mSubtitlePaint.measureText(mSubTitle) / 2);

      canvas.drawText(mSubTitle, xPos, yPos, mSubtitlePaint);
    }

    super.onDraw(canvas);
  }
コード例 #6
0
ファイル: StringBlock.java プロジェクト: glonerr/androidUI
    public void chooseHeight(
        CharSequence text,
        int start,
        int end,
        int spanstartv,
        int v,
        Paint.FontMetricsInt fm,
        TextPaint paint) {
      int size = mSize;
      if (paint != null) {
        size *= paint.density;
      }

      if (fm.bottom - fm.top < size) {
        fm.top = fm.bottom - size;
        fm.ascent = fm.ascent - size;
      } else {
        if (sProportion == 0) {
          /*
           * Calculate what fraction of the nominal ascent the height
           * of a capital letter actually is, so that we won't reduce
           * the ascent to less than that unless we absolutely have
           * to.
           */

          Paint p = new Paint();
          p.setTextSize(100);
          Rect r = new Rect();
          p.getTextBounds("ABCDEFG", 0, 7, r);

          sProportion = (r.top) / p.ascent();
        }

        int need = (int) Math.ceil(-fm.top * sProportion);

        if (size - fm.descent >= need) {
          /*
           * It is safe to shrink the ascent this much.
           */

          fm.top = fm.bottom - size;
          fm.ascent = fm.descent - size;
        } else if (size >= need) {
          /*
           * We can't show all the descent, but we can at least show
           * all the ascent.
           */

          fm.top = fm.ascent = -need;
          fm.bottom = fm.descent = fm.top + size;
        } else {
          /*
           * Show as much of the ascent as we can, and no descent.
           */

          fm.top = fm.ascent = -size;
          fm.bottom = fm.descent = 0;
        }
      }
    }
コード例 #7
0
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    // Draw the inner circle
    canvas.drawArc(innerCircleBounds, 360, 360, false, circlePaint);
    // Draw the rim
    canvas.drawArc(circleBounds, 360, 360, false, rimPaint);
    canvas.drawArc(circleOuterContour, 360, 360, false, contourPaint);
    // canvas.drawArc(circleInnerContour, 360, 360, false, contourPaint);
    // Draw the bar
    if (isSpinning) {
      canvas.drawArc(circleBounds, progress - 90, barLength, false, barPaint);
    } else {
      canvas.drawArc(circleBounds, -90, progress, false, barPaint);
    }
    // Draw the text (attempts to center it horizontally and vertically)
    float textHeight = textPaint.descent() - textPaint.ascent();
    float verticalTextOffset = (textHeight / 2) - textPaint.descent();

    for (String line : splitText) {
      float horizontalTextOffset = textPaint.measureText(line) / 2;
      canvas.drawText(
          line,
          this.getWidth() / 2 - horizontalTextOffset,
          this.getHeight() / 2 + verticalTextOffset,
          textPaint);
    }
    if (isSpinning) {
      scheduleRedraw();
    }
  }
コード例 #8
0
  @Override
  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {

    int height = 0;
    if (mBitmap != null) {
      height += mBitmap.getHeight();
      bx = ((right - left) - mBitmap.getWidth()) / 2;
    }
    if (message != null) {
      Rect bounds = new Rect();
      mPaint.getTextBounds(message, 0, message.length() - 1, bounds);
      int tw = bounds.right - bounds.left;
      int th = bounds.bottom - bounds.top;
      height += th;
      tx = ((right - left) - tw) / 2;
    }

    by = (bottom - top - height) / 2;
    if (mBitmap != null) {
      ty = by + mBitmap.getHeight();
    } else {
      ty = by;
    }
    if (message != null) {
      ty += (-mPaint.ascent());
    }
  }
コード例 #9
0
ファイル: ViewTodayItem.java プロジェクト: mondonc/AnCalv2
 public static int GetMinItemHeight(int iPaddingTop, int iPaddingBottom) {
   Paint pt = new Paint();
   pt.setAntiAlias(true);
   pt.setTextSize(fTextSize);
   float iHeight = (int) (-pt.ascent() + pt.descent());
   return iPaddingTop + iMargin + (int) iHeight + iMargin + iMargin + iPaddingBottom;
 }
コード例 #10
0
ファイル: Marker.java プロジェクト: XiaoYuQin/osmdroid
  /**
   * Sets the icon for the marker. Can be changed at any time.
   *
   * @param icon if null, the default osmdroid marker is used.
   */
  public void setIcon(Drawable icon) {
    if (ENABLE_TEXT_LABELS_WHEN_NO_IMAGE
        && icon == null
        && this.mTitle != null
        && this.mTitle.length() > 0) {
      Paint background = new Paint();
      background.setColor(mTextLabelBackgroundColor);

      Paint p = new Paint();
      p.setTextSize(mTextLabelFontSize);
      p.setColor(mTextLabelForegroundColor);

      p.setAntiAlias(true);
      p.setTypeface(Typeface.DEFAULT_BOLD);
      p.setTextAlign(Paint.Align.LEFT);
      int width = (int) (p.measureText(getTitle()) + 0.5f);
      float baseline = (int) (-p.ascent() + 0.5f);
      int height = (int) (baseline + p.descent() + 0.5f);
      Bitmap image = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
      Canvas c = new Canvas(image);
      c.drawPaint(background);
      c.drawText(getTitle(), 0, baseline, p);

      mIcon = new BitmapDrawable(resource, image);
    }
    if (!ENABLE_TEXT_LABELS_WHEN_NO_IMAGE && icon != null) this.mIcon = icon;
    // there's still an edge case here, title label no defined, icon is null and textlabel is
    // enabled
    if (this.mIcon == null) mIcon = mDefaultIcon;
  }
コード例 #11
0
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    if (firstTimeLaunched) {
      float scalewidth = (float) viewWidth / (float) imgBackgnd.getWidth();
      float scaleheight = (float) viewHeight / (float) imgBackgnd.getHeight();
      scaleFinal = scaleheight > scalewidth ? scalewidth : scaleheight;

      matrixBackgnd.setScale(scaleFinal, scaleFinal);

      firstTimeLaunched = false;
    }

    // (maxValue-value)*(maxPix-MinPix)/(maxValue-MinValue) + minPix
    float altitudePos = (4000 - value) * (470 - 70) / (4000) + 70;

    canvas.drawBitmap(imgBackgnd, matrixBackgnd, paint);
    canvas.concat(matrixBackgnd);

    float height = ((paint.descent() + paint.ascent()) / 2);

    int center = 70;

    canvas.drawLine(center, altitudePos, center + 15, altitudePos, paint);

    canvas.drawText(value + " m", center + 17, altitudePos - height, paint);

    canvas.drawRect(center, altitudePos, center + 10, 471, paint);
  }
コード例 #12
0
ファイル: BurnText.java プロジェクト: CarlosKweak/HTextView
  private void calc() {
    textSize = mHTextView.getTextSize();
    paint.setTextSize(textSize);

    for (int i = 0; i < mText.length(); i++) {
      gaps[i] = paint.measureText(mText.charAt(i) + "");
    }

    oldPaint.setTextSize(textSize);

    for (int i = 0; i < mOldText.length(); i++) {
      oldGaps[i] = oldPaint.measureText(mOldText.charAt(i) + "");
    }

    oldStartX = (mHTextView.getWidth() - oldPaint.measureText(mOldText.toString())) / 2f;

    startX = (mHTextView.getWidth() - paint.measureText(mText.toString())) / 2f;
    startY = (int) ((mHTextView.getHeight() / 2) - ((paint.descent() + paint.ascent()) / 2));

    differentList.clear();
    differentList.addAll(CharacterUtils.diff(mOldText, mText));

    Rect bounds = new Rect();
    paint.getTextBounds(mText.toString(), 0, mText.length(), bounds);
    upDistance = bounds.height();
  }
コード例 #13
0
ファイル: LegendPainter.java プロジェクト: jdddog/Lablet
  private LayoutInfo layout() {
    LayoutInfo info = new LayoutInfo();

    info.labelHeight = labelPaint.descent() - labelPaint.ascent();

    float maxMarkerSize = Float.MIN_VALUE;
    float maxLength = Float.MIN_VALUE;
    for (Entry entry : entryList) {
      float length = labelPaint.measureText(entry.label);
      if (maxLength < length) maxLength = length;
      float markerSize = entry.painter.getDrawConfig().getMarkerSize();
      if (markerSize > maxMarkerSize) maxMarkerSize = markerSize;
    }

    info.markerWidth = maxMarkerSize;

    info.frame.left = 0;
    info.frame.top = 0;
    info.frame.right =
        2 * info.margin
            + info.markerWidth
            + info.markerXSpacing
            + maxLength
            + 2 * info.markerLineSpace;
    info.frame.bottom = 2 * info.margin + entryList.size() * (info.labelHeight + info.labelSpacing);

    return info;
  }
コード例 #14
0
 /**
  * Calculate the bounds for a view's title
  *
  * @param index
  * @param paint
  * @return
  */
 private RectF calcBounds(int index, Paint paint) {
   // Calculate the text bounds
   RectF bounds = new RectF();
   bounds.right = paint.measureText(mTitleProvider.getTitle(index));
   bounds.bottom = paint.descent() - paint.ascent();
   return bounds;
 }
コード例 #15
0
ファイル: Hardware.java プロジェクト: apuder/TRS-80
 private void generateASCIIFont(AsyncTask task) {
   String ascii =
       " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
   Paint p = new Paint();
   p.setTextAlign(Align.CENTER);
   Typeface tf = Fonts.getTypeface(configuration.getModel());
   p.setTypeface(tf);
   p.setTextScaleX(1.0f);
   p.setColor(configuration.getCharacterColorAsRGB());
   p.setAntiAlias(true);
   setFontSize(p);
   int xPos = trsCharWidth / 2;
   int yPos = (int) ((trsCharHeight / 2) - ((p.descent() + p.ascent()) / 2));
   for (int i = 0; i < ascii.length(); i++) {
     if (task.isCancelled()) {
       return;
     }
     Bitmap b = Bitmap.createBitmap(trsCharWidth, trsCharHeight, Bitmap.Config.RGB_565);
     Canvas c = new Canvas(b);
     c.drawColor(configuration.getScreenColorAsRGB());
     c.drawText(ascii.substring(i, i + 1), xPos, yPos, p);
     font[i + 32] = b;
   }
   // Use space for all other characters
   for (int i = 0; i < font.length; i++) {
     if (font[i] == null) {
       font[i] = font[32];
     }
   }
 }
コード例 #16
0
  /**
   * Using the trigonometric Unit Circle, calculate the positions that the text will need to be
   * drawn at based on the specified circle radius. Place the values in the textGridHeights and
   * textGridWidths parameters.
   */
  private void calculateGridSizes(
      float numbersRadius,
      float xCenter,
      float yCenter,
      float textSize,
      float[] textGridHeights,
      float[] textGridWidths) {
    /*
     * The numbers need to be drawn in a 7x7 grid, representing the points on the Unit Circle.
     */
    float offset1 = numbersRadius;
    // cos(30) = a / r => r * cos(30) = a => r * √3/2 = a
    float offset2 = numbersRadius * ((float) Math.sqrt(3)) / 2f;
    // sin(30) = o / r => r * sin(30) = o => r / 2 = a
    float offset3 = numbersRadius / 2f;
    mPaint.setTextSize(textSize);
    // We'll need yTextBase to be slightly lower to account for the text's baseline.
    yCenter -= (mPaint.descent() + mPaint.ascent()) / 2;

    textGridHeights[0] = yCenter - offset1;
    textGridWidths[0] = xCenter - offset1;
    textGridHeights[1] = yCenter - offset2;
    textGridWidths[1] = xCenter - offset2;
    textGridHeights[2] = yCenter - offset3;
    textGridWidths[2] = xCenter - offset3;
    textGridHeights[3] = yCenter;
    textGridWidths[3] = xCenter;
    textGridHeights[4] = yCenter + offset3;
    textGridWidths[4] = xCenter + offset3;
    textGridHeights[5] = yCenter + offset2;
    textGridWidths[5] = xCenter + offset2;
    textGridHeights[6] = yCenter + offset1;
    textGridWidths[6] = xCenter + offset1;
  }
コード例 #17
0
 /**
  * Calculate the bounds for a view's title
  *
  * @param index
  * @param paint
  * @return
  */
 private Rect calcBounds(int index, Paint paint) {
   // Calculate the text bounds
   Rect bounds = new Rect();
   CharSequence title = getTitle(index);
   bounds.right = (int) paint.measureText(title, 0, title.length());
   bounds.bottom = (int) (paint.descent() - paint.ascent());
   return bounds;
 }
コード例 #18
0
 /**
  * Calculate the bounds for a view's title
  *
  * @param index
  * @param paint
  * @return
  */
 private Rect calcBounds(int index, Paint paint) {
   // Get the title
   String title = getTitle(index);
   // Calculate the text bounds
   Rect bounds = new Rect();
   bounds.right = (int) paint.measureText(title);
   bounds.bottom = (int) (paint.descent() - paint.ascent());
   return bounds;
 }
コード例 #19
0
ファイル: Cell.java プロジェクト: nagyist/emobc-android
  public Cell(int dayOfMon, Rect rect, float textSize, boolean bold) {
    mDayOfMonth = dayOfMon;
    mBound = rect;
    mPaint.setTextSize(textSize /*26f*/);
    mPaint.setColor(Color.BLACK);
    if (bold) mPaint.setFakeBoldText(true);

    dx = (int) mPaint.measureText(String.valueOf(mDayOfMonth)) / 2;
    dy = (int) (-mPaint.ascent() + mPaint.descent()) / 2;
  }
コード例 #20
0
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    mInnerRectF.set(0, 0, canvas.getWidth(), canvas.getHeight());
    final int halfBorder = (int) (mStrokePaint.getStrokeWidth() / 2f + 0.5f);
    mInnerRectF.inset(halfBorder, halfBorder);

    canvas.drawArc(mInnerRectF, 0, 360, true, mBackgroundPaint);

    switch (mProgressFillType) {
      case FILL_TYPE_RADIAL:
        float sweepAngle = 360 * mProgress / mMax;
        canvas.drawArc(mInnerRectF, mStartAngle, sweepAngle, true, mProgressPaint);
        break;
      case FILL_TYPE_CENTER:
        float centerX = canvas.getWidth() / 2;
        float centerY = canvas.getHeight() / 2;
        float radius = (canvas.getWidth() / 2) * ((float) mProgress / mMax);
        canvas.drawCircle(
            centerX, centerY, radius + 0.5f - mStrokePaint.getStrokeWidth(), mProgressPaint);
        break;
      default:
        throw new IllegalArgumentException("Invalid Progress Fill = " + mProgressFillType);
    }

    if (!TextUtils.isEmpty(mText) && mShowText) {
      if (!TextUtils.isEmpty(mTypeface)) {
        Typeface typeface = sTypefaceCache.get(mTypeface);
        if (null == typeface && null != getResources()) {
          AssetManager assets = getResources().getAssets();
          if (null != assets) {
            typeface = Typeface.createFromAsset(assets, mTypeface);
            sTypefaceCache.put(mTypeface, typeface);
          }
        }
        mTextPaint.setTypeface(typeface);
      }
      int xPos = canvas.getWidth() / 2;
      int yPos =
          (int) ((canvas.getHeight() / 2) - ((mTextPaint.descent() + mTextPaint.ascent()) / 2));
      canvas.drawText(mText, xPos, yPos, mTextPaint);
    }

    if (null != mImage && mShowImage) {
      int drawableSize = mImage.getIntrinsicWidth();
      mImageRect.set(0, 0, drawableSize, drawableSize);
      mImageRect.offset((getWidth() - drawableSize) / 2, (getHeight() - drawableSize) / 2);
      mImage.setBounds(mImageRect);
      mImage.draw(canvas);
    }

    if (mShowStroke) {
      canvas.drawOval(mInnerRectF, mStrokePaint);
    }
  }
コード例 #21
0
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    float startAngle = 360 - arcAngle / 2f;
    float finishedSweepAngle = progress / (float) getMax() * arcAngle;
    float finishedStartAngle = startAngle;
    paint.setColor(unfinishedStrokeColor);
    canvas.drawArc(rectF, startAngle, arcAngle, false, paint);
    canvas.save();
    canvas.rotate(90, getWidth() / 2, getHeight() / 2);
    paint.setColor(finishedStrokeColor);
    canvas.drawArc(rectF, finishedStartAngle, finishedSweepAngle, false, paint);
    canvas.restore();
    String text = String.valueOf(getProgress());
    if (!TextUtils.isEmpty(text)) {
      textPaint.setColor(textColor);
      textPaint.setTextSize(textSize);
      float textHeight = textPaint.descent() + textPaint.ascent();
      float textBaseline = (getHeight() - textHeight) / 2.0f;
      canvas.drawText(
          text, (getWidth() - textPaint.measureText(text)) / 2.0f, textBaseline, textPaint);
      textPaint.setTextSize(suffixTextSize);
      float suffixHeight = textPaint.descent() + textPaint.ascent();
      canvas.drawText(
          suffixText,
          getWidth() / 2.0f + textPaint.measureText(text) + suffixTextPadding,
          textBaseline + textHeight - suffixHeight,
          textPaint);
    }

    if (!TextUtils.isEmpty(getBottomText())) {
      textPaint.setTextSize(bottomTextSize);
      float bottomTextBaseline =
          getHeight() - arcBottomHeight - (textPaint.descent() + textPaint.ascent()) / 2;
      canvas.drawText(
          getBottomText(),
          (getWidth() - textPaint.measureText(getBottomText())) / 2.0f,
          bottomTextBaseline,
          textPaint);
    }
  }
コード例 #22
0
 private void drawTextWhenFill(int size, float degrees, Canvas canvas, boolean isTop) {
   canvas.save();
   canvas.rotate(degrees, size / 2f, size / 2f);
   float delta = isTop ? -size / 4 : size / 4;
   float textBaseY = size / 2 - (mTextPaint.descent() + mTextPaint.ascent()) / 2 + delta;
   canvas.drawText(
       mTextAllCaps ? mTextContent.toUpperCase() : mTextContent,
       getPaddingLeft() + (size - getPaddingLeft() - getPaddingRight()) / 2,
       textBaseY,
       mTextPaint);
   canvas.restore();
 }
コード例 #23
0
 public Bitmap makeOverlay(String text) {
   Rect b = new Rect();
   paint.getTextBounds(text, 0, text.length(), b);
   int bwidth = b.width() + 2;
   int bheight = b.height() + 2;
   Bitmap bm = Bitmap.createBitmap(bwidth, bheight, Bitmap.Config.ARGB_8888);
   Canvas c = new Canvas(bm);
   paint.setColor(overlayBackgroundColor);
   c.drawRect(0, 0, bwidth, bheight, paint);
   paint.setColor(overlayTextColor);
   c.drawText(
       text, -b.left + 1, (bheight / 2) - ((paint.ascent() + paint.descent()) / 2) + 1, paint);
   return bm;
 }
コード例 #24
0
  public Cell(int year, int month, int dayOfMon, Rect rect, float textSize, boolean bold) {

    this.year = year;
    this.month = month;
    mDayOfMonth = dayOfMon;
    mBound = rect;
    mPaint = new Paint(Paint.SUBPIXEL_TEXT_FLAG | Paint.ANTI_ALIAS_FLAG);
    mPaint.setTextSize(textSize);
    mPaint.setColor(Color.WHITE);
    if (bold) {
      mPaint.setFakeBoldText(true);
    }
    dx = (int) mPaint.measureText(String.valueOf(mDayOfMonth)) / 2;
    dy = (int) (-mPaint.ascent() + mPaint.descent()) / 2;
  }
コード例 #25
0
  /**
   * Calculate the bounds for a view's title
   *
   * @param index
   * @param paint
   * @return
   */
  private Rect calcBounds(int index, Paint paint) {
    // Calculate the text bounds
    Rect bounds = new Rect();
    CharSequence title = getTitle(index);
    bounds.right = (int) paint.measureText(title, 0, title.length());
    bounds.bottom = (int) (paint.descent() - paint.ascent());

    Drawable icon = getIcon(index);
    if (icon != null) {
      Rect iconBounds = icon.getBounds();
      bounds.right += iconBounds.width() + mIconPadding;
    }

    return bounds;
  }
コード例 #26
0
  public boolean exportBitmap(String strPath, int nWidth, int nHeight) {
    Bitmap bitmap = null;

    if (null == mBitmap) {
      bitmap = BitmapFactory.decodeFile(mstrBackground);
    } else {
      bitmap = Bitmap.createBitmap(nWidth, nHeight, Bitmap.Config.ARGB_8888);
      Canvas canvas = new Canvas(bitmap);
      draw(canvas);
      if (null != mstrText) {
        // canvas.drawText(mstrText, 40, 40, mPaint);
        // new antialised Paint
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        // text color - #3D3D3D
        paint.setColor(Color.rgb(61, 61, 61));
        // text size in pixels
        paint.setTextSize(24);
        // text shadow
        paint.setShadowLayer(1f, 0f, 1f, Color.WHITE);

        // draw text to the Canvas center
        Rect bounds = new Rect();
        paint.getTextBounds(mstrText, 0, mstrText.length(), bounds);
        int x = (bitmap.getWidth() - bounds.width()) / 2;
        int y = (bitmap.getHeight() + bounds.height()) / 2;

        canvas.drawText(mstrText, x, y, paint);

        for (String line : mstrText.split("\n")) {
          canvas.drawText(line, x, y, paint);
          y += -paint.ascent() + paint.descent();
        }
      }
    }

    FileOutputStream out;
    try {
      out = new FileOutputStream(strPath);
      bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
      bitmap.recycle();
      return true;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return false;
  }
コード例 #27
0
  @Override
  protected synchronized void onDraw(Canvas canvas) {
    canvas.save();
    canvas.translate(getPaddingLeft(), getHeight() / 2);

    // 是否需要绘制默认进度条
    boolean noNeedUnReach = false;

    String text = getProgress() + "%";
    // 计算文本的宽度
    int textWidth = (int) mPaint.measureText(text);

    /** draw reach */
    // 当前进度比例
    float radio = getProgress() * 1.0f / getMax();
    float progressX = radio * mRealWidth;
    // 当前进度加文本宽度超过最大宽度时,不再绘制默认进度
    if (progressX + textWidth > mRealWidth) {
      progressX = mRealWidth - textWidth;
      noNeedUnReach = true;
    }
    float endX = progressX - mTextOffset / 2;
    if (endX > 0) {
      mPaint.setColor(mReachColor);
      mPaint.setStrokeWidth(mReachHeight);
      canvas.drawLine(0, 0, endX, 0, mPaint);
    }

    /** draw text */
    mPaint.setColor(mTextColor);
    int y = (int) (-(mPaint.descent() + mPaint.ascent()) / 2);
    canvas.drawText(text, progressX, y, mPaint);

    /** draw unReach */
    if (!noNeedUnReach) {
      float start = progressX + mTextOffset / 2 + textWidth;
      mPaint.setColor(mUnReachColor);
      mPaint.setStrokeWidth(mUnReachHeight);
      canvas.drawLine(start, 0, mRealWidth, 0, mPaint);
    }

    canvas.restore();
  }
コード例 #28
0
  /**
   * Determines the height of this view
   *
   * @param measureSpec A measureSpec packed into an int
   * @return The height of the view, honoring constraints from measureSpec
   */
  private int measureHeight(int measureSpec) {
    float result = 0;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);

    if (specMode == MeasureSpec.EXACTLY) {
      // We were told how big to be
      result = specSize;
    } else {
      // Calculate the text bounds
      RectF bounds = new RectF();
      bounds.bottom = mPaintText.descent() - mPaintText.ascent();
      result = bounds.bottom - bounds.top + mFooterLineHeight + mFooterPadding + mTopPadding;
      if (mFooterIndicatorStyle != IndicatorStyle.None) {
        result += mFooterIndicatorHeight;
      }
    }
    return (int) result;
  }
コード例 #29
0
 /** 设置未读消息偏移,原点为文字的右上角.当控件高度固定,消息提示位置易控制,显示效果佳 */
 public void setMsgMargin(int position, float leftPadding, float bottomPadding) {
   if (position >= mTabCount) {
     position = mTabCount - 1;
   }
   View tabView = mTabsContainer.getChildAt(position);
   MsgView tipView = (MsgView) tabView.findViewById(R.id.rtv_msg_tip);
   if (tipView != null) {
     TextView tv_tab_title = (TextView) tabView.findViewById(R.id.tv_tab_title);
     mTextPaint.setTextSize(mTextsize);
     float textWidth = mTextPaint.measureText(tv_tab_title.getText().toString());
     float textHeight = mTextPaint.descent() - mTextPaint.ascent();
     MarginLayoutParams lp = (MarginLayoutParams) tipView.getLayoutParams();
     lp.leftMargin =
         mTabWidth >= 0
             ? (int) (mTabWidth / 2 + textWidth / 2 + dp2px(leftPadding))
             : (int) (mTabPadding + textWidth + dp2px(leftPadding));
     lp.topMargin = mHeight > 0 ? (int) (mHeight - textHeight) / 2 - dp2px(bottomPadding) : 0;
     tipView.setLayoutParams(lp);
   }
 }
コード例 #30
0
  /**
   * Determines the height of this view
   *
   * @param measureSpec A measureSpec packed into an int
   * @return The height of the view, honoring constraints from measureSpec
   */
  private int measureHeight(int measureSpec) {
    int result = 0;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);

    // We were told how big to be
    if (specMode == MeasureSpec.EXACTLY) {
      result = specSize;
    }
    // Measure the height
    else {
      // Calculate the text bounds
      Rect bounds = new Rect();
      bounds.bottom = (int) (paintText.descent() - paintText.ascent());
      result =
          bounds.bottom - bounds.top + (int) footerTriangleHeight + (int) footerLineHeight + 10;
      return result;
    }
    return result;
  }