Home | History | Annotate | Download | only in widget
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.settings.widget;
     18 
     19 import android.content.Context;
     20 import android.content.res.TypedArray;
     21 import android.graphics.Canvas;
     22 import android.graphics.Color;
     23 import android.graphics.Paint;
     24 import android.graphics.Paint.Style;
     25 import android.graphics.Point;
     26 import android.graphics.Rect;
     27 import android.graphics.drawable.Drawable;
     28 import android.text.DynamicLayout;
     29 import android.text.Layout;
     30 import android.text.Layout.Alignment;
     31 import android.text.SpannableStringBuilder;
     32 import android.text.TextPaint;
     33 import android.util.AttributeSet;
     34 import android.util.MathUtils;
     35 import android.view.MotionEvent;
     36 import android.view.View;
     37 
     38 import com.android.settings.R;
     39 import com.google.common.base.Preconditions;
     40 
     41 /**
     42  * Sweep across a {@link ChartView} at a specific {@link ChartAxis} value, which
     43  * a user can drag.
     44  */
     45 public class ChartSweepView extends View {
     46 
     47     private static final boolean DRAW_OUTLINE = false;
     48 
     49     // TODO: clean up all the various padding/offset/margins
     50 
     51     private Drawable mSweep;
     52     private Rect mSweepPadding = new Rect();
     53 
     54     /** Offset of content inside this view. */
     55     private Rect mContentOffset = new Rect();
     56     /** Offset of {@link #mSweep} inside this view. */
     57     private Point mSweepOffset = new Point();
     58 
     59     private Rect mMargins = new Rect();
     60     private float mNeighborMargin;
     61 
     62     private int mFollowAxis;
     63 
     64     private int mLabelMinSize;
     65     private float mLabelSize;
     66 
     67     private int mLabelTemplateRes;
     68     private int mLabelColor;
     69 
     70     private SpannableStringBuilder mLabelTemplate;
     71     private DynamicLayout mLabelLayout;
     72 
     73     private ChartAxis mAxis;
     74     private long mValue;
     75     private long mLabelValue;
     76 
     77     private long mValidAfter;
     78     private long mValidBefore;
     79     private ChartSweepView mValidAfterDynamic;
     80     private ChartSweepView mValidBeforeDynamic;
     81 
     82     private float mLabelOffset;
     83 
     84     private Paint mOutlinePaint = new Paint();
     85 
     86     public static final int HORIZONTAL = 0;
     87     public static final int VERTICAL = 1;
     88 
     89     private int mTouchMode = MODE_NONE;
     90 
     91     private static final int MODE_NONE = 0;
     92     private static final int MODE_DRAG = 1;
     93     private static final int MODE_LABEL = 2;
     94 
     95     private static final int LARGE_WIDTH = 1024;
     96 
     97     private long mDragInterval = 1;
     98 
     99     public interface OnSweepListener {
    100         public void onSweep(ChartSweepView sweep, boolean sweepDone);
    101         public void requestEdit(ChartSweepView sweep);
    102     }
    103 
    104     private OnSweepListener mListener;
    105 
    106     private float mTrackingStart;
    107     private MotionEvent mTracking;
    108 
    109     private ChartSweepView[] mNeighbors = new ChartSweepView[0];
    110 
    111     public ChartSweepView(Context context) {
    112         this(context, null);
    113     }
    114 
    115     public ChartSweepView(Context context, AttributeSet attrs) {
    116         this(context, attrs, 0);
    117     }
    118 
    119     public ChartSweepView(Context context, AttributeSet attrs, int defStyle) {
    120         super(context, attrs, defStyle);
    121 
    122         final TypedArray a = context.obtainStyledAttributes(
    123                 attrs, R.styleable.ChartSweepView, defStyle, 0);
    124 
    125         setSweepDrawable(a.getDrawable(R.styleable.ChartSweepView_sweepDrawable));
    126         setFollowAxis(a.getInt(R.styleable.ChartSweepView_followAxis, -1));
    127         setNeighborMargin(a.getDimensionPixelSize(R.styleable.ChartSweepView_neighborMargin, 0));
    128 
    129         setLabelMinSize(a.getDimensionPixelSize(R.styleable.ChartSweepView_labelSize, 0));
    130         setLabelTemplate(a.getResourceId(R.styleable.ChartSweepView_labelTemplate, 0));
    131         setLabelColor(a.getColor(R.styleable.ChartSweepView_labelColor, Color.BLUE));
    132 
    133         // TODO: moved focused state directly into assets
    134         setBackgroundResource(R.drawable.data_usage_sweep_background);
    135 
    136         mOutlinePaint.setColor(Color.RED);
    137         mOutlinePaint.setStrokeWidth(1f);
    138         mOutlinePaint.setStyle(Style.STROKE);
    139 
    140         a.recycle();
    141 
    142         setClickable(true);
    143         setFocusable(true);
    144         setOnClickListener(mClickListener);
    145 
    146         setWillNotDraw(false);
    147     }
    148 
    149     private OnClickListener mClickListener = new OnClickListener() {
    150         public void onClick(View v) {
    151             dispatchRequestEdit();
    152         }
    153     };
    154 
    155     void init(ChartAxis axis) {
    156         mAxis = Preconditions.checkNotNull(axis, "missing axis");
    157     }
    158 
    159     public void setNeighbors(ChartSweepView... neighbors) {
    160         mNeighbors = neighbors;
    161     }
    162 
    163     public int getFollowAxis() {
    164         return mFollowAxis;
    165     }
    166 
    167     public Rect getMargins() {
    168         return mMargins;
    169     }
    170 
    171     public void setDragInterval(long dragInterval) {
    172         mDragInterval = dragInterval;
    173     }
    174 
    175     /**
    176      * Return the number of pixels that the "target" area is inset from the
    177      * {@link View} edge, along the current {@link #setFollowAxis(int)}.
    178      */
    179     private float getTargetInset() {
    180         if (mFollowAxis == VERTICAL) {
    181             final float targetHeight = mSweep.getIntrinsicHeight() - mSweepPadding.top
    182                     - mSweepPadding.bottom;
    183             return mSweepPadding.top + (targetHeight / 2) + mSweepOffset.y;
    184         } else {
    185             final float targetWidth = mSweep.getIntrinsicWidth() - mSweepPadding.left
    186                     - mSweepPadding.right;
    187             return mSweepPadding.left + (targetWidth / 2) + mSweepOffset.x;
    188         }
    189     }
    190 
    191     public void addOnSweepListener(OnSweepListener listener) {
    192         mListener = listener;
    193     }
    194 
    195     private void dispatchOnSweep(boolean sweepDone) {
    196         if (mListener != null) {
    197             mListener.onSweep(this, sweepDone);
    198         }
    199     }
    200 
    201     private void dispatchRequestEdit() {
    202         if (mListener != null) {
    203             mListener.requestEdit(this);
    204         }
    205     }
    206 
    207     @Override
    208     public void setEnabled(boolean enabled) {
    209         super.setEnabled(enabled);
    210         setFocusable(enabled);
    211         requestLayout();
    212     }
    213 
    214     public void setSweepDrawable(Drawable sweep) {
    215         if (mSweep != null) {
    216             mSweep.setCallback(null);
    217             unscheduleDrawable(mSweep);
    218         }
    219 
    220         if (sweep != null) {
    221             sweep.setCallback(this);
    222             if (sweep.isStateful()) {
    223                 sweep.setState(getDrawableState());
    224             }
    225             sweep.setVisible(getVisibility() == VISIBLE, false);
    226             mSweep = sweep;
    227             sweep.getPadding(mSweepPadding);
    228         } else {
    229             mSweep = null;
    230         }
    231 
    232         invalidate();
    233     }
    234 
    235     public void setFollowAxis(int followAxis) {
    236         mFollowAxis = followAxis;
    237     }
    238 
    239     public void setLabelMinSize(int minSize) {
    240         mLabelMinSize = minSize;
    241         invalidateLabelTemplate();
    242     }
    243 
    244     public void setLabelTemplate(int resId) {
    245         mLabelTemplateRes = resId;
    246         invalidateLabelTemplate();
    247     }
    248 
    249     public void setLabelColor(int color) {
    250         mLabelColor = color;
    251         invalidateLabelTemplate();
    252     }
    253 
    254     private void invalidateLabelTemplate() {
    255         if (mLabelTemplateRes != 0) {
    256             final CharSequence template = getResources().getText(mLabelTemplateRes);
    257 
    258             final TextPaint paint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
    259             paint.density = getResources().getDisplayMetrics().density;
    260             paint.setCompatibilityScaling(getResources().getCompatibilityInfo().applicationScale);
    261             paint.setColor(mLabelColor);
    262             paint.setShadowLayer(4 * paint.density, 0, 0, Color.BLACK);
    263 
    264             mLabelTemplate = new SpannableStringBuilder(template);
    265             mLabelLayout = new DynamicLayout(
    266                     mLabelTemplate, paint, LARGE_WIDTH, Alignment.ALIGN_RIGHT, 1f, 0f, false);
    267             invalidateLabel();
    268 
    269         } else {
    270             mLabelTemplate = null;
    271             mLabelLayout = null;
    272         }
    273 
    274         invalidate();
    275         requestLayout();
    276     }
    277 
    278     private void invalidateLabel() {
    279         if (mLabelTemplate != null && mAxis != null) {
    280             mLabelValue = mAxis.buildLabel(getResources(), mLabelTemplate, mValue);
    281             setContentDescription(mLabelTemplate);
    282             invalidateLabelOffset();
    283             invalidate();
    284         } else {
    285             mLabelValue = mValue;
    286         }
    287     }
    288 
    289     /**
    290      * When overlapping with neighbor, split difference and push label.
    291      */
    292     public void invalidateLabelOffset() {
    293         float margin;
    294         float labelOffset = 0;
    295         if (mFollowAxis == VERTICAL) {
    296             if (mValidAfterDynamic != null) {
    297                 mLabelSize = Math.max(getLabelWidth(this), getLabelWidth(mValidAfterDynamic));
    298                 margin = getLabelTop(mValidAfterDynamic) - getLabelBottom(this);
    299                 if (margin < 0) {
    300                     labelOffset = margin / 2;
    301                 }
    302             } else if (mValidBeforeDynamic != null) {
    303                 mLabelSize = Math.max(getLabelWidth(this), getLabelWidth(mValidBeforeDynamic));
    304                 margin = getLabelTop(this) - getLabelBottom(mValidBeforeDynamic);
    305                 if (margin < 0) {
    306                     labelOffset = -margin / 2;
    307                 }
    308             } else {
    309                 mLabelSize = getLabelWidth(this);
    310             }
    311         } else {
    312             // TODO: implement horizontal labels
    313         }
    314 
    315         mLabelSize = Math.max(mLabelSize, mLabelMinSize);
    316 
    317         // when offsetting label, neighbor probably needs to offset too
    318         if (labelOffset != mLabelOffset) {
    319             mLabelOffset = labelOffset;
    320             invalidate();
    321             if (mValidAfterDynamic != null) mValidAfterDynamic.invalidateLabelOffset();
    322             if (mValidBeforeDynamic != null) mValidBeforeDynamic.invalidateLabelOffset();
    323         }
    324     }
    325 
    326     @Override
    327     public void jumpDrawablesToCurrentState() {
    328         super.jumpDrawablesToCurrentState();
    329         if (mSweep != null) {
    330             mSweep.jumpToCurrentState();
    331         }
    332     }
    333 
    334     @Override
    335     public void setVisibility(int visibility) {
    336         super.setVisibility(visibility);
    337         if (mSweep != null) {
    338             mSweep.setVisible(visibility == VISIBLE, false);
    339         }
    340     }
    341 
    342     @Override
    343     protected boolean verifyDrawable(Drawable who) {
    344         return who == mSweep || super.verifyDrawable(who);
    345     }
    346 
    347     public ChartAxis getAxis() {
    348         return mAxis;
    349     }
    350 
    351     public void setValue(long value) {
    352         mValue = value;
    353         invalidateLabel();
    354     }
    355 
    356     public long getValue() {
    357         return mValue;
    358     }
    359 
    360     public long getLabelValue() {
    361         return mLabelValue;
    362     }
    363 
    364     public float getPoint() {
    365         if (isEnabled()) {
    366             return mAxis.convertToPoint(mValue);
    367         } else {
    368             // when disabled, show along top edge
    369             return 0;
    370         }
    371     }
    372 
    373     /**
    374      * Set valid range this sweep can move within, in {@link #mAxis} values. The
    375      * most restrictive combination of all valid ranges is used.
    376      */
    377     public void setValidRange(long validAfter, long validBefore) {
    378         mValidAfter = validAfter;
    379         mValidBefore = validBefore;
    380     }
    381 
    382     public void setNeighborMargin(float neighborMargin) {
    383         mNeighborMargin = neighborMargin;
    384     }
    385 
    386     /**
    387      * Set valid range this sweep can move within, defined by the given
    388      * {@link ChartSweepView}. The most restrictive combination of all valid
    389      * ranges is used.
    390      */
    391     public void setValidRangeDynamic(ChartSweepView validAfter, ChartSweepView validBefore) {
    392         mValidAfterDynamic = validAfter;
    393         mValidBeforeDynamic = validBefore;
    394     }
    395 
    396     /**
    397      * Test if given {@link MotionEvent} is closer to another
    398      * {@link ChartSweepView} compared to ourselves.
    399      */
    400     public boolean isTouchCloserTo(MotionEvent eventInParent, ChartSweepView another) {
    401         final float selfDist = getTouchDistanceFromTarget(eventInParent);
    402         final float anotherDist = another.getTouchDistanceFromTarget(eventInParent);
    403         return anotherDist < selfDist;
    404     }
    405 
    406     private float getTouchDistanceFromTarget(MotionEvent eventInParent) {
    407         if (mFollowAxis == HORIZONTAL) {
    408             return Math.abs(eventInParent.getX() - (getX() + getTargetInset()));
    409         } else {
    410             return Math.abs(eventInParent.getY() - (getY() + getTargetInset()));
    411         }
    412     }
    413 
    414     @Override
    415     public boolean onTouchEvent(MotionEvent event) {
    416         if (!isEnabled()) return false;
    417 
    418         final View parent = (View) getParent();
    419         switch (event.getAction()) {
    420             case MotionEvent.ACTION_DOWN: {
    421 
    422                 // only start tracking when in sweet spot
    423                 final boolean acceptDrag;
    424                 final boolean acceptLabel;
    425                 if (mFollowAxis == VERTICAL) {
    426                     acceptDrag = event.getX() > getWidth() - (mSweepPadding.right * 8);
    427                     acceptLabel = mLabelLayout != null ? event.getX() < mLabelLayout.getWidth()
    428                             : false;
    429                 } else {
    430                     acceptDrag = event.getY() > getHeight() - (mSweepPadding.bottom * 8);
    431                     acceptLabel = mLabelLayout != null ? event.getY() < mLabelLayout.getHeight()
    432                             : false;
    433                 }
    434 
    435                 final MotionEvent eventInParent = event.copy();
    436                 eventInParent.offsetLocation(getLeft(), getTop());
    437 
    438                 // ignore event when closer to a neighbor
    439                 for (ChartSweepView neighbor : mNeighbors) {
    440                     if (isTouchCloserTo(eventInParent, neighbor)) {
    441                         return false;
    442                     }
    443                 }
    444 
    445                 if (acceptDrag) {
    446                     if (mFollowAxis == VERTICAL) {
    447                         mTrackingStart = getTop() - mMargins.top;
    448                     } else {
    449                         mTrackingStart = getLeft() - mMargins.left;
    450                     }
    451                     mTracking = event.copy();
    452                     mTouchMode = MODE_DRAG;
    453 
    454                     // starting drag should activate entire chart
    455                     if (!parent.isActivated()) {
    456                         parent.setActivated(true);
    457                     }
    458 
    459                     return true;
    460                 } else if (acceptLabel) {
    461                     mTouchMode = MODE_LABEL;
    462                     return true;
    463                 } else {
    464                     mTouchMode = MODE_NONE;
    465                     return false;
    466                 }
    467             }
    468             case MotionEvent.ACTION_MOVE: {
    469                 if (mTouchMode == MODE_LABEL) {
    470                     return true;
    471                 }
    472 
    473                 getParent().requestDisallowInterceptTouchEvent(true);
    474 
    475                 // content area of parent
    476                 final Rect parentContent = getParentContentRect();
    477                 final Rect clampRect = computeClampRect(parentContent);
    478                 if (clampRect.isEmpty()) return true;
    479 
    480                 long value;
    481                 if (mFollowAxis == VERTICAL) {
    482                     final float currentTargetY = getTop() - mMargins.top;
    483                     final float requestedTargetY = mTrackingStart
    484                             + (event.getRawY() - mTracking.getRawY());
    485                     final float clampedTargetY = MathUtils.constrain(
    486                             requestedTargetY, clampRect.top, clampRect.bottom);
    487                     setTranslationY(clampedTargetY - currentTargetY);
    488 
    489                     value = mAxis.convertToValue(clampedTargetY - parentContent.top);
    490                 } else {
    491                     final float currentTargetX = getLeft() - mMargins.left;
    492                     final float requestedTargetX = mTrackingStart
    493                             + (event.getRawX() - mTracking.getRawX());
    494                     final float clampedTargetX = MathUtils.constrain(
    495                             requestedTargetX, clampRect.left, clampRect.right);
    496                     setTranslationX(clampedTargetX - currentTargetX);
    497 
    498                     value = mAxis.convertToValue(clampedTargetX - parentContent.left);
    499                 }
    500 
    501                 // round value from drag to nearest increment
    502                 value -= value % mDragInterval;
    503                 setValue(value);
    504 
    505                 dispatchOnSweep(false);
    506                 return true;
    507             }
    508             case MotionEvent.ACTION_UP: {
    509                 if (mTouchMode == MODE_LABEL) {
    510                     performClick();
    511                 } else if (mTouchMode == MODE_DRAG) {
    512                     mTrackingStart = 0;
    513                     mTracking = null;
    514                     mValue = mLabelValue;
    515                     dispatchOnSweep(true);
    516                     setTranslationX(0);
    517                     setTranslationY(0);
    518                     requestLayout();
    519                 }
    520 
    521                 mTouchMode = MODE_NONE;
    522                 return true;
    523             }
    524             default: {
    525                 return false;
    526             }
    527         }
    528     }
    529 
    530     /**
    531      * Update {@link #mValue} based on current position, including any
    532      * {@link #onTouchEvent(MotionEvent)} in progress. Typically used when
    533      * {@link ChartAxis} changes during sweep adjustment.
    534      */
    535     public void updateValueFromPosition() {
    536         final Rect parentContent = getParentContentRect();
    537         if (mFollowAxis == VERTICAL) {
    538             final float effectiveY = getY() - mMargins.top - parentContent.top;
    539             setValue(mAxis.convertToValue(effectiveY));
    540         } else {
    541             final float effectiveX = getX() - mMargins.left - parentContent.left;
    542             setValue(mAxis.convertToValue(effectiveX));
    543         }
    544     }
    545 
    546     public int shouldAdjustAxis() {
    547         return mAxis.shouldAdjustAxis(getValue());
    548     }
    549 
    550     private Rect getParentContentRect() {
    551         final View parent = (View) getParent();
    552         return new Rect(parent.getPaddingLeft(), parent.getPaddingTop(),
    553                 parent.getWidth() - parent.getPaddingRight(),
    554                 parent.getHeight() - parent.getPaddingBottom());
    555     }
    556 
    557     @Override
    558     public void addOnLayoutChangeListener(OnLayoutChangeListener listener) {
    559         // ignored to keep LayoutTransition from animating us
    560     }
    561 
    562     @Override
    563     public void removeOnLayoutChangeListener(OnLayoutChangeListener listener) {
    564         // ignored to keep LayoutTransition from animating us
    565     }
    566 
    567     private long getValidAfterDynamic() {
    568         final ChartSweepView dynamic = mValidAfterDynamic;
    569         return dynamic != null && dynamic.isEnabled() ? dynamic.getValue() : Long.MIN_VALUE;
    570     }
    571 
    572     private long getValidBeforeDynamic() {
    573         final ChartSweepView dynamic = mValidBeforeDynamic;
    574         return dynamic != null && dynamic.isEnabled() ? dynamic.getValue() : Long.MAX_VALUE;
    575     }
    576 
    577     /**
    578      * Compute {@link Rect} in {@link #getParent()} coordinates that we should
    579      * be clamped inside of, usually from {@link #setValidRange(long, long)}
    580      * style rules.
    581      */
    582     private Rect computeClampRect(Rect parentContent) {
    583         // create two rectangles, and pick most restrictive combination
    584         final Rect rect = buildClampRect(parentContent, mValidAfter, mValidBefore, 0f);
    585         final Rect dynamicRect = buildClampRect(
    586                 parentContent, getValidAfterDynamic(), getValidBeforeDynamic(), mNeighborMargin);
    587 
    588         if (!rect.intersect(dynamicRect)) {
    589             rect.setEmpty();
    590         }
    591         return rect;
    592     }
    593 
    594     private Rect buildClampRect(
    595             Rect parentContent, long afterValue, long beforeValue, float margin) {
    596         if (mAxis instanceof InvertedChartAxis) {
    597             long temp = beforeValue;
    598             beforeValue = afterValue;
    599             afterValue = temp;
    600         }
    601 
    602         final boolean afterValid = afterValue != Long.MIN_VALUE && afterValue != Long.MAX_VALUE;
    603         final boolean beforeValid = beforeValue != Long.MIN_VALUE && beforeValue != Long.MAX_VALUE;
    604 
    605         final float afterPoint = mAxis.convertToPoint(afterValue) + margin;
    606         final float beforePoint = mAxis.convertToPoint(beforeValue) - margin;
    607 
    608         final Rect clampRect = new Rect(parentContent);
    609         if (mFollowAxis == VERTICAL) {
    610             if (beforeValid) clampRect.bottom = clampRect.top + (int) beforePoint;
    611             if (afterValid) clampRect.top += afterPoint;
    612         } else {
    613             if (beforeValid) clampRect.right = clampRect.left + (int) beforePoint;
    614             if (afterValid) clampRect.left += afterPoint;
    615         }
    616         return clampRect;
    617     }
    618 
    619     @Override
    620     protected void drawableStateChanged() {
    621         super.drawableStateChanged();
    622         if (mSweep.isStateful()) {
    623             mSweep.setState(getDrawableState());
    624         }
    625     }
    626 
    627     @Override
    628     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    629 
    630         // TODO: handle vertical labels
    631         if (isEnabled() && mLabelLayout != null) {
    632             final int sweepHeight = mSweep.getIntrinsicHeight();
    633             final int templateHeight = mLabelLayout.getHeight();
    634 
    635             mSweepOffset.x = 0;
    636             mSweepOffset.y = 0;
    637             mSweepOffset.y = (int) ((templateHeight / 2) - getTargetInset());
    638             setMeasuredDimension(mSweep.getIntrinsicWidth(), Math.max(sweepHeight, templateHeight));
    639 
    640         } else {
    641             mSweepOffset.x = 0;
    642             mSweepOffset.y = 0;
    643             setMeasuredDimension(mSweep.getIntrinsicWidth(), mSweep.getIntrinsicHeight());
    644         }
    645 
    646         if (mFollowAxis == VERTICAL) {
    647             final int targetHeight = mSweep.getIntrinsicHeight() - mSweepPadding.top
    648                     - mSweepPadding.bottom;
    649             mMargins.top = -(mSweepPadding.top + (targetHeight / 2));
    650             mMargins.bottom = 0;
    651             mMargins.left = -mSweepPadding.left;
    652             mMargins.right = mSweepPadding.right;
    653         } else {
    654             final int targetWidth = mSweep.getIntrinsicWidth() - mSweepPadding.left
    655                     - mSweepPadding.right;
    656             mMargins.left = -(mSweepPadding.left + (targetWidth / 2));
    657             mMargins.right = 0;
    658             mMargins.top = -mSweepPadding.top;
    659             mMargins.bottom = mSweepPadding.bottom;
    660         }
    661 
    662         mContentOffset.set(0, 0, 0, 0);
    663 
    664         // make touch target area larger
    665         final int widthBefore = getMeasuredWidth();
    666         final int heightBefore = getMeasuredHeight();
    667         if (mFollowAxis == HORIZONTAL) {
    668             final int widthAfter = widthBefore * 3;
    669             setMeasuredDimension(widthAfter, heightBefore);
    670             mContentOffset.left = (widthAfter - widthBefore) / 2;
    671 
    672             final int offset = mSweepPadding.bottom * 2;
    673             mContentOffset.bottom -= offset;
    674             mMargins.bottom += offset;
    675         } else {
    676             final int heightAfter = heightBefore * 2;
    677             setMeasuredDimension(widthBefore, heightAfter);
    678             mContentOffset.offset(0, (heightAfter - heightBefore) / 2);
    679 
    680             final int offset = mSweepPadding.right * 2;
    681             mContentOffset.right -= offset;
    682             mMargins.right += offset;
    683         }
    684 
    685         mSweepOffset.offset(mContentOffset.left, mContentOffset.top);
    686         mMargins.offset(-mSweepOffset.x, -mSweepOffset.y);
    687     }
    688 
    689     @Override
    690     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    691         super.onLayout(changed, left, top, right, bottom);
    692         invalidateLabelOffset();
    693     }
    694 
    695     @Override
    696     protected void onDraw(Canvas canvas) {
    697         super.onDraw(canvas);
    698 
    699         final int width = getWidth();
    700         final int height = getHeight();
    701 
    702         final int labelSize;
    703         if (isEnabled() && mLabelLayout != null) {
    704             final int count = canvas.save();
    705             {
    706                 final float alignOffset = mLabelSize - LARGE_WIDTH;
    707                 canvas.translate(
    708                         mContentOffset.left + alignOffset, mContentOffset.top + mLabelOffset);
    709                 mLabelLayout.draw(canvas);
    710             }
    711             canvas.restoreToCount(count);
    712             labelSize = (int) mLabelSize;
    713         } else {
    714             labelSize = 0;
    715         }
    716 
    717         if (mFollowAxis == VERTICAL) {
    718             mSweep.setBounds(labelSize, mSweepOffset.y, width + mContentOffset.right,
    719                     mSweepOffset.y + mSweep.getIntrinsicHeight());
    720         } else {
    721             mSweep.setBounds(mSweepOffset.x, labelSize, mSweepOffset.x + mSweep.getIntrinsicWidth(),
    722                     height + mContentOffset.bottom);
    723         }
    724 
    725         mSweep.draw(canvas);
    726 
    727         if (DRAW_OUTLINE) {
    728             mOutlinePaint.setColor(Color.RED);
    729             canvas.drawRect(0, 0, width, height, mOutlinePaint);
    730         }
    731     }
    732 
    733     public static float getLabelTop(ChartSweepView view) {
    734         return view.getY() + view.mContentOffset.top;
    735     }
    736 
    737     public static float getLabelBottom(ChartSweepView view) {
    738         return getLabelTop(view) + view.mLabelLayout.getHeight();
    739     }
    740 
    741     public static float getLabelWidth(ChartSweepView view) {
    742         return Layout.getDesiredWidth(view.mLabelLayout.getText(), view.mLabelLayout.getPaint());
    743     }
    744 }
    745