Discussion :

[ikeas]

Bonjour

je cherche un petit grapheur comme celui qui existe dans la fenêtre task manager
historique utilisation du processeur avec le mouvement
natif wpf si possible

merci

[ikeas]

comme personne m'a répondu
je l'ai fait ça interresse du monde ?

[Sankasssss]

Hello,

C'est toujours bon à prendre

[ikeas]

voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
  public class MovingGraph : Border
    {
        Queue<double> queue = new Queue<double>();
        private const int QUEUE_SIZE = 100;
 
        private const double STEP = 10;
        private const double MIN_MAX = 500;
        private const double DECAL_Y_GRAPH = 10;
 
        private double pos = 5;
 
        private double? fixe = null;
 
        public MovingGraph()
        {
            // initialize stack
            for (int i = 0; i < QUEUE_SIZE; i++, queue.Enqueue(0)) ;
        }
 
        public void Add(double value)
        {
            pos = ++pos % STEP;
            queue.Dequeue();
            queue.Enqueue(value);
            this.InvalidateVisual();
        }
 
        protected override void OnRender(System.Windows.Media.DrawingContext dc)
        {
            base.OnRender(dc);
            // draw lines 
            {
                Pen p = new Pen(this.Line, 1);
                for (double x = -pos; x < this.ActualWidth; x += STEP)
                {
                    if (x >= 0)
                        dc.DrawLine(p, new Point(x, 0), new Point(x, this.ActualHeight));
                }
                for (double y = this.ActualHeight; y > 0; y -= STEP)
                {
                    dc.DrawLine(p, new Point(0, y), new Point(this.ActualWidth, y));
                }
            }
            double cy = this.ActualHeight - DECAL_Y_GRAPH;
            double max = MIN_MAX;
            foreach (var item in queue)
            {
                max = Math.Max(max, item);
            }
            double py = cy / max;
            if (fixe != null)
            {
                Pen p = new Pen(this.Fixe, 2);
                double y = cy - ((double)fixe * py);
                dc.DrawLine(p, new Point(0, y), new Point(this.ActualWidth, y));
            }
            // draw graph
            // get maw in stack
            {
                Pen p = new Pen(this.Graph, 2);
                double px = this.ActualWidth / QUEUE_SIZE;
                double i = 0;
 
                Point lastp = new Point(i * px, cy - (queue.Peek() * py));
                i++;
                foreach (var item in queue)
                {
                    Point newp = new Point(i * px, cy - (item * py));
                    dc.DrawLine(p, (Point)lastp, newp);
                    lastp = newp;
                    i++;
                }
            }
        }
 
 
        public void Fixed(double? value = null)
        {
            double v = 0;
            if (value == null)
            {
                v = queue.LastOrDefault();
            }
            else
                v = (double)value;
            fixe = v;
            this.InvalidateVisual();
        }
        public void Unfixed()
        {
            fixe = null;
            this.InvalidateVisual();
        }
        public bool IsFixed { get { return fixe != null; } }
        public double? FixedValue { get { return fixe; } }
 
        #region DP
 
        #region Line (DP SHORT)
        public Brush Line { get { return (Brush)GetValue(LineProperty); } set { SetValue(LineProperty, value); } }
        public static readonly DependencyProperty LineProperty = DependencyProperty.Register("Line", typeof(Brush), typeof(MovingGraph), new PropertyMetadata(new SolidColorBrush(Colors.Green)));
        #endregion
 
        #region Graph (DP SHORT)
        public Brush Graph { get { return (Brush)GetValue(GraphProperty); } set { SetValue(GraphProperty, value); } }
        public static readonly DependencyProperty GraphProperty = DependencyProperty.Register("Graph", typeof(Brush), typeof(MovingGraph), new PropertyMetadata(new SolidColorBrush(Colors.Yellow)));
        #endregion
 
        #region Fixe (DP SHORT)
        public Brush Fixe { get { return (Brush)GetValue(FixeProperty); } set { SetValue(FixeProperty, value); } }
        public static readonly DependencyProperty FixeProperty = DependencyProperty.Register("Fixe", typeof(Brush), typeof(MovingGraph), new PropertyMetadata(new SolidColorBrush(Colors.Red)));
        #endregion
 
        #endregion
    }

pour info on pourrait l’améliorer car la profondeur ici 100 devrait dépendre seulement de la taille du composant ou du moins être plus grande que la taille de celui ci par exemple 1000
et redessiner le 0 a -width sur la profondeur de la queue

sinon ca marche bien