Android开发之自定义CheckBox

 /**  * A MeasureSpec encapsulates the layout requirements passed from parent to child.  * Each MeasureSpec represents a requirement for either the width or the height.  * A MeasureSpec is comprised of a size and a mode.   * MeasureSpecs are implemented as ints to reduce object allocation. This class  * is provided to pack and unpack the <size, mode> tuple into the int.  */ public static class MeasureSpec {  private static final int MODE_SHIFT = 30;  private static final int MODE_MASK = 0x3 << MODE_SHIFT;  /**   * Measure specification mode: The parent has not imposed any constraint   * on the child. It can be whatever size it wants.   */  public static final int UNSPECIFIED = 0 << MODE_SHIFT;  /**   * Measure specification mode: The parent has determined an exact size   * for the child. The child is going to be given those bounds regardless   * of how big it wants to be.   */  public static final int EXACTLY  = 1 << MODE_SHIFT;  /**   * Measure specification mode: The child can be as large as it wants up   * to the specified size.   */  public static final int AT_MOST  = 2 << MODE_SHIFT;  /**   * Extracts the mode from the supplied measure specification.   *   * @param measureSpec the measure specification to extract the mode from   * @return {@link android.view.View.MeasureSpec#UNSPECIFIED},   *   {@link android.view.View.MeasureSpec#AT_MOST} or   *   {@link android.view.View.MeasureSpec#EXACTLY}   */  public static int getMode(int measureSpec) {   return (measureSpec & MODE_MASK);  }  /**   * Extracts the size from the supplied measure specification.   *   * @param measureSpec the measure specification to extract the size from   * @return the size in pixels defined in the supplied measure specification   */  public static int getSize(int measureSpec) {   return (measureSpec & ~MODE_MASK);  } }

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),    getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec)); }

public static int getDefaultSize(int size, int measureSpec) {  int result = size;  int specMode = MeasureSpec.getMode(measureSpec);  int specSize = MeasureSpec.getSize(measureSpec);  switch (specMode) {  case MeasureSpec.UNSPECIFIED:   result = size;   break;  case MeasureSpec.AT_MOST:  case MeasureSpec.EXACTLY:   result = specSize;   break;  }  return result; }

 @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  int widthMode = MeasureSpec.getMode(widthMeasureSpec);  int widthSize = MeasureSpec.getSize(widthMeasureSpec);  int heightMode = MeasureSpec.getMode(heightMeasureSpec);  int heightSize = MeasureSpec.getSize(heightMeasureSpec);  int width = widthSize, height = heightSize;  if (widthMode == MeasureSpec.AT_MOST) {   width = dp2px(DEFAULT_SIZE);  }  if (heightMode == MeasureSpec.AT_MOST) {   height = dp2px(DEFAULT_SIZE);  }  setMeasuredDimension(width, height); }

 mTickPath.addPath(entryPath); mTickPath.addPath(leftPath); mTickPath.addPath(rightPath); mTickMeasure = new PathMeasure(mTickPath, false); // mTickMeasure is a PathMeasure

 /**  * Return the total length of the current contour, or 0 if no path is  * associated with this measure object.  */ public float getLength() {  return native_getLength(native_instance); }

 SkScalar SkPathMeasure::getLength() {  if (fPath == NULL) {   return 0;  }  if (fLength < 0) {   this->buildSegments();  }  SkASSERT(fLength >= 0);  return fLength;}

SkPathMeasure::SkPathMeasure(const SkPath& path, bool forceClosed) { fPath = &path; fLength = -1; // signal we need to compute it fForceClosed = forceClosed; fFirstPtIndex = -1; fIter.setPath(path, forceClosed);}

void SkPathMeasure::buildSegments() { SkPoint   pts[4]; int    ptIndex = fFirstPtIndex; SkScalar  distance = 0; bool   isClosed = fForceClosed; bool   firstMoveTo = ptIndex < 0; Segment*  seg; /* Note: * as we accumulate distance, we have to check that the result of += * actually made it larger, since a very small delta might be > 0, but * still have no effect on distance (if distance >>> delta). * * We do this check below, and in compute_quad_segs and compute_cubic_segs */ fSegments.reset(); bool done = false; do {  switch (fIter.next(pts)) {   case SkPath::kMove_Verb:    ptIndex += 1;    fPts.append(1, pts);    if (!firstMoveTo) {     done = true;     break;    }    firstMoveTo = false;    break;   case SkPath::kLine_Verb: {    SkScalar d = SkPoint::Distance(pts[0], pts[1]);    SkASSERT(d >= 0);    SkScalar prevD = distance;    distance += d;    if (distance > prevD) {     seg = fSegments.append();     seg->fDistance = distance;     seg->fPtIndex = ptIndex;     seg->fType = kLine_SegType;     seg->fTValue = kMaxTValue;     fPts.append(1, pts + 1);     ptIndex++;    }   } break;   case SkPath::kQuad_Verb: {    SkScalar prevD = distance;    distance = this->compute_quad_segs(pts, distance, 0, kMaxTValue, ptIndex);    if (distance > prevD) {     fPts.append(2, pts + 1);     ptIndex += 2;    }   } break;   case SkPath::kConic_Verb: {    const SkConic conic(pts, fIter.conicWeight());    SkScalar prevD = distance;    distance = this->compute_conic_segs(conic, distance, 0, kMaxTValue, ptIndex);    if (distance > prevD) {     // we store the conic weight in our next point, followed by the last 2 pts     // thus to reconstitue a conic, you'd need to say     // SkConic(pts[0], pts[2], pts[3], weight = pts[1].fX)     fPts.append()->set(conic.fW, 0);     fPts.append(2, pts + 1);     ptIndex += 3;    }   } break;   case SkPath::kCubic_Verb: {    SkScalar prevD = distance;    distance = this->compute_cubic_segs(pts, distance, 0, kMaxTValue, ptIndex);    if (distance > prevD) {     fPts.append(3, pts + 1);     ptIndex += 3;    }   } break;   case SkPath::kClose_Verb:    isClosed = true;    break;   case SkPath::kDone_Verb:    done = true;    break;  } } while (!done); fLength = distance; fIsClosed = isClosed; fFirstPtIndex = ptIndex;

/* Iterate through all of the segments (lines, quadratics, cubics) ofeach contours in a path.The iterator cleans up the segments along the way, removing degeneratesegments and adding close verbs where necessary. When the forceCloseargument is provided, each contour (as defined by a new startingmove command) will be completed with a close verb regardless of thecontour's contents. /

 Verb next(SkPoint pts[4], bool doConsumeDegerates = true) {   if (doConsumeDegerates) {    this->consumeDegenerateSegments();   }   return this->doNext(pts); }

enum Verb { kMove_Verb,  //!< iter.next returns 1 point kLine_Verb,  //!< iter.next returns 2 points kQuad_Verb, //!< iter.next returns 3 points kConic_Verb, //!< iter.next returns 3 points + iter.conicWeight() kCubic_Verb, //!< iter.next returns 4 points kClose_Verb, //!< iter.next returns 1 point (contour's moveTo pt) kDone_Verb,  //!< iter.next returns 0 points}

/** Move to the next contour in the path. Return true if one exists, or false if we're done with the path.*/bool SkPathMeasure::nextContour() { fLength = -1; return this->getLength() > 0;}