private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var a = new Vector2(10, 10); var b = new Vector2(100, 100); args.DrawingSession.DrawLine(a, b, Colors.Yellow); }
private void canvasCtrl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (!this.initialized) { return; } this.host.CallFunction("drawScene"); var target = (CanvasRenderTarget)this.host.Window.Render(); args.DrawingSession.DrawImage(target); if (drawCount == 0) { this.start = DateTime.Now; } drawCount++; var seconds = (DateTime.Now - this.start).TotalSeconds; if (seconds > 0) { var fps = drawCount / seconds; args.DrawingSession.DrawText(fps.ToString("0.#") + "fps", 10, 10, Colors.Red); } // triggers next Draw event at max 60fps this.canvasCtrl.Invalidate(); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { GaussianBlurEffect effect = new GaussianBlurEffect() { Source = _bitmap, BlurAmount = 5, BorderMode = EffectBorderMode.Hard }; args.DrawingSession.DrawImage(effect); }
private void CanvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { CubeHelper helper = new CubeHelper(GetLength()); foreach (Tuple<Vector2, Vector2> edge in helper.GetEdges(currentTransformation)) { ColorValue colorValue = ColorComboBox.SelectedValue as ColorValue; Color color = (colorValue == null ? Colors.Black : colorValue.Color); args.DrawingSession.DrawLine(edge.Item1, edge.Item2, color); } }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var ds = args.DrawingSession; ds.Clear(Color.FromArgb(0,0,0,0)); var shape = this.Shapes.SelectedItem as Shape; if (shape == null) return; var width = sender.ActualWidth; var height = sender.ActualHeight; if (shape.Drawer != null) shape.Drawer(sender, ds); }
void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { float strokeWidth = 1; sharedResources = GetSharedResources(sender); var arrow = sharedResources.GetArrow(TextDirection); var bounds = arrow.ComputeStrokeBounds(strokeWidth); var ds = args.DrawingSession; var foregroundBrush = (SolidColorBrush)this.Foreground; var color = foregroundBrush.Color; arrow = arrow.Transform(CalculateTransform(bounds, new Rect(new Point(0, 0), sender.Size))); ds.DrawGeometry(arrow, color, strokeWidth, ArrowStrokeStyle); }
public void Draw(CanvasControl sender, CanvasDrawEventArgs args) { var size = sender.Size; using (var ds = args.DrawingSession) { ds.DrawImage(effect, (size.ToVector2() - currentEffectSize) / 2); var brush = new CanvasImageBrush(sender, this.effect) { ExtendX = CanvasEdgeBehavior.Wrap, ExtendY = CanvasEdgeBehavior.Wrap, SourceRectangle = new Rect(0, bitmap.SizeInPixels.Height - 96, 96, 96) }; ds.FillRectangle(0, 0, (float)this.ActualWidth, (float)this.ActualHeight, brush); } sender.Invalidate(); }
private void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { if (_graphics == null) { _graphics = new NativeGraphics(); _graphics.destination = new AsyncGraphics(args.DrawingSession); _graphics.resetClip(); } else { ((AsyncGraphics)_graphics.destination).getInternal().setGraphics(args.DrawingSession); } if (renderingOperations.Count > 0) { foreach (AsyncOp o in renderingOperations) { //Debug.WriteLine("OnDraw - execute " + o); o.executeWithClip(((AsyncGraphics)_graphics.destination).getInternal()); } } args.DrawingSession.Dispose(); renderingOperations.Clear(); }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (CanvasImage.IsHistogramSupported(sender.Device)) { SetEffectProperties(); // Draw the image. if (!ThumbnailGenerator.IsDrawingThumbnail) { args.DrawingSession.DrawImage(hueEffect, (sender.Size.ToVector2() - bitmap.Size.ToVector2()) * new Vector2(0.5f, 0.25f)); } // Overlay a histogram for each color channel. args.DrawingSession.Blend = CanvasBlend.Add; DrawHistogram(args.DrawingSession, sender.Size, EffectChannelSelect.Red, redBrush); DrawHistogram(args.DrawingSession, sender.Size, EffectChannelSelect.Green, greenBrush); DrawHistogram(args.DrawingSession, sender.Size, EffectChannelSelect.Blue, blueBrush); } else { DrawNotSupported(args.DrawingSession, sender.Size); } }
private void Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (_contentPresenter == null) return; var border = VisualTreeHelper.GetChild(_contentPresenter, 0) as Border; if (border == null) return; var borderPoint = border.TransformToVisual(this).TransformPoint(new Point(0, 0)); var cl = new CanvasCommandList(sender); using (var clds = cl.CreateDrawingSession()) { clds.FillRoundedRectangle(new Rect(borderPoint.X, borderPoint.Y, border.ActualWidth, border.ActualHeight), (float)border.CornerRadius.TopLeft, (float)border.CornerRadius.TopLeft, Color.FromArgb(128, 0, 0, 0)); } var shadowEffect = new Transform2DEffect { Source = new Transform2DEffect { Source = new ShadowEffect { BlurAmount = 2, ShadowColor = Color.FromArgb(160, 0, 0, 0), Source = cl }, //TODO not doing any scaling right now, confirm with larger shadows TransformMatrix = Matrix3x2.CreateScale(1.0f, new Vector2((float)(border.ActualWidth / 2), ((float)border.ActualHeight / 2))) }, TransformMatrix = Matrix3x2.CreateTranslation(0, 1) }; args.DrawingSession.DrawImage(shadowEffect); // args.DrawingSession.DrawImage(cl); }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { // Transform and clip so the scene will fit whatever size display we are running on. Vector2 sceneSize = sceneSizes[whichScene]; args.DrawingSession.Transform = Utils.GetDisplayTransform(sender.Size.ToVector2(), sceneSize); using (args.DrawingSession.CreateLayer(1f, new Rect(0, 0, sceneSize.X, sceneSize.Y))) { // Draw the vector art. currentDrawingSession = args.DrawingSession; switch (whichScene) { case 0: DrawScene0(); break; case 1: DrawScene1(randomSeed); break; } } }
private void canvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (DesignMode.DesignModeEnabled) return; if (modeInstance == null) { frameCounter = 0; modeInstance = CurrentMode.Create(this, sender); } modeInstance.Draw(args.DrawingSession, frameCounter, (float)sender.ActualWidth, (float)sender.ActualHeight); frameCounter++; sender.Invalidate(); }
void canvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { args.DrawingSession.Clear(Colors.CornflowerBlue); args.DrawingSession.DrawEllipse(190, 125, 140, 40, Colors.Black, 6); args.DrawingSession.DrawText("Hello, world!", 100, 100, Colors.Yellow); }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var ds = args.DrawingSession; var centerPoint = (arcPoints[0] + arcPoints[1]) / 2; // Draw the end point markers. if (!ThumbnailGenerator.IsDrawingThumbnail) { for (int i = 0; i < 2; i++) { ds.DrawCircle(arcPoints[i], hitTestRadius, (i == activeDrag) ? Colors.White : Colors.Gray); } } switch (CurrentOverload) { case AddArcOverload.AroundEllipse: // Compute positions. var ellipseRadius = (arcPoints[1] - arcPoints[0]) / 2; ellipseRadius.X = Math.Abs(ellipseRadius.X); ellipseRadius.Y = Math.Abs(ellipseRadius.Y); float startAngle = Utils.DegreesToRadians(ArcStartAngle); float sweepAngle = Utils.DegreesToRadians(ArcSweepAngle); var startPoint = centerPoint + Vector2.Transform(Vector2.UnitX, Matrix3x2.CreateRotation(startAngle)) * ellipseRadius; // Draw the bounding rectangle. if (!ThumbnailGenerator.IsDrawingThumbnail) { ds.DrawRectangle(new Rect(arcPoints[0].ToPoint(), arcPoints[1].ToPoint()), Color.FromArgb(255, 64, 64, 64)); } // Draw the arc. using (var builder = new CanvasPathBuilder(sender)) { builder.BeginFigure(startPoint); builder.AddArc(centerPoint, ellipseRadius.X, ellipseRadius.Y, startAngle, sweepAngle); builder.EndFigure(CanvasFigureLoop.Open); using (var geometry = CanvasGeometry.CreatePath(builder)) { ds.DrawGeometry(geometry, Colors.Yellow, strokeWidth, strokeStyle); } } break; case AddArcOverload.PointToPoint: // Display a warning if this is an invalid arc configuration. bool isRadiusTooSmall = IsArcRadiusTooSmall(); if (isRadiusTooSmall) { ds.DrawText("Radius is less than the\ndistance between the\nstart and end points", centerPoint, Colors.Red, textFormat); } // Draw the arc. using (var builder = new CanvasPathBuilder(sender)) { builder.BeginFigure(arcPoints[0]); builder.AddArc(arcPoints[1], ArcRadiusX, ArcRadiusY, Utils.DegreesToRadians(ArcRotation), ArcSweepDirection, ArcSize); builder.EndFigure(CanvasFigureLoop.Open); using (var geometry = CanvasGeometry.CreatePath(builder)) { ds.DrawGeometry(geometry, isRadiusTooSmall ? Colors.Red : Colors.Yellow, strokeWidth, strokeStyle); } } break; } }
void OnCanvasControlDraw(CanvasControl sender, CanvasDrawEventArgs args) { CanvasDrawingSession session = args.DrawingSession; // Recreate the geometry if necessary if (baseGeometry == null) { BuildGeometry(session); } // Don't continue if stretchedGeometry does not exist if (stretchedGeometry == null) { return; } // Recreate the brushes if necessary. if (xamStroke != null && strokeBrushWrapper.Brush == null) { ConvertBrush(session, xamStroke, strokeBrushWrapper); } if (xamFill != null && fillBrushWrapper.Brush == null) { ConvertBrush(session, xamFill, fillBrushWrapper); } // Don't continue if both brushes are null. if (strokeBrushWrapper.Brush == null && fillBrushWrapper.Brush == null) { return; } // If it's a Rectangle, RadiusX and RadiusY must be independent of Stretch if (this is RectangleCanvasControl) { float radiusX = (this as RectangleCanvasControl).RadiusX; float radiusY = (this as RectangleCanvasControl).RadiusY; stretchedGeometry = CanvasGeometry.CreateRoundedRectangle(session, stretchedGeometryBounds, radiusX, radiusY); } // Shift so negative coordinates are visible. session.Transform = renderMatrix; // Brush-fixing logic. TODO: This is similar for stroke and fill and can probably // be consolidated in a Func. if (fillBrushWrapper.Brush != null) { bool okToRender = true; if (fillBrushWrapper.Brush is CanvasLinearGradientBrush) { fillBrushWrapper.SetGradientPoints(stretchedGeometryBounds); } else if (fillBrushWrapper.Brush is CanvasImageBrush) { okToRender = fillBrushWrapper.SetImageBrushBitmap(); } if (okToRender) { session.FillGeometry(stretchedGeometry, fillBrushWrapper.Brush); } } if (strokeBrushWrapper.Brush != null) { bool okToRender = true; if (strokeBrushWrapper.Brush is CanvasLinearGradientBrush) { strokeBrushWrapper.SetGradientPoints(stretchedGeometryStrokeBounds); } else if (strokeBrushWrapper.Brush is CanvasImageBrush) { okToRender = strokeBrushWrapper.SetImageBrushBitmap(); } if (okToRender) { session.DrawGeometry(stretchedGeometry, strokeBrushWrapper.Brush, strokeWidth, strokeStyle); } } }
private void ChartWin2DCanvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (_offscreenBackGround != null) { //background with lines and value texts args.DrawingSession.DrawImage(_offscreenBackGround, new Rect(new Point(0, 0), ChartWin2DCanvas.Size), new Rect(new Point(0, 0), _offscreenBackGround.Size)); if (_offscreenChartImage != null) { //the actual graph is drawn in here, according to move & zoom values args.DrawingSession.DrawImage(_offscreenChartImage, new Rect(new Point(0, 0), ChartWin2DCanvas.Size), new Rect(_graphDrawingPoint, _graphDrawingSource)); } } else { // in the start we don't have data, so we'll just draw the background rect with background color args.DrawingSession.DrawRectangle(0, 0, (float)ChartWin2DCanvas.Size.Width, (float)ChartWin2DCanvas.Size.Height, BACKGROUND_COLOR); } }
private void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { this.UpdateGeometry(args.DrawingSession, sender.Size); }
private void TheCanvas_Draw(CanvasControl sender, CanvasDrawEventArgs e) { /* * * * FROM https://en.wikipedia.org/wiki/Mandelbrot_set#Computer_drawings * For each pixel (Px, Py) on the screen, do: * { * x0 = scaled x coordinate of pixel (scaled to lie in the Mandelbrot X scale (-2.5, 1)) * y0 = scaled y coordinate of pixel (scaled to lie in the Mandelbrot Y scale (-1, 1)) * x = 0.0 * y = 0.0 * iteration = 0 * max_iteration = 1000 * while (x*x + y*y < 2*2 AND iteration < max_iteration) { * xtemp = x*x - y*y + x0 * y = 2*x*y + y0 * x = xtemp * iteration = iteration + 1 * } * color = palette[iteration] * plot(Px, Py, color) * } * */ double paletteMin = 30, palletteMax = 330; Rect rect; Color color; List <Color> pallette = new List <Color>(); Rect bounds; bounds = new Rect(new Point(-2, 0.5), new Point(-1, -0.5)); bounds = GetBounds(-0.7463, 0.1102, 0.005); bounds = GetBounds(-0.7453, 0.1127, 0.00065); int iterations = 10000; double palletteStep = (palletteMax - paletteMin) / (double)iterations; double hue; for (int i = 0; i < iterations; ++i) { hue = paletteMin + (i * palletteStep); while (hue > 360) { hue -= 360.0; } pallette.Add(Microsoft.Toolkit.Uwp.Helpers.ColorHelper.FromHsv(hue, 1, 1)); } double deltaX = bounds.Width / this.ActualWidth; double deltaY = bounds.Height / this.ActualHeight; Point logicalPoint; double x, y; for (double pX = 0.0; pX < this.ActualWidth; ++pX) { x = (pX * deltaX) + bounds.Left; for (double pY = 0; pY < this.ActualHeight; ++pY) { y = (pY * deltaY) + bounds.Top; logicalPoint = new Point(x, y); color = GetColorForPoint(pallette, logicalPoint); rect = new Rect(new Point(pX, pY), new Size(1, 1)); e.DrawingSession.DrawRectangle(rect, color); } } }
protected void valueControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { this.EnsureResources(sender, args); CanvasDrawingSession ds = args.DrawingSession; float height = (float)(sender.ActualHeight * _gaugeGridHeight); float yTop = (float)(sender.ActualHeight - height) / 2F; height -= 4F * c_boxThickness; yTop += 2F * c_boxThickness; float increment = (float)(height / (this.MaxValue - this.MinValue)); float atX = 10F; float atY = (float)(yTop + height - ((this.Value - this.MinValue) * increment)); Vector2 atPointer = new Vector2(atX, atY); Rect pointerBoundingRectangle; Rect valueBoundingRectangle; using (var textFormat = new CanvasTextFormat() { HorizontalAlignment = CanvasHorizontalAlignment.Center, VerticalAlignment = CanvasVerticalAlignment.Center, FontSize = 32, // (float)this.ValueFontSize, }) { ds.DrawText("◄", atPointer, this.GaugePointerColor, textFormat); pointerBoundingRectangle = Utilities.CalculateStringBoundingRectangle(sender, args, "◄", textFormat); } using (var textFormat = new CanvasTextFormat() { HorizontalAlignment = CanvasHorizontalAlignment.Left, VerticalAlignment = CanvasVerticalAlignment.Center, FontSize = (float)this.ValueFontSize * 0.8F, }) { string format = "{0:F" + string.Format("{0:F0}", this.Resolution) + "}"; Vector2 at = new Vector2( (float)pointerBoundingRectangle.Width, atPointer.Y); ds.DrawText(string.Format(format, this.Value), at, this.GaugePointerColor, textFormat); valueBoundingRectangle = Utilities.CalculateStringBoundingRectangle(sender, args, string.Format(format, this.Value), textFormat); } using (var textFormat = new CanvasTextFormat() { HorizontalAlignment = CanvasHorizontalAlignment.Left, VerticalAlignment = CanvasVerticalAlignment.Center, FontSize = (float)this.UnitsFontSize * 0.9F }) { Vector2 at = new Vector2( (float)pointerBoundingRectangle.Width, atPointer.Y + (float)valueBoundingRectangle.Height * 0.9F); ds.DrawText(this.Units, at, this.GaugePointerColor, textFormat); } }
protected abstract void DrawGhost(CanvasControl sender, CanvasDrawEventArgs args);
private void canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { startupGraphic(); //Horizontal da canvas float vx = totalVL + lateralArea; while (vx < drawAreaHorizontal + lateralArea) { args.DrawingSession.DrawLine(vx, 0, vx, drawAreaVertical + 30, Colors.DarkGray, (float)1.5, strokeStyle); vx = vx + totalVL; } //Linha de isolamento superior args.DrawingSession.DrawLine(0 + lateralArea, 10, drawAreaHorizontal + lateralArea, 10, Colors.DarkGray, (float)1.5, strokeStyle); //Linha de isolamento lateral args.DrawingSession.DrawLine(0 + lateralArea, 0, 0 + lateralArea, drawAreaVertical + 30, Colors.DarkGray, (float)1.5, strokeStyle); //Linha de isolamento inferior args.DrawingSession.DrawLine(0 + lateralArea, drawAreaVertical, drawAreaHorizontal + lateralArea, drawAreaVertical, Colors.DarkGray, (float)1.5, strokeStyle); //Texto inferior float tx = 0; int ix = 0; string month = "JAN"; while (tx <= drawAreaHorizontal) { #region IF MESES if (ix == 0) { month = "JAN"; } if (ix == 1) { month = "FEV"; } if (ix == 2) { month = "MAR"; } if (ix == 3) { month = "ABR"; } if (ix == 4) { month = "MAI"; } if (ix == 5) { month = "JUN"; } if (ix == 6) { month = "JUL"; } if (ix == 7) { month = "AGO"; } if (ix == 8) { month = "SET"; } if (ix == 9) { month = "OUT"; } if (ix == 10) { month = "NOV"; } if (ix == 11) { month = "DEZ"; } #endregion args.DrawingSession.DrawText(month, new Vector2(tx + ((totalVL / 2) - 15) + lateralArea, (float)canvas.ActualHeight - 25), Colors.DarkGray, MonthsFormat); tx = tx + totalVL; ix++; } //Texto lateral float ty = 0; float iy = vMax; while (ty <= drawAreaVertical - 10) { args.DrawingSession.DrawText(string.Format(cultureInfo, "{0:C}", iy), new Vector2(10, ty), Colors.DarkGray, ValuesFormat); iy = iy - (vMax / itemsV); ty = ty + totalHL; } //Vertical da canvas float hy = totalHL + 10; while (hy < (drawAreaVertical - 10)) { args.DrawingSession.DrawLine(0 + lateralArea, hy, drawAreaHorizontal + lateralArea, hy, Colors.DarkGray, (float)1.5, strokeStyle); hy = hy + totalHL; } //Desenha o gráfico mensal manual foreach (line l in Lines) { args.DrawingSession.DrawLine(l.x1, l.y1, l.x2, l.y2, Colors.Red, 1); if (l.isMouseOver == true) { args.DrawingSession.DrawRectangle(new Rect(new Point(l.x2 + 5, l.y2 + 5), new Point(l.x2 - 5, l.y2 - 5)), Colors.DeepSkyBlue); args.DrawingSession.DrawText(string.Format(cultureInfo, "{0:C}", l.value), new Vector2(l.x2 + 10, l.y2 - 8), Colors.DarkGray, ValuesFormat); } } //Desenha itens aleatórios no gráfico if (draw == true) { int iT = 0; while (iT < itemsTotal) { if (iT == 0) { x1 = totalVL + lateralArea; y1 = rnd.Next(10, (int)drawAreaVertical + 1); args.DrawingSession.DrawLine(lateralArea, rnd.Next(10, (int)drawAreaVertical), x1, y1, Colors.Red, 1); a1 = totalVL + lateralArea; b1 = rnd.Next(10, (int)drawAreaVertical + 1); args.DrawingSession.DrawLine(lateralArea, rnd.Next(10, (int)drawAreaVertical), a1, b1, Colors.YellowGreen, 1); iT++; } if (iT > 0) { x2 = x1 + totalVL; y2 = rnd.Next(10, (int)drawAreaVertical + 1); args.DrawingSession.DrawLine(x1, y1, x2, y2, Colors.Red, 1); x1 = x2; y1 = y2; a2 = a1 + totalVL; b2 = rnd.Next(10, (int)drawAreaVertical + 1); args.DrawingSession.DrawLine(a1, b1, a2, b2, Colors.YellowGreen, 1); a1 = a2; b1 = b2; iT++; } } draw = false; } }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var currentShape = availableShapes[this.Shapes.SelectedIndex]; currentShape.Drawer(sender, args.DrawingSession); }
void OnDrawGpuGraph(CanvasControl sender, CanvasDrawEventArgs args) { var graphDrawer = new GraphDrawer((float)sender.ActualWidth, (float)sender.ActualHeight, Scenarios, e => e.GpuTimeInMs, "GPU"); graphDrawer.Draw(args.DrawingSession); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { strokeStyle.StartCap = StartCap; strokeStyle.EndCap = EndCap; strokeStyle.DashStyle = DashStyle; strokeStyle.DashCap = DashCap; strokeStyle.LineJoin = LineJoin; var ds = args.DrawingSession; var width = (float)sender.ActualWidth; var height = (float)sender.ActualHeight; var col1Left = width * 0.1f; var col1Right = width * 0.4f; var col2Left = width * 0.6f; var col2Right = width * 0.9f; var row1Top = height * 0.1f; var row1Bottom = height * 0.4f; var row2Top = height * 0.6f; var row2Bottom = height * 0.9f; // // Draw hairlines showing the start/end points of the line. // This helps demonstrate the behavior of start/end cap. // ds.DrawLine( col1Left, row1Top, col1Left, row1Bottom, Colors.Aqua, 1.0f, this.hairlineStrokeStyle); ds.DrawLine( col1Right, row1Top, col1Right, row1Bottom, Colors.Aqua, 1.0f, this.hairlineStrokeStyle); // // Draw the demo shapes with the chosen stroke style // var strokeWidth = (float)Math.Max(5, Math.Min(30, width / 50)); ds.DrawLine( col1Left, (row1Top + row1Bottom) / 2, col1Right, (row1Top + row1Bottom) / 2, Colors.Green, strokeWidth, this.strokeStyle); ds.DrawRectangle( new Rect(new Point(col2Left, row1Top), new Point(col2Right, row1Bottom)), Colors.Green, strokeWidth, this.strokeStyle); ds.DrawRoundedRectangle( new Rect(new Point(col1Left, row2Top), new Point(col1Right, row2Bottom)), width * 0.1f, height * 0.1f, Colors.Green, strokeWidth, this.strokeStyle); ds.DrawEllipse( (col2Left + col2Right) / 2, (row2Top + row2Bottom) / 2, (col2Right - col2Left) / 2, (row2Bottom - row2Top) / 2, Colors.Green, strokeWidth, this.strokeStyle); // // Explain what is going on if this combination of properties leaves dots invisible // bool hasDots = DashStyle == CanvasDashStyle.Dot || DashStyle == CanvasDashStyle.DashDot || DashStyle == CanvasDashStyle.DashDotDot; if (hasDots && DashCap == CanvasCapStyle.Flat) { ds.DrawText("Dots have zero size when DashCap = CanvasCapStyle.Flat", col1Left, 0, Colors.White); } }
void DriveCanvas_DrawEvent(object sender, CanvasDrawEventArgs args) { args.DrawingSession.DrawImage(joystickBitmap, joystickDrawRect); }
private void canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { //var mybitmap = new CanvasRenderTarget(sender, 200, 200); //using (var ds=mybitmap.CreateDrawingSession()) //{ //} //only draw if image is loaded if (bitmapImg != null) { bitmapRect = new Rect(0, 0, canvas.ActualWidth, canvas.ActualHeight); //args.DrawingSession.DrawImage(bitmapImg, bitmapRect,new Rect(0, 0, 100, 100) ); //sender.Invalidate(); args.DrawingSession.DrawImage(bitmapImg); } }
private void OnCanvasDraw(CanvasControl sender, CanvasDrawEventArgs args) { if (string.IsNullOrWhiteSpace(_data)) { CommandsList.Text = string.Empty; return; } this._errorGeometry ??= CanvasPathGeometry.CreateGeometry(sender, ErrorString); _logger?.Clear(); CommandsList.Text = string.Empty; try { _logger?.AppendLine("// The following commands represent the CanvasPathBuilder command(s) needed"); _logger?.AppendLine("// to create the CanvasGeometry from the specified Win2d Path Mini Language."); var geometry = CanvasPathGeometry.CreateGeometry(sender, _data); _reader.StartLogging(); geometry.SendPathTo(_reader); _logger?.AppendLine(_reader.EndLogging()); CommandsList.Text = _logger?.ToString() ?? string.Empty; args.DrawingSession.FillGeometry(geometry, _fillColor); args.DrawingSession.DrawGeometry(geometry, _strokeColor, _strokeThickness); RootPivot.SelectedIndex = 0; CommandsList.Foreground = _commandBrush; } catch (ArgumentException argEx) { var message = argEx.Message; var errorCode = message.Substring(0, 11); var parseError = string.Empty; if (message.StartsWith(ParseError1)) { parseError = "Parse Error: No matching data!"; } else if (message.StartsWith(ParseError2)) { parseError = "Parse Error: Multiple FillRule elements present in Path Data!"; } else if (message.StartsWith(ParseError3)) { var tokens = message.Split('\n', StringSplitOptions.RemoveEmptyEntries); if (tokens.Length == 3) { parseError = $"Parse Error at {tokens[1]}. Cannot parse '{tokens[2]}'."; } } else { parseError = "Parsing error! Invalid input data!"; } args.DrawingSession.FillGeometry(_errorGeometry, Colors.Black); CommandsList.Text = parseError; RootPivot.SelectedIndex = 1; CommandsList.Foreground = _commandErrorBrush; } catch (Exception) { args.DrawingSession.FillGeometry(_errorGeometry, Colors.Black); CommandsList.Text = "Parsing error! Invalid input data!"; RootPivot.SelectedIndex = 1; CommandsList.Foreground = _commandErrorBrush; } }
// Draw to the CanvasControl. void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { Draw(args.DrawingSession, "Canvas\nControl", sender.Size); }
private void DrawText(InkRecognitionUnit recoUnit, CanvasControl sender, CanvasDrawEventArgs args) { var childIds = recoUnit.childIds; var initialTransformation = args.DrawingSession.Transform; // Points of bounding rectangle to align drawn text float floatX = (float)recoUnit.boundingRectangle.topX; float floatY = (float)recoUnit.boundingRectangle.topY; // Rotated bounding rectangle points to get correct angle of text being drawn float topLeftX = (float)recoUnit.rotatedBoundingRectangle[0].x; float topLeftY = (float)recoUnit.rotatedBoundingRectangle[0].y; float topRightX = (float)recoUnit.rotatedBoundingRectangle[1].x; float topRightY = (float)recoUnit.rotatedBoundingRectangle[1].y; float bottomRightX = (float)recoUnit.rotatedBoundingRectangle[2].x; float bottomRightY = (float)recoUnit.rotatedBoundingRectangle[2].y; float bottomLeftX = (float)recoUnit.rotatedBoundingRectangle[3].x; float bottomLeftY = (float)recoUnit.rotatedBoundingRectangle[3].y; // Height and width of bounding rectangle to get font size and width for text layout float height = GetDistanceBetweenPoints(topRightX, bottomRightX, topRightY, bottomRightY) * dipsPerMm; float width = GetDistanceBetweenPoints(bottomLeftX, bottomRightX, bottomLeftY, bottomRightY) * dipsPerMm; if (height < 45) { height = 45; } // Transform to get correct angle of text float centerPointX = ((topLeftX + topRightX) / 2) * dipsPerMm; float centerPointY = ((topLeftY + bottomLeftY) / 2) * dipsPerMm; var centerPoint = new Vector2(centerPointX, centerPointY); Matrix3x2 angle = GetRotationAngle(bottomLeftX, bottomRightX, bottomLeftY, bottomRightY, centerPoint); args.DrawingSession.Transform = angle; var textFormat = new CanvasTextFormat() { FontSize = height - 5, WordWrapping = CanvasWordWrapping.NoWrap, FontFamily = "Ink Free" }; // Build string to be drawn to canvas string textLine = string.Empty; foreach (var item in childIds) { int id = int.Parse(item.ToString()); // Deconstruct the tuple to get the recognized text from it (string text, _) = recoText[id]; textLine += text + " "; } var textLayout = new CanvasTextLayout(sender.Device, textLine, textFormat, width, height); // Associate correct color with each word in string int index = 0; foreach (var item in childIds) { int id = int.Parse(item.ToString()); // Deconstruct the tuple to get the recognized text and color from it (string text, Color color) = recoText[id]; textLayout.SetColor(index, text.Length, color); index += text.Length + 1; } args.DrawingSession.DrawTextLayout(textLayout, floatX * dipsPerMm, floatY * dipsPerMm, Colors.Black); args.DrawingSession.Transform = initialTransformation; }
//x private void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { var sz = new Size(ParentWidth, ParentHeight); DoEffect(args.DrawingSession, sz, (float)GlowAmount, GlowColor, ((SolidColorBrush)GlowFill).Color, ExpandAmount); }
private void Img_Draw(CanvasControl sender, CanvasDrawEventArgs args) { args.DrawingSession.FillRectangle(new Rect(new Point(), sender.Size), sender.Tag as CanvasImageBrush); }
void canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { // We animate the source image by changing which character is highlighted in yellow. // Therefore there can be two changed regions: the highlighted character has changed from // white to yellow, while the previous highlight has changed from yellow back to white. // Look up the bounds of the two changed characters. var highlightBounds = GetCharacterBounds(highlightedCharacter); var previousBounds = GetCharacterBounds(previousHighlight); // Tell our effects that the highlighted character region has changed. blurEffect.InvalidateSourceRectangle(args.DrawingSession, 0, highlightBounds); shadowEffect.InvalidateSourceRectangle(args.DrawingSession, 0, highlightBounds); // Query what part of the output image will change as a result. var highlightInvalidRects = compositeEffect.GetInvalidRectangles(args.DrawingSession); var highlightInvalidUnion = GetRectangleUnion(highlightInvalidRects); // Also tell the effects about the previously highlighted character. blurEffect.InvalidateSourceRectangle(args.DrawingSession, 0, previousBounds); shadowEffect.InvalidateSourceRectangle(args.DrawingSession, 0, previousBounds); // Query the output region again. This will return a superset of highlightInvalidRects, // as it now accounts for the change to previousBounds as well as highlightBounds. var totalInvalidRects = compositeEffect.GetInvalidRectangles(args.DrawingSession); var totalInvalidUnion = GetRectangleUnion(totalInvalidRects); // We can also look up in the opposite direction: given that we are going to redraw only // the totalInvalidUnion area, what portion of each source image is needed to do that? // When using filter kernels like blur, this will be larger than just highlightBounds+previousBounds. var requiredSourceRects = compositeEffect.GetRequiredSourceRectangles(args.DrawingSession, totalInvalidUnion, new ICanvasEffect[] { blurEffect, shadowEffect }, new uint[] { 0, 0 }, new Rect[2] { sourceRenderTarget.Bounds, sourceRenderTarget.Bounds }); // How about if we were going to redraw only highlightBounds, skipping previousBounds? // (we don't actually do this, but do display what source regions it would require). var blurSourceRect = compositeEffect.GetRequiredSourceRectangle(args.DrawingSession, highlightInvalidUnion, blurEffect, 0, sourceRenderTarget.Bounds); var shadowSourceRect = compositeEffect.GetRequiredSourceRectangle(args.DrawingSession, highlightInvalidUnion, shadowEffect, 0, sourceRenderTarget.Bounds); // Draw text into the source rendertarget. using (var drawingSession = sourceRenderTarget.CreateDrawingSession()) { // To make sure the correct requiredSourceRects were reported, we clear the background outside // that region to magenta. If everything is working correctly, this should never be picked up by // effect drawing, as we only leave magenta in the areas we don't expect the effects to read from. drawingSession.Clear(Colors.Magenta); // Clear the requiredSourceRects to transparent. drawingSession.Blend = CanvasBlend.Copy; foreach (var r in requiredSourceRects) { drawingSession.FillRectangle(r, Colors.Transparent); } // Draw the text characters. drawingSession.Blend = CanvasBlend.SourceOver; for (int i = 0; i < characterLayouts.Count; i++) { var color = (i == highlightedCharacter) ? Colors.Yellow : Colors.White; drawingSession.DrawTextLayout(characterLayouts[i], characterPositions[i], color); } } // Draw the effect graph (which reads from sourceRenderTarget) into destRenderTarget. using (var drawingSession = destRenderTarget.CreateDrawingSession()) { // Slightly darken down the existing contents of the output rendertarget. This causes everything // except totalInvalidUnion to gradually fade out, so we can see which areas are getting redrawn. // If this FillRectangle was removed, the result of redrawing only the changed region would be // identical to if we redrew the whole thing every time (by removing the CreateLayer call). drawingSession.FillRectangle(destRenderTarget.Bounds, Color.FromArgb(16, 0, 0, 0)); // Clip our drawing to the totalInvalidUnion rectangle, // which should be the only part of the output that has changed. using (var layer = drawingSession.CreateLayer(1, totalInvalidUnion)) { drawingSession.Clear(Colors.CornflowerBlue); drawingSession.DrawImage(compositeEffect, totalInvalidUnion, totalInvalidUnion); } } if (!ThumbnailGenerator.IsDrawingThumbnail) { args.DrawingSession.Transform = Matrix3x2.CreateTranslation(gap, gap); // Display sourceRenderTarget. args.DrawingSession.DrawImage(sourceRenderTarget); // Display highlightBounds, blurSourceRect, and shadowSourceRect. args.DrawingSession.DrawRectangle(highlightBounds, Colors.Gray); args.DrawingSession.DrawRectangle(blurSourceRect, Colors.Blue); args.DrawingSession.DrawRectangle(shadowSourceRect, Colors.Blue); } args.DrawingSession.Transform = Matrix3x2.CreateTranslation(gap, gap * 2 + height); // Display destRenderTarget. args.DrawingSession.DrawImage(destRenderTarget); // Display highlightInvalidRects. foreach (var i in highlightInvalidRects) { args.DrawingSession.DrawRectangle(i, Colors.DarkBlue); } previousHighlight = highlightedCharacter; // When generating thumbnails, repeat the first draw a bunch of times to reach a more interesting image. if (ThumbnailGenerator.IsDrawingThumbnail && highlightedCharacter < characterLayouts.Count * 5 / 6) { highlightedCharacter++; canvas_Draw(sender, args); } }
private void CanvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var drawingSession = args.DrawingSession; drawingSession.DrawImage(_effect); }
public void Render(CanvasDrawEventArgs args, long delta) { Rect bounds = ApplicationView.GetForCurrentView().VisibleBounds; Rect imgBounds = Grid.Bounds; // Calculate scale float ratio = GetRatio(bounds, imgBounds); Matrix3x2 scale = Matrix3x2.CreateScale(ratio, ratio); // Draw TicTacToe Grid Transform2DEffect Img = new Transform2DEffect() { Source = Grid }; Img.TransformMatrix = scale; Vector2 startPoint = GetStartPoint(bounds, imgBounds, ratio); args.DrawingSession.DrawImage(Img, startPoint); // Draw State for (byte i = 0; i < 3; i++) { for (byte j = 0; j < 3; j++) { Vector2 location = startPoint + new Vector2(i * ratio * 166, j * ratio * 166); if (Game[i, j] % 2 == 0) { Transform2DEffect ImgX = new Transform2DEffect() { Source = X }; ImgX.TransformMatrix = scale; args.DrawingSession.DrawImage(ImgX, location); } else if (Game[i, j] % 2 == 1) { Transform2DEffect ImgO = new Transform2DEffect() { Source = O }; ImgO.TransformMatrix = scale; args.DrawingSession.DrawImage(ImgO, location); } } } // Display Game result if (State != Result.Game) { // Display PAUSE TEXT args.DrawingSession.FillRectangle((float)bounds.Width / 2 - 300, (float)bounds.Height / 2 - 75, 600, 150, Color.FromArgb(255, 255, 0, 0)); CanvasTextFormat format = new CanvasTextFormat() { FontSize = 92 }; args.DrawingSession.DrawText("GAME OVER", (float)bounds.Width / 2 - 250, (float)bounds.Height / 2 - 65, Color.FromArgb(255, 0, 0, 0), format); } }
public void Update(GameState gameState, CanvasDrawEventArgs args) { var(playerX, playerY, xPlus, yPlus) = zoomer.Update(gameState); var scale = (float)zoomer.GetTimes(); // walls foreach (var segment in gameState.PerimeterSegments) { var width = 1_000_000; var xOffset = 0f; if (segment.Start.y > segment.End.y) { xOffset = -width / 2f; } else if (segment.Start.y < segment.End.y) { xOffset = width / 2f; } var yOffset = 0f; if (segment.Start.x > segment.End.x) { yOffset = width / 2f; } else if (segment.Start.x < segment.End.x) { yOffset = -width / 2f; } DrawLine( segment.Start.x + xOffset, segment.Start.y + yOffset, segment.End.x + xOffset, segment.End.y + yOffset, Color.FromArgb(0x11, 0x00, 0x00, 0x00), width, CanvasCapStyle.Square); } // goals DrawFilledCircle( gameState.LeftGoal.Posistion.x, gameState.LeftGoal.Posistion.y, Constants.goalLen, Color.FromArgb(0xff, 0xff, 0xff, 0xff)); DrawFilledCircle( gameState.RightGoal.Posistion.x, gameState.RightGoal.Posistion.y, Constants.goalLen, Color.FromArgb(0xff, 0xff, 0xff, 0xff)); // has ball highlight DrawCircle(gameState.GameBall.Posistion.x, gameState.GameBall.Posistion.y, Constants.BallRadius, Color.FromArgb((byte)((gameState.CountDownState.Countdown ? gameState.CountDownState.BallOpacity : 1) * 0xff), 0xff, 0xff, 0xff), 35 / scale); // players bodies foreach (var playerPair in gameState.players) { DrawFilledCircle(playerPair.Value.PlayerBody.Position.x, playerPair.Value.PlayerBody.Position.y, Constants.playerCenterRadius, Color.FromArgb(0xff, playerPair.Value.PlayerBody.R, playerPair.Value.PlayerBody.G, playerPair.Value.PlayerBody.B)); //DrawFilledCircle(playerPair.Value.PlayerBody.Position.x, playerPair.Value.PlayerBody.Position.y, Constants.footLen, Color.FromArgb(playerPair.Value.PlayerBody.A, playerPair.Value.PlayerBody.R, playerPair.Value.PlayerBody.G, playerPair.Value.PlayerBody.B)); } // draw number of boosts foreach (var playerPair in gameState.players) { if (playerPair.Value.Boosts > 0) { DrawCircle(playerPair.Value.PlayerFoot.Position.x, playerPair.Value.PlayerFoot.Position.y, Constants.PlayerRadius + (playerPair.Value.Boosts * 2.0 / scale) + (2 / scale), Color.FromArgb(0x22, playerPair.Value.PlayerFoot.R, playerPair.Value.PlayerFoot.G, playerPair.Value.PlayerFoot.B), (float)(playerPair.Value.Boosts * 4.0 / scale)); } } // players feet foreach (var playerPair in gameState.players) { DrawFilledCircle(playerPair.Value.PlayerFoot.Position.x, playerPair.Value.PlayerFoot.Position.y, Constants.PlayerRadius, Color.FromArgb(playerPair.Value.PlayerFoot.A, playerPair.Value.PlayerFoot.R, playerPair.Value.PlayerFoot.G, playerPair.Value.PlayerFoot.B)); //if (playerPair.Value.BoostVelocity.Length > 10) //{ // var boostV = playerPair.Value.BoostVelocity;//.NewAdded(playerPair.Value.PlayerBody.Velocity).NewAdded(playerPair.Value.PlayerFoot.Velocity).NewAdded(playerPair.Value.ExternalVelocity).NewAdded(playerPair.Value.BoostVelocity); // DrawLine( // playerPair.Value.PlayerFoot.Position.x, // playerPair.Value.PlayerFoot.Position.y, // playerPair.Value.PlayerFoot.Position.x + (boostV.x * 15), // playerPair.Value.PlayerFoot.Position.y + (boostV.y * 15), // Color.FromArgb(0x20, playerPair.Value.PlayerFoot.R, playerPair.Value.PlayerFoot.G, playerPair.Value.PlayerFoot.B), // Constants.PlayerRadius * 2); //} //var vel = playerPair.Value.PlayerBody.Velocity;//.NewAdded(playerPair.Value.PlayerBody.Velocity).NewAdded(playerPair.Value.PlayerFoot.Velocity).NewAdded(playerPair.Value.ExternalVelocity).NewAdded(playerPair.Value.BoostVelocity); //DrawLine( // playerPair.Value.PlayerFoot.Position.x, // playerPair.Value.PlayerFoot.Position.y, // playerPair.Value.PlayerFoot.Position.x + (vel.x * 15), // playerPair.Value.PlayerFoot.Position.y + (vel.y * 15), // Color.FromArgb(0x20, playerPair.Value.PlayerFoot.R, playerPair.Value.PlayerFoot.G, playerPair.Value.PlayerFoot.B), // Constants.PlayerRadius ); } // ball DrawFilledCircle(gameState.GameBall.Posistion.x, gameState.GameBall.Posistion.y, Constants.BallRadius, Color.FromArgb( (byte)((gameState.CountDownState.Countdown ? gameState.CountDownState.BallOpacity : 1) * 0xff) , 0x00, 0x00, 0x00)); // ball wall if (gameState.CountDownState.Countdown) { DrawCircle(gameState.CountDownState.X, gameState.CountDownState.Y, gameState.CountDownState.Radius - (gameState.CountDownState.StrokeThickness / 2.0), Color.FromArgb((byte)((1 - gameState.CountDownState.BallOpacity) * 0xff), 0x88, 0x88, 0x88), (float)gameState.CountDownState.StrokeThickness); } // score leftScore.Text = gameState.RightScore + ""; rightScore.Text = gameState.LeftScore + ""; // goals scored foreach (var goalScored in gameState.GoalsScored.Except(goalScoreds)) { //Task.Run(() => //{ // bell.Volume = 3; // bell.AudioBalance = goalScored.LeftScored ? 0 : 1; // bell.Play(); //}); goalScoreds.Add(goalScored); } var goalAnimationLength = 120.0; goalScoreds = goalScoreds.Where(x => gameState.Frame - x.Frame < goalAnimationLength).ToList(); foreach (var goalSocred in goalScoreds) { DrawLine( goalSocred.Posistion.x + (goalSocred.Surface.x * 1000 * (gameState.Frame - goalSocred.Frame)), goalSocred.Posistion.y + (goalSocred.Surface.y * 1000 * (gameState.Frame - goalSocred.Frame)), goalSocred.Posistion.x - (goalSocred.Surface.x * 1000 * (gameState.Frame - goalSocred.Frame)), goalSocred.Posistion.y - (goalSocred.Surface.y * 1000 * (gameState.Frame - goalSocred.Frame)), Color.FromArgb((byte)(1.0 - (((gameState.Frame - goalSocred.Frame) / goalAnimationLength)) * 0xff), 0x00, 0x00, 0x00), 1 / scale, CanvasCapStyle.Round); } // collisions foreach (var collision in gameState.collisions.Except(collisions)) { if (collision.Force.Length > 100) { // Task.Run(() => //{ //var item = collisionSounds.First.Value; //collisionSounds.RemoveFirst(); //collisionSounds.AddLast(item); // item.Volume = (collision.Force.Length * collision.Force.Length / 100.0); // item.AudioBalance = collision.Position.x / FieldDimensions.Default.xMax; // item.Play(); //}); } collisions.Add(collision); } var timeDenom = 100.0; collisions = collisions.Where(x => gameState.Frame - x.Frame < x.Force.Length / timeDenom).Take(10).ToList(); foreach (var collision in collisions) { DrawLine( collision.Position.x + ((collision.Force.y + (collision.Force.x / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.y - ((collision.Force.x + (collision.Force.y / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.x + ((collision.Force.y + (collision.Force.x / 10.0)) * 1 * (gameState.Frame - collision.Frame)), collision.Position.y - ((collision.Force.x + (collision.Force.y / 10.0)) * 1 * (gameState.Frame - collision.Frame)), Color.FromArgb((byte)(1.0 - (((gameState.Frame - collision.Frame) / (collision.Force.Length / timeDenom))) * 0xff), 0x00, 0x00, 0x00), 1 / scale, CanvasCapStyle.Round); DrawLine( collision.Position.x - ((collision.Force.y + (collision.Force.x / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.y + ((collision.Force.x + (collision.Force.y / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.x - ((collision.Force.y + (collision.Force.x / 10.0)) * 1 * (gameState.Frame - collision.Frame)), collision.Position.y + ((collision.Force.x + (collision.Force.y / 10.0)) * 1 * (gameState.Frame - collision.Frame)), Color.FromArgb((byte)(1.0 - (((gameState.Frame - collision.Frame) / (collision.Force.Length / timeDenom))) * 0xff), 0x00, 0x00, 0x00), 1 / scale, CanvasCapStyle.Round); DrawLine( collision.Position.x + ((collision.Force.y - (collision.Force.x / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.y - ((collision.Force.x - (collision.Force.y / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.x + ((collision.Force.y - (collision.Force.x / 10.0)) * 1 * (gameState.Frame - collision.Frame)), collision.Position.y - ((collision.Force.x - (collision.Force.y / 10.0)) * 1 * (gameState.Frame - collision.Frame)), Color.FromArgb((byte)(1.0 - (((gameState.Frame - collision.Frame) / (collision.Force.Length / timeDenom))) * 0xff), 0x00, 0x00, 0x00), 1 / scale, CanvasCapStyle.Round); DrawLine( collision.Position.x - ((collision.Force.y - (collision.Force.x / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.y + ((collision.Force.x - (collision.Force.y / 10.0)) * .5 * (gameState.Frame - collision.Frame)), collision.Position.x - ((collision.Force.y - (collision.Force.x / 10.0)) * 1 * (gameState.Frame - collision.Frame)), collision.Position.y + ((collision.Force.x - (collision.Force.y / 10.0)) * 1 * (gameState.Frame - collision.Frame)), Color.FromArgb((byte)(1.0 - (((gameState.Frame - collision.Frame) / (collision.Force.Length / timeDenom))) * 0xff), 0x00, 0x00, 0x00), 1 / scale, CanvasCapStyle.Round); } foreach (var collision in gameState.debugs.Where(x => gameState.Frame - x.Frame < 180)) { DrawCircle(collision.Target.x, collision.Target.y, Constants.BallRadius, Colors.Black, 1 / scale); } // draw throw preview foreach (var playerPair in gameState.players) { //if (gameState.GameBall.OwnerOrNull == playerPair.Key) //{ var toThrow = playerPair.Value.ProposedThrow;//.NewAdded(playerPair.Value.PlayerBody.Velocity).NewAdded(playerPair.Value.PlayerFoot.Velocity).NewAdded(playerPair.Value.ExternalVelocity).NewAdded(playerPair.Value.BoostVelocity); DrawLine( playerPair.Value.PlayerFoot.Position.x, playerPair.Value.PlayerFoot.Position.y, playerPair.Value.PlayerFoot.Position.x + (toThrow.x * 30), playerPair.Value.PlayerFoot.Position.y + (toThrow.y * 30), Color.FromArgb(0xff, playerPair.Value.PlayerFoot.R, playerPair.Value.PlayerFoot.G, playerPair.Value.PlayerFoot.B), 1 / scale, CanvasCapStyle.Round); //} } void DrawFilledCircle(double x, double y, double rad, Color color) { args.DrawingSession.FillCircle( (float)((x * scale) + xPlus), (float)((y * scale) + yPlus), (float)(rad * scale), color); } void DrawCircle(double x, double y, double rad, Color color, float strokeWidth) { args.DrawingSession.DrawCircle( (float)((x * scale) + xPlus), (float)((y * scale) + yPlus), (float)(rad * scale), color, strokeWidth * scale); } void DrawLine(double x1, double y1, double x2, double y2, Color color, float strokeWidth, CanvasCapStyle capStyle) { args.DrawingSession.DrawLine( new Vector2((float)((x1 * scale) + xPlus), (float)((y1 * scale) + yPlus)), new Vector2((float)((x2 * scale) + xPlus), (float)((y2 * scale) + yPlus)), color, strokeWidth * scale, new CanvasStrokeStyle { EndCap = capStyle }); } }
/// <summary> /// Draw the canvas and its contents /// </summary> /// <param name="sender"></param> /// <param name="args"></param> void CanvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { // Get Screen Size/Bounds var bounds = ApplicationView.GetForCurrentView().VisibleBounds; var scaleFactor = DisplayInformation.GetForCurrentView().RawPixelsPerViewPixel; var size = new Size(bounds.Width * scaleFactor, bounds.Height * scaleFactor); //Calculate Canvase Size double width = size.Width - 200; double height = size.Height - 180; //Calculate Seperator double scale = 7; _Space = height / scale; _PixelSize = height / (scale * 1000); //Set Text Properties CanvasTextFormat textFormat = new CanvasTextFormat(); textFormat.FontSize = 14; CanvasTextFormat textFormatFat = new CanvasTextFormat(); textFormatFat.FontSize = 16; textFormatFat.FontWeight = Windows.UI.Text.FontWeights.Medium; //Set Canvas Size GridCanvas.Width = width; GridCanvas.Height = height; //Draw Grid for (int i = (int)_Space; i < width; i += (int)_Space) { args.DrawingSession.DrawLine(i, 0, i, (int)height, Colors.LightGray); args.DrawingSession.DrawText((Math.Round(i / _Space) - 1).ToString(), i + 3, 0, Colors.LightGray, textFormat); } for (int i = (int)_Space; i < height; i += (int)_Space) { args.DrawingSession.DrawLine(0, i, (int)width, i, Colors.LightGray); args.DrawingSession.DrawText((Math.Round(i / _Space) - 1).ToString(), 0, i + 3, Colors.LightGray, textFormat); } //Draw Anchors foreach (Anchor anchor in _Pozyx.Anchors) { args.DrawingSession.DrawEllipse((float)(anchor.X * _PixelSize + _Space), (float)(anchor.Y * _PixelSize + _Space), 5, 5, Colors.Blue); args.DrawingSession.FillCircle((float)(anchor.X * _PixelSize + _Space), (float)(anchor.Y * _PixelSize + _Space), 5, Colors.Blue); args.DrawingSession.DrawText("ID: 0X" + anchor.Id.ToString("X4"), (float)(anchor.X * _PixelSize + _Space), (float)(anchor.Y * _PixelSize + _Space + 2), Colors.SlateGray, textFormatFat); args.DrawingSession.DrawText(anchor.X + "," + anchor.Y + "," + anchor.Z, (float)(anchor.X * _PixelSize + _Space), (float)(anchor.Y * _PixelSize + _Space + 20), Colors.DarkGray, textFormat); } // Draw table big args.DrawingSession.DrawRectangle((float)(1980 * _PixelSize + _Space), (float)(2000 * _PixelSize + _Space), (float)(3600 * _PixelSize), (float)(1200 * _PixelSize), Colors.Cyan, 5); // Draw table circle // args.DrawingSession.DrawEllipse((float)(2030 * pixelSize + space), (float)(2310 * pixelSize + space), (float)(600 * pixelSize), (float)(600 * pixelSize), Colors.Cyan, 5); // Draw Test Path //args.DrawingSession.DrawRectangle((float)(1170 * _PixelSize + _Space), (float)(1220 * _PixelSize + _Space), (float)(5000 * _PixelSize), (float)(2500 * _PixelSize), Colors.BlanchedAlmond, 29); // Draw line for (int i = 0; i < _LinePoints.Count - 1; i++) { args.DrawingSession.DrawLine(_LinePoints[i][0], _LinePoints[i][1], _LinePoints[i + 1][0], _LinePoints[i + 1][1], Windows.UI.Colors.Green); } // Draw line friend for (int i = 0; i < _FriendLine.Count - 1; i++) { args.DrawingSession.DrawLine(_FriendLine[i][0], _FriendLine[i][1], _FriendLine[i + 1][0], _FriendLine[i + 1][1], Windows.UI.Colors.Purple); } if (_LinePoints.Count >= 1) { // Draw Tag args.DrawingSession.FillCircle(_LinePoints.Last()[0], _LinePoints.Last()[1], 5, Colors.Green); } if (_FriendLine.Count >= 1) { // Draw friend args.DrawingSession.FillCircle(_FriendLine.Last()[0], _FriendLine.Last()[1], 5, Colors.Purple); } }
private void CanvasControl_OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { _chartRenderer.RenderData(chartCanvas, args, statusColor, DataStrokeThickness, _data, false, _max); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (ItemTemplate == null) { return; } if (ItemsSource == null) { return; } /* * var items = ItemsSource.Select(o => { * var item = ItemTemplate.LoadContent() as LineChartItem; * item.DataContext = o; * return item; * }).ToList(); */ List <LineChartItem> items = new List <LineChartItem>(); foreach (LineChartItem item in ItemsSource) { items.Add(item); } if (!items.Any()) { return; } var availableWidth = (float)_canvas.ActualWidth; var availableHeight = (float)_canvas.ActualHeight; var fill = Fill ?? new SolidColorBrush(DefaultColors.GetRandom()); var elementWidth = availableWidth / (items.Count - 1); var radius = (float)(Thickness * 2); var min = items.Min(i => i.Value); var max = items.Max(i => i.Value); var diff = max - min; var d = diff * 0.01; #region Add X captions _xCap.Children.Clear(); _xCap.Children.Add(new TextBlock { Text = "Test",//items.First().Key.ToString(), HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Stretch }); _xCap.Children.Add(new TextBlock { Text = "Test", //items.Last().Key.ToString(), HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Stretch }); #endregion #region Add Y captions _yCap.Children.Clear(); if (YAxis == YMode.FromMin) { _yCap.Children.Add(new TextBlock { Text = min.ToString(), HorizontalAlignment = HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Bottom }); } else { _yCap.Children.Add(new TextBlock { Text = "0", HorizontalAlignment = HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Bottom }); _yCap.Children.Add(new TextBlock { Text = min.ToString(), HorizontalAlignment = HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Bottom, Margin = new Thickness(0, 0, 0, -10 + min * availableHeight / max) }); } _yCap.Children.Add(new TextBlock { Text = max.ToString(), HorizontalAlignment = HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Top, }); #endregion // Draw lines using (var builder = new CanvasPathBuilder(sender)) { for (var i = 0; i < items.Count; i++) { var item = items[i]; var x = i * elementWidth; var y = availableHeight - (YAxis == YMode.FromMin ? (float)((item.Value - min) * availableHeight / diff) : (float)(item.Value * availableHeight / max)); // Fixes for edge points if (max - item.Value < d) { y += radius; } if (item.Value - min < d) { y -= radius; } // Main drawing if (i == 0) { builder.BeginFigure(x, y); } else { builder.AddLine(x, y); } } builder.EndFigure(CanvasFigureLoop.Open); using (var geometry = CanvasGeometry.CreatePath(builder)) args.DrawingSession.DrawGeometry(geometry, fill.Color, (float)Thickness); // Draw axis var color = ForegroundColor; args.DrawingSession.DrawLine(0, 0, 0, availableHeight, Colors.Black, 1); args.DrawingSession.DrawLine(0, availableHeight, availableWidth, availableHeight, Colors.Black, 1); } }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (testBitmaps == null) return; var ds = args.DrawingSession; float senderSize = Math.Min((float)sender.Size.Width, (float)sender.Size.Height); float marginSize = senderSize / 50.0f; // There are 11 cells, so divide the target into a 4x3 grid (with one empty cell). float cellWidthInclMargin = (float)sender.Size.Width / 4.0f; float cellWidth = cellWidthInclMargin - marginSize; float cellHeightInclMargin = (float)sender.Size.Height / 3.0f; float cellHeight = cellHeightInclMargin - marginSize; const int cellsPerRow = 4; for (int cellY = 0; cellY < 3; ++cellY) { for (int cellX = 0; cellX < cellsPerRow; ++cellX) { int bitmapIndex = (cellsPerRow * cellY) + cellX; Rect cellRect = new Rect(cellX * cellWidthInclMargin, cellY * cellHeightInclMargin, cellWidth, cellHeight); if (bitmapIndex < testBitmaps.Length) { var image = testBitmaps[bitmapIndex]; var bitmap = image as CanvasBitmap; if (bitmap != null) { ds.DrawImage(bitmap, cellRect); } #if WINDOWS_UWP else { var virtualBitmap = image as CanvasVirtualBitmap; ds.DrawImage(virtualBitmap, cellRect, virtualBitmap.Bounds); } #endif } else { // X out the cell, just to show it's not glitched out or anything. ds.DrawLine((float)cellRect.Left, (float)cellRect.Top, (float)cellRect.Right, (float)cellRect.Bottom, Colors.White); ds.DrawLine((float)cellRect.Right, (float)cellRect.Top, (float)cellRect.Left, (float)cellRect.Bottom, Colors.White); } } } }
void canvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { args.DrawingSession.DrawEllipse(155, 115, 80, 30, Colors.Black, 3); args.DrawingSession.DrawText("Hello, world!", 100, 100, Colors.Yellow); }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void CanvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { Draw(args.DrawingSession); }
private void Canvas12_Draw(CanvasControl sender, CanvasDrawEventArgs args) { DrawCanvasState(sender, args.DrawingSession, ++drawCount12); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var ds = args.DrawingSession; foreach (var link in Links) { var centerPoint = (link.Node1.Position + link.Node2.Position) / 2; //if (Math.Abs(link.Node1.PositionX - link.Node2.PositionX) > Math.Abs(link.Node1.PositionY - link.Node2.PositionY)) //{ // ds.DrawText(link.Weight.ToString(), centerPoint.X, centerPoint.Y - 10, foregroundColor); //} ds.DrawEllipse((float)Canvas.ActualWidth / 2, (float)Canvas.ActualHeight / 2, 500, 500, foregroundColor); using (var builder = new CanvasPathBuilder(sender)) { builder.BeginFigure(link.Node1.Position); builder.AddArc(link.Node2.Position, arcRadiusX, arcRadiusY, 0, CanvasSweepDirection.Clockwise, CanvasArcSize.Small); builder.EndFigure(CanvasFigureLoop.Open); using (var geometry = CanvasGeometry.CreatePath(builder)) { ds.DrawGeometry(geometry, foregroundColor, strokeWidth); } } } foreach (var node in Nodes) { DrawNode(ds, node); } }
private void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { var currentShape = this.availableShapes.FirstOrDefault(s => s.Key == ShapeType); if(args.DrawingSession == null) currentShape = this.DefaultShape; currentShape.Value.Invoke(sender, args.DrawingSession); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { EnsureLayout(sender); if (ShowLayoutRectangles) { foreach (var layoutRectangle in layoutRectangles) { args.DrawingSession.DrawRectangle(layoutRectangle, Colors.Gray); } } if (ShowSelectionBox) { args.DrawingSession.DrawRectangle(layoutBox, Colors.LightGray, 2.0f, dashedStroke); } var brush = new CanvasSolidColorBrush(sender, Colors.LightSkyBlue); foreach (LayoutBox l in layoutBoxes) { if (l.GlyphRuns.Count > 0) { float layoutAdvance = 0; foreach (var g in l.GlyphRuns) { layoutAdvance += g.GetAdvance(); } float x = (float)l.Rectangle.Left; if (CurrentTextDirection == TextDirection.RightToLeft) { x = (float)l.Rectangle.Right - layoutAdvance; } int[] bidiOrdering = l.ProduceBidiOrdering(); foreach (int glyphRunIndex in bidiOrdering) { GlyphRun g = l.GlyphRuns[glyphRunIndex]; // // The Arabic test string contains control characters. A typical text renderer will just not draw these. // if (g.FormattingSpan.Script.Shape == CanvasScriptShape.NoVisual) { continue; } if (g.Glyphs.Count > 0) { float advance = g.GetAdvance(); Vector2 position; position.X = x; position.Y = (float)l.Rectangle.Bottom; if (g.FormattingSpan.BidiLevel % 2 != 0) { position.X += advance; } args.DrawingSession.DrawGlyphRun( position, g.FormattingSpan.FontFace, g.FormattingSpan.FontSize, g.Glyphs.ToArray(), false, // isSideways g.FormattingSpan.BidiLevel, brush); x += advance; } } } } }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { using (var session = args.DrawingSession) { var blur = new GaussianBlurEffect { BlurAmount = 50.0f, // increase this to make it more blurry or vise versa. //Optimization = EffectOptimization.Balanced, // default value //BorderMode = EffectBorderMode.Soft // default value Source = _bitmap }; session.DrawImage(blur, new Rect(0, 0, sender.ActualWidth, sender.ActualHeight), new Rect(0, 0, _bitmap.SizeInPixels.Width, _bitmap.SizeInPixels.Height), 0.9f); } }
private void CanvasMinus_Draw(CanvasControl sender, CanvasDrawEventArgs args) { DrawHorizontalLine(sender, args); DrawBorder(sender, args); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { EnsureResources(sender, sender.Size); float strokeWidth = CurrentTextLengthOption == TextLengthOption.Paragraph ? 2.0f : 15.0f; args.DrawingSession.DrawGeometry(textGeometry, Colors.White, strokeWidth, dashedStroke); if (ShowNonOutlineText) { Color semitrans = Colors.CornflowerBlue; semitrans.A = 127; args.DrawingSession.DrawTextLayout(textLayout, 0, 0, semitrans); } }
private void DrawCanvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (_isFirstCall) { _isFirstCall = false; PanZoomReset(); } if (sender == EditCanvas) { Draw(DrawModel.BackData); Draw(DrawModel.EditData); if (SelectorGrid.Visibility == Visibility.Visible) { UpdateSelectorGrid(); } } else if (sender == OverCanvas) { Draw(DrawModel.EditData); } else if (sender == Pick1Canvas) { Draw(DrawModel.Picker1Data); } else if (sender == Pick2Canvas) { Draw(DrawModel.Picker2Data); } void Draw(IDrawData data) { if (data is null) { return; } var(scale, offset) = CanvasScaleOffset[sender]; var ds = args.DrawingSession; foreach (var(P, (K, S, W), (A, R, G, B)) in data.Parms) { var isFilled = S == StrokeType.Filled; var V = W * scale; if (V < 1) { V = 1; } if (K < ShapeType.SimpleShapeMask) { var color = Color.FromArgb(A, R, G, B); var stroke = StrokeStyle(S); switch (K) { case ShapeType.Line: for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale + offset; ds.DrawLine(a, b, color, V, stroke); } break; case ShapeType.Circle: if (isFilled) { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; ds.FillCircle(a, b.X, color); } } else { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; ds.DrawCircle(a, b.X, color, V, stroke); } } break; case ShapeType.Ellipse: if (isFilled) { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; ds.FillEllipse(a, b.X, b.Y, color); } } else { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; ds.DrawEllipse(a, b.X, b.Y, color, V, stroke); } } break; case ShapeType.EqualRect: var d = P[0] * scale; if (isFilled) { for (int i = 1; i < P.Length; i++) { var a = P[i] * scale + offset; ds.FillRectangle(a.X, a.Y, d.X, d.Y, color); } } else { for (int i = 1; i < P.Length; i++) { var a = P[i] * scale + offset; ds.DrawRectangle(a.X, a.Y, d.X, d.Y, color, V, stroke); } } break; case ShapeType.CornerRect: if (isFilled) { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; ds.FillRectangle(a.X, a.Y, b.X, b.Y, color); } } else { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; ds.DrawRectangle(a.X, a.Y, b.X, b.Y, color, V, stroke); } } break; case ShapeType.CenterRect: if (isFilled) { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; var e = a - b; var f = 2 * b; ds.FillRectangle(e.X, e.Y, f.X, f.Y, color); } } else { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; var e = a - b; var f = 2 * b; ds.DrawRectangle(e.X, e.Y, f.X, f.Y, color, V, stroke); } } break; case ShapeType.RoundedRect: var r = 8 * scale; if (isFilled) { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; var e = a - b; var f = 2 * b; ds.FillRoundedRectangle(e.X, e.Y, f.X, f.Y, r, r, color); } } else { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; var b = P[i + 1] * scale; var e = a - b; var f = 2 * b; ds.DrawRoundedRectangle(e.X, e.Y, f.X, f.Y, r, r, color, V, stroke); } } break; case ShapeType.Pin2: { var b = 2 * scale; if (isFilled) { for (int i = 0; i < P.Length; i++) { var a = P[i] * scale + offset; ds.FillCircle(a, b, color); ds.DrawCircle(a, b + V, Colors.Black, V, stroke); } } else { for (int i = 0; i < P.Length; i++) { var a = P[i] * scale + offset; ds.DrawCircle(a, b - V, Colors.Black, V, stroke); ds.DrawCircle(a, b, color, V, stroke); ds.DrawCircle(a, b + V, Colors.Black, V, stroke); } } } break; case ShapeType.Pin4: { var b = 4 * scale; if (isFilled) { for (int i = 0; i < P.Length; i++) { var a = P[i] * scale + offset; ds.FillCircle(a, b, color); ds.DrawCircle(a, b + V, Colors.Black, V, stroke); } } else { for (int i = 0; i < P.Length; i++) { var a = P[i] * scale + offset; ds.DrawCircle(a, b - V, Colors.Black, V, stroke); ds.DrawCircle(a, b, color, V, stroke); ds.DrawCircle(a, b + V, Colors.Black, V, stroke); } } } break; case ShapeType.Grip2: { var e = 2 * scale; var f = 2 * e; if (isFilled) { for (int i = 0; i < P.Length; i++) { var a = P[i] * scale + offset; ds.FillRectangle(a.X - e, a.Y - e, f, f, color); } } else { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; ds.DrawRectangle(a.X - e, a.Y - e, f, f, color, V, stroke); } } } break; case ShapeType.Grip4: { var e = 4 * scale; var f = 2 * e; if (isFilled) { for (int i = 0; i < P.Length; i++) { var a = P[i] * scale + offset; ds.FillRectangle(a.X - e, a.Y - e, f, f, color); } } else { for (int i = 0; i < P.Length; i += 2) { var a = P[i] * scale + offset; ds.DrawRectangle(a.X - e, a.Y - e, f, f, color, V, stroke); } } } break; } } else { using (var pb = new CanvasPathBuilder(ds)) { pb.BeginFigure(P[0] * scale + offset); if ((K & ShapeType.JointedLines) != 0 || (K & ShapeType.ClosedLines) != 0) { for (int i = 1; i < P.Length; i++) { pb.AddLine(P[i] * scale + offset); } } else { var N = P.Length; for (var i = 0; i < N - 2;) { pb.AddCubicBezier(P[i] * scale + offset, P[++i] * scale + offset, P[++i] * scale + offset); } } if ((K & ShapeType.ClosedLines) != 0) { pb.EndFigure(CanvasFigureLoop.Closed); } else { pb.EndFigure(CanvasFigureLoop.Open); } using (var geo = CanvasGeometry.CreatePath(pb)) { if (isFilled) { ds.FillGeometry(geo, Color.FromArgb(A, R, G, B)); } else { ds.DrawGeometry(geo, Color.FromArgb(A, R, G, B), V, StrokeStyle(S)); } } } } } foreach (var((P, T), (A, R, G, B)) in data.Text) { var p = P * scale + offset; ds.DrawText(T, p, Color.FromArgb(A, R, G, B)); } } }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var size = sender.Size; var ds = args.DrawingSession; // Animate and then display the current image effect. animationFunction((float)timer.Elapsed.TotalSeconds); ds.DrawImage(effect, (size.ToVector2() - currentEffectSize) / 2); // Draw text showing which effects are in use, but only if the screen is large enough to fit it. const float minSizeToShowText = 500; if ((size.Width + size.Height) / 2 > minSizeToShowText && !ThumbnailGenerator.IsDrawingThumbnail) { string text = activeEffectNames; if (textLabel != null) { text += "\n\n" + textLabel; } ds.DrawText(text, 0, 80, Colors.White, textFormat); } sender.Invalidate(); }
private void Ground_Draw(CanvasControl sender, CanvasDrawEventArgs args) { args.DrawingSession.DrawImage(bitmapOrb, xPos, yPos); ground.Invalidate(); }
private void canvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (needToCreateSizeDependentResources) { CreateSizeDependentResources(); } if (needToRedrawInkSurface) { ClearInkSurface(); DrawStrokeCollectionToInkSurface(inkManager.GetStrokes()); needToRedrawInkSurface = false; } DrawBackgroundText(args.DrawingSession); if (pendingDry != null && deferredDryDelay == 0) { // Incremental draw only. DrawStrokeCollectionToInkSurface(pendingDry); // Register to call EndDry on the next-but-one draw, // by which time our dry ink will be visible. deferredDryDelay = 1; CompositionTarget.Rendering += DeferredEndDry; } args.DrawingSession.DrawImage(renderTarget); DrawForegroundText(args.DrawingSession); DrawSelectionBoundingRect(args.DrawingSession); DrawSelectionLasso(sender, args.DrawingSession); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (ItemTemplate == null) { return; } if (ItemsSource == null) { return; } var items = ItemsSource.Cast <LineChartItem>().ToList(); if (!items.Any()) { return; } var availableWidth = (float)_canvas.ActualWidth; var availableHeight = (float)_canvas.ActualHeight; var fill = Fill ?? new SolidColorBrush(DefaultColors.GetRandom()); var elementWidth = (availableWidth - (Thickness * 2)) / (items.Count - 1); var radius = (float)(Thickness * 2); var min = items.Min(i => i.Value); var max = items.Max(i => i.Value); var diff = max - min; var d = diff * 0.01; #region Add X captions _xCap.Children.Clear(); _xCap.Children.Add(new TextBlock { // Text = items.First().Key.ToString(), HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Stretch }); _xCap.Children.Add(new TextBlock { // Text = items.Last().Key.ToString(), HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Stretch }); #endregion /* #region Add Y captions * _yCap.Children.Clear(); * if (YAxis == YMode.FromMin) { * _yCap.Children.Add(new TextBlock { * Text = min.ToString(), * HorizontalAlignment = HorizontalAlignment.Stretch, * VerticalAlignment = VerticalAlignment.Bottom * }); * } * else { * _yCap.Children.Add(new TextBlock { * Text = "0", * HorizontalAlignment = HorizontalAlignment.Stretch, * VerticalAlignment = VerticalAlignment.Bottom * }); * _yCap.Children.Add(new TextBlock { * Text = min.ToString(), * HorizontalAlignment = HorizontalAlignment.Stretch, * VerticalAlignment = VerticalAlignment.Bottom, * Margin = new Thickness(0, 0, 0, -10 + min * availableHeight / max) * }); * } * _yCap.Children.Add(new TextBlock { * Text = max.ToString(), * HorizontalAlignment = HorizontalAlignment.Stretch, * VerticalAlignment = VerticalAlignment.Top, * }); #endregion * */ IList <Vector2> array = new List <Vector2>(); IList <Vector2> controlPoints = new List <Vector2>(); for (var i = 0; i < items.Count; i++) { var item = items[i]; var x = (float)(i * (elementWidth) + Thickness); var y = availableHeight - (YAxis == YMode.FromMin ? (float)((item.Value - min) * availableHeight / diff) : (float)(item.Value * availableHeight / max)); // Fixes for edge points if (max - item.Value < d) { y += radius; } if (item.Value - min < d) { y -= radius; } array.Add(new Vector2(x, y)); } for (int i = 1; i < array.Count - 1; i++) { Vector2[] controlPoint2 = CalculateControlPoints(array[i - 1], array[i], array[i + 1]); controlPoints.Add(controlPoint2[0]); controlPoints.Add(controlPoint2[1]); } // Fill area using (var fillBuilder = new CanvasPathBuilder(sender)) { // Draw lines using (var drawBuilder = new CanvasPathBuilder(sender)) { for (int i = 0; i < array.Count; i++) { if (i == 0) { drawBuilder.BeginFigure(array[i]); fillBuilder.BeginFigure(array[i]); } else if (i == 1 && array.Count == 2) { drawBuilder.AddCubicBezier(array[0], array[1], array[1]); fillBuilder.AddCubicBezier(array[0], array[1], array[1]); } else if (i == 1 && array.Count > 2) { drawBuilder.AddCubicBezier(array[0], controlPoints[0], array[1]); fillBuilder.AddCubicBezier(array[0], controlPoints[0], array[1]); } else if (i < array.Count - 1) { drawBuilder.AddCubicBezier(controlPoints[i * 2 - 3], controlPoints[i * 2 - 2], array[i]); fillBuilder.AddCubicBezier(controlPoints[i * 2 - 3], controlPoints[i * 2 - 2], array[i]); } else if (array.Count > 1) { drawBuilder.AddCubicBezier(controlPoints[i * 2 - 3], array[i], array[i]); fillBuilder.AddCubicBezier(controlPoints[i * 2 - 3], array[i], array[i]); } } drawBuilder.EndFigure(CanvasFigureLoop.Open); using (var geometry = CanvasGeometry.CreatePath(drawBuilder)) { CanvasStrokeStyle strokeStyle = new CanvasStrokeStyle { EndCap = CanvasCapStyle.Round, StartCap = CanvasCapStyle.Round }; Color startColor = fill.Color; Color startColor2 = fill.Color; startColor2.A = 150; CanvasLinearGradientBrush ee = new CanvasLinearGradientBrush(_canvas, startColor, startColor2) { StartPoint = new Vector2(0, 0), EndPoint = new Vector2(0, availableHeight) }; args.DrawingSession.DrawGeometry(geometry, ee, (float)Thickness, strokeStyle); } fillBuilder.AddLine(array.Last().X, availableHeight); fillBuilder.AddLine(array[0].X, availableHeight); fillBuilder.EndFigure(CanvasFigureLoop.Closed); using (var geometry = CanvasGeometry.CreatePath(fillBuilder)) { Color startColor = fill.Color; startColor.A = 50; CanvasLinearGradientBrush ee = new CanvasLinearGradientBrush(_canvas, startColor, Colors.Transparent) { StartPoint = new Vector2(0, 0), EndPoint = new Vector2(0, availableHeight) }; args.DrawingSession.FillGeometry(geometry, ee); } } } args.DrawingSession.DrawLine( 0, availableHeight, availableWidth, availableHeight + 16, Color.FromArgb(35, 255, 255, 255), 0.5f); // Draw axis Color color = ((SolidColorBrush)Foreground).Color; color.A = 40; CanvasStrokeStyle strokeStyle2 = new CanvasStrokeStyle { CustomDashStyle = new float[] { 2, 4 }, }; var part = (availableHeight - 2 * radius) / 3; for (int i = 0; i < 4; i++) { var yPos = radius + i * part; args.DrawingSession.DrawLine(0, yPos, availableWidth, yPos, color, 1, strokeStyle2); } }
private void canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { //only draw if image is loaded if (bitmapImg != null) { args.DrawingSession.DrawImage(bitmapImg, bitmapRect); sender.Invalidate(); } }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { EnsureResources(sender, sender.Size); currentDrawingSession = args.DrawingSession; textLayout.SetBrush(0, testString.Length, null); if (hasSelection) { int firstIndex = Math.Min(selectionStartIndex, selectionEndIndex); int length = Math.Abs(selectionEndIndex - selectionStartIndex) + 1; CanvasTextLayoutRegion[] descriptions = textLayout.GetCharacterRegions(firstIndex, length); foreach (CanvasTextLayoutRegion description in descriptions) { args.DrawingSession.FillRectangle(InflateRect(description.LayoutBounds), Colors.White); } textLayout.SetBrush(firstIndex, length, selectionTextBrush); } EnsureInlineObjects(); args.DrawingSession.DrawTextLayout(textLayout, 0, 0, textBrush); if (ShowPerCharacterLayoutBounds) { for (int i = 0; i < testString.Length; i++) { CanvasTextLayoutRegion textLayoutRegion; textLayout.GetCaretPosition(i, false, out textLayoutRegion); args.DrawingSession.DrawRectangle(textLayoutRegion.LayoutBounds, Colors.Blue, 2); } } if (ShowDrawBounds) { args.DrawingSession.DrawRectangle(textLayout.DrawBounds, Colors.Green, 2); } if (ShowLayoutBounds) { args.DrawingSession.DrawRectangle(textLayout.LayoutBounds, Colors.Red, 2, dashedStroke); } }