source: trunk/CrypPlugins/Enigma/EnigmaSettings.cs @ 2801

Last change on this file since 2801 was 2801, checked in by weyers, 11 years ago

EnigmaPresentation - EnigmaSettings synchronisation, EnigmaPresentation input management updated

  • Property svn:eol-style set to CRLF
  • Property svn:keywords set to URL Author Date Rev Id
File size: 53.7 KB
Line 
1/*
2   Copyright 2008-2009, Dr. Arno Wacker, University of Duisburg-Essen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17
18using System;
19using System.Collections.Generic;
20using System.Linq;
21using System.Text;
22
23//additionally needed libs
24using System.ComponentModel;
25using System.Collections.ObjectModel;
26using System.Windows;
27
28// Cryptool 2.0 specific includes
29using Cryptool.PluginBase;
30using Cryptool.PluginBase.Miscellaneous;
31
32
33namespace Cryptool.Enigma
34{
35    public class EnigmaSettings : ISettings
36    {
37        #region Private variables
38
39        private bool hasChanges = false;
40        private int action = 0; //0=encrypt, 1=decrypt
41        private ObservableCollection<string> actionStrings = new ObservableCollection<string>();
42        private ObservableCollection<string> rotorAStrings = new ObservableCollection<string>();
43        private ObservableCollection<string> rotorBStrings = new ObservableCollection<string>();
44        private ObservableCollection<string> reflectorStrings = new ObservableCollection<string>();
45        private int model = 3;
46        private int unknownSymbolHandling = 0; // 0=ignore, leave unmodified
47        private int caseHandling = 0; // 0=preserve, 1, convert all to upper, 2= convert all to lower
48        private string key = "AAA";
49        private string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
50
51        private bool analyzeRotors = true;
52        private bool analyzeKey = true;
53        private bool analyzeRings = true;
54        private bool analyzePlugs = true;
55        private bool analysisUseRotorI = true;
56        private bool analysisUseRotorII = true;
57        private bool analysisUseRotorIII = true;
58        private bool analysisUseRotorIV = true;
59        private bool analysisUseRotorV = true;
60        private bool analysisUseRotorVI = true;
61        private bool analysisUseRotorVII = true;
62        private bool analysisUseRotorVIII = true;
63
64        private int keySearchMethod = 0;
65        private int maxSearchedPlugs = 10;
66        private int plugSearchMethod = 2;
67
68        private int rotor1 = 0;
69        private int rotor2 = 1;
70        private int rotor3 = 2;
71        private int rotor4 = 0;
72
73        private int ring1 = 1; // 01 = A, 02 = B ...
74        private int ring2 = 1; 
75        private int ring3 = 1;
76        private int ring4 = 1;
77
78        private int reflector = 1;
79
80        private bool involutoricPlugBoard = true;
81        private StringBuilder plugBoard = new StringBuilder("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
82
83        #endregion
84
85        #region Private methods
86
87        private void checkRotorChange(int rotor, int was, int becomes)
88        {
89            switch (rotor)
90            {
91                case 1:
92                    if (rotor2 == becomes) { rotor2 = was; OnPropertyChanged("Rotor2"); }
93                    if (rotor3 == becomes) { rotor3 = was; OnPropertyChanged("Rotor3"); }
94                    break;
95                case 2:
96                    if (rotor1 == becomes) { rotor1 = was; OnPropertyChanged("Rotor1"); }
97                    if (rotor3 == becomes) { rotor3 = was; OnPropertyChanged("Rotor3"); }
98                    break;
99                case 3:
100                    if (rotor1 == becomes) { rotor1 = was; OnPropertyChanged("Rotor1"); }
101                    if (rotor2 == becomes) { rotor2 = was; OnPropertyChanged("Rotor2"); }
102                    break;
103            } 
104        }
105
106        private void setPlugBoard(int letterPos, int newIndex)
107        {
108            if (newIndex != alphabet.IndexOf(plugBoard[letterPos]))
109            {
110                hasChanges = true;
111                char newChar = alphabet[newIndex];
112                //int newCharIndex = plugBoard.ToString().IndexOf(newChar);
113                char currentChar = plugBoard[letterPos];
114                int currentIndex = alphabet.IndexOf(currentChar);
115
116               
117                //if (this.involutoricPlugBoard)
118                //{
119                this.plugBoard[newIndex] = currentChar;
120                OnPropertyChanged("PlugBoard" + alphabet[newIndex]);
121
122               
123
124
125                if (newChar == this.alphabet[letterPos])
126                    {
127                        // we removed a plug
128                        this.plugBoard[currentIndex] = this.alphabet[currentIndex];
129                        OnPropertyChanged("PlugBoard" + alphabet[currentIndex] );
130                    }
131
132
133
134                //}
135               
136                this.plugBoard[letterPos] = newChar;
137                OnPropertyChanged("PlugBoard" + alphabet[letterPos]);
138
139               
140
141
142
143                OnPropertyChanged("PlugBoardDisplay");
144            }
145        }
146
147        private void showSettingsElement(string element)
148        {
149            if (TaskPaneAttributeChanged != null)
150            {
151                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer(element, Visibility.Visible)));
152            }
153        }
154
155        private void hideSettingsElement(string element)
156        {
157            if (TaskPaneAttributeChanged != null)
158            {
159                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer(element, Visibility.Collapsed)));
160            }
161        }
162
163        #endregion
164
165        #region Public Events and Methods
166
167        /// <summary>
168        /// This event is needed in order to render settings elements visible/invisible
169        /// </summary>
170        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
171
172        /// <summary>
173        /// Return the expected length of n-grams statistics for the given search method.
174        /// </summary>
175        /// <returns></returns>
176        public int GetGramLength(int searchMethod)
177        {
178            switch (searchMethod)
179            {
180                case 0:
181                    return 1;
182                case 1:
183                    return 2;
184                case 2:
185                    return 3;
186                case 3:
187                    return 1;
188                case 4:
189                    return 2;
190                case 5:
191                    return 1;
192                default:
193                    throw new NotSupportedException("Search method with index " + searchMethod + " is unknown");
194            }
195        }
196
197        public int AlphabetIndexOf(char c)
198        {
199            return c - 'A';
200        }
201
202        #endregion
203
204        #region Initialisation / Contructor
205
206        public EnigmaSettings()
207        {
208            actionStrings.Add("Encrypt/Decrypt"); actionStrings.Add("Analyze");
209            reflectorStrings.Add("UKW A"); reflectorStrings.Add("UKW B (2. November 1937)"); reflectorStrings.Add("UKW C (since 1940/41)");
210            rotorAStrings.Add("I (since 1930)"); rotorAStrings.Add("II (since 1930)"); rotorAStrings.Add("III (since 1930)");
211            rotorAStrings.Add("IV (since 1938, M3 \"Heer\")"); rotorAStrings.Add("V (since 1938, M3 \"Heer\")"); rotorAStrings.Add("VI (since 1939, M3/M4)");
212            rotorAStrings.Add("VII (since 1939, M3/M4)"); rotorAStrings.Add("VIII (since 1939, M3/M4)");
213            rotorBStrings.Add("Not available for this model.");
214        }
215
216        public void Initialize()
217        {
218            hideSettingsElement("Rotor4"); hideSettingsElement("Ring4");
219        }
220
221        #endregion
222
223        #region Public properties
224
225        public string Alphabet
226        { 
227            get {return alphabet; }
228            set {alphabet = value; } 
229        }
230
231        #endregion
232
233        #region Taskpane settings
234
235        [ContextMenu("Enigma model", "Please select which Enigma model you want to use. This settings influences available rotors and their inner cabling.",
236            0, ContextMenuControlType.ComboBox, null,
237            new string[] { "Commercial Enigma A/B - since 1924", "Commercial Enigma D", "Reichsbahn (Rocket) - since 1941", "Enigma I / M3", "M4 (Shark)", "K-Model", "G (Defense model)" })]
238        [TaskPane("Enigma model", "Please select which Enigma model you want to use. This settings influences the available rotors and their inner cabling.",
239            null, 0, false, ControlType.ComboBox,
240            new string[] { "Enigma A/B - since 1924", "Enigma D", "Reichsbahn (Rocket) - since 1941", "Enigma I / M3", "M4 (Shark)", "K-Model", "G (Defense model)" })]
241        [PropertySaveOrder(1)]
242        public int Model
243        {
244            get { return this.model; }
245            set
246            {
247                if (value != model) hasChanges = true;
248                this.model = value;
249                OnPropertyChanged("Model");
250                switch (this.model)
251                {
252                    case 0: // Enigma A/B
253                        actionStrings.Clear(); actionStrings.Add("Encrypt"); actionStrings.Add("Decrypt"); action = 0; OnPropertyChanged("Action");
254                        if (key.Length > 3) key = key.Remove(0,1); OnPropertyChanged("Key");
255                        rotorAStrings.Clear();  rotorAStrings.Add("I (C) -- since 1924"); rotorAStrings.Add("II (C) -- since 1924"); rotorAStrings.Add("III (C) -- since 1924");
256                        rotor1 = 0; rotor2 = 1; rotor3 = 2; OnPropertyChanged("Rotor1"); OnPropertyChanged("Rotor2"); OnPropertyChanged("Rotor3");
257                        rotorBStrings.Clear(); rotorBStrings.Add("Not available for this model."); rotor4 = 0;  OnPropertyChanged("Rotor4");
258                        reflectorStrings.Clear(); reflectorStrings.Add("Not available for this model."); reflector = 0; OnPropertyChanged("Reflector");
259                        hideSettingsElement("Rotor4"); hideSettingsElement("Ring4"); hideSettingsElement("Reflector");
260                        break;
261                    case 1: // Enigma D
262                        actionStrings.Clear(); actionStrings.Add("Encrypt / Decrypt"); action = 0; OnPropertyChanged("Action");
263                        if (key.Length > 3) key = key.Remove(0, 1); OnPropertyChanged("Key");
264                        rotorAStrings.Clear(); rotorAStrings.Add("I (D)"); rotorAStrings.Add("II (D)"); rotorAStrings.Add("III (D)");
265                        rotor1 = 0; rotor2 = 1; rotor3 = 2; OnPropertyChanged("Rotor1"); OnPropertyChanged("Rotor2"); OnPropertyChanged("Rotor3");
266                        rotorBStrings.Clear(); rotorBStrings.Add("Not available for this model."); rotor4 = 0; OnPropertyChanged("Rotor4");
267                        reflectorStrings.Clear(); reflectorStrings.Add("UKW (D)"); reflector = 0; OnPropertyChanged("Reflector");
268                        hideSettingsElement("Rotor4"); hideSettingsElement("Ring4");
269                        showSettingsElement("Reflector");
270                        break;
271                    case 2: // Reichsbahn (Rocket)
272                        actionStrings.Clear(); actionStrings.Add("Encrypt / Decrypt"); action = 0; OnPropertyChanged("Action");
273                        if (key.Length > 3) key = key.Remove(0, 1); OnPropertyChanged("Key");
274                        rotorAStrings.Clear(); rotorAStrings.Add("I -- since 7th Feb. 1941"); rotorAStrings.Add("II -- since 7th Feb. 1941"); rotorAStrings.Add("III -- since 7th Feb. 1941");
275                        rotor1 = 0; rotor2 = 1; rotor3 = 2; OnPropertyChanged("Rotor1"); OnPropertyChanged("Rotor2"); OnPropertyChanged("Rotor3");
276                        rotorBStrings.Clear(); rotorBStrings.Add("Not available for this model."); rotor4 = 0; OnPropertyChanged("Rotor4");
277                        reflectorStrings.Clear(); reflectorStrings.Add("UKW -- since 7th Feb. 1941"); reflector = 0; OnPropertyChanged("Reflector");
278                        hideSettingsElement("Rotor4"); hideSettingsElement("Ring4");
279                        showSettingsElement("Reflector");
280                        break;
281                    case 3: // Enigma I / M3
282                        actionStrings.Clear(); actionStrings.Add("Encrypt / Decrypt"); actionStrings.Add("Analyze"); action = 0; OnPropertyChanged("Action");
283                        if (key.Length > 3) key = key.Remove(0, 1); OnPropertyChanged("Key");
284                        rotorAStrings.Clear(); rotorAStrings.Add("I (since 1930)"); rotorAStrings.Add("II (since 1930)"); rotorAStrings.Add("III (since 1930)");
285                        rotorAStrings.Add("IV (since 1938, M3 \"Heer\")"); rotorAStrings.Add("V (since 1938, M3 \"Heer\")"); rotorAStrings.Add("VI (since 1939, M3/M4)");
286                        rotorAStrings.Add("VII (since 1939, M3/M4)"); rotorAStrings.Add("VIII (since 1939, M3/M4)");
287                        rotor1 = 0; rotor2 = 1; rotor3 = 2; OnPropertyChanged("Rotor1"); OnPropertyChanged("Rotor2"); OnPropertyChanged("Rotor3");
288                        rotorBStrings.Clear(); rotorBStrings.Add("Not available for this model."); rotor4 = 0; OnPropertyChanged("Rotor4");
289                        reflectorStrings.Clear(); reflectorStrings.Add("UKW A"); reflectorStrings.Add("UKW B (2. November 1937)");
290                        reflectorStrings.Add("UKW C (since 1940/41)"); reflector = 1; OnPropertyChanged("Reflector");
291                        hideSettingsElement("Rotor4"); hideSettingsElement("Ring4"); 
292                        showSettingsElement("Reflector");
293                        break;
294                    case 4: // Enigma M4 "Shark"
295                        actionStrings.Clear(); actionStrings.Add("Encrypt / Decrypt"); action = 0; OnPropertyChanged("Action");
296                        if (key.Length < 4) key = "A" + key; OnPropertyChanged("Key");
297                        rotorAStrings.Clear(); rotorAStrings.Add("I (since 1930)"); rotorAStrings.Add("II (since 1930)"); rotorAStrings.Add("III (since 1930)");
298                        rotorAStrings.Add("IV (since 1938, M3 \"Heer\")"); rotorAStrings.Add("V (since 1938, M3 \"Heer\")"); rotorAStrings.Add("VI (since 1939, M3/M4)");
299                        rotorAStrings.Add("VII (since 1939, M3/M4)"); rotorAStrings.Add("VIII (since 1939, M3/M4)");
300                        rotor1 = 0; rotor2 = 1; rotor3 = 2; OnPropertyChanged("Rotor1"); OnPropertyChanged("Rotor2"); OnPropertyChanged("Rotor3");
301                        rotorBStrings.Clear(); rotorBStrings.Add("Beta -- since 1st Feb. 1942"); rotorBStrings.Add("Gamma -- since 1st July 1943"); rotor4 = 0; OnPropertyChanged("Rotor4");
302                        reflectorStrings.Clear(); reflectorStrings.Add("UKW B \"thin\" -- since 1st Feb. 1942"); reflectorStrings.Add("UKW C \"thin\" -- since 1st July 1943");
303                        reflector = 0; OnPropertyChanged("Reflector");
304                        showSettingsElement("Rotor4"); showSettingsElement("Ring4"); showSettingsElement("Reflector");
305                        break;
306                    case 5: // Enigma K-Model
307                        actionStrings.Clear(); actionStrings.Add("Encrypt / Decrypt"); action = 0; OnPropertyChanged("Action");
308                        if (key.Length > 3) key = key.Remove(0, 1); OnPropertyChanged("Key");
309                        rotorAStrings.Clear(); rotorAStrings.Add("I (K) -- since Feb. 1939"); rotorAStrings.Add("II (K) -- since Feb. 1939"); rotorAStrings.Add("III (K) -- since Feb. 1939");
310                        rotor1 = 0; rotor2 = 1; rotor3 = 2; OnPropertyChanged("Rotor1"); OnPropertyChanged("Rotor2"); OnPropertyChanged("Rotor3");
311                        rotorBStrings.Clear(); rotorBStrings.Add("Not available for this model."); rotor4 = 0; OnPropertyChanged("Rotor4");
312                        reflectorStrings.Clear(); reflectorStrings.Add("UKW (K) -- since Feb. 1939"); reflector = 0; OnPropertyChanged("Reflector");
313                        hideSettingsElement("Rotor4"); hideSettingsElement("Ring4");
314                        showSettingsElement("Reflector");
315                        break;
316                    case 6: // Enigam G / Abwehr
317                        actionStrings.Clear(); actionStrings.Add("Encrypt / Decrypt"); action = 0; OnPropertyChanged("Action");
318                        if (key.Length > 3) key = key.Remove(0, 1); OnPropertyChanged("Key");
319                        rotorAStrings.Clear(); rotorAStrings.Add("I (G)"); rotorAStrings.Add("II (G)"); rotorAStrings.Add("III (G)");
320                        rotor1 = 0; rotor2 = 1; rotor3 = 2; OnPropertyChanged("Rotor1"); OnPropertyChanged("Rotor2"); OnPropertyChanged("Rotor3");
321                        rotorBStrings.Clear(); rotorBStrings.Add("Not available for this model."); rotor4 = 0; OnPropertyChanged("Rotor4");
322                        reflectorStrings.Clear(); reflectorStrings.Add("UKW (G)"); reflector = 0; OnPropertyChanged("Reflector");
323                        hideSettingsElement("Rotor4"); hideSettingsElement("Ring4");
324                        showSettingsElement("Reflector");
325                        break;
326                }
327            }
328        }
329
330
331        [TaskPane("Key (Initial rotor setting)", "Please provide the initial rotor setting for each rotor, e.g. ABCD. Note that the slowest rotor is on the left and the fastest rotor is on the right. Only the Enigma M4 \"Shark\" uses four rotors.",
332            null, 1, false, ControlType.TextBox, ValidationType.RegEx, "^([A-Z]|[a-z]){3,4}$")]
333        public string Key
334        {
335            get { return this.key; }
336            set
337            {
338                if (value != key) hasChanges = true;
339                this.key = value;
340                OnPropertyChanged("Key");
341            }
342        }
343
344
345        [TaskPane("Operation mode", "Select the mode of operation for this Enigma simulator. Note that all Enigmas since Enigma D are working with a reflector and therefore there is not difference between encrypting an decrypting.",
346            null, 2, false, ControlType.DynamicComboBox, new string[] { "ActionStrings" })]
347        [PropertySaveOrder(9)]
348        public int Action
349        {
350            get { return this.action; }
351            set
352            {
353                if (((int)value) != action) hasChanges = true;
354                this.action = (int)value;
355                OnPropertyChanged("Action");
356            }
357        }
358
359        /// <summary>
360        /// This collection contains the values for the Action combobox.
361        /// </summary>
362        [PropertySaveOrder(9)]
363        public ObservableCollection<string> ActionStrings
364        {
365            get { return actionStrings; }
366            set
367            {
368                if (value != actionStrings)
369                {
370                    actionStrings = value;
371                }
372                OnPropertyChanged("ActionStrings");
373            }
374        }
375
376        #region Text options
377
378        [ContextMenu("Unknown symbol handling", "What should be done with encountered characters at the input which are not in the alphabet?",
379            3, ContextMenuControlType.ComboBox, null,
380            new string[] { "Ignore (leave unmodified)", "Remove", "Replace with \'X\'" })]
381        [TaskPane("Unknown symbol handling", "What should be done with encountered characters at the input which are not in the alphabet?",
382            "Text options", 3, false, ControlType.ComboBox,
383            new string[] { "Ignore (leave unmodified)", "Remove", "Replace with \'X\'" })]
384        public int UnknownSymbolHandling
385        {
386            get { return this.unknownSymbolHandling; }
387            set
388            {
389                if ((int)value != unknownSymbolHandling) HasChanges = true;
390                this.unknownSymbolHandling = (int)value;
391                OnPropertyChanged("UnknownSymbolHandling");
392            }
393        }
394
395        [ContextMenu("Case handling", "What should be done with upper and lower case letters?",
396            4, ContextMenuControlType.ComboBox, null,
397            new string[] { "Preserve case", "Convert to upper", "Convert to lower" })]
398        [TaskPane("Case handling", "What should be done with upper and lower case letters?",
399            "Text options", 4, false, ControlType.ComboBox,
400            new string[] { "Preserve case", "Convert to upper", "Convert to lower" })]
401        public int CaseHandling
402        {
403            get { return this.caseHandling; }
404            set
405            {
406                if ((int)value != caseHandling) HasChanges = true;
407                this.caseHandling = (int)value;
408                OnPropertyChanged("CaseHandling");
409            }
410        }
411
412        #endregion
413
414        #region Analysis options
415
416        [TaskPane("Analyze key (initial rotor pos.)", "If checked, the analysis tries to detect the correct key. If unchecked, the value from \"Key\" is used.",
417            "Analysis options", 6, false, ControlType.CheckBox, "", null)]
418        public bool AnalyzeKey
419        {
420            get { return analyzeKey; }
421            set
422            {
423                if (value != analyzeKey)
424                {
425                    analyzeKey = value;
426                    hasChanges = true;
427                    OnPropertyChanged("AnalyzeKey");
428                }
429            }
430        }
431
432        [TaskPane("Analyze used rotors", "If checked, the analysis tries to detect the correct rotors and their positions. If unchecked, the values from the rotor settings are used.",
433            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
434        public bool AnalyzeRotors
435        {
436            get { return analyzeRotors; }
437            set
438            {
439                if (value != analyzeRotors)
440                {
441                    analyzeRotors = value;
442                    hasChanges = true;
443                    OnPropertyChanged("AnalyzeRotors");
444                }
445            }
446        }
447
448        [SettingsFormat(1,"Normal","Normal")]
449        [TaskPane("Include rotor I", "Check if rotor I should be included when analyzing rotors.",
450            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
451        public bool AnalysisUseRotorI
452        {
453            get { return analysisUseRotorI; }
454            set
455            {
456                if (value != analysisUseRotorI)
457                {
458                    analysisUseRotorI = value;
459                    hasChanges = true;
460                    OnPropertyChanged("AnalysisUseRotorI");
461                }
462            }
463        }
464
465        [SettingsFormat(1, "Normal", "Normal")]
466        [TaskPane("Include rotor II", "Check if rotor II should be included when analyzing rotors.",
467            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
468        public bool AnalysisUseRotorII
469        {
470            get { return analysisUseRotorII; }
471            set
472            {
473                if (value != analysisUseRotorII)
474                {
475                    analysisUseRotorII = value;
476                    hasChanges = true;
477                    OnPropertyChanged("AnalysisUseRotorII");
478                }
479            }
480        }
481
482        [SettingsFormat(1, "Normal", "Normal")]
483        [TaskPane("Include rotor III", "Check if rotor III should be included when analyzing rotors.",
484            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
485        public bool AnalysisUseRotorIII
486        {
487            get { return analysisUseRotorIII; }
488            set
489            {
490                if (value != analysisUseRotorIII)
491                {
492                    analysisUseRotorIII = value;
493                    hasChanges = true;
494                    OnPropertyChanged("AnalysisUseRotorIII");
495                }
496            }
497        }
498
499        [SettingsFormat(1, "Normal", "Normal")]
500        [TaskPane("Include rotor IV", "Check if rotor IV should be included when analyzing rotors.",
501            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
502        public bool AnalysisUseRotorIV
503        {
504            get { return analysisUseRotorIV; }
505            set
506            {
507                if (value != analysisUseRotorIV)
508                {
509                    analysisUseRotorIV = value;
510                    hasChanges = true;
511                    OnPropertyChanged("AnalysisUseRotorIV");
512                }
513            }
514        }
515
516
517        [SettingsFormat(1, "Normal", "Normal")]
518        [TaskPane("Include rotor V", "Check if rotor V should be included when analyzing rotors.",
519            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
520        public bool AnalysisUseRotorV
521        {
522            get { return analysisUseRotorV; }
523            set
524            {
525                if (value != analysisUseRotorV)
526                {
527                    analysisUseRotorV = value;
528                    hasChanges = true;
529                    OnPropertyChanged("AnalysisUseRotorV");
530                }
531            }
532        }
533
534        [SettingsFormat(1, "Normal", "Normal")]
535        [TaskPane("Include rotor VI", "Check if rotor VI should be included when analyzing rotors.",
536            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
537        public bool AnalysisUseRotorVI
538        {
539            get { return analysisUseRotorVI; }
540            set
541            {
542                if (value != analysisUseRotorVI)
543                {
544                    analysisUseRotorVI = value;
545                    hasChanges = true;
546                    OnPropertyChanged("AnalysisUseRotorVI");
547                }
548            }
549        }
550
551
552        [SettingsFormat(1, "Normal", "Normal")]
553        [TaskPane("Include rotor VII", "Check if rotor VII should be included when analyzing rotors.",
554            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
555        public bool AnalysisUseRotorVII
556        {
557            get { return analysisUseRotorVII; }
558            set
559            {
560                if (value != analysisUseRotorVII)
561                {
562                    analysisUseRotorVII = value;
563                    hasChanges = true;
564                    OnPropertyChanged("AnalysisUseRotorVII");
565                }
566            }
567        }
568
569
570        [SettingsFormat(1, "Normal", "Normal")]
571        [TaskPane("Include rotor VIII", "Check if rotor VIII should be included when analyzing rotors.",
572            "Analysis options", 7, false, ControlType.CheckBox, "", null)]
573        public bool AnalysisUseRotorVIII
574        {
575            get { return analysisUseRotorVIII; }
576            set
577            {
578                if (value != analysisUseRotorVIII)
579                {
580                    analysisUseRotorVIII = value;
581                    hasChanges = true;
582                    OnPropertyChanged("AnalysisUseRotorVIII");
583                }
584            }
585        }
586
587
588        [TaskPane("Analyze rings settings", "If checked, the analysis tries to detect the correct rings settings. If unchecked, the values from the ring settings are used.",
589            "Analysis options", 8, false, ControlType.CheckBox, "", null)]
590        public bool AnalyzeRings
591        {
592            get { return analyzeRings; }
593            set
594            {
595                if (value != analyzeRings)
596                {
597                    analyzeRings = value;
598                    hasChanges = true;
599                    OnPropertyChanged("AnalyzeRings");
600                }
601            }
602        }
603
604        [TaskPane("Rotor/Ring/Key search method", "Which method should be used to assess the best rotor configuration?", "Analysis options", 8, false, ControlType.ComboBox, new string[] { "Index of coincidence", "log2-bigram", "log2-trigram", "Sinkov unigram", "Sinkov bigram", "Unigram entropy" })]
605        public int KeySearchMethod
606        {
607            get { return this.keySearchMethod; }
608            set
609            {
610                if (value != keySearchMethod)
611                {
612                    hasChanges = true;
613                    keySearchMethod = value;
614                    OnPropertyChanged("KeySearchMethod");
615                }
616            }
617        }
618
619        [TaskPane("Analyze plugs", "If checked, the analysis tries to detect the correct plug settings. If unchecked, the values from the plugboard are used.",
620            "Analysis options", 9, false, ControlType.CheckBox, "", null)]
621        public bool AnalyzePlugs
622        {
623            get { return analyzePlugs; }
624            set
625            {
626                if (value != analyzePlugs)
627                {
628                    analyzePlugs = value;
629                    hasChanges = true;
630                    OnPropertyChanged("AnalyzePlugs");
631                }
632            }
633        }
634       
635        [TaskPane("Max. plugs searched", "Select how many plugs should be searched at most. Note that the search algorithm might return less plugs - this number is just an upper limit",
636            "Analysis options", 9, false, ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 26)]
637        public int MaxSearchedPlugs
638        {
639            get { return this.maxSearchedPlugs; }
640            set
641            {
642                if (value != maxSearchedPlugs)
643                {
644                    hasChanges = true;
645                    maxSearchedPlugs = value;
646                    OnPropertyChanged("MaxSearchedPlugs");
647                }
648            }
649        }
650
651        [TaskPane("Plug search method", "Which method should be used to assess the best plugboard configuration?", "Analysis options", 9, false, ControlType.ComboBox, new string[] { "Index of coincidence", "log2-bigram", "log2-trigram", "Sinkov unigram", "Sinkov bigram", "Unigram entropy" })]
652        public int PlugSearchMethod
653        {
654            get { return this.plugSearchMethod; }
655            set
656            {
657                if (value != plugSearchMethod)
658                {
659                    hasChanges = true;
660                    plugSearchMethod = value;
661                    OnPropertyChanged("PlugSearchMethod");
662                }
663            }
664        }
665
666        #endregion
667
668        #region Used rotor settings
669
670        [TaskPane("Rotor 1 (fastest/right)", "Select the used rotor on the right (fastest) position.",
671            "Used rotors", 10, false, ControlType.DynamicComboBox, new string[] { "RotorAStrings" })]
672        public int Rotor1
673        {
674            get { return this.rotor1; }
675            set
676            {
677                if (((int)value) != rotor1) hasChanges = true;
678                checkRotorChange(1, this.rotor1, value);
679                this.rotor1 = value;
680                OnPropertyChanged("Rotor1");
681            }
682        }
683
684        [TaskPane("Rotor 2", "Select the used rotor on the second position.",
685            "Used rotors", 11, false, ControlType.DynamicComboBox, new string[] { "RotorAStrings" })]
686        public int Rotor2
687        {
688            get { return this.rotor2; }
689            set
690            {
691                if (((int)value) != rotor2) hasChanges = true;
692                checkRotorChange(2, this.rotor2, value);
693                this.rotor2 = (int)value;
694                OnPropertyChanged("Rotor2");
695            }
696        }
697
698        [TaskPane("Rotor 3", "Select the used rotor on the third position.",
699            "Used rotors", 12, false, ControlType.DynamicComboBox, new string[] { "RotorAStrings" })]
700        public int Rotor3
701        {
702            get { return this.rotor3; }
703            set
704            {
705                if (((int)value) != rotor3) hasChanges = true;
706                checkRotorChange(3, this.rotor3, value);
707                this.rotor3 = (int)value;
708                OnPropertyChanged("Rotor3");
709            }
710        }
711
712        [TaskPane("Rotor 4 (slowest/left)", "Select the used rotor on the forth position. If you want to use only three rotors, select none here.",
713            "Used rotors", 13, false, ControlType.DynamicComboBox, new string[] { "RotorBStrings" })]
714        public int Rotor4
715        {
716            get { return this.rotor4; }
717            set
718            {
719                if (((int)value) != rotor4) hasChanges = true;
720                this.rotor4 = (int)value;
721                OnPropertyChanged("Rotor4");
722            }
723        }
724
725
726        [TaskPane("Reflector", "Select the used reflector. If you don't want to use a reflector, select none here.",
727            "Used rotors", 14, false, ControlType.DynamicComboBox, new string[] { "ReflectorStrings" })]
728        public int Reflector
729        {
730            get { return this.reflector; }
731            set
732            {
733                if (((int)value) != reflector) hasChanges = true;
734                this.reflector = (int)value;
735                OnPropertyChanged("Reflector");
736            }
737        }
738
739        /// <summary>
740        /// This collection contains the values for the Rotor 1-3 comboboxes.
741        /// </summary>
742        public ObservableCollection<string> RotorAStrings
743        {
744            get { return rotorAStrings; }
745            set
746            {
747                if (value != rotorAStrings)
748                {
749                    rotorAStrings = value;
750                }
751                OnPropertyChanged("RotorAStrings");
752            }
753        }
754
755        /// <summary>
756        /// This collection contains the values for the Rotor 4 combobox.
757        /// </summary>
758        public ObservableCollection<string> RotorBStrings
759        {
760            get { return rotorBStrings; }
761            set
762            {
763                if (value != rotorBStrings)
764                {
765                    rotorBStrings = value;
766                }
767                OnPropertyChanged("RotorBStrings");
768            }
769        }
770
771        /// <summary>
772        /// This collection contains the values for the Rotor 1-3 comboboxes.
773        /// </summary>
774        public ObservableCollection<string> ReflectorStrings
775        {
776            get { return reflectorStrings; }
777            set
778            {
779                if (value != reflectorStrings)
780                {
781                    reflectorStrings = value;
782                }
783                OnPropertyChanged("ReflectorStrings");
784            }
785        }
786
787        #endregion
788
789        #region Used ring settings
790
791        [TaskPane("Ring 1 (right)", "Select the the offset for ring 1", "Ring settings", 20, false, ControlType.NumericUpDown, ValidationType.RangeInteger,1,26)]
792        public int Ring1
793        {
794            get { return ring1; }
795            set
796            {
797                if (value < ring1)
798                {
799                    hasChanges = true;
800                    ring1 = value;
801                    OnPropertyChanged("Ring1down");
802                }
803                if (value > ring1)
804                {
805                    hasChanges = true;
806                    ring1 = value;
807                    OnPropertyChanged("Ring1up");
808                }
809            }
810        }
811
812        [TaskPane("Ring 2", "Select the the offset for ring 2", "Ring settings", 21, false, ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 26)]
813        public int Ring2
814        {
815            get { return ring2; }
816            set
817            {
818                if (value < ring2)
819                {
820                    hasChanges = true;
821                    ring2 = value;
822                    OnPropertyChanged("Ring2down");
823                }
824                if (value > ring2)
825                {
826                    hasChanges = true;
827                    ring2 = value;
828                    OnPropertyChanged("Ring2up");
829                }
830            }
831        }
832
833        [TaskPane("Ring 3", "Select the the offset for ring 3", "Ring settings", 22, false, ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 26)]
834        public int Ring3
835        {
836            get { return ring3; }
837            set
838            {
839                if (value < ring3)
840                {
841                    hasChanges = true;
842                    ring3 = value;
843                    OnPropertyChanged("Ring3down");
844                }
845                if (value > ring3)
846                {
847                    hasChanges = true;
848                    ring3 = value;
849                    OnPropertyChanged("Ring3up");
850                }
851            }
852        }
853
854        [TaskPane("Ring 4 (left)", "Select the the offset for ring 4", "Ring settings", 23, false, ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 26)]
855        public int Ring4
856        {
857            get { return ring4; }
858            set
859            {
860                if (value < ring4)
861                {
862                    hasChanges = true;
863                    ring4 = value;
864                    OnPropertyChanged("Ring4down");
865                }
866                if (value > ring4)
867                {
868                    hasChanges = true;
869                    ring4 = value;
870                    OnPropertyChanged("Ring4up");
871                }
872            }
873        }
874
875        #endregion
876
877        #region Plugboard settings
878
879        [TaskPane("Plugboard substitution", "Displays the current substitution", "Plugboard", 30, false, ControlType.TextBoxReadOnly)]
880        public string PlugBoard
881        {
882            get { return plugBoard.ToString(); }
883            set { }
884        }
885
886        [TaskPane("Involutoric", "The mapping and the inverse mapping are the same. As an example if A mapps to X, also X is mapped to A", "Plugboard", 31, false, ControlType.CheckBox, "", null)]
887        public bool Involutoric
888        {
889            get { return involutoricPlugBoard; }
890            set
891            {
892                if (value != involutoricPlugBoard)
893                {
894                    involutoricPlugBoard = value;
895                    hasChanges = true;
896                    OnPropertyChanged("Involutoric");
897                }
898            }
899        }
900
901        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
902        [TaskPane("A=", "Select the letter for connecting this plug.", "Plugboard", 40, false, ControlType.ComboBox,
903            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
904        public int PlugBoardA
905        {
906            get { return alphabet.IndexOf(this.plugBoard[0]); }
907            set { setPlugBoard(0, value); }
908        }
909
910        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
911        [TaskPane("B=", "Select the letter for connecting this plug.", "Plugboard", 41, false, ControlType.ComboBox,
912            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
913        public int PlugBoardB
914        {
915            get { return alphabet.IndexOf(this.plugBoard[1]); }
916            set { setPlugBoard(1, value);  }
917        }
918
919        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
920        [TaskPane("C=", "Select the letter for connecting this plug.", "Plugboard", 42, false, ControlType.ComboBox,
921            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
922        public int PlugBoardC
923        {
924            get { return alphabet.IndexOf(this.plugBoard[2]); }
925            set { setPlugBoard(2, value); }
926        }
927
928        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
929        [TaskPane("D=", "Select the letter for connecting this plug.", "Plugboard", 43, false, ControlType.ComboBox,
930            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
931        public int PlugBoardD
932        {
933            get { return alphabet.IndexOf(this.plugBoard[3]); }
934            set { setPlugBoard(3, value); }
935        }
936
937        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
938        [TaskPane("E=", "Select the letter for connecting this plug.", "Plugboard", 44, false, ControlType.ComboBox,
939            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
940        public int PlugBoardE
941        {
942            get { return alphabet.IndexOf(this.plugBoard[4]); }
943            set { setPlugBoard(4, value);  }
944        }
945
946        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
947        [TaskPane("F=", "Select the letter for connecting this plug.", "Plugboard", 45, false, ControlType.ComboBox,
948            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
949        public int PlugBoardF
950        {
951            get { return alphabet.IndexOf(this.plugBoard[5]); }
952            set { setPlugBoard(5, value);  }
953        }
954
955        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
956        [TaskPane("G=", "Select the letter for connecting this plug.", "Plugboard", 46, false, ControlType.ComboBox,
957            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
958        public int PlugBoardG
959        {
960            get { return alphabet.IndexOf(this.plugBoard[6]); }
961            set { setPlugBoard(6, value);  }
962        }
963
964        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
965        [TaskPane("H=", "Select the letter for connecting this plug.", "Plugboard", 47, false, ControlType.ComboBox,
966            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
967        public int PlugBoardH
968        {
969            get { return alphabet.IndexOf(this.plugBoard[7]); }
970            set { setPlugBoard(7, value);  }
971        }
972
973        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
974        [TaskPane("I=", "Select the letter for connecting this plug.", "Plugboard", 48, false, ControlType.ComboBox,
975            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
976        public int PlugBoardI
977        {
978            get { return alphabet.IndexOf(this.plugBoard[8]); }
979            set { setPlugBoard(8, value); }
980        }
981
982        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
983        [TaskPane("J=", "Select the letter for connecting this plug.", "Plugboard", 49, false, ControlType.ComboBox,
984            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
985        public int PlugBoardJ
986        {
987            get { return alphabet.IndexOf(this.plugBoard[9]); }
988            set { setPlugBoard(9, value); }
989        }
990
991        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
992        [TaskPane("K=", "Select the letter for connecting this plug.", "Plugboard", 50, false, ControlType.ComboBox,
993            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
994        public int PlugBoardK
995        {
996            get { return alphabet.IndexOf(this.plugBoard[10]); }
997            set { setPlugBoard(10, value);  }
998        }
999
1000        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
1001        [TaskPane("L=", "Select the letter for connecting this plug.", "Plugboard", 51, false, ControlType.ComboBox,
1002            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1003        public int PlugBoardL
1004        {
1005            get { return alphabet.IndexOf(this.plugBoard[11]); }
1006            set { setPlugBoard(11, value); }
1007        }
1008
1009        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fuenf")]
1010        [TaskPane("M=", "Select the letter for connecting this plug.", "Plugboard", 52, false, ControlType.ComboBox,
1011            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1012        public int PlugBoardM
1013        {
1014            get { return alphabet.IndexOf(this.plugBoard[12]); }
1015            set { setPlugBoard(12, value); }
1016        }
1017
1018        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fuenf")]
1019        [TaskPane("N=", "Select the letter for connecting this plug.", "Plugboard", 53, false, ControlType.ComboBox,
1020            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1021        public int PlugBoardN
1022        {
1023            get { return alphabet.IndexOf(this.plugBoard[13]); }
1024            set { setPlugBoard(13, value);  }
1025        }
1026
1027        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fuenf")]
1028        [TaskPane("O=", "Select the letter for connecting this plug.", "Plugboard", 54, false, ControlType.ComboBox,
1029            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1030        public int PlugBoardO
1031        {
1032            get { return alphabet.IndexOf(this.plugBoard[14]); }
1033            set { setPlugBoard(14, value);  }
1034        }
1035
1036        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sechs")]
1037        [TaskPane("P=", "Select the letter for connecting this plug.", "Plugboard", 55, false, ControlType.ComboBox,
1038            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1039        public int PlugBoardP
1040        {
1041            get { return alphabet.IndexOf(this.plugBoard[15]); }
1042            set { setPlugBoard(15, value); }
1043        }
1044
1045        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sechs")]
1046        [TaskPane("Q=", "Select the letter for connecting this plug.", "Plugboard", 56, false, ControlType.ComboBox,
1047            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1048        public int PlugBoardQ
1049        {
1050            get { return alphabet.IndexOf(this.plugBoard[16]); }
1051            set { setPlugBoard(16, value); }
1052        }
1053
1054        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sechs")]
1055        [TaskPane("R=", "Select the letter for connecting this plug.", "Plugboard", 57, false, ControlType.ComboBox,
1056            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1057        public int PlugBoardR
1058        {
1059            get { return alphabet.IndexOf(this.plugBoard[17]); }
1060            set { setPlugBoard(17, value);  }
1061        }
1062
1063        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sieben")]
1064        [TaskPane("S=", "Select the letter for connecting this plug.", "Plugboard", 58, false, ControlType.ComboBox,
1065            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1066        public int PlugBoardS
1067        {
1068            get { return alphabet.IndexOf(this.plugBoard[18]); }
1069            set { setPlugBoard(18, value); }
1070        }
1071
1072        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sieben")]
1073        [TaskPane("T=", "Select the letter for connecting this plug.", "Plugboard", 59, false, ControlType.ComboBox,
1074            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1075        public int PlugBoardT
1076        {
1077            get { return alphabet.IndexOf(this.plugBoard[19]); }
1078            set { setPlugBoard(19, value); }
1079        }
1080
1081        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sieben")]
1082        [TaskPane("U=", "Select the letter for connecting this plug.", "Plugboard", 60, false, ControlType.ComboBox,
1083            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1084        public int PlugBoardU
1085        {
1086            get { return alphabet.IndexOf(this.plugBoard[20]); }
1087            set { setPlugBoard(20, value); }
1088        }
1089
1090        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Acht")]
1091        [TaskPane("V=", "Select the letter for connecting this plug.", "Plugboard", 61, false, ControlType.ComboBox,
1092            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1093        public int PlugBoardV
1094        {
1095            get { return alphabet.IndexOf(this.plugBoard[21]); }
1096            set { setPlugBoard(21, value); }
1097        }
1098
1099        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto","*", "Acht")]
1100        [TaskPane("W=", "Select the letter for connecting this plug.", "Plugboard", 62, false, ControlType.ComboBox,
1101            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1102        public int PlugBoardW
1103        {
1104            get { return alphabet.IndexOf(this.plugBoard[22]); }
1105            set { setPlugBoard(22, value); }
1106        }
1107
1108        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal,"Auto","*" ,"Acht")]
1109        [TaskPane("X=", "Select the letter for connecting this plug.", "Plugboard", 63, false, ControlType.ComboBox,
1110            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1111        public int PlugBoardX
1112        {
1113            get { return alphabet.IndexOf(this.plugBoard[23]); }
1114            set { setPlugBoard(23, value);  }
1115        }
1116
1117        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Neun")]
1118        [TaskPane("Y=", "Select the letter for connecting this plug.", "Plugboard", 64, false, ControlType.ComboBox,
1119            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1120        public int PlugBoardY
1121        {
1122            get { return alphabet.IndexOf(this.plugBoard[24]); }
1123            set { setPlugBoard(24, value); }
1124        }
1125
1126        [SettingsFormat(1, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Neun")]
1127        [TaskPane("Z=", "Select the letter for connecting this plug.", "Plugboard", 65, false, ControlType.ComboBox,
1128            new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" })]
1129        public int PlugBoardZ
1130        {
1131            get { return alphabet.IndexOf(this.plugBoard[25]); }
1132            set { setPlugBoard(25, value); }
1133        }
1134
1135
1136        [TaskPane("Remove all plugs", "By pressing this button the plugboard is reset to its empty state, i.e. all plugs are removed", "Plugboard", 70, false, ControlType.Button)]
1137        public void ResetPlugboard()
1138        {
1139            plugBoard = new StringBuilder("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
1140            OnPropertyChanged("PlugBoardDisplay");
1141            for (int i = 0; i < alphabet.Length; i++)
1142            {
1143                OnPropertyChanged("PlugBoard" + alphabet[i]);
1144            }
1145        }
1146
1147        #endregion
1148
1149        #endregion
1150
1151        #region ISettings Member
1152
1153        public bool HasChanges
1154        {
1155            get
1156            {
1157                return hasChanges;
1158            }
1159            set
1160            {
1161                hasChanges = value;
1162            }
1163        }
1164
1165        #endregion
1166
1167        #region INotifyPropertyChanged Member
1168
1169        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
1170
1171        protected void OnPropertyChanged(string name)
1172        {
1173            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
1174        }
1175
1176        #endregion
1177    }
1178}
Note: See TracBrowser for help on using the repository browser.