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

Last change on this file since 2685 was 2685, checked in by nolte, 11 years ago
  • Gave all Information Elements their values
  • ToolTip over LastTimeUpdated shows NextTimeUpdate
  • Rearranged Information Gui Elements for a better View
File size: 24.6 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            ((MachineSumToProgressConverter)Resources["MachineSumToProgressConverter"]).StatisticsPresentation = this;
37            ((MaxDateConverter)Resources["MaxDateConverter"]).StatisticsPresentation = this;
38            ((TimeConverter)Resources["TimeConverter"]).StatisticsPresentation = this;
39            ((StringLengthConverter)Resources["StringLengthConverter"]).StatisticsPresentation = this;
40           
41        }
42
43        private Dictionary<string, Dictionary<long, Information>> statistics = null;
44        public Dictionary<string, Dictionary<long, Information>> Statistics
45        {
46            get { return statistics; }
47            set
48            {
49                lock (this)
50                {
51                    statistics = value;
52                }
53                if (statistics != null)
54                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
55                                               {
56                                                   try
57                                                   {
58                                                       if (statistics != null)
59                                                       {
60                                                           statisticsTree.DataContext = statistics;
61                                                           statisticsTree.Items.Refresh();
62                                                       }
63                                                   }
64                                                   catch (Exception)
65                                                   {
66                                                   }
67                                               }, null);
68
69            }
70        }
71
72        private Dictionary<long, Maschinfo> machineHierarchy = null;
73        public Dictionary<long, Maschinfo> MachineHierarchy
74        {
75            get { return machineHierarchy; }
76            set
77            {
78                lock (this)
79                {
80                    machineHierarchy = value;
81                }
82                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
83                                                {
84                                                    try
85                                                    {
86                                                        if (machineHierarchy != null)
87                                                        {
88                                                            machineTree.DataContext = machineHierarchy;
89                                                            machineTree.Items.Refresh();
90                                                        }
91                                                    }
92                                                    catch (Exception)
93                                                    {
94                                                    }
95                                                }, null);
96            }
97        }
98
99        #region Information
100
101        private string days = "??? Days";
102        public string Days
103        {
104            get { return days; }
105            set
106            {
107                lock (this)
108                {
109                    days = value;
110                }
111
112                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
113                {
114                    if (days != null)
115                        WorkingDays.Content = days;
116                }, null);
117            }
118        }
119
120        private string updatetime = "Last__Update__Time: -";
121        public string UpdateTime
122        {
123            get { return updatetime; }
124            set
125            {
126                lock (this)
127                {
128                    updatetime = value;
129                }
130
131                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
132                {
133                    if (days != null)
134                        LastUpdateTime.Content = updatetime;
135                }, null);
136            }
137        }
138
139        private string nextupdatetime = "Next__Update__Time: -";
140        public string NextUpdateTime
141        {
142            get { return nextupdatetime; }
143            set
144            {
145                lock (this)
146                {
147                    nextupdatetime = value;
148                }
149
150                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
151                {
152                    if (days != null)
153                        LastUpdateTime.ToolTip = nextupdatetime;
154                }, null);
155            }
156        }
157
158        private BigInteger totalBlocks = 0;
159        public BigInteger TotalBlocks
160        {
161            get { return totalBlocks; }
162            set
163            {
164                lock (this)
165                {
166                    totalBlocks = value;
167                }
168
169                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
170                {
171                    TotalAmountOfBlocks.Content = totalBlocks;
172                }, null);
173            }
174        }
175
176        private BigInteger calculatedBlocks = 0;
177        public BigInteger CalculatedBlocks
178        {
179            get { return calculatedBlocks; }
180            set
181            {
182                lock (this)
183                {
184                    calculatedBlocks = value;
185                }
186
187                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
188                {
189                    TotalBlocksTested.Content = calculatedBlocks;
190                }, null);
191            }
192        }
193
194        private BigInteger totalKeys = 0;
195        public BigInteger TotalKeys
196        {
197            get { return totalKeys; }
198            set
199            {
200                lock (this)
201                {
202                    totalKeys = value;
203                }
204
205                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
206                {
207                    TotalAmountOfKeys.Content = totalKeys;
208                }, null);
209            }
210        }
211
212        private BigInteger calculatedKeys = 0;
213        public BigInteger CalculatedKeys
214        {
215            get { return calculatedKeys; }
216            set
217            {
218                lock (this)
219                {
220                    calculatedKeys = value;
221                }
222
223                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
224                {
225                    TotalKeysTested.Content = calculatedKeys;
226                }, null);
227            }
228        }
229
230        private double percent = 0;
231        public double Percent
232        {
233            get { return percent; }
234            set
235            {
236                lock (this)
237                {
238                    if (totalBlocks != 0)
239                    {
240                        percent = Math.Round((value/(double) totalBlocks)*Math.Pow(10, totalKeys.ToString().Length)) / Math.Pow(10, totalKeys.ToString().Length-2);
241                    }
242                    else
243                    {
244                        percent = 0;
245                    }
246                }
247
248                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
249                {
250                     PercentsComplete.Content = string.Format("{0:0."+ getCommaPlaces() +"} %", percent);
251                }, null);
252            }
253        }
254
255        private string getCommaPlaces()
256        {
257            var l = totalKeys.ToString().Length;
258
259            if(l < 5)
260            {
261                return "####";
262            }
263            else if(l < 10)
264            {
265                return "########";
266            }
267            else
268            {
269                return "############";
270            }           
271        }
272
273        private BigInteger users = 1;
274        public BigInteger Users
275        {
276            get { return users; }
277            set
278            {
279                lock (this)
280                {
281                    users = value;
282                }
283
284                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
285                {
286                    UserCount.Content = users;
287                }, null);
288            }
289        }
290
291        private BigInteger currentusers = 1;
292        public BigInteger CurrentUsers
293        {
294            get { return currentusers; }
295            set
296            {
297                lock (this)
298                {
299                    if (value > 0)
300                    {
301                        currentusers = value;
302                    }
303                }
304
305                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
306                {
307                    CurrentUserCount.Content = currentusers;
308                }, null);
309            }
310        }
311
312        private string beeusers = "-";
313        public string BeeUsers
314        {
315            get { return beeusers; }
316            set
317            {
318                lock (this)
319                {
320                    beeusers = value;
321                }
322
323                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
324                {
325                    if (beeusers != null)
326                        BestUser.Content = beeusers;
327                }, null);
328            }
329        }
330
331        private BigInteger machines = 1;
332        public BigInteger Machines
333        {
334            get { return machines; }
335            set
336            {
337                lock (this)
338                {
339                    machines = value;
340                }
341
342                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
343                {
344                    MachineCount.Content = machines;
345                }, null);
346            }
347        }
348
349        private BigInteger currentmachines = 1;
350        public BigInteger CurrentMachines
351        {
352            get { return currentmachines; }
353            set
354            {
355                lock (this)
356                {
357                    if (value > 0)
358                    {
359                        currentmachines = value;
360                    }
361                }
362
363                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
364                {
365                    CurrentMachineCount.Content = currentmachines;
366                }, null);
367            }
368        }
369
370        private string beemachines = "-";
371        public string BeeMachines
372        {
373            get { return beemachines; }
374            set
375            {
376                lock (this)
377                {
378                    beemachines = value;
379                }
380
381                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
382                {
383                    if (beemachines != null)
384                        BestMachine.Content = beemachines;
385                }, null);
386            }
387        }
388
389        private BigInteger rate = 0;
390        public BigInteger SetRate
391        {
392            get { return rate; }
393            set
394            {
395                lock (this)
396                {
397                    rate = value;
398                }
399
400                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
401                {
402                    Rate.Content = rate + " key/sec";
403                }, null);
404            }
405        }
406
407        private BigInteger currentrate = 0;
408        public BigInteger SetCurrentRate
409        {
410            get { return currentrate; }
411            set
412            {
413                lock (this)
414                {
415                    currentrate = value;
416                }
417
418                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
419                {
420                    CurrentRate.Content = currentrate + " key/sec";
421                }, null);
422            }
423        }
424
425        #endregion
426
427        private void Button_Click(object sender, RoutedEventArgs e)
428        {
429            Button b = sender as Button;
430
431            if(statisticsTree.ItemContainerStyle == null)
432            {
433                b.Content = "Expand";
434                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
435            }
436
437            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle"] as Style))
438            {
439                b.Content = "Expand";
440                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
441                return;
442            }
443
444            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle2"] as Style))
445            {
446                b.Content = "Collapse";
447                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle"] as Style;
448                return;
449            }
450        }
451
452        private QuickWatch ParentQuickWatch
453        {
454            get { return (QuickWatch) ((Grid) ((Grid) Parent).Parent).Parent; }
455        }
456
457        private void SwitchView(object sender, RoutedEventArgs e)
458        {
459            ParentQuickWatch.ShowStatistics = false;
460        }
461    }
462
463    #region Converters
464    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
465    class InformationToProgressConverter : IValueConverter
466    {
467        public StatisticsPresentation StatisticsPresentation { get; set; }
468
469        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
470        {
471            try
472            {
473                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
474                {
475                    lock (StatisticsPresentation)
476                    {
477                        double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
478                        double vCount = ((Dictionary<long, Information>)value).Sum(i => i.Value.Count);
479                        return vCount / allCount;
480                    }
481                }
482            }
483            catch (Exception)
484            {
485            }
486            return 0.0;
487        }
488
489        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
490        {
491            throw new NotImplementedException();
492        }
493    }
494
495    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
496    class MachineSumToProgressConverter : IValueConverter
497    {
498        public StatisticsPresentation StatisticsPresentation { get; set; }
499
500        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
501        {
502            try
503            {
504                if (StatisticsPresentation != null && StatisticsPresentation.MachineHierarchy != null)
505                {
506                    lock (StatisticsPresentation)
507                    {
508                        double allCount = (StatisticsPresentation.MachineHierarchy).Sum(i => i.Value.Sum);
509                        double vCount = (int)value;
510                        return vCount / allCount;
511                    }
512                }
513            }
514            catch (Exception)
515            {
516            }
517            return 0.0;
518        }
519
520        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
521        {
522            throw new NotImplementedException();
523        }
524    }
525
526    [ValueConversion(typeof(string), typeof(Double))]
527    class ChunkSumConverter : IValueConverter
528    {
529        public StatisticsPresentation StatisticsPresentation { get; set; }
530
531        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
532        {
533            try
534            {
535                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
536                {
537                    lock (StatisticsPresentation)
538                    {
539                        string key = (string)value;
540                        var data = (StatisticsPresentation.Statistics)[key];
541                        return data.Sum(i => i.Value.Count);
542                    }
543                }
544            }
545            catch (Exception)
546            {
547            }
548            return 0.0;
549        }
550
551        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
552        {
553            throw new NotImplementedException();
554        }
555    }
556
557    [ValueConversion(typeof(string), typeof(string))]
558    class StringLengthConverter : IValueConverter
559    {
560        public StatisticsPresentation StatisticsPresentation { get; set; }
561
562        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
563        {
564            if (value != null && value is string)
565            {
566                string name = (string)value;
567                if (name.Length < 13)
568                {
569                    return name;
570                }
571                return string.Format("{0}...", name.Substring(0, 9));
572            }
573            return "";
574        }
575
576        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
577        {
578            throw new NotImplementedException();
579        }
580    }
581
582    [ValueConversion(typeof(Int32), typeof(Double))]
583    class InformationToProgressConverter2 : IValueConverter
584    {
585        public StatisticsPresentation StatisticsPresentation { get; set; }
586
587        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
588        {
589            try
590            {
591                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
592                {
593                    lock (StatisticsPresentation)
594                    {
595                        double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
596                        return (int)value / allCount;
597                    }
598                }
599            }
600            catch (Exception)
601            {
602            }
603            return 0.0;
604        }
605
606        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
607        {
608            throw new NotImplementedException();
609        }
610    }
611
612    [ValueConversion(typeof(String), typeof(DateTime))]
613    class MaxDateConverter : IValueConverter
614    {
615        public StatisticsPresentation StatisticsPresentation { get; set; }
616
617        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
618        {
619            try
620            {
621                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
622                {
623                    lock (StatisticsPresentation)
624                    {
625                        var max = DateTime.MinValue;
626                        var machines = StatisticsPresentation.Statistics[(string)value];
627                        foreach (var id in machines.Keys.Where(id => machines[id].Date > max))
628                        {
629                            max = machines[id].Date;
630                        }
631                        return max.ToLocalTime();
632                    }
633                }
634            }
635            catch (Exception)
636            {
637            }
638            return DateTime.UtcNow.ToLocalTime();
639        }
640
641        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
642        {
643            throw new NotImplementedException();
644        }
645    }
646
647    [ValueConversion(typeof(DateTime), typeof(DateTime))]
648    class TimeConverter : IValueConverter
649    {
650        public StatisticsPresentation StatisticsPresentation { get; set; }
651
652        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
653        {
654            try
655            {
656                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
657                {
658                    lock (StatisticsPresentation)
659                    {
660                     
661                        return ((DateTime)value).ToLocalTime();
662                    }
663                }
664            }
665            catch (Exception)
666            {
667            }
668            return DateTime.UtcNow.ToLocalTime();
669        }
670
671        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
672        {
673            throw new NotImplementedException();
674        }
675    }
676
677    public class ColorToDateConverter : IMultiValueConverter
678    {
679        public static SolidColorBrush[] AlternationColors = {Brushes.LimeGreen, Brushes.Red, Brushes.Blue};
680
681        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
682        {
683            try
684            {
685                DateTime date = (DateTime)values[0];
686                SolidColorBrush brush = ColorToDateConverter.AlternationColors[(int)values[1]].Clone();
687                TimeSpan diff = DateTime.UtcNow.Subtract(date);
688
689                Color color;
690                if (diff >= TimeSpan.FromDays(4))
691                {
692                    color = Color.FromArgb(
693                        (byte)50,
694                        brush.Color.R,
695                        brush.Color.G,
696                        brush.Color.B);
697
698                    brush.Color = color;
699                    return brush;
700                }
701
702                if (diff >= TimeSpan.FromDays(3))
703                {
704                    color = Color.FromArgb(
705                       (byte)100,
706                       brush.Color.R,
707                       brush.Color.G,
708                       brush.Color.B);
709
710                    brush.Color = color;
711                    return brush;
712                }
713
714                if (diff >= TimeSpan.FromDays(2))
715                {
716                    color = Color.FromArgb(
717                       (byte)150,
718                       brush.Color.R,
719                       brush.Color.G,
720                       brush.Color.B);
721
722                    brush.Color = color;
723                    return brush;
724                }
725
726                if (diff >= TimeSpan.FromDays(1))
727                {
728                    color = Color.FromArgb(
729                        (byte)200,
730                        brush.Color.R,
731                        brush.Color.G,
732                        brush.Color.B);
733
734                    brush.Color = color;
735                    return brush;
736                }
737
738                if (diff >= TimeSpan.FromDays(0))
739                {
740
741                    color = Color.FromArgb(
742                        (byte)255,
743                        brush.Color.R,
744                        brush.Color.G,
745                        brush.Color.B);
746
747                    brush.Color = color;
748                    return brush;
749                }
750            }
751            catch (Exception)
752            {
753            }
754
755            return Brushes.AntiqueWhite;
756        }
757
758        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
759        {
760            throw new NotImplementedException();
761        }
762    }
763    #endregion
764
765}
Note: See TracBrowser for help on using the repository browser.