Example usage for android.graphics Canvas drawCircle

List of usage examples for android.graphics Canvas drawCircle

  1. HOME
  2. Java
  3. android
  4. android.graphics.*
  5. Canvas
  6. drawCircle

Introduction

In this page you can find the example usage for android.graphics Canvas drawCircle.

Prototype

public void drawCircle(float cx, float cy, float radius, @NonNull Paint paint)

Source Link

Document

Draw the specified circle using the specified paint.

Usage

From source file:com.android.datetimepicker.time.AmPmCirclesView.java

@Override
public void onDraw(Canvas canvas) {
    int viewWidth = getWidth();
    if (viewWidth == 0 || !mIsInitialized) {
        return;//  ww  w  .  ja  v a 2 s .  c o m
    }

    if (!mDrawValuesReady) {
        int layoutXCenter = getWidth() / 2;
        int layoutYCenter = getHeight() / 2;
        int circleRadius = (int) (Math.min(layoutXCenter, layoutYCenter) * mCircleRadiusMultiplier);
        mAmPmCircleRadius = (int) (circleRadius * mAmPmCircleRadiusMultiplier);
        layoutYCenter += mAmPmCircleRadius * 0.75;
        int textSize = mAmPmCircleRadius * 11 / 16;
        mPaint.setTextSize(textSize);

        // Line up the vertical center of the AM/PM circles with the bottom of the main circle.
        mAmPmYCenter = layoutYCenter - mAmPmCircleRadius / 2 + circleRadius;
        // Line up the horizontal edges of the AM/PM circles with the horizontal edges
        // of the main circle.
        mAmXCenter = layoutXCenter - circleRadius + mAmPmCircleRadius;
        mPmXCenter = layoutXCenter + circleRadius - mAmPmCircleRadius;

        mDrawValuesReady = true;
    }

    // We'll need to draw either a lighter blue (for selection), a darker blue (for touching)
    // or white (for not selected).
    int amColor = mUnselectedColor;
    int amAlpha = 255;
    int amTextColor = mAmPmTextColor;
    int pmColor = mUnselectedColor;
    int pmAlpha = 255;
    int pmTextColor = mAmPmTextColor;

    if (mAmOrPm == AM) {
        amColor = mSelectedColor;
        amAlpha = mSelectedAlpha;
        amTextColor = mAmPmSelectedTextColor;
    } else if (mAmOrPm == PM) {
        pmColor = mSelectedColor;
        pmAlpha = mSelectedAlpha;
        pmTextColor = mAmPmSelectedTextColor;
    }
    if (mAmOrPmPressed == AM) {
        amColor = mTouchedColor;
        amAlpha = mSelectedAlpha;
    } else if (mAmOrPmPressed == PM) {
        pmColor = mTouchedColor;
        pmAlpha = mSelectedAlpha;
    }
    if (mAmDisabled) {
        amColor = mUnselectedColor;
        amTextColor = mAmPmDisabledTextColor;
    }
    if (mPmDisabled) {
        pmColor = mUnselectedColor;
        pmTextColor = mAmPmDisabledTextColor;
    }

    // Draw the two circles.
    mPaint.setColor(amColor);
    mPaint.setAlpha(amAlpha);
    canvas.drawCircle(mAmXCenter, mAmPmYCenter, mAmPmCircleRadius, mPaint);
    mPaint.setColor(pmColor);
    mPaint.setAlpha(pmAlpha);
    canvas.drawCircle(mPmXCenter, mAmPmYCenter, mAmPmCircleRadius, mPaint);

    // Draw the AM/PM texts on top.
    mPaint.setColor(amTextColor);
    int textYCenter = mAmPmYCenter - (int) (mPaint.descent() + mPaint.ascent()) / 2;
    canvas.drawText(mAmText, mAmXCenter, textYCenter, mPaint);
    mPaint.setColor(pmTextColor);
    canvas.drawText(mPmText, mPmXCenter, textYCenter, mPaint);
}

From source file:com.xujun.administrator.customviewspecif.view.CirclePageIndicator.java

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    if (mViewPager == null) {
        return;/*w  w w  .  j av  a2 s.  com*/
    }
    final int count = mViewPager.getAdapter().getCount();
    if (count == 0) {
        return;
    }

    if (mCurrentPage >= count) {
        setCurrentItem(count - 1);
        return;
    }

    int longSize;
    int longPaddingBefore;
    int longPaddingAfter;
    int shortPaddingBefore;
    //  ????????
    if (mOrientation == HORIZONTAL) {
        longSize = getWidth();
        longPaddingBefore = getPaddingLeft();
        longPaddingAfter = getPaddingRight();
        shortPaddingBefore = getPaddingTop();
    } else {
        longSize = getHeight();
        longPaddingBefore = getPaddingTop();
        longPaddingAfter = getPaddingBottom();
        shortPaddingBefore = getPaddingLeft();
    }

    final float threeRadius = mRadius * 3;
    final float shortOffset = shortPaddingBefore + mRadius;
    float longOffset = longPaddingBefore + mRadius;
    /**
     * 
     */
    if (mCentered) {
        longOffset += ((longSize - longPaddingBefore - longPaddingAfter) / 2.0f)
                - ((count * threeRadius) / 2.0f);
    }

    float dX;
    float dY;

    float pageFillRadius = mRadius;
    if (mPaintStroke.getStrokeWidth() > 0) {
        pageFillRadius -= mPaintStroke.getStrokeWidth() / 2.0f;
    }

    //Draw stroked circles
    for (int iLoop = 0; iLoop < count; iLoop++) {
        float drawLong = longOffset + (iLoop * threeRadius);
        if (mOrientation == HORIZONTAL) {
            dX = drawLong;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = drawLong;
        }
        // Only paint fill if not completely transparent
        if (mPaintPageFill.getAlpha() > 0) {
            canvas.drawCircle(dX, dY, pageFillRadius, mPaintPageFill);
        }

        // Only paint stroke if a stroke width was non-zero
        if (pageFillRadius != mRadius) {
            canvas.drawCircle(dX, dY, mRadius, mPaintStroke);
        }
    }

    //?

    float cx = (mSnap ? mSnapPage : mCurrentPage) * threeRadius;
    //?????
    if (!mSnap) {
        cx += mPageOffset * threeRadius;
    }
    if (mOrientation == HORIZONTAL) {
        dX = longOffset + cx;
        dY = shortOffset;
    } else {
        dX = shortOffset;
        dY = longOffset + cx;
    }
    canvas.drawCircle(dX, dY, mRadius, mPaintFill);
}

From source file:com.github.lakeshire.pageindicator.CirclePageIndicator.java

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    if (mViewPager == null) {
        return;//from  ww  w. ja  v  a2 s.co m
    }
    int count = mViewPager.getAdapter().getCount();
    if (realCount > 0) {
        count = realCount;
    }
    if (count == 0) {
        return;
    }

    if (mCurrentPage >= count) {
        setCurrentItem(count - 1);
        return;
    }

    int longSize;
    int longPaddingBefore;
    int longPaddingAfter;
    int shortPaddingBefore;
    if (mOrientation == HORIZONTAL) {
        longSize = getWidth();
        longPaddingBefore = getPaddingLeft();
        longPaddingAfter = getPaddingRight();
        shortPaddingBefore = getPaddingTop();
    } else {
        longSize = getHeight();
        longPaddingBefore = getPaddingTop();
        longPaddingAfter = getPaddingBottom();
        shortPaddingBefore = getPaddingLeft();
    }

    final float threeRadius = mRadius * 3 + mExtraSpacing;
    final float shortOffset = shortPaddingBefore + mRadius;
    float longOffset = longPaddingBefore + mRadius;
    if (mCentered) {
        longOffset += ((longSize - longPaddingBefore - longPaddingAfter) / 2.0f)
                - ((count * threeRadius) / 2.0f);
    }

    float dX;
    float dY;

    float pageFillRadius = mRadius;
    if (mPaintStroke.getStrokeWidth() > 0) {
        pageFillRadius -= mPaintStroke.getStrokeWidth() / 2.0f;
    }

    //Draw stroked circles
    for (int iLoop = 0; iLoop < count; iLoop++) {
        float drawLong = longOffset + (iLoop * threeRadius);
        if (mOrientation == HORIZONTAL) {
            dX = drawLong;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = drawLong;
        }
        // Only paint fill if not completely transparent
        if (mPaintPageFill.getAlpha() > 0) {
            canvas.drawCircle(dX, dY, pageFillRadius, mPaintPageFill);
        }

        // Only paint stroke if a stroke width was non-zero
        if (pageFillRadius != mRadius) {
            canvas.drawCircle(dX, dY, mRadius, mPaintStroke);
        }
    }

    if (realCount > 0 && mLastPage == realCount - 1 && mCurrentPage == realCount - 1) {
        float x = longOffset + (count - 1) * threeRadius;
        canvas.drawCircle(x, shortOffset, mRadius, mPaintFill);
        return;
    }

    if (realCount > 0 && mLastPage == 0 && mCurrentPage == realCount - 1) {
        canvas.drawCircle(longOffset, shortOffset, mRadius, mPaintFill);
        return;
    }

    //Draw the filled circle according to the current scroll
    float cx = (mSnap ? mSnapPage : mCurrentPage) * threeRadius;
    if (!mSnap) {
        cx += mPageOffset * threeRadius;
    }
    if (mOrientation == HORIZONTAL) {
        dX = longOffset + cx;
        dY = shortOffset;
    } else {
        dX = shortOffset;
        dY = longOffset + cx;
    }
    canvas.drawCircle(dX, dY, mRadius, mPaintFill);
}

From source file:charles_lun.loopview.indicator.CircleIndicator.java

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    if (mViewPager == null) {
        return;/*www  .ja  v a 2  s  . c  o m*/
    }
    final int count = ((RecyleAdapter) mViewPager.getAdapter()).getRealCount();
    //        final int count = (PageAdapter)mViewPager.getAdapter().getCount();
    if (count <= 1) {
        return;
    }

    int longSize;
    int longPaddingBefore;
    int longPaddingAfter;
    int shortPaddingBefore;
    if (mOrientation == HORIZONTAL) {
        longSize = getWidth();
        longPaddingBefore = getPaddingLeft();
        longPaddingAfter = getPaddingRight();
        shortPaddingBefore = getPaddingTop();
    } else {
        longSize = getHeight();
        longPaddingBefore = getPaddingTop();
        longPaddingAfter = getPaddingBottom();
        shortPaddingBefore = getPaddingLeft();
    }

    final float threeRadius = mRadius * 3;
    final float shortOffset = shortPaddingBefore + mRadius;
    float longOffset = longPaddingBefore + mRadius;
    if (mCentered) {
        longOffset += ((longSize - longPaddingBefore - longPaddingAfter) / 2.0f)
                - ((count * threeRadius) / 2.0f);
        //            longOffset += ((longSize - longPaddingBefore - longPaddingAfter) / 2.0f) - ((mRealCount * threeRadius) / 2.0f);
    }

    float dX;
    float dY;

    float pageFillRadius = mRadius;
    if (mPaintStroke.getStrokeWidth() > 0) {
        pageFillRadius -= mPaintStroke.getStrokeWidth() / 2.0f;
    }

    //Draw stroked circles
    for (int iLoop = 0; iLoop < count; iLoop++) {
        float drawLong = longOffset + (iLoop * threeRadius);
        if (mOrientation == HORIZONTAL) {
            dX = drawLong;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = drawLong;
        }
        // Only paint fill if not completely transparent
        if (mPaintPageFill.getAlpha() > 0) {
            canvas.drawCircle(dX, dY, pageFillRadius, mPaintPageFill);
        }

        // Only paint stroke if a stroke width was non-zero
        if (pageFillRadius != mRadius) {
            canvas.drawCircle(dX, dY, mRadius, mPaintStroke);
        }
    }

    //Draw the filled circle according to the current scroll
    float cx = mSnapPage % count * threeRadius;
    //        float cx = (mSnap ? mSnapPage : mCurrentPage) * threeRadius;
    //        if (!mSnap) {
    //            cx += mPageOffset * threeRadius;
    //        }
    if (mOrientation == HORIZONTAL) {
        dX = longOffset + cx;
        dY = shortOffset;
    } else {
        dX = shortOffset;
        dY = longOffset + cx;
    }
    canvas.drawCircle(dX, dY, mRadius, mPaintFill);
}

From source file:piuk.blockchain.android.ui.zxing.ViewfinderView.java

@Override
public void onDraw(Canvas canvas) {
    if (cameraManager == null) {
        return; // not ready yet, early draw before done configuring
    }/* w  w w . ja  va2 s  . c  o  m*/
    cameraManager.setFramingViewSize(new Point(this.getWidth(), this.getHeight()));
    Rect frame = cameraManager.getFramingRect();
    if (frame == null) {
        return;
    }
    int width = canvas.getWidth();
    int height = canvas.getHeight();

    // Draw the exterior (i.e. outside the framing rect) darkened
    paint.setColor(resultBitmap != null ? resultColor : maskColor);
    canvas.drawRect(0, 0, width, frame.top, paint);
    canvas.drawRect(0, frame.top, frame.left, frame.bottom + 1, paint);
    canvas.drawRect(frame.right + 1, frame.top, width, frame.bottom + 1, paint);
    canvas.drawRect(0, frame.bottom + 1, width, height, paint);

    if (resultBitmap != null) {
        // Draw the opaque result bitmap over the scanning rectangle
        paint.setAlpha(CURRENT_POINT_OPACITY);
        canvas.drawBitmap(resultBitmap, null, frame, paint);
    } else {

        // Draw a red "laser scanner" line through the middle to show decoding is active
        paint.setColor(laserColor);
        paint.setAlpha(SCANNER_ALPHA[scannerAlpha]);
        scannerAlpha = (scannerAlpha + 1) % SCANNER_ALPHA.length;
        int middle = frame.height() / 2 + frame.top;
        canvas.drawRect(frame.left + 2, middle - 1, frame.right - 1, middle + 2, paint);

        Rect previewFrame = cameraManager.getFramingRectInPreview();
        assert previewFrame != null;
        float scaleX = frame.width() / (float) previewFrame.width();
        float scaleY = frame.height() / (float) previewFrame.height();

        List<ResultPoint> currentPossible = possibleResultPoints;
        List<ResultPoint> currentLast = lastPossibleResultPoints;
        int frameLeft = frame.left;
        int frameTop = frame.top;
        if (currentPossible.isEmpty()) {
            lastPossibleResultPoints = null;
        } else {
            possibleResultPoints = new ArrayList<>(5);
            lastPossibleResultPoints = currentPossible;
            paint.setAlpha(CURRENT_POINT_OPACITY);
            paint.setColor(resultPointColor);
            synchronized (currentPossible) {
                for (ResultPoint point : currentPossible) {
                    canvas.drawCircle(frameLeft + (int) (point.getX() * scaleX),
                            frameTop + (int) (point.getY() * scaleY), POINT_SIZE, paint);
                }
            }
        }
        if (currentLast != null) {
            paint.setAlpha(CURRENT_POINT_OPACITY / 2);
            paint.setColor(resultPointColor);
            synchronized (currentLast) {
                float radius = POINT_SIZE / 2.0f;
                for (ResultPoint point : currentLast) {
                    canvas.drawCircle(frameLeft + (int) (point.getX() * scaleX),
                            frameTop + (int) (point.getY() * scaleY), radius, paint);
                }
            }
        }

        // Request another update at the animation interval, but only repaint the laser line,
        // not the entire viewfinder mask.
        postInvalidateDelayed(ANIMATION_DELAY, frame.left - POINT_SIZE, frame.top - POINT_SIZE,
                frame.right + POINT_SIZE, frame.bottom + POINT_SIZE);
    }
}

From source file:cn.wander.Utils.views.pageindicator.LoopPageCircleIndicator.java

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    if (mViewPager == null) {
        return;//from   ww w. j  a  v a  2 s . c o m
    }
    final int count = mViewPager.getAdapter().getCount() - 2; //CirclePageIndicatior????1
    if (count <= 0) {
        return;
    }

    if (mCurrentPage > count) {
        setCurrentItem(count);
        return;
    }

    int longSize;
    int longPaddingBefore;
    int longPaddingAfter;
    int shortPaddingBefore;
    if (mOrientation == HORIZONTAL) {
        longSize = getWidth();
        longPaddingBefore = getPaddingLeft();
        longPaddingAfter = getPaddingRight();
        shortPaddingBefore = getPaddingTop();
    } else {
        longSize = getHeight();
        longPaddingBefore = getPaddingTop();
        longPaddingAfter = getPaddingBottom();
        shortPaddingBefore = getPaddingLeft();
    }

    final float threeRadius = mRadius * 3;
    final float shortOffset = shortPaddingBefore + mRadius;
    float longOffset = longPaddingBefore + mRadius;
    if (mCentered) {
        longOffset += ((longSize - longPaddingBefore - longPaddingAfter) / 2.0f)
                - ((count * threeRadius) / 2.0f);
    }

    float dX;
    float dY;

    float pageFillRadius = mRadius;
    if (mPaintStroke.getStrokeWidth() > 0) {
        pageFillRadius -= mPaintStroke.getStrokeWidth() / 2.0f;
    }

    //Draw stroked circles
    for (int iLoop = 0; iLoop < count; iLoop++) {
        float drawLong = longOffset + (iLoop * threeRadius);
        if (mOrientation == HORIZONTAL) {
            dX = drawLong;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = drawLong;
        }
        // Only paint fill if not completely transparent
        if (mPaintPageFill.getAlpha() > 0) {
            canvas.drawCircle(dX, dY, pageFillRadius, mPaintPageFill);
        }

        // Only paint stroke if a stroke width was non-zero
        if (pageFillRadius != mRadius) {
            canvas.drawCircle(dX, dY, mRadius, mPaintStroke);
        }
    }
    int curPageIndex = mCurrentPage;
    if (curPageIndex < 0) { //??Adapter,???????????
        curPageIndex = count - 1;
    } else if (curPageIndex == count) {
        curPageIndex = 0;
    }
    //Draw the filled circle according to the current scroll
    float cx = (mSnap ? mSnapPage : curPageIndex) * threeRadius;
    if (!mSnap) {
        cx += mPageOffset * threeRadius;
    }
    if (mOrientation == HORIZONTAL) {
        dX = longOffset + cx;
        dY = shortOffset;
    } else {
        dX = shortOffset;
        dY = longOffset + cx;
    }
    canvas.drawCircle(dX, dY, mRadius, mPaintFill);
}

From source file:com.gm.common.ui.widget.pageindicator.PageIndicatorView.java

private void drawWithFillAnimation(@NonNull Canvas canvas, int position, int x, int y) {
    int color = unselectedColor;
    float radius = radiusPx;
    int stroke = strokePx;

    if (interactiveAnimation) {
        if (position == selectingPosition) {
            color = frameColor;// w  ww.  ja  va 2s .  co m
            radius = frameRadiusPx;
            stroke = frameStrokePx;

        } else if (position == selectedPosition) {
            color = frameColorReverse;
            radius = frameRadiusReversePx;
            stroke = frameStrokeReversePx;
        }

    } else {
        if (position == selectedPosition) {
            color = frameColor;
            radius = frameRadiusPx;
            stroke = frameStrokePx;

        } else if (position == lastSelectedPosition) {
            color = frameColorReverse;
            radius = frameRadiusReversePx;
            stroke = frameStrokeReversePx;
        }
    }

    strokePaint.setColor(color);
    strokePaint.setStrokeWidth(strokePx);
    canvas.drawCircle(x, y, radiusPx, strokePaint);

    strokePaint.setStrokeWidth(stroke);
    canvas.drawCircle(x, y, radius, strokePaint);
}

From source file:com.appeaser.sublimepickerlibrary.datepicker.SimpleMonthView.java

/**
 * Draws the month days.//from  www .  j  a  v a 2  s .c  om
 */
@SuppressWarnings("ConstantConditions")
private void drawDays(Canvas canvas) {
    final TextPaint p = mDayPaint;
    final int headerHeight = mMonthHeight + mDayOfWeekHeight;
    //final int rowHeight = mDayHeight;
    final float rowHeight = mDayHeight;
    //final int colWidth = mCellWidth;
    final float colWidth = mCellWidth;

    // Text is vertically centered within the row height.
    final float halfLineHeight = (p.ascent() + p.descent()) / 2f;
    //int rowCenter = headerHeight + rowHeight / 2;
    float rowCenter = headerHeight + rowHeight / 2f;

    for (int day = 1, col = findDayOffset(); day <= mDaysInMonth; day++) {
        //final int colCenter = colWidth * col + colWidth / 2;
        final float colCenter = colWidth * col + colWidth / 2f;
        //final int colCenterRtl;
        final float colCenterRtl;
        if (SUtils.isLayoutRtlCompat(this)) {
            colCenterRtl = mPaddedWidth - colCenter;
        } else {
            colCenterRtl = colCenter;
        }

        int stateMask = 0;

        final boolean isDayEnabled = isDayEnabled(day);
        if (isDayEnabled) {
            stateMask |= SUtils.STATE_ENABLED;
        }

        final boolean isDayInActivatedRange = mActivatedDays.isValid() && mActivatedDays.isActivated(day);
        final boolean isSelected = mActivatedDays.isSelected(day);

        if (isSelected) {
            stateMask |= SUtils.STATE_ACTIVATED;
            canvas.drawCircle(colCenterRtl, rowCenter, mDaySelectorRadius, mDaySelectorPaint);
        } else if (isDayInActivatedRange) {
            stateMask |= SUtils.STATE_ACTIVATED;

            int bgShape = DRAW_RECT;

            if (mActivatedDays.isSingleDay()) {
                if (mActivatedDays.isStartOfMonth()) {
                    bgShape = DRAW_RECT_WITH_CURVE_ON_RIGHT;
                } else {
                    bgShape = DRAW_RECT_WITH_CURVE_ON_LEFT;
                }
            } else if (mActivatedDays.isStartingDayOfRange(day)) {
                bgShape = DRAW_RECT_WITH_CURVE_ON_LEFT;
            } else if (mActivatedDays.isEndingDayOfRange(day)) {
                bgShape = DRAW_RECT_WITH_CURVE_ON_RIGHT;
            }

            // Use height to constrain the protrusion of the arc
            boolean constrainProtrusion = colWidth > (rowHeight - (2 * mPaddingRangeIndicator));
            float horDistFromCenter = constrainProtrusion ? rowHeight / 2f - mPaddingRangeIndicator
                    : colWidth / 2f;

            switch (bgShape) {
            case DRAW_RECT_WITH_CURVE_ON_LEFT:
                int leftRectArcLeft = (int) (colCenterRtl - horDistFromCenter) % 2 == 1
                        ? (int) (colCenterRtl - horDistFromCenter) + 1
                        : (int) (colCenterRtl - horDistFromCenter);

                int leftRectArcRight = (int) (colCenterRtl + horDistFromCenter) % 2 == 1
                        ? (int) (colCenterRtl + horDistFromCenter) + 1
                        : (int) (colCenterRtl + horDistFromCenter);

                RectF leftArcRect = new RectF(leftRectArcLeft,
                        rowCenter - rowHeight / 2f + mPaddingRangeIndicator, leftRectArcRight,
                        rowCenter + rowHeight / 2f - mPaddingRangeIndicator);

                canvas.drawArc(leftArcRect, 90, 180, true, mDayRangeSelectorPaint);

                canvas.drawRect(new RectF(leftArcRect.centerX(),
                        rowCenter - rowHeight / 2f + mPaddingRangeIndicator, colCenterRtl + colWidth / 2f,
                        rowCenter + rowHeight / 2f - mPaddingRangeIndicator), mDayRangeSelectorPaint);
                break;
            case DRAW_RECT_WITH_CURVE_ON_RIGHT:
                int rightRectArcLeft = (int) (colCenterRtl - horDistFromCenter) % 2 == 1
                        ? (int) (colCenterRtl - horDistFromCenter) + 1
                        : (int) (colCenterRtl - horDistFromCenter);

                int rightRectArcRight = (int) (colCenterRtl + horDistFromCenter) % 2 == 1
                        ? (int) (colCenterRtl + horDistFromCenter) + 1
                        : (int) (colCenterRtl + horDistFromCenter);

                RectF rightArcRect = new RectF(rightRectArcLeft,
                        rowCenter - rowHeight / 2f + mPaddingRangeIndicator, rightRectArcRight,
                        rowCenter + rowHeight / 2f - mPaddingRangeIndicator);

                canvas.drawArc(rightArcRect, 270, 180, true, mDayRangeSelectorPaint);

                canvas.drawRect(new RectF(colCenterRtl - colWidth / 2f,
                        rowCenter - rowHeight / 2f + mPaddingRangeIndicator, rightArcRect.centerX(),
                        rowCenter + rowHeight / 2f - mPaddingRangeIndicator), mDayRangeSelectorPaint);
                break;
            default:
                canvas.drawRect(new RectF(colCenterRtl - colWidth / 2f,
                        rowCenter - rowHeight / 2f + mPaddingRangeIndicator, colCenterRtl + colWidth / 2f,
                        rowCenter + rowHeight / 2f - mPaddingRangeIndicator), mDayRangeSelectorPaint);
                break;
            }
        }

        if (mTouchedItem == day) {
            stateMask |= SUtils.STATE_PRESSED;

            if (isDayEnabled) {
                canvas.drawCircle(colCenterRtl, rowCenter, mDaySelectorRadius, mDayHighlightPaint);
            }
        }

        final boolean isDayToday = mToday == day;
        final int dayTextColor;

        if (isDayToday && !isDayInActivatedRange) {
            dayTextColor = mDaySelectorPaint.getColor();
        } else {
            final int[] stateSet = SUtils.resolveStateSet(stateMask);
            dayTextColor = mDayTextColor.getColorForState(stateSet, 0);
        }
        p.setColor(dayTextColor);

        canvas.drawText(mDayFormatter.format(day), colCenterRtl, rowCenter - halfLineHeight, p);

        col++;

        if (col == DAYS_IN_WEEK) {
            col = 0;
            rowCenter += rowHeight;
        }
    }
}

From source file:util.android.viewpagerindicator.FakeEndlessCirclePagerIndicator.java

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    if (mViewPager == null) {
        return;//  ww  w.j a v a  2s.c  o  m
    }
    final int count = (numberOfItems == 0) ? mViewPager.getAdapter().getCount() : numberOfItems;
    if (mViewPager.getAdapter().getCount() == 0) {
        return;
    }

    if (mCurrentPage >= mViewPager.getAdapter().getCount()) {
        setCurrentItem(mViewPager.getAdapter().getCount() - 1);
        return;
    }

    int longSize;
    int longPaddingBefore;
    int longPaddingAfter;
    int shortPaddingBefore;
    if (mOrientation == HORIZONTAL) {
        longSize = getWidth() + extraSpacing;
        longPaddingBefore = getPaddingLeft();
        longPaddingAfter = getPaddingRight();
        shortPaddingBefore = getPaddingTop();
    } else {
        longSize = getHeight();
        longPaddingBefore = getPaddingTop();
        longPaddingAfter = getPaddingBottom();
        shortPaddingBefore = getPaddingLeft();
    }

    final float threeRadius = mRadius * 3 + extraSpacing;
    final float shortOffset = shortPaddingBefore + mRadius;
    float longOffset = longPaddingBefore + mRadius;
    if (mCentered) {
        longOffset += ((longSize - longPaddingBefore - longPaddingAfter) / 2.0f)
                - ((count * threeRadius) / 2.0f);
    }

    float dX;
    float dY;

    float pageFillRadius = mRadius;
    if (mPaintStroke.getStrokeWidth() > 0) {
        pageFillRadius -= mPaintStroke.getStrokeWidth() / 2.0f;
    }

    //Draw stroked circles
    for (int iLoop = 0; iLoop < count; iLoop++) {
        float drawLong = longOffset + (iLoop * threeRadius);
        if (mOrientation == HORIZONTAL) {
            dX = drawLong;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = drawLong;
        }
        // Only paint fill if not completely transparent
        if (mPaintPageFill.getAlpha() > 0) {
            canvas.drawCircle(dX, dY, pageFillRadius, mPaintPageFill);
        }

        // Only paint stroke if a stroke width was non-zero
        if (pageFillRadius != mRadius) {
            canvas.drawCircle(dX, dY, mRadius, mPaintStroke);
        }
    }

    //Draw the filled circle according to the current scroll
    float cx = (mSnap ? mSnapPage : (numberOfItems == 0) ? mCurrentPage : mCurrentPage % numberOfItems)
            * threeRadius;
    //        Log.d(LOGTAG, "currentPage: " + mCurrentPage + " numberOfItems " + numberOfItems + "
    // result: " + mCurrentPage % ((numberOfItems == 0) ? 1 : numberOfItems));

    if (numberOfItems != 0 && (mCurrentPage % numberOfItems == numberOfItems - 1)) {
        if (!mSnap && mPageOffset != 0) {
            cx -= mPageOffset * threeRadius * (numberOfItems - 1);
        }
        if (mOrientation == HORIZONTAL) {
            dX = longOffset + cx;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = longOffset + cx;
        }
    } else {
        if (!mSnap) {
            cx += mPageOffset * threeRadius;
        }
        if (mOrientation == HORIZONTAL) {
            dX = longOffset + cx;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = longOffset + cx;
        }
    }
    canvas.drawCircle(dX, dY, mRadius, mPaintFill);
}

From source file:cpi.suhaib.extendedcirclepagerindicator.CirclePageIndicator.java

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    if (mViewPager == null) {
        return;//  w  ww.j av a2 s .  c o m
    }
    final int count = mIsMaxIndicatorsEnabled ? mMaxIndicators : mTotalCount;
    if (count == 0) {
        return;
    }

    if (mCurrentPage >= mTotalCount) {
        setCurrentItem(count - 1);
        return;
    }

    int longSize;
    int longPaddingBefore;
    int longPaddingAfter;
    int shortPaddingBefore;
    if (mOrientation == HORIZONTAL) {
        longSize = getWidth();
        longPaddingBefore = getPaddingLeft();
        longPaddingAfter = getPaddingRight();
        shortPaddingBefore = getPaddingTop();
    } else {
        longSize = getHeight();
        longPaddingBefore = getPaddingTop();
        longPaddingAfter = getPaddingBottom();
        shortPaddingBefore = getPaddingLeft();
    }

    final float threeRadius = mRadius * 3;
    final float shortOffset = shortPaddingBefore + mRadius;
    float longOffset = longPaddingBefore + mRadius;
    if (mCentered) {
        longOffset += ((longSize - longPaddingBefore - longPaddingAfter) / 2.0f)
                - ((count * threeRadius) / 2.0f);
    }

    float dX;
    float dY;

    float pageFillRadius = mRadius;
    if (mPaintStroke.getStrokeWidth() > 0) {
        pageFillRadius -= mPaintStroke.getStrokeWidth() / 2.0f;
    }

    //Draw stroked circles
    for (int iLoop = 0; iLoop < count; iLoop++) {
        if (mHiddenDots.contains(iLoop)) {
            continue;
        }
        float drawLong = longOffset + (iLoop * threeRadius);
        if (mOrientation == HORIZONTAL) {
            dX = drawLong;
            dY = shortOffset;
        } else {
            dX = shortOffset;
            dY = drawLong;
        }
        // Only paint fill if not completely transparent
        if (mPaintPageFill.getAlpha() > 0) {
            canvas.drawCircle(dX, dY, pageFillRadius, mPaintPageFill);
        }

        // Only paint stroke if a stroke width was non-zero
        if (pageFillRadius != mRadius) {
            canvas.drawCircle(dX, dY, mRadius, mPaintStroke);
        }

    }

    //Draw the filled circle according to the current scroll
    if (mScrollState == 1 && mIsMaxIndicatorsEnabled) {
        if (mSwipeDirection == SwipeDirection.RIGHT && mCurrentPage - mOffset >= mMaxIndicators - 1) {
            mSnap = true;
            mSnapPage = mMaxIndicators - 1;
        } else if (mSwipeDirection == SwipeDirection.LEFT && mCurrentPage - mOffset < 0) {
            mSnap = true;
            mSnapPage = 0;
        } else {
            mSnap = false;
        }
    }
    float cx = (mSnap ? mSnapPage : mCurrentPage - mOffset) * threeRadius;
    if (!mSnap) {
        cx += mPageOffset * threeRadius;
    }
    if (mOrientation == HORIZONTAL) {
        dX = longOffset + cx;
        dY = shortOffset;
    } else {
        dX = shortOffset;
        dY = longOffset + cx;
    }
    canvas.drawCircle(dX, dY, mRadius, mPaintFill);

    if (mIsMaxIndicatorsEnabled
            && ((mSnap && mSnapPage == mMaxIndicators - 1) || mCurrentPage - mOffset >= mMaxIndicators - 1)
            && mCurrentPage < mTotalCount - 1) {
        mPaintMore.setAlpha(mPageOffset == 0 ? 100 : (int) (mPageOffset * 100));
        canvas.drawBitmap(mNextIcon, dX + threeRadius - mRadius, shortPaddingBefore, mPaintMore);
    } else if (mIsMaxIndicatorsEnabled && mCurrentPage - mOffset <= 0 && mCurrentPage > 0) {
        mPaintMore.setAlpha(mPageOffset == 0 ? 100 : (int) ((1 - mPageOffset) * 100));
        canvas.drawBitmap(mPreviousIcon, longPaddingBefore, shortPaddingBefore, mPaintMore);
    }
}