protected override void OnDraw(Canvas canvas) {
base.OnDraw (canvas);
if (mBlurredView != null) {
if (prepare()) {
// If the background of the blurred view is a color drawable, we use it to clear
// the blurring canvas, which ensures that edges of the child views are blurred
// as well; otherwise we clear the blurring canvas with a transparent color.
if (mBlurredView.Background != null && mBlurredView.Background is ColorDrawable){
mBitmapToBlur.EraseColor(((ColorDrawable) mBlurredView.Background).Color);
}else {
mBitmapToBlur.EraseColor(Color.Transparent);
}
mBlurredView.Draw(mBlurringCanvas);
blur();
canvas.Save();
canvas.Translate(mBlurredView.GetX() - GetX(), mBlurredView.GetY() - GetY());
canvas.Scale(mDownsampleFactor, mDownsampleFactor);
canvas.DrawBitmap(mBlurredBitmap, 0, 0, null);
canvas.Restore();
}
canvas.DrawColor(mOverlayColor);
}
}
protected override void OnDraw(Android.Graphics.Canvas canvas)
{
canvas.Save();
canvas.Translate(_width, _height);
canvas.Rotate(-90);
TextPaint paint = this.Paint;
//Android.Graphics.Color Colorr = Color. //this.TextColors.DefaultColor;
//
//var defcolor = this.TextColors.DefaultColor;
//var Redd = Color.GetRedComponent(defcolor);
//var Blue = Color.GetBlueComponent(defcolor);
//var Greenn = Color.GetGreenComponent(defcolor);
//var Birlestir = Color.Rgb(Redd, Greenn, Blue);
//ColorFilter cf = new PorterDuffColorFilter(Birlestir, PorterDuff.Mode.SrcAtop);
//paint.SetColorFilter(cf);
paint.Color = Color.White;
String text = getTextt();
paint.GetTextBounds(text, 0, text.Length, _bounds);
canvas.DrawText(text, this.CompoundPaddingLeft, (_bounds.Height() - _width) / 2, paint);
canvas.Restore();
}
protected override void DispatchDraw(Android.Graphics.Canvas canvas)
{
base.DispatchDraw(canvas);
if (opened || isTracking || animator != null)
{
// Draw inset shadow on the menu
canvas.Save();
shadowDrawable.SetBounds(0, 0, Context.ToPixels(8), Height);
canvas.Translate(ContentView.Left - shadowDrawable.Bounds.Width(), 0);
shadowDrawable.Draw(canvas);
canvas.Restore();
if (contentOffsetX != 0)
{
// Cover the area with a black overlay to display openess graphically
var openness = ((float)(MaxOffset - contentOffsetX)) / MaxOffset;
overlayPaint.Alpha = Math.Max(0, (int)(MaxOverlayAlpha * openness));
if (overlayPaint.Alpha > 0)
{
canvas.DrawRect(0, 0, ContentView.Left, Height, overlayPaint);
}
}
}
}
public void DrawStopwatch(Canvas canvas)
{
canvas.Save();
canvas.Translate(Width / 2F, Height / 2F);
var tickMarks = new Path();
tickMarks.AddCircle(0, 0, 90, Path.Direction.Cw);
var scale = Math.Min(Width, Height) / 2F / 120;
canvas.Scale(scale, scale);
var paint = new Paint
{
StrokeCap = Paint.Cap.Square,
Color = new Color(240, 240, 240)
};
paint.SetStyle(Paint.Style.Stroke);
paint.StrokeWidth = 3;
paint.SetPathEffect(MinuteDashEffect);
canvas.DrawPath(tickMarks, paint);
paint.Color = new Color(240, 240, 240);
paint.StrokeWidth = 4;
paint.SetPathEffect(FifthMinuteDashEffect);
canvas.DrawPath(tickMarks, paint);
}
public void Draw(Canvas canvas)
{
canvas.Save();
canvas.Translate((float)Position.X, (float)Position.Y);
canvas.Rotate((float)Acceleration.Direction + ROTATION_OFFSET);
mDrawable.Draw(canvas);
canvas.Restore();
}
protected override void OnDraw (Canvas canvas)
{
base.OnDraw (canvas);
canvas.Save ();
canvas.Translate (_posX, _posY);
canvas.Scale (_scaleFactor, _scaleFactor);
_icon.Draw (canvas);
canvas.Restore ();
}
private void ShowPath(Canvas canvas, int x, int y, Path.FillType ft, Paint paint)
{
canvas.Save();
canvas.Translate(x, y);
canvas.ClipRect(0, 0, 120, 120);
canvas.DrawColor(Color.White);
mPath.SetFillType(ft);
canvas.DrawPath(mPath, paint);
canvas.Restore();
}
protected override void OnDraw(Canvas canvas)
{
for (int i = 0; i < balls.Count; ++i)
{
ShapeHolder shapeHolder = balls[i];
canvas.Save();
canvas.Translate(shapeHolder.X, shapeHolder.Y);
shapeHolder.Shape.Draw(canvas);
canvas.Restore();
}
}
public override void Draw(Canvas canvas, ICharSequence text, int start, int end, float x, int top, int y, int bottom, Paint paint)
{
PrepView();
canvas.Save();
//Centering the token looks like a better strategy that aligning the bottom
int padding = (bottom - top - View.Bottom) / 2;
canvas.Translate(x, bottom - View.Bottom - padding);
View.Draw(canvas);
canvas.Restore();
}
protected override void OnDraw(Android.Graphics.Canvas canvas)
{
BorderedRectPaintDrawable paintDrawable = Background as BorderedRectPaintDrawable;
if (paintDrawable != null)
{
float borderWidth = TypedValue.ApplyDimension(ComplexUnitType.Dip, paintDrawable.BorderWidth, Rock.Mobile.PlatformSpecific.Android.Core.Context.Resources.DisplayMetrics);
canvas.Translate(borderWidth, borderWidth);
}
base.OnDraw(canvas);
}
protected override void OnDraw(Android.Graphics.Canvas canvas)
{
var textPaint = this.Paint;
textPaint.Color = new Color(this.CurrentTextColor);
canvas.Save();
if (m_TopDown)
{
canvas.Translate(this.Width, 0);
canvas.Rotate(90.0f);
}
else
{
canvas.Translate(0, this.Height);
canvas.Rotate(-90.0f);
}
canvas.Translate(this.CompoundPaddingLeft, this.ExtendedPaddingTop);
this.Layout.Draw(canvas);
canvas.Restore();
}
protected override void OnDraw(Canvas canvas)
{
Paint paint = mPaint;
canvas.DrawColor(Color.Argb(255, 204, 204, 204));
canvas.Translate(20, 20);
paint.AntiAlias = true;
ShowPath(canvas, 0, 0, Path.FillType.Winding, paint);
ShowPath(canvas, 160, 0, Path.FillType.EvenOdd, paint);
ShowPath(canvas, 0, 160, Path.FillType.InverseWinding, paint);
ShowPath(canvas, 160, 160, Path.FillType.InverseEvenOdd, paint);
}
protected override void OnDraw (Canvas canvas)
{
canvas.DrawColor (Color.White);
canvas.Translate (10, 10);
canvas.SaveLayerAlpha (0, 0, 200, 200, 0x88, SaveFlags.All);
mPaint.Color = Color.Red;
canvas.DrawCircle (75, 75, 75, mPaint);
mPaint.Color = Color.Blue;
canvas.DrawCircle (125, 125, 75, mPaint);
canvas.Restore ();
}
protected override void OnDraw(Android.Graphics.Canvas canvas)
{
BorderedRectPaintDrawable paintDrawable = Background as BorderedRectPaintDrawable;
if (paintDrawable != null)
{
float borderWidth = TypedValue.ApplyDimension(ComplexUnitType.Dip, paintDrawable.BorderWidth, Rock.Mobile.PlatformSpecific.Android.Core.Context.Resources.DisplayMetrics);
// perform just a vertical translation to ensure the text is centered
canvas.Translate(0, borderWidth);
// create a scalar to uniformly scale down the text so it fits within the border
float scalar = (canvas.Width - (borderWidth * 2)) / canvas.Width;
canvas.Scale(scalar, scalar);
}
base.OnDraw(canvas);
}
protected override void OnDraw(Canvas canvas)
{
int canvasWidth = canvas.Width;
int canvasHeight = canvas.Height;
paint.SetStyle(Paint.Style.Fill);
paint.Color=color(0xffff0000);
canvas.DrawRect(dp2px(16), dp2px(16), dp2px(50), dp2px(50), paint);
paint.Color= color(0xffcc9900);
canvas.DrawRect(dp2px(100), dp2px(16), dp2px(133), dp2px(50), paint);
paint.Color = color(0xff00ff00);
canvas.DrawRect(dp2px(16), dp2px(106), dp2px(50), dp2px(140), paint);
paint.Color = color(0xff6600ff);
canvas.DrawRect(dp2px(100), dp2px(106), dp2px(133), dp2px(140), paint);
canvas.Translate(canvasWidth / 2, canvasHeight / 2);
paint.StrokeWidth=3;
paint.SetStyle(Paint.Style.Stroke);
paint.TextSize=dp2px(18);
paint.Color= color(0xffffff00);
canvas.DrawText("Custom View", -dp2px(53), dp2px(3), paint);
}
protected override void OnDraw(Canvas canvas)
{
var r = CenterX - _paint.StrokeWidth * 0.5f;
canvas.Translate(CenterX, CenterX);
canvas.DrawOval(new RectF(-r, -r, r, r), _paint);
canvas.DrawCircle(0, 0, CenterRadius, _centerPaint);
if (_trackingCenter)
{
var c = _centerPaint.Color;
_centerPaint.SetStyle(Paint.Style.Stroke);
_centerPaint.Alpha = _highlightCenter ? 255 : 128;
canvas.DrawCircle(0, 0,
CenterRadius + _centerPaint.StrokeWidth,
_centerPaint);
_centerPaint.SetStyle(Paint.Style.Fill);
_centerPaint.Color = c;
}
}
protected void DrawAt(Canvas canvas, Drawable drawable, int x, int y, bool shadow)
{
try
{
canvas.Save();
canvas.Translate(x, y);
if (shadow)
{
drawable.SetColorFilter(Util.Int32ToColor(2130706432), PorterDuff.Mode.SrcIn);
canvas.Skew(-0.9F, 0.0F);
canvas.Scale(1.0F, 0.5F);
}
drawable.Draw(canvas);
if (shadow)
{
drawable.ClearColorFilter();
}
}
finally
{
canvas.Restore();
}
}
protected override void OnDraw(Canvas canvas)
{
Paint paint = mPaint;
canvas.DrawColor (Color.White);
paint.AntiAlias = true;
paint.Color = Color.Black;
paint.SetStyle (Paint.Style.Fill);
int w = canvas.Width;
int h = canvas.Height;
int cx = w / 2;
int cy = h / 2;
canvas.Translate (cx, cy);
if (compass.mValues != null)
canvas.Rotate (-compass.mValues[0]);
canvas.DrawPath (mPath, mPaint);
}
public void TransformCanvas(Canvas canvas, float percentOpen)
{
canvas.Translate(0, canvas.Height * (1 - Interpolator.GetInterpolation(percentOpen)));
}
internal CCTexture2D CreateTextSprite(string text, CCFontDefinition textDefinition)
{
if (string.IsNullOrEmpty(text))
return new CCTexture2D();
int imageWidth;
int imageHeight;
var textDef = textDefinition;
var contentScaleFactorWidth = CCLabel.DefaultTexelToContentSizeRatios.Width;
var contentScaleFactorHeight = CCLabel.DefaultTexelToContentSizeRatios.Height;
textDef.FontSize *= contentScaleFactorWidth;
textDef.Dimensions.Width *= contentScaleFactorWidth;
textDef.Dimensions.Height *= contentScaleFactorHeight;
bool hasPremultipliedAlpha;
var display = Game.Activity.WindowManager.DefaultDisplay;
var metrics = new DisplayMetrics();
display.GetMetrics(metrics);
// Do not take into account ScaleDensity for now.
// var fontScaleFactor = metrics.ScaledDensity;
// textDef.FontSize = (int)(textDef.FontSize * fontScaleFactor);
// out paint object to hold our drawn text
// var paintFlags = new PaintFlags();
// if (textDefinition.isShouldAntialias)
// paintFlags = PaintFlags.AntiAlias | PaintFlags.SubpixelText;
var textPaint = new TextPaint();
textPaint.Color = Android.Graphics.Color.White;
textPaint.TextAlign = Paint.Align.Left;
textPaint.AntiAlias = textDefinition.isShouldAntialias;
textPaint.TextSize = textDef.FontSize;
var fontName = textDef.FontName;
var ext = System.IO.Path.GetExtension(fontName);
if (!String.IsNullOrEmpty(ext) && ext.ToLower() == ".ttf")
{
CCContentManager.SharedContentManager.GetAssetStreamAsBytes(fontName, out fontName);
var activity = Game.Activity;
try
{
var typeface = Typeface.CreateFromAsset(activity.Assets, fontName);
textPaint.SetTypeface(typeface);
}
catch (Exception)
{
textPaint.SetTypeface(Typeface.Create(fontName, TypefaceStyle.Normal));
}
}
else
{
textPaint.SetTypeface(Typeface.Create(fontName, TypefaceStyle.Normal));
}
// color
var foregroundColor = Android.Graphics.Color.White;
textPaint.Color = foregroundColor;
// alignment
var horizontalAlignment = textDef.Alignment;
var verticleAlignement = textDef.LineAlignment;
var textAlign = (CCTextAlignment.Right == horizontalAlignment) ? Layout.Alignment.AlignOpposite
: (CCTextAlignment.Center == horizontalAlignment) ? Layout.Alignment.AlignCenter
: Layout.Alignment.AlignNormal;
// LineBreak
// TODO: Find a way to specify the type of line breaking if possible.
var dimensions = new CCSize(textDef.Dimensions.Width, textDef.Dimensions.Height);
var layoutAvailable = true;
if (dimensions.Width <= 0)
{
dimensions.Width = 8388608;
layoutAvailable = false;
}
if (dimensions.Height <= 0)
{
dimensions.Height = 8388608;
layoutAvailable = false;
}
// Get bounding rectangle - we need its attribute and method values
var layout = new StaticLayout(text, textPaint,
(int)dimensions.Width, textAlign, 1.0f, 0.0f, false);
var boundingRect = new Rect();
var lineBounds = new Rect();
// Loop through all the lines so we can find our drawing offsets
var lineCount = layout.LineCount;
// early out if something went wrong somewhere and nothing is to be drawn
if (lineCount == 0)
return new CCTexture2D();
for (int lc = 0; lc < lineCount; lc++)
{
layout.GetLineBounds(lc, lineBounds);
var max = (int)Math.Ceiling(layout.GetLineMax(lc));
if (boundingRect.Right < max)
boundingRect.Right = max;
boundingRect.Bottom = lineBounds.Bottom;
}
if (!layoutAvailable)
{
if (dimensions.Width == 8388608)
{
dimensions.Width = boundingRect.Right;
}
if (dimensions.Height == 8388608)
{
dimensions.Height = boundingRect.Bottom;
}
}
imageWidth = (int)dimensions.Width;
imageHeight = (int)dimensions.Height;
// Recreate our layout based on calculated dimensions so that we can draw the text correctly
// in our image when Alignment is not Left.
if (textAlign != Layout.Alignment.AlignNormal)
{
layout = new StaticLayout(text, textPaint,
(int)dimensions.Width, textAlign, 1.0f, 0.0f, false);
}
// Line alignment
var yOffset = (CCVerticalTextAlignment.Bottom == verticleAlignement
|| boundingRect.Bottom >= dimensions.Height) ? dimensions.Height - boundingRect.Bottom // align to bottom
: (CCVerticalTextAlignment.Top == verticleAlignement) ? 0 // align to top
: (imageHeight - boundingRect.Bottom) * 0.5f; // align to center
try {
// Create our platform dependant image to be drawn to.
using (Bitmap textureBitmap = Bitmap.CreateBitmap(imageWidth, imageHeight, Bitmap.Config.Argb8888))
{
using (Canvas drawingCanvas = new Canvas(textureBitmap))
{
drawingCanvas.DrawARGB(0, 255, 255, 255);
// Set our vertical alignment
drawingCanvas.Translate(0, yOffset);
// Now draw the text using our layout
layout.Draw(drawingCanvas);
// Create a pixel array
int[] pixels = new int[imageWidth * imageHeight];
// Now lets get our pixels.
// We use CopyPixelsToBuffer so that it is in Premultiplied Alpha already.
// Using Bitmap.GetPixels return non Premultiplied Alpha which causes blending problems
Java.Nio.IntBuffer byteBuffer = Java.Nio.IntBuffer.Allocate(imageWidth * imageHeight);
textureBitmap.CopyPixelsToBuffer(byteBuffer);
if (byteBuffer.HasArray)
{
byteBuffer.Rewind();
byteBuffer.Get(pixels, 0, pixels.Length);
}
// Make sure we recycle - Let's keep it green
textureBitmap.Recycle();
// Here we create our Texture and then set our pixel data.
var texture = new CCTexture2D(imageWidth, imageHeight);
texture.XNATexture.SetData<int>(pixels);
return texture;
}
}
}
catch (Exception exc)
{
CCLog.Log ("CCLabel Android: Error creating native label:{0}\n{1}", exc.Message, exc.StackTrace);
return new CCTexture2D();
}
}
protected override void OnDraw(Canvas canvas)
{
lock (this) {
if (mBitmap != null) {
Path path = mPath;
int outer = new Color (192, 192, 192);
int inner = new Color (255, 112, 16);
if (mLastX >= mMaxX) {
mLastX = 0;
Canvas cavas = mCanvas;
float yoffset = mYOffset;
float maxx = mMaxX;
float oneG = SensorManager.StandardGravity * mScale[0];
paint.Color = new Color (170, 170, 170);
cavas.DrawColor (Color.Black);
cavas.DrawLine (0, yoffset, maxx, yoffset, paint);
cavas.DrawLine (0, yoffset + oneG, maxx, yoffset + oneG, paint);
cavas.DrawLine (0, yoffset - oneG, maxx, yoffset - oneG, paint);
}
canvas.DrawBitmap (mBitmap, 0, 0, null);
float[] values = mOrientationValues;
if (mWidth < mHeight) {
float w0 = mWidth * 0.333333f;
float w = w0 - 32;
float x = w0 * 0.5f;
for (int i = 0; i < 3; i++) {
canvas.Save (SaveFlags.Matrix);
canvas.Translate (x, w * 0.5f + 4.0f);
canvas.Save (SaveFlags.Matrix);
paint.Color = outer;
canvas.Scale (w, w);
canvas.DrawOval (mRect, paint);
canvas.Restore ();
canvas.Scale (w - 5, w - 5);
paint.Color = inner;
canvas.Rotate (-values[i]);
canvas.DrawPath (path, paint);
canvas.Restore ();
x += w0;
}
} else {
float h0 = mHeight * 0.333333f;
float h = h0 - 32;
float y = h0 * 0.5f;
for (int i = 0; i < 3; i++) {
canvas.Save (SaveFlags.Matrix);
canvas.Translate (mWidth - (h * 0.5f + 4.0f), y);
canvas.Save (SaveFlags.Matrix);
paint.Color = outer;
canvas.Scale (h, h);
canvas.DrawOval (mRect, paint);
canvas.Restore ();
canvas.Scale (h - 5, h - 5);
paint.Color = inner;
canvas.Rotate (-values[i]);
canvas.DrawPath (path, paint);
canvas.Restore ();
y += h0;
}
}
}
}
}
public void transformCanvas(Canvas canvas, float percentOpen)
{
mTrans.transformCanvas(canvas, percentOpen);
float f = interp.GetInterpolation(percentOpen);
canvas.Translate((openedX - closedX) * f + closedX,
(openedY - closedY) * f + closedY);
}
protected override void OnDraw (Canvas canvas)
{
base.OnDraw (canvas);
// Clear screen to pink.
paint.Color = new Color (255, 204, 204);
canvas.DrawPaint (paint);
// Overall transforms to shift (0, 0) to center and scale.
canvas.Translate (this.Width / 2, this.Height / 2);
float scale = Math.Min (this.Width, this.Height) / 2.0f / 100;
canvas.Scale (scale, scale);
// Attributes for tick marks.
paint.Color = Color.Black;
paint.StrokeCap = Paint.Cap.Round;
paint.SetStyle (Paint.Style.Stroke);
// Set line dash to draw tick marks for every minute.
paint.StrokeWidth = 3;
paint.SetPathEffect (minuteTickDashEffect);
canvas.DrawPath (tickMarks, paint);
// Set line dash to draw tick marks for every hour.
paint.StrokeWidth = 6;
paint.SetPathEffect (hourTickDashEffect);
canvas.DrawPath (tickMarks, paint);
// Set attributes common to all clock hands.
Color strokeColor = Color.Black;
Color fillColor = Color.Blue;
paint.StrokeWidth = 2;
paint.SetPathEffect (null);
// Draw hour hand.
canvas.Save ();
canvas.Rotate (this.hourAngle);
paint.Color = fillColor;
paint.SetStyle (Paint.Style.Fill);
canvas.DrawPath (hourHand, paint);
paint.Color = strokeColor;
paint.SetStyle (Paint.Style.Stroke);
canvas.DrawPath (hourHand, paint);
canvas.Restore ();
// Draw minute hand.
canvas.Save ();
canvas.Rotate (this.minuteAngle);
paint.Color = fillColor;
paint.SetStyle (Paint.Style.Fill);
canvas.DrawPath (minuteHand, paint);
paint.Color = strokeColor;
paint.SetStyle (Paint.Style.Stroke);
canvas.DrawPath (minuteHand, paint);
canvas.Restore ();
// Draw second hand.
canvas.Save ();
canvas.Rotate (this.secondAngle);
paint.Color = strokeColor;
paint.SetStyle (Paint.Style.Stroke);
canvas.DrawPath (secondHand, paint);
canvas.Restore ();
}
protected override void DispatchDraw(Canvas canvas)
{
if (!_isFoldPrepared || FloatNearlyEqual(_foldFactor, 0))
{
base.DispatchDraw(canvas);
return;
}
if (!_shouldDraw)
return;
for (var x = 0; x < _numberOfFolds; x++)
{
var src = _foldRectArray[x];
canvas.Save();
canvas.Concat(_matrix[x]);
if (Build.VERSION.SdkInt == BuildVersionCodes.JellyBeanMr2)
{
_dstRect.Set(0, 0, src.Width(), src.Height());
canvas.DrawBitmap(_fullBitmap, src, _dstRect, null);
}
else
{
canvas.ClipRect(0, 0, src.Right - src.Left, src.Bottom - src.Top);
if (_isHorizontal)
canvas.Translate(-src.Left, 0);
else
canvas.Translate(0, -src.Top);
base.DispatchDraw(canvas);
if (_isHorizontal)
canvas.Translate(src.Left, 0);
else
canvas.Translate(0, src.Top);
}
canvas.DrawRect(0, 0, _foldDrawWidth, _foldDrawHeight, x % 2 == 0 ? _solidShadow : _gradientShadow);
canvas.Restore();
}
}
protected override void OnDraw(Canvas canvas)
{
if (!_clockwise)
{
canvas.Scale(-1, 1, _arcRect.CenterX(), _arcRect.CenterY());
}
// Draw the arcs
var arcStart = _startAngle + MAngleOffset + _arcRotation;
var arcSweep = _sweepAngle;
canvas.DrawArc(_arcRect, arcStart, arcSweep, false, _arcPaint);
canvas.DrawArc(_arcRect, arcStart, _progressSweep, false,
_progressPaint);
// Draw the thumb nail
canvas.Translate(_translateX - _thumbXPos, _translateY - _thumbYPos);
_thumb.Draw(canvas);
}
private void DrawStickyHeader(Canvas canvas)
{
var headerHeight = GetHeaderHeight();
var top = m_HeaderBottomPosition - headerHeight;
//clip the headers drawing area
m_ClippingRect.Left = PaddingLeft;
m_ClippingRect.Right = Width - PaddingRight;
m_ClippingRect.Bottom = top + headerHeight;
m_ClippingRect.Top = m_ClippingToPadding ? PaddingTop : 0;
canvas.Save();
canvas.ClipRect(m_ClippingRect);
canvas.Translate(PaddingLeft, top);
m_Header.Draw(canvas);
canvas.Restore();
}
private void drawString(Canvas gfx, TextPaint paint, float x, float y)
{
if (_maxWidth == int.MaxValue)
{
gfx.DrawText(_text, x, y, paint);
}
else
{
paint.TextAlign = alignWrap();
StaticLayout layout = new StaticLayout (_text, paint, _maxWidth, Layout.Alignment.AlignNormal, 1f, 0f, false);
gfx.Translate(x, y);
layout.Draw(gfx);
gfx.Translate(-x, -y);
}
}
public override void Draw(Canvas canvas)
{
_bounds = Bounds;
canvas.ClipRect(_bounds);
if (_reversed)
{
canvas.Translate(_bounds.Width(), 0);
canvas.Scale(-1, 1);
}
DrawStrokes(canvas);
}
protected override void OnDraw (Canvas canvas)
{
base.OnDraw (canvas);
var width = canvas.Width;
var height = canvas.Height;
// Center the canvas
canvas.Translate (width / 2f, height / 2f);
if (slicePath.IsEmpty) {
if (startAngle == 0 && endAngle == 360) {
slicePath.AddCircle (0, 0, radius - thickness, Path.Direction.Cw);
slicePath.AddCircle (0, 0, radius, Path.Direction.Ccw);
slicePath.Close ();
} else {
// Inner arc
rect.Set (-radius + thickness, -radius + thickness, radius - thickness, radius - thickness);
slicePath.ArcTo (rect, -90 + startAngle, endAngle - startAngle);
// Outer arc
rect.Set (-radius, -radius, radius, radius);
slicePath.ArcTo (rect, -90 + endAngle, startAngle - endAngle);
slicePath.Close ();
}
}
canvas.DrawPath (slicePath, slicePaint);
}
protected override void OnDraw (Canvas canvas)
{
var scale = this.Context.Resources.DisplayMetrics.Density;
var frame = GetFramingRect();
if (frame == null)
return;
var width = canvas.Width;
var height = canvas.Height;
paint.Color = resultBitmap != null ? resultColor : maskColor;
paint.Alpha = 100;
canvas.DrawRect(0, 0, width, frame.Top, paint);
//canvas.DrawRect(0, frame.Top, frame.Left, frame.Bottom + 1, paint);
//canvas.DrawRect(frame.Right + 1, frame.Top, width, frame.Bottom + 1, paint);
canvas.DrawRect(0, frame.Bottom + 1, width, height, paint);
var textPaint = new TextPaint();
textPaint.Color = Color.White;
textPaint.TextSize = 16 * scale;
var topTextLayout = new StaticLayout(this.TopText, textPaint, canvas.Width, Android.Text.Layout.Alignment.AlignCenter, 1.0f, 0.0f, false);
canvas.Save();
Rect topBounds = new Rect();
textPaint.GetTextBounds(this.TopText, 0, this.TopText.Length, topBounds);
canvas.Translate(0, frame.Top / 2 - (topTextLayout.Height / 2));
//canvas.Translate(topBounds.Left, topBounds.Bottom);
topTextLayout.Draw(canvas);
canvas.Restore();
var botTextLayout = new StaticLayout(this.BottomText, textPaint, canvas.Width, Android.Text.Layout.Alignment.AlignCenter, 1.0f, 0.0f, false);
canvas.Save();
Rect botBounds = new Rect();
textPaint.GetTextBounds(this.BottomText, 0, this.BottomText.Length, botBounds);
canvas.Translate(0, (frame.Bottom + (canvas.Height - frame.Bottom) / 2) - (botTextLayout.Height / 2));
//canvas.Translate(topBounds.Left, topBounds.Bottom);
botTextLayout.Draw(canvas);
canvas.Restore();
if (resultBitmap != null)
{
paint.Alpha = CURRENT_POINT_OPACITY;
canvas.DrawBitmap(resultBitmap, null, new RectF(frame.Left, frame.Top, frame.Right, frame.Bottom), paint);
}
else
{
// Draw a two pixel solid black border inside the framing rect
paint.Color = frameColor;
//canvas.DrawRect(frame.Left, frame.Top, frame.Right + 1, frame.Top + 2, paint);
//canvas.DrawRect(frame.Left, frame.Top + 2, frame.Left + 2, frame.Bottom - 1, paint);
//canvas.DrawRect(frame.Right - 1, frame.Top, frame.Right + 1, frame.Bottom - 1, paint);
//canvas.DrawRect(frame.Left, frame.Bottom - 1, frame.Right + 1, frame.Bottom + 1, paint);
// Draw a red "laser scanner" line through the middle to show decoding is active
paint.Color = laserColor;
paint.Alpha = SCANNER_ALPHA[scannerAlpha];
scannerAlpha = (scannerAlpha + 1) % SCANNER_ALPHA.Length;
int middle = frame.Height() / 2 + frame.Top;
//int middle = frame.Width() / 2 + frame.Left;
//canvas.DrawRect(frame.Left + 2, middle - 1, frame.Right - 1, middle + 2, paint);
canvas.DrawRect(0, middle - 1, width, middle + 2, paint);
//canvas.DrawRect(middle - 1, frame.Top + 2, middle + 2, frame.Bottom - 1, paint); //frame.Top + 2, middle - 1, frame.Bottom - 1, middle + 2, paint);
//var previewFrame = scanner.GetFramingRectInPreview();
//float scaleX = frame.Width() / (float) previewFrame.Width();
//float scaleY = frame.Height() / (float) previewFrame.Height();
/*var currentPossible = possibleResultPoints;
var currentLast = lastPossibleResultPoints;
int frameLeft = frame.Left;
int frameTop = frame.Top;
if (currentPossible == null || currentPossible.Count <= 0)
{
lastPossibleResultPoints = null;
}
else
{
possibleResultPoints = new List<com.google.zxing.ResultPoint>(5);
lastPossibleResultPoints = currentPossible;
paint.Alpha = CURRENT_POINT_OPACITY;
paint.Color = resultPointColor;
lock (currentPossible)
{
foreach (var point in currentPossible)
{
canvas.DrawCircle(frameLeft + (int) (point.X * scaleX),
frameTop + (int) (point.Y * scaleY), POINT_SIZE, paint);
}
}
}
if (currentLast != null)
{
paint.Alpha = CURRENT_POINT_OPACITY / 2;
paint.Color = resultPointColor;
lock (currentLast)
{
float radius = POINT_SIZE / 2.0f;
foreach (var point in currentLast)
{
canvas.DrawCircle(frameLeft + (int) (point.X * scaleX),
frameTop + (int) (point.Y * scaleY), radius, paint);
}
}
}
*/
// Request another update at the animation interval, but only repaint the laser line,
// not the entire viewfinder mask.
PostInvalidateDelayed(ANIMATION_DELAY,
frame.Left - POINT_SIZE,
frame.Top - POINT_SIZE,
frame.Right + POINT_SIZE,
frame.Bottom + POINT_SIZE);
}
base.OnDraw (canvas);
}
public override void Draw(Android.Graphics.Canvas canvas)
{
canvas.Rotate(-90);
canvas.Translate(-Height, 0);
base.OnDraw(canvas);
}
protected override void OnDraw(Canvas canvas)
{
base.OnDraw(canvas);
float r = strokeWidth - myPaint.StrokeWidth * 0.5f;
canvas.Translate((float)wowZapp.LaffOutOut.Singleton.ScreenXWidth / 1.5f, (float)wowZapp.LaffOutOut.Singleton.ScreenYHeight / 2.5f);
canvas.DrawOval(new RectF(-r, -r, r, r), myPaint);
canvas.DrawRect(new RectF(0f, 0f, 0f, 0f), myCenterPaint);
if (trackingCentre)
{
Color c = myCenterPaint.Color;
myCenterPaint.SetStyle(Paint.Style.Stroke);
myCenterPaint.Alpha = (highlightCentre == true ? 0xff : 0x80);
Rect rect = new Rect(0, 0, 0, 0);
myCenterPaint.SetStyle(Paint.Style.Fill);
myCenterPaint.Color = c;
canvas.DrawRect(rect, myCenterPaint);
}
}
private BitmapDrawable MakeTagChip (String tagText)
{
var Inflater = LayoutInflater.FromContext (Context);
var tagChipView = (TextView)Inflater.Inflate (Resource.Layout.TagViewChip, this, false);
tagChipView.Text = tagText.ToUpper ();
int spec = MeasureSpec.MakeMeasureSpec (0, MeasureSpecMode.Unspecified);
tagChipView.Measure (spec, spec);
tagChipView.Layout (0, 0, tagChipView.MeasuredWidth, tagChipView.MeasuredHeight);
var b = Bitmap.CreateBitmap (tagChipView.Width, tagChipView.Height, Bitmap.Config.Argb8888);
var canvas = new Canvas (b);
canvas.Translate (-tagChipView.ScrollX, -tagChipView.ScrollY);
tagChipView.Draw (canvas);
tagChipView.DrawingCacheEnabled = true;
var cacheBmp = tagChipView.DrawingCache;
var viewBmp = cacheBmp.Copy (Bitmap.Config.Argb8888, true);
tagChipView.DestroyDrawingCache ();
var bmpDrawable = new BitmapDrawable (Resources, viewBmp);
bmpDrawable.SetBounds (0, 0, bmpDrawable.IntrinsicWidth, bmpDrawable.IntrinsicHeight);
return bmpDrawable;
}
protected override void DispatchDraw (Canvas canvas)
{
base.DispatchDraw (canvas);
if (mPinnedSection != null) {
// prepare variables
int pLeft = ListPaddingLeft;
int pTop = ListPaddingTop;
View view = mPinnedSection.view;
// draw child
canvas.Save();
int clipHeight = view.Height +
(mShadowDrawable == null ? 0 : Math.Min(mShadowHeight, mSectionsDistanceY));
canvas.ClipRect(pLeft, pTop, pLeft + view.Width, pTop + clipHeight);
canvas.Translate(pLeft, pTop + mTranslateY);
DrawChild(canvas, mPinnedSection.view, DrawingTime);
if (mShadowDrawable != null && mSectionsDistanceY > 0) {
mShadowDrawable.SetBounds(mPinnedSection.view.Left,
mPinnedSection.view.Bottom,
mPinnedSection.view.Right,
mPinnedSection.view.Bottom + mShadowHeight);
mShadowDrawable.Draw(canvas);
}
canvas.Restore();
}
}
protected override void DispatchDraw(Canvas canvas)
{
base.DispatchDraw(canvas);
if (mDrag && (mShadowBuilder != null))
{
Point size = new Point();
Point touchPoint = new Point();
mShadowBuilder.OnProvideShadowMetrics(size, touchPoint);
canvas.Save();
canvas.Translate(mX - touchPoint.X, mY - touchPoint.Y);
mShadowBuilder.OnDraw(canvas);
canvas.Restore();
}
}
protected override void OnDraw(Canvas canvas)
{
base.OnDraw (canvas);
float r = 100 - myPaint.StrokeWidth * 0.5f;
float outr = 120;
canvas.Translate (144f, 140f);
canvas.DrawOval (new RectF (-r, -r, r, r), myPaint);
canvas.DrawOval (new RectF (-outr, -outr, outr, outr), myOuterPaint);
canvas.DrawRect (new RectF (-50f, 140f, 100f, 160f), myCenterPaint);
if (trackingCentre) {
Color c = myCenterPaint.Color;
myCenterPaint.SetStyle (Paint.Style.Stroke);
myCenterPaint.Alpha = (highlightCentre == true ? 0xff : 0x80);
Rect rect = new Rect (-50, 140, 100, 160);
myCenterPaint.SetStyle (Paint.Style.Fill);
myCenterPaint.Color = c;
canvas.DrawRect (rect, myCenterPaint);
}
}
