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

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

Statistic Update

  • Progress Bars using full length of Screen
  • Last Working Time Bubble/Skull
  • Culture Related Time Formation
  • Some DE-ENG Workings (further changes following soon)
File size: 33.0 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            ((DateFalseVisibleConverter1)Resources["DateFalseVisibleConverter1"]).StatisticsPresentation = this;
42            ((DateTrueVisibleConverter1)Resources["DateTrueVisibleConverter1"]).StatisticsPresentation = this;
43            ((DateFalseVisibleConverter2)Resources["DateFalseVisibleConverter2"]).StatisticsPresentation = this;
44            ((DateTrueVisibleConverter2)Resources["DateTrueVisibleConverter2"]).StatisticsPresentation = this;
45            ((DateToColorConverter1)Resources["DateToColorConverter1"]).StatisticsPresentation = this;
46            ((DateToColorConverter2)Resources["DateToColorConverter2"]).StatisticsPresentation = this;
47           
48        }
49
50        private Dictionary<string, Dictionary<long, Information>> statistics = null;
51        public Dictionary<string, Dictionary<long, Information>> Statistics
52        {
53            get { return statistics; }
54            set
55            {
56                lock (this)
57                {
58                    statistics = value;
59                }
60                if (statistics != null)
61                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
62                                               {
63                                                   try
64                                                   {
65                                                       if (statistics != null)
66                                                       {
67                                                           statisticsTree.DataContext = statistics;
68                                                           statisticsTree.Items.Refresh();
69                                                       }
70                                                   }
71                                                   catch (Exception)
72                                                   {
73                                                   }
74                                               }, null);
75
76            }
77        }
78
79        private Dictionary<long, Maschinfo> machineHierarchy = null;
80        public Dictionary<long, Maschinfo> MachineHierarchy
81        {
82            get { return machineHierarchy; }
83            set
84            {
85                lock (this)
86                {
87                    machineHierarchy = value;
88                }
89                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
90                                                {
91                                                    try
92                                                    {
93                                                        if (machineHierarchy != null)
94                                                        {
95                                                            machineTree.DataContext = machineHierarchy;
96                                                            machineTree.Items.Refresh();
97                                                        }
98                                                    }
99                                                    catch (Exception)
100                                                    {
101                                                    }
102                                                }, null);
103            }
104        }
105
106        #region Information
107
108        private string days = "??? Days";
109        public string Days
110        {
111            get { return days; }
112            set
113            {
114                lock (this)
115                {
116                    days = value;
117                }
118
119                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
120                {
121                    if (days != null)
122                        WorkingDays.Content = days;
123                }, null);
124            }
125        }
126
127        private string updatetime = "Last__Update__Time: -";
128        public string UpdateTime
129        {
130            get { return updatetime; }
131            set
132            {
133                lock (this)
134                {
135                    updatetime = value;
136                }
137
138                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
139                {
140                    if (days != null)
141                        LastUpdateTime.Content = updatetime;
142                }, null);
143            }
144        }
145
146        private string nextupdatetime = "Next__Update__Time: -";
147        public string NextUpdateTime
148        {
149            get { return nextupdatetime; }
150            set
151            {
152                lock (this)
153                {
154                    nextupdatetime = value;
155                }
156
157                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
158                {
159                    if (days != null)
160                        LastUpdateTime.ToolTip = nextupdatetime;
161                }, null);
162            }
163        }
164
165        private BigInteger totalBlocks = 0;
166        public BigInteger TotalBlocks
167        {
168            get { return totalBlocks; }
169            set
170            {
171                lock (this)
172                {
173                    totalBlocks = value;
174                }
175
176                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
177                {
178                    TotalAmountOfBlocks.Content = string.Format("{0:0,0}", totalBlocks);
179                }, null);
180            }
181        }
182
183        private BigInteger calculatedBlocks = 0;
184        public BigInteger CalculatedBlocks
185        {
186            get { return calculatedBlocks; }
187            set
188            {
189                lock (this)
190                {
191                    calculatedBlocks = value;
192                }
193
194                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
195                {
196                    TotalBlocksTested.Content = string.Format("{0:0,0}", calculatedBlocks);
197                }, null);
198            }
199        }
200
201        private BigInteger totalKeys = 0;
202        public BigInteger TotalKeys
203        {
204            get { return totalKeys; }
205            set
206            {
207                lock (this)
208                {
209                    totalKeys = value;
210                }
211
212                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
213                {
214                    TotalAmountOfKeys.Content = string.Format("{0:0,0}", totalKeys);
215                }, null);
216            }
217        }
218
219        private BigInteger calculatedKeys = 0;
220        public BigInteger CalculatedKeys
221        {
222            get { return calculatedKeys; }
223            set
224            {
225                lock (this)
226                {
227                    calculatedKeys = value;
228                }
229
230                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
231                {
232                    TotalKeysTested.Content = string.Format("{0:0,0}", calculatedKeys);
233                }, null);
234            }
235        }
236
237        private double percent = 0;
238        public double Percent
239        {
240            get { return percent; }
241            set
242            {
243                lock (this)
244                {
245                    if (totalBlocks != 0)
246                    {
247                        percent = Math.Round((value/(double) totalBlocks)*Math.Pow(10, totalKeys.ToString().Length)) / Math.Pow(10, totalKeys.ToString().Length-2);
248                    }
249                    else
250                    {
251                        percent = 0;
252                    }
253                }
254
255                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
256                {
257                     PercentsComplete.Content = string.Format("{0:0."+ getCommaPlaces() +"} %", percent);
258                }, null);
259            }
260        }
261
262        private string getCommaPlaces()
263        {
264            var l = totalKeys.ToString().Length;
265
266            if(l < 5)
267            {
268                return "####";
269            }
270            else if(l < 10)
271            {
272                return "########";
273            }
274            else
275            {
276                return "############";
277            }           
278        }
279
280        private BigInteger users = 1;
281        public BigInteger Users
282        {
283            get { return users; }
284            set
285            {
286                lock (this)
287                {
288                    users = value;
289                }
290
291                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
292                {
293                    UserCount.Content = users;
294                }, null);
295            }
296        }
297
298        private BigInteger currentusers = 1;
299        public BigInteger CurrentUsers
300        {
301            get { return currentusers; }
302            set
303            {
304                lock (this)
305                {
306                    if (value > 0)
307                    {
308                        currentusers = value;
309                    }
310                }
311
312                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
313                {
314                    CurrentUserCount.Content = currentusers;
315                }, null);
316            }
317        }
318
319        private string beeusers = "-";
320        public string BeeUsers
321        {
322            get { return beeusers; }
323            set
324            {
325                lock (this)
326                {
327                    beeusers = value;
328                }
329
330                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
331                {
332                    if (beeusers != null)
333                        BestUser.Content = beeusers;
334                }, null);
335            }
336        }
337
338        private BigInteger machines = 1;
339        public BigInteger Machines
340        {
341            get { return machines; }
342            set
343            {
344                lock (this)
345                {
346                    machines = value;
347                }
348
349                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
350                {
351                    MachineCount.Content = machines;
352                }, null);
353            }
354        }
355
356        private BigInteger currentmachines = 1;
357        public BigInteger CurrentMachines
358        {
359            get { return currentmachines; }
360            set
361            {
362                lock (this)
363                {
364                    if (value > 0)
365                    {
366                        currentmachines = value;
367                    }
368                }
369
370                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
371                {
372                    CurrentMachineCount.Content = currentmachines;
373                }, null);
374            }
375        }
376
377        private string beemachines = "-";
378        public string BeeMachines
379        {
380            get { return beemachines; }
381            set
382            {
383                lock (this)
384                {
385                    beemachines = value;
386                }
387
388                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
389                {
390                    if (beemachines != null)
391                        BestMachine.Content = beemachines;
392                }, null);
393            }
394        }
395
396        private BigInteger rate = 0;
397        public BigInteger SetRate
398        {
399            get { return rate; }
400            set
401            {
402                lock (this)
403                {
404                    rate = value;
405                }
406
407                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
408                {
409                    Rate.Content = string.Format(KeySearcher.Properties.Resources.StatisticsPresentation_SetCurrentRate, rate);
410                }, null);
411            }
412        }
413
414        private BigInteger currentrate = 0;
415        public BigInteger SetCurrentRate
416        {
417            get { return currentrate; }
418            set
419            {
420                lock (this)
421                {
422                    currentrate = value;
423                }
424
425                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
426                {
427                    CurrentRate.Content = string.Format(KeySearcher.Properties.Resources.StatisticsPresentation_SetCurrentRate, currentrate);
428                }, null);
429            }
430        }
431
432        #endregion
433
434        private void Button_Click(object sender, RoutedEventArgs e)
435        {
436            Button b = sender as Button;
437
438            if(statisticsTree.ItemContainerStyle == null)
439            {
440                b.Content = "Expand";
441                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
442            }
443
444            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle"] as Style))
445            {
446                b.Content = "Expand";
447                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle2"] as Style;
448                return;
449            }
450
451            if (statisticsTree.ItemContainerStyle.Equals(this.Resources["ItemStyle2"] as Style))
452            {
453                b.Content = "Collapse";
454                statisticsTree.ItemContainerStyle = this.Resources["ItemStyle"] as Style;
455                return;
456            }
457        }
458
459        private QuickWatch ParentQuickWatch
460        {
461            get { return (QuickWatch) ((Grid) ((Grid) Parent).Parent).Parent; }
462        }
463
464        private void SwitchView(object sender, RoutedEventArgs e)
465        {
466            ParentQuickWatch.ShowStatistics = false;
467        }
468    }
469
470    #region Converters
471    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
472    class InformationToProgressConverter : IValueConverter
473    {
474        public StatisticsPresentation StatisticsPresentation { get; set; }
475
476        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
477        {
478            try
479            {
480                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
481                {
482                    lock (StatisticsPresentation)
483                    {
484                        double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
485                        double vCount = ((Dictionary<long, Information>)value).Sum(i => i.Value.Count);
486                        return vCount / allCount;
487                    }
488                }
489            }
490            catch (Exception)
491            {
492            }
493            return 0.0;
494        }
495
496        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
497        {
498            throw new NotImplementedException();
499        }
500    }
501
502    [ValueConversion(typeof(Dictionary<long, Information>), typeof(Double))]
503    class MachineSumToProgressConverter : IValueConverter
504    {
505        public StatisticsPresentation StatisticsPresentation { get; set; }
506
507        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
508        {
509            try
510            {
511                if (StatisticsPresentation != null && StatisticsPresentation.MachineHierarchy != null)
512                {
513                    lock (StatisticsPresentation)
514                    {
515                        double allCount = (StatisticsPresentation.MachineHierarchy).Sum(i => i.Value.Sum);
516                        double vCount = (int)value;
517                        return vCount / allCount;
518                    }
519                }
520            }
521            catch (Exception)
522            {
523            }
524            return 0.0;
525        }
526
527        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
528        {
529            throw new NotImplementedException();
530        }
531    }
532
533    [ValueConversion(typeof(string), typeof(Double))]
534    class ChunkSumConverter : IValueConverter
535    {
536        public StatisticsPresentation StatisticsPresentation { get; set; }
537
538        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
539        {
540            try
541            {
542                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
543                {
544                    lock (StatisticsPresentation)
545                    {
546                        string key = (string)value;
547                        var data = (StatisticsPresentation.Statistics)[key];
548                        return data.Sum(i => i.Value.Count);
549                    }
550                }
551            }
552            catch (Exception)
553            {
554            }
555            return 0.0;
556        }
557
558        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
559        {
560            throw new NotImplementedException();
561        }
562    }
563
564    [ValueConversion(typeof(string), typeof(string))]
565    class StringLengthConverter : IValueConverter
566    {
567        public StatisticsPresentation StatisticsPresentation { get; set; }
568
569        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
570        {
571            if (value != null && value is string)
572            {
573                string name = (string)value;
574                if (name.Length < 13)
575                {
576                    return name;
577                }
578                return string.Format("{0}...", name.Substring(0, 9));
579            }
580            return "";
581        }
582
583        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
584        {
585            throw new NotImplementedException();
586        }
587    }
588
589    [ValueConversion(typeof(Int32), typeof(Double))]
590    class InformationToProgressConverter2 : IValueConverter
591    {
592        public StatisticsPresentation StatisticsPresentation { get; set; }
593
594        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
595        {
596            try
597            {
598                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
599                {
600                    lock (StatisticsPresentation)
601                    {
602                        double allCount = (StatisticsPresentation.Statistics).Sum(i => i.Value.Sum(j => j.Value.Count));
603                        return (int)value / allCount;
604                    }
605                }
606            }
607            catch (Exception)
608            {
609            }
610            return 0.0;
611        }
612
613        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
614        {
615            throw new NotImplementedException();
616        }
617    }
618
619    [ValueConversion(typeof(DateTime), typeof(String))]
620    class MaxDateConverter : IValueConverter
621    {
622        public StatisticsPresentation StatisticsPresentation { get; set; }
623
624        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
625        {
626            try
627            {
628                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
629                {
630                    lock (StatisticsPresentation)
631                    {
632                        var max = DateTime.MinValue;
633                        var machines = StatisticsPresentation.Statistics[(string)value];
634                        foreach (var id in machines.Keys.Where(id => machines[id].Date > max))
635                        {
636                            max = machines[id].Date;
637                        }
638                        return max.ToLocalTime().ToString("g");
639                    }
640                }
641            }
642            catch (Exception)
643            {
644            }
645            return DateTime.UtcNow.ToLocalTime().ToString("g");
646        }
647
648        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
649        {
650            throw new NotImplementedException();
651        }
652    }
653
654    [ValueConversion(typeof(DateTime), typeof(String))]
655    class TimeConverter : IValueConverter
656    {
657        public StatisticsPresentation StatisticsPresentation { get; set; }
658
659        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
660        {
661            try
662            {
663                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
664                {
665                    lock (StatisticsPresentation)
666                    {
667
668                        return ((DateTime)value).ToLocalTime().ToString("g");
669                    }
670                }
671            }
672            catch (Exception)
673            {
674            }
675            return DateTime.UtcNow.ToLocalTime().ToString("g");
676        }
677
678        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
679        {
680            throw new NotImplementedException();
681        }
682    }
683
684    [ValueConversion(typeof(DateTime), typeof(String))]
685    class DateToColorConverter1 : IValueConverter
686    {
687        public StatisticsPresentation StatisticsPresentation { get; set; }
688
689        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
690        {
691            try
692            {
693                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
694                {
695                    lock (StatisticsPresentation)
696                    {
697                        var max = DateTime.MinValue;
698                        var machines = StatisticsPresentation.Statistics[(string)value];
699                        foreach (var id in machines.Keys.Where(id => machines[id].Date > max))
700                        {
701                            max = machines[id].Date;
702                        }
703                        TimeSpan diff = DateTime.UtcNow.Subtract(max);
704                        var minutes = diff.TotalMinutes;
705
706                        var r = Math.Round(minutes/20);
707                        var g = -1*(Math.Round(minutes/20)) + 255;
708
709                        if (r > 255) r = 255;
710                        if (g < 0) g = 0;
711
712                        Color c = Color.FromRgb((byte) r, (byte) g, (byte) 0);
713                        return c.ToString();
714                    }
715                }
716            }
717            catch (Exception)
718            {
719            }
720            return Color.FromRgb(0, 0, 0).ToString();
721        }
722
723        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
724        {
725            throw new NotImplementedException();
726        }
727    }
728
729    [ValueConversion(typeof(DateTime), typeof(String))]
730    class DateToColorConverter2 : IValueConverter
731    {
732        public StatisticsPresentation StatisticsPresentation { get; set; }
733
734        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
735        {
736            try
737            {
738                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
739                {
740                    lock (StatisticsPresentation)
741                    {
742                        DateTime date = (DateTime)value;
743                        TimeSpan diff = DateTime.UtcNow.Subtract(date);
744                        var minutes = diff.TotalMinutes;
745
746                        var r = Math.Round(minutes / 20);
747                        var g = -1 * (Math.Round(minutes / 20)) + 255;
748
749                        if (r > 255) r = 255;
750                        if (g < 0) g = 0;
751
752                        Color c = Color.FromRgb((byte)r, (byte)g, 0);
753                        return c.ToString();
754                    }
755                }
756            }
757            catch (Exception)
758            {
759            }
760            return Color.FromRgb(0, 0, 0).ToString();
761        }
762
763        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
764        {
765            throw new NotImplementedException();
766        }
767    }
768
769    [ValueConversion(typeof(DateTime), typeof(Visibility))]
770    class DateFalseVisibleConverter1 : IValueConverter
771    {
772        public StatisticsPresentation StatisticsPresentation { get; set; }
773
774        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
775        {
776            try
777            {
778                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
779                {
780                    lock (StatisticsPresentation)
781                    {
782                        var max = DateTime.MinValue;
783                        var machines = StatisticsPresentation.Statistics[(string)value];
784                        foreach (var id in machines.Keys.Where(id => machines[id].Date > max))
785                        {
786                            max = machines[id].Date;
787                        }
788                        TimeSpan diff = DateTime.UtcNow.Subtract(max);
789                        var minutes = diff.TotalMinutes;
790
791                        if (targetType != typeof(Visibility))
792                            throw new InvalidOperationException("The target must be of Visibility");
793
794                        if (minutes > 7200) //five days
795                        {
796                            return Visibility.Hidden;
797                        }
798
799                        return Visibility.Visible;
800                    }
801                }
802            }
803            catch (Exception)
804            {
805            }
806            return Visibility.Hidden;
807        }
808
809        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
810        {
811            throw new NotImplementedException();
812        }
813    }
814
815    [ValueConversion(typeof(DateTime), typeof(Visibility))]
816    class DateTrueVisibleConverter1 : IValueConverter
817    {
818        public StatisticsPresentation StatisticsPresentation { get; set; }
819
820        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
821        {
822            try
823            {
824                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
825                {
826                    lock (StatisticsPresentation)
827                    {
828                        var max = DateTime.MinValue;
829                        var machines = StatisticsPresentation.Statistics[(string)value];
830                        foreach (var id in machines.Keys.Where(id => machines[id].Date > max))
831                        {
832                            max = machines[id].Date;
833                        }
834                        TimeSpan diff = DateTime.UtcNow.Subtract(max);
835                        var minutes = diff.TotalMinutes;
836
837                        if (targetType != typeof(Visibility))
838                            throw new InvalidOperationException("The target must be of Visibility");
839
840                        if (minutes > 7200) //five days
841                        {
842                            return Visibility.Visible;
843                        }
844
845                        return Visibility.Hidden;
846                    }
847                }
848            }
849            catch (Exception)
850            {
851            }
852            return Visibility.Hidden;
853        }
854
855        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
856        {
857            throw new NotImplementedException();
858        }
859    }
860
861    [ValueConversion(typeof(DateTime), typeof(Visibility))]
862    class DateFalseVisibleConverter2 : IValueConverter
863    {
864        public StatisticsPresentation StatisticsPresentation { get; set; }
865
866        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
867        {
868            try
869            {
870                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
871                {
872                    lock (StatisticsPresentation)
873                    {
874                        DateTime date = (DateTime)value;
875                        TimeSpan diff = DateTime.UtcNow.Subtract(date);
876                        var minutes = diff.TotalMinutes;
877
878                        if (targetType != typeof(Visibility))
879                            throw new InvalidOperationException("The target must be of Visibility");
880
881                        if (minutes > 7200) //five days
882                        {
883                            return Visibility.Hidden;
884                        }
885
886                        return Visibility.Visible;
887                    }
888                }
889            }
890            catch (Exception)
891            {
892            }
893            return Visibility.Hidden;
894        }
895
896        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
897        {
898            throw new NotImplementedException();
899        }
900    }
901
902    [ValueConversion(typeof(DateTime), typeof(Visibility))]
903    class DateTrueVisibleConverter2 : IValueConverter
904    {
905        public StatisticsPresentation StatisticsPresentation { get; set; }
906
907        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
908        {
909            try
910            {
911                if (StatisticsPresentation != null && StatisticsPresentation.Statistics != null)
912                {
913                    lock (StatisticsPresentation)
914                    {
915                        DateTime date = (DateTime)value;
916                        TimeSpan diff = DateTime.UtcNow.Subtract(date);
917                        var minutes = diff.TotalMinutes;
918
919                        if (targetType != typeof(Visibility))
920                            throw new InvalidOperationException("The target must be of Visibility");
921
922                        if (minutes > 7200) //five days
923                        {
924                            return Visibility.Visible;
925                        }
926
927                        return Visibility.Hidden;
928                    }
929                }
930            }
931            catch (Exception)
932            {
933            }
934            return Visibility.Hidden;
935        }
936
937        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
938        {
939            throw new NotImplementedException();
940        }
941    }
942
943    public class ColorToDateConverter : IMultiValueConverter
944    {
945        public static SolidColorBrush[] AlternationColors = {Brushes.LimeGreen, Brushes.Red, Brushes.Blue};
946
947        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
948        {
949            try
950            {
951                SolidColorBrush brush = ColorToDateConverter.AlternationColors[(int)values[1]].Clone();
952                return brush;             
953            }
954            catch (Exception)
955            {
956            }
957
958            return Brushes.AntiqueWhite;
959        }
960
961        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
962        {
963            throw new NotImplementedException();
964        }
965    }
966    #endregion
967
968}
Note: See TracBrowser for help on using the repository browser.