Changeset 5961


Ignore:
Timestamp:
Apr 17, 2014, 6:53:30 PM (8 years ago)
Author:
weyers
Message:

SIGABA Known Plaintext Keyspace cipherrotor limitation feature added

Location:
trunk/CrypPluginsExperimental/SIgabaKnownPlaintext
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginsExperimental/SIgabaKnownPlaintext/Properties/Resources.resx

    r5955 r5961  
    443443  </data>
    444444  <data name="PluginCaption" xml:space="preserve">
    445     <value>SigabaBruteforce</value>
     445    <value>SIGABA Known Plaintext</value>
    446446  </data>
    447447  <data name="PluginToolTip" xml:space="preserve">
    448     <value>Analyzing tool for the American rotor cipher machine SIGABA</value>
     448    <value>Analyzing tool for the American rotor cipher machine SIGABA with known plaintext</value>
    449449  </data>
    450450  <data name="SigabaSettings_SigabaSettings_Cipher" xml:space="preserve">
  • trunk/CrypPluginsExperimental/SIgabaKnownPlaintext/SigabaKnownPlaintext.cs

    r5957 r5961  
    3737namespace SigabaKnownPlaintext
    3838{
    39     // HOWTO: Change author name, email address, organization and URL.
    40     [Author("Anonymous", "coredevs@cryptool.org", "CrypTool 2 Team", "http://cryptool2.vs.uni-due.de")]
    41     // HOWTO: Change plugin caption (title to appear in CT2) and tooltip.
    42     // You can (and should) provide a user documentation as XML file and an own icon.
    43     [PluginInfo("SIGABA-Widerspruchsbeweis", "", "SigabaPhaseI/userdoc.xml", new[] { "CrypWin/images/default.png" })]
    44     // HOWTO: Change category to one that fits to your plugin. Multiple categories are allowed.
     39
     40    [Author("Julian Weyers", "weyers@cryptool.org", "CrypTool 2 Team", "http://cryptool2.vs.uni-due.de")]
     41
     42
     43    //[PluginInfo("SIGABA-Widerspruchsbeweis", "", "SigabaPhaseI/userdoc.xml", new[] { "CrypWin/images/default.png" })]
     44    [PluginInfo("SigabaKnownPlaintext.Properties.Resources", "PluginCaption", "PluginToolTip",
     45        "Enigma/DetailedDescription/doc.xml",
     46        "Sigaba/Images/Icon.png", "Enigma/Images/encrypt.png", "Enigma/Images/decrypt.png")]
     47
    4548    [ComponentCategory(ComponentCategory.ToolsMisc)]
    4649    public class SigabaKnownPlaintext : ICrypComponent
     
    5255        private SigabaKnownPlaintextPresentaion _sigpa;
    5356        private readonly SigabaKnownPlaintextSettings settings = new SigabaKnownPlaintextSettings();
    54         private SigabaCoreFastKnownPlaintext _core ;
     57        private SigabaCoreFastKnownPlaintext _core;
    5558        private SigabaCoreFastPhaseI _coreP1 = new SigabaCoreFastPhaseI();
    5659
     
    6467            _sigpa = new SigabaKnownPlaintextPresentaion();
    6568            _core = new SigabaCoreFastKnownPlaintext(this);
    66             this.Presentation= _sigpa;
     69            this.Presentation = _sigpa;
    6770            _sigpa.doppelClick += doppelClick;
    6871            //         _coreP2 = new SigabaCoreFastPhaseII(this);
     
    9598        /// </summary>
    9699        [PropertyInfo(Direction.InputData, "Cipher", "Input tooltip description")]
    97         public string Cipher
    98         {
    99             get;
    100             set;
    101         }
     100        public string Cipher { get; set; }
    102101
    103102        [PropertyInfo(Direction.InputData, "Crib", "Input tooltip description")]
    104         public string Crib
    105         {
    106             get;
    107             set;
    108         }
     103        public string Crib { get; set; }
    109104
    110105        /// <summary>
     
    113108        /// </summary>
    114109        [PropertyInfo(Direction.OutputData, "Output name", "Output tooltip description")]
    115         public string Output
    116         {
    117             get;
    118             set;
    119         }
     110        public string Output { get; set; }
    120111
    121112        #endregion
     
    143134        }
    144135
    145         BlockingCollection<KeyValuePair<Survivor, int[][]>> _blocc = new BlockingCollection<KeyValuePair<Survivor, int[][]>>(100);
    146         Task[] _tasks = new Task[Environment.ProcessorCount];
     136        private BlockingCollection<KeyValuePair<Survivor, int[][]>> _blocc =
     137            new BlockingCollection<KeyValuePair<Survivor, int[][]>>(100);
     138
     139        private Task[] _tasks = new Task[Environment.ProcessorCount];
    147140
    148141        /// <summary>
     
    153146            // HOWTO: Use this to show the progress of a plugin algorithm execution in the editor.
    154147            ProgressChanged(0, 1);
    155             bestlist= new List<ValueKey>();
     148            bestlist = new List<ValueKey>();
    156149            double best = Double.MinValue;
    157             bestlist.Add(new ValueKey(){value = Double.MinValue});
     150            bestlist.Add(new ValueKey() {value = Double.MinValue});
    158151
    159152            startime = DateTime.Now;
     
    162155            {
    163156                best = Double.MaxValue;
    164                 bestlist.Add(new ValueKey(){value = Double.MaxValue});
     157                bestlist.Add(new ValueKey() {value = Double.MaxValue});
    165158            }
    166159            list1 = getDummyLinkedList(best);
     
    169162            //SomeOutput = SomeInput - settings.SomeParameter;
    170163
    171            
     164
    172165            survivorProducer();
    173            
     166
    174167            Console.WriteLine(DateTime.Now);
    175168
    176169            OnPropertyChanged("SomeOutput");
    177170
    178            
     171
    179172            ProgressChanged(1, 1);
    180173        }
     
    193186        public void Stop()
    194187        {
    195            
     188
    196189        }
    197190
     
    215208        {
    216209            KeyValuePair<Survivor, int[][]> survivor;
    217            
     210
    218211            while (_blocc.TryTake(out survivor, Timeout.Infinite))
    219212            {
     
    232225                    Console.Write(c);
    233226                }
    234                 foreach ( int[] c in survivor.Value)
     227                foreach (int[] c in survivor.Value)
    235228                {
    236229                    foreach (int i in c)
     
    244237
    245238                //_coreP2.setCodeWheels(survivor.Key.type);
    246                 Stopwatch sw= new Stopwatch();
     239                Stopwatch sw = new Stopwatch();
    247240                sw.Start();
    248241                //List<Candidate> winnerList = _coreP2.stepOneCompact(survivor.Value);
    249242                sw.Stop();
    250243                Console.WriteLine(sw.Elapsed + "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
    251                
    252 
    253             }
    254         }
    255 
    256         ResultEntry actRes ;
     244
     245
     246            }
     247        }
     248
     249        private ResultEntry actRes;
    257250        private DateTime lastUpdate;
    258251        private DateTime startime;
    259252
    260         private List<ValueKey> bestlist ;
     253        private List<ValueKey> bestlist;
    261254
    262255        private void survivorProducer()
    263256        {
    264             int total = 967200*26^5;
     257            int total = 967200*26 ^ 5;
    265258            int tickbig = 0;
    266259            int ticksmall = 0;
    267             lastUpdate=DateTime.Now;
     260
     261            List<string> RotorRevList = new List<string>();
     262
     263            for (int i = 0; i < 32; i++)
     264            {
     265                String s = GetIntBinaryString(i);
     266                if (checkWithSetting(s))
     267                {
     268                    RotorRevList.Add(s);
     269                }
     270            }
     271
     272            lastUpdate = DateTime.Now;
     273
    268274            List<long> ticklist = new List<long>();
    269275            var foo = new int[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    270276            IEnumerable<IEnumerable<int>> combis = foo.Combinations(5);
    271            
    272            
     277
    273278            int counter = 0;
    274279
     
    276281            _core.InitializeRotors();
    277282
    278             for (int enumi = 0; enumi <252; enumi++)
    279             {
    280                
     283            for (int enumi = 0; enumi < 252; enumi++)
     284            {
     285
    281286                int[] arr = combis.ElementAt(enumi).ToArray();
    282 
    283287                int[] f = foo.Except(arr).ToArray();
     288                if(checkWithSetting(arr))
    284289                do
    285290                {
    286291                    for (int y = 0; y < 5; y++)
    287292                    {
    288                         _core.setCipherRotors(y, (byte)arr[y]);
     293                        _core.setCipherRotors(y, (byte) arr[y]);
    289294                    }
    290                     for (int ix = 0; ix < 32; ix++)
     295
     296                    controlMaster.setCipherRotors(4, (byte)(arr[0]));
     297                    controlMaster.setCipherRotors(3, (byte)(arr[1]));
     298                    controlMaster.setCipherRotors(2, (byte)(arr[2]));
     299                    controlMaster.setCipherRotors(1, (byte)(arr[3]));
     300                    controlMaster.setCipherRotors(0, (byte)(arr[4]));
     301
     302                    for (int ix = 0; ix < RotorRevList.Count; ix++)
    291303                    {
     304
     305                        String s = RotorRevList[ix];
    292306                       
    293                         String s = GetIntBinaryString(ix);
    294                         _core.setBool((byte)arr[0], 0, s[0] == '1');
    295                         _core.setBool((byte)arr[1], 1, s[1] == '1');
    296                         _core.setBool((byte)arr[2], 2, s[2] == '1');
    297                         _core.setBool((byte)arr[3], 3, s[3] == '1');
    298                         _core.setBool((byte)arr[4], 4, s[4] == '1');
    299 
    300                        
    301 
    302                        
     307
     308
     309                        _core.setBool((byte) arr[0], 0, s[0] == '1');
     310                        _core.setBool((byte) arr[1], 1, s[1] == '1');
     311                        _core.setBool((byte) arr[2], 2, s[2] == '1');
     312                        _core.setBool((byte) arr[3], 3, s[3] == '1');
     313                        _core.setBool((byte) arr[4], 4, s[4] == '1');
     314
     315                        controlMaster.setBool((byte)arr[0], 4, s[0] == '1');
     316                        controlMaster.setBool((byte)arr[1], 3, s[1] == '1');
     317                        controlMaster.setBool((byte)arr[2], 2, s[2] == '1');
     318                        controlMaster.setBool((byte)arr[3], 1, s[3] == '1');
     319                        controlMaster.setBool((byte)arr[4], 0, s[4] == '1');
     320
    303321                        var enc = new ASCIIEncoding();
    304322
    305                         byte[] loopvars = new byte[] { 0, 0, 0, 0, 0};
    306 
    307                        
    308                        
     323                        byte[] loopvars = new byte[] {  (byte)settings.cipherRotorFrom[0],
     324                                                        (byte)settings.cipherRotorFrom[1],
     325                                                        (byte)settings.cipherRotorFrom[2],
     326                                                        (byte)settings.cipherRotorFrom[3],
     327                                                        (byte)settings.cipherRotorFrom[4] };
     328
    309329                        int[][] test2 = new int[5][];
    310330
    311331                        for (int i = 0; i < 5; i++)
    312332                        {
    313                             test2[i] = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 };
     333                            List<int> temp = new List<int>();
     334
     335                            for (int x = (int)settings.cipherRotorFrom[i]; x < (int)settings.cipherRotorTo[i];x++ )
     336                            {
     337                                temp.Add(x);
     338                            }
     339
     340                            test2[i] = temp.ToArray();
    314341                        }
    315342
     343
     344                        if(checkWithSetting(s))
    316345                        do
    317346                        {
    318                             tickbig++;
    319                             ProgressChanged(tickbig, total);
    320                            
    321                             var retlst = new List<int[][]>();
    322 
    323                             _core.setCodeWheels(arr);
    324                             retlst = _core.PhaseI3(enc.GetBytes(Cipher), enc.GetBytes(Crib), arr, loopvars);
    325                             if (retlst.Count != 0)
     347                            //if(checkWithSetting( loopvars))
    326348                            {
    327                                 List<int[]>[] treetlst = new List<int[]>[Crib.Length];
    328                                 List<List<int>>[] pathLst = new List<List<int>>[Crib.Length];
    329 
    330                                 for (int i = 0; i < retlst.Count; i++)
     349                                tickbig++;
     350                                ProgressChanged(tickbig, total);
     351
     352                                var retlst = new List<int[][]>();
     353
     354                                _core.setCodeWheels(arr);
     355                                retlst = _core.PhaseI3(enc.GetBytes(Cipher), enc.GetBytes(Crib), arr, loopvars);
     356                                if (retlst.Count != 0)
    331357                                {
    332                                     for (int j = 0; j < retlst[i].Length; j++)
     358                                    List<int[]>[] treetlst = new List<int[]>[Crib.Length];
     359                                    List<List<int>>[] pathLst = new List<List<int>>[Crib.Length];
     360
     361                                    for (int i = 0; i < retlst.Count; i++)
    333362                                    {
    334                                         if (treetlst[j] == null)
     363                                        for (int j = 0; j < retlst[i].Length; j++)
    335364                                        {
    336 
    337                                             treetlst[j] = new List<int[]>();
    338                                             treetlst[j].Add(retlst[i][j]);
    339                                             pathLst[j] = new List<List<int>>() {new List<int>()};
    340 
    341                                             //pathLst[j].Last().Add(Array.IndexOf(treetlst[j + 1].ToArray(), retlst[i][j + 1]));
    342 
    343                                         }
    344 
    345                                         Boolean b = true;
    346                                         for (int iy = 0; iy < treetlst[j].Count(); iy++)
    347                                         {
    348                                             if (ArraysEqual(treetlst[j][iy], retlst[i][j]))
     365                                            if (treetlst[j] == null)
    349366                                            {
    350                                                 b = false;
    351                                                 /*    if(j>0)
     367
     368                                                treetlst[j] = new List<int[]>();
     369                                                treetlst[j].Add(retlst[i][j]);
     370                                                pathLst[j] = new List<List<int>>() {new List<int>()};
     371
     372                                                //pathLst[j].Last().Add(Array.IndexOf(treetlst[j + 1].ToArray(), retlst[i][j + 1]));
     373
     374                                            }
     375
     376                                            Boolean b = true;
     377                                            for (int iy = 0; iy < treetlst[j].Count(); iy++)
     378                                            {
     379                                                if (ArraysEqual(treetlst[j][iy], retlst[i][j]))
     380                                                {
     381                                                    b = false;
     382                                                    /*    if(j>0)
    352383                                                    if(!pathLst[j].Last().Contains(Array.IndexOf(treetlst[j+1].ToArray(),retlst[i][j+1])))
    353384                                                    {
    354385                                                        pathLst[j].Last().Add(Array.IndexOf(treetlst[j+1].ToArray(),retlst[i][j+1]));
    355386                                                    }*/
     387                                                }
    356388                                            }
     389
     390
     391                                            if (b)
     392                                            {
     393                                                pathLst[j].Add(new List<int>());
     394                                                treetlst[j].Add(retlst[i][j]);
     395
     396                                            }
     397
    357398                                        }
    358 
    359 
    360                                         if (b)
     399                                    }
     400
     401
     402                                    for (int j = 0; j < treetlst.Count() - 1; j++)
     403                                    {
     404                                        for (int iy = 0; iy < treetlst[j].Count(); iy++)
    361405                                        {
    362                                             pathLst[j].Add(new List<int>());
    363                                             treetlst[j].Add(retlst[i][j]);
    364 
    365                                         }
    366 
    367                                     }
    368                                 }
    369                                
    370 
    371                                 for (int j = 0; j < treetlst.Count() - 1; j++)
    372                                 {
    373                                     for (int iy = 0; iy < treetlst[j].Count(); iy++)
    374                                     {
    375                                         for (int i = 0; i < retlst.Count; i++)
    376                                         {
    377                                             if (ArraysEqual(treetlst[j][iy], retlst[i][j]))
     406                                            for (int i = 0; i < retlst.Count; i++)
    378407                                            {
    379                                                 if (
    380                                                     !pathLst[j][iy].Contains(
    381                                                         treetlst[j + 1].FindLastIndex(
    382                                                             item =>
    383                                                             ArraysEqual(item.ToArray(), retlst[i][j + 1].ToArray()))))
     408                                                if (ArraysEqual(treetlst[j][iy], retlst[i][j]))
    384409                                                {
    385                                                     /*int xgh=Array.IndexOf(treetlst[j + 1].ToArray(), retlst[i][j + 1]);
     410                                                    if (
     411                                                        !pathLst[j][iy].Contains(
     412                                                            treetlst[j + 1].FindLastIndex(
     413                                                                item =>
     414                                                                ArraysEqual(item.ToArray(), retlst[i][j + 1].ToArray()))))
     415                                                    {
     416                                                        /*int xgh=Array.IndexOf(treetlst[j + 1].ToArray(), retlst[i][j + 1]);
    386417                                                   
    387418                                                    int[][] llist = treetlst[j + 1].ToArray();
     
    389420                                                    int xgh2 = Array.IndexOf(llist, gh);
    390421                                                    Console.WriteLine(gh+""+xgh+"" +llist+""+xgh2);*/
    391                                                     pathLst[j][iy].Add(
    392                                                         treetlst[j + 1].FindLastIndex(
    393                                                             item =>
    394                                                             ArraysEqual(item.ToArray(), retlst[i][j + 1].ToArray())));
     422                                                        pathLst[j][iy].Add(
     423                                                            treetlst[j + 1].FindLastIndex(
     424                                                                item =>
     425                                                                ArraysEqual(item.ToArray(), retlst[i][j + 1].ToArray())));
     426                                                    }
    395427                                                }
    396428                                            }
     429
    397430                                        }
    398 
    399431                                    }
    400                                 }
    401                                 /*
     432                                    /*
    402433                                List<Node> nodeList = new List<Node>();
    403434
     
    435466                                }*/
    436467
    437                                 Stopwatch sw = new Stopwatch();
    438                                 sw.Start();
    439 
    440                                 counter++;
    441                                 actRes = new ResultEntry();
    442                                 actRes.CipherKey = loopvars[0] + "" + loopvars[1] + "" + loopvars[2] + "" + loopvars[3] +
    443                                                    "" + loopvars[4];
    444                                 actRes.CipherRotors = "" + arr[0] + "" + arr[1] + "" + arr[2] + "" + arr[3] + "" +
    445                                                       arr[4] + "" + s[0] + "" + s[1] + "" + s[2] + "" + s[3] + "" + s[4];
    446 
    447                                 controlMaster.setCipherRotors(0, (byte) (arr[0]));
    448                                 controlMaster.setCipherRotors(1, (byte) (arr[1]));
    449                                 controlMaster.setCipherRotors(2, (byte) (arr[2]));
    450                                 controlMaster.setCipherRotors(3, (byte) (arr[3]));
    451                                 controlMaster.setCipherRotors(4, (byte) (arr[4]));
    452 
    453                                 //ProgressChanged(ticksmall, retlst.Count);
    454 
    455                                 ticksmall++;
    456                                 if (!treetlst.Contains(null))
    457                                     if (_core.stepOneCompact(enc.GetBytes(Cipher), enc.GetBytes(Crib), arr, loopvars,
    458                                                              treetlst, pathLst))
    459                                     {
    460 
    461                                         sw.Stop();
    462                                         ticklist.Add(sw.Elapsed.Ticks);
    463                                         TimeSpan ts = new TimeSpan((long) ticklist.Average());
    464                                         Console.WriteLine("time" + ts.Minutes + ":  " + ts.Seconds);
    465                                         Console.WriteLine("How many?" + ticklist.Count + " :  " + counter);
    466                                     }
    467 
    468                                
     468                                    Stopwatch sw = new Stopwatch();
     469                                    sw.Start();
     470
     471                                    counter++;
     472                                    actRes = new ResultEntry();
     473                                    actRes.CipherKey = loopvars[0] + "" + loopvars[1] + "" + loopvars[2] + "" +
     474                                                       loopvars[3] +
     475                                                       "" + loopvars[4];
     476                                    actRes.CipherRotors = "" + arr[0] + "" + arr[1] + "" + arr[2] + "" + arr[3] + "" +
     477                                                          arr[4] + "" + s[0] + "" + s[1] + "" + s[2] + "" + s[3] + "" +
     478                                                          s[4];
     479
     480                                    controlMaster.setCipherRotors(0, (byte) (arr[0]));
     481                                    controlMaster.setCipherRotors(1, (byte) (arr[1]));
     482                                    controlMaster.setCipherRotors(2, (byte) (arr[2]));
     483                                    controlMaster.setCipherRotors(3, (byte) (arr[3]));
     484                                    controlMaster.setCipherRotors(4, (byte) (arr[4]));
     485
     486                                   
     487
     488                                    //ProgressChanged(ticksmall, retlst.Count);
     489
     490                                    ticksmall++;
     491                                    if (!treetlst.Contains(null))
     492                                        if (_core.stepOneCompact(enc.GetBytes(Cipher), enc.GetBytes(Crib), arr, loopvars,
     493                                                                 treetlst, pathLst))
     494                                        {
     495
     496                                            sw.Stop();
     497                                            ticklist.Add(sw.Elapsed.Ticks);
     498                                            TimeSpan ts = new TimeSpan((long) ticklist.Average());
     499                                            Console.WriteLine("time" + ts.Minutes + ":  " + ts.Seconds);
     500                                            Console.WriteLine("How many?" + ticklist.Count + " :  " + counter);
     501                                        }
     502
     503
     504                                }
     505
    469506                            }
    470                            
    471                            
    472                            
     507
    473508                        } while (increment2(loopvars, test2));
    474                        
     509
    475510                    }
    476511                } while (NextPermutation(arr));
    477                                            
    478             }
    479 
    480                 Console.WriteLine(counter);
    481                                      
    482         }
    483 
    484        
     512
     513            }
     514
     515            Console.WriteLine(counter);
     516
     517        }
     518
     519        private bool checkWithSetting(byte[] loopvars )
     520        {
     521            bool retb = true;
     522            for (int i = 0;i<5;i++)
     523            {
     524                if ((int)settings.cipherRotorFrom[i] > loopvars[i])
     525                {
     526                    retb = false;
     527                }
     528               
     529                if (settings.cipherRotorTo[i] < loopvars[i])
     530                {
     531                    retb = false;
     532                }
     533
     534               
     535
     536            }
     537
     538            return retb;
     539        }
     540
     541        private bool checkWithSetting( int[] arr)
     542        {
     543            bool retb = true;
     544           
     545           
     546            if (!settings.cipher1AnalysisUseRotor[arr[0]-1])
     547            {
     548                retb = false;
     549            }
     550            if (!settings.cipher2AnalysisUseRotor[arr[1] - 1])
     551            {
     552                retb = false;
     553            }   
     554            if (!settings.cipher3AnalysisUseRotor[arr[2] - 1])
     555            {
     556                retb = false;
     557            }
     558            if (!settings.cipher4AnalysisUseRotor[arr[3] - 1])
     559            {
     560                retb = false;
     561            }
     562            if (!settings.cipher5AnalysisUseRotor[arr[4] - 1])
     563            {
     564                retb = false;
     565            }   
     566
     567           
     568
     569            return retb;
     570        }
     571
     572        private bool checkWithSetting( String s)
     573        {
     574            bool retb = true;
     575            for (int i = 0; i < 5; i++)
     576            {
     577               
     578
     579                if (s[i] == '0')
     580                {
     581                    if (settings.cipherRotorRev[i] == 2)
     582                    { retb = false; }
     583                }
     584                else
     585                {
     586                    if (settings.cipherRotorRev[i] == 1)
     587                    { retb = false; }
     588                }
     589
     590            }
     591
     592            return retb;
     593        }
     594
    485595        int calculateSet(int[][] con)
    486596        {
     
    645755            int[] b = new int[] { (byte)(actRes.CipherRotors[0] - 48), (byte)(actRes.CipherRotors[1] - 48), (byte)(actRes.CipherRotors[2] - 48), (byte)(actRes.CipherRotors[3] - 48), (byte)(actRes.CipherRotors[4] - 48), (winner.RotorTypeReal[0]), (winner.RotorTypeReal[1]), (winner.RotorTypeReal[2]), p };
    646756            byte[] b2 = new byte[] { (byte)(actRes.CipherKey[0] - 48), (byte)(actRes.CipherKey[1] - 48), (byte)(actRes.CipherKey[2] - 48), (byte)(actRes.CipherKey[3] - 48), (byte)(actRes.CipherKey[4] - 48), (byte)winner.Positions[0], (byte)winner.Positions[1], (byte)winner.Positions[2], (byte)pos};
     757
     758           
    647759
    648760            controlMaster.setPositionsControl((byte)(winner.RotorTypeReal[0]), 5, (byte)winner.Positions[0]);
     
    10771189            var rse = lvi.Content as ResultEntry;
    10781190           
    1079             if (!list1.ElementAt( Int32.Parse(rse.Ranking)-1).tested)
     1191           
    10801192            if (rse != null)
     1193            if (!list1.ElementAt(Int32.Parse(rse.Ranking) - 1).tested)
    10811194            {
    10821195                Console.WriteLine(Int32.Parse(rse.Ranking) - 1 + "TEst");
  • trunk/CrypPluginsExperimental/SIgabaKnownPlaintext/SigabaKnownPlaintextSettings.cs

    r5926 r5961  
    2222{
    2323    // HOWTO: rename class (click name, press F2)
     24    [global::Cryptool.PluginBase.Attributes.Localization("SigabaKnownPlaintext.Properties.Resources")]
    2425    public class SigabaKnownPlaintextSettings : ISettings
    2526    {
     27        public int[] cipherRotorRev;
     28        public int[] cipherRotorFrom;
     29        public int[] cipherRotorTo;
     30
     31        public bool[][] AnalysisUseRotor;
     32
     33        public bool[] cipher1AnalysisUseRotor;
     34        public bool[] cipher2AnalysisUseRotor;
     35        public bool[] cipher3AnalysisUseRotor;
     36        public bool[] cipher4AnalysisUseRotor;
     37        public bool[] cipher5AnalysisUseRotor;
     38       
     39        public bool action = false;
     40
    2641        #region Private Variables
    2742
    28         public bool action = false;
     43       
     44
     45        private int cipherRotor1From = 0;
     46        private int cipherRotor1To = 25;
     47
     48        private int cipherRotor1Rev = 0;
     49
     50        private int cipherRotor2From = 0;
     51        private int cipherRotor2To = 25;
     52
     53        private int cipherRotor2Rev = 0;
     54
     55        private int cipherRotor3From = 0;
     56        private int cipherRotor3To = 25;
     57
     58        private int cipherRotor3Rev = 0;
     59
     60        private int cipherRotor4From = 0;
     61        private int cipherRotor4To = 25;
     62
     63        private int cipherRotor4Rev = 0;
     64
     65        private int cipherRotor5From = 0;
     66        private int cipherRotor5To = 25;
     67
     68        private int cipherRotor5Rev = 0;
     69
     70       
     71        private bool cipher1AnalysisUseRotor1 = true;
     72        private bool cipher1AnalysisUseRotor2 = true;
     73        private bool cipher1AnalysisUseRotor3 = true;
     74        private bool cipher1AnalysisUseRotor4 = true;
     75        private bool cipher1AnalysisUseRotor5 = true;
     76        private bool cipher1AnalysisUseRotor6 = true;
     77        private bool cipher1AnalysisUseRotor7 = true;
     78        private bool cipher1AnalysisUseRotor8 = true;
     79        private bool cipher1AnalysisUseRotor9 = true;
     80        private bool cipher1AnalysisUseRotor0 = true;
     81
     82        private bool cipher2AnalysisUseRotor1 = true;
     83        private bool cipher2AnalysisUseRotor2 = true;
     84        private bool cipher2AnalysisUseRotor3 = true;
     85        private bool cipher2AnalysisUseRotor4 = true;
     86        private bool cipher2AnalysisUseRotor5 = true;
     87        private bool cipher2AnalysisUseRotor6 = true;
     88        private bool cipher2AnalysisUseRotor7 = true;
     89        private bool cipher2AnalysisUseRotor8 = true;
     90        private bool cipher2AnalysisUseRotor9 = true;
     91        private bool cipher2AnalysisUseRotor0 = true;
     92
     93        private bool cipher3AnalysisUseRotor1 = true;
     94        private bool cipher3AnalysisUseRotor2 = true;
     95        private bool cipher3AnalysisUseRotor3 = true;
     96        private bool cipher3AnalysisUseRotor4 = true;
     97        private bool cipher3AnalysisUseRotor5 = true;
     98        private bool cipher3AnalysisUseRotor6 = true;
     99        private bool cipher3AnalysisUseRotor7 = true;
     100        private bool cipher3AnalysisUseRotor8 = true;
     101        private bool cipher3AnalysisUseRotor9 = true;
     102        private bool cipher3AnalysisUseRotor0 = true;
     103
     104        private bool cipher4AnalysisUseRotor1 = true;
     105        private bool cipher4AnalysisUseRotor2 = true;
     106        private bool cipher4AnalysisUseRotor3 = true;
     107        private bool cipher4AnalysisUseRotor4 = true;
     108        private bool cipher4AnalysisUseRotor5 = true;
     109        private bool cipher4AnalysisUseRotor6 = true;
     110        private bool cipher4AnalysisUseRotor7 = true;
     111        private bool cipher4AnalysisUseRotor8 = true;
     112        private bool cipher4AnalysisUseRotor9 = true;
     113        private bool cipher4AnalysisUseRotor0 = true;
     114
     115        private bool cipher5AnalysisUseRotor1 = true;
     116        private bool cipher5AnalysisUseRotor2 = true;
     117        private bool cipher5AnalysisUseRotor3 = true;
     118        private bool cipher5AnalysisUseRotor4 = true;
     119        private bool cipher5AnalysisUseRotor5 = true;
     120        private bool cipher5AnalysisUseRotor6 = true;
     121        private bool cipher5AnalysisUseRotor7 = true;
     122        private bool cipher5AnalysisUseRotor8 = true;
     123        private bool cipher5AnalysisUseRotor9 = true;
     124        private bool cipher5AnalysisUseRotor0 = true;
     125
     126        public SigabaKnownPlaintextSettings()
     127        {
     128            cipherRotorFrom = new [] {    CipherRotor1From,
     129                                            CipherRotor2From,
     130                                            CipherRotor3From,
     131                                            CipherRotor4From,
     132                                            CipherRotor5From
     133                                           
     134            };
     135
     136            cipherRotorTo = new []{      CipherRotor1To,
     137                                            CipherRotor2To,
     138                                            CipherRotor3To,
     139                                            CipherRotor4To,
     140                                            CipherRotor5To
     141                                           
     142            };
     143
     144            cipherRotorRev = new []{ CipherRotor1Rev,
     145                                        CipherRotor2Rev,
     146                                        CipherRotor3Rev,
     147                                        CipherRotor4Rev,
     148                                        CipherRotor5Rev,
     149           
     150            };
     151
     152            AnalysisUseRotor = new [] { cipher1AnalysisUseRotor, cipher2AnalysisUseRotor, cipher3AnalysisUseRotor, cipher4AnalysisUseRotor, cipher5AnalysisUseRotor };
     153
     154            cipher1AnalysisUseRotor = new [] {  Cipher1AnalysisUseRotor0,
     155                                                    Cipher1AnalysisUseRotor1,
     156                                                    Cipher1AnalysisUseRotor2,
     157                                                    Cipher1AnalysisUseRotor3,
     158                                                    Cipher1AnalysisUseRotor4,
     159                                                    Cipher1AnalysisUseRotor5,
     160                                                    Cipher1AnalysisUseRotor6,
     161                                                    Cipher1AnalysisUseRotor7,
     162                                                    Cipher1AnalysisUseRotor8,
     163                                                    Cipher1AnalysisUseRotor9
     164            };
     165
     166            cipher2AnalysisUseRotor = new [] {  Cipher2AnalysisUseRotor0,
     167                                                    Cipher2AnalysisUseRotor1,
     168                                                    Cipher2AnalysisUseRotor2,
     169                                                    Cipher2AnalysisUseRotor3,
     170                                                    Cipher2AnalysisUseRotor4,
     171                                                    Cipher2AnalysisUseRotor5,
     172                                                    Cipher2AnalysisUseRotor6,
     173                                                    Cipher2AnalysisUseRotor7,
     174                                                    Cipher2AnalysisUseRotor8,
     175                                                    Cipher2AnalysisUseRotor9
     176            };
     177            cipher3AnalysisUseRotor = new [] {  Cipher3AnalysisUseRotor0,
     178                                                    Cipher3AnalysisUseRotor1,
     179                                                    Cipher3AnalysisUseRotor2,
     180                                                    Cipher3AnalysisUseRotor3,
     181                                                    Cipher3AnalysisUseRotor4,
     182                                                    Cipher3AnalysisUseRotor5,
     183                                                    Cipher3AnalysisUseRotor6,
     184                                                    Cipher3AnalysisUseRotor7,
     185                                                    Cipher3AnalysisUseRotor8,
     186                                                    Cipher3AnalysisUseRotor9
     187            };
     188            cipher4AnalysisUseRotor = new [] {  Cipher4AnalysisUseRotor0,
     189                                                    Cipher4AnalysisUseRotor1,
     190                                                    Cipher4AnalysisUseRotor2,
     191                                                    Cipher4AnalysisUseRotor3,
     192                                                    Cipher4AnalysisUseRotor4,
     193                                                    Cipher4AnalysisUseRotor5,
     194                                                    Cipher4AnalysisUseRotor6,
     195                                                    Cipher4AnalysisUseRotor7,
     196                                                    Cipher4AnalysisUseRotor8,
     197                                                    Cipher4AnalysisUseRotor9
     198            };
     199            cipher5AnalysisUseRotor = new [] {  Cipher5AnalysisUseRotor0,
     200                                                    Cipher5AnalysisUseRotor1,
     201                                                    Cipher5AnalysisUseRotor2,
     202                                                    Cipher5AnalysisUseRotor3,
     203                                                    Cipher5AnalysisUseRotor4,
     204                                                    Cipher5AnalysisUseRotor5,
     205                                                    Cipher5AnalysisUseRotor6,
     206                                                    Cipher5AnalysisUseRotor7,
     207                                                    Cipher5AnalysisUseRotor8,
     208                                                    Cipher5AnalysisUseRotor9
     209            };
     210        }
    29211
    30212        #endregion
     
    59241        #endregion
    60242
     243        #region Cipher Bank
     244
     245        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
     246        [TaskPane("CipherRotor1From", "PlugBoardATooltip", "PositionOptionsGroup", 1, false, ControlType.ComboBox,
     247            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     248        public int CipherRotor1From
     249        {
     250            get
     251            {
     252                return this.cipherRotor1From;
     253            }
     254            set
     255            {
     256
     257                this.cipherRotor1From = (int)value;
     258                this.cipherRotorFrom[0] = (int)value;
     259                OnPropertyChanged("CipherRotor1From");
     260               
     261
     262                if (value > cipherRotor1To)
     263                {
     264                    CipherRotor1To = value;
     265                    this.cipherRotorTo[0] = (int)value;
     266
     267                }
     268            }
     269        }
     270
     271        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Eins")]
     272        [TaskPane("ToCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 2, false, ControlType.ComboBox,
     273            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     274        public int CipherRotor1To
     275        {
     276            get { return cipherRotor1To; }
     277            set
     278            {
     279                cipherRotor1To = value;
     280                this.cipherRotorTo[0] = (int)value;
     281                OnPropertyChanged("CipherRotor1To");
     282               
     283                if (value < cipherRotor1From)
     284                {
     285                    CipherRotor1From = value;
     286                    this.cipherRotorFrom[0] = (int)value;
     287                }
     288
     289            }
     290        }
     291
     292        [TaskPane("RevCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 3, false, ControlType.RadioButton, new String[] { "undefinedCaption", "normalCaption", "reverseCaption" })]
     293        public int CipherRotor1Rev
     294        {
     295            get { return cipherRotor1Rev; }
     296            set
     297            {
     298               
     299                if (value != cipherRotor1Rev)
     300                {
     301                    cipherRotorRev[0] = value;
     302                    cipherRotor1Rev = value;
     303                    OnPropertyChanged("CipherRotor1Rev");
     304                }
     305
     306            }
     307        }
     308
     309        #region Rotor choice
     310
     311        [TaskPane("AnalysisUseRotorICaption", "AnalysisUseRotorITooltip",
     312            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     313        public bool Cipher1AnalysisUseRotor1
     314        {
     315            get { return cipher1AnalysisUseRotor1; }
     316            set
     317            {
     318
     319                if (value != cipher1AnalysisUseRotor1)
     320                {
     321                    cipher1AnalysisUseRotor[0] = value;
     322                    cipher1AnalysisUseRotor1 = value;
     323                    OnPropertyChanged("Cipher1AnalysisUseRotor1");
     324                }
     325
     326            }
     327        }
     328
     329
     330        [TaskPane("AnalysisUseRotorIICaption", "AnalysisUseRotorIITooltip",
     331            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     332        public bool Cipher1AnalysisUseRotor2
     333        {
     334            get { return cipher1AnalysisUseRotor2; }
     335            set
     336            {
     337
     338                if (value != cipher1AnalysisUseRotor2)
     339                {
     340                    cipher1AnalysisUseRotor[1] = value;
     341                    cipher1AnalysisUseRotor2 = value;
     342                    OnPropertyChanged("Cipher1AnalysisUseRotor2");
     343                }
     344            }
     345        }
     346
     347
     348        [TaskPane("AnalysisUseRotorIIICaption", "AnalysisUseRotorIIITooltip",
     349            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     350        public bool Cipher1AnalysisUseRotor3
     351        {
     352            get { return cipher1AnalysisUseRotor3; }
     353            set
     354            {
     355
     356                if (value != cipher1AnalysisUseRotor3)
     357                {
     358                    cipher1AnalysisUseRotor[2] = value;
     359                    cipher1AnalysisUseRotor3 = value;
     360                    OnPropertyChanged("Cipher1AnalysisUseRotor3");
     361                }
     362            }
     363        }
     364
     365
     366        [TaskPane("AnalysisUseRotorIVCaption", "AnalysisUseRotorIVTooltip",
     367            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     368        public bool Cipher1AnalysisUseRotor4
     369        {
     370            get { return cipher1AnalysisUseRotor4; }
     371            set
     372            {
     373
     374                if (value != cipher1AnalysisUseRotor4)
     375                {
     376                    cipher1AnalysisUseRotor[3] = value;
     377                    cipher1AnalysisUseRotor4 = value;
     378                    OnPropertyChanged("Cipher1AnalysisUseRotor4");
     379                }
     380            }
     381        }
     382
     383
     384
     385        [TaskPane("AnalysisUseRotorVCaption", "AnalysisUseRotorVTooltip",
     386            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     387        public bool Cipher1AnalysisUseRotor5
     388        {
     389            get { return cipher1AnalysisUseRotor5; }
     390            set
     391            {
     392
     393                if (value != cipher1AnalysisUseRotor5)
     394                {
     395                    cipher1AnalysisUseRotor[4] = value;
     396                    cipher1AnalysisUseRotor5 = value;
     397                    OnPropertyChanged("Cipher1AnalysisUseRotor5");
     398                }
     399            }
     400        }
     401
     402
     403        [TaskPane("AnalysisUseRotorVICaption", "AnalysisUseRotorVITooltip",
     404            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     405        public bool Cipher1AnalysisUseRotor6
     406        {
     407            get { return cipher1AnalysisUseRotor6; }
     408            set
     409            {
     410
     411                if (value != cipher1AnalysisUseRotor6)
     412                {
     413                    cipher1AnalysisUseRotor[5] = value;
     414                    cipher1AnalysisUseRotor6 = value;
     415                    OnPropertyChanged("Cipher1AnalysisUseRotor6");
     416                }
     417            }
     418        }
     419
     420        [TaskPane("AnalysisUseRotorVIICaption", "AnalysisUseRotorVIITooltip",
     421            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     422        public bool Cipher1AnalysisUseRotor7
     423        {
     424            get { return cipher1AnalysisUseRotor7; }
     425            set
     426            {
     427
     428                if (value != cipher1AnalysisUseRotor7)
     429                {
     430                    cipher1AnalysisUseRotor[6] = value;
     431                    cipher1AnalysisUseRotor7 = value;
     432                    OnPropertyChanged("Cipher1AnalysisUseRotor7");
     433                }
     434            }
     435        }
     436
     437        [TaskPane("AnalysisUseRotorVIIICaption", "AnalysisUseRotorVIIITooltip",
     438            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     439        public bool Cipher1AnalysisUseRotor8
     440        {
     441            get { return cipher1AnalysisUseRotor8; }
     442            set
     443            {
     444
     445                if (value != cipher1AnalysisUseRotor8)
     446                {
     447                    cipher1AnalysisUseRotor[7] = value;
     448                    cipher1AnalysisUseRotor8 = value;
     449                    OnPropertyChanged("Cipher1AnalysisUseRotor8");
     450                }
     451            }
     452        }
     453
     454        [TaskPane("AnalysisUseRotorIXCaption", "AnalysisUseRotorVIIITooltip",
     455            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     456        public bool Cipher1AnalysisUseRotor9
     457        {
     458            get { return cipher1AnalysisUseRotor9; }
     459            set
     460            {
     461
     462                if (value != cipher1AnalysisUseRotor9)
     463                {
     464                    cipher1AnalysisUseRotor[8] = value;
     465                    cipher1AnalysisUseRotor9 = value;
     466                    OnPropertyChanged("Cipher1AnalysisUseRotor9");
     467                }
     468            }
     469        }
     470        [TaskPane("AnalysisUseRotorXCaption", "AnalysisUseRotorVIIITooltip",
     471            "Cipher1AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     472        public bool Cipher1AnalysisUseRotor0
     473        {
     474            get { return cipher1AnalysisUseRotor0; }
     475            set
     476            {
     477
     478                if (value != cipher1AnalysisUseRotor0)
     479                {
     480                    cipher1AnalysisUseRotor[9] = value;
     481                    cipher1AnalysisUseRotor0 = value;
     482                    OnPropertyChanged("Cipher1AnalysisUseRotor0");
     483                }
     484            }
     485        }
     486        #endregion
     487
     488        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
     489        [TaskPane("CipherRotor2FromCaption", "PlugBoardATooltip", "PositionOptionsGroup", 4, false, ControlType.ComboBox,
     490            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     491        public int CipherRotor2From
     492        {
     493            get { return cipherRotor2From; }
     494            set
     495            {
     496
     497                cipherRotor2From = value;
     498               
     499                this.cipherRotorFrom[1] = (int)value;
     500                OnPropertyChanged("CipherRotor2From");
     501               
     502
     503                if (value > cipherRotor2To)
     504                {
     505                    CipherRotor2To = value;
     506                    this.cipherRotorTo[1] = (int)value;
     507
     508                }
     509            }
     510        }
     511
     512        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Zwei")]
     513        [TaskPane("ToCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 5, false, ControlType.ComboBox,
     514            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     515        public int CipherRotor2To
     516        {
     517            get { return cipherRotor2To; }
     518            set
     519            {
     520
     521                cipherRotor2To = value;
     522                this.cipherRotorTo[0] = (int)value;
     523                OnPropertyChanged("CipherRotor2To");
     524               
     525                if (value < cipherRotor2From)
     526                {
     527                    CipherRotor2From = value;
     528                    this.cipherRotorFrom[0] = (int)value;
     529                }
     530
     531            }
     532        }
     533
     534        [TaskPane("RevCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 6, false, ControlType.RadioButton, new String[] { "undefinedCaption", "normalCaption", "reverseCaption" })]
     535        public int CipherRotor2Rev
     536        {
     537            get { return cipherRotor2Rev; }
     538            set
     539            {
     540               
     541                if (value != cipherRotor2Rev)
     542                {
     543                    cipherRotorRev[1] = value;
     544                    cipherRotor2Rev = value;
     545                    OnPropertyChanged("CipherRotor2Rev");
     546                }
     547
     548            }
     549        }
     550
     551        #region Rotor choice
     552
     553        [TaskPane("AnalysisUseRotorICaption", "AnalysisUseRotorITooltip",
     554            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     555        public bool Cipher2AnalysisUseRotor1
     556        {
     557            get { return cipher2AnalysisUseRotor1; }
     558            set
     559            {
     560
     561                if (value != cipher2AnalysisUseRotor1)
     562                {
     563                    cipher2AnalysisUseRotor[0] = value;
     564                    cipher2AnalysisUseRotor1 = value;
     565                    OnPropertyChanged("Cipher2AnalysisUseRotor1");
     566                }
     567            }
     568        }
     569
     570
     571        [TaskPane("AnalysisUseRotorIICaption", "Cipher2AnalysisUseRotorIITooltip",
     572            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     573        public bool Cipher2AnalysisUseRotor2
     574        {
     575            get { return cipher2AnalysisUseRotor2; }
     576            set
     577            {
     578
     579                if (value != cipher2AnalysisUseRotor2)
     580                {
     581                    cipher2AnalysisUseRotor[1] = value;
     582                    cipher2AnalysisUseRotor2 = value;
     583                    OnPropertyChanged("Cipher2AnalysisUseRotor2");
     584                }
     585            }
     586        }
     587
     588
     589        [TaskPane("AnalysisUseRotorIIICaption", "Cipher2AnalysisUseRotorIIITooltip",
     590            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     591        public bool Cipher2AnalysisUseRotor3
     592        {
     593            get { return cipher2AnalysisUseRotor3; }
     594            set
     595            {
     596
     597                if (value != cipher2AnalysisUseRotor3)
     598                {
     599                    cipher2AnalysisUseRotor[2] = value;
     600                    cipher2AnalysisUseRotor3 = value;
     601                    OnPropertyChanged("Cipher2AnalysisUseRotor3");
     602                }
     603            }
     604        }
     605
     606
     607        [TaskPane("AnalysisUseRotorIVCaption", "Cipher2AnalysisUseRotorIVTooltip",
     608            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     609        public bool Cipher2AnalysisUseRotor4
     610        {
     611            get { return cipher2AnalysisUseRotor4; }
     612            set
     613            {
     614
     615                if (value != cipher2AnalysisUseRotor4)
     616                {
     617                    cipher2AnalysisUseRotor[3] = value;
     618                    cipher2AnalysisUseRotor4 = value;
     619                    OnPropertyChanged("Cipher2AnalysisUseRotor4");
     620                }
     621            }
     622        }
     623
     624
     625
     626        [TaskPane("AnalysisUseRotorVCaption", "Cipher2AnalysisUseRotorVTooltip",
     627            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     628        public bool Cipher2AnalysisUseRotor5
     629        {
     630            get { return cipher2AnalysisUseRotor5; }
     631            set
     632            {
     633
     634                if (value != cipher2AnalysisUseRotor5)
     635                {
     636                    cipher2AnalysisUseRotor[4] = value;
     637                    cipher2AnalysisUseRotor5 = value;
     638                    OnPropertyChanged("Cipher2AnalysisUseRotor5");
     639                }
     640            }
     641        }
     642
     643
     644        [TaskPane("AnalysisUseRotorVICaption", "Cipher2AnalysisUseRotorVITooltip",
     645            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     646        public bool Cipher2AnalysisUseRotor6
     647        {
     648            get { return cipher2AnalysisUseRotor6; }
     649            set
     650            {
     651
     652                if (value != cipher2AnalysisUseRotor6)
     653                {
     654                    cipher2AnalysisUseRotor[5] = value;
     655                    cipher2AnalysisUseRotor6 = value;
     656                    OnPropertyChanged("Cipher2AnalysisUseRotor6");
     657                }
     658            }
     659        }
     660
     661
     662
     663        [TaskPane("AnalysisUseRotorVIICaption", "Cipher2AnalysisUseRotorVIITooltip",
     664            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     665        public bool Cipher2AnalysisUseRotor7
     666        {
     667            get { return cipher2AnalysisUseRotor7; }
     668            set
     669            {
     670
     671                if (value != cipher2AnalysisUseRotor7)
     672                {
     673                    cipher2AnalysisUseRotor[6] = value;
     674                    cipher2AnalysisUseRotor7 = value;
     675                    OnPropertyChanged("Cipher2AnalysisUseRotor7");
     676                }
     677            }
     678        }
     679
     680
     681
     682        [TaskPane("AnalysisUseRotorVIIICaption", "Cipher2AnalysisUseRotorVIIITooltip",
     683            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     684        public bool Cipher2AnalysisUseRotor8
     685        {
     686            get { return cipher2AnalysisUseRotor8; }
     687            set
     688            {
     689
     690                if (value != cipher2AnalysisUseRotor8)
     691                {
     692                    cipher2AnalysisUseRotor[7] = value;
     693                    cipher2AnalysisUseRotor8 = value;
     694                    OnPropertyChanged("Cipher2AnalysisUseRotor8");
     695                }
     696            }
     697        }
     698
     699        [TaskPane("AnalysisUseRotorIXCaption", "Cipher2AnalysisUseRotorVIIITooltip",
     700            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     701        public bool Cipher2AnalysisUseRotor9
     702        {
     703            get { return cipher2AnalysisUseRotor9; }
     704            set
     705            {
     706
     707                if (value != cipher2AnalysisUseRotor9)
     708                {
     709                    cipher2AnalysisUseRotor[8] = value;
     710                    cipher2AnalysisUseRotor9 = value;
     711                    OnPropertyChanged("Cipher2AnalysisUseRotor9");
     712                }
     713            }
     714        }
     715        [TaskPane("AnalysisUseRotorXCaption", "Cipher2AnalysisUseRotorVIIITooltip",
     716            "Cipher2AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     717        public bool Cipher2AnalysisUseRotor0
     718        {
     719            get { return cipher2AnalysisUseRotor0; }
     720            set
     721            {
     722
     723                if (value != cipher2AnalysisUseRotor0)
     724                {
     725                    cipher2AnalysisUseRotor[9] = value;
     726                    cipher2AnalysisUseRotor0 = value;
     727                    OnPropertyChanged("Cipher2AnalysisUseRotor0");
     728                }
     729            }
     730        }
     731        #endregion
     732
     733        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
     734        [TaskPane("Cipher Rotor 3: From", "PlugBoardATooltip", "PositionOptionsGroup", 7, false, ControlType.ComboBox,
     735            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     736        public int CipherRotor3From
     737        {
     738            get { return cipherRotor3From; }
     739            set
     740            {
     741
     742                cipherRotor3From = value;
     743                this.cipherRotorFrom[2] = (int)value;
     744                OnPropertyChanged("CipherRotor3From");
     745               
     746
     747                if (value > cipherRotor3To)
     748                {
     749                    CipherRotor3To = value;
     750                    this.cipherRotorTo[2] = (int)value;
     751
     752                }
     753            }
     754        }
     755
     756        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Drei")]
     757        [TaskPane("ToCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 8, false, ControlType.ComboBox,
     758            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     759        public int CipherRotor3To
     760        {
     761            get { return cipherRotor3To; }
     762            set
     763            {
     764
     765                cipherRotor3To = value;
     766                this.cipherRotorTo[2] = (int)value;
     767
     768                OnPropertyChanged("CipherRotor3To");
     769               
     770                if (value < cipherRotor3From)
     771                {
     772                    CipherRotor3From = value;
     773                    this.cipherRotorFrom[2] = (int)value;
     774                }
     775
     776            }
     777        }
     778
     779        [TaskPane("RevCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 9, false, ControlType.RadioButton, new String[] { "undefinedCaption", "normalCaption", "reverseCaption" })]
     780        public int CipherRotor3Rev
     781        {
     782            get { return cipherRotor3Rev; }
     783            set
     784            {
     785               
     786                if (value != cipherRotor3Rev)
     787                {
     788                    cipherRotorRev[2] = value;
     789                    cipherRotor3Rev = value;
     790                    OnPropertyChanged("CipherRotor3Rev");
     791                }
     792
     793            }
     794        }
     795
     796        #region Rotor choice
     797
     798        [TaskPane("AnalysisUseRotorICaption", "AnalysisUseRotorITooltip",
     799            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     800        public bool Cipher3AnalysisUseRotor1
     801        {
     802            get { return cipher3AnalysisUseRotor1; }
     803            set
     804            {
     805
     806                if (value != cipher3AnalysisUseRotor1)
     807                {
     808                    cipher3AnalysisUseRotor[0] = value;
     809                    cipher3AnalysisUseRotor1 = value;
     810                    OnPropertyChanged("Cipher3AnalysisUseRotor1");
     811                }
     812            }
     813        }
     814
     815
     816        [TaskPane("AnalysisUseRotorIICaption", "Cipher3AnalysisUseRotorIITooltip",
     817            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     818        public bool Cipher3AnalysisUseRotor2
     819        {
     820            get { return cipher3AnalysisUseRotor2; }
     821            set
     822            {
     823
     824                if (value != cipher3AnalysisUseRotor2)
     825                {
     826                    cipher3AnalysisUseRotor[1] = value;
     827                    cipher3AnalysisUseRotor2 = value;
     828                    OnPropertyChanged("Cipher3AnalysisUseRotor2");
     829                }
     830            }
     831        }
     832
     833
     834        [TaskPane("AnalysisUseRotorIIICaption", "Cipher3AnalysisUseRotorIIITooltip",
     835            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     836        public bool Cipher3AnalysisUseRotor3
     837        {
     838            get { return cipher3AnalysisUseRotor3; }
     839            set
     840            {
     841
     842                if (value != cipher3AnalysisUseRotor3)
     843                {
     844                    cipher3AnalysisUseRotor[2] = value;
     845                    cipher3AnalysisUseRotor3 = value;
     846                    OnPropertyChanged("Cipher3AnalysisUseRotor3");
     847                }
     848            }
     849        }
     850
     851
     852        [TaskPane("AnalysisUseRotorIVCaption", "Cipher3AnalysisUseRotorIVTooltip",
     853            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     854        public bool Cipher3AnalysisUseRotor4
     855        {
     856            get { return cipher3AnalysisUseRotor4; }
     857            set
     858            {
     859
     860                if (value != cipher3AnalysisUseRotor4)
     861                {
     862                    cipher3AnalysisUseRotor[3] = value;
     863                    cipher3AnalysisUseRotor4 = value;
     864                    OnPropertyChanged("Cipher3AnalysisUseRotor4");
     865                }
     866            }
     867        }
     868
     869
     870
     871        [TaskPane("AnalysisUseRotorVCaption", "Cipher3AnalysisUseRotorVTooltip",
     872            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     873        public bool Cipher3AnalysisUseRotor5
     874        {
     875            get { return cipher3AnalysisUseRotor5; }
     876            set
     877            {
     878
     879                if (value != cipher3AnalysisUseRotor5)
     880                {
     881                    cipher3AnalysisUseRotor[4] = value;
     882                    cipher3AnalysisUseRotor5 = value;
     883                    OnPropertyChanged("Cipher3AnalysisUseRotor5");
     884                }
     885            }
     886        }
     887
     888
     889        [TaskPane("AnalysisUseRotorVICaption", "Cipher3AnalysisUseRotorVITooltip",
     890            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     891        public bool Cipher3AnalysisUseRotor6
     892        {
     893            get { return cipher3AnalysisUseRotor6; }
     894            set
     895            {
     896
     897                if (value != cipher3AnalysisUseRotor6)
     898                {
     899                    cipher3AnalysisUseRotor[5] = value;
     900                    cipher3AnalysisUseRotor6 = value;
     901                    OnPropertyChanged("Cipher3AnalysisUseRotor6");
     902                }
     903            }
     904        }
     905
     906
     907
     908        [TaskPane("AnalysisUseRotorVIICaption", "Cipher3AnalysisUseRotorVIITooltip",
     909            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     910        public bool Cipher3AnalysisUseRotor7
     911        {
     912            get { return cipher3AnalysisUseRotor7; }
     913            set
     914            {
     915
     916                if (value != cipher3AnalysisUseRotor7)
     917                {
     918                    cipher3AnalysisUseRotor[6] = value;
     919                    cipher3AnalysisUseRotor7 = value;
     920                    OnPropertyChanged("Cipher3AnalysisUseRotor7");
     921                }
     922            }
     923        }
     924
     925
     926
     927        [TaskPane("AnalysisUseRotorVIIICaption", "Cipher3AnalysisUseRotorVIIITooltip",
     928            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     929        public bool Cipher3AnalysisUseRotor8
     930        {
     931            get { return cipher3AnalysisUseRotor8; }
     932            set
     933            {
     934
     935                if (value != cipher3AnalysisUseRotor8)
     936                {
     937                    cipher3AnalysisUseRotor[7] = value;
     938                    cipher3AnalysisUseRotor8 = value;
     939                    OnPropertyChanged("Cipher3AnalysisUseRotor8");
     940                }
     941            }
     942        }
     943
     944        [TaskPane("AnalysisUseRotorIXCaption", "Cipher3AnalysisUseRotorVIIITooltip",
     945            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     946        public bool Cipher3AnalysisUseRotor9
     947        {
     948            get { return cipher3AnalysisUseRotor9; }
     949            set
     950            {
     951
     952                if (value != cipher3AnalysisUseRotor9)
     953                {
     954                    cipher3AnalysisUseRotor[8] = value;
     955                    cipher3AnalysisUseRotor9 = value;
     956                    OnPropertyChanged("Cipher3AnalysisUseRotor9");
     957                }
     958            }
     959        }
     960        [TaskPane("AnalysisUseRotorXCaption", "Cipher3AnalysisUseRotorVIIITooltip",
     961            "Cipher3AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     962        public bool Cipher3AnalysisUseRotor0
     963        {
     964            get { return cipher3AnalysisUseRotor0; }
     965            set
     966            {
     967
     968                if (value != cipher3AnalysisUseRotor0)
     969                {
     970                    cipher3AnalysisUseRotor[9] = value;
     971                    cipher3AnalysisUseRotor0 = value;
     972                    OnPropertyChanged("Cipher3AnalysisUseRotor0");
     973                }
     974            }
     975        }
     976        #endregion
     977
     978        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
     979        [TaskPane("Cipher Rotor 4: From", "PlugBoardATooltip", "PositionOptionsGroup", 10, false, ControlType.ComboBox,
     980            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     981        public int CipherRotor4From
     982        {
     983            get { return cipherRotor4From; }
     984            set
     985            {
     986
     987                cipherRotor4From = value;
     988                this.cipherRotorFrom[3] = (int)value;
     989                OnPropertyChanged("CipherRotor4From");
     990               
     991
     992                if (value > cipherRotor4To)
     993                {
     994                    CipherRotor4To = value;
     995                    this.cipherRotorTo[3] = (int)value;
     996
     997
     998                }
     999            }
     1000        }
     1001
     1002        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Vier")]
     1003        [TaskPane("ToCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 11, false, ControlType.ComboBox,
     1004            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     1005        public int CipherRotor4To
     1006        {
     1007            get { return cipherRotor4To; }
     1008            set
     1009            {
     1010
     1011                cipherRotor4To = value;
     1012                this.cipherRotorTo[3] = (int)value;
     1013                OnPropertyChanged("CipherRotor4To");
     1014               
     1015                if (value < cipherRotor4From)
     1016                {
     1017                    CipherRotor4From = value;
     1018                    this.cipherRotorFrom[3] = (int)value;
     1019                }
     1020
     1021            }
     1022        }
     1023
     1024        [TaskPane("RevCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 12, false, ControlType.RadioButton, new String[] { "undefinedCaption", "normalCaption", "reverseCaption" })]
     1025        public int CipherRotor4Rev
     1026        {
     1027            get { return cipherRotor4Rev; }
     1028            set
     1029            {
     1030               
     1031                if (value != cipherRotor4Rev)
     1032                {
     1033                    cipherRotorRev[3] = value;
     1034                    cipherRotor4Rev = value;
     1035                    OnPropertyChanged("CipherRotor4Rev");
     1036                }
     1037
     1038            }
     1039        }
     1040
     1041        #region Rotor choice
     1042
     1043        [TaskPane("AnalysisUseRotorICaption", "AnalysisUseRotorITooltip",
     1044            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1045        public bool Cipher4AnalysisUseRotor1
     1046        {
     1047            get { return cipher4AnalysisUseRotor1; }
     1048            set
     1049            {
     1050
     1051                if (value != cipher4AnalysisUseRotor1)
     1052                {
     1053                    cipher4AnalysisUseRotor[0] = value;
     1054                    cipher4AnalysisUseRotor1 = value;
     1055                    OnPropertyChanged("Cipher4AnalysisUseRotor1");
     1056                }
     1057            }
     1058        }
     1059
     1060
     1061        [TaskPane("AnalysisUseRotorIICaption", "Cipher4AnalysisUseRotorIITooltip",
     1062            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1063        public bool Cipher4AnalysisUseRotor2
     1064        {
     1065            get { return cipher4AnalysisUseRotor2; }
     1066            set
     1067            {
     1068
     1069                if (value != cipher4AnalysisUseRotor2)
     1070                {
     1071                    cipher4AnalysisUseRotor[1] = value;
     1072                    cipher4AnalysisUseRotor2 = value;
     1073                    OnPropertyChanged("Cipher4AnalysisUseRotor2");
     1074                }
     1075            }
     1076        }
     1077
     1078
     1079        [TaskPane("AnalysisUseRotorIIICaption", "Cipher4AnalysisUseRotorIIITooltip",
     1080            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1081        public bool Cipher4AnalysisUseRotor3
     1082        {
     1083            get { return cipher4AnalysisUseRotor3; }
     1084            set
     1085            {
     1086
     1087                if (value != cipher4AnalysisUseRotor3)
     1088                {
     1089                    cipher4AnalysisUseRotor[2] = value;
     1090                    cipher4AnalysisUseRotor3 = value;
     1091                    OnPropertyChanged("Cipher4AnalysisUseRotor3");
     1092                }
     1093            }
     1094        }
     1095
     1096
     1097        [TaskPane("AnalysisUseRotorIVCaption", "Cipher4AnalysisUseRotorIVTooltip",
     1098            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1099        public bool Cipher4AnalysisUseRotor4
     1100        {
     1101            get { return cipher4AnalysisUseRotor4; }
     1102            set
     1103            {
     1104
     1105                if (value != cipher4AnalysisUseRotor4)
     1106                {
     1107                    cipher4AnalysisUseRotor[3] = value;
     1108                    cipher4AnalysisUseRotor4 = value;
     1109                    OnPropertyChanged("Cipher4AnalysisUseRotor4");
     1110                }
     1111            }
     1112        }
     1113
     1114
     1115
     1116        [TaskPane("AnalysisUseRotorVCaption", "Cipher4AnalysisUseRotorVTooltip",
     1117            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1118        public bool Cipher4AnalysisUseRotor5
     1119        {
     1120            get { return cipher4AnalysisUseRotor5; }
     1121            set
     1122            {
     1123
     1124                if (value != cipher4AnalysisUseRotor5)
     1125                {
     1126                    cipher4AnalysisUseRotor[4] = value;
     1127                    cipher4AnalysisUseRotor5 = value;
     1128                    OnPropertyChanged("Cipher4AnalysisUseRotor5");
     1129                }
     1130            }
     1131        }
     1132
     1133
     1134        [TaskPane("AnalysisUseRotorVICaption", "Cipher4AnalysisUseRotorVITooltip",
     1135            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1136        public bool Cipher4AnalysisUseRotor6
     1137        {
     1138            get { return cipher4AnalysisUseRotor6; }
     1139            set
     1140            {
     1141
     1142                if (value != cipher4AnalysisUseRotor6)
     1143                {
     1144                    cipher4AnalysisUseRotor[5] = value;
     1145                    cipher4AnalysisUseRotor6 = value;
     1146                    OnPropertyChanged("Cipher4AnalysisUseRotor6");
     1147                }
     1148            }
     1149        }
     1150
     1151
     1152
     1153        [TaskPane("AnalysisUseRotorVIICaption", "Cipher4AnalysisUseRotorVIITooltip",
     1154            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1155        public bool Cipher4AnalysisUseRotor7
     1156        {
     1157            get { return cipher4AnalysisUseRotor7; }
     1158            set
     1159            {
     1160
     1161                if (value != cipher4AnalysisUseRotor7)
     1162                {
     1163                    cipher4AnalysisUseRotor[6] = value;
     1164                    cipher4AnalysisUseRotor7 = value;
     1165                    OnPropertyChanged("Cipher4AnalysisUseRotor7");
     1166                }
     1167            }
     1168        }
     1169
     1170
     1171
     1172        [TaskPane("AnalysisUseRotorVIIICaption", "Cipher4AnalysisUseRotorVIIITooltip",
     1173            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1174        public bool Cipher4AnalysisUseRotor8
     1175        {
     1176            get { return cipher4AnalysisUseRotor8; }
     1177            set
     1178            {
     1179
     1180                if (value != cipher4AnalysisUseRotor8)
     1181                {
     1182                    cipher4AnalysisUseRotor[7] = value;
     1183                    cipher4AnalysisUseRotor8 = value;
     1184                    OnPropertyChanged("Cipher4AnalysisUseRotor8");
     1185                }
     1186            }
     1187        }
     1188
     1189        [TaskPane("AnalysisUseRotorIXCaption", "Cipher4AnalysisUseRotorVIIITooltip",
     1190            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1191        public bool Cipher4AnalysisUseRotor9
     1192        {
     1193            get { return cipher4AnalysisUseRotor9; }
     1194            set
     1195            {
     1196
     1197                if (value != cipher4AnalysisUseRotor9)
     1198                {
     1199                    cipher4AnalysisUseRotor[8] = value;
     1200                    cipher4AnalysisUseRotor9 = value;
     1201                    OnPropertyChanged("Cipher4AnalysisUseRotor9");
     1202                }
     1203            }
     1204        }
     1205        [TaskPane("AnalysisUseRotorXCaption", "Cipher4AnalysisUseRotorVIIITooltip",
     1206            "Cipher4AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1207        public bool Cipher4AnalysisUseRotor0
     1208        {
     1209            get { return cipher4AnalysisUseRotor0; }
     1210            set
     1211            {
     1212
     1213                if (value != cipher4AnalysisUseRotor0)
     1214                {
     1215                    cipher4AnalysisUseRotor[9] = value;
     1216                    cipher4AnalysisUseRotor0 = value;
     1217                    OnPropertyChanged("Cipher4AnalysisUseRotor0");
     1218                }
     1219            }
     1220        }
     1221        #endregion
     1222
     1223        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fünf")]
     1224        [TaskPane("Cipher Rotor 5: From", "PlugBoardATooltip", "PositionOptionsGroup", 13, false, ControlType.ComboBox,
     1225            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     1226        public int CipherRotor5From
     1227        {
     1228            get { return cipherRotor5From; }
     1229            set
     1230            {
     1231
     1232                cipherRotor5From = value;
     1233                this.cipherRotorFrom[4] = (int)value;
     1234                OnPropertyChanged("CipherRotor5From");
     1235               
     1236
     1237                if (value > cipherRotor5To)
     1238                {
     1239                    CipherRotor5To = value;
     1240                    this.cipherRotorTo[4] = (int)value;
     1241                   
     1242                }
     1243            }
     1244        }
     1245
     1246        [SettingsFormat(0, "Normal", "Normal", "Black", "White", System.Windows.Controls.Orientation.Horizontal, "Auto", "*", "Fünf")]
     1247        [TaskPane("ToCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 14, false, ControlType.ComboBox,
     1248            new String[] { "LetterA", "LetterB", "LetterC", "LetterD", "LetterE", "LetterF", "LetterG", "LetterH", "LetterI", "LetterJ", "LetterK", "LetterL", "LetterM", "LetterN", "LetterO", "LetterP", "LetterQ", "LetterR", "LetterS", "LetterT", "LetterU", "LetterV", "LetterW", "LetterX", "LetterY", "LetterZ" })]
     1249        public int CipherRotor5To
     1250        {
     1251            get { return cipherRotor5To; }
     1252            set
     1253            {
     1254
     1255                cipherRotor5To = value;
     1256                this.cipherRotorTo[4] = (int)value;
     1257                OnPropertyChanged("CipherRotor5To");
     1258               
     1259                if (value < cipherRotor5From)
     1260                {
     1261                    CipherRotor5From = value;
     1262                    this.cipherRotorFrom[4] = (int)value;
     1263                }
     1264
     1265            }
     1266        }
     1267
     1268        [TaskPane("RevCaption", "PlugBoardBTooltip", "PositionOptionsGroup", 15, false, ControlType.RadioButton, new String[] { "undefinedCaption", "normalCaption", "reverseCaption" })]
     1269        public int CipherRotor5Rev
     1270        {
     1271            get { return cipherRotor5Rev; }
     1272            set
     1273            {
     1274
     1275                if (value != cipherRotor5Rev)
     1276                {
     1277                    cipherRotorRev[4] = value;
     1278                    cipherRotor5Rev = value;
     1279                    OnPropertyChanged("CipherRotor5Rev");
     1280                }
     1281
     1282            }
     1283        }
     1284
     1285        #region Rotor choice
     1286
     1287        [TaskPane("AnalysisUseRotorICaption", "AnalysisUseRotorITooltip",
     1288            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1289        public bool Cipher5AnalysisUseRotor1
     1290        {
     1291            get { return cipher5AnalysisUseRotor1; }
     1292            set
     1293            {
     1294
     1295                if (value != cipher5AnalysisUseRotor1)
     1296                {
     1297                    cipher5AnalysisUseRotor[0] = value;
     1298                    cipher5AnalysisUseRotor1 = value;
     1299                    OnPropertyChanged("Cipher5AnalysisUseRotor1");
     1300                }
     1301            }
     1302        }
     1303
     1304
     1305        [TaskPane("AnalysisUseRotorIICaption", "Cipher5AnalysisUseRotorIITooltip",
     1306            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1307        public bool Cipher5AnalysisUseRotor2
     1308        {
     1309            get { return cipher5AnalysisUseRotor2; }
     1310            set
     1311            {
     1312
     1313                if (value != cipher5AnalysisUseRotor2)
     1314                {
     1315                    cipher5AnalysisUseRotor[1] = value;
     1316                    cipher5AnalysisUseRotor2 = value;
     1317                    OnPropertyChanged("Cipher5AnalysisUseRotor2");
     1318                }
     1319            }
     1320        }
     1321
     1322
     1323        [TaskPane("AnalysisUseRotorIIICaption", "Cipher5AnalysisUseRotorIIITooltip",
     1324            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1325        public bool Cipher5AnalysisUseRotor3
     1326        {
     1327            get { return cipher5AnalysisUseRotor3; }
     1328            set
     1329            {
     1330
     1331                if (value != cipher5AnalysisUseRotor3)
     1332                {
     1333                    cipher5AnalysisUseRotor[2] = value;
     1334                    cipher5AnalysisUseRotor3 = value;
     1335                    OnPropertyChanged("Cipher5AnalysisUseRotor3");
     1336                }
     1337            }
     1338        }
     1339
     1340
     1341        [TaskPane("AnalysisUseRotorIVCaption", "Cipher5AnalysisUseRotorIVTooltip",
     1342            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1343        public bool Cipher5AnalysisUseRotor4
     1344        {
     1345            get { return cipher5AnalysisUseRotor4; }
     1346            set
     1347            {
     1348
     1349                if (value != cipher5AnalysisUseRotor4)
     1350                {
     1351                    cipher5AnalysisUseRotor[3] = value;
     1352                    cipher5AnalysisUseRotor4 = value;
     1353                    OnPropertyChanged("Cipher5AnalysisUseRotor4");
     1354                }
     1355            }
     1356        }
     1357
     1358
     1359
     1360        [TaskPane("AnalysisUseRotorVCaption", "Cipher5AnalysisUseRotorVTooltip",
     1361            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1362        public bool Cipher5AnalysisUseRotor5
     1363        {
     1364            get { return cipher5AnalysisUseRotor5; }
     1365            set
     1366            {
     1367
     1368                if (value != cipher5AnalysisUseRotor5)
     1369                {
     1370                    cipher5AnalysisUseRotor[4] = value;
     1371                    cipher5AnalysisUseRotor5 = value;
     1372                    OnPropertyChanged("Cipher5AnalysisUseRotor5");
     1373                }
     1374            }
     1375        }
     1376
     1377
     1378        [TaskPane("AnalysisUseRotorVICaption", "Cipher5AnalysisUseRotorVITooltip",
     1379            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1380        public bool Cipher5AnalysisUseRotor6
     1381        {
     1382            get { return cipher5AnalysisUseRotor6; }
     1383            set
     1384            {
     1385
     1386                if (value != cipher5AnalysisUseRotor6)
     1387                {
     1388                    cipher5AnalysisUseRotor[5] = value;
     1389                    cipher5AnalysisUseRotor6 = value;
     1390                    OnPropertyChanged("Cipher5AnalysisUseRotor6");
     1391                }
     1392            }
     1393        }
     1394
     1395
     1396
     1397        [TaskPane("AnalysisUseRotorVIICaption", "Cipher5AnalysisUseRotorVIITooltip",
     1398            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1399        public bool Cipher5AnalysisUseRotor7
     1400        {
     1401            get { return cipher5AnalysisUseRotor7; }
     1402            set
     1403            {
     1404
     1405                if (value != cipher5AnalysisUseRotor7)
     1406                {
     1407                    cipher5AnalysisUseRotor[6] = value;
     1408                    cipher5AnalysisUseRotor7 = value;
     1409                    OnPropertyChanged("Cipher5AnalysisUseRotor7");
     1410                }
     1411            }
     1412        }
     1413
     1414
     1415
     1416        [TaskPane("AnalysisUseRotorVIIICaption", "Cipher5AnalysisUseRotorVIIITooltip",
     1417            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1418        public bool Cipher5AnalysisUseRotor8
     1419        {
     1420            get { return cipher5AnalysisUseRotor8; }
     1421            set
     1422            {
     1423
     1424                if (value != cipher5AnalysisUseRotor8)
     1425                {
     1426                    cipher5AnalysisUseRotor[7] = value;
     1427                    cipher5AnalysisUseRotor8 = value;
     1428                    OnPropertyChanged("Cipher5AnalysisUseRotor8");
     1429                }
     1430            }
     1431        }
     1432
     1433        [TaskPane("AnalysisUseRotorIXCaption", "Cipher5AnalysisUseRotorVIIITooltip",
     1434            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1435        public bool Cipher5AnalysisUseRotor9
     1436        {
     1437            get { return cipher5AnalysisUseRotor9; }
     1438            set
     1439            {
     1440
     1441                if (value != cipher5AnalysisUseRotor9)
     1442                {
     1443                    cipher5AnalysisUseRotor[8] = value;
     1444                    cipher5AnalysisUseRotor9 = value;
     1445                    OnPropertyChanged("Cipher5AnalysisUseRotor9");
     1446                }
     1447            }
     1448        }
     1449        [TaskPane("AnalysisUseRotorXCaption", "Cipher5AnalysisUseRotorVIIITooltip",
     1450            "Cipher5AnalysisOptionsGroup", 7, false, ControlType.CheckBox, "", null)]
     1451        public bool Cipher5AnalysisUseRotor0
     1452        {
     1453            get { return cipher5AnalysisUseRotor0; }
     1454            set
     1455            {
     1456
     1457                if (value != cipher5AnalysisUseRotor0)
     1458                {
     1459                    cipher5AnalysisUseRotor[9] = value;
     1460                    cipher5AnalysisUseRotor0 = value;
     1461                    OnPropertyChanged("Cipher5AnalysisUseRotor0");
     1462                }
     1463            }
     1464        }
     1465        #endregion
     1466
     1467        #endregion
     1468
    611469        #region Events
    621470
Note: See TracChangeset for help on using the changeset viewer.