C# android.drawRect方法代码示例

		public override void draw(android.graphics.Canvas canvas)
		{
			if (((int)(((uint)mState.mUseColor) >> 24)) != 0)
			{
				mPaint.setColor(mState.mUseColor);
				canvas.drawRect(getBounds(), mPaint);
			}
		}

		public override void draw(android.graphics.Canvas canvas)
		{
			android.graphics.Bitmap bitmap = mBitmap;
			if (bitmap != null)
			{
				android.graphics.drawable.BitmapDrawable.BitmapState state = mBitmapState;
				if (state.mRebuildShader)
				{
					android.graphics.Shader.TileMode? tmx = state.mTileModeX;
					android.graphics.Shader.TileMode? tmy = state.mTileModeY;
					if (tmx == null && tmy == null)
					{
						state.mPaint.setShader(null);
					}
					else
					{
						state.mPaint.setShader(new android.graphics.BitmapShader(bitmap, tmx == null ? android.graphics.Shader.TileMode
							.CLAMP : tmx, tmy == null ? android.graphics.Shader.TileMode.CLAMP : tmy));
					}
					state.mRebuildShader = false;
					copyBounds(mDstRect);
				}
				android.graphics.Shader shader = state.mPaint.getShader();
				if (shader == null)
				{
					if (mApplyGravity)
					{
						int layoutDirection = getResolvedLayoutDirectionSelf();
						android.view.Gravity.apply(state.mGravity, mBitmapWidth, mBitmapHeight, getBounds
							(), mDstRect, layoutDirection);
						mApplyGravity = false;
					}
					canvas.drawBitmap(bitmap, null, mDstRect, state.mPaint);
				}
				else
				{
					if (mApplyGravity)
					{
						copyBounds(mDstRect);
						mApplyGravity = false;
					}
					canvas.drawRect(mDstRect, state.mPaint);
				}
			}
		}

		public override void draw(android.graphics.Canvas canvas)
		{
			if (!ensureValidRect())
			{
				// nothing to draw
				return;
			}
			// remember the alpha values, in case we temporarily overwrite them
			// when we modulate them with mAlpha
			int prevFillAlpha = mFillPaint.getAlpha();
			int prevStrokeAlpha = mStrokePaint != null ? mStrokePaint.getAlpha() : 0;
			// compute the modulate alpha values
			int currFillAlpha = modulateAlpha(prevFillAlpha);
			int currStrokeAlpha = modulateAlpha(prevStrokeAlpha);
			bool haveStroke = currStrokeAlpha > 0 && mStrokePaint.getStrokeWidth() > 0;
			bool haveFill = currFillAlpha > 0;
			android.graphics.drawable.GradientDrawable.GradientState st = mGradientState;
			bool useLayer = haveStroke && haveFill && st.mShape != LINE && currStrokeAlpha < 
				255 && (mAlpha < 255 || mColorFilter != null);
			if (useLayer)
			{
				if (mLayerPaint == null)
				{
					mLayerPaint = new android.graphics.Paint();
				}
				mLayerPaint.setDither(mDither);
				mLayerPaint.setAlpha(mAlpha);
				mLayerPaint.setColorFilter(mColorFilter);
				float rad = mStrokePaint.getStrokeWidth();
				canvas.saveLayer(mRect.left - rad, mRect.top - rad, mRect.right + rad, mRect.bottom
					 + rad, mLayerPaint, android.graphics.Canvas.HAS_ALPHA_LAYER_SAVE_FLAG);
				// don't perform the filter in our individual paints
				// since the layer will do it for us
				mFillPaint.setColorFilter(null);
				mStrokePaint.setColorFilter(null);
			}
			else
			{
				mFillPaint.setAlpha(currFillAlpha);
				mFillPaint.setDither(mDither);
				mFillPaint.setColorFilter(mColorFilter);
				if (haveStroke)
				{
					mStrokePaint.setAlpha(currStrokeAlpha);
					mStrokePaint.setDither(mDither);
					mStrokePaint.setColorFilter(mColorFilter);
				}
			}
			switch (st.mShape)
			{
				case RECTANGLE:
				{
					if (st.mRadiusArray != null)
					{
						if (mPathIsDirty || mRectIsDirty)
						{
							mPath.reset();
							mPath.addRoundRect(mRect, st.mRadiusArray, android.graphics.Path.Direction.CW);
							mPathIsDirty = mRectIsDirty = false;
						}
						canvas.drawPath(mPath, mFillPaint);
						if (haveStroke)
						{
							canvas.drawPath(mPath, mStrokePaint);
						}
					}
					else
					{
						if (st.mRadius > 0.0f)
						{
							// since the caller is only giving us 1 value, we will force
							// it to be square if the rect is too small in one dimension
							// to show it. If we did nothing, Skia would clamp the rad
							// independently along each axis, giving us a thin ellipse
							// if the rect were very wide but not very tall
							float rad = st.mRadius;
							float r = System.Math.Min(mRect.width(), mRect.height()) * 0.5f;
							if (rad > r)
							{
								rad = r;
							}
							canvas.drawRoundRect(mRect, rad, rad, mFillPaint);
							if (haveStroke)
							{
								canvas.drawRoundRect(mRect, rad, rad, mStrokePaint);
							}
						}
						else
						{
							canvas.drawRect(mRect, mFillPaint);
							if (haveStroke)
							{
								canvas.drawRect(mRect, mStrokePaint);
							}
						}
					}
					break;
				}

				case OVAL:
//.........这里部分代码省略.........

		public override void draw(android.graphics.Canvas canvas)
		{
			android.graphics.Rect r = getBounds();
			android.graphics.Paint paint = mShapeState.mPaint;
			int prevAlpha = paint.getAlpha();
			paint.setAlpha(modulateAlpha(prevAlpha, mShapeState.mAlpha));
			if (mShapeState.mShape != null)
			{
				// need the save both for the translate, and for the (unknown) Shape
				int count = canvas.save();
				canvas.translate(r.left, r.top);
				onDraw(mShapeState.mShape, canvas, paint);
				canvas.restoreToCount(count);
			}
			else
			{
				canvas.drawRect(r, paint);
			}
			// restore
			paint.setAlpha(prevAlpha);
		}

		public override void draw(android.graphics.Canvas canvas, android.graphics.Paint 
			paint)
		{
			canvas.drawRect(mRect, paint);
		}