Exemplo n.º 1
0
		public override void draw(android.graphics.Canvas canvas, android.graphics.Paint 
			paint)
		{
			canvas.save();
			canvas.scale(mScaleX, mScaleY);
			canvas.drawPath(mPath, paint);
			canvas.restore();
		}
Exemplo n.º 2
0
		public override void draw(android.graphics.Canvas canvas)
		{
			if (mPicture != null)
			{
				android.graphics.Rect bounds = getBounds();
				canvas.save();
				canvas.clipRect(bounds);
				canvas.translate(bounds.left, bounds.top);
				canvas.drawPicture(mPicture);
				canvas.restore();
			}
		}
Exemplo n.º 3
0
		public virtual void draw(android.graphics.Canvas canvas)
		{
			if (mDrawable == null)
			{
				return;
			}
			canvas.save(android.graphics.Canvas.MATRIX_SAVE_FLAG);
			canvas.translate(mTranslationX, mTranslationY);
			canvas.scale(mScaleX, mScaleY);
			canvas.translate(-0.5f * getWidth(), -0.5f * getHeight());
			mDrawable.setAlpha((int)Sharpen.Util.Round(mAlpha * 255f));
			mDrawable.draw(canvas);
			canvas.restore();
		}
Exemplo n.º 4
0
		protected internal override void onDraw(android.graphics.Canvas canvas)
		{
			lock (this)
			{
				base.onDraw(canvas);
				if (mThumb != null)
				{
					canvas.save();
					// Translate the padding. For the x, we need to allow the thumb to
					// draw in its extra space
					canvas.translate(mPaddingLeft - mThumbOffset, mPaddingTop);
					mThumb.draw(canvas);
					canvas.restore();
				}
			}
		}
Exemplo n.º 5
0
		public override void draw(android.graphics.Canvas canvas)
		{
			if (mClipState.mDrawable.getLevel() == 0)
			{
				return;
			}
			android.graphics.Rect r = mTmpRect;
			android.graphics.Rect bounds = getBounds();
			int level = getLevel();
			int w = bounds.width();
			int iw = 0;
			//mClipState.mDrawable.getIntrinsicWidth();
			if ((mClipState.mOrientation & HORIZONTAL) != 0)
			{
				w -= (w - iw) * (10000 - level) / 10000;
			}
			int h = bounds.height();
			int ih = 0;
			//mClipState.mDrawable.getIntrinsicHeight();
			if ((mClipState.mOrientation & VERTICAL) != 0)
			{
				h -= (h - ih) * (10000 - level) / 10000;
			}
			int layoutDirection = getResolvedLayoutDirectionSelf();
			android.view.Gravity.apply(mClipState.mGravity, w, h, bounds, r, layoutDirection);
			if (w > 0 && h > 0)
			{
				canvas.save();
				canvas.clipRect(r);
				mClipState.mDrawable.draw(canvas);
				canvas.restore();
			}
		}
Exemplo n.º 6
0
		/// <summary>Draw this object to the canvas using the properties defined in this class.
		/// 	</summary>
		/// <remarks>Draw this object to the canvas using the properties defined in this class.
		/// 	</remarks>
		/// <param name="canvas">canvas to draw into</param>
		public virtual void draw(android.graphics.Canvas canvas)
		{
			float threshold = 1.0f / 256.0f;
			// contribution less than 1 LSB of RGB byte
			if (mAlpha <= threshold)
			{
				// don't bother if it won't show up
				return;
			}
			canvas.save(android.graphics.Canvas.MATRIX_SAVE_FLAG);
			canvas.translate(mX, mY);
			canvas.scale(mScaleX, mScaleY);
			canvas.translate(-0.5f * getWidth(), -0.5f * getHeight());
			mDrawable.setAlpha((int)Sharpen.Util.Round(mAlpha * 255f));
			mDrawable.draw(canvas);
			canvas.restore();
		}
Exemplo n.º 7
0
		protected internal override void onDraw(android.graphics.Canvas canvas)
		{
			base.onDraw(canvas);
			bool changed = mChanged;
			if (changed)
			{
				mChanged = false;
			}
			int availableWidth = mRight - mLeft;
			int availableHeight = mBottom - mTop;
			int x = availableWidth / 2;
			int y = availableHeight / 2;
			android.graphics.drawable.Drawable dial = mDial;
			int w = dial.getIntrinsicWidth();
			int h = dial.getIntrinsicHeight();
			bool scaled = false;
			if (availableWidth < w || availableHeight < h)
			{
				scaled = true;
				float scale = System.Math.Min((float)availableWidth / (float)w, (float)availableHeight
					 / (float)h);
				canvas.save();
				canvas.scale(scale, scale, x, y);
			}
			if (changed)
			{
				dial.setBounds(x - (w / 2), y - (h / 2), x + (w / 2), y + (h / 2));
			}
			dial.draw(canvas);
			canvas.save();
			canvas.rotate(mHour / 12.0f * 360.0f, x, y);
			android.graphics.drawable.Drawable hourHand = mHourHand;
			if (changed)
			{
				w = hourHand.getIntrinsicWidth();
				h = hourHand.getIntrinsicHeight();
				hourHand.setBounds(x - (w / 2), y - (h / 2), x + (w / 2), y + (h / 2));
			}
			hourHand.draw(canvas);
			canvas.restore();
			canvas.save();
			canvas.rotate(mMinutes / 60.0f * 360.0f, x, y);
			android.graphics.drawable.Drawable minuteHand = mMinuteHand;
			if (changed)
			{
				w = minuteHand.getIntrinsicWidth();
				h = minuteHand.getIntrinsicHeight();
				minuteHand.setBounds(x - (w / 2), y - (h / 2), x + (w / 2), y + (h / 2));
			}
			minuteHand.draw(canvas);
			canvas.restore();
			if (scaled)
			{
				canvas.restore();
			}
		}
Exemplo n.º 8
0
		protected internal override void dispatchDraw(android.graphics.Canvas canvas)
		{
			bool expandClipRegion = false;
			canvas.getClipBounds(stackInvalidateRect);
			int childCount = getChildCount();
			{
				for (int i = 0; i < childCount; i++)
				{
					android.view.View child = getChildAt(i);
					android.widget.StackView.LayoutParams lp = (android.widget.StackView.LayoutParams
						)child.getLayoutParams();
					if ((lp.horizontalOffset == 0 && lp.verticalOffset == 0) || child.getAlpha() == 0f
						 || child.getVisibility() != VISIBLE)
					{
						lp.resetInvalidateRect();
					}
					android.graphics.Rect childInvalidateRect = lp.getInvalidateRect();
					if (!childInvalidateRect.isEmpty())
					{
						expandClipRegion = true;
						stackInvalidateRect.union(childInvalidateRect);
					}
				}
			}
			// We only expand the clip bounds if necessary.
			if (expandClipRegion)
			{
				canvas.save(android.graphics.Canvas.CLIP_SAVE_FLAG);
				canvas.clipRect(stackInvalidateRect, android.graphics.Region.Op.UNION);
				base.dispatchDraw(canvas);
				canvas.restore();
			}
			else
			{
				base.dispatchDraw(canvas);
			}
		}
Exemplo n.º 9
0
		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:
				{
					canvas.drawOval(mRect, mFillPaint);
					if (haveStroke)
					{
						canvas.drawOval(mRect, mStrokePaint);
					}
					break;
				}

				case LINE:
				{
					android.graphics.RectF r = mRect;
					float y = r.centerY();
					canvas.drawLine(r.left, y, r.right, y, mStrokePaint);
					break;
				}

				case RING:
				{
					android.graphics.Path path = buildRing(st);
					canvas.drawPath(path, mFillPaint);
					if (haveStroke)
					{
						canvas.drawPath(path, mStrokePaint);
					}
					break;
				}
			}
			if (useLayer)
			{
				canvas.restore();
			}
			else
			{
				mFillPaint.setAlpha(prevFillAlpha);
				if (haveStroke)
				{
					mStrokePaint.setAlpha(prevStrokeAlpha);
				}
			}
		}