private void DrawHeart(CanvasControl sender, CanvasDrawingSession ds)
        {
            var width = (float) sender.ActualWidth;
            var height = (float) sender.ActualHeight;
            var stroke = this.defaultStroke / 2;
            var scale = Math.Min(width,height) / 2 - stroke;
            var center = new Vector2(width / 2 , height / 2);

            var heartGeometry = CreateHeart(sender, scale, center);
            ds.FillGeometry(heartGeometry, ForegroundColor);
            ds.DrawGeometry(heartGeometry, GlowColor, stroke);
        }
        private void DrawTriangle(CanvasControl sender, CanvasDrawingSession ds)
        {
            var width = (float) sender.ActualWidth;
            var height = (float) sender.ActualHeight;
            var stroke = this.defaultStroke;
            var center =  new Vector2(width / 2, height / 2);
            var scale = (width / 2) - (stroke * 2);

            var triangleGeometry = CreateTriangleGeometry(sender, scale, center);
            ds.FillGeometry(triangleGeometry, ForegroundColor);
            ds.DrawGeometry(triangleGeometry, GlowColor, stroke);
        }
        public void Draw(ICanvasAnimatedControl sender, CanvasTimingInformation timingInformation, CanvasDrawingSession ds)
        {
            ds.DrawCachedGeometry(clockFaceCachedFill, backgroundBrush);

            double fractionSecond;
            int seconds;

            if (sender.IsFixedTimeStep)
            {
                double updatesPerSecond = 1000.0 / sender.TargetElapsedTime.TotalMilliseconds;
                seconds = (int)((timingInformation.UpdateCount / updatesPerSecond) % 10);

                double updates = (double)timingInformation.UpdateCount;
                fractionSecond = (updates / updatesPerSecond) % 1.0;
            }
            else
            {
                double totalMilliseconds = timingInformation.TotalTime.TotalMilliseconds;
                double millisecondsThisIteration = totalMilliseconds % 1000;

                fractionSecond = millisecondsThisIteration / 1000.0f;
                seconds = (int)timingInformation.TotalTime.TotalSeconds % 10;
            }

            hueRotationEffect.Angle = (float)Math.PI * (seconds / 10.0f) * 2.0f;

            using (var timeSegmentGeometry = CreateTimeSegmentGeometry(ds, fractionSecond))
            {
                ds.FillGeometry(timeSegmentGeometry, foregroundBrush);

                DrawSecondsText(ds, new Vector2(center), seconds);

                ds.DrawGeometry(timeSegmentGeometry, Colors.White, 1, hairlineStrokeStyle);
            }


            ds.DrawCachedGeometry(clockFaceCachedStroke18, Colors.White);
            ds.DrawCachedGeometry(clockFaceCachedStroke16, Colors.Black);
        }
Ejemplo n.º 4
0
        static void DrawContactGeometry(CanvasDrawingSession ds, CanvasGeometry geom)
        {
            if (geom == null)
                return;

            ds.FillGeometry(geom, Colors.Green);
            ds.DrawGeometry(geom, Colors.Blue, 5);
        }
Ejemplo n.º 5
0
        public void DisplayRegionEditInProgress(CanvasDrawingSession drawingSession, List<Vector2> points, float zoomFactor)
        {
            if (RegionSelectionMode == SelectionMode.MagicWand)
            {
                // Display a magic wand selection.
                var mask = GetMagicWandMask(points, zoomFactor);
                var border = GetSelectionBorder(mask, zoomFactor);

                drawingSession.Blend = CanvasBlend.Add;
                drawingSession.DrawImage(mask, Vector2.Zero, SourceBitmap.Bounds, 0.25f);

                drawingSession.Blend = CanvasBlend.SourceOver;
                drawingSession.DrawImage(border);
            }
            else
            {
                // Display a geometric shape selection.
                var geometry = GetSelectionGeometry(drawingSession, points);

                drawingSession.Blend = CanvasBlend.Add;
                drawingSession.FillGeometry(geometry, Color.FromArgb(0x20, 0xFF, 0xFF, 0xFF));

                drawingSession.Blend = CanvasBlend.SourceOver;
                drawingSession.DrawGeometry(geometry, Colors.Magenta, 1f / zoomFactor);
            }
        }
Ejemplo n.º 6
0
        private void DoPathEffect(CanvasControl sender, CanvasDrawingSession ds )
        {    
            using (var thBuilder = new Microsoft.Graphics.Canvas.Geometry.CanvasPathBuilder(sender))
            {
                var pthConverter = new PathToD2DPathGeometryConverter();

                foreach(var path in _paths)
                {
                    var offset = (float)ExpandAmount / 2;
                    using (var cl = new CanvasCommandList(ds))
                    using (var pthGeo = pthConverter.parse(path, thBuilder))
                    {
                        using (var clds = cl.CreateDrawingSession())
                        {
                            clds.FillGeometry(pthGeo,0,0, GlowColor);
                        }

                        _eg.Setup(cl, (float)GlowAmount, GlowColor);
                        ds.DrawImage(_eg.Output, offset, offset);
                        ds.FillGeometry(pthGeo,offset, offset, ((SolidColorBrush)GlowFill).Color);
                    }
                    
                }

            }
        }
        private static void drawDOMArrow(ICanvasResourceCreator device, CanvasDrawingSession ds, Point[] domPoints)
        {
           // Pen pen = new Pen(Color.Black, 3f);

            //pen.MiterLimit = 3;
            
            CanvasPathBuilder domPath = new CanvasPathBuilder(device);
            CanvasPathBuilder domArrow = new CanvasPathBuilder(device);

            if (domPoints[1].X == 0 && domPoints[1].Y == 0)
            {
                domPath.BeginFigure(domPoints[0].ToVector2());
                domPath.AddLine(domPoints[2].ToVector2());
                domPath.EndFigure(CanvasFigureLoop.Open);
            }
            else
            {
                domPath.BeginFigure(domPoints[0].ToVector2());
                domPath.AddLine(domPoints[1].ToVector2());
                domPath.AddLine(domPoints[2].ToVector2());
                domPath.EndFigure(CanvasFigureLoop.Open);
            }

            domArrow.BeginFigure(domPoints[3].ToVector2());
            domArrow.AddLine(domPoints[4].ToVector2());
            domArrow.AddLine(domPoints[5].ToVector2());
            domArrow.EndFigure(CanvasFigureLoop.Closed);

            CanvasGeometry cgPath = CanvasGeometry.CreatePath(domPath);
            CanvasGeometry cgArrow = CanvasGeometry.CreatePath(domArrow);

            ds.DrawGeometry(cgPath, Colors.Black,3f);
            ds.FillGeometry(cgArrow, Colors.Black);
        }