Ejemplo n.º 1
0
    private void drawTriangle(Canvas c, float startAngle, float sweepAngle, Rect bounds) {
      if (mShowArrow) {
        if (mArrow == null) {
          mArrow = new Path();
          mArrow.setFillType(Path.FillType.EVEN_ODD);
        } else {
          mArrow.reset();
        }

        // Adjust the position of the triangle so that it is inset as
        // much as the arc, but also centered on the arc.
        float inset = (int) mStrokeInset / 2 * mArrowScale;
        float x = (float) (mRingCenterRadius * Math.cos(0) + bounds.exactCenterX());
        float y = (float) (mRingCenterRadius * Math.sin(0) + bounds.exactCenterY());

        // Update the path each time. This works around an issue in SKIA
        // where concatenating a rotation matrix to a scale matrix
        // ignored a starting negative rotation. This appears to have
        // been fixed as of API 21.
        mArrow.moveTo(0, 0);
        mArrow.lineTo(mArrowWidth * mArrowScale, 0);
        mArrow.lineTo((mArrowWidth * mArrowScale / 2), (mArrowHeight * mArrowScale));
        mArrow.offset(x - inset, y);
        mArrow.close();
        // draw a triangle
        mArrowPaint.setColor(mColors[mColorIndex]);
        c.rotate(
            startAngle + sweepAngle - ARROW_OFFSET_ANGLE,
            bounds.exactCenterX(),
            bounds.exactCenterY());
        c.drawPath(mArrow, mArrowPaint);
      }
    }
  @Override
  protected boolean onStateChange(int[] state) {
    boolean pressed = ViewUtil.hasState(state, android.R.attr.state_pressed);

    if (mPressed != pressed) {
      mPressed = pressed;

      if (mPressed) {
        Rect bounds = getBounds();

        if (mState == STATE_OUT || mState == STATE_RELEASE) {
          if (mRippleType == TYPE_WAVE || mRippleType == TYPE_TOUCH_MATCH_VIEW)
            mMaxRippleRadius = getMaxRippleRadius(bounds.exactCenterX(), bounds.exactCenterY());

          setRippleEffect(bounds.exactCenterX(), bounds.exactCenterY(), 0);
          setRippleState(STATE_PRESS);
        } else if (mRippleType == TYPE_TOUCH)
          setRippleEffect(bounds.exactCenterX(), bounds.exactCenterY(), mRippleRadius);
      } else {
        if (mState != STATE_OUT) {
          if (mState == STATE_HOVER) {
            if (mRippleType == TYPE_WAVE || mRippleType == TYPE_TOUCH_MATCH_VIEW)
              setRippleEffect(mRipplePoint.x, mRipplePoint.y, 0);

            setRippleState(STATE_RELEASE);
          } else setRippleState(STATE_RELEASE_ON_HOLD);
        }
      }

      return true;
    }

    return false;
  }
 @Override
 protected void onBoundsChange(Rect bounds) {
   mBoxRect.set(
       bounds.exactCenterX() - mBoxSize / 2,
       bounds.exactCenterY() - mBoxSize / 2,
       bounds.exactCenterX() + mBoxSize / 2,
       bounds.exactCenterY() + mBoxSize / 2);
 }
Ejemplo n.º 4
0
 public final void draw(Canvas paramCanvas) {
   Rect localRect = getBounds();
   int i = paramCanvas.save();
   paramCanvas.rotate(this.mRotation, localRect.exactCenterX(), localRect.exactCenterY());
   Ring localRing = this.mRing;
   RectF localRectF = localRing.mTempBounds;
   localRectF.set(localRect);
   localRectF.inset(localRing.mStrokeInset, localRing.mStrokeInset);
   float f1 = 360.0F * (localRing.mStartTrim + localRing.mRotation);
   float f2 = 360.0F * (localRing.mEndTrim + localRing.mRotation) - f1;
   localRing.mPaint.setColor(localRing.mCurrentColor);
   paramCanvas.drawArc(localRectF, f1, f2, false, localRing.mPaint);
   if (localRing.mShowArrow) {
     if (localRing.mArrow != null) {
       break label427;
     }
     localRing.mArrow = new Path();
     localRing.mArrow.setFillType(Path.FillType.EVEN_ODD);
   }
   for (; ; ) {
     float f3 = (int) localRing.mStrokeInset / 2 * localRing.mArrowScale;
     float f4 = (float) (localRing.mRingCenterRadius * Math.cos(0.0D) + localRect.exactCenterX());
     float f5 = (float) (localRing.mRingCenterRadius * Math.sin(0.0D) + localRect.exactCenterY());
     localRing.mArrow.moveTo(0.0F, 0.0F);
     localRing.mArrow.lineTo(localRing.mArrowWidth * localRing.mArrowScale, 0.0F);
     localRing.mArrow.lineTo(
         localRing.mArrowWidth * localRing.mArrowScale / 2.0F,
         localRing.mArrowHeight * localRing.mArrowScale);
     localRing.mArrow.offset(f4 - f3, f5);
     localRing.mArrow.close();
     localRing.mArrowPaint.setColor(localRing.mCurrentColor);
     paramCanvas.rotate(f1 + f2 - 5.0F, localRect.exactCenterX(), localRect.exactCenterY());
     paramCanvas.drawPath(localRing.mArrow, localRing.mArrowPaint);
     if (localRing.mAlpha < 255) {
       localRing.mCirclePaint.setColor(localRing.mBackgroundColor);
       localRing.mCirclePaint.setAlpha(255 - localRing.mAlpha);
       paramCanvas.drawCircle(
           localRect.exactCenterX(),
           localRect.exactCenterY(),
           localRect.width() / 2,
           localRing.mCirclePaint);
     }
     paramCanvas.restoreToCount(i);
     return;
     label427:
     localRing.mArrow.reset();
   }
 }
Ejemplo n.º 5
0
  private void updatePath() {
    float radius = getWidth() / 20;
    float arrowHeight = getHeight() / 4;

    Rect rect = new Rect(2, 2, this.getWidth() - 4, this.getHeight() - 4);

    mPath = new Path();
    mPath.moveTo(rect.left + radius, rect.top);
    mPath.lineTo(rect.right, rect.top);
    mPath.lineTo(rect.right, rect.bottom - arrowHeight);
    mPath.lineTo(rect.exactCenterX(), rect.bottom);
    mPath.lineTo(rect.left, rect.bottom - arrowHeight);
    mPath.lineTo(rect.left, rect.top);
    mPath.close();

    int color = this.getContext().getResources().getColor(R.color.tag_unselected_outline);
    if (mIsActive) color = this.getContext().getResources().getColor(R.color.tag_selected_outline);

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setColor(color);
    mPaint.setStyle(Paint.Style.FILL);
    mPaint.setStrokeWidth(0);
    mPaint.setStrokeJoin(Paint.Join.ROUND); // set the join to round you
    // want
    mPaint.setStrokeCap(Paint.Cap.ROUND); // set the paint cap to round too
    mPaint.setPathEffect(new CornerPathEffect(radius)); // set the path
    // effect when they

    color = this.getContext().getResources().getColor(R.color.tag_unselected);
    if (mIsActive) color = this.getContext().getResources().getColor(R.color.tag_selected);
    mShader = new LinearGradient(0, 0, 0, getHeight(), color, color, Shader.TileMode.CLAMP);
  }
Ejemplo n.º 6
0
 @Override
 public void draw(Canvas canvas) {
   canvas.save();
   canvas.rotate(rotation, drawableArea.exactCenterX(), drawableArea.exactCenterY());
   canvas.drawPath(glyphPath, glyphPaint);
   canvas.restore();
 }
  /**
   * Shrink the {@code shrinkTarget} rectangle to snugly fit inside of {@code reference}; the aspect
   * ratio of {@code shrinkTarget} will change to be the same aspect ratio as {@code reference}.
   *
   * <p>At most a single dimension will scale (down). Both dimensions will never be scaled.
   *
   * @param reference the rectangle whose aspect ratio will be used as the new aspect ratio
   * @param shrinkTarget the rectangle which will be scaled down to have a new aspect ratio
   * @return a new rectangle, a subset of {@code shrinkTarget}, whose aspect ratio will match that
   *     of {@code reference}
   */
  private static Rect shrinkToSameAspectRatioCentered(Rect reference, Rect shrinkTarget) {
    float aspectRatioReference = reference.width() * 1.0f / reference.height();
    float aspectRatioShrinkTarget = shrinkTarget.width() * 1.0f / shrinkTarget.height();

    float cropH, cropW;
    if (aspectRatioShrinkTarget < aspectRatioReference) {
      // The new width must be smaller than the height, so scale the width by AR
      cropH = reference.height();
      cropW = cropH * aspectRatioShrinkTarget;
    } else {
      // The new height must be smaller (or equal) than the width, so scale the height by AR
      cropW = reference.width();
      cropH = cropW / aspectRatioShrinkTarget;
    }

    Matrix translateMatrix = new Matrix();
    RectF shrunkRect = new RectF(shrinkTarget);

    // Scale the rectangle down, but keep its center in the same place as before
    translateMatrix.setScale(
        cropW / reference.width(),
        cropH / reference.height(),
        shrinkTarget.exactCenterX(),
        shrinkTarget.exactCenterY());

    translateMatrix.mapRect(/*inout*/ shrunkRect);

    return ParamsUtils.createRect(shrunkRect);
  }
  private void init() {
    if (mPaint == null) {
      mPaint = new Paint();
      mPaint.setColor(Color.WHITE);
      mPaint.setAntiAlias(true);
      mPaint.setStyle(Paint.Style.FILL);
    }

    int count = (mPoints - 1) * 4;
    posX = new float[count];
    posY = new float[count];

    Rect bounds = new Rect();
    bounds.set(getBounds());
    bounds.inset(mPadding, mPadding);

    // circumference
    float circ = (float) (Math.PI * (float) Math.min(bounds.width(), bounds.height()));
    float arcLength = circ / count;

    mSize = (float) ((arcLength) / (2 * Math.PI));

    double degrees = Math.toRadians((float) 360 / (float) count);
    for (int i = 0; i < count; i++) {
      posX[i] = (float) (bounds.exactCenterX() - (bounds.width() / 2) * Math.sin(degrees * i));
      posY[i] = (float) (bounds.exactCenterY() + (bounds.height() / 2) * Math.cos(degrees * i));
    }
  }
 public void draw(Canvas paramCanvas)
 {
   Rect localRect = getBounds();
   int i = paramCanvas.save();
   paramCanvas.rotate(mRotation, localRect.exactCenterX(), localRect.exactCenterY());
   mRing.draw(paramCanvas, localRect);
   paramCanvas.restoreToCount(i);
 }
Ejemplo n.º 10
0
 @Override
 public void draw(Canvas c) {
   final Rect bounds = getBounds();
   final int saveCount = c.save();
   c.rotate(mRotation, bounds.exactCenterX(), bounds.exactCenterY());
   mRing.draw(c, bounds);
   c.restoreToCount(saveCount);
 }
Ejemplo n.º 11
0
 @Override
 protected void onPostDraw(Canvas canvas, Rect rect) {
   paintStroke.setColor(DARK_GRAY);
   final float size = recalc(rect, 23.783f);
   paintStroke.setStrokeWidth(8 * rect.width() / 1000f);
   canvas.drawLine(
       rect.exactCenterX() - size,
       rect.exactCenterY() - size,
       rect.exactCenterX() + size,
       rect.exactCenterY() + size,
       paintStroke);
   canvas.drawLine(
       rect.exactCenterX() - size,
       rect.exactCenterY() + size,
       rect.exactCenterX() + size,
       rect.exactCenterY() - size,
       paintStroke);
 }
 @Override
 protected void onDraw(Canvas canvas) {
   final int saveCount = canvas.save();
   Rect rect = mDrawable.getBounds();
   int l = getPaddingLeft() + (getMeasuredWidth() - mDrawable.getIntrinsicWidth()) / 2;
   canvas.translate(l, getPaddingTop());
   canvas.scale(mScale, mScale, rect.exactCenterX(), rect.exactCenterY());
   mDrawable.draw(canvas);
   canvas.restoreToCount(saveCount);
 }
Ejemplo n.º 13
0
  @Override
  protected void onDraw(Canvas canvas) {
    try {
      int height = getHeight() / 10;
      Bitmap state =
          State == 7
              ? StateSplash4
              : State == 6
                  ? StateSplash3
                  : State == 5
                      ? StateSplash2
                      : State == 4
                          ? StateSplash1
                          : State == 3
                              ? StateLand
                              : State == 2 ? StateFly : State == 1 ? StateJump : StateSit;

      if (Position == null) {
        X = (int) GameStat.RoseStart.exactCenterX();
        Y = (int) GameStat.RoseStart.exactCenterY();

        Y -= height;
        X -= height / 2;

        Position = new Rect(X, Y, X + height, Y + height);
      }

      if (Charge > 0 && State == 0) {

        int si = Charge + 5;
        Drop.setStrokeWidth(Position.width() / 2);
        Drop.setPathEffect(
            new DashPathEffect(new float[] {Position.width() / 8, Position.width()}, 0));

        Path p = new Path();
        p.moveTo(Position.exactCenterX(), Position.exactCenterY());
        p.lineTo(MovePoint.x, MovePoint.y);

        canvas.drawPath(p, Drop);
      }
      Scorer.setTextSize(getHeight() / 8);
      Scorer.setFakeBoldText(true);
      // Scorer.setShadowLayer(10, 10, 10, Color.DKGRAY);

      canvas.drawText(
          String.valueOf(Score),
          FontHelper.drawTextX(String.valueOf(Score), Scorer, getWidth() / 2),
          0 + getHeight() / 8,
          Scorer);

      BitmapHelper.drawIn(canvas, Position, state);
    } catch (Exception e) {
    }
  }
Ejemplo n.º 14
0
 @Override
 public void draw(Canvas canvas) {
   if (mBitmap != null) {
     Rect bounds = getBounds();
     float x = bounds.exactCenterX();
     float y = bounds.exactCenterY();
     float radius = bounds.height() / 2f;
     mPaint.setShader(mBitmapShader);
     canvas.drawCircle(x, y, radius, mPaint);
   }
 }
Ejemplo n.º 15
0
 public static Bitmap getRoundBitmap(Bitmap bitmap) {
   int width = bitmap.getWidth();
   int height = bitmap.getHeight();
   Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);
   Canvas canvas = new Canvas(output);
   final int color = 0xff424242;
   final Paint paint = new Paint();
   final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
   paint.setAntiAlias(true);
   canvas.drawARGB(0, 0, 0, 0);
   paint.setColor(color);
   if (width <= height) {
     canvas.drawCircle(rect.exactCenterX(), rect.exactCenterY(), (rect.width() / 2) - 3, paint);
   } else {
     canvas.drawCircle(rect.exactCenterX(), rect.exactCenterY(), (rect.height() / 2) - 3, paint);
   }
   paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
   canvas.drawBitmap(bitmap, rect, rect, paint);
   return output;
 }
Ejemplo n.º 16
0
  @Override
  protected void onDraw(Canvas canvas) {
    if (userLocation == null || !userLocation.hasAccuracy() || displayState == null) {
      return;
    }
    // Figure out distance from user location to screen center point
    float[] mapLonLat = displayState.getScreenCenterGeoLocation();
    screenCenterLocation.setLatitude(mapLonLat[1]);
    screenCenterLocation.setLongitude(mapLonLat[0]);
    int distanceM = Math.round(userLocation.distanceTo(screenCenterLocation));
    int accuracyM = Math.round(userLocation.getAccuracy());

    // Don't draw if centered
    if (distanceM == 0) {
      return;
    }

    // Format the distance and accuracy nicely
    String distanceStr;
    if (PreferenceStore.instance(getContext()).isMetric()) {
      distanceStr = getMetricDistanceString(distanceM, accuracyM);
    } else {
      distanceStr = getEnglishDistanceString(distanceM, accuracyM);
    }

    // Compute the pixel size of the distanceStr
    // -- set font size based on canvas density (dpi)
    textPaint.setTextSize(ptsToPixels(textSizePt, canvas));
    Rect distanceBox = new Rect();
    textPaint.getTextBounds(distanceStr, 0, distanceStr.length(), distanceBox);
    distanceBox.offsetTo(0, 0);
    int padding = Math.round(ptsToPixels(paddingPt, canvas));
    distanceBox.right += 2 * padding;
    distanceBox.bottom += 2 * padding;
    distanceBox.offset((getWidth() - distanceBox.width()) / 2, getHeight() - distanceBox.height());
    float baseline = distanceBox.bottom - padding;
    backgroundPaint.setAlpha(192);
    backgroundPaint.setStyle(Paint.Style.FILL);
    textPaint.setStrokeWidth(1f);
    textPaint.setStyle(Paint.Style.FILL_AND_STROKE);
    canvas.drawRoundRect(new RectF(distanceBox), padding, padding, backgroundPaint);
    canvas.drawText(distanceStr, distanceBox.exactCenterX(), baseline, textPaint);

    // Draw center circles
    int x = getWidth() / 2;
    int y = getHeight() / 2;
    backgroundPaint.setAlpha(255);
    backgroundPaint.setStyle(Paint.Style.STROKE);
    textPaint.setStrokeWidth(2f);
    textPaint.setStyle(Paint.Style.STROKE);
    canvas.drawCircle(x, y, 5, backgroundPaint);
    canvas.drawCircle(x, y, 5, textPaint);
  }
Ejemplo n.º 17
0
 @Override
 public void draw(Canvas c) {
   Rect bounds = getBounds();
   final int saveCount = c.save();
   c.translate(0, mTop);
   mCircle.draw(c);
   // c.scale((float)mWidth / bounds.width(), (float)mHeight /
   // bounds.height());
   c.rotate(mRotation, bounds.exactCenterX(), bounds.exactCenterY());
   mRing.draw(c, bounds);
   c.restoreToCount(saveCount);
 }
Ejemplo n.º 18
0
  @Override
  protected void onDraw(Canvas canvas) {
    canvasNew = canvas;

    // one time function
    if (firstDrawBallRect) {
      canvasHeight = canvas.getHeight();
      canvasWidth = canvas.getWidth();
      // dim = canvasWidth/5;
      ballRectX = canvasWidth / 2 - dim / 2;
      ballRectY = canvasHeight - dim;
      ballRect =
          new Rect(
              canvasWidth / 2 - dim / 2,
              canvasHeight - dim,
              canvasWidth / 2 + dim / 2,
              canvasHeight);
      firstDrawBallRect = false;
    }

    // drawing the paths and connectors
    paint.setColor(pathPaint);
    rect =
        new Rect(
            canvasWidth / 2 - dim / 2 - 10,
            canvasHeight / 2,
            canvasWidth / 2 + dim / 2 + 10,
            canvasHeight);
    canvas.drawRect(rect, paint);

    conRect = new Rect(rect.left, rect.top - dim, rect.right, rect.top + dim);
    canvas.drawRect(conRect, paint);

    rect2 = new Rect(conRect.left, rect.top - rect.width(), canvasWidth - 200, rect.top);
    canvas.drawRect(rect2, paint);

    // drawing the goal
    paint.setColor(Color.CYAN);
    goal = new Rect(rect2.right - 110, rect2.top + 10, rect2.right - 10, rect2.bottom - 10);
    canvas.drawRect(goal, paint);

    // drawing the ball
    paint.setColor(ballPaint);
    canvas.drawRect(ballRect, paint);

    // drawing the text
    paint.setColor(textPaint);
    paint.setTextSize(40);
    canvas.drawText(
        "Ball at (" + ballRect.exactCenterX() + "," + ballRect.exactCenterY() + ")", 30, 50, paint);

    invalidate();
  }
  @Override
  public void draw(Canvas c) {
    if (mShadow != null) {
      mShadow.getPaint().setColor(mBackgroundColor);
      mShadow.draw(c);
    }

    final Rect bounds = getBounds();
    final int saveCount = c.save();
    c.rotate(mRotation, bounds.exactCenterX(), bounds.exactCenterY());
    mRing.draw(c, bounds);
    c.restoreToCount(saveCount);
  }
Ejemplo n.º 20
0
    private void updateMatrix() {
      if (mBitmap == null) return;

      Rect bounds = getBounds();
      if (bounds.width() == 0 || bounds.height() == 0) return;

      mMatrix.reset();
      float scale = bounds.height() / (float) Math.min(mBitmap.getWidth(), mBitmap.getHeight());
      mMatrix.setScale(scale, scale, 0, 0);
      mMatrix.postTranslate(
          bounds.exactCenterX() - mBitmap.getWidth() * scale / 2,
          bounds.exactCenterY() - mBitmap.getHeight() * scale / 2);

      mBitmapShader.setLocalMatrix(mMatrix);
    }
Ejemplo n.º 21
0
  private void applyZoomToCurrentRect(float animationProgress) {
    if (mSourceRect == null) return;
    if (mCurrentRect == null) mCurrentRect = new Rect();

    mCurrentRect.set(
        mSourceRect.left + (((int) (mCurrentZoom * mSourceRect.width()) / 2)),
        mSourceRect.top + (((int) (mCurrentZoom * mSourceRect.height()) / 2)),
        mSourceRect.right - (((int) (mCurrentZoom * mSourceRect.width()) / 2)),
        mSourceRect.bottom - (((int) (mCurrentZoom * mSourceRect.height()) / 2)));

    if (mFocalPoint != null)
      mCurrentRect.offset(
          ((int) ((mFocalPoint.x - mSourceRect.exactCenterX()) * animationProgress)),
          ((int) ((mFocalPoint.y - mSourceRect.exactCenterY()) * animationProgress)));

    fixCurrentRectBounds();
  }
Ejemplo n.º 22
0
  /**
   * Emulates a tap event positioned at the center of the selected view. No-op if no view is
   * selected.
   */
  private void tapSelectedView() {
    if (mSelectedView == null) {
      return;
    }

    final float centerX = mSelectedRect.exactCenterX();
    final float centerY = mSelectedRect.exactCenterY();
    final long currTime = SystemClock.uptimeMillis();

    MotionEvent down =
        MotionEvent.obtain(currTime, currTime, MotionEvent.ACTION_DOWN, centerX, centerY, 0);
    MotionEvent up =
        MotionEvent.obtain(currTime, currTime, MotionEvent.ACTION_UP, centerX, centerY, 0);

    super.dispatchTouchEvent(down);
    super.dispatchTouchEvent(up);
  }
    /** Draw the progress spinner */
    public void draw(Canvas c, Rect bounds) {

      mCirclePaint.setColor(mBackgroundColor);
      mCirclePaint.setAlpha(mAlpha);

      c.drawCircle(bounds.exactCenterX(), bounds.exactCenterY(), bounds.width() / 2, mCirclePaint);

      final RectF arcBounds = mTempBounds;
      arcBounds.set(bounds);
      arcBounds.inset(mStrokeInset, mStrokeInset);
      final float startAngle = (mStartTrim + mRotation) * 360;
      final float endAngle = (mEndTrim + mRotation) * 360;
      float sweepAngle = endAngle - startAngle;
      mArcPaint.setColor(mColors[mColorIndex]);
      mArcPaint.setAlpha(mAlpha);
      c.drawArc(arcBounds, startAngle, sweepAngle, false, mArcPaint);
      drawTriangle(c, startAngle, sweepAngle, bounds);
    }
 private void drawLetter(Canvas canvas, float cx, float cy) {
   mLetterPaint.setColor(mLetterColor);
   mLetterPaint.setTextSize(spToPx(mLetterSize, context.getResources()));
   if (mInitials) {
     mLetterPaint.getTextBounds(
         mLetter,
         0,
         mInitialsNumber > mLetter.length() ? mLetter.length() : mInitialsNumber,
         textBounds);
   } else {
     mLetterPaint.getTextBounds(
         mLetter,
         0,
         mLettersNumber > mLetter.length() ? mLetter.length() : mLettersNumber,
         textBounds);
   }
   canvas.drawText(
       mLetter, cx - textBounds.exactCenterX(), cy - textBounds.exactCenterY(), mLetterPaint);
 }
  @Override
  public void draw(Canvas canvas) {
    final Rect r = new Rect(getBounds());
    if (canvas.getClipBounds(sTempRect) && !Rect.intersects(sTempRect, r)) {
      // The draw region has been clipped.
      return;
    }
    if (mIndicatorRectDirty) {
      initIndicatorRect();
    }
    final float iconScale;

    if ((mAnimationProgress >= ANIMATION_PROGRESS_STARTED)
        && (mAnimationProgress < ANIMATION_PROGRESS_COMPLETED)) {
      mPaint.setAlpha((int) ((1 - mAnimationProgress) * 255));
      mBgDrawable.setAlpha(mPaint.getAlpha());
      mBgDrawable.draw(canvas);
      canvas.drawOval(mIndicatorRect, mPaint);

      iconScale = ICON_SCALE_FACTOR + (1 - ICON_SCALE_FACTOR) * mAnimationProgress;
    } else if (mAnimationProgress == ANIMATION_PROGRESS_STOPPED) {
      mPaint.setAlpha(255);
      iconScale = ICON_SCALE_FACTOR;
      mBgDrawable.setAlpha(255);
      mBgDrawable.draw(canvas);

      if (mProgress >= 100) {
        canvas.drawOval(mIndicatorRect, mPaint);
      } else if (mProgress > 0) {
        canvas.drawArc(mIndicatorRect, -90, mProgress * 3.6f, false, mPaint);
      }
    } else {
      iconScale = 1;
    }

    canvas.save();
    canvas.scale(iconScale, iconScale, r.exactCenterX(), r.exactCenterY());
    mIcon.draw(canvas);
    canvas.restore();
  }
  /**
   * Get the available 'crop' (zoom) rectangles for this camera.
   *
   * <p>When zoom is supported, this will return a list of {@code 1 + #getMaxZoom} size, where each
   * crop rectangle corresponds to a zoom ratio (and is centered at the middle).
   *
   * <p>Each crop rectangle is changed to have the same aspect ratio as {@code streamSize}, by
   * shrinking the rectangle if necessary.
   *
   * <p>To get the reported crop region when applying a zoom to the sensor, use {@code streamSize} =
   * {@code activeArray size}.
   *
   * @param params non-{@code null} camera api1 parameters
   * @param activeArray active array dimensions, in sensor space
   * @param streamSize stream size dimensions, in pixels
   * @return a list of available zoom rectangles, sorted from least zoomed to most zoomed
   */
  private static List<Rect> getAvailableCropRectangles(
      Camera.Parameters params, Rect activeArray, Size streamSize) {
    checkNotNull(params, "params must not be null");
    checkNotNull(activeArray, "activeArray must not be null");
    checkNotNull(streamSize, "streamSize must not be null");

    // TODO: change all uses of Rect activeArray to Size activeArray,
    // since we want the crop to be active-array relative, not pixel-array relative

    Rect unzoomedStreamCrop = getPreviewCropRectangleUnzoomed(activeArray, streamSize);

    if (!params.isZoomSupported()) {
      // Trivial case: No zoom -> only support the full size as the crop region
      return new ArrayList<>(Arrays.asList(unzoomedStreamCrop));
    }

    List<Rect> zoomCropRectangles = new ArrayList<>(params.getMaxZoom() + 1);
    Matrix scaleMatrix = new Matrix();
    RectF scaledRect = new RectF();

    for (int zoom : params.getZoomRatios()) {
      float shrinkRatio = ZOOM_RATIO_MULTIPLIER * 1.0f / zoom; // normalize to 1.0 and smaller

      // set scaledRect to unzoomedStreamCrop
      ParamsUtils.convertRectF(unzoomedStreamCrop, /*out*/ scaledRect);

      scaleMatrix.setScale(
          shrinkRatio, shrinkRatio, activeArray.exactCenterX(), activeArray.exactCenterY());

      scaleMatrix.mapRect(scaledRect);

      Rect intRect = ParamsUtils.createRect(scaledRect);

      // Round the rect corners towards the nearest integer values
      zoomCropRectangles.add(intRect);
    }

    return zoomCropRectangles;
  }
  /**
   * Calculate the effective crop rectangle for this preview viewport; assumes the preview is
   * centered to the sensor and scaled to fit across one of the dimensions without skewing.
   *
   * <p>The preview size must be a subset of the active array size; the resulting rectangle will
   * also be a subset of the active array rectangle.
   *
   * <p>The unzoomed crop rectangle is calculated only.
   *
   * @param activeArray active array dimensions, in sensor space
   * @param previewSize size of the preview buffer render target, in pixels (not in sensor space)
   * @return a rectangle which serves as the preview stream's effective crop region (unzoomed), in
   *     sensor space
   * @throws NullPointerException if any of the args were {@code null}
   * @throws IllegalArgumentException if {@code previewSize} is wider or taller than {@code
   *     activeArray}
   */
  private static Rect getPreviewCropRectangleUnzoomed(Rect activeArray, Size previewSize) {
    if (previewSize.getWidth() > activeArray.width()) {
      throw new IllegalArgumentException("previewSize must not be wider than activeArray");
    } else if (previewSize.getHeight() > activeArray.height()) {
      throw new IllegalArgumentException("previewSize must not be taller than activeArray");
    }

    float aspectRatioArray = activeArray.width() * 1.0f / activeArray.height();
    float aspectRatioPreview = previewSize.getWidth() * 1.0f / previewSize.getHeight();

    float cropH, cropW;
    if (Math.abs(aspectRatioPreview - aspectRatioArray) < ASPECT_RATIO_TOLERANCE) {
      cropH = activeArray.height();
      cropW = activeArray.width();
    } else if (aspectRatioPreview < aspectRatioArray) {
      // The new width must be smaller than the height, so scale the width by AR
      cropH = activeArray.height();
      cropW = cropH * aspectRatioPreview;
    } else {
      // The new height must be smaller (or equal) than the width, so scale the height by AR
      cropW = activeArray.width();
      cropH = cropW / aspectRatioPreview;
    }

    Matrix translateMatrix = new Matrix();
    RectF cropRect = new RectF(/*left*/ 0, /*top*/ 0, cropW, cropH);

    // Now center the crop rectangle so its center is in the center of the active array
    translateMatrix.setTranslate(activeArray.exactCenterX(), activeArray.exactCenterY());
    translateMatrix.postTranslate(-cropRect.centerX(), -cropRect.centerY());

    translateMatrix.mapRect(/*inout*/ cropRect);

    // Round the rect corners towards the nearest integer values
    return ParamsUtils.createRect(cropRect);
  }
 @Override
 protected void onBoundsChange(Rect bounds) {
   mX = bounds.exactCenterX();
   mY = bounds.exactCenterY();
   mRadius = Math.min(bounds.width(), bounds.height()) / 2f;
 }
Ejemplo n.º 29
0
  private Intent createShortcutIntent(int position) {
    String url = getUrl(position);
    String title = getBookmarkTitle(position);
    Bitmap touchIcon = getTouchIcon(position);

    final Intent i = new Intent();
    final Intent shortcutIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
    long urlHash = url.hashCode();
    long uniqueId = (urlHash << 32) | shortcutIntent.hashCode();
    shortcutIntent.putExtra(Browser.EXTRA_APPLICATION_ID, Long.toString(uniqueId));
    i.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
    i.putExtra(Intent.EXTRA_SHORTCUT_NAME, title);
    // Use the apple-touch-icon if available
    if (touchIcon != null) {
      // Make a copy so we can modify the pixels.  We can't use
      // createScaledBitmap or copy since they will preserve the config
      // and lose the ability to add alpha.
      Bitmap bm = Bitmap.createBitmap(mIconSize, mIconSize, Bitmap.Config.ARGB_8888);
      Canvas canvas = new Canvas(bm);
      Rect src = new Rect(0, 0, touchIcon.getWidth(), touchIcon.getHeight());
      Rect dest = new Rect(0, 0, bm.getWidth(), bm.getHeight());

      // Paint used for scaling the bitmap and drawing the rounded rect.
      Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
      paint.setFilterBitmap(true);
      canvas.drawBitmap(touchIcon, src, dest, paint);

      // Construct a path from a round rect. This will allow drawing with
      // an inverse fill so we can punch a hole using the round rect.
      Path path = new Path();
      path.setFillType(Path.FillType.INVERSE_WINDING);
      RectF rect = new RectF(0, 0, bm.getWidth(), bm.getHeight());
      rect.inset(1, 1);
      path.addRoundRect(rect, 8f, 8f, Path.Direction.CW);

      // Reuse the paint and clear the outside of the rectangle.
      paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
      canvas.drawPath(path, paint);

      i.putExtra(Intent.EXTRA_SHORTCUT_ICON, bm);
    } else {
      Bitmap favicon = getFavicon(position);
      if (favicon == null) {
        i.putExtra(
            Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
            Intent.ShortcutIconResource.fromContext(
                BrowserBookmarksPage.this, R.drawable.ic_launcher_shortcut_browser_bookmark));
      } else {
        Bitmap icon =
            BitmapFactory.decodeResource(
                getResources(), R.drawable.ic_launcher_shortcut_browser_bookmark_icon);

        // Make a copy of the regular icon so we can modify the pixels.
        Bitmap copy = icon.copy(Bitmap.Config.ARGB_8888, true);
        Canvas canvas = new Canvas(copy);

        // Make a Paint for the white background rectangle and for
        // filtering the favicon.
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
        p.setStyle(Paint.Style.FILL_AND_STROKE);
        p.setColor(Color.WHITE);

        final float density = getResources().getDisplayMetrics().density;
        // Create a rectangle that is slightly wider than the favicon
        final float iconSize = 16 * density; // 16x16 favicon
        final float padding = 2 * density; // white padding around icon
        final float rectSize = iconSize + 2 * padding;

        final Rect iconBounds = new Rect(0, 0, icon.getWidth(), icon.getHeight());
        final float x = iconBounds.exactCenterX() - (rectSize / 2);
        // Note: Subtract 2 dip from the y position since the box is
        // slightly higher than center. Use padding since it is already
        // 2 * density.
        final float y = iconBounds.exactCenterY() - (rectSize / 2) - padding;
        RectF r = new RectF(x, y, x + rectSize, y + rectSize);

        // Draw a white rounded rectangle behind the favicon
        canvas.drawRoundRect(r, 2, 2, p);

        // Draw the favicon in the same rectangle as the rounded
        // rectangle but inset by the padding
        // (results in a 16x16 favicon).
        r.inset(padding, padding);
        canvas.drawBitmap(favicon, null, r, p);
        i.putExtra(Intent.EXTRA_SHORTCUT_ICON, copy);
      }
    }
    // Do not allow duplicate items
    i.putExtra("duplicate", false);
    return i;
  }
Ejemplo n.º 30
0
  @Override
  protected void onDraw(Canvas canvas) {
    Bitmap sweet = BitmapFactory.decodeResource(getResources(), R.drawable.sq);
    canvas.drawColor(color.black);
    canvas.drawBitmap(sweet, 0, 0, null);

    Paint paint = new Paint();

    // draw a red circle
    paint.setColor(Color.RED);
    canvas.drawCircle(20, 50, 25, paint);

    // a blue circle with antialiasing turned on
    paint.setAntiAlias(true);
    paint.setColor(Color.BLUE);
    canvas.drawCircle(60, 50, 25, paint);

    // Now we wiil create some triangles.Create a Path object to store
    // out triangle's segments. Use.offset to draw in many locations.
    paint.setStyle(Paint.Style.FILL_AND_STROKE);
    paint.setStrokeWidth(2);
    paint.setColor(Color.GREEN);
    Path path = new Path();
    path.moveTo(4, -10);
    path.lineTo(20, 0);
    path.lineTo(-9, 0);
    path.close();
    path.offset(60, 40);
    canvas.drawPath(path, paint);
    path.offset(90, 100);
    canvas.drawPath(path, paint);
    path.offset(80, 150);
    canvas.drawPath(path, paint);

    // Now draw a text using FILL style:
    paint.setStyle(Paint.Style.FILL);
    paint.setAntiAlias(true);
    paint.setTextSize(20);
    canvas.drawText("Hello Android! Fill...", 50, 230, paint);

    // rotate the text, and you can draw it where you want:
    int x = 75;
    int y = 185;
    paint.setColor(Color.GRAY);
    paint.setTextSize(25);
    String rotatedtext = "Rotated hellowandroid:)";

    // draw bounding rect befor rotating text:
    Rect rect = new Rect();
    paint.getTextBounds(rotatedtext, 0, rotatedtext.length(), rect);
    canvas.translate(x, y);
    paint.setStyle(Paint.Style.FILL);

    canvas.drawText("Rotated helloandroid :)", 0, 0, paint);
    paint.setStyle(Paint.Style.STROKE);
    canvas.drawRect(rect, paint);

    canvas.translate(-x, -y);

    paint.setColor(Color.RED);
    canvas.rotate(-45, x + rect.exactCenterX(), y + rect.exactCenterY());
    paint.setStyle(Paint.Style.FILL);
    canvas.drawText(rotatedtext, x, y, paint);

    // draw a draw a thick dashed line in angle
    DashPathEffect dashPath = new DashPathEffect(new float[] {10, 40}, 1);
    paint.setPathEffect(dashPath);
    paint.setStrokeWidth(8);
    canvas.drawLine(0, 60, 320, 300, paint);
  }