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); } }