C# CanvasControl.Invalidate方法代码示例

        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 canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args)
 {
     //only draw if image is loaded
     if (bitmapImg != null)
     {
         args.DrawingSession.DrawImage(bitmapImg, bitmapRect);
         sender.Invalidate();
     }
 }

        private void UpdateJoystick(CanvasControl control, double posX, double posY, bool isFirstTime=false)
        {
            joystickDirection.X = (float)(posX - joystickCanvasSize.Width/2);
            joystickDirection.Y = (float)(posY - joystickCanvasSize.Height/2);

            float overRatio = joystickDirection.Length() / (float)JOYSTICK_HALF_SIZE;
            if (overRatio > 1.0f)
            {
                joystickDirection.X /= overRatio;
                joystickDirection.Y /= overRatio;
            }

            joystickDrawRect.X = joystickCanvasSize.Width / 2 + joystickDirection.X - JOYSTICK_HALF_SIZE;
            joystickDrawRect.Y = joystickCanvasSize.Height / 2 + joystickDirection.Y - JOYSTICK_HALF_SIZE;

            if (!isFirstTime)
            {
                control.Invalidate();
            }
        }

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

        private void OnIOGraphDraw(CanvasControl sender, CanvasDrawEventArgs args)
        {
            var ds = args.DrawingSession;

            var mostRecentBytesRead = imageStream == null ? 0 : imageStream.GetBytesRead();

            bytesRead.Add(mostRecentBytesRead);

            // Flash the control red when there's some IO
            if (mostRecentBytesRead != 0)
                flash = 1;
            else
                flash *= 0.95f;

            ds.Clear(new Vector4(flash, 0, 0, 1));

            ds.DrawText("Bytes read", new Rect(0, 0, sender.ActualWidth, sender.ActualHeight), Colors.DarkRed,
                new CanvasTextFormat()
                {
                    VerticalAlignment = CanvasVerticalAlignment.Center,
                    HorizontalAlignment = CanvasHorizontalAlignment.Left,
                    FontSize = 12
                });


            int maxBytesRead = bytesRead.Max();
            maxBytesRead = Math.Max(1, maxBytesRead);

            int displayCount = 120;

            // Draw a moving vertical tick to allow us to see that the graph is
            // updating even if nothing is being read.
            drawCount = (drawCount + 1) % displayCount;
            var vx = (1.0f - (float)drawCount / (float)displayCount) * (float)sender.ActualWidth;
            ds.DrawLine(vx, (float)sender.ActualHeight - 5, vx, (float)sender.ActualHeight, Colors.Gray);


            // Draw the graph
            if (bytesRead.Count > 2)
            {
                var p = new CanvasPathBuilder(sender);
                for (int i = 0; i < Math.Min(displayCount, bytesRead.Count); ++i)
                {
                    var x = ((float)i / (float)displayCount) * (float)sender.ActualWidth;
                    var y = (float)sender.ActualHeight - ((float)bytesRead[i] / (float)maxBytesRead) * (float)sender.ActualHeight;

                    if (i == 0)
                        p.BeginFigure(x, y);
                    else
                        p.AddLine(x, y);
                }
                p.EndFigure(CanvasFigureLoop.Open);

                using (var g = CanvasGeometry.CreatePath(p))
                {
                    ds.DrawGeometry(g, Colors.White, 3, new CanvasStrokeStyle()
                    {
                        LineJoin = CanvasLineJoin.Round
                    });
                }

                int toRemove = bytesRead.Count - displayCount;
                if (toRemove > 0)
                    bytesRead.RemoveRange(0, toRemove);
            }

            sender.Invalidate();
        }

        void MainCanvas_Draw(CanvasControl sender, CanvasDrawEventArgs args)
        {
            var ds = args.DrawingSession;
            ds.Clear(Colors.Black);

            float dt = m_stopwatch.ElapsedMilliseconds / 1000.0f;
            m_stopwatch.Restart();

            // We are abusing the Draw call as our "game loop" = create new fireworks here
            // independent of the timing of input events.
            //if (m_wasPointerPressed == true) // Disable check so we always are rendering.
            {
                for (int i = 0; i < Constants.NumPerFrame; i++)
                {
                    var firework = new Firework(
                        (float)m_pointerPos.X + RndFloat(-Constants.PosRndMax, Constants.PosRndMax),
                        (float)m_pointerPos.Y + RndFloat(-Constants.PosRndMax, Constants.PosRndMax),
                        (float)(m_pointerPos.X - m_pointerPrevPos.X) / dt * Constants.PointerVelCoeff + RndFloat(-Constants.VelRndMax, Constants.VelRndMax),
                        (float)(m_pointerPos.Y - m_pointerPrevPos.Y) / dt * Constants.PointerVelCoeff + RndFloat(-Constants.VelRndMax, Constants.VelRndMax),
                        RndFloat(Constants.RadiusMin, Constants.RadiusMax),
                        Color.FromArgb(
                            255,
                            RndByte(0, 255),
                            RndByte(0, 255),
                            RndByte(0, 255)
                        ));

                    m_controller.AddFirework(firework);
                }
            }

            m_controller.UpdateFireworks(dt);
            m_controller.RenderFireworks(ds);

            // We snap the pointer position with each Draw call, independent of the frequency of input events.
            m_pointerPrevPos = m_pointerPos;

            // Render loop.
            sender.Invalidate();
        }