source: trunk/CrypPlugins/Transposition/Transposition.cs @ 833

Last change on this file since 833 was 833, checked in by weyers, 12 years ago

Transposition Presentation updated!

File size: 30.6 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.ComponentModel;
6
7using Cryptool;
8using Cryptool.PluginBase.IO;
9using Cryptool.PluginBase;
10using Cryptool.PluginBase.Cryptography;
11using Cryptool.PluginBase.Miscellaneous;
12
13namespace Transposition
14{
15    [Author("Daniel Kohnen, Julian Weyers, Simon Malischewski, Armin Wiefels", "kohnen@cryptool.org, weyers@cryptool.org, malischewski@cryptool.org, wiefels@cryptool.org", "Universität Duisburg-Essen", "http://www.uni-due.de")]
16    [PluginInfo(false, "Transposition", "Transposition cipher", "Transposition/Description/TranspositionDescript.xaml", "Transposition/Images/icon.png", "Transposition/Images/encrypt.png", "Transposition/Images/decrypt.png")]
17    [EncryptionType(EncryptionType.Classic)]
18    public class Transposition : IEncryption
19    {
20        # region Private variables
21
22        private String keyword = "";
23        private String input = "";
24        private String output = "";
25        private TranspositionSettings settings;
26        private TranspositionPresentation myPresentation;
27
28        private char[,] read_in_matrix;
29        private char[,] permuted_matrix;
30        private int[] key;
31        # endregion       
32
33        /// <summary>
34        /// Constructor
35        /// </summary>
36        public Transposition()
37        {
38            this.settings = new TranspositionSettings();
39            myPresentation = new TranspositionPresentation();
40            Presentation = myPresentation;
41        }
42
43        /// <summary>
44        /// Get or set all settings for this algorithm.
45        /// </summary>
46        public ISettings Settings
47        {
48            get { return this.settings; }
49            set { this.settings = (TranspositionSettings)value; }
50        }
51
52        # region getter methods
53
54        /// <summary>
55        /// Get read in matrix.
56        /// </summary>
57        public char[,] Read_in_matrix
58        {
59            get
60            {
61                return read_in_matrix;
62            }
63        }
64
65        /// <summary>
66        /// Get permuted matrix.
67        /// </summary>
68        public char[,] Permuted_matrix
69        {
70            get
71            {
72                return permuted_matrix;
73            }
74        }
75
76        /// <summary>
77        /// Get numerical key order.
78        /// </summary>
79        public int[] Key
80        {
81            get
82            {
83                return key;
84            }
85        }
86        # endregion
87
88        # region Properties
89
90        [PropertyInfo(Direction.InputData, "Input", "input", "Text to be encrypted.", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
91        public string Input
92        {
93            get
94            {
95                return this.input;
96            }
97
98            set
99            {
100                this.input = value;
101                OnPropertyChange("Input");
102            }
103        }
104
105        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "Keyword used for encryption", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
106        public string Keyword
107        {
108            get
109            {
110                return this.keyword;
111            }
112
113            set
114            {
115                this.keyword = value;
116                OnPropertyChange("Keyword");
117            }
118        }
119
120        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
121        public string Output
122        {
123            get
124            {
125                return this.output;
126            }
127            set
128            {
129                this.output = value;
130                OnPropertyChange("Output");
131            }
132        }
133
134        private void OnPropertyChange(String propertyname)
135        {
136            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(propertyname));
137        }
138
139        private void ProgressChanged(double value, double max)
140        {
141            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
142        }
143
144        # endregion
145
146        #region IPlugin Member
147
148        public void Dispose()
149        {
150
151        }
152
153        public void Execute()
154        {
155            ProcessTransposition();
156            myPresentation.main(Read_in_matrix,Permuted_matrix,key,Keyword,Input,Output,this.settings.Permutation,this.settings.ReadIn,this.settings.ReadOut);
157           
158        }
159
160        public void Initialize()
161        {
162
163        }
164
165        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
166
167        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
168
169        public event StatusChangedEventHandler OnPluginStatusChanged;
170
171        public void Pause()
172        {
173           
174        }
175
176        public void PostExecution()
177        {
178
179        }
180
181        public void PreExecution()
182        {
183
184        }
185
186        public System.Windows.Controls.UserControl Presentation
187        {
188            get;
189            private set; 
190        }
191
192        public System.Windows.Controls.UserControl QuickWatchPresentation
193        {
194            get { return Presentation; }
195        }
196
197        public void Stop()
198        {
199            myPresentation.my_Stop(this, EventArgs.Empty);
200        }
201
202        #endregion
203
204        #region INotifyPropertyChanged Member
205
206        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
207
208        #endregion
209
210        # region Private Methods
211
212        private void ProcessTransposition()
213        {
214            try
215            {
216                if (keyword.Contains(','))
217                {
218                    key = get_Keyword_Array(keyword);
219                }
220
221                else
222                {
223                    key = sortKey(keyword);
224                }
225
226                switch (settings.Action)
227                {
228                    case 0:
229                        Output = encrypt(input, key);
230                        break;
231                    case 1:
232                        Output = decrypt(input, key);
233                        break;
234                    default:
235                        break;
236                }
237                ProgressChanged(1, 1);
238            }
239
240            catch (Exception)
241            {
242                Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
243                Output = "";
244            }
245        }
246
247        private String encrypt(String input, int[] key)
248        {
249            if (key != null && input != null && key.Length > 0)
250            {
251                if (is_Valid_Keyword(key))
252                {
253                    String encrypted = "";
254
255                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
256                    {
257                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
258                        {
259                            case TranspositionSettings.ReadInMode.byRow:
260                                read_in_matrix = enc_read_in_by_row_if_row_perm(input, key.Length); break;
261                            case TranspositionSettings.ReadInMode.byColumn:
262                                read_in_matrix = enc_read_in_by_column_if_row_perm(input, key.Length); break;
263                            default:
264                                break;
265                        }
266
267                        permuted_matrix = enc_permute_by_row(read_in_matrix, key);
268
269                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
270                        {
271                            case TranspositionSettings.ReadOutMode.byRow:
272                                encrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
273                            case TranspositionSettings.ReadOutMode.byColumn:
274                                encrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
275                            default:
276                                break;
277                        }
278                    }
279
280                    // permute by column:
281                    else
282                    {
283                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
284                        {
285                            case TranspositionSettings.ReadInMode.byRow:
286                                read_in_matrix = enc_read_in_by_row(input, key.Length); break;
287                            case TranspositionSettings.ReadInMode.byColumn:
288                                read_in_matrix = enc_read_in_by_column(input, key.Length); break;
289                            default:
290                                break;
291                        }
292
293                        permuted_matrix = enc_permut_by_column(read_in_matrix, key);
294
295                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
296                        {
297                            case TranspositionSettings.ReadOutMode.byRow:
298                                encrypted = read_out_by_row(permuted_matrix, key.Length); break;
299                            case TranspositionSettings.ReadOutMode.byColumn:
300                                encrypted = read_out_by_column(permuted_matrix, key.Length); break;
301                            default:
302                                break;
303                        }
304                    }
305                    return encrypted;
306                }
307                else
308                {
309                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
310                    return "";
311                }
312            }
313            else
314            {
315                // 2do: Anzeige "Kein gültiges Keyword
316                return "";
317            }
318        }
319
320        private String decrypt(String input, int[] key)
321        {
322            if (key != null && input != null && key.Length > 0)
323            {
324                if (is_Valid_Keyword(key))
325                {
326                    String decrypted = "";
327                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
328                    {
329                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
330                        {
331                            case TranspositionSettings.ReadOutMode.byRow:
332                                read_in_matrix = dec_read_in_by_row_if_row_perm(input, key); break;
333                            case TranspositionSettings.ReadOutMode.byColumn:
334                                read_in_matrix = dec_read_in_by_column_if_row_perm(input, key); break;
335                            default:
336                                break;
337                        }
338
339                        permuted_matrix = dec_permut_by_row(read_in_matrix, key);
340
341                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
342                        {
343                            case TranspositionSettings.ReadInMode.byRow:
344                                decrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
345                            case TranspositionSettings.ReadInMode.byColumn:
346                                decrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
347                            default:
348                                break;
349                        }
350                    }
351
352                    // permute by column:
353                    else
354                    {
355                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
356                        {
357                            case TranspositionSettings.ReadOutMode.byRow:
358                                read_in_matrix = dec_read_in_by_row(input, key); break;
359                            case TranspositionSettings.ReadOutMode.byColumn:
360                                read_in_matrix = dec_read_in_by_column(input, key); break;
361                            default:
362                                break;
363                        }
364
365                        permuted_matrix = dec_permut_by_column(read_in_matrix, key);
366
367                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
368                        {
369                            case TranspositionSettings.ReadInMode.byRow:
370                                decrypted = read_out_by_row(permuted_matrix, key.Length); break;
371                            case TranspositionSettings.ReadInMode.byColumn:
372                                decrypted = read_out_by_column(permuted_matrix, key.Length); break;
373                            default:
374                                break;
375                        }
376                    }
377
378                    return decrypted;
379                }
380                else
381                {
382                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
383                    return "";
384                }
385            }
386            else
387            {
388                // 2do: Anzeige "Kein gültiges Keyword
389                return "";
390            }
391        }
392
393        private char[,] enc_read_in_by_row(String input, int keyword_length)
394        {
395            int size = input.Length / keyword_length;
396
397            if (input.Length % keyword_length != 0)
398            {
399                size++;
400            }
401
402            int pos = 0;
403            char[,] matrix = new char[keyword_length, size];
404
405            for (int i = 0; i < size; i++)
406            {
407                for (int j = 0; j < keyword_length; j++)
408                {
409                    if (pos < input.Length)
410                    {
411                        matrix[j, i] = input[pos];
412                        pos++;
413                    }
414                }
415            }
416            return matrix;
417        }
418
419        private char[,] enc_read_in_by_column(String input, int keyword_length)
420        {
421            int size = input.Length / keyword_length;
422            int offs = input.Length % keyword_length;
423            if (offs != 0)
424            {
425                size++;
426            }
427
428            int pos = 0;
429
430            char[,] matrix = new char[keyword_length, size];
431            for (int i = 0; i < keyword_length; i++)
432            {
433                for (int j = 0; j < size; j++)
434                {
435                    if (pos < input.Length)
436                    {
437                        if (offs > 0 && j == size - 1 && i >= offs) { }
438                        else
439                        {
440                            matrix[i, j] = input[pos];
441                            pos++;
442                        }
443                    }
444                }
445            }
446            return matrix;
447        }
448
449        private char[,] enc_read_in_by_row_if_row_perm(String input, int keyword_length)
450        {
451            int height = keyword_length;
452            int length = input.Length / keyword_length;
453            int offs = input.Length % keyword_length;
454            if (offs != 0)
455            {
456                length++;
457            }
458
459            char[,] matrix = new char[length, height];
460            int pos = 0;
461
462            for (int i = 0; i < height; i++)
463            {
464                for (int j = 0; j < length; j++)
465                {
466                    if (pos < input.Length)
467                    {
468                        if (j.Equals(length - 1) && offs != 0)
469                        {
470                            if (i < offs)
471                            {
472                                matrix[j, i] = input[pos];
473                                pos++;
474                            }
475                        }
476
477                        else
478                        {
479                            matrix[j, i] = input[pos];
480                            pos++;
481                        }
482                    }
483                }
484            }
485            return matrix;
486        }
487
488        private char[,] enc_read_in_by_column_if_row_perm(String input, int keyword_length)
489        {
490            int height = keyword_length;
491            int length = input.Length / keyword_length;
492            int offs = input.Length % keyword_length;
493            if (offs != 0)
494            {
495                length++;
496            }
497
498            char[,] matrix = new char[length, height];
499            int pos = 0;
500
501            for (int i = 0; i < length; i++)
502            {
503                for (int j = 0; j < height; j++)
504                {
505                    if (pos < input.Length)
506                    {
507                        matrix[i, j] = input[pos];
508                        pos++;
509                    }
510                }
511            }
512            return matrix;
513        }
514
515        private char[,] dec_read_in_by_column(String input, int[] keyword)
516        {
517            int size = input.Length / keyword.Length;
518            int offs = input.Length % keyword.Length;
519            if (offs != 0)
520            {
521                size++;
522            }
523
524            char[,] matrix = new char[keyword.Length, size];
525            int pos = 0;
526
527            for (int i = 0; i < keyword.Length; i++)
528            {
529                for (int j = 0; j < size; j++)
530                {
531                    if (pos < input.Length)
532                    {
533                        if ((!offs.Equals(0)) && j.Equals(size - 1))
534                        {
535                            bool ok = false;
536
537                            for (int k = 0; k < offs; k++)
538                            {
539                                if ((keyword[k] - 1).Equals(i))
540                                {
541                                    ok = true;
542                                }
543                            }
544
545                            if (ok)
546                            {
547                                matrix[i, j] = input[pos];
548                                pos++;
549                            }
550
551                        }
552                        else
553                        {
554                            matrix[i, j] = input[pos];
555                            pos++;
556                        }
557                    }
558                }
559            }
560            return matrix;
561        }
562
563        private char[,] dec_read_in_by_column_if_row_perm(String input, int[] keyword)
564        {
565            int size = input.Length / keyword.Length;
566            int offs = input.Length % keyword.Length;
567            if (offs != 0)
568            {
569                size++;
570            }
571
572            char[,] matrix = new char[size, keyword.Length];
573            int pos = 0;
574
575            for (int i = 0; i < size; i++)
576            {
577                for (int j = 0; j < keyword.Length; j++)
578                {
579                    if (pos < input.Length)
580                    {
581                        if ((!offs.Equals(0)) && i.Equals(size - 1))
582                        {
583                            bool ok = false;
584
585                            for (int k = 0; k < offs; k++)
586                            {
587                                if ((keyword[k] - 1).Equals(j))
588                                {
589                                    ok = true;
590                                }
591                            }
592
593                            if (ok)
594                            {
595                                matrix[i, j] = input[pos];
596                                pos++;
597                            }
598
599                        }
600                        else
601                        {
602                            matrix[i, j] = input[pos];
603                            pos++;
604                        }
605                    }
606                }
607            }
608            return matrix;
609        }
610
611        private char[,] dec_read_in_by_row(String input, int[] keyword)
612        {
613            int size = input.Length / keyword.Length;
614            int offs = input.Length % keyword.Length;
615            if (offs != 0)
616            {
617                size++;
618            }
619
620            char[,] matrix = new char[keyword.Length, size];
621            int pos = 0;
622
623            for (int i = 0; i < size; i++)
624            {
625                for (int j = 0; j < keyword.Length; j++)
626                {
627                    if (pos < input.Length)
628                    {
629                        if ((!offs.Equals(0)) && i.Equals(size - 1))
630                        {
631                            bool ok = false;
632
633                            for (int k = 0; k < offs; k++)
634                            {
635                                if ((keyword[k] - 1).Equals(j))
636                                {
637                                    ok = true;
638                                }
639                            }
640
641                            if (ok)
642                            {
643                                matrix[j, i] = input[pos];
644                                pos++;
645                            }
646
647                        }
648                        else
649                        {
650                            matrix[j, i] = input[pos];
651                            pos++;
652                        }
653                    }
654                }
655            }
656            return matrix;
657        }
658
659        private char[,] dec_read_in_by_row_if_row_perm(String input, int[] keyword)
660        {
661            int size = input.Length / keyword.Length;
662            int offs = input.Length % keyword.Length;
663            if (offs != 0)
664            {
665                size++;
666            }
667
668            char[,] matrix = new char[size, keyword.Length];
669            int pos = 0;
670
671            for (int i = 0; i < keyword.Length; i++)
672            {
673                for (int j = 0; j < size; j++)
674                {
675                    if (pos < input.Length)
676                    {
677                        if ((!offs.Equals(0)) && j.Equals(size - 1))
678                        {
679                            bool ok = false;
680
681                            for (int k = 0; k < offs; k++)
682                            {
683                                if ((keyword[k] - 1).Equals(i))
684                                {
685                                    ok = true;
686                                }
687                            }
688
689                            if (ok)
690                            {
691                                matrix[j, i] = input[pos];
692                                pos++;
693                            }
694
695                        }
696                        else
697                        {
698                            matrix[j, i] = input[pos];
699                            pos++;
700                        }
701                    }
702                }
703            }
704            return matrix;
705        }
706
707        private char[,] enc_permut_by_column(char[,] readin_matrix, int[] keyword)
708        {
709            int x = keyword.Length;
710            int y = readin_matrix.Length / keyword.Length;
711            char[,] matrix = new char[x, y];
712            int pos = 0;
713
714            for (int i = 1; i <= keyword.Length; i++)
715            {
716                for (int j = 0; j < keyword.Length; j++)
717                {
718                    if (i.Equals(keyword[j]))
719                    {
720                        pos = j;
721                    }
722                }
723
724                for (int j = 0; j < y; j++)
725                {
726                    matrix[i - 1, j] = readin_matrix[pos, j];
727                }
728            }
729            return matrix;
730        }
731
732        private char[,] enc_permute_by_row(char[,] readin_matrix, int[] keyword)
733        {
734            int y = keyword.Length;
735            int x = readin_matrix.Length / keyword.Length;
736            char[,] matrix = new char[x, y];
737            int pos = 0;
738
739            for (int i = 1; i <= y; i++)
740            {
741                for (int j = 0; j < keyword.Length; j++)
742                {
743                    if (keyword[j].Equals(i))
744                    {
745                        pos = j;
746                    }
747                }
748
749                for (int j = 0; j < x; j++)
750                {
751                    matrix[j, i - 1] = readin_matrix[j, pos];
752                }
753            }
754            return matrix;
755        }
756
757        private char[,] dec_permut_by_column(char[,] readin_matrix, int[] keyword)
758        {
759            int x = keyword.Length;
760            int y = readin_matrix.Length / keyword.Length;
761            char[,] matrix = new char[x, y];
762
763            for (int i = 0; i < x; i++)
764            {
765                for (int j = 0; j < y; j++)
766                {
767                    matrix[i, j] = readin_matrix[keyword[i] - 1, j];
768                }
769            }
770            return matrix;
771        }
772
773        private static char[,] dec_permut_by_row(char[,] readin_matrix, int[] keyword)
774        {
775            int x = keyword.Length;
776            int y = readin_matrix.Length / keyword.Length;
777            char[,] matrix = new char[y, x];
778
779            for (int i = 0; i < x; i++)
780            {
781                for (int j = 0; j < y; j++)
782                {
783                    matrix[j, i] = readin_matrix[j, keyword[i] - 1];
784                }
785            }
786            return matrix;
787        }
788
789        private String read_out_by_row(char[,] matrix, int keyword_length)
790        {
791            int x = keyword_length;
792            int y = matrix.Length / keyword_length;
793            String enc = "";
794            char empty_char = new char();
795
796            for (int i = 0; i < y; i++)
797            {
798                for (int j = 0; j < x; j++)
799                {
800                    char tmp = matrix[j, i];
801                    if (!tmp.Equals(empty_char))
802                    {
803                        enc += tmp;
804                    }
805                }
806            }
807            return enc;
808        }
809
810        private String read_out_by_row_if_row_perm(char[,] matrix, int keyword_length)
811        {
812            int y = keyword_length;
813            int x = matrix.Length / keyword_length;
814            String enc = "";
815            char empty_char = new char();
816
817            for (int i = 0; i < y; i++)
818            {
819                for (int j = 0; j < x; j++)
820                {
821                    char tmp = matrix[j, i];
822                    if (!tmp.Equals(empty_char))
823                    {
824                        enc += tmp;
825                    }
826                }
827            }
828            return enc;
829        }
830
831        private String read_out_by_column(char[,] matrix, int keyword_length)
832        {
833            int x = keyword_length;
834            int y = matrix.Length / keyword_length;
835            String enc = "";
836            char empty_char = new char();
837
838            for (int i = 0; i < x; i++)
839            {
840                for (int j = 0; j < y; j++)
841                {
842                    char tmp = matrix[i, j];
843                    if (!tmp.Equals(empty_char))
844                    {
845                        enc += tmp;
846                    }
847                }
848            }
849            return enc;
850        }
851
852        private String read_out_by_column_if_row_perm(char[,] matrix, int keyword_length)
853        {
854            int y = keyword_length;
855            int x = matrix.Length / keyword_length;
856            String enc = "";
857            char empty_char = new char();
858
859            for (int i = 0; i < x; i++)
860            {
861                for (int j = 0; j < y; j++)
862                {
863                    char tmp = matrix[i, j];
864                    if (!tmp.Equals(empty_char))
865                    {
866                        enc += tmp;
867                    }
868                }
869            }
870            return enc;
871        }
872
873        private int[] get_Keyword_Array(String keyword)
874        {
875            try
876            {
877                int length = 1;
878                char komma = ',';
879
880                for (int i = 0; i < keyword.Length; i++)
881                {
882                    if (keyword[i].Equals(komma))
883                    {
884                        length++;
885                    }
886                }
887
888                int[] keys = new int[length];
889                String tmp = "";
890                int pos = 0;
891                for (int i = 0; i < keyword.Length; i++)
892                {
893                    if (i.Equals(keyword.Length - 1))
894                    {
895                        tmp += keyword[i];
896                        keys[pos] = Convert.ToInt32(tmp);
897                    }
898
899                    else
900                    {
901                        if (keyword[i].Equals(komma))
902                        {
903                            keys[pos] = Convert.ToInt32(tmp);
904                            tmp = "";
905                            pos++;
906                        }
907                        else
908                        {
909                            tmp += keyword[i];
910                        }
911                    }
912                }
913                return keys;
914            }
915            catch (FormatException)
916            {
917                return null;
918            }
919        }
920
921        private bool is_Valid_Keyword(int[] keyword)
922        {
923            for (int i = 1; i <= keyword.Length; i++)
924            {
925                bool exists = false;
926
927                for (int j = 0; j < keyword.Length; j++)
928                {
929                    if (i.Equals(keyword[j]))
930                    {
931                        exists = true;
932                    }
933                }
934
935                if (!exists)
936                {
937                    return false;
938                }
939            }
940            return true;
941        }
942
943        public int[] sortKey(String input)
944        {
945            if (input != null && !input.Equals(""))
946            {
947                String key = input;
948                Char[] keyChars = key.ToCharArray();
949                Char[] orgChars = key.ToCharArray();
950                int[] rank = new int[keyChars.Length];
951                Array.Sort(keyChars);
952
953                for (int i = 0; i < orgChars.Length; i++)
954                {
955                    rank[i] = (Array.IndexOf(keyChars, orgChars[i])) + 1;
956                    keyChars[Array.IndexOf(keyChars, orgChars[i])] = (char)0;
957                }
958                return rank;
959            }
960            return null;
961        }
962
963        private void Transposition_LogMessage(string msg, NotificationLevel loglevel)
964        {
965            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
966        }
967
968        # endregion
969    }
970}
Note: See TracBrowser for help on using the repository browser.