source: trunk/CrypPlugins/KeySearcher/Presentation/Controls/StatisticsPresentation.xaml.cs @ 2556

Last change on this file since 2556 was 2556, checked in by nolte, 11 years ago

Added more Information to the Information-Statistic Tab

File size: 17.4 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.ComponentModel;
4using System.Globalization;
5using System.Linq;
6using System.Numerics;
7using System.Text;
8using System.Threading;
9using System.Windows;
10using System.Windows.Controls;
11using System.Windows.Data;
12using System.Windows.Documents;
13using System.Windows.Input;
14using System.Windows.Media;
15using System.Windows.Media.Imaging;
16using System.Windows.Navigation;
17using System.Windows.Shapes;
18using System.Windows.Threading;
19using KeySearcher;
20using KeySearcher.KeyPattern;
21
22namespace KeySearcherPresentation.Controls
23{
24    /// <summary>
25    /// Interaction logic for StatisticsPresentation.xaml
26    /// </summary>
27    [Cryptool.PluginBase.Attributes.Localization("KeySearcher.Properties.Resources")]
28    public partial class StatisticsPresentation : UserControl
29    {
30        public StatisticsPresentation()
31        {
32            InitializeComponent();
33            ((InformationToProgressConverter)Resources["InformationToProgressConverter"]).StatisticsPresentation = this;
34            ((InformationToProgressConverter2)Resources["InformationToProgressConverter2"]).StatisticsPresentation = this;
35            ((ChunkSumConverter)Resources["ChunkSumConverter"]).StatisticsPresentation = this;
36            ((StringLengthConverter)Resources["StringLengthConverter"]).StatisticsPresentation = this;
37            ((MachineSumToProgressConverter)Resources["MachineSumToProgressConverter"]).StatisticsPresentation = this;
38        }
39
40        private Dictionary<string, Dictionary<long, Information>> statistics = null;
41        public Dictionary<string, Dictionary<long, Information>> Statistics
42        {
43            get { return statistics; }
44            set
45            {
46                lock (this)
47                {
48                    statistics = value;
49                }
50                if (statistics != null)
51                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
52                                               {
53                                                   if (statistics != null)
54                                                   {
55                                                       var orderedstats = statistics.OrderByDescending((x) => x.Value.Sum((z) => z.Value.Count));
56                                                       statisticsTree.DataContext = orderedstats;
57                                                       statisticsTree.Items.Refresh();
58                                                   }
59                                               }, null);
60
61            }
62        }
63
64        private Dictionary<long, Maschinfo> machineHierarchy = null;
65        public Dictionary<long, Maschinfo> MachineHierarchy
66        {
67            get { return machineHierarchy; }
68            set
69            {
70                lock (this)
71                {
72                    machineHierarchy = value;
73                }
74                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
75                                                {
76                                                    machineTree.DataContext = machineHierarchy;
77                                                    machineTree.Items.Refresh();
78                                                }, null);
79            }
80        }
81
82        #region Information
83
84        private string days = "??? Days";
85        public string Days
86        {
87            get { return days; }
88            set
89            {
90                lock (this)
91                {
92                    days = value;
93                }
94
95                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
96                {
97                    WorkingDays.Content = days;
98                }, null);
99            }
100        }
101
102        private BigInteger totalBlocks = 0;
103        public BigInteger TotalBlocks
104        {
105            get { return totalBlocks; }
106            set
107            {
108                lock (this)
109                {
110                    totalBlocks = value;
111                }
112
113                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
114                {
115                    TotalAmountOfBlocks.Content = totalBlocks;
116                }, null);
117            }
118        }
119
120        private BigInteger calculatedBlocks = 0;
121        public BigInteger CalculatedBlocks
122        {
123            get { return calculatedBlocks; }
124            set
125            {
126                lock (this)
127                {
128                    calculatedBlocks = value;
129                }
130
131                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
132                {
133                    TotalBlocksTested.Content = calculatedBlocks;
134                }, null);
135            }
136        }
137
138        private BigInteger totalKeys = 0;
139        public BigInteger TotalKeys
140        {
141            get { return totalKeys; }
142            set
143            {
144                lock (this)
145                {
146                    totalKeys = value;
147                }
148
149                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
150                {
151                    TotalAmountOfKeys.Content = totalKeys;
152                }, null);
153            }
154        }
155
156        private BigInteger calculatedKeys = 0;
157        public BigInteger CalculatedKeys
158        {
159            get { return calculatedKeys; }
160            set
161            {
162                lock (this)
163                {
164                    calculatedKeys = value;
165                }
166
167                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
168                {
169                    TotalKeysTested.Content = calculatedKeys;
170                }, null);
171            }
172        }
173
174        private double percent = 0;
175        public double Percent
176        {
177            get { return percent; }
178            set
179            {
180                lock (this)
181                {
182                    if (totalBlocks != 0)
183                    {
184                        percent = Math.Round((value/(double) totalBlocks)*10000)/100;
185                    }
186                    else
187                    {
188                        percent = 0;
189                    }
190                }
191
192                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
193                {
194                    PercentsComplete.Content = percent + " %";
195                }, null);
196            }
197        }
198
199        private BigInteger users = 1;
200        public BigInteger Users
201        {
202            get { return users; }
203            set
204            {
205                lock (this)
206                {
207                    users = value;
208                }
209
210                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
211                {
212                    UserCount.Content = users + " users are working on this job";
213                }, null);
214            }
215        }
216
217        private string beeusers = "-";
218        public string BeeUsers
219        {
220            get { return beeusers; }
221            set
222            {
223                lock (this)
224                {
225                    beeusers = value;
226                }
227
228                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
229                {
230                    BestUser.Content = " Top user: " + beeusers;
231                }, null);
232            }
233        }
234
235        private BigInteger machines = 1;
236        public BigInteger Machines
237        {
238            get { return machines; }
239            set
240            {
241                lock (this)
242                {
243                    machines = value;
244                }
245
246                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
247                {
248                    MachineCount.Content = machines + " machines are working on this job";
249                }, null);
250            }
251        }
252
253        private string beemachines = "-";
254        public string BeeMachines
255        {
256            get { return beemachines; }
257            set
258            {
259                lock (this)
260                {
261                    beemachines = value;
262                }
263
264                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
265                {
266                    BestMachine.Content = " Top machine: " + beemachines;
267                }, null);
268            }
269        }
270
271        private double rate = 0;
272        public double SetRate
273        {
274            get { return percent; }
275            set
276            {
277                lock (this)
278                {
279                    if (false)
280                    {
281                        rate = 0;
282                    }
283                    else
284                    {
285                        rate = 0;
286                    }
287                }
288
289                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
290                {
291                    Rate.Content = " Overall rate: " + rate + " key/sec";
292                }, null);
293            }
294        }
295
296        #endregion
297
298        private void Button_Click(object sender, RoutedEventArgs e)
299        {
300            Button b = sender as Button;
301
302            if(statisticsTree.ItemContainerStyle == null)
303            {
304                b.Content = "Expand";
305                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
306            }
307
308            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle"] as Style))
309            {
310                b.Content = "Expand";
311                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
312                return;
313            }
314
315            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle2"] as Style))
316            {
317                b.Content = "Collapse";
318                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle"] as Style;
319                return;
320            }
321        }
322    }
323
324    #region Converters
325    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
326    class InformationToProgressConverter : IValueConverter
327    {
328        public StatisticsPresentation StatisticsPresentation { get; set; }
329
330        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
331        {
332            if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
333            {
334                lock (StatisticsPresentation)
335                {
336                    double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
337                    double vCount = ((Dictionary<long, Information>) value).Sum(i => i.Value.Count);
338                    return vCount/allCount;
339                }
340            }
341            else
342            {
343                return 0;
344            }
345        }
346
347        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
348        {
349            throw new NotImplementedException();
350        }
351    }
352
353    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
354    class MachineSumToProgressConverter : IValueConverter
355    {
356        public StatisticsPresentation StatisticsPresentation { get; set; }
357
358        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
359        {
360            if (StatisticsPresentation != null && StatisticsPresentation.MachineHierarchy != null)
361            {
362                lock (StatisticsPresentation)
363                {
364                    double allCount = (StatisticsPresentation.MachineHierarchy).Sum(i => i.Value.Sum);
365                    double vCount = (int) value;
366                    return vCount/allCount;
367                }
368            }
369            else
370            {
371                return 0;
372            }
373        }
374
375        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
376        {
377            throw new NotImplementedException();
378        }
379    }
380
381    [ValueConversion(typeof(string), typeof(Double))]
382    class ChunkSumConverter : IValueConverter
383    {
384        public StatisticsPresentation StatisticsPresentation { get; set; }
385
386        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
387        {
388            if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
389            {
390                lock (StatisticsPresentation)
391                {
392                    string key = (string) value;
393                    var data = (StatisticsPresentation.Statistics)[key];
394                    return data.Sum(i => i.Value.Count);
395                }
396            }
397            else
398            {
399                return 0;
400            }
401        }
402
403        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
404        {
405            throw new NotImplementedException();
406        }
407    }
408
409    [ValueConversion(typeof(string), typeof(string))]
410    class StringLengthConverter : IValueConverter
411    {
412        public StatisticsPresentation StatisticsPresentation { get; set; }
413
414        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
415        {
416            if (StatisticsPresentation != null)
417            {
418                string name = (string)value;
419               
420                if(name.Length < 13)
421                {
422                    return name;
423                }
424                else
425                {
426                    return string.Format("{0}...", name.Substring(0, 9));
427                }
428            }
429            else
430            {
431                return "";
432            }
433        }
434
435        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
436        {
437            throw new NotImplementedException();
438        }
439    }
440
441    [ValueConversion(typeof(Int32), typeof(Double))]
442    class InformationToProgressConverter2 : IValueConverter
443    {
444        public StatisticsPresentation StatisticsPresentation { get; set; }
445
446        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
447        {
448            if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
449            {
450                lock (StatisticsPresentation)
451                {
452                    double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
453                    return (int) value/allCount;
454                }
455            }
456            else
457            {
458                return 0;
459            }
460        }
461
462        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
463        {
464            throw new NotImplementedException();
465        }
466    }
467
468    public class ColorToDateConverter : IMultiValueConverter
469    {
470        public static SolidColorBrush[] AlternationColors = {Brushes.LimeGreen, Brushes.Red, Brushes.Blue};
471
472        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
473        {
474            DateTime date = (DateTime) values[0];
475            SolidColorBrush brush = ColorToDateConverter.AlternationColors[(int) values[1]].Clone();
476            TimeSpan diff = DateTime.UtcNow.Subtract(date);
477
478            Color color;
479            if (diff >= TimeSpan.FromDays(4))
480            {
481                color = Color.FromArgb(
482                    (byte)50,
483                    brush.Color.R, 
484                    brush.Color.G, 
485                    brush.Color.B);
486
487                brush.Color = color;
488                return brush;
489            }
490
491            if (diff >= TimeSpan.FromDays(3))
492            {
493                 color = Color.FromArgb(
494                    (byte)100,
495                    brush.Color.R, 
496                    brush.Color.G, 
497                    brush.Color.B);
498
499                brush.Color = color;
500                return brush;
501            }
502
503            if (diff >= TimeSpan.FromDays(2))
504            {
505                 color = Color.FromArgb(
506                    (byte)150,
507                    brush.Color.R, 
508                    brush.Color.G, 
509                    brush.Color.B);
510
511                brush.Color = color;
512                return brush;
513            }
514
515            if (diff >= TimeSpan.FromDays(1))
516            {
517                color = Color.FromArgb(
518                    (byte)200,
519                    brush.Color.R, 
520                    brush.Color.G, 
521                    brush.Color.B);
522
523                brush.Color = color;
524                return brush;
525            }
526
527            if (diff >= TimeSpan.FromDays(0))
528            {
529
530                color = Color.FromArgb(
531                    (byte)255,
532                    brush.Color.R,
533                    brush.Color.G,
534                    brush.Color.B);
535
536                brush.Color = color;
537                return brush;
538            }
539            return Brushes.AntiqueWhite;
540        }
541
542        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
543        {
544            throw new NotImplementedException();
545        }
546    }
547    #endregion
548
549}
Note: See TracBrowser for help on using the repository browser.