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

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

Fixed Top-User logic

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