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

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

Enigma Presentation first implementation attempt.

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