Changeset 2801


Ignore:
Timestamp:
Feb 23, 2011, 12:46:33 PM (11 years ago)
Author:
weyers
Message:

EnigmaPresentation - EnigmaSettings synchronisation, EnigmaPresentation input management updated

Location:
trunk/CrypPlugins/Enigma
Files:
6 edited

Legend:

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

    r2701 r2801  
    1717
    1818using System;
     19using System.Windows;
    1920using System.Collections.Generic;
    2021using System.Linq;
     
    6162        private EnigmaSettings settings;
    6263        private EnigmaPresentation myPresentation;
     64        private AutoResetEvent ars;
    6365        private EnigmaCore core;
    6466        private EnigmaAnalyzer analyzer;
     
    9092        {
    9193            String input = preFormatInput(text);
    92             myPresentation.setinput(input);
    93             myPresentation.playClick(null, EventArgs.Empty);
    94             return postFormatOutput(core.Encrypt(rotor1Pos, rotor2Pos, rotor3Pos, rotor4Pos, input));
     94            if (Presentation.IsVisible)
     95            {
     96               
     97                String output = core.Encrypt(rotor1Pos, rotor2Pos, rotor3Pos, rotor4Pos, input);
     98               
     99                myPresentation.output = output;
     100                myPresentation.setinput(input);
     101                //myPresentation.playClick(null, EventArgs.Empty);
     102                //return postFormatOutput(output);
     103                return "";
     104            }
     105            else
     106                return postFormatOutput(core.Encrypt(rotor1Pos, rotor2Pos, rotor3Pos, rotor4Pos, input));
    95107        }
    96108
     
    276288            this.analyzer.OnIntermediateResult += new EventHandler<IntermediateResultEventArgs>(analyzer_OnIntermediateResult);
    277289            this.statistics = new Dictionary<int, IDictionary<string, double[]>>();
    278             myPresentation = new EnigmaPresentation(this.settings);
     290           
     291            this.ars = new AutoResetEvent(false);
     292            this.myPresentation = new EnigmaPresentation(this);
    279293            this.Presentation = myPresentation;
     294            //this.Presentation.IsVisibleChanged += presentation_isvisibleChanged;
    280295            this.settings.PropertyChanged += myPresentation.settings_OnPropertyChange;
    281296            this.settings.PropertyChanged += settings_OnPropertyChange;
    282         }
     297            this.myPresentation.fireLetters += fireLetters;
     298
     299           
     300            }
    283301
    284302        #endregion
     
    291309        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    292310        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
     311
     312        private void fireLetters(object sender, EventArgs args) 
     313        {
     314            Object[] carrier = sender as Object[];
     315
     316            OutputString = (String)carrier[0] ;
     317            int x = (int)carrier[1];
     318            int y = (int)carrier[2];
     319            ShowProgress(x,y);
     320
     321        }
     322
     323        private void presentation_isvisibleChanged(object sender, DependencyPropertyChangedEventArgs args)
     324        {
     325            LogMessage("Here we go " + args.NewValue, NotificationLevel.Debug);
     326            Boolean visible = (Boolean) args.NewValue ;
     327            if (visible)
     328            {
     329             
     330            }
     331
     332            else
     333            {
     334               
     335            }
     336        }
    293337
    294338        private void settings_OnPropertyChange(object sender, PropertyChangedEventArgs e)
     
    370414        public void PreExecution()
    371415        {
     416            myPresentation.stopclick(this, EventArgs.Empty);
    372417            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs("Preparing enigma for operation..", this,  NotificationLevel.Info));
    373418
  • trunk/CrypPlugins/Enigma/EnigmaCore.cs

    r1259 r2801  
    138138                //update the status, if we are not in anylzing mode
    139139                // this must be deactivated during analysis, since it takes a lot of time
    140                 if (settings.Action == 0)
     140                if (settings.Action == 0 && !pluginFacade.Presentation.IsVisible)
    141141                    pluginFacade.ShowProgress(i, input.Length);
    142142            }
     
    321321           
    322322            // write back the updated rotor settings (only if not analyzing)
    323             if (settings.Action == 0)
    324                 settings.Key = currentKeyString();
     323            //if (settings.Action == 0)
     324            //    settings.Key = currentKeyString();
    325325
    326326            //add the ring-offset
  • trunk/CrypPlugins/Enigma/EnigmaPresentation.xaml

    r2701 r2801  
    55             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    66             mc:Ignorable="d"
    7              d:DesignHeight="1250" d:DesignWidth="2200">
     7             d:DesignHeight="1250" d:DesignWidth="2200" KeyDown="tastedruecken">
    88    <Canvas Name="mainCanvas">
    99
     
    1111        <Canvas Name="mainmainmain" Height="1250" Width="2200" HorizontalAlignment="Left">
    1212
    13             <Image Name ="background2" Source= "Images/background2.png" Height="999" Width="1678" Canvas.Top="-50" Canvas.Left="528" AllowDrop="True" Opacity="0.0"></Image>
     13            <Image Name ="background2" Source= "Images/background2.png" Height="1250" Width="2200" Canvas.Top="0" Canvas.Left="0" AllowDrop="True" Opacity="8.0"></Image>
    1414            <Image Name ="rotor1img" Source= "Images/rotor.png" Height="899" Width="260" Canvas.Top="0" Canvas.Left="458"></Image>
    1515            <Image Name ="rotor2img" Source= "Images/rotor.png" Height="899" Width="260" Canvas.Top="0" Canvas.Left="228"></Image>
    1616            <Image Name ="rotor3img" Source= "Images/rotor.png" Height="899" Width="260" Canvas.Top="0" Canvas.Left="688"></Image>
    1717            <Image Name ="walzeimg" Source= "Images/walze.png" Height="800" Width="260" Canvas.Top="42" Canvas.Left="0"></Image>
    18             <Image Name ="paperimg" Source= "Images/paper.png" Height="310" Width="1150" Canvas.Bottom="0" Canvas.Left="1100"></Image>
     18            <Image Name ="paperimg" Source= "Images/paper.png" Height="310" Width="1100" Canvas.Bottom="0" Canvas.Left="1100"></Image>
    1919            <Image Name ="kisteimg" Source= "Images/kiste.png" Height="130" Width="360" Canvas.Top="838" Canvas.Left="1280"></Image>
    2020            <Image Name ="kiste2img" Source= "Images/kiste.png" Height="130" Width="360" Canvas.Top="838" Canvas.Left="1695"></Image>
    2121            <Image Name ="oldpaperimg" Source= "Images/oldpaper.png" Height="300" Width="1050" Canvas.Bottom="0" Canvas.Left="0"></Image>
    2222
    23             <Rectangle Name="dummy" Opacity="0.0" Width="2200" Height="3000" Stroke="White" StrokeThickness="1" Fill="White" AllowDrop="True">
     23            <Rectangle Name="dummy" Opacity="0.0" Width="2200" Height="1250" Stroke="White" StrokeThickness="1" Fill="White" AllowDrop="True">
    2424
    2525            </Rectangle>
     
    9696
    9797            </WrapPanel>
    98             <WrapPanel Canvas.Bottom="-80" Name="outputPanel" Canvas.Right="50" Width="950" Height="300">
     98            <WrapPanel Canvas.Bottom="10" Name="outputPanel" Canvas.Right="67" Width="983" Height="200">
    9999                <WrapPanel.RenderTransform>
    100100                    <RotateTransform x:Name="TransRotate2"
    101                            CenterX="25" CenterY="25" Angle="-2" />
     101                           CenterX="25" CenterY="25" Angle="-2.5" />
    102102                </WrapPanel.RenderTransform>
    103103
  • trunk/CrypPlugins/Enigma/EnigmaPresentation.xaml.cs

    r2701 r2801  
    5353    public partial class  EnigmaPresentation : UserControl
    5454    {
     55        private Enigma pluginFacade;
     56        private EnigmaSettings settings;
     57
     58        public String output;
     59        public event EventHandler fireLetters;
     60        public event EventHandler updateProgress;
     61
     62
     63        String input;
    5564        Button[] bList = new Button[26];
    5665        Button[] tList = new Button[26];
     
    6372
    6473        Rectangle[] leuchtenList = new Rectangle[26];
     74       
     75        Canvas dummycanvas;
    6576
    6677        Line[,] umlList = new Line[26,3];
     
    141152        public void settings_OnPropertyChange(object sender, PropertyChangedEventArgs e)
    142153        {
    143             EnigmaSettings dummyset = sender as EnigmaSettings;
    144 
    145             if (e.PropertyName == "Ring1down")
    146             {
    147                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    148                 {
    149                     rotorarray[2].upperclick1(null, EventArgs.Empty);   
    150                 }, null);
    151             }
    152 
    153             if (e.PropertyName == "Ring1up")
    154             {
    155                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    156                 {
    157                     rotorarray[2].downerclick1(null, EventArgs.Empty);
    158                 }, null);
    159             }
    160 
    161             if (e.PropertyName == "Ring2down")
    162             {
    163                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    164                 {
    165                     rotorarray[1].upperclick1(null, EventArgs.Empty);
    166                 }, null);
    167             }
    168 
    169             if (e.PropertyName == "Ring2up")
    170             {
    171                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    172                 {
    173                     rotorarray[1].downerclick1(null, EventArgs.Empty);
    174                 }, null);
    175             }
    176 
    177             if (e.PropertyName == "Ring3down")
    178             {
    179                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    180                 {
    181                     rotorarray[0].upperclick1(null, EventArgs.Empty);
    182                 }, null);
    183             }
    184 
    185             if (e.PropertyName == "Ring3up")
    186             {
    187                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    188                 {
    189                     rotorarray[0].downerclick1(null, EventArgs.Empty);
    190                 }, null);
    191             }
    192 
    193             if (e.PropertyName[0] == 'P' && e.PropertyName !="PlugBoardDisplay")
    194             {
    195                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    196                 {
    197                     Button b = new Button();
    198                     b.Uid ="" +( Convert.ToInt32(e.PropertyName[9]) -65);
    199                     b.Content = Convert.ToInt32(e.PropertyName[9]) - 65;
    200                     int i = Convert.ToInt32(e.PropertyName[9]) - 65;
    201                     if(i == switchlist[i])
    202                     switch (i) {
    203                         case 0:
    204                            
    205                                 switchbuttons(i, dummyset.PlugBoardA);
    206                                 break;
    207                         case 1:
    208                                 switchbuttons(i, dummyset.PlugBoardB);
    209                                 break;
    210                         case 2:
    211                                 switchbuttons(i, dummyset.PlugBoardC);
    212                                 break;
    213                         case 3:
    214                            
    215                                 switchbuttons(i, dummyset.PlugBoardD);
    216                                 break;
    217                         case 4:
    218                                 switchbuttons(i, dummyset.PlugBoardE);
    219                                 break;
    220                         case 5:
    221                                 switchbuttons(i, dummyset.PlugBoardF);
    222                                 break;
    223                         case 6:
    224                                 switchbuttons(i, dummyset.PlugBoardG);
    225                                 break;
    226                         case 7:
    227                                 switchbuttons(i, dummyset.PlugBoardH);
    228                                 break;
    229                         case 8:
    230                                 switchbuttons(i, dummyset.PlugBoardI);
    231                                 break;
    232                         case 9:
    233                                 switchbuttons(i, dummyset.PlugBoardJ);
    234                                 break;
    235                         case 10:
    236                                 switchbuttons(i, dummyset.PlugBoardK);
    237                                 break;
    238                         case 11:
    239                                 switchbuttons(i, dummyset.PlugBoardL);
    240                                 break;
    241                         case 12:
    242                                 switchbuttons(i, dummyset.PlugBoardM);
    243                                 break;
    244                         case 13:
    245                                 switchbuttons(i, dummyset.PlugBoardN);
    246                                 break;
    247                         case 14:
    248                                 switchbuttons(i, dummyset.PlugBoardO);
    249                                 break;
    250                         case 15:
    251                                 switchbuttons(i, dummyset.PlugBoardP);
    252                                 break;
    253                         case 16:
    254                                 switchbuttons(i, dummyset.PlugBoardQ);
    255                                 break;
    256                         case 17:
    257                                 switchbuttons(i, dummyset.PlugBoardR);
    258                                 break;
    259                         case 18:
    260                                 switchbuttons(i, dummyset.PlugBoardS);
    261                                 break;
    262                         case 19:
    263                                 switchbuttons(i, dummyset.PlugBoardT);
    264                                 break;
    265                         case 20:
    266                                 switchbuttons(i, dummyset.PlugBoardU);
    267                                 break;
    268                         case 21:
    269                                 switchbuttons(i, dummyset.PlugBoardV);
    270                                 break;
    271                         case 22:
    272                                 switchbuttons(i, dummyset.PlugBoardW);
    273                                 break;
    274                         case 23:
    275                                 switchbuttons(i, dummyset.PlugBoardX);
    276                                 break;
    277                         case 24:
    278                                 switchbuttons(i, dummyset.PlugBoardY);
    279                                 break;
    280                         case 25:
    281                                 switchbuttons(i, dummyset.PlugBoardZ);
    282                                 break;
    283                        
    284 
    285                 }
    286 
    287                     //List_MouseLeftButtonDown(b,EventArgs.Empty);
    288                 }, null);
    289             }
    290             if (e.PropertyName == "PlugBoardDisplay")
    291             {
    292                 merken = -1;
    293             }
    294 
    295             if (e.PropertyName == "Reflector")
    296             {
    297                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    298                 {
    299                     this.walze.helpNextAnimation -= helptoanimate5;
    300 
    301                     dropBoxCanvasWalze.Children.Remove(walzeimgs[dummyset.Reflector]);
    302 
    303                     Image img = new Image();
    304                     img.Height = 100;
    305                     img.Width = 50;
    306                     BitmapImage bi = new BitmapImage();
    307                     bi.BeginInit();
    308                     bi.UriSource = new Uri("Images/rotor" + walze.typ + ".jpg", UriKind.Relative);
    309                     bi.EndInit();
    310                     img.Source = bi;
    311 
    312 
    313                     Canvas.SetLeft(img, 50 * walze.typ);
    314 
    315                     dropBoxCanvasWalze.Children.Add(img);
    316                     img.Uid = "" + walze.typ;
    317                     img.Cursor = Cursors.Hand;
    318 
    319                     img.PreviewMouseMove += Walze_MouseMove1;
    320                     walzeimgs[walze.typ - 1] = img;
    321                     walzenarea.Children.Remove(walze);
    322 
    323                     Walze walze1 = new Walze(dummyset.Reflector , this.Width, this.Height);
    324                     walze1.fast = speed * 80;
    325                     Canvas.SetLeft(walze1, 0);
    326                     Canvas.SetTop(walze1, 60);
    327                     walzenarea.Children.Add(walze1);
    328                     walze1.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
    329                     walze1.PreviewMouseMove += new MouseEventHandler(Walze_MouseMove);
    330                     this.walze = walze1;
    331                     walze.helpNextAnimation += helptoanimate5;
    332 
    333 
    334                 }, null);
    335             }
    336 
    337             if (e.PropertyName == "Rotor1")
    338             {
    339                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    340                 {
    341                     dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor1]);
    342 
    343                     Image img = new Image();
    344                     img.Height = 100;
    345                     img.Width = 50;
    346                     BitmapImage bi = new BitmapImage();
    347                     bi.BeginInit();
    348                     bi.UriSource = new Uri("Images/rotor" + rotorarray[2].map + ".jpg", UriKind.Relative);
    349                     bi.EndInit();
    350                     img.Source = bi;
    351 
    352 
    353                     Canvas.SetLeft(img, 50 * rotorarray[2].map);
    354 
    355                     dropBoxCanvas.Children.Add(img);
    356                     img.Uid = "" + rotorarray[2].map;
    357                     img.Cursor = Cursors.Hand;
    358 
    359                     img.PreviewMouseMove += Rotor_MouseMove1;
    360                     rotorimgs[rotorarray[2].map - 1] = img;
    361 
    362                     rotorarray[2].helpNextAnimation -= helptoanimate2;
    363                     rotorarray[2].helpNextAnimation2 -= helptoanimate8;
    364                     rotorarea.Children.Remove(rotorarray[2]);
    365 
    366                     Rotor2 rotor = new Rotor2(dummyset.Rotor1, this.Width, this.Height, dummyset.Key[2] - 65, dummyset.Ring1);
    367                     rotor.fast = speed * 80;
    368                     rotor.Cursor = Cursors.Hand;
    369                     rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
    370                     Canvas.SetLeft(rotor, 460);
    371                     rotorarea.Children.Add(rotor);
    372                     rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
    373 
    374                     rotorarray[2] = rotor;
    375                     rotorarray[2].helpNextAnimation += helptoanimate2;
    376                     rotorarray[2].helpNextAnimation2 += helptoanimate8;
    377 
    378 
    379 
    380                 }, null);
    381             }
    382 
    383             if (e.PropertyName == "Rotor2")
    384             {
    385                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    386                 {
    387 
    388                     dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor2]);
    389                     Image img = new Image();
    390                     img.Height = 100;
    391                     img.Width = 50;
    392                     BitmapImage bi = new BitmapImage();
    393                     bi.BeginInit();
    394                     bi.UriSource = new Uri("Images/rotor" + rotorarray[1].map + ".jpg", UriKind.Relative);
    395                     bi.EndInit();
    396                     img.Source = bi;
    397                     dropBoxCanvas.Children.Add(img);
    398                     Canvas.SetLeft(img, 50 * rotorarray[1].map);
    399                     img.Uid = "" + rotorarray[1].map;
    400                     img.Cursor = Cursors.Hand;
    401 
    402                     img.PreviewMouseMove += Rotor_MouseMove1;
    403 
    404                     rotorimgs[rotorarray[1].map - 1] = img;
    405 
    406                     rotorarray[1].helpNextAnimation -= helptoanimate2;
    407                     rotorarray[1].helpNextAnimation2 -= helptoanimate8;
    408 
    409                     rotorarea.Children.Remove(rotorarray[1]);
    410 
    411                     Rotor2 rotor = new Rotor2(dummyset.Rotor2, this.Width, this.Height, dummyset.Key[1] - 65, dummyset.Ring2);
    412                     rotor.fast = speed * 80;
    413                     rotor.Cursor = Cursors.Hand;
    414                     rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
    415                     Canvas.SetLeft(rotor, 230);
    416                     rotorarea.Children.Add(rotor);
    417                     rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
    418 
    419                     rotorarray[1] = rotor;
    420                     rotorarray[1].helpNextAnimation += helptoanimate3;
    421                     rotorarray[1].helpNextAnimation2 += helptoanimate7;
    422 
    423                 }, null);
    424             }
    425 
    426             if (e.PropertyName == "Rotor3")
    427             {
    428                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    429                 {
    430 
    431                     dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor3]);
    432 
    433                     Image img = new Image();
    434                     img.Height = 100;
    435                     img.Width = 50;
    436                     BitmapImage bi = new BitmapImage();
    437                     bi.BeginInit();
    438                     bi.UriSource = new Uri("Images/rotor" + rotorarray[0].map + ".jpg", UriKind.Relative);
    439                     bi.EndInit();
    440                     img.Source = bi;
    441                     dropBoxCanvas.Children.Add(img);
    442                     Canvas.SetLeft(img, 50 * rotorarray[0].map);
    443                     img.Uid = "" + rotorarray[0].map;
    444                     img.Cursor = Cursors.Hand;
    445 
    446                     img.PreviewMouseMove += Rotor_MouseMove1;
    447 
    448                     rotorimgs[rotorarray[0].map - 1] = img;
    449 
    450                     rotorarray[0].helpNextAnimation -= helptoanimate2;
    451                     rotorarray[0].helpNextAnimation2 -= helptoanimate8;
    452 
    453                     rotorarea.Children.Remove(rotorarray[0]);
    454 
    455                     Rotor2 rotor = new Rotor2(dummyset.Rotor3, this.Width, this.Height, dummyset.Key[0] - 65, dummyset.Ring3);
    456                     rotor.fast = speed * 80;
    457                     rotor.Cursor = Cursors.Hand;
    458                     rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
    459                     Canvas.SetLeft(rotor, 0);
    460                     rotorarea.Children.Add(rotor);
    461                     rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
    462 
    463                     rotorarray[0] = rotor;
    464                     rotorarray[0].helpNextAnimation += helptoanimate4;
    465                     rotorarray[0].helpNextAnimation2 += helptoanimate6;
    466                 }, null);
    467             }
    468 
    469             Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    470             {
    471                 dropBoxCanvasWalze.Children.Remove(walzeimgs[dummyset.Reflector]);
    472                 dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor3]);
    473                 dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor2]);
    474                 dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor1]);
    475             }, null);
    476 
    477         }
    478            
    479        
    480 
    481         /*
    482         public void settingsChanged(EnigmaSettings dummyset)
    483         {
    484             if (justonce)
    485             {
    486                 justonce = false;
    487                 Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    488                 { everythingblack(); Debug.Text = "" + walze.typ; }, null);
    489                
    490                 if (dummyset.Reflector+1  !=  walze.typ)
     154            EnigmaSettings settings = sender as EnigmaSettings;
     155            if (!playbool)
     156            {
     157                if (e.PropertyName == "Key" && justme)
     158                {
     159                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     160                    {
     161                        rotorarray[2].changeoffset(settings.Key[2] - 65, settings.Ring1);
     162                        rotorarray[1].changeoffset(settings.Key[1] - 65, settings.Ring2);
     163                        rotorarray[0].changeoffset(settings.Key[0] - 65, settings.Ring3);
     164                    }, null);
     165                }
     166                if (e.PropertyName == "Ring1down")
     167                {
     168                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     169                    {
     170                        rotorarray[2].upperclick1(null, EventArgs.Empty);
     171                    }, null);
     172                }
     173
     174                if (e.PropertyName == "Ring1up")
     175                {
     176                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     177                    {
     178                        rotorarray[2].downerclick1(null, EventArgs.Empty);
     179                    }, null);
     180                }
     181
     182                if (e.PropertyName == "Ring2down" && justme)
     183                {
     184                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     185                    {
     186                        rotorarray[1].upperclick1(null, EventArgs.Empty);
     187                    }, null);
     188                }
     189
     190                if (e.PropertyName == "Ring2up")
     191                {
     192                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     193                    {
     194                        rotorarray[1].downerclick1(null, EventArgs.Empty);
     195                    }, null);
     196                }
     197
     198                if (e.PropertyName == "Ring3down")
     199                {
     200                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     201                    {
     202                        rotorarray[0].upperclick1(null, EventArgs.Empty);
     203                    }, null);
     204                }
     205
     206                if (e.PropertyName == "Ring3up")
     207                {
     208                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     209                    {
     210                        rotorarray[0].downerclick1(null, EventArgs.Empty);
     211                    }, null);
     212                }
     213
     214                if (e.PropertyName[0] == 'P' && e.PropertyName != "PlugBoardDisplay" && justme)
     215                {
     216                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     217                    {
     218                        Button b = new Button();
     219                        b.Uid = "" + (Convert.ToInt32(e.PropertyName[9]) - 65);
     220                        b.Content = Convert.ToInt32(e.PropertyName[9]) - 65;
     221                        int i = Convert.ToInt32(e.PropertyName[9]) - 65;
     222                        if (i == switchlist[i])
     223                            switch (i)
     224                            {
     225                                case 0:
     226
     227                                    switchbuttons(i, settings.PlugBoardA);
     228                                    break;
     229                                case 1:
     230                                    switchbuttons(i, settings.PlugBoardB);
     231                                    break;
     232                                case 2:
     233                                    switchbuttons(i, settings.PlugBoardC);
     234                                    break;
     235                                case 3:
     236
     237                                    switchbuttons(i, settings.PlugBoardD);
     238                                    break;
     239                                case 4:
     240                                    switchbuttons(i, settings.PlugBoardE);
     241                                    break;
     242                                case 5:
     243                                    switchbuttons(i, settings.PlugBoardF);
     244                                    break;
     245                                case 6:
     246                                    switchbuttons(i, settings.PlugBoardG);
     247                                    break;
     248                                case 7:
     249                                    switchbuttons(i, settings.PlugBoardH);
     250                                    break;
     251                                case 8:
     252                                    switchbuttons(i, settings.PlugBoardI);
     253                                    break;
     254                                case 9:
     255                                    switchbuttons(i, settings.PlugBoardJ);
     256                                    break;
     257                                case 10:
     258                                    switchbuttons(i, settings.PlugBoardK);
     259                                    break;
     260                                case 11:
     261                                    switchbuttons(i, settings.PlugBoardL);
     262                                    break;
     263                                case 12:
     264                                    switchbuttons(i, settings.PlugBoardM);
     265                                    break;
     266                                case 13:
     267                                    switchbuttons(i, settings.PlugBoardN);
     268                                    break;
     269                                case 14:
     270                                    switchbuttons(i, settings.PlugBoardO);
     271                                    break;
     272                                case 15:
     273                                    switchbuttons(i, settings.PlugBoardP);
     274                                    break;
     275                                case 16:
     276                                    switchbuttons(i, settings.PlugBoardQ);
     277                                    break;
     278                                case 17:
     279                                    switchbuttons(i, settings.PlugBoardR);
     280                                    break;
     281                                case 18:
     282                                    switchbuttons(i, settings.PlugBoardS);
     283                                    break;
     284                                case 19:
     285                                    switchbuttons(i, settings.PlugBoardT);
     286                                    break;
     287                                case 20:
     288                                    switchbuttons(i, settings.PlugBoardU);
     289                                    break;
     290                                case 21:
     291                                    switchbuttons(i, settings.PlugBoardV);
     292                                    break;
     293                                case 22:
     294                                    switchbuttons(i, settings.PlugBoardW);
     295                                    break;
     296                                case 23:
     297                                    switchbuttons(i, settings.PlugBoardX);
     298                                    break;
     299                                case 24:
     300                                    switchbuttons(i, settings.PlugBoardY);
     301                                    break;
     302                                case 25:
     303                                    switchbuttons(i, settings.PlugBoardZ);
     304                                    break;
     305
     306
     307                            }
     308
     309                        //List_MouseLeftButtonDown(b,EventArgs.Empty);
     310                    }, null);
     311                }
     312                if (e.PropertyName == "PlugBoardDisplay")
     313                {
     314                    merken = -1;
     315                }
     316
     317                if (e.PropertyName == "Reflector")
    491318                {
    492319                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     
    494321                        this.walze.helpNextAnimation -= helptoanimate5;
    495322
    496                         dropBoxCanvasWalze.Children.Remove(walzeimgs[dummyset.Reflector]);
     323                        dropBoxCanvasWalze.Children.Remove(walzeimgs[settings.Reflector]);
    497324
    498325                        Image img = new Image();
     
    516343                        walzenarea.Children.Remove(walze);
    517344
    518                         Walze walze1 = new Walze(dummyset.Reflector+1, this.Width, this.Height);
     345                        Walze walze1 = new Walze(settings.Reflector + 1, this.Width, this.Height);
     346                        walze1.fast = speed * 80;
     347                        Canvas.SetLeft(walze1, 0);
     348                        Canvas.SetTop(walze1, 60);
     349                        walzenarea.Children.Add(walze1);
     350                        walze1.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
     351                        walze1.PreviewMouseMove += new MouseEventHandler(Walze_MouseMove);
     352                        this.walze = walze1;
     353                        walze.helpNextAnimation += helptoanimate5;
     354
     355
     356                    }, null);
     357                }
     358
     359                if (e.PropertyName == "Rotor1")
     360                {
     361                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     362                    {
     363                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor1]);
     364
     365                        Image img = new Image();
     366                        img.Height = 100;
     367                        img.Width = 50;
     368                        BitmapImage bi = new BitmapImage();
     369                        bi.BeginInit();
     370                        bi.UriSource = new Uri("Images/rotor" + rotorarray[2].map + ".jpg", UriKind.Relative);
     371                        bi.EndInit();
     372                        img.Source = bi;
     373
     374
     375                        Canvas.SetLeft(img, 50 * rotorarray[2].map);
     376
     377                        dropBoxCanvas.Children.Add(img);
     378                        img.Uid = "" + (rotorarray[2].map);
     379                        img.Cursor = Cursors.Hand;
     380
     381                        img.PreviewMouseMove += Rotor_MouseMove1;
     382                        rotorimgs[rotorarray[2].map - 1] = img;
     383
     384                        rotorarray[2].helpNextAnimation -= helptoanimate2;
     385                        rotorarray[2].helpNextAnimation2 -= helptoanimate8;
     386                        rotorarea.Children.Remove(rotorarray[2]);
     387
     388                        Rotor2 rotor = new Rotor2(settings.Rotor1 + 1, this.Width, this.Height, settings.Key[2] - 65, settings.Ring1);
     389
     390                        rotor.updone += changeSettings;
     391                        rotor.downdone += changeSettings;
     392                        rotor.up1done += changeSettings;
     393                        rotor.down1done += changeSettings;
     394
     395
     396                        rotor.fast = speed * 80;
     397                        rotor.Cursor = Cursors.Hand;
     398                        rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
     399                        Canvas.SetLeft(rotor, 460);
     400                        rotorarea.Children.Add(rotor);
     401                        rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
     402
     403                        rotorarray[2] = rotor;
     404                        rotorarray[2].helpNextAnimation += helptoanimate2;
     405                        rotorarray[2].helpNextAnimation2 += helptoanimate8;
     406
     407
     408
     409                    }, null);
     410                }
     411
     412                if (e.PropertyName == "Rotor2")
     413                {
     414                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     415                    {
     416
     417                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor2]);
     418                        Image img = new Image();
     419                        img.Height = 100;
     420                        img.Width = 50;
     421                        BitmapImage bi = new BitmapImage();
     422                        bi.BeginInit();
     423                        bi.UriSource = new Uri("Images/rotor" + rotorarray[1].map + ".jpg", UriKind.Relative);
     424                        bi.EndInit();
     425                        img.Source = bi;
     426                        dropBoxCanvas.Children.Add(img);
     427                        Canvas.SetLeft(img, 50 * rotorarray[1].map);
     428                        img.Uid = "" + (rotorarray[1].map);
     429                        img.Cursor = Cursors.Hand;
     430
     431                        img.PreviewMouseMove += Rotor_MouseMove1;
     432
     433                        rotorimgs[rotorarray[1].map - 1] = img;
     434
     435                        rotorarray[1].helpNextAnimation -= helptoanimate2;
     436                        rotorarray[1].helpNextAnimation2 -= helptoanimate8;
     437
     438                        rotorarea.Children.Remove(rotorarray[1]);
     439
     440                        Rotor2 rotor = new Rotor2(settings.Rotor2 + 1, this.Width, this.Height, settings.Key[1] - 65, settings.Ring2);
     441
     442
     443                        rotor.updone += changeSettings;
     444                        rotor.downdone += changeSettings;
     445                        rotor.up1done += changeSettings;
     446                        rotor.down1done += changeSettings;
     447
     448
     449                        rotor.fast = speed * 80;
     450                        rotor.Cursor = Cursors.Hand;
     451                        rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
     452                        Canvas.SetLeft(rotor, 230);
     453                        rotorarea.Children.Add(rotor);
     454                        rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
     455
     456                        rotorarray[1] = rotor;
     457                        rotorarray[1].helpNextAnimation += helptoanimate3;
     458                        rotorarray[1].helpNextAnimation2 += helptoanimate7;
     459
     460                    }, null);
     461                }
     462
     463                if (e.PropertyName == "Rotor3")
     464                {
     465                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     466                    {
     467
     468                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor3]);
     469
     470                        Image img = new Image();
     471                        img.Height = 100;
     472                        img.Width = 50;
     473                        BitmapImage bi = new BitmapImage();
     474                        bi.BeginInit();
     475                        bi.UriSource = new Uri("Images/rotor" + rotorarray[0].map + ".jpg", UriKind.Relative);
     476                        bi.EndInit();
     477                        img.Source = bi;
     478                        dropBoxCanvas.Children.Add(img);
     479                        Canvas.SetLeft(img, 50 * rotorarray[0].map);
     480                        img.Uid = "" + (rotorarray[0].map);
     481                        img.Cursor = Cursors.Hand;
     482
     483                        img.PreviewMouseMove += Rotor_MouseMove1;
     484
     485                        rotorimgs[rotorarray[0].map - 1] = img;
     486
     487                        rotorarray[0].helpNextAnimation -= helptoanimate2;
     488                        rotorarray[0].helpNextAnimation2 -= helptoanimate8;
     489
     490                        rotorarea.Children.Remove(rotorarray[0]);
     491
     492                        Rotor2 rotor = new Rotor2(settings.Rotor3 + 1, this.Width, this.Height, settings.Key[0] - 65, settings.Ring3);
     493
     494
     495                        rotor.updone += changeSettings;
     496                        rotor.downdone += changeSettings;
     497                        rotor.up1done += changeSettings;
     498                        rotor.down1done += changeSettings;
     499
     500
     501                        rotor.fast = speed * 80;
     502                        rotor.Cursor = Cursors.Hand;
     503                        rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
     504                        Canvas.SetLeft(rotor, 0);
     505                        rotorarea.Children.Add(rotor);
     506                        rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
     507
     508                        rotorarray[0] = rotor;
     509                        rotorarray[0].helpNextAnimation += helptoanimate4;
     510                        rotorarray[0].helpNextAnimation2 += helptoanimate6;
     511                    }, null);
     512                }
     513
     514                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     515                {
     516                    dropBoxCanvasWalze.Children.Remove(walzeimgs[settings.Reflector]);
     517                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor3]);
     518                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor2]);
     519                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor1]);
     520                }, null);
     521            }
     522        }
     523           
     524       
     525
     526        /*
     527        public void settingsChanged(EnigmaSettings settings)
     528        {
     529            if (justonce)
     530            {
     531                justonce = false;
     532                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     533                { everythingblack(); Debug.Text = "" + walze.typ; }, null);
     534               
     535                if (settings.Reflector+1  !=  walze.typ)
     536                {
     537                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     538                    {
     539                        this.walze.helpNextAnimation -= helptoanimate5;
     540
     541                        dropBoxCanvasWalze.Children.Remove(walzeimgs[settings.Reflector]);
     542
     543                        Image img = new Image();
     544                        img.Height = 100;
     545                        img.Width = 50;
     546                        BitmapImage bi = new BitmapImage();
     547                        bi.BeginInit();
     548                        bi.UriSource = new Uri("Images/rotor" + walze.typ + ".jpg", UriKind.Relative);
     549                        bi.EndInit();
     550                        img.Source = bi;
     551
     552
     553                        Canvas.SetLeft(img, 50 * walze.typ);
     554
     555                        dropBoxCanvasWalze.Children.Add(img);
     556                        img.Uid = "" + walze.typ;
     557                        img.Cursor = Cursors.Hand;
     558
     559                        img.PreviewMouseMove += Walze_MouseMove1;
     560                        walzeimgs[walze.typ - 1] = img;
     561                        walzenarea.Children.Remove(walze);
     562
     563                        Walze walze1 = new Walze(settings.Reflector+1, this.Width, this.Height);
    519564                        walze1.fast = speed * 80;
    520565                        Canvas.SetLeft(walze1, 0);
     
    530575                }
    531576
    532                 if (dummyset.Rotor1 + 1 != rotorarray[2].map)
     577                if (settings.Rotor1 + 1 != rotorarray[2].map)
    533578                {
    534579                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    535580                    {
    536                         dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor1]);
     581                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor1]);
    537582
    538583                        Image img = new Image();
     
    559604                        rotorarea.Children.Remove(rotorarray[2]);
    560605
    561                         Rotor2 rotor = new Rotor2(dummyset.Rotor1 + 1, this.Width, this.Height);
     606                        Rotor2 rotor = new Rotor2(settings.Rotor1 + 1, this.Width, this.Height);
    562607                        rotor.fast = speed * 80;
    563608                        rotor.Cursor = Cursors.Hand;
     
    576621                }
    577622
    578                 if (dummyset.Rotor2 + 1 != rotorarray[1].map)
     623                if (settings.Rotor2 + 1 != rotorarray[1].map)
    579624                {
    580625                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    581626                    {
    582627
    583                         dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor2]);
     628                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor2]);
    584629                        Image img = new Image();
    585630                        img.Height = 100;
     
    604649                        rotorarea.Children.Remove(rotorarray[1]);
    605650
    606                         Rotor2 rotor = new Rotor2(dummyset.Rotor2 + 1, this.Width, this.Height);
     651                        Rotor2 rotor = new Rotor2(settings.Rotor2 + 1, this.Width, this.Height);
    607652                        rotor.fast = speed * 80;
    608653                        rotor.Cursor = Cursors.Hand;
     
    619664                }
    620665
    621                 if (dummyset.Rotor3 + 1 != rotorarray[0].map)
     666                if (settings.Rotor3 + 1 != rotorarray[0].map)
    622667                {
    623668                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    624669                    {
    625670
    626                         dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor3]);
     671                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor3]);
    627672
    628673                        Image img = new Image();
     
    648693                        rotorarea.Children.Remove(rotorarray[0]);
    649694
    650                         Rotor2 rotor = new Rotor2(dummyset.Rotor3 + 1, this.Width, this.Height);
     695                        Rotor2 rotor = new Rotor2(settings.Rotor3 + 1, this.Width, this.Height);
    651696                        rotor.fast = speed * 80;
    652697                        rotor.Cursor = Cursors.Hand;
     
    663708                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    664709                {
    665                     dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor3]);
    666                     dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor2]);
    667                     dropBoxCanvas.Children.Remove(rotorimgs[dummyset.Rotor1]);
     710                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor3]);
     711                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor2]);
     712                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor1]);
    668713                }, null);
    669714                justonce = true;
     
    673718
    674719
    675         public EnigmaPresentation(EnigmaSettings settings)
    676         {
     720        public EnigmaPresentation(Enigma facade)
     721        {
     722           
     723
     724            pluginFacade = facade;
     725            settings = (EnigmaSettings)pluginFacade.Settings;
     726            //settings.PropertyChanged += changeSettings;
     727
    677728            InitializeComponent();
    678729            SizeChanged += sizeChanged;
     730
     731           
     732
    679733            //mainWindow.WindowStyle = WindowStyle.None;
    680734            slider1.ValueChanged += this.sliderValueChanged;
     
    918972            //String settingskey = settings.Key;
    919973
    920            
    921 
    922 
    923             Rotor2 rotor = new Rotor2(settings.Rotor1, this.Width, this.Height,settings.Key[0]-65,settings.Ring1);
     974
     975
     976
     977            Rotor2 rotor = new Rotor2(settings.Rotor3 + 1, this.Width, this.Height, settings.Key[0] - 65, settings.Ring1);
     978            rotor.updone += changeSettings;
     979            rotor.downdone += changeSettings;
    924980            rotor.fast = speed * 80;
    925981            rotor.Cursor =  Cursors.Hand;
     
    935991
    936992
    937             Walze walze = new Walze(settings.Reflector, this.Width, this.Height);
     993            Walze walze = new Walze(settings.Reflector+1, this.Width, this.Height);
    938994            walze.fast = speed * 80;
    939995            Canvas.SetLeft(walze, 0);
     
    9441000            this.walze = walze;
    9451001
    946             Rotor2 rotor1 = new Rotor2(settings.Rotor2, this.Width, this.Height, settings.Key[1] - 65, settings.Ring1);
     1002            Rotor2 rotor1 = new Rotor2(settings.Rotor2+1, this.Width, this.Height, settings.Key[1] - 65, settings.Ring1);
     1003            rotor1.updone += changeSettings;
     1004            rotor1.downdone += changeSettings;
    9471005            rotor1.fast = speed * 80;
    9481006            rotor1.Cursor = Cursors.Hand;
     
    9541012            rotorarray[1] = rotor1;
    9551013
    956             Rotor2 rotor2 = new Rotor2(settings.Rotor3, this.Width, this.Height, settings.Key[2] - 65, settings.Ring1);
     1014            Rotor2 rotor2 = new Rotor2(settings.Rotor1 + 1, this.Width, this.Height, settings.Key[2] - 65, settings.Ring1);
     1015            rotor2.updone += changeSettings;
     1016            rotor2.downdone += changeSettings;
    9571017            rotor2.fast = speed * 80;
    9581018            rotor2.Cursor = Cursors.Hand;
     
    10681128            dropBoxCanvas.Children.Add(img4);
    10691129            Canvas.SetLeft(img4, 50 * 5);
    1070             img4.Uid = "5";
     1130            img4.Uid = "4";
    10711131            img4.Cursor = Cursors.Hand;
    10721132
     
    10811141            dropBoxCanvas.Children.Add(img3);
    10821142            Canvas.SetLeft(img3, 50 * 4);
    1083             img3.Uid = "4";
     1143            img3.Uid = "3";
    10841144            img3.Cursor = Cursors.Hand;
    10851145
     
    11131173            fadeOut.Duration = new Duration(TimeSpan.FromMilliseconds((1000)));
    11141174
    1115            
    1116 
     1175            dummycanvas = new Canvas();
     1176            mainmainmain.Children.Add(dummycanvas);
     1177            input = "";
    11171178            /*
    11181179            String input = "LJPQHSVDWCLYXZQFXHIUVWDJOBJNZXRCWEOTVNJCIONTFQNSXWISXKHJDAGDJVAKUKVMJAJHSZQQJHZOIAVZOWMSCKASRDNXKKSRFHCXCMPJGXYIJCCKISYYSHETXVVOVDQLZYTNJXNUWKZRXUJFXMBDIBRVMJKRHTCUJQPTEEIYNYNJBEAQJCLMUODFWMARQCFOBWN";
     
    11461207            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    11471208            {
    1148                 inputtebo = new List<TextBlock>();
    1149 
    1150                 for (int i = 0; i < input.Length; i++)
    1151                 {
    1152                     if (i % 5 == 0 && i != 0)
     1209
     1210
     1211                               
     1212
     1213                if (this.input.Length+1 != input.Length &&!playbool && input !="")
     1214                {
     1215                    stopclick(this,EventArgs.Empty);
     1216                    this.input = input;
     1217                    inputtebo = new List<TextBlock>();
     1218
     1219                    for (int i = 0; i < input.Length; i++)
    11531220                    {
    1154                         TextBlock t1 = new TextBlock();
    1155                         t1.Text = " ";
    1156                         t1.FontSize = 40;
    1157                         inputPanel.Children.Add(t1);
     1221                        /*
     1222                        if (i % 5 == 0 && i != 0)
     1223                        {
     1224                            TextBlock t1 = new TextBlock();
     1225                            t1.Text = " ";
     1226                            t1.FontSize = 40;
     1227                            inputPanel.Children.Add(t1);
     1228
     1229                        }
     1230                        */
     1231                        TextBlock t = new TextBlock();
     1232                        t.FontFamily = new FontFamily("Courier New");
     1233                        t.Text = input[i] + "";
     1234                        t.FontSize = 41;
     1235                        inputPanel.Children.Add(t);
     1236                        inputtebo.Add(t);
    11581237
    11591238                    }
    1160 
    1161                     TextBlock t = new TextBlock();
    1162                     t.FontFamily = new FontFamily("Courier New");
    1163                     t.Text = input[i] + "";
    1164                     t.FontSize = 41;
    1165                     inputPanel.Children.Add(t);
    1166                     inputtebo.Add(t);
    1167 
    1168                 }
    1169 
    1170 
     1239                    Debug.Text = "Schiiiiiiiiibiiiiiiiiiiiiiiiiiiiiii";
     1240                    playClick(null,EventArgs.Empty);
     1241                }
     1242
     1243               
     1244                if (input == "")
     1245                {
     1246                    this.input = input;
     1247                }
     1248
     1249               
     1250
     1251
     1252                if (this.input.Length < input.Length)
     1253                {
     1254                    int pos = input.Length-1;
     1255                    for (int i = 0; i < input.Length-1; i++)
     1256                    {
     1257                        if(this.input[i] != input[i])
     1258                        {
     1259                            pos = i;
     1260                            break;
     1261                        }
     1262                    }
     1263
     1264                    if (pos > inputcounter)
     1265                    {
     1266
     1267
     1268                        this.input = input;
     1269                        if (inputtebo == null)
     1270                        {
     1271                            inputtebo = new List<TextBlock>();
     1272                        }
     1273                        int foo = pos + pos / 5 - 1;
     1274                        /*
     1275                        if ((pos) % 5 == 0)
     1276                        {
     1277                            TextBlock t1 = new TextBlock();
     1278                            t1.Text = " ";
     1279                            t1.FontSize = 40;
     1280                            inputPanel.Children.Insert(foo, t1);
     1281
     1282                        }*/
     1283                        TextBlock t = new TextBlock();
     1284                        t.FontFamily = new FontFamily("Courier New");
     1285                        t.Text = input[pos] + "";
     1286                        t.FontSize = 41;
     1287
     1288                        inputPanel.Children.Insert(pos, t);
     1289                        inputtebo.Insert(pos, t);
     1290
     1291                        if (inputtebo.Count == 1)
     1292                        {
     1293                            playClick(null, EventArgs.Empty);
     1294                            Debug.Text = "WHAAAAAAAAATSUUUUUUUUUUUP";
     1295                        }
     1296                    }
     1297                    else
     1298                    {
     1299                        stopclick(null, EventArgs.Empty);
     1300                    }
     1301                }
     1302
     1303
     1304                if (this.input.Length > input.Length)
     1305                {
     1306                    int pos = this.input.Length-1;
     1307                   
     1308                    for (int i = 0; i < input.Length - 1; i++)
     1309                    {
     1310                        if (this.input[i] != input[i])
     1311                        {
     1312                            pos = i;
     1313                            break;
     1314                        }
     1315                    }
     1316
     1317                    if (pos > inputcounter)
     1318                    {
     1319                        this.input = input;
     1320                        if (inputtebo == null)
     1321                        {
     1322                            inputtebo = new List<TextBlock>();
     1323                        }
     1324
     1325                        int foo = pos + pos / 5 - 1;
     1326                        /*
     1327                        if ((foo) % 5 == 0)
     1328                        {
     1329                            inputPanel.Children.RemoveAt(foo);
     1330
     1331                        }
     1332                        */
     1333                        inputPanel.Children.RemoveAt(pos);
     1334                        inputtebo.RemoveAt(pos);
     1335                       
     1336
     1337                        if (inputtebo.Count == 1)
     1338                        {
     1339                            //playClick(null, EventArgs.Empty);
     1340                            Debug.Text = "WHAAAAAAAAATSUUUUUUUUUUUP";
     1341                        }
     1342                    }
     1343                    else
     1344                    {
     1345                        stopclick(null, EventArgs.Empty);
     1346                    }
     1347                }
     1348
     1349               
    11711350            }, null);
    11721351        }
     
    16571836        }
    16581837
    1659        
    1660 
    1661         private void tastedruecken(object sender, KeyEventArgs e)
     1838
     1839
     1840
     1841       
     1842        public void tastedruecken(object sender, KeyEventArgs e)
    16621843        {
    16631844            Key k = e.Key;
    16641845            string s = k.ToString();
    16651846            int x = (int)s[0] - 65;
    1666            
     1847            if(!playbool)
    16671848            tasteClick(bList[x], EventArgs.Empty);
    16681849            Debug.Text = s;
     
    19382119        public void stopclick(object sender, EventArgs e)
    19392120        {
    1940             stop = true;
    1941             inputPanel.Children.Clear();
    1942             outputPanel.Children.Clear();
    1943             inputcounter = 0;
    1944             everythingblack();
    1945             blupp = true;
     2121            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     2122              {
     2123                  mainmainmain.Children.Remove(dummycanvas);
     2124                  rotorarray[0].stop = true;
     2125                  rotorarray[1].stop = true;
     2126                  rotorarray[2].stop = true;
     2127                  walze.stop = true;
     2128                  stop = true;
     2129                  inputPanel.Children.Clear();
     2130                  outputPanel.Children.Clear();
     2131                  inputcounter = 0;
     2132                  everythingblack();
     2133                  blupp = true;
     2134                  input = "";
     2135                  playbool = false;
     2136              }, null);
    19462137        }
    19472138
     
    19942185
    19952186        Boolean playbool = false;
     2187       
     2188
    19962189
    19972190        public void playClick(object sender, EventArgs e)
     
    19992192             Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    20002193            {
    2001             stop = false;
     2194                if(!playbool)
     2195                { dummycanvas = new Canvas();
     2196                dummycanvas.Height = 1250;
     2197                dummycanvas.Width = 2200;
     2198                dummycanvas.Opacity = 1.0;
     2199                dummycanvas.Cursor = Cursors.No;
     2200                dummycanvas.Background = Brushes.Transparent;
     2201
     2202                mainmainmain.Children.Add(dummycanvas);
     2203
     2204               
    20022205            everythingblack();
    20032206            ColorAnimation colorani = new ColorAnimation();
     
    20072210            colorani.From = Colors.Transparent;
    20082211            colorani.To = Colors.Orange;
    2009             colorani.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
     2212            colorani.Duration = new Duration(TimeSpan.FromMilliseconds((0)));
    20102213            inputtebo[0].Background = brush;
    20112214            colorani.Completed += prefadeout;
     
    20152218
    20162219            //inputtebo[0].Opacity = 0.0;
    2017             playbool = true;
     2220            playbool = true;}
    20182221                }, null);
    20192222       
     
    20222225        private void prefadeout(object sender, EventArgs e)
    20232226        {
    2024             int x = Convert.ToInt32(inputtebo[0].Text[0]) - 65;
    2025             tasteClick(bList[x], EventArgs.Empty);
    2026 
    2027             fadeOut.From = 1.0;
    2028             fadeOut.To = 1.0;
    2029             fadeOut.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
    2030 
    2031             inputtebo[0].BeginAnimation(OpacityProperty,fadeOut);
    2032 
     2227            rotorarray[0].stop = false;
     2228            rotorarray[1].stop = false;
     2229            rotorarray[2].stop = false;
     2230            walze.stop = false;
     2231            stop = false;
     2232                int x = Convert.ToInt32(inputtebo[0].Text[0]) - 65;
     2233                letterInput(bList[x], EventArgs.Empty);
     2234
     2235                fadeOut.From = 1.0;
     2236                fadeOut.To = 1.0;
     2237                fadeOut.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
     2238
     2239                inputtebo[0].BeginAnimation(OpacityProperty, fadeOut);
     2240           
    20332241        }
    20342242
    20352243        private void prefadeout1(object sender, EventArgs e)
    20362244        {
    2037             everythingblack();
    2038             DoubleAnimation fadeOut2 = new DoubleAnimation();
    2039             fadeOut2.From = 1.0;
    2040             fadeOut2.To = 1.0;
    2041             fadeOut2.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
    2042             fadeOut2.Completed += prefadeout2;
    2043 
    2044             inputtebo[inputcounter].BeginAnimation(OpacityProperty, fadeOut2);
    2045            
     2245            if (!stop)
     2246            {
     2247                everythingblack();
     2248                DoubleAnimation fadeOut2 = new DoubleAnimation();
     2249                fadeOut2.From = 1.0;
     2250                fadeOut2.To = 1.0;
     2251                fadeOut2.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
     2252                fadeOut2.Completed += prefadeout2;
     2253
     2254                inputtebo[inputcounter].BeginAnimation(OpacityProperty, fadeOut2);
     2255            }
    20462256           
    20472257
     
    20502260        private void prefadeout2(object sender, EventArgs e)
    20512261        {
    2052             int x = Convert.ToInt32(inputtebo[inputcounter].Text[0]) - 65;
    2053             tasteClick(bList[x], EventArgs.Empty);
     2262            if (!stop)
     2263            {
     2264                int x = Convert.ToInt32(inputtebo[inputcounter].Text[0]) - 65;
     2265                letterInput(bList[x], EventArgs.Empty);
     2266            }
    20542267           
    20552268        }
     
    20602273        private void nextPlease(object sender, EventArgs e)
    20612274        {
    2062             Debug.Text = ""+outputchar;
     2275            Debug.Text = "" + outputchar;
    20632276            inputcounter++;
    2064             if (inputtebo.Count > inputcounter)
     2277            if (inputtebo.Count > inputcounter && !stop)
    20652278            {
    20662279               
     
    21092322        private void nextPlease0(object sender, EventArgs e)
    21102323        {
     2324            if (!stop)
     2325            {
     2326                Object[] carrier = new Object[3];
     2327                carrier[0] = output.Substring(0, inputcounter);
     2328                carrier[1] = inputcounter;
     2329                carrier[2] = output.Length;
     2330                fireLetters(carrier, EventArgs.Empty);
     2331               
     2332
    21112333                ColorAnimation colorani = new ColorAnimation();
    21122334                SolidColorBrush brush = new SolidColorBrush();
     
    21162338                colorani.To = Colors.Transparent;
    21172339                colorani.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
    2118                 outputtebo[outputtebo.Count-1].Background = brush;
     2340                outputtebo[outputtebo.Count - 1].Background = brush;
    21192341                colorani.Completed += nextPlease1;
    21202342                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorani);
     2343            }
    21212344       }
    21222345        private void nextPlease1(object sender, EventArgs e)
    21232346        {
    2124             ColorAnimation colorani0 = new ColorAnimation();
    2125             SolidColorBrush brush0 = new SolidColorBrush();
    2126             brush0.Color = Colors.Orange;
    2127 
    2128             colorani0.From = Colors.Orange;
    2129             colorani0.To = Colors.Transparent;
    2130             colorani0.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
    2131            
    2132             brush0.BeginAnimation(SolidColorBrush.ColorProperty, colorani0);
    2133             inputtebo[inputcounter - 1].Background = brush0;
    2134 
    2135             DoubleAnimation fadeOut2 = new DoubleAnimation();
    2136             fadeOut2.From = 1.0;
    2137             fadeOut2.To = 0.5;
    2138             fadeOut2.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
    2139             inputtebo[inputcounter-1].BeginAnimation(OpacityProperty, fadeOut2);
    2140 
    2141             ColorAnimation colorani = new ColorAnimation();
    2142             SolidColorBrush brush = new SolidColorBrush();
    2143             brush.Color = Colors.Transparent;
    2144 
    2145             colorani.From = Colors.Transparent;
    2146             colorani.To = Colors.Orange;
    2147             colorani.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
    2148             inputtebo[inputcounter].Background = brush;
    2149             colorani.Completed += prefadeout1;
    2150             brush.BeginAnimation(SolidColorBrush.ColorProperty, colorani);
     2347            if (!stop)
     2348            {
     2349                ColorAnimation colorani0 = new ColorAnimation();
     2350                SolidColorBrush brush0 = new SolidColorBrush();
     2351                brush0.Color = Colors.Orange;
     2352
     2353                colorani0.From = Colors.Orange;
     2354                colorani0.To = Colors.Transparent;
     2355                colorani0.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
     2356
     2357                brush0.BeginAnimation(SolidColorBrush.ColorProperty, colorani0);
     2358                inputtebo[inputcounter - 1].Background = brush0;
     2359
     2360                DoubleAnimation fadeOut2 = new DoubleAnimation();
     2361                fadeOut2.From = 1.0;
     2362                fadeOut2.To = 0.5;
     2363                fadeOut2.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
     2364                inputtebo[inputcounter - 1].BeginAnimation(OpacityProperty, fadeOut2);
     2365
     2366                ColorAnimation colorani = new ColorAnimation();
     2367                SolidColorBrush brush = new SolidColorBrush();
     2368                brush.Color = Colors.Transparent;
     2369
     2370                colorani.From = Colors.Transparent;
     2371                colorani.To = Colors.Orange;
     2372                colorani.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
     2373                inputtebo[inputcounter].Background = brush;
     2374                colorani.Completed += prefadeout1;
     2375                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorani);
     2376            }
    21512377        }
    21522378        private void deStopClick(object sender, EventArgs e)
     
    21592385        }
    21602386
    2161         private void tasteClick(object sender, EventArgs e)
     2387        private void tasteClick(object sender, EventArgs e)
     2388        {
     2389            if (blupp)
     2390            {
     2391                rotorarray[0].stop = false;
     2392                rotorarray[1].stop = false;
     2393                rotorarray[2].stop = false;
     2394                walze.stop = false;
     2395                stop = false;
     2396                everythingblack();
     2397                playbool = false;
     2398                letterInput(sender, EventArgs.Empty);
     2399            }
     2400        }
     2401
     2402        private void letterInput(object sender, EventArgs e)
    21622403        {
    21632404           
     
    21692410                    {
    21702411
    2171                         //stop = true;
     2412                        stop = false;
    21722413                        blupp = false;
    21732414                        temp = sender as Button;
     
    22852526                }
    22862527            }
    2287             else
    2288             {
    2289                 stopclick(this, EventArgs.Empty);
    2290             }
     2528           
    22912529        }
    22922530   
     
    29233161            {
    29243162                mydouble.Completed -= helptoanimate21;
    2925                 blupp = true;
    29263163                whostoanimate2++;
    29273164                animateLines2();
     
    30133250                }
    30143251
     3252                if (l == batterie.Children[2])
     3253                {
     3254                    blupp = true;
     3255                }
     3256
    30153257                if (l == batterie.Children[2]&&playbool)
    30163258                {
     
    30183260                    mydouble.Completed -= helptoanimate21;
    30193261                    mydouble.Completed += nextPlease;
     3262                   
    30203263                }
    30213264
     
    32053448
    32063449
    3207         /*
    3208         private int DrawLines(int fromboard)
    3209         {
    3210            
    3211             Line l = new Line();
    3212             l.Stroke = Brushes.Green;
    3213             l.X1 = fromboard*30+15 ;
    3214             l.Y1 = -5;
    3215             l.X2 = fromboard * 30 + 15;
    3216             l.Y2 = 30.5;
    3217             maingrid2.Children.Add(l);
    3218 
    3219             drawLines[0] = l;
    3220 
    3221             Line l1 = new Line();
    3222             l1.Stroke = Brushes.Green;
    3223             l1.X1 = fromboard * 30 + 15;
    3224             l1.Y1 = 30.5;
    3225             l1.X2 = -15;
    3226             l1.Y2 = 30.5;
    3227             maingrid2.Children.Add(l1);
    3228 
    3229             drawLines[1] = l1;
    3230 
    3231             Line l2 = new Line();
    3232             l2.Stroke = Brushes.Green;
    3233             l2.X1 = 990;
    3234             l2.Y1 = 811.5;
    3235             l2.X2 = 1100;
    3236             l2.Y2 = 811.5;
    3237             mainmainmain.Children.Add(l2);
    3238 
    3239             drawLines[2] = l2;
    3240 
    3241             Line l3 = new Line();
    3242             l3.Stroke = Brushes.Green;
    3243             l3.X1 = 990 ;
    3244             l3.Y1 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
    3245             l3.X2 = 990;
    3246             l3.Y2 = 811.5;
    3247             mainmainmain.Children.Add(l3);
    3248 
    3249             drawLines[3] = l3;
    3250 
    3251             Line l4 = new Line();
    3252             l4.Stroke = Brushes.Green;
    3253             l4.X1 = 990;
    3254             l4.Y1 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
    3255             l4.X2 = 860;
    3256             l4.Y2 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
    3257             mainmainmain.Children.Add(l4);
    3258 
    3259             drawLines[4] = l4;
    3260 
    3261             rotorarray[2].coloring(Brushes.LawnGreen,fromboard);
    3262 
    3263             Line l5 = new Line();
    3264             l5.Stroke = Brushes.Green;
    3265             l5.X1 = 800;
    3266             l5.Y1 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
    3267             l5.X2 = 710;
    3268             l5.Y2 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
    3269             mainmainmain.Children.Add(l5);
    3270 
    3271             drawLines[5] = l5;
    3272 
    3273             int ein = 0;
    3274 
    3275             Line l6 = new Line();
    3276             l6.Stroke = Brushes.Green;
    3277             l6.X1 = 710;
    3278             l6.Y1 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
    3279             l6.X2 = 710;
    3280             l6.Y2 = 74 + rotorarray[2].maparray[fromboard, 1] * 29.5;
    3281             ein =rotorarray[2].maparray[fromboard, 1];
    3282            
    3283             mainmainmain.Children.Add(l6);
    3284 
    3285             drawLines[6] = l6;
    3286 
    3287             Line l7 = new Line();
    3288             l7.Stroke = Brushes.Green;
    3289             l7.X1 = 710;
    3290             l7.Y1 = 74 + rotorarray[2].maparray[fromboard, 1] * 29.5;
    3291             l7.X2 = 660;
    3292             l7.Y2 = 74 + rotorarray[2].maparray[fromboard, 1] * 29.5;
    3293             mainmainmain.Children.Add(l7);
    3294 
    3295             drawLines[7] = l7;
    3296             rotorarray[1].coloring(Brushes.LawnGreen, rotorarray[2].maparray[fromboard, 1]);
    3297 
    3298             Line l51 = new Line();
    3299             l51.Stroke = Brushes.Green;
    3300             l51.X1 = 600;
    3301             l51.Y1 = 74 + rotorarray[2].maparray[fromboard, 1] * 29.5;
    3302             l51.X2 = 500;
    3303             l51.Y2 = 74 + rotorarray[2].maparray[fromboard, 1] * 29.5;
    3304             mainmainmain.Children.Add(l51);
    3305 
    3306             drawLines[8] = l51;
    3307 
    3308             Line l61 = new Line();
    3309             l61.Stroke = Brushes.Green;
    3310             l61.X1 = 500;
    3311             l61.Y1 = 74 + rotorarray[1].maparray[ein, 0] * 29.5;
    3312             l61.X2 = 500;
    3313             l61.Y2 = 74 + rotorarray[1].maparray[ein, 1] * 29.5;
    3314             Debug.Text = rotorarray[1].maparray[ein, 1] + "";
    3315             mainmainmain.Children.Add(l61);
    3316 
    3317             drawLines[9] = l61;
    3318 
    3319             Line l71 = new Line();
    3320             l71.Stroke = Brushes.Green;
    3321             l71.X1 = 500;
    3322             l71.Y1 = 74 + rotorarray[1].maparray[ein, 1] * 29.5;
    3323             l71.X2 = 460;
    3324             l71.Y2 = 74 + rotorarray[1].maparray[ein, 1] * 29.5;
    3325             mainmainmain.Children.Add(l71);
    3326 
    3327             drawLines[10] = l71;
    3328 
    3329             rotorarray[0].coloring(Brushes.LawnGreen, rotorarray[1].maparray[ein, 1]);
    3330 
    3331             int ein6 = rotorarray[1].maparray[ein, 1];
    3332 
    3333             Line l512 = new Line();
    3334             l512.Stroke = Brushes.Green;
    3335             l512.X1 = 400;
    3336             l512.Y1 = 74 + rotorarray[1].maparray[ein, 1] * 29.5;
    3337             l512.X2 = 310;
    3338             l512.Y2 = 74 + rotorarray[1].maparray[ein, 1] * 29.5;
    3339             mainmainmain.Children.Add(l512);
    3340 
    3341             drawLines[8] = l51;
    3342 
    3343             Line l612 = new Line();
    3344             l612.Stroke = Brushes.Green;
    3345             l612.X1 = 310;
    3346             l612.Y1 = 74 + rotorarray[1].maparray[ein, 1] * 29.5;
    3347             l612.X2 = 310;
    3348             l612.Y2 = 74 + rotorarray[0].maparray[ein6, 1] * 29.5;
    3349             Debug.Text = rotorarray[1].maparray[ein, 1] + "";
    3350             mainmainmain.Children.Add(l612);
    3351 
    3352             drawLines[9] = l61;
    3353 
    3354             Line l712 = new Line();
    3355             l712.Stroke = Brushes.Green;
    3356             l712.X1 = 310;
    3357             l712.Y1 = 74 + rotorarray[0].maparray[ein6, 1] * 29.5;
    3358             l712.X2 = 260;
    3359             l712.Y2 = 74 + rotorarray[0].maparray[ein6, 1] * 29.5;
    3360             mainmainmain.Children.Add(l712);
    3361 
    3362             drawLines[10] = l71;
    3363 
    3364             int ein7 = walze.umkehrlist[rotorarray[0].maparray[ein6, 1]];
    3365 
    3366             Line l513 = new Line();
    3367             l513.Stroke = Brushes.Red;
    3368             l513.X1 = 260;
    3369             l513.Y1 = 74 + rotorarray[0].maparray[ein7, 0] * 29.5;
    3370             l513.X2 = 350;
    3371             l513.Y2 = 74 + rotorarray[0].maparray[ein7, 0] * 29.5;
    3372             mainmainmain.Children.Add(l513);
    3373 
    3374             drawLines[8] = l51;
    3375 
    3376             Line l613 = new Line();
    3377             l613.Stroke = Brushes.Red;
    3378             l613.X1 = 350;
    3379             l613.Y1 = 74 + rotorarray[0].maparray[ein7, 0] * 29.5;
    3380             l613.X2 = 350;
    3381             l613.Y2 = 74 + rotorarray[0].maptoreverse(ein7) * 29.5;
    3382             Debug.Text = rotorarray[1].maparray[ein, 1] + "";
    3383             mainmainmain.Children.Add(l613);
    3384 
    3385             drawLines[9] = l61;
    3386 
    3387             Line l713 = new Line();
    3388             l713.Stroke = Brushes.Red;
    3389             l713.X1 = 350;
    3390             l713.Y1 = 74 + rotorarray[0].maptoreverse(ein7) * 29.5;
    3391             l713.X2 = 400;
    3392             l713.Y2 = 74 + rotorarray[0].maptoreverse(ein7) * 29.5;
    3393             mainmainmain.Children.Add(l713);
    3394 
    3395             drawLines[10] = l71;
    3396 
    3397             int ein2 = rotorarray[0].maptoreverse(ein7);
    3398 
    3399             rotorarray[0].coloring(Brushes.Red, ein2);
    3400 
    3401             Debug.Text = ein2+"test";
    3402 
    3403             Line l52 = new Line();
    3404             l52.Stroke = Brushes.Red;
    3405             l52.X1 = 460;
    3406             l52.Y1 = 74 + rotorarray[0].maparray[ein2, 0] * 29.5;
    3407             l52.X2 = 550;
    3408             l52.Y2 = 74 + rotorarray[0].maparray[ein2, 0] * 29.5;
    3409             mainmainmain.Children.Add(l52);
    3410 
    3411             drawLines[11] = l52;
    3412 
    3413             Line l62 = new Line();
    3414             l62.Stroke = Brushes.Red;
    3415             l62.X1 = 550;
    3416             l62.Y1 = 74 + rotorarray[1].maparray[ein2, 0] * 29.5;
    3417             l62.X2 = 550;
    3418             int ein3=rotorarray[1].maptoreverse(ein2);
    3419            
    3420 
    3421             l62.Y2 = 74 + rotorarray[1].maparray[ein3, 0] * 29.5;
    3422 
    3423             mainmainmain.Children.Add(l62);
    3424             drawLines[12] = l62;
    3425 
    3426 
    3427             Line l72 = new Line();
    3428             l72.Stroke = Brushes.Red;
    3429             l72.X1 = 550;
    3430             l72.Y1 = 74 + rotorarray[1].maparray[ein3, 0] * 29.5;
    3431             l72.X2 = 600;
    3432             l72.Y2 = 74 + rotorarray[1].maparray[ein3, 0] * 29.5;
    3433             mainmainmain.Children.Add(l72);
    3434             drawLines[13] = l72;
    3435 
    3436             rotorarray[1].coloring(Brushes.Red, ein3);
    3437 
    3438             Line l53 = new Line();
    3439             l53.Stroke = Brushes.Red;
    3440             l53.X1 = 660;
    3441             l53.Y1 = 74 + rotorarray[0].maparray[ein3, 0] * 29.5;
    3442             l53.X2 = 740;
    3443             l53.Y2 = 74 + rotorarray[0].maparray[ein3, 0] * 29.5;
    3444             mainmainmain.Children.Add(l53);
    3445             drawLines[14] = l53;
    3446 
    3447             int ein4 = rotorarray[2].maptoreverse(ein3);
    3448 
    3449             Line l63 = new Line();
    3450             l63.Stroke = Brushes.Red;
    3451             l63.X1 = 740;
    3452             l63.Y1 = 74 + rotorarray[0].maparray[ein3, 0] * 29.5;
    3453             l63.X2 = 740;
    3454             l63.Y2 = 74 + rotorarray[1].maparray[ein4, 0] * 29.5;
    3455            
    3456            
    3457 
    3458             mainmainmain.Children.Add(l63);
    3459             drawLines[15] = l63;
    3460 
    3461             Line l73 = new Line();
    3462             l73.Stroke = Brushes.Red;
    3463             l73.X1 = 740;
    3464             l73.Y1 = 74 + rotorarray[1].maparray[ein4, 0] * 29.5;
    3465             l73.X2 = 800;
    3466             l73.Y2 = 74 + rotorarray[1].maparray[ein4, 0] * 29.5;
    3467             mainmainmain.Children.Add(l73);
    3468             drawLines[16] = l73;
    3469 
    3470             int ein5 = rotorarray[2].maptoreverse(ein4);
    3471             rotorarray[2].coloring(Brushes.Red, ein4);
    3472 
    3473 
    3474             Line l41 = new Line();
    3475             l41.Stroke = Brushes.Red;
    3476             l41.X1 = 940;
    3477             l41.Y1 = 74 + rotorarray[2].maparray[ein5, 1] * 29.5;
    3478             l41.X2 = 860;
    3479             l41.Y2 = 74 + rotorarray[2].maparray[ein5, 1] * 29.5;
    3480             mainmainmain.Children.Add(l41);
    3481 
    3482             drawLines[17] = l41;
    3483 
    3484             Line l31 = new Line();
    3485             l31.Stroke = Brushes.Red;
    3486             l31.X1 = 940;
    3487             l31.Y1 = 74 + rotorarray[2].maparray[ein5, 1] * 29.5;
    3488             l31.X2 = 940;
    3489             l31.Y2 = 821.5;
    3490             mainmainmain.Children.Add(l31);
    3491 
    3492             drawLines[18] = l31;
    3493 
    3494             Line l21 = new Line();
    3495             l21.Stroke = Brushes.Red;
    3496             l21.X1 = 940;
    3497             l21.Y1 = 821.5;
    3498             l21.X2 = 1100;
    3499             l21.Y2 = 821.5;
    3500             mainmainmain.Children.Add(l21);
    3501 
    3502             drawLines[19] = l21;
    3503 
    3504             Line l11 = new Line();
    3505             l11.Stroke = Brushes.Red;
    3506             l11.X1 = rotorarray[2].maparray[ein5, 1] * 30 + 15;
    3507             l11.Y1 = 40.5;
    3508             l11.X2 = -15;
    3509             l11.Y2 = 40.5;
    3510             maingrid2.Children.Add(l11);
    3511 
    3512             drawLines[20] = l11;
    3513 
    3514             Line ln1 = new Line();
    3515             ln1.Stroke = Brushes.Red;
    3516             ln1.X1 = rotorarray[2].maparray[ein5, 1] * 30 + 15;
    3517             ln1.Y1 = -5;
    3518             ln1.X2 = rotorarray[2].maparray[ein5, 1] * 30 + 15;
    3519             ln1.Y2 = 40.5;
    3520             maingrid2.Children.Add(ln1);
    3521 
    3522             drawLines[21] = ln1;
    3523 
    3524             return rotorarray[2].maparray[ein5, 1];
    3525         }
    3526         */
     3450 
    35273451
    35283452        private void List_MouseLeftButtonDown(object sender, EventArgs e)
     
    35573481                merken =-1;
    35583482            }
    3559         }
    3560 
    3561        
    3562 
     3483
     3484            syncPluboardSettings();
     3485        }
     3486
     3487
     3488        Boolean justme = true;
    35633489        private void List_MouseMove(object sender, MouseEventArgs e)
    35643490        {
     3491           
    35653492            // Get the current mouse position
    35663493            Point mousePos = e.GetPosition(null);
     
    42014128                else
    42024129                    b = true;
    4203            
     4130
     4131                syncPluboardSettings();
    42044132
    42054133        }
     
    43684296
    43694297            int urint = Int32.Parse(uID);
    4370             Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, 0, 0);
     4298            Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, settings.Key[1]-65, settings.Ring2);
    43714299            Canvas.SetLeft(rotor2, 230);
    43724300            rotorarea.Children.Add(rotor2);
     
    43904318     
    43914319            int urint = Int32.Parse(uID);
    4392             Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, 0, 0);
     4320            Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, settings.Key[2] - 65, settings.Ring3);
    43934321            Canvas.SetLeft(rotor2, 460);
    43944322            rotorarea.Children.Add(rotor2);
     
    44344362
    44354363            int urint = Int32.Parse(uID);
    4436             Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, 0, 0);
     4364            Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, settings.Key[0] - 65, settings.Ring1);
    44374365            Canvas.SetLeft(rotor2, 0);
    44384366            rotorarea.Children.Add(rotor2);
     
    44854413        private void switchbuttons(int button1, int button2)
    44864414        {
     4415         
    44874416           
    44884417            Button dummy = new Button();
    44894418            double dummyl ;
     4419
     4420
     4421           
     4422           
     4423
    44904424
    44914425           // Debug.Text += lList[button1].X1 + "" + lList[button2].X1;
     
    45664500
    45674501            //bList[button2].Content = "test";
    4568            
    4569             }
     4502           
     4503            }
     4504
     4505        private void syncPluboardSettings()
     4506        {
     4507            justme = false;
     4508            for (int i = 0; i < switchlist.Length; i++)
     4509            {
     4510                switch (i)
     4511                {
     4512                    case 0: settings.PlugBoardA = switchlist[i]; break;
     4513                    case 1: settings.PlugBoardB = switchlist[i]; break;
     4514                    case 2: settings.PlugBoardC = switchlist[i]; break;
     4515                    case 3: settings.PlugBoardD = switchlist[i]; break;
     4516                    case 4: settings.PlugBoardE = switchlist[i]; break;
     4517                    case 5: settings.PlugBoardF = switchlist[i]; break;
     4518                    case 6: settings.PlugBoardG = switchlist[i]; break;
     4519                    case 7: settings.PlugBoardH = switchlist[i]; break;
     4520                    case 8: settings.PlugBoardI = switchlist[i]; break;
     4521                    case 9: settings.PlugBoardJ = switchlist[i]; break;
     4522                    case 10: settings.PlugBoardK = switchlist[i]; break;
     4523                    case 11: settings.PlugBoardL = switchlist[i]; break;
     4524                    case 12: settings.PlugBoardM = switchlist[i]; break;
     4525                    case 13: settings.PlugBoardN = switchlist[i]; break;
     4526                    case 14: settings.PlugBoardO = switchlist[i]; break;
     4527                    case 15: settings.PlugBoardP = switchlist[i]; break;
     4528                    case 16: settings.PlugBoardQ = switchlist[i]; break;
     4529                    case 17: settings.PlugBoardR = switchlist[i]; break;
     4530                    case 18: settings.PlugBoardS = switchlist[i]; break;
     4531                    case 19: settings.PlugBoardT = switchlist[i]; break;
     4532                    case 20: settings.PlugBoardU = switchlist[i]; break;
     4533                    case 21: settings.PlugBoardV = switchlist[i]; break;
     4534                    case 22: settings.PlugBoardW = switchlist[i]; break;
     4535                    case 23: settings.PlugBoardX = switchlist[i]; break;
     4536                    case 24: settings.PlugBoardY = switchlist[i]; break;
     4537                    case 25: settings.PlugBoardZ = switchlist[i]; break;
     4538                }
     4539            }
     4540            justme = true;
     4541        }
     4542
     4543        private void changeSettings(object sender, EventArgs e)
     4544        {
     4545            justme = false;
     4546            Button dummy= sender as Button;
     4547
     4548            if (dummy == rotorarray[0].up || dummy == rotorarray[1].up || dummy == rotorarray[2].up)
     4549                {
     4550                    settings.Key = rotorarray[0].custom.Text + rotorarray[1].custom.Text  +rotorarray[2].custom.Text ;
     4551                }
     4552
     4553            if (dummy == rotorarray[0].down || dummy == rotorarray[1].down || dummy == rotorarray[2].down)
     4554            {
     4555                settings.Key = rotorarray[0].custom.Text + rotorarray[1].custom.Text + rotorarray[2].custom.Text;
     4556            }
     4557            if (dummy == rotorarray[1].up1)
     4558                {
     4559                    settings.Ring2 = Int32.Parse( rotorarray[1].custom2.Text);
     4560                   
     4561                }
     4562            /*
     4563            if (dummy == rotorarray[0].down || dummy == rotorarray[1].down || dummy == rotorarray[2].down)
     4564            {
     4565                settings.Key = rotorarray[0].custom.Text[0] + "" + rotorarray[1].custom.Text[0] + rotorarray[2].custom.Text[0];
     4566            }
     4567              */ 
     4568           
     4569            justme = true;
     4570        }
    45704571
    45714572        private void List_DragEnter(object sender, DragEventArgs e)
     
    46134614                if (aktuell != -1)
    46144615                {
    4615                     lList[aktuell].X2 = args.GetPosition(DragScope).X * 2200 / this.ActualWidth - 1700  /* - _startPoint.X */ ;
    4616                     lList[aktuell].Y2 = args.GetPosition(DragScope).Y * 1250 / this.ActualHeight - 380*1250 / this.ActualHeight /* - _startPoint.Y */ ;
     4616
     4617
     4618
     4619                    lList[aktuell].X2 = args.GetPosition(mainmain).X * 800 / this.mainmain.ActualWidth;
     4620
     4621                    lList[aktuell].Y2 = args.GetPosition(mainmain).Y * 1000 / this.mainmain.ActualHeight - 520; /* 1250 / this.ActualHeight - 380 * 1250 / this.ActualHeight */ ;
    46174622                }
    46184623                _adorner.LeftOffset = args.GetPosition(DragScope).X /* - _startPoint.X */ ;
  • trunk/CrypPlugins/Enigma/EnigmaSettings.cs

    r2636 r2801  
    114114                int currentIndex = alphabet.IndexOf(currentChar);
    115115
    116                 if (this.involutoricPlugBoard)
    117                 {
    118                     this.plugBoard[newIndex] = currentChar;
    119                     OnPropertyChanged("PlugBoard" + alphabet[newIndex]);
    120 
    121                     if (newChar == this.alphabet[letterPos])
     116               
     117                //if (this.involutoricPlugBoard)
     118                //{
     119                this.plugBoard[newIndex] = currentChar;
     120                OnPropertyChanged("PlugBoard" + alphabet[newIndex]);
     121
     122               
     123
     124
     125                if (newChar == this.alphabet[letterPos])
    122126                    {
    123127                        // we removed a plug
    124128                        this.plugBoard[currentIndex] = this.alphabet[currentIndex];
    125                         OnPropertyChanged("PlugBoard" + alphabet[currentIndex]);
     129                        OnPropertyChanged("PlugBoard" + alphabet[currentIndex] );
    126130                    }
    127131
    128                 }
    129 
     132
     133
     134                //}
     135               
    130136                this.plugBoard[letterPos] = newChar;
    131137                OnPropertyChanged("PlugBoard" + alphabet[letterPos]);
     138
     139               
     140
     141
     142
    132143                OnPropertyChanged("PlugBoardDisplay");
    133144            }
  • trunk/CrypPlugins/Enigma/Rotor2.cs

    r2701 r2801  
    2828        List<TextBlock> tebo2 = new List<TextBlock>();
    2929        Line[] lines = new Line[26];
    30         TextBlock custom = new TextBlock();
    31         TextBlock custom2 = new TextBlock();
     30        public TextBlock custom = new TextBlock();
     31        public TextBlock custom2 = new TextBlock();
    3232        Canvas lineCanvas = new Canvas();
    3333        Line lineToAnimat = new Line();
     
    3737        TextBlock[] textBlockToAnimat2 = new TextBlock[2];
    3838
     39        StackPanel stack = new StackPanel();
     40        StackPanel stack1 = new StackPanel();
     41        StackPanel stack2 = new StackPanel();
     42
     43        public Button up;
     44        public Button up1;
     45
     46        public Button down;
     47        public Button down1;
     48
    3949        public TextBlock iAm = new TextBlock();
    4050
    4151        public Boolean anomalie = false;
    4252
     53        private Canvas content;
     54
    4355        public double fast = 400;
     56
     57        public Boolean stop = false;
    4458
    4559        public Boolean next = false;
     
    6175        int[] fuenf = new int[] { 21, 25, 1, 17, 6, 8, 19, 24, 20, 15, 18, 3, 13, 7, 11, 23, 0, 22, 12, 9, 16, 14, 5, 4, 2, 10 };
    6276
    63         public void changeoffset(int offset)
    64         {
    65 
    66         }
    67 
    68 
     77        public void changeoffset(int offset,int ringoffset)
     78        {
     79            tebo = new List<TextBlock>();
     80            tebo2 = new List<TextBlock>();
     81            lines = new Line[26];
     82            custom = new TextBlock();
     83            custom2 = new TextBlock();
     84            lineCanvas = new Canvas();
     85            lineToAnimat = new Line();
     86            lineToAnimat2 = new Line();
     87            lineTrash = new List<Line>();
     88            stack = new StackPanel();
     89            stack1 = new StackPanel();
     90            stack2 = new StackPanel();
     91            iAm = new TextBlock();
     92
     93
     94            this.Children.Remove(content);
     95            this.content = alpha(offset, ringoffset - 1);
     96            this.Children.Add(content);
     97
     98        }
     99
     100       
    69101
    70102        public int returnMap()
     
    82114            this.width = width;
    83115            this.height = height;
    84             this.map = map+1;
    85 
    86 
    87             this.Children.Add(alpha(offset,ringoffset-1));
     116            this.map = map;
     117
     118            this.content = alpha(offset, ringoffset - 1);
     119            this.Children.Add(content);
    88120        }
    89121
     
    142174        public void startAnimation()
    143175        {
    144 
     176            if (!stop)
    145177            animateThisTebo(textBlockToAnimat[0], true);
    146178
     
    149181        public void startAnimationReverse()
    150182        {
    151 
     183            if(!stop)
    152184            animateThisTebo2(textBlockToAnimat2[1], true);
    153 
    154 
    155185        }
    156186
    157187        private void helpNextAnimationMethod13(object sender, EventArgs e)
    158188        {
     189            if (!stop)
    159190            animateThisLine2(lineToAnimat2);
    160191        }
     
    162193        private void helpNextAnimationMethod14(object sender, EventArgs e)
    163194        {
     195            if (!stop)
    164196            helpNextAnimation2(this, EventArgs.Empty);
    165197        }
     
    167199        private void helpNextAnimationMethod1(object sender, EventArgs e)
    168200        {
     201            if (!stop)
    169202            animateThisLine(lineToAnimat);
    170203        }
     
    172205        private void helpNextAnimationMethod12(object sender, EventArgs e)
    173206        {
     207            if (!stop)
    174208            helpNextAnimation(this, EventArgs.Empty);
    175209        }
     
    177211        private void helpNextAnimationMethod2(object sender, EventArgs e)
    178212        {
     213            if (!stop)
    179214            animateThisTebo2(textBlockToAnimat2[0], false);
    180 
    181 
    182215        }
    183216
    184217        private void helpNextAnimationMethod(object sender, EventArgs e)
    185218        {
     219            if (!stop)
    186220            animateThisTebo(textBlockToAnimat[1], false);
    187 
    188221        }
    189222
    190223        public event EventHandler helpNextAnimation;
    191224        public event EventHandler helpNextAnimation2;
     225
     226        public event EventHandler updone;
     227        public event EventHandler downdone;
     228        public event EventHandler up1done;
     229        public event EventHandler down1done;
    192230
    193231
     
    429467
    430468            derotate();
     469            downdone(down, EventArgs.Empty);
    431470            b = true;
    432471        }
     
    577616                }
    578617            }
     618            down1done(down1, EventArgs.Empty);
    579619            b = true;
    580620        }
     
    769809
    770810            rotate();
    771 
     811            EventArgs test = new EventArgs();
     812           
     813            updone(up, EventArgs.Empty);
    772814            b = true;
    773815
     
    863905
    864906                lineCanvas.BeginAnimation(Canvas.TopProperty, mydouble1);
     907
     908               
    865909            }
    866910        }
     
    9911035                }
    9921036            }
     1037            up1done(up1, EventArgs.Empty);
    9931038            b = true;
    9941039        }
     
    10621107
    10631108            }
     1109           
    10641110        }
    10651111
     
    11581204
    11591205
    1160         StackPanel stack = new StackPanel();
    1161         StackPanel stack1 = new StackPanel();
    1162         StackPanel stack2 = new StackPanel();
    1163 
    11641206
    11651207        private Canvas alpha(int offset, int ringoffset)
     
    12271269                t.Background = Brushes.Gainsboro;
    12281270                t.TextAlignment = TextAlignment.Center;
    1229                 if (i % 2 == 0)
     1271                if ((i+offset) % 2 == 0)
    12301272                    t.Background = Brushes.Silver;
    12311273                if (i == 0)
     
    12511293                t2.Background = Brushes.Gainsboro;
    12521294                t2.TextAlignment = TextAlignment.Center;
    1253                 if (i % 2 == 0)
     1295                if (inew % 2 == 0)
    12541296                    t2.Background = Brushes.Silver;
    12551297
     
    13531395                t.Background = Brushes.Gainsboro;
    13541396                t.TextAlignment = TextAlignment.Center;
    1355                 if (i % 2 == 0)
     1397                if ((i+offset) % 2 == 0)
    13561398                    t.Background = Brushes.Silver;
    13571399                if (i == 0)
     
    13771419                t2.Background = Brushes.Gainsboro;
    13781420                t2.TextAlignment = TextAlignment.Center;
    1379                 if (i % 2 == 0)
     1421                if (inew % 2 == 0)
    13801422                    t2.Background = Brushes.Silver;
    13811423
     
    14581500            temp.Children.Add(stack);
    14591501
    1460             Button up = new Button();
     1502            up = new Button();
    14611503            up.Click += upperclick;
    14621504            up.Height = 50;
     
    14661508            Canvas.SetTop(up, 5);
    14671509
    1468             Button down = new Button();
     1510            down = new Button();
    14691511            down.Click += downerclick;
    14701512            down.Height = 50;
     
    15431585            temp.Children.Add(down);
    15441586
    1545             Button up1 = new Button();
     1587            up1 = new Button();
    15461588            up1.Click += upperclick1;
    15471589            up1.Height = 50;
     
    15511593            Canvas.SetTop(up1, 830);
    15521594
    1553             Button down1 = new Button();
     1595            down1 = new Button();
    15541596            down1.Click += downerclick1;
    15551597            down1.Height = 50;
Note: See TracChangeset for help on using the changeset viewer.