Graphics grfx = Graphics.FromImage(new Bitmap(1,1));

System.Drawing.Font f = new System.Drawing.Font("Times New Roman",10,FontStyle.Regular);

const string text1 = "check_space";
Sizef bounds1 = grfx.MeasureString(text1,f);

const string text2 = "check_space ";
Sizef bounds2 = grfx.MeasureString(text2,f);

Assert.IsTrue(bounds1.Width < bounds2.Width); // I have Fail here!

我想知道为什么我的测试失败了.为什么带尾部空格的文本宽度不比没有空格的文本宽？

更新：我可以理解这两个字符串不相等.但是,我在心理上理解带空格的字符串应该比没有空格的字符串宽.别？

Graphics grfx = Graphics.FromImage(new Bitmap(1,FontStyle.Regular);

string text1 = "check_space";
Sizef bounds1 = grfx.MeasureString(text1,f,new PointF(0,0),new StringFormat( StringFormatFlags.MeasureTrailingSpaces ));

string text2 = "check_space ";
Sizef bounds2 = grfx.MeasureString(text2,new StringFormat( StringFormatFlags.MeasureTrailingSpaces ) );

public PathInterpolatorGingerbread(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,false /* forceClosed */);

    final float pathLength = pathMeasure.getLength();
    final int numPoints = (int) (pathLength / PRECISION) + 1;

    mX = new float[numPoints];
    mY = new float[numPoints];

    final float[] position = new float[2];
    for (int i = 0; i < numPoints; ++i) {
        final float distance = (i * pathLength) / (numPoints - 1);
        pathMeasure.getPosTan(distance,position,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

@Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.translate(x,y);

        for (int i = 0; i < pathMeasures.size(); i++) {
            Path path1 = new Path();
            PathMeasure pathMeasure = pathMeasures.get(i);
            MyPath path = paths.get(i);
            if (!isReverse) {
                pathMeasure.getSegment(0,pathMeasure.getLength() * animatorValue,path1,true);
                canvas.drawPath(path1,linePaint);
            } else {
                pathMeasure.getSegment(0,pathMeasure.getLength() * (1 - animatorValue),linePaint);
            }
            drawCircles(radiusArray.get(i),canvas,path.endPoint,path.endDirection,i);
        }

        drawCenterCircle(canvas);
//        drawCircles(radiusArray.get(0),paths.get(0).endPoint,paths.get(0).endDirection);
    }

public FreshDownloadView(Context context,AttributeSet attrs,int defStyleAttr) {
    super(context,attrs,defStyleAttr);
    circular_edge = getResources().getDimension(R.dimen.edge);

    bounds = new Rect();
    mTempBounds = new RectF();
    publicPaint = new Paint();
    path1 = new Path();
    path2 = new Path();
    path3 = new Path();
    pathMeasure1 = new PathMeasure();
    pathMeasure2 = new PathMeasure();
    pathMeasure3 = new PathMeasure();
    textBounds = new Rect();

    parseAttrs(context.obtainStyledAttributes(attrs,R.styleable.FreshDownloadView));
    initPaint();
}

private void initData() {

        defaultPadding = 2 * radius + dp2px(2);
        defaultPaddingBottom = 2 * radius + dp2px(15);
        defaultWidth = (int) (2 * defaultPadding + dp2px(200));
        defaultHeight = (int) (defaultPadding + defaultPaddingBottom + dp2px(80));

        paint = new Paint[ballCount];
        for (int i = 0; i < paint.length; i++) {
            paint[i] = new Paint(Paint.ANTI_ALIAS_FLAG);
            paint[i].setColor(ballColor);
            paint[i].setStyle(Paint.Style.FILL);
        }

        path = new Path();
        pathMeasure = new PathMeasure();
        randomBallColors = new int[ballCount];
        randomradius = new float[ballCount];
        randomTransRatioX = new float[ballCount];
        randomTransRatioY = new float[ballCount];

        translateFraction = new float[ballCount];
        translateAnim = new ValueAnimator[ballCount];

    }

private void initRoomTempPath(float[] data) {
    mRoomTempPath.reset();
    // Path path = new Path();
    float pointX;
    float pointY;
    // 横向
    mRoomTempPath.moveto(Xpoint + xFirstPointOffset,getDataY(data[0],Ylabel));
    mRoomTempPath.moveto(Xpoint + xFirstPointOffset,Ylabel));
    for (int i = 0; i < Xlabel.length; i++) {
        float startX = Xpoint + i * Xscale + xFirstPointOffset;
        // 绘制数据连线
        if (i != 0) {
            pointX = Xpoint + (i - 1) * Xscale + xFirstPointOffset;
            pointY = getDataY(data[i - 1],Ylabel);
            mRoomTempPath.lineto(pointX,pointY);
        }
        if (i == Xlabel.length - 1) {
            pointX = startX;
            pointY = getDataY(data[i],pointY);
        }
    }
    mRoomTempPathMeasure = new PathMeasure(mRoomTempPath,false);
}

/**
 * 获取target temp绘线Path数据
 *
 * @param data target temp绘线Path数据
 */
private void initTargetTempPath(float[] data) {
    mTargetTempPath.reset();
    float pointX;
    float pointY;
    // 横向
    mTargetTempPath.moveto(Xpoint + xFirstPointOffset,Ylabel);
            mTargetTempPath.lineto(pointX,pointY);
        }
    }
    mTargetTempPathMeasure = new PathMeasure(mTargetTempPath,false);
}

public void matchVertsToPath(Path path,float bottomCoord,float extraOffset) {
    PathMeasure pm = new PathMeasure(path,false);

    for (int i = 0; i < staticVerts.length / 2; i++) {

        float yIndexValue = staticVerts[i * 2 + 1];
        float xIndexValue = staticVerts[i * 2];


        float percentOffsetX = (0.000001f + xIndexValue) / bitmap.getWidth();
        float percentOffsetX2 = (0.000001f + xIndexValue) / (bitmap.getWidth() + extraOffset);
        percentOffsetX2 += pathOffsetPercent;
        pm.getPosTan(pm.getLength() * (1f - percentOffsetX),coords,null);
        pm.getPosTan(pm.getLength() * (1f - percentOffsetX2),coords2,null);

        if (yIndexValue == 0) {
            setXY(drawingVerts,i,coords[0],coords2[1]);
        } else {
            float desiredYCoord = bottomCoord;
            setXY(drawingVerts,desiredYCoord);

        }
    }
}

public void matchVertsToPath(Path path,desiredYCoord);

        }
    }
}

public void matchVertsToPath(Path path,false);
    int index = 0;
    for (int i = 0; i < staticVerts.length / 2; i++) {

        float yIndexValue = staticVerts[i * 2 + 1];
        float xIndexValue = staticVerts[i * 2];


        float percentOffsetX = (0.000001f + xIndexValue) / bitmap.getWidth();
        float percentOffsetX2 = (0.000001f + xIndexValue) / (bitmap.getWidth() + extraOffset);
        percentOffsetX2 += pathOffsetPercent;
        pm.getPosTan(pm.getLength() * (1f - percentOffsetX),coords2[1] + verticalOffset);
        } else {
            float desiredYCoord = Math.max(coords2[1],coords2[1] + easedFoamCoords[Math.min(easedFoamCoords.length - 1,index)]);
            setXY(drawingVerts,desiredYCoord + verticalOffset);

            index += 1;

        }
    }
}

@Override public PointF getValue(Keyframe<PointF> keyframe,float keyframeProgress) {
  PathKeyframe pathKeyframe = (PathKeyframe) keyframe;
  Path path = pathKeyframe.getPath();
  if (path == null) {
    return keyframe.startValue;
  }

  if (pathMeasureKeyframe != pathKeyframe) {
    pathMeasure = new PathMeasure(path,false);
    pathMeasureKeyframe = pathKeyframe;
  }

  pathMeasure.getPosTan(keyframeProgress * pathMeasure.getLength(),pos,null);
  point.set(pos[0],pos[1]);
  return point;
}

public SunnyType(Context context,ShortWeatherInfo info) {
    super(context);
    mPathFront = new Path();
    mPathRear = new Path();
    sunPath = new Path();
    mPaint = new Paint();
    pos = new float[2];
    tan = new float[2];
    mMatrix = new Matrix();
    measure = new PathMeasure();
    sunMeasure = new PathMeasure();
    currentSunPosition = TimeUtils.getTimeDiffPercent(info.getSunrise(),info.getSunset());
    currentMoonPosition = TimeUtils.getTimeDiffPercent(info.getMoonrise(),info.getMoonset());
    if (currentSunPosition >= 0 && currentSunPosition <= 1) {
        setColor(colorDay);
        boat = BitmapFactory.decodeResource(getContext().getResources(),R.drawable.ic_boat_day);
    } else {
        setColor(colorNight);
        boat = BitmapFactory.decodeResource(getContext().getResources(),R.drawable.ic_boat_night);
    }

    cloud = BitmapFactory.decodeResource(getContext().getResources(),R.drawable.ic_cloud);

}

public RainType(Context context,@RainLevel int rainLevel,@WindLevel int windLevel) {
    super(context);
    setColor(0xFF6188DA);
    this.rainLevel = rainLevel;
    this.windLevel = windLevel;
    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setColor(Color.WHITE);
    mPaint.setstrokeWidth(5);
    mPaint.setStyle(Paint.Style.stroke);
    mRains = new ArrayList<>();
    mSNows = new ArrayList<>();
    matrix = new Matrix();
    bitmap = BitmapFactory.decodeResource(context.getResources(),R.drawable.ic_rain_ground);
    mdstFlash1 = new Path();
    flashPathMeasure1 = new PathMeasure();

    mdstFlash2 = new Path();
    flashPathMeasure2 = new PathMeasure();

    mdstFlash3 = new Path();
    flashPathMeasure3 = new PathMeasure();
}

/**
 * 用来给每一个button设置一个中心点
 *
 * @param orbit 一个特定角度的path
 */
private void setPos(Path orbit) {
    PathMeasure measure = new PathMeasure(orbit,false);
    TextLableView tv;
    for (int i = 0; i < mButtons.size(); i++) {
        PopupButton pp = mButtons.get(i);
        tv = kvs.get(pp);
        float[] coords = new float[]{0f,0f};
        int length = (int) ((i) * measure.getLength() / mButtons.size());
        measure.getPosTan(length,null);
        int px = (int) coords[0] - pp.getMeasuredWidth() / 2;
        int py = (int) coords[1] - pp.getMeasuredHeight() / 2;
        int tvx = (int) coords[0] - tv.getMeasuredWidth() / 2;
        tv.x = tvx;
        tv.y = py - 60;
        pp.x = px;
        pp.y = py;
    }
}

public PathInterpolatorDonut(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

private void init() {
    borderPaint = new Paint();
    borderPaint.setColor(borderColor);
    borderPaint.setStyle(Paint.Style.stroke);
    borderPaint.setstrokeWidth(borderWidth);
    rectPaint = new Paint();
    rectPaint.setColor(rectColor);
    rectPaint.setStyle(Paint.Style.FILL);
    linePaint = new Paint();
    linePaint.setAntiAlias(true);
    linePaint.setColor(lineColor);
    linePaint.setStyle(Paint.Style.stroke);
    linePaint.setstrokeWidth(linewidth);
    linePaint.setstrokeJoin(Paint.Join.ROUND);
    textPaint = new TextPaint();
    textPaint.setAntiAlias(true);
    textPaint.setColor(textColor);
    textPaint.setTextSize(textSize);
    fm = textPaint.getFontMetrics();
    path = new Path();
    pathDst = new Path();
    pm = new PathMeasure();
    selectedindex = -1;
}

private void init(int selectedBgColor,float pointstrokeWidth,int pathColor,float pathWidth) {
    pointPaint = new Paint();
    pointPaint.setAntiAlias(true);
    pointPaint.setColor(pointColor);
    pointPaint.setstrokeWidth(pointstrokeWidth);
    pointPaint.setStyle(Paint.Style.stroke);
    pathPaint = new Paint();
    pathPaint.setAntiAlias(true);
    pathPaint.setColor(pathColor);
    pathPaint.setstrokeWidth(pathWidth);
    pathPaint.setStyle(Paint.Style.stroke);
    selectedBgPaint = new Paint();
    selectedBgPaint.setAntiAlias(true);
    selectedBgPaint.setColor(selectedBgColor);
    selectedBgPaint.setstrokeWidth(0);
    selectedBgPaint.setStyle(Paint.Style.FILL);
    selectedBgPaint.setAlpha(100);
    path = new Path();
    pathDst = new Path();
    pm = new PathMeasure();
    rectoval = new RectF();
    selectedindex = -1;
}

private void init() {
    mPaint = new Paint();
    mPaint.setStyle(Paint.Style.stroke); // 设置为空心
    mPaint.setstrokeWidth(15); // 宽度
    mPaint.setColor(Color.RED); // 颜色
    mPaint.setstrokeCap(Paint.Cap.ROUND); // 设置画笔为园笔
    mPaint.setAntiAlias(true); // 抗锯齿
    mPath = new Path(); // 路径
    RectF rect = new RectF(-100,-100,100,100); // 测定圆弧的范围
    mPath.addArc(rect,-90,359.9f); // 设置路径范围，起始角度，终止角度
    mPathMeasure = new PathMeasure(mPath,false); // 初始化要截取的路径

    valueAnimator = ValueAnimator.ofFloat(0f,1f).setDuration(2500);
    valueAnimator.setRepeatCount(ValueAnimator.INFINITE); // 设置动画播放模式
    valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            animationValue = (float) animation.getAnimatedValue();
            invalidate();
        }
    });
    valueAnimator.start();
}

public PathInterpolatorBase(Path path) {
  final PathMeasure pathMeasure = new PathMeasure(path,false /* forceClosed */);

  final float pathLength = pathMeasure.getLength();
  final int numPoints = (int) (pathLength / PRECISION) + 1;

  mX = new float[numPoints];
  mY = new float[numPoints];

  final float[] position = new float[2];
  for (int i = 0; i < numPoints; ++i) {
    final float distance = (i * pathLength) / (numPoints - 1);
    pathMeasure.getPosTan(distance,null /* tangent */);

    mX[i] = position[0];
    mY[i] = position[1];
  }
}

public PathInterpolatorGingerbread(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

private Point calculateItemPositions(Integer startAngle,Integer endAngle) {
    final Point center = getActionViewCenter();
    RectF area = new RectF(center.x - radius,center.y - radius,center.x + radius,center.y + radius);
    Path orbit = new Path();
    orbit.addArc(area,startAngle,endAngle - startAngle);
    PathMeasure measure = new PathMeasure(orbit,false);
    // Prevent overlapping when it is a full circle
    int divisor;
    if (Math.abs(endAngle - startAngle) >= 360 || subMenuButtons.size() <= 1) {
        divisor = subMenuButtons.size();
    } else {
        divisor = subMenuButtons.size() - 1;
    }
    // Measure the path in order to find points that have the same distance between each other
    for (int i = 0; i < subMenuButtons.size(); i++) {
        SubButton currentSubButton = subMenuButtons.get(i);
        float[] coordinates = new float[]{0f,0f};
        int factor = animationType == AnimationType.RADIAL ? 0 : i;
        measure.getPosTan(factor * measure.getLength() / divisor,coordinates,null);
        currentSubButton.setX((int) coordinates[0] - currentSubButton.getWidth() / 2);
        currentSubButton.setY((int) coordinates[1] - currentSubButton.getHeight() / 2);
    }
    return center;
}

public TagViewGroup(Context context,defStyleAttr);
    Resources.Theme theme = context.getTheme();
    TypedArray array = theme.obtainStyledAttributes(attrs,R.styleable.TagViewGroup,defStyleAttr,0);
    mRadius = array.getDimensionPixelSize(R.styleable.TagViewGroup_radius,DipConvertUtils.dip2px(context,DEFAULT_RADIUS));
    mInnerRadius = array.getDimensionPixelSize(R.styleable.TagViewGroup_inner_radius,DEFAULT_INNER_RADIUS));
    mtdistance = array.getDimensionPixelSize(R.styleable.TagViewGroup_tilt_distance,DEFAULT_TILT_disTANCE));
    mVdistance = array.getDimensionPixelSize(R.styleable.TagViewGroup_v_distance,DEFAULT_V_disTANCE));
    mLinesWidth = array.getDimensionPixelSize(R.styleable.TagViewGroup_line_width,DEFAULT_LInes_WIDTH));
    mRippleMaxRadius = array.getDimensionPixelSize(R.styleable.TagViewGroup_ripple_maxRadius,DEFAULT_RIPPLE_MAX_RADIUS));
    mRippleAlpha = array.getInteger(R.styleable.TagViewGroup_ripple_alpha,DEFULT_RIPPLE_ALPHA);
    mRippleMinRadius = mInnerRadius + (mRadius - mInnerRadius) / 2;
    array.recycle();
    mPaint = new Paint();
    mPath = new Path();
    mdstPath = new Path();
    mPathMeasure = new PathMeasure();
    mPaint.setAntiAlias(true);
    mGestureDetector = new GestureDetectorCompat(context,new TagOnGestureListener());
    mChildUsed = new int[4];
    mCenterRect = new RectF();
}

private void initTool() {
    oPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    oPaint.setStyle(Paint.Style.FILL_AND_stroke);

    cPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    cPaint.setStyle(Paint.Style.stroke);
    cPaint.setstrokeCap(Paint.Cap.ROUND);

    sPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    sPaint.setStyle(Paint.Style.FILL);

    path = new Path();
    dstPath = new Path();
    pathMeasure = new PathMeasure();

    for (int i = 0; i < menuRectFs.length; i++) {
        menuRectFs[i] = new RectF();
    }
}

public PathInterpolatorDonut(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

public void matchVertsToPath(Path path,desiredYCoord);

        }
    }
}

private void reMeasure() {
    int mViewWidth = getWidth();
    int mViewHeight = getHeight();
    mCenterX = mViewWidth / 2;
    mCenterY = mViewHeight / 2;

    temp = mRadius / 2.0f * factor;
    Path path = new Path();
    path.moveto(mCenterX - temp,mCenterY - temp);
    path.lineto(mCenterX + temp,mCenterY + temp);
    pathLeftMeasure = new PathMeasure(path,false);

    path = new Path();
    path.moveto(mCenterX + temp,mCenterY - temp);
    path.lineto(mCenterX - temp,mCenterY + temp);
    pathRightMeasure = new PathMeasure(path,false);


}

/**
 * 画折线
 *
 * @param canvas
 */
public void drawLines(Canvas canvas,Line line) {
    if (line != null && isShow) {
        linePaint.setColor(line.getLineColor());
        linePaint.setstrokeWidth(LeafUtil.dp2px(mContext,line.getlinewidth()));
        linePaint.setStyle(Paint.Style.stroke);
        List<PointValue> values = line.getValues();
        Path path = line.getPath();
        int size = values.size();
        for (int i = 0; i < size; i++) {
            PointValue point = values.get(i);
            if (i == 0) path.moveto(point.getoriginX(),point.getoriginY());
            else path.lineto(point.getoriginX(),point.getoriginY());
        }

        measure = new PathMeasure(path,false);
        linePaint.setPathEffect(createPathEffect(measure.getLength(),phase,0.0f));
        canvas.drawPath(path,linePaint);

    }
}

/**
 * 画折线
 *
 * @param canvas
 */
public void drawLines(Canvas canvas,Line line,Axis axisY,int moveX) {
    if(line != null && isShow){
        linePaint.setColor(line.getLineColor());
        linePaint.setstrokeWidth(LeafUtil.dp2px(mContext,line.getlinewidth()));
        linePaint.setStyle(Paint.Style.stroke);
        List<PointValue> values = line.getValues();
        Path path = line.getPath();
        int size = values.size();
        for (int i = 0; i < size; i++) {
            PointValue point = values.get(i);
            if(i == 0)  path.moveto(point.getoriginX() + moveX,point.getoriginY());
            else  path.lineto(point.getoriginX() + moveX,0.0f));
        canvas.save(Canvas.CLIP_SAVE_FLAG);
        canvas.clipRect(axisY.getStartX(),mWidth,mHeight);
        canvas.drawPath(path,linePaint);
        canvas.restore();
    }
}

public PathInterpolatorDonut(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

/**
 * 初始化 Path
 */
private void initPath() {
    mSearchPath = new Path();
    mCirclePath = new Path();
    mMeasure = new PathMeasure();

    RectF oval1 = new RectF(-50,-50,50,50);
    mSearchPath.addArc(oval1,45,359.9f); // 放大镜的圆框

    RectF oval2 = new RectF(-100,100);
    mCirclePath.addArc(oval2,359.9f); // 搜索的圆圈

    float[] pos = new float[2];
    mMeasure.setPath(mCirclePath,false);
    mMeasure.getPosTan(0,null); // 放大镜手柄的末端

    mSearchPath.lineto(pos[0],pos[1]); // 放大镜的手柄
}

@Override public PointF getValue(Keyframe<PointF> keyframe,pos[1]);
  return point;
}

public PathInterpolatorDonut(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

public PathInterpolatorDonut(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

public PathInterpolatorDonut(Path path) {
    final PathMeasure pathMeasure = new PathMeasure(path,null /* tangent */);

        mX[i] = position[0];
        mY[i] = position[1];
    }
}

public FreshDownloadView(Context context,R.styleable.FreshDownloadView));
    initPaint();
}

private void createSuccesspath(){

        if(mSuccesspath != null){
            mSuccesspath.reset();
        }else{
            mSuccesspath = new Path();
        }

        float mLineWith = 2*mDensity;

        float left = width/2 - mRadius + mRadius/3 + mLineWith;
        float top = mPadding + mRadius/2 + mLineWith;
        float right = width/2 + mRadius - mLineWith - mRadius/3;
        float bottom = (mLineWith + mRadius) * 1.5f + mPadding/2;
        float xPoint = width/2 - mRadius/6;

        mSuccesspath = new Path();
        mSuccesspath.moveto(left,mPadding+mRadius + mLineWith);
        mSuccesspath.lineto(xPoint,bottom);
        mSuccesspath.lineto(right,top);

        PathMeasure measure = new PathMeasure(mSuccesspath,false);
        mSuccesspathLength = measure.getLength();
        mSuccesspathIntervals = new float[]{mSuccesspathLength,mSuccesspathLength};
    }

private void createFailedPath(){

        if(mFailedPath != null){
            mFailedPath.reset();
            mFailedPath2.reset();
        }else{
            mFailedPath = new Path();
            mFailedPath2 = new Path();
        }

        float left = width/2 - mRadius + mRadius/2;
        float top = mRadius/2 + mPadding;

        mFailedPath.moveto(left,top);
        mFailedPath.lineto(left+mRadius,top+mRadius);

        mFailedPath2.moveto(width/2 + mRadius/2,top);
        mFailedPath2.lineto(width/2 - mRadius + mRadius/2,top+mRadius);

        PathMeasure measure = new PathMeasure(mFailedPath,false);
        mFailedPathLength = measure.getLength();
        mFailedPathIntervals = new float[]{mFailedPathLength,mFailedPathLength};

        PathEffect PathEffect = new DashPathEffect(mFailedPathIntervals,mFailedPathLength);
        mPathEffectPaint2.setPathEffect(PathEffect);
    }

private void init(Context context) {
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);

    width = wm.getDefaultdisplay().getWidth();
    height = (int) (wm.getDefaultdisplay().getHeight() * 3 / 2f);

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setstrokeWidth(2);
    mPaint.setColor(Color.BLUE);
    mPaint.setStyle(Paint.Style.stroke);

    pathMeasure = new PathMeasure();

    builderFollower(fllowerCount,fllowers1);
    builderFollower(fllowerCount,fllowers2);
    builderFollower(fllowerCount,fllowers3);
}

/**
 * 绘制外层圆环进度和小圆点
 */
private void drawRingProgress(Canvas canvas) {

  Path path = new Path();
  path.addArc(mMiddleProgressRect,mStartAngle,mCurrentAngle);
  PathMeasure pathMeasure = new PathMeasure(path,false);
  pathMeasure.getPosTan(pathMeasure.getLength() * 1,tan);
  matrix.reset();
  matrix.postTranslate(pos[0] - bitmap.getWidth() / 2,pos[1] - bitmap.getHeight() / 2);
  canvas.drawPath(path,marcProgresspaint);
  //起始角度不为0时候才进行绘制小圆点
  if (mCurrentAngle == 0) {
    return;
  }
  canvas.drawBitmap(bitmap,matrix,mBitmapPaint);
  mBitmapPaint.setColor(Color.WHITE);
  canvas.drawCircle(pos[0],pos[1],8,mBitmapPaint);
}

其中一个特性是它确定了文本可能的最大字体大小,同时将文本保留在盒子的限制范围内.

这在大多数情况下都可以正常工作,但有时它会将一个单词切成两半以适应它.

所以它可能会显示为……

stackov 
erflow

而不是

stackoverflow

(但是字体较小)

我认为会有一个StringFormatFlag允许我指定如何完成自动换行.

我想要自动换行,但不是’字符’换行.

谢谢
丰富.

TextRenderer.DrawText(e.Graphics,"stackoverflow",this.Font,new Rectangle(10,10,32,32),Color.Black,Color.Empty,textformatFlags.WordBreak | textformatFlags.VerticalCenter | textformatFlags.HorizontalCenter);

  TextRenderer.DrawText(e.Graphics,"stack overflow",new Rectangle(50,textformatFlags.WordBreak | textformatFlags.VerticalCenter | textformatFlags.HorizontalCenter);

注意,最好我可以指出的字体是正确构造的(我只是使用10pt的Arial),rect的大小是正的和有效的,画笔是一个白色的SolidBrush,格式标志不影响输出; ie如果我从调用中排除格式标志,我仍然收到错误.

DrawString调用就在底部附近.

public ActionResult RenderText(
    string fontFamily,float pointSize,string foreColor,string backColor,bool isBold,bool isItalic,bool isvertical,string align,string[] allText,int textIndex)
{
    // method renders a horizontal or vertical text image,taking all the text strings that will be rendered in each image
    // and sizing the final bitmap according to which text would take the most space,thereby making it possible to render
    // a selection of text images all at the same size.

    Response.ContentType = "image/png";

    var fmt = StringFormat.GenericTypographic;
    if(isvertical)
        fmt.FormatFlags = StringFormatFlags.DirectionVertical;

    Func<string,Stringalignment> getAlign = (s => {
        switch(s.ToLower())
        {
            case "right": return Stringalignment.Far;
            case "center": return Stringalignment.Center;
            default: return Stringalignment.Near;
        }
    });
    fmt.LineAlignment = isvertical ? Stringalignment.Center : getAlign(align);
    fmt.Alignment = isvertical ? getAlign(align) : Stringalignment.Center;

    var strings = (allText ?? new string[0]).Where(t => t.Length > 0).ToList();
    if(strings.Count == 0)
        strings.Add("[Missing Text]");

    FontStyle style = FontStyle.Regular;
    if(isBold)
        if(isItalic)
            style = FontStyle.Bold | FontStyle.Italic;
        else
            style = FontStyle.Bold;
    else if(isItalic)
        style = FontStyle.Italic;

    Font font = new Font(fontFamily,pointSize,style,GraphicsUnit.Point);
    Color fc = foreColor.IsHexColorString() ? foreColor.ToColorFromHex() : foreColor.ToColor();
    Color bc = backColor.IsHexColorString() ? backColor.ToColorFromHex() : backColor.ToColor();

    var maxSize = new Size(0,0);
    using(var tmp = new Bitmap(100,200))
        using(var gfx = Graphics.FromImage(tmp))
            foreach(var txt in strings)
            {
                var size = gfx.MeasureString(txt,font,1000,fmt);
                maxSize = new Size(
                    Math.Max(Convert.ToInt32(isvertical ? size.Height : size.Width),maxSize.Width),Math.Max(Convert.ToInt32(isvertical ? size.Width : size.Height),maxSize.Width)
                );
            }

    using(var bmp = new Bitmap(maxSize.Width,maxSize.Height))
    {
        using(var gfx = Graphics.FromImage(bmp))
        {
            gfx.CompositingMode = CompositingMode.sourcecopy;
            gfx.CompositingQuality = CompositingQuality.HighQuality;
            gfx.SmoothingMode = SmoothingMode.HighQuality;
            gfx.InterpolationMode = InterpolationMode.HighQualityBicubic;

            var rect = new RectangleF(new PointF(0,0),maxSize);
            gfx.FillRectangle(new SolidBrush(bc),rect);
            gfx.DrawString(strings[textIndex],new SolidBrush(fc),rect,fmt);
        }
        bmp.Save(Response.OutputStream,ImageFormat.Png);
    }
    return new EmptyResult();
}

gfx.CompositingMode = CompositingMode.sourcecopy;

private static void TestPerformance(Action action, int times)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for(int i = 0; i < times; i++)
            {
                action();
            }
            sw.Stop();
            Console.WriteLine(action.Method.Name + ", FullTime: " + sw.ElapsedMilliseconds);
        }

private static void AddTest()
        {
            string s = string.Empty;
            s = "1" + "2" + "3" + "4" + "5" + "6" + "7" + "8";
        }

private static void AddWithParamTest2()
        {
            string s = string.Empty;
            s += "1";
            s += "2";
            s += "3";
            s += "4";
            s += "5";
            s += "6";
            s += "7";
            s += "8";
        }

private static void ConcatTest()
        {
            string s = string.Empty;
            s = string.Concat(s, "1");
            s = string.Concat(s, "2");
            s = string.Concat(s, "3");
            s = string.Concat(s, "4");
            s = string.Concat(s, "5");
            s = string.Concat(s, "6");
            s = string.Concat(s, "7");
            s = string.Concat(s, "8");
        }

private static void ConcatTest2()
        {
            string s = string.Empty;
            string.Concat(s, "1", "2", "3", "4", "5", "6", "7", "8");           
        }

private static void FormatTest()
        {
            string s = string.Empty;
            s = string.Format("{0}{1}{2}{3}{4}{5}{6}{7}", "1", "2", "3", "4", "5", "6", "7", "8");
        }

private static void FormatTest2()
        {
            string s = string.Empty;
            s = string.Format("{0}{1}", s, "1");
            s = string.Format("{0}{1}", s, "2");
            s = string.Format("{0}{1}", s, "3");
            s = string.Format("{0}{1}", s, "4");
            s = string.Format("{0}{1}", s, "5");
            s = string.Format("{0}{1}", s, "6");
            s = string.Format("{0}{1}", s, "7");
            s = string.Format("{0}{1}", s, "8");
        }

private static void BuilderTest()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("1");
            sb.Append("2");
            sb.Append("3");
            sb.Append("4");
            sb.Append("5");
            sb.Append("6");
            sb.Append("7");
            sb.Append("8");
        }

private static void TestPerformanceWithParam<T>(Action<T> action, T t, int times)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < times; i++)
            {
                action(t);
            }
            sw.Stop();
            Console.WriteLine(action.Method.Name + ", FullTime: " + sw.ElapsedMilliseconds);
        }

private static void AddTest(string t)
        {
            string s = string.Empty;
            s = t + t + t + t + t + t + t + t;
        }

.method private hidebysig static void  AddTest(string t) cil managed
{
  // Code size       51 (0x33)
  .maxstack  8
  IL_0000:  ldsfld     string [System.Runtime]System.String::Empty
  IL_0005:  pop
  IL_0006:  ldc.i4.8
  IL_0007:  newarr     [System.Runtime]System.String
  IL_000c:  dup
  IL_000d:  ldc.i4.0
  IL_000e:  ldarg.0
  IL_000f:  stelem.ref
  IL_0010:  dup
  IL_0011:  ldc.i4.1
  IL_0012:  ldarg.0
  IL_0013:  stelem.ref
  IL_0014:  dup
  IL_0015:  ldc.i4.2
  IL_0016:  ldarg.0
  IL_0017:  stelem.ref
  IL_0018:  dup
  IL_0019:  ldc.i4.3
  IL_001a:  ldarg.0
  IL_001b:  stelem.ref
  IL_001c:  dup
  IL_001d:  ldc.i4.4
  IL_001e:  ldarg.0
  IL_001f:  stelem.ref
  IL_0020:  dup
  IL_0021:  ldc.i4.5
  IL_0022:  ldarg.0
  IL_0023:  stelem.ref
  IL_0024:  dup
  IL_0025:  ldc.i4.6
  IL_0026:  ldarg.0
  IL_0027:  stelem.ref
  IL_0028:  dup
  IL_0029:  ldc.i4.7
  IL_002a:  ldarg.0
  IL_002b:  stelem.ref
  IL_002c:  call       string [System.Runtime]System.String::Concat(string[])
  IL_0031:  pop
  IL_0032:  ret
} // end of method Program::AddTest

private static void AddWithParamTest2(string t)
        {
            string s = string.Empty;
            s += t;
            s += t;
            s += t;
            s += t;
            s += t;
            s += t;
            s += t;
            s += t;
        }

private static void FormatTest(string t)
        {
            string s = string.Format("{0}{1}{2}{3}{4}{5}{6}{7}", t, t, t, t, t, t, t, t);
        }

private static void BuilderTest(string t)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(t);
            sb.Append(t);
            sb.Append(t);
            sb.Append(t);
            sb.Append(t);
            sb.Append(t);
            sb.Append(t);
            sb.Append(t);
        }

private static void TestAddVeryLong(string s, int times)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            string str = string.Empty;
            for(int i = 0; i < times; i++)
            {
                str += s;
            }
            sw.Stop();
            Console.WriteLine("add very long: " + sw.ElapsedMilliseconds);
        }

private static void TestConcatVeryLong(string s, int times)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            string str = string.Empty;
            for (int i = 0; i < times; i++)
            {
                str = string.Concat(str, s);
            }
            sw.Stop();
            Console.WriteLine("concat very long: " + sw.ElapsedMilliseconds);
        }

private static void TestFormatVeryLong(string s, int times)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            string str = string.Empty;
            for (int i = 0; i < times; i++)
            {
                str = string.Format("{0}{1}", str, s);
            }
            sw.Stop();
            Console.WriteLine("format very long: " + sw.ElapsedMilliseconds);
        }

private static void TestBuilderVeryLong(string s, int times)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < times; i++)
            {
                sb.Append(s);
            }
            sw.Stop();
            Console.WriteLine("builder very long: " + sw.ElapsedMilliseconds);
        }