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

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

Added more Information to the Information-Tag of the
StatisticPresentation.

File size: 15.8 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;
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 = 0;
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 BigInteger machines = 0;
218        public BigInteger Machines
219        {
220            get { return machines; }
221            set
222            {
223                lock (this)
224                {
225                    machines = value;
226                }
227
228                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
229                {
230                    MachineCount.Content = machines + " machines are working on this job";
231                }, null);
232            }
233        }
234
235        #endregion
236
237        private void Button_Click(object sender, RoutedEventArgs e)
238        {
239            Button b = sender as Button;
240
241            if(statisticsTree.ItemContainerStyle == null)
242            {
243                b.Content = "Expand";
244                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
245            }
246
247            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle"] as Style))
248            {
249                b.Content = "Expand";
250                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
251                return;
252            }
253
254            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle2"] as Style))
255            {
256                b.Content = "Collapse";
257                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle"] as Style;
258                return;
259            }
260        }
261    }
262
263    #region Converters
264    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
265    class InformationToProgressConverter : IValueConverter
266    {
267        public StatisticsPresentation StatisticsPresentation { get; set; }
268
269        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
270        {
271            if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
272            {
273                lock (StatisticsPresentation)
274                {
275                    double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
276                    double vCount = ((Dictionary<long, Information>) value).Sum(i => i.Value.Count);
277                    return vCount/allCount;
278                }
279            }
280            else
281            {
282                return 0;
283            }
284        }
285
286        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
287        {
288            throw new NotImplementedException();
289        }
290    }
291
292    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
293    class MachineSumToProgressConverter : IValueConverter
294    {
295        public StatisticsPresentation StatisticsPresentation { get; set; }
296
297        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
298        {
299            if (StatisticsPresentation != null && StatisticsPresentation.MachineHierarchy != null)
300            {
301                lock (StatisticsPresentation)
302                {
303                    double allCount = (StatisticsPresentation.MachineHierarchy).Sum(i => i.Value.Sum);
304                    double vCount = (int) value;
305                    return vCount/allCount;
306                }
307            }
308            else
309            {
310                return 0;
311            }
312        }
313
314        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
315        {
316            throw new NotImplementedException();
317        }
318    }
319
320    [ValueConversion(typeof(string), typeof(Double))]
321    class ChunkSumConverter : IValueConverter
322    {
323        public StatisticsPresentation StatisticsPresentation { get; set; }
324
325        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
326        {
327            if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
328            {
329                lock (StatisticsPresentation)
330                {
331                    string key = (string) value;
332                    var data = (StatisticsPresentation.Statistics)[key];
333                    return data.Sum(i => i.Value.Count);
334                }
335            }
336            else
337            {
338                return 0;
339            }
340        }
341
342        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
343        {
344            throw new NotImplementedException();
345        }
346    }
347
348    [ValueConversion(typeof(string), typeof(string))]
349    class StringLengthConverter : IValueConverter
350    {
351        public StatisticsPresentation StatisticsPresentation { get; set; }
352
353        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
354        {
355            if (StatisticsPresentation != null)
356            {
357                string name = (string)value;
358               
359                if(name.Length < 13)
360                {
361                    return name;
362                }
363                else
364                {
365                    return string.Format("{0}...", name.Substring(0, 9));
366                }
367            }
368            else
369            {
370                return "";
371            }
372        }
373
374        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
375        {
376            throw new NotImplementedException();
377        }
378    }
379
380    [ValueConversion(typeof(Int32), typeof(Double))]
381    class InformationToProgressConverter2 : IValueConverter
382    {
383        public StatisticsPresentation StatisticsPresentation { get; set; }
384
385        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
386        {
387            if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
388            {
389                lock (StatisticsPresentation)
390                {
391                    double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
392                    return (int) value/allCount;
393                }
394            }
395            else
396            {
397                return 0;
398            }
399        }
400
401        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
402        {
403            throw new NotImplementedException();
404        }
405    }
406
407    public class ColorToDateConverter : IMultiValueConverter
408    {
409        public static SolidColorBrush[] AlternationColors = {Brushes.LimeGreen, Brushes.Red, Brushes.Blue};
410
411        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
412        {
413            DateTime date = (DateTime) values[0];
414            SolidColorBrush brush = ColorToDateConverter.AlternationColors[(int) values[1]].Clone();
415            TimeSpan diff = DateTime.UtcNow.Subtract(date);
416
417            Color color;
418            if (diff >= TimeSpan.FromDays(4))
419            {
420                color = Color.FromArgb(
421                    (byte)50,
422                    brush.Color.R, 
423                    brush.Color.G, 
424                    brush.Color.B);
425
426                brush.Color = color;
427                return brush;
428            }
429
430            if (diff >= TimeSpan.FromDays(3))
431            {
432                 color = Color.FromArgb(
433                    (byte)100,
434                    brush.Color.R, 
435                    brush.Color.G, 
436                    brush.Color.B);
437
438                brush.Color = color;
439                return brush;
440            }
441
442            if (diff >= TimeSpan.FromDays(2))
443            {
444                 color = Color.FromArgb(
445                    (byte)150,
446                    brush.Color.R, 
447                    brush.Color.G, 
448                    brush.Color.B);
449
450                brush.Color = color;
451                return brush;
452            }
453
454            if (diff >= TimeSpan.FromDays(1))
455            {
456                color = Color.FromArgb(
457                    (byte)200,
458                    brush.Color.R, 
459                    brush.Color.G, 
460                    brush.Color.B);
461
462                brush.Color = color;
463                return brush;
464            }
465
466            if (diff >= TimeSpan.FromDays(0))
467            {
468
469                color = Color.FromArgb(
470                    (byte)255,
471                    brush.Color.R,
472                    brush.Color.G,
473                    brush.Color.B);
474
475                brush.Color = color;
476                return brush;
477            }
478            return Brushes.AntiqueWhite;
479        }
480
481        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
482        {
483            throw new NotImplementedException();
484        }
485    }
486    #endregion
487
488}
Note: See TracBrowser for help on using the repository browser.