Ignore:
Timestamp:
Sep 14, 2009, 12:48:34 PM (12 years ago)
Author:
angelov
Message:

Manual Input by "PlugBoard";
New Input for dictionary hits => "Contains" plug-in have to get new integer output;

Location:
trunk/CrypPlugins/MonoalphabeticAnalysis
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/MonoalphabeticAnalysis/MonoalphabeticAnalysis.cs

    r476 r512  
    4949        public string PathToDigramStatistics = "CrypPlugins/MonoalphabeticAnalysis_di_en.txt";
    5050        private string alphabetCaseInsensitive = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    51 
     51        private bool finished = false;
    5252
    5353        #region Properties (Inputs/Outputs)
     
    9696
    9797
     98
     99        private int dictionaryHits;
     100        [PropertyInfo(Direction.InputData, "Words Found in Dictionary", "Words Found in Dictionary", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     101        public int DictionaryHits
     102        {
     103            get
     104            {
     105                return dictionaryHits;
     106            }
     107            set { dictionaryHits = value; OnPropertyChanged("DictionaryHits"); }
     108        }
     109
     110
    98111        [PropertyInfo(Direction.OutputData, "String output", "Proposal Alphabets", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    99112        public string StringOutput
     
    139152
    140153        private MonoalphabeticAnalysisSettings settings;
     154
    141155        public ISettings Settings
    142156        {
    143             get { return settings; }
    144             set { settings = (MonoalphabeticAnalysisSettings)value; }
     157            get { return (ISettings)this.settings; }
     158            set { this.settings = (MonoalphabeticAnalysisSettings)value; }
    145159        }
    146160        // private FrequencyTestPresentation presentation;
    147161        public MonoalphabeticAnalysis()
    148162        {
    149             settings = new MonoalphabeticAnalysisSettings();
     163            this.settings = new MonoalphabeticAnalysisSettings();
     164            //settings = new MonoalphabeticAnalysisSettings();
    150165            // presentation = new FrequencyTestPresentation(this);
    151166            // Presentation = presentation;
     
    167182        //EXECUTE!!!//    //IMPLEMENTATION ATTEMPT OF THE ALGORITHM: Jakobsen, Thomas(1995)'A FAST METHOD FOR CRYPTANALYSIS OF SUBSTITUTION CIPHERS',Cryptologia,19:3,265 — 274
    168183        //////////////
    169      
    170         public void Execute()
    171         {
    172            
    173 
    174             if (cipherTextFrequencyInput_Monograms != "")
    175             {
    176 
    177                //File.WriteAllText("veriinterestingfilewithmonogramstatistic", textStatisticInput_Monograms);
    178                // File.WriteAllText("veriinterestingfilewithdigramstatistic", textStatisticInput_Digrams);
     184
     185        public void Execute()
     186        {
     187            if (settings.SuggestSubstitutionManually == true && settings.WorkKey != "" )
     188            {
     189                stringOutput = settings.WorkKey;
     190                OnPropertyChanged("StringOutput");
    179191               
    180                // ImplementSettings();
    181                 //if Optional Statistical input not used -> use variables from pre-analysed Text (James Clavel's Shogun in our case) 
    182                 if (textStatisticInput_Monograms == "") textStatisticInput_Monograms = ShogunStatistics.ShogunMonograms;//File.ReadAllText(PathToMonogramStatistics);
    183                 if (textStatisticInput_Digrams == "") textStatisticInput_Digrams = ShogunStatistics.ShogunDigrams;//File.ReadAllText(PathToDigramStatistics);
    184 
    185                  if (GoodAlphabet == null) //first pass
    186                  {
    187                      //GoodAlphabet equals null means initial alphabet should be generated
    188                     string alphabet = "";
    189                     ArrayList mapping1 = InitialMapping(cipherTextFrequencyInput_Monograms, textStatisticInput_Monograms);
    190 
    191                     alphabet = AlphabetFromMapping(mapping1);
    192 
    193                     GoodAlphabet = alphabet;
    194                     stringOutput = MapDecryptKeyAlphabet(alphabet);
    195                     OnPropertyChanged("StringOutput");
    196 
    197                  }
    198 
     192            }
     193            else
     194            {
     195
     196
     197                if (cipherTextFrequencyInput_Monograms != "")
     198                {
     199
     200                    //File.WriteAllText("veriinterestingfilewithmonogramstatistic", textStatisticInput_Monograms);
     201                    // File.WriteAllText("veriinterestingfilewithdigramstatistic", textStatisticInput_Digrams);
     202
     203                    // ImplementSettings();
     204                    //if Optional Statistical input not used -> use variables from pre-analysed Text (James Clavel's Shogun in our case) 
     205                    if (textStatisticInput_Monograms == "") textStatisticInput_Monograms = ShogunStatistics.ShogunMonograms;//File.ReadAllText(PathToMonogramStatistics);//
     206                    if (textStatisticInput_Digrams == "") textStatisticInput_Digrams = ShogunStatistics.ShogunDigrams;//File.ReadAllText(PathToDigramStatistics);//
     207
     208                    if (GoodAlphabet == null) //first pass
     209                    {
     210                        //GoodAlphabet equals null means initial alphabet should be generated
     211                        string alphabet = "";
     212                        ArrayList mapping1 = InitialMapping(cipherTextFrequencyInput_Monograms, textStatisticInput_Monograms);
     213
     214                        alphabet = AlphabetFromMapping(mapping1);
     215
     216                        GoodAlphabet = alphabet;
     217                        stringOutput = MapDecryptKeyAlphabet(alphabet);
     218                       
     219
     220                    }
     221
     222
     223
     224                    if (GoodAlphabet != null && decipherAttempt_Digrams != "" && AlphabetcounterB < GoodAlphabet.Length)
     225                    {
     226
     227                        double goodness = ReturnAlphabetGoodness();
     228                        if (alphabetGoodnes == 0) //secondpass
     229                        {
     230
     231                            if (settings.FastAproach == 1)
     232                            {
     233                                alphabetGoodnes = goodness;
     234                                FastAproach();
     235
     236
     237                            }
     238
     239
     240                            else
     241                            {
     242                                alphabetGoodnes = goodness;
     243                                string alphabet1 = GenerateNextAlphabet();
     244                                NextAlphabet = alphabet1;
     245                                stringOutput = MapDecryptKeyAlphabet(NextAlphabet);
     246                               
     247                            }
     248
     249
     250
     251
     252                        }
     253
     254                        if (alphabetGoodnes > goodness && settings.FastAproach == 0) //third pass and on
     255                        {
     256                            GoodAlphabet = NextAlphabet;
     257                            alphabetGoodnes = goodness;
     258
     259                            string alphabet1 = GenerateNextAlphabet();
     260                            NextAlphabet = alphabet1;
     261                            stringOutput = MapDecryptKeyAlphabet(NextAlphabet);
     262                           
     263                        }
     264
     265                        if (alphabetGoodnes < goodness && settings.FastAproach == 0)
     266                        {
     267                            string alphabet1 = GenerateNextAlphabet();
     268                            NextAlphabet = alphabet1;
     269                            stringOutput = MapDecryptKeyAlphabet(NextAlphabet);
     270                           
     271                        }
     272
     273                        if (AlphabetcounterB == GoodAlphabet.Length)
     274                        {
     275                            stringOutput = MapDecryptKeyAlphabet(GoodAlphabet);
     276                           
     277                        }
     278
     279                    }
     280
     281
     282
     283
     284                }
     285
     286
     287
     288                ((MonoalphabeticAnalysisSettings)this.settings).PlugBoard = stringOutput;
     289                ((MonoalphabeticAnalysisSettings)this.settings).WorkKey = stringOutput;
     290                ((MonoalphabeticAnalysisSettings)this.settings).ProposalKey = stringOutput;
    199291               
    200                
    201                  if (GoodAlphabet != null && decipherAttempt_Digrams!="" && AlphabetcounterB < GoodAlphabet.Length)
    202                  {
    203 
    204                      double goodness = ReturnAlphabetGoodness();
    205                      if (alphabetGoodnes == 0) //secondpass
    206                      {
    207 
    208                          if (settings.FastAproach==1)
    209                          {
    210                              alphabetGoodnes = goodness;
    211                              FastAproach();
    212 
    213 
    214                          }
    215 
    216 
    217                          else
    218                          {
    219                              alphabetGoodnes = goodness;
    220                              string alphabet1 = GenerateNextAlphabet();
    221                              NextAlphabet = alphabet1;
    222                              stringOutput = MapDecryptKeyAlphabet(NextAlphabet);
    223                              OnPropertyChanged("StringOutput");
    224                          }
    225                          
    226 
    227 
    228 
    229                      }
    230                      
    231                      if (alphabetGoodnes > goodness && settings.FastAproach==0) //third pass and on
    232                      {
    233                          GoodAlphabet = NextAlphabet;
    234                          alphabetGoodnes = goodness;
    235                          
    236                          string alphabet1 = GenerateNextAlphabet();
    237                          NextAlphabet = alphabet1;
    238                          stringOutput = MapDecryptKeyAlphabet(NextAlphabet);
    239                          OnPropertyChanged("StringOutput");
    240                      }
    241 
    242                      if (alphabetGoodnes < goodness && settings.FastAproach == 0)
    243                      {
    244                          string alphabet1 = GenerateNextAlphabet();
    245                          NextAlphabet = alphabet1;
    246                          stringOutput = MapDecryptKeyAlphabet(NextAlphabet);
    247                          OnPropertyChanged("StringOutput");
    248                      }
    249 
    250                      if (AlphabetcounterB == GoodAlphabet.Length)
    251                      {
    252                          stringOutput = MapDecryptKeyAlphabet(GoodAlphabet);
    253                          OnPropertyChanged("StringOutput");
    254                      }
    255 
    256                  }
    257 
    258                
    259                
    260 
    261             }
    262 
    263            
    264            
    265                
    266 
    267         }
    268 
    269 
     292                OnPropertyChanged("StringOutput");
     293            }
     294
     295        }
    270296
    271297        public void PostExecution()
     
    635661
    636662          stringOutput = MapDecryptKeyAlphabet(GoodAlphabet);
     663       
     664         
    637665          OnPropertyChanged("StringOutput");
    638 
    639666
    640667      }
  • trunk/CrypPlugins/MonoalphabeticAnalysis/MonoalphabeticAnalysis.csproj

    r476 r512  
    6363    <Compile Include="CollectionElement.cs" />
    6464    <Compile Include="MonoalphabeticAnalysis.cs" />
    65     <Compile Include="MonoalphabeticAnalysisSettings.cs" />
     65    <Compile Include="..\..\..\..\MonoalphabeticAnalysisSettings.cs">
     66      <Link>MonoalphabeticAnalysisSettings.cs</Link>
     67    </Compile>
    6668    <Compile Include="ShogunStatistics.cs" />
    6769    <Compile Include="SortElements.cs" />
  • trunk/CrypPlugins/MonoalphabeticAnalysis/MonoalphabeticAnalysisSettings.cs

    r476 r512  
    2020
    2121        #endregion
    22        
     22
     23        private string proposalKey = "";
     24        public string ProposalKey
     25        {
     26            get { return proposalKey; }
     27            set {
     28                  proposalKey = value;
     29                  //hasChanges = true;
     30                }
     31        }
     32
     33        private string workKey = "";
     34        public string WorkKey
     35        {
     36            get { return workKey; }
     37            set
     38            {
     39                workKey = value;
     40                //hasChanges = true;
     41            }
     42        }
     43
     44        private string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     45        //private bool involutoricPlugBoard = true;
     46        private bool suggestSubstitutionManually = false;
     47        private string plugBoard = "";
     48       
     49        private char[] workKeyCharArray = new char[26];
     50
     51
     52        private void setPlugBoard(int letterPos, int newIndex)
     53        {
     54                if (workKey[letterPos] != proposalKey[letterPos]) //Change has been made. Must be undone
     55                {   hasChanges=true;
     56                    this.workKeyCharArray = this.workKey.ToCharArray(); 
     57                    char currentworkchar = this.workKey[letterPos];
     58                    this.workKeyCharArray[letterPos] = this.proposalKey[letterPos];
     59                    int indexofcurrentworkchar = this.proposalKey.IndexOf(currentworkchar);
     60                    this.workKeyCharArray[indexofcurrentworkchar] = currentworkchar;
     61                    this.workKey= new string(this.workKeyCharArray);
     62                }
     63
     64                hasChanges = true;
     65
     66                this.workKeyCharArray = this.workKey.ToCharArray(); 
     67               
     68                char newKeyChar=this.workKey[newIndex];
     69               
     70                char currentKeyChar = this.workKey[letterPos];
     71
     72                this.workKeyCharArray[letterPos] = newKeyChar;
     73
     74                this.workKeyCharArray[newIndex] = currentKeyChar;
     75
     76                this.workKey = new string(workKeyCharArray);
     77
     78                this.PlugBoard= this.workKey;
     79
     80                OnPropertyChanged("PlugBoard");
     81
     82                OnPropertyChanged("PlugBoardDisplay");
     83           
     84        }
     85
    2386       
    2487        private int fastAproach = 0;
     
    2689
    2790       
    28         [PropertySaveOrder(1)]
    29         [ContextMenu("Generate digram matrix internally", "When the digram matrix is generated internally, the time for calculating the cost function is significantly reduced. ", 7, DisplayLevel.Expert, ContextMenuControlType.ComboBox, null, new string[] { "Don't generate internally", "Generate internally" })]
    30         [TaskPane("Digram matrix", "When the digram matrix is generated internally, the time for calculating the cost function is significantly reduced.", "", 7, false, DisplayLevel.Expert, ControlType.ComboBox, new string[] { "Don't generate internally", "Generate internally" })]
     91        //[PropertySaveOrder(1)]
     92        [ContextMenu("Generate digram matrix internally", "When the digram matrix is generated internally, the time for calculating the cost function is significantly reduced. ", 27, DisplayLevel.Expert, ContextMenuControlType.ComboBox, null, new string[] { "Don't generate internally", "Generate internally" })]
     93        [TaskPane("Digram matrix", "When the digram matrix is generated internally, the time for calculating the cost function is significantly reduced.", "", 27, false, DisplayLevel.Expert, ControlType.ComboBox, new string[] { "Don't generate internally", "Generate internally" })]
    3194        public int FastAproach
    3295        {
     
    83146            }
    84147        }   */
     148
     149
     150        #region Plugboard settings
     151
     152
     153       
     154
     155
     156        [TaskPane("ManualSuggestion", "Once you have a key proposittion you can make fixes according to the decipher results. Use the Letter drop-down boxes to correct the text in substitution decipher output, check 'Manual Suggestion'(Me) and 'play' the chain again. Good Luck! ", "", 28, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     157        public bool SuggestSubstitutionManually
     158        {
     159            get { return suggestSubstitutionManually; }
     160            set
     161            {
     162                if (value != suggestSubstitutionManually)
     163                {
     164                    suggestSubstitutionManually = value;
     165                    hasChanges = true;
     166                    OnPropertyChanged("ManualSuggestion");
     167                }
     168            }
     169        }
     170
     171
     172        [TaskPane("Plaintext Alphabet", "Displays the Plaintext alphabet", "", 29, false, DisplayLevel.Beginner, ControlType.TextBoxReadOnly)]
     173        public string PlaintextAlphabet
     174        {
     175            get { return alphabet; }
     176           
     177            set { } 
     178        }
    85179       
     180
     181        [TaskPane("Key Proposal", "Displays the current key proposal", "", 30, false, DisplayLevel.Beginner, ControlType.TextBoxReadOnly)]
     182        public string PlugBoard
     183        {
     184            get {
     185                 return this.plugBoard;
     186                }
     187
     188            set
     189            {
     190                hasChanges = true;
     191                plugBoard = value;
     192               OnPropertyChanged("Plugboard");
     193            }
     194        }
     195       
     196   /*     [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, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     197        public bool Involutoric
     198        {
     199            get { return involutoricPlugBoard; }
     200            set
     201            {
     202                if (value != involutoricPlugBoard)
     203                {
     204                    involutoricPlugBoard = value;
     205                    hasChanges = true;
     206                    OnPropertyChanged("Involutoric");
     207                }
     208            }
     209        }*/
     210
     211        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
     212        [TaskPane("A=", "Select the letter for connecting this plug.", "", 40, false, DisplayLevel.Beginner, ControlType.ComboBox,
     213            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" })]
     214        public int PlugBoardA
     215        {
     216            get { return alphabet.IndexOf(this.alphabet[0]); }
     217            set { setPlugBoard(0, value); }
     218        }
     219
     220        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
     221        [TaskPane("B=", "Select the letter for connecting this plug.", "", 41, false, DisplayLevel.Beginner, ControlType.ComboBox,
     222            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" })]
     223        public int PlugBoardB
     224        {
     225            get { return alphabet.IndexOf(this.plugBoard[1]); }
     226            set { setPlugBoard(1, value); }
     227        }
     228
     229        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
     230        [TaskPane("C=", "Select the letter for connecting this plug.", "", 42, false, DisplayLevel.Beginner, ControlType.ComboBox,
     231            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" })]
     232        public int PlugBoardC
     233        {
     234            get { return alphabet.IndexOf(this.plugBoard[2]); }
     235            set { setPlugBoard(2, value); }
     236        }
     237
     238        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
     239        [TaskPane("D=", "Select the letter for connecting this plug.", "", 43, false, DisplayLevel.Beginner, ControlType.ComboBox,
     240            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" })]
     241        public int PlugBoardD
     242        {
     243            get { return alphabet.IndexOf(this.plugBoard[3]); }
     244            set { setPlugBoard(3, value); }
     245        }
     246
     247        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
     248        [TaskPane("E=", "Select the letter for connecting this plug.", "", 44, false, DisplayLevel.Beginner, ControlType.ComboBox,
     249            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" })]
     250        public int PlugBoardE
     251        {
     252            get { return alphabet.IndexOf(this.plugBoard[4]); }
     253            set { setPlugBoard(4, value); }
     254        }
     255
     256        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
     257        [TaskPane("F=", "Select the letter for connecting this plug.", "", 45, false, DisplayLevel.Beginner, ControlType.ComboBox,
     258            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" })]
     259        public int PlugBoardF
     260        {
     261            get { return alphabet.IndexOf(this.plugBoard[5]); }
     262            set { setPlugBoard(5, value); }
     263        }
     264
     265        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
     266        [TaskPane("G=", "Select the letter for connecting this plug.", "", 46, false, DisplayLevel.Beginner, ControlType.ComboBox,
     267            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" })]
     268        public int PlugBoardG
     269        {
     270            get { return alphabet.IndexOf(this.plugBoard[6]); }
     271            set { setPlugBoard(6, value); }
     272        }
     273
     274        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
     275        [TaskPane("H=", "Select the letter for connecting this plug.", "", 47, false, DisplayLevel.Beginner, ControlType.ComboBox,
     276            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" })]
     277        public int PlugBoardH
     278        {
     279            get { return alphabet.IndexOf(this.plugBoard[7]); }
     280            set { setPlugBoard(7, value); }
     281        }
     282
     283        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
     284        [TaskPane("I=", "Select the letter for connecting this plug.", "", 48, false, DisplayLevel.Beginner, ControlType.ComboBox,
     285            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" })]
     286        public int PlugBoardI
     287        {
     288            get { return alphabet.IndexOf(this.plugBoard[8]); }
     289            set { setPlugBoard(8, value); }
     290        }
     291
     292        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
     293        [TaskPane("J=", "Select the letter for connecting this plug.", "", 49, false, DisplayLevel.Beginner, ControlType.ComboBox,
     294            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" })]
     295        public int PlugBoardJ
     296        {
     297            get { return alphabet.IndexOf(this.plugBoard[9]); }
     298            set { setPlugBoard(9, value); }
     299        }
     300
     301        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
     302        [TaskPane("K=", "Select the letter for connecting this plug.", "", 50, false, DisplayLevel.Beginner, ControlType.ComboBox,
     303            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" })]
     304        public int PlugBoardK
     305        {
     306            get { return alphabet.IndexOf(this.plugBoard[10]); }
     307            set { setPlugBoard(10, value); }
     308        }
     309
     310        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
     311        [TaskPane("L=", "Select the letter for connecting this plug.", "", 51, false, DisplayLevel.Beginner, ControlType.ComboBox,
     312            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" })]
     313        public int PlugBoardL
     314        {
     315            get { return alphabet.IndexOf(this.plugBoard[11]); }
     316            set { setPlugBoard(11, value); }
     317        }
     318
     319        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fuenf")]
     320        [TaskPane("M=", "Select the letter for connecting this plug.", "", 52, false, DisplayLevel.Beginner, ControlType.ComboBox,
     321            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" })]
     322        public int PlugBoardM
     323        {
     324            get { return alphabet.IndexOf(this.plugBoard[12]); }
     325            set { setPlugBoard(12, value); }
     326        }
     327
     328        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fuenf")]
     329        [TaskPane("N=", "Select the letter for connecting this plug.", "", 53, false, DisplayLevel.Beginner, ControlType.ComboBox,
     330            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" })]
     331        public int PlugBoardN
     332        {
     333            get { return alphabet.IndexOf(this.plugBoard[13]); }
     334            set { setPlugBoard(13, value); }
     335        }
     336
     337        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fuenf")]
     338        [TaskPane("O=", "Select the letter for connecting this plug.", "", 54, false, DisplayLevel.Beginner, ControlType.ComboBox,
     339            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" })]
     340        public int PlugBoardO
     341        {
     342            get { return alphabet.IndexOf(this.plugBoard[14]); }
     343            set { setPlugBoard(14, value); }
     344        }
     345
     346        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sechs")]
     347        [TaskPane("P=", "Select the letter for connecting this plug.", "", 55, false, DisplayLevel.Beginner, ControlType.ComboBox,
     348            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" })]
     349        public int PlugBoardP
     350        {
     351            get { return alphabet.IndexOf(this.plugBoard[15]); }
     352            set { setPlugBoard(15, value); }
     353        }
     354
     355        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sechs")]
     356        [TaskPane("Q=", "Select the letter for connecting this plug.", "", 56, false, DisplayLevel.Beginner, ControlType.ComboBox,
     357            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" })]
     358        public int PlugBoardQ
     359        {
     360            get { return alphabet.IndexOf(this.plugBoard[16]); }
     361            set { setPlugBoard(16, value); }
     362        }
     363
     364        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sechs")]
     365        [TaskPane("R=", "Select the letter for connecting this plug.", "", 57, false, DisplayLevel.Beginner, ControlType.ComboBox,
     366            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" })]
     367        public int PlugBoardR
     368        {
     369            get { return alphabet.IndexOf(this.plugBoard[17]); }
     370            set { setPlugBoard(17, value); }
     371        }
     372
     373        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sieben")]
     374        [TaskPane("S=", "Select the letter for connecting this plug.", "", 58, false, DisplayLevel.Beginner, ControlType.ComboBox,
     375            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" })]
     376        public int PlugBoardS
     377        {
     378            get { return alphabet.IndexOf(this.plugBoard[18]); }
     379            set { setPlugBoard(18, value); }
     380        }
     381
     382        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sieben")]
     383        [TaskPane("T=", "Select the letter for connecting this plug.", "", 59, false, DisplayLevel.Beginner, ControlType.ComboBox,
     384            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" })]
     385        public int PlugBoardT
     386        {
     387            get { return alphabet.IndexOf(this.plugBoard[19]); }
     388            set { setPlugBoard(19, value); }
     389        }
     390
     391        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Sieben")]
     392        [TaskPane("U=", "Select the letter for connecting this plug.", "", 60, false, DisplayLevel.Beginner, ControlType.ComboBox,
     393            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" })]
     394        public int PlugBoardU
     395        {
     396            get { return alphabet.IndexOf(this.plugBoard[20]); }
     397            set { setPlugBoard(20, value); }
     398        }
     399
     400        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Acht")]
     401        [TaskPane("V=", "Select the letter for connecting this plug.", "", 61, false, DisplayLevel.Beginner, ControlType.ComboBox,
     402            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" })]
     403        public int PlugBoardV
     404        {
     405            get { return alphabet.IndexOf(this.plugBoard[21]); }
     406            set { setPlugBoard(21, value); }
     407        }
     408
     409        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Acht")]
     410        [TaskPane("W=", "Select the letter for connecting this plug.", "", 62, false, DisplayLevel.Beginner, ControlType.ComboBox,
     411            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" })]
     412        public int PlugBoardW
     413        {
     414            get { return alphabet.IndexOf(this.plugBoard[22]); }
     415            set { setPlugBoard(22, value); }
     416        }
     417
     418        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Acht")]
     419        [TaskPane("X=", "Select the letter for connecting this plug.", "", 63, false, DisplayLevel.Beginner, ControlType.ComboBox,
     420            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" })]
     421        public int PlugBoardX
     422        {
     423            get { return alphabet.IndexOf(this.plugBoard[23]); }
     424            set { setPlugBoard(23, value); }
     425        }
     426
     427        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Neun")]
     428        [TaskPane("Y=", "Select the letter for connecting this plug.", "", 64, false, DisplayLevel.Beginner, ControlType.ComboBox,
     429            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" })]
     430        public int PlugBoardY
     431        {
     432            get { return alphabet.IndexOf(this.plugBoard[24]); }
     433            set { setPlugBoard(24, value); }
     434        }
     435
     436        [SettingsFormat(1, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Neun")]
     437        [TaskPane("Z=", "Select the letter for connecting this plug.", "", 65, false, DisplayLevel.Beginner, ControlType.ComboBox,
     438            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" })]
     439        public int PlugBoardZ
     440        {
     441            get { return alphabet.IndexOf(this.plugBoard[25]); }
     442            set { setPlugBoard(25, value); }
     443        }
     444
     445
     446        #endregion
     447
    86448
    87449        #region INotifyPropertyChanged Members
Note: See TracChangeset for help on using the changeset viewer.