source: trunk/CrypPlugins/Enigma/EnigmaPresentation.xaml.cs @ 2801

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

EnigmaPresentation - EnigmaSettings synchronisation, EnigmaPresentation input management updated

File size: 169.3 KB
Line 
1/*using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.Windows;
6using System.Windows.Controls;
7using System.Windows.Data;
8using System.Windows.Documents;
9using System.Windows.Input;
10using System.Windows.Media;
11using System.Windows.Media.Imaging;
12using System.Windows.Navigation;
13using System.Windows.Shapes;
14
15namespace Cryptool.Enigma
16{
17    /// <summary>
18    /// Interaction logic for UserControl1.xaml
19    /// </summary>
20    public partial class EnigmaPresentation : UserControl
21    {
22        public EnigmaPresentation()
23        {
24            InitializeComponent();
25        }
26    }
27}*/
28using System;
29using System.Collections.Generic;
30using System.Linq;
31using System.Text;
32using System.Windows;
33using System.Windows.Controls;
34using System.Windows.Data;
35using System.Windows.Documents;
36using System.Windows.Input;
37using System.Windows.Media;
38using System.Windows.Media.Imaging;
39using System.Windows.Navigation;
40using System.Windows.Shapes;
41using System.Windows.Media.Animation;
42using System.Threading;
43using System.Windows.Threading;
44using System.ComponentModel;
45
46
47
48namespace Cryptool.Enigma
49{
50    /// <summary>
51    /// Interaction logic for MainWindow.xaml
52    /// </summary>
53    public partial class  EnigmaPresentation : UserControl
54    {
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;
64        Button[] bList = new Button[26];
65        Button[] tList = new Button[26];
66        TextBlock[] inputList = new TextBlock[26];
67        TextBlock[] outputList = new TextBlock[26];
68        int[] switchlist = new int[26];
69        int[] umkehrlist = {4,9,12,25,0,11,24,23,21,1,22,5,2,17,16,20,14,13,19,18,15,8,10,7,6,3};
70
71        int aktuell = -1;
72
73        Rectangle[] leuchtenList = new Rectangle[26];
74       
75        Canvas dummycanvas;
76
77        Line[,] umlList = new Line[26,3];
78        List<Line[]> schalterlist = new List<Line[]>();
79        List<Line[]> schalterlist2 = new List<Line[]>();
80
81        Rectangle[] dummyrec = new Rectangle[4];
82
83        Boolean stop = false;
84
85        Boolean off = false;
86
87        Boolean mfouron = false;
88
89        double speed = 0.5;
90
91        Line[,] frombat = new Line[9,3];
92        Line[,] frombat2 = new Line[3,2];
93
94        Line[,] toBat = new Line[26, 6];
95        Line[,] tobat1 = new Line[9, 3];
96        Line[,] tobat2 = new Line[3, 2];
97       
98        Canvas rotorlocks1 ;
99        Canvas rotorlocks2;
100        Canvas rotorlocks3;
101        Canvas rotorlocks4;
102
103        List<TextBlock> inputtebo;
104        List<TextBlock> outputtebo = new List<TextBlock>();
105        TextBlock[] textBlocksToAnimate = new TextBlock[6];
106
107        Line[] drawLines = new Line[22];
108
109        Rotor2[] rotorarray = new Rotor2[4];
110        private Walze walze;
111        Image[] rotorimgs = new Image[5];
112        Image[] walzeimgs = new Image[3];
113
114
115        Point startPoint;
116        Line[] lList = new Line[26];
117
118        List<Canvas> schalterlist3 = new List<Canvas>();
119        List<Canvas> leuchtenlist3 = new List<Canvas>();
120
121        List<UIElement> linesToAnimate = new List<UIElement>();
122        List<UIElement> linesToAnimate2 = new List<UIElement>();
123        List<Line> linesToThrowAway = new List<Line>();
124        DoubleAnimation fadeIn = new DoubleAnimation();
125        DoubleAnimation fadeOut = new DoubleAnimation();
126        DoubleAnimation nop = new DoubleAnimation();
127        AutoResetEvent ars = new AutoResetEvent(false);
128       
129        private void sizeChanged(Object sender, EventArgs eventArgs)
130        {
131            this.mainmainmain.RenderTransform = new ScaleTransform(this.ActualWidth / this.mainmainmain.ActualWidth,
132                                                            this.ActualHeight / this.mainmainmain.ActualHeight);
133           
134               
135        }
136
137        private void sliderValueChanged(object sender, EventArgs args) 
138        {
139            speed = slider1.Value;
140            if(rotorarray[0]!=null)
141            rotorarray[0].fast = slider1.Value * 80;
142            if (rotorarray[1] != null)
143            rotorarray[1].fast = slider1.Value * 80;
144            if (rotorarray[2] != null)
145            rotorarray[2].fast = slider1.Value * 80;
146            if (walze != null)
147            walze.fast = slider1.Value * 80;
148        }
149
150        Boolean justonce = true;
151
152        public void settings_OnPropertyChange(object sender, PropertyChangedEventArgs e)
153        {
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")
318                {
319                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
320                    {
321                        this.walze.helpNextAnimation -= helptoanimate5;
322
323                        dropBoxCanvasWalze.Children.Remove(walzeimgs[settings.Reflector]);
324
325                        Image img = new Image();
326                        img.Height = 100;
327                        img.Width = 50;
328                        BitmapImage bi = new BitmapImage();
329                        bi.BeginInit();
330                        bi.UriSource = new Uri("Images/rotor" + walze.typ + ".jpg", UriKind.Relative);
331                        bi.EndInit();
332                        img.Source = bi;
333
334
335                        Canvas.SetLeft(img, 50 * walze.typ);
336
337                        dropBoxCanvasWalze.Children.Add(img);
338                        img.Uid = "" + walze.typ;
339                        img.Cursor = Cursors.Hand;
340
341                        img.PreviewMouseMove += Walze_MouseMove1;
342                        walzeimgs[walze.typ - 1] = img;
343                        walzenarea.Children.Remove(walze);
344
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);
564                        walze1.fast = speed * 80;
565                        Canvas.SetLeft(walze1, 0);
566                        Canvas.SetTop(walze1, 60);
567                        walzenarea.Children.Add(walze1);
568                        walze1.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
569                        walze1.PreviewMouseMove += new MouseEventHandler(Walze_MouseMove);
570                        this.walze = walze1;
571                        walze.helpNextAnimation += helptoanimate5;
572                       
573
574                    }, null);
575                }
576
577                if (settings.Rotor1 + 1 != rotorarray[2].map)
578                {
579                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
580                    {
581                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor1]);
582
583                        Image img = new Image();
584                        img.Height = 100;
585                        img.Width = 50;
586                        BitmapImage bi = new BitmapImage();
587                        bi.BeginInit();
588                        bi.UriSource = new Uri("Images/rotor" + rotorarray[2].map + ".jpg", UriKind.Relative);
589                        bi.EndInit();
590                        img.Source = bi;
591
592
593                        Canvas.SetLeft(img, 50 * rotorarray[2].map);
594
595                        dropBoxCanvas.Children.Add(img);
596                        img.Uid = "" + rotorarray[2].map;
597                        img.Cursor = Cursors.Hand;
598
599                        img.PreviewMouseMove += Rotor_MouseMove1;
600                        rotorimgs[rotorarray[2].map - 1] = img;
601
602                        rotorarray[2].helpNextAnimation -= helptoanimate2;
603                        rotorarray[2].helpNextAnimation2 -= helptoanimate8;
604                        rotorarea.Children.Remove(rotorarray[2]);
605
606                        Rotor2 rotor = new Rotor2(settings.Rotor1 + 1, this.Width, this.Height);
607                        rotor.fast = speed * 80;
608                        rotor.Cursor = Cursors.Hand;
609                        rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
610                        Canvas.SetLeft(rotor, 460);
611                        rotorarea.Children.Add(rotor);
612                        rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
613
614                        rotorarray[2] = rotor;
615                        rotorarray[2].helpNextAnimation += helptoanimate2;
616                        rotorarray[2].helpNextAnimation2 += helptoanimate8;
617
618                       
619                       
620                    }, null);
621                }
622
623                if (settings.Rotor2 + 1 != rotorarray[1].map)
624                {
625                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
626                    {
627
628                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor2]);
629                        Image img = new Image();
630                        img.Height = 100;
631                        img.Width = 50;
632                        BitmapImage bi = new BitmapImage();
633                        bi.BeginInit();
634                        bi.UriSource = new Uri("Images/rotor" + rotorarray[1].map + ".jpg", UriKind.Relative);
635                        bi.EndInit();
636                        img.Source = bi;
637                        dropBoxCanvas.Children.Add(img);
638                        Canvas.SetLeft(img, 50 * rotorarray[1].map);
639                        img.Uid = "" + rotorarray[1].map;
640                        img.Cursor = Cursors.Hand;
641
642                        img.PreviewMouseMove += Rotor_MouseMove1;
643
644                        rotorimgs[rotorarray[1].map - 1] = img;
645
646                        rotorarray[1].helpNextAnimation -= helptoanimate2;
647                        rotorarray[1].helpNextAnimation2 -= helptoanimate8;
648                       
649                        rotorarea.Children.Remove(rotorarray[1]);
650
651                        Rotor2 rotor = new Rotor2(settings.Rotor2 + 1, this.Width, this.Height);
652                        rotor.fast = speed * 80;
653                        rotor.Cursor = Cursors.Hand;
654                        rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
655                        Canvas.SetLeft(rotor, 230);
656                        rotorarea.Children.Add(rotor);
657                        rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
658
659                        rotorarray[1] = rotor;
660                        rotorarray[1].helpNextAnimation += helptoanimate3;
661                        rotorarray[1].helpNextAnimation2 += helptoanimate7;
662                       
663                    }, null);
664                }
665
666                if (settings.Rotor3 + 1 != rotorarray[0].map)
667                {
668                    Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
669                    {
670
671                        dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor3]);
672
673                        Image img = new Image();
674                        img.Height = 100;
675                        img.Width = 50;
676                        BitmapImage bi = new BitmapImage();
677                        bi.BeginInit();
678                        bi.UriSource = new Uri("Images/rotor" + rotorarray[0].map + ".jpg", UriKind.Relative);
679                        bi.EndInit();
680                        img.Source = bi;
681                        dropBoxCanvas.Children.Add(img);
682                        Canvas.SetLeft(img, 50 * rotorarray[0].map);
683                        img.Uid = "" + rotorarray[0].map;
684                        img.Cursor = Cursors.Hand;
685
686                        img.PreviewMouseMove += Rotor_MouseMove1;
687
688                        rotorimgs[rotorarray[0].map - 1] = img;
689
690                        rotorarray[0].helpNextAnimation -= helptoanimate2;
691                        rotorarray[0].helpNextAnimation2 -= helptoanimate8;
692                       
693                        rotorarea.Children.Remove(rotorarray[0]);
694
695                        Rotor2 rotor = new Rotor2(settings.Rotor3 + 1, this.Width, this.Height);
696                        rotor.fast = speed * 80;
697                        rotor.Cursor = Cursors.Hand;
698                        rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
699                        Canvas.SetLeft(rotor, 0);
700                        rotorarea.Children.Add(rotor);
701                        rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
702
703                        rotorarray[0] = rotor;
704                        rotorarray[0].helpNextAnimation += helptoanimate4;
705                        rotorarray[0].helpNextAnimation2 += helptoanimate6;
706                    }, null);
707                }
708                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
709                {
710                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor3]);
711                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor2]);
712                    dropBoxCanvas.Children.Remove(rotorimgs[settings.Rotor1]);
713                }, null);
714                justonce = true;
715            }
716        }
717        */
718
719
720        public EnigmaPresentation(Enigma facade)
721        {
722           
723
724            pluginFacade = facade;
725            settings = (EnigmaSettings)pluginFacade.Settings;
726            //settings.PropertyChanged += changeSettings;
727
728            InitializeComponent();
729            SizeChanged += sizeChanged;
730
731           
732
733            //mainWindow.WindowStyle = WindowStyle.None;
734            slider1.ValueChanged += this.sliderValueChanged;
735
736            slider1.Minimum = 0.5;
737            slider1.Maximum = 6;
738
739            Stop.Click += stopclick;
740            destop.Click += deStopClick;
741            m4on.Click += m4onClick;
742            play.Click += playClick;
743            //mainmain.PreviewMouseLeftButtonDown += new MouseButtonEventHandler(DragSource_PreviewMouseLeftButtonDown);
744            //mainmain.PreviewMouseMove += new MouseEventHandler(DragSource_PreviewMouseMove);
745
746
747
748            int x = 30;
749            int y = 50;
750
751            int modx = 0;
752            int mody = 0;
753            int modz = 0;
754
755           
756
757            for (int i = 0; i < 26; i++)
758            {
759               
760                switchlist[i] = i;
761                Button b = new Button();
762                b.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
763                b.Click += List_MouseLeftButtonDown;
764                b.Background = Brushes.LightBlue;
765                b.Height = y;
766                b.Width = x;
767                b.PreviewMouseMove +=new MouseEventHandler(List_MouseMove);
768                b.Drop += List_Drop;
769                //b.DragEnter+=List_DragEnter;
770                //b.AllowDrop=true;
771                b.Uid = ""+i;
772                b.Content = Convert.ToChar(i+80)+"" ;
773                b.Content = i;
774                b.Cursor = Cursors.Hand;
775                b.Opacity = 1;
776
777
778                //b.Style.Resources.Source =
779
780                //Style mystyle = new Style();
781                //mystyle.Resources.Source = StaticResource GlassButton;
782                //b.BorderThickness = new Thickness(10.0);
783                steckerbrett.Children.Add(b);
784                bList[i] = b;
785
786                Line l = new Line();
787                l.Name = "l" + i;
788                l.X1 = x/2+i*x;
789                l.Y1 = 0;
790                l.X2 = x/2+i*x;
791                l.Y2 = 200;
792               
793                SolidColorBrush redBrush = new SolidColorBrush();
794
795                redBrush.Color = Colors.Black;
796
797             
798                redBrush.Color = Colors.Black;
799
800                TextBlock t = new TextBlock();
801                t.Text =  ""+Convert.ToChar(i + 65) ;
802                t.Height = x;
803                t.Width = x;
804                t.Background = Brushes.SkyBlue;
805                t.TextAlignment = TextAlignment.Center;
806                if(i%2 == 0)
807                    t.Background = Brushes.LightSeaGreen;
808                alpha.Children.Add(t);
809                TextBlock t1 = new TextBlock();
810                t1.Text = Convert.ToChar(i + 65) + "";
811                t1.Height = x;
812                t1.Width = x;
813                t.FontSize= 20;
814                t1.FontSize = 20;
815                t1.Background = Brushes.SkyBlue;
816                t1.TextAlignment = TextAlignment.Center;
817                if (i % 2 == 0)
818                    t1.Background = Brushes.LightSeaGreen;
819               
820                alpha2.Children.Add(t1);
821                inputList[i] = t;
822                outputList[i] = t1;
823                //alpha2.Children.Add(t1);
824                // Set Line's width and color
825
826                l.StrokeThickness = 1;
827
828                l.Stroke = redBrush;
829
830                Line l2 = new Line();
831                l2.X1 = x / 2 + i * x;
832                l2.Y1 = 0;
833                l2.X2 = x / 2 + i * x;
834                l2.Y2 = 20 + umkehrlist[i] * 10;
835
836                l2.StrokeThickness = 1;
837
838                //l2.Stroke = redBrush;
839               
840                umlList[i, 0] = l2;
841                if(umkehrlist[i]<i)
842                maingrid2.Children.Add(l2);
843
844                Line l3 = new Line();
845                l3.X1 = x / 2 + umkehrlist[i] * x;
846                l3.Y1 = 20 + umkehrlist[i] * 10;
847                l3.X2 = x / 2 + i * x;
848                l3.Y2 = 20 + umkehrlist[i] * 10;
849
850                l3.StrokeThickness = 1;
851
852               // l3.Stroke = redBrush;
853
854                umlList[i, 1] = l3;
855                if(umkehrlist[i]<i)
856                maingrid2.Children.Add(l3);
857
858                lList[i] = l;
859                maingrid.Children.Add(l);
860               
861                NameScope.GetNameScope(this).RegisterName("l"+i, l);
862
863
864                Line l4 = new Line();
865                l4.X1 = x / 2 + umkehrlist[i] * x;
866                l4.Y1 = 0;
867                l4.X2 = x / 2 + umkehrlist[i] * x;
868                l4.Y2 = 20+umkehrlist[i] * 10;
869
870                l4.StrokeThickness = 1;
871
872               // l4.Stroke = redBrush;
873
874                umlList[i, 2] = l4;
875                if (umkehrlist[i]<i)
876                maingrid2.Children.Add(l4);
877
878                Button taste = new Button();
879                taste.Height = 39;
880                taste.Width = 39;
881                taste.Uid = i+"";
882                taste.Content = ""+Convert.ToChar(i + 65);
883                taste.Click += tasteClick;
884                taste.FontSize=25;
885                Canvas.SetLeft(taste,50*i);
886
887               
888
889                //Canvas hschalter = schalter();
890
891                if (i %3==0)
892                {
893                    Canvas hschalter = schalter(0,i);
894                    Canvas hleuchte = leuchte(0,i);
895
896                    Canvas.SetLeft(taste, 90 * modx-5);
897                    Canvas.SetLeft(hschalter, 90 * modx -10);
898                    Canvas.SetTop(hschalter, 0);
899                    Canvas.SetLeft(hleuchte, 90 * modx - 5);
900
901                    tastaturrow0.Children.Add(taste);
902                    schalterrow0.Children.Add(hschalter);
903                    schalterlist3.Add(hschalter);
904                    leuchtenlist3.Add(hleuchte);
905
906                    leuchten.Children.Add(hleuchte);
907                    modx++;
908                }
909
910                if (i %3==1)
911                {
912                    Canvas hschalter = schalter(1,i);
913                    Canvas hleuchte = leuchte(1, i);
914
915                    Canvas.SetLeft(taste, 90 * mody  + 25);
916                    Canvas.SetLeft(hschalter, 90 * mody+20);
917                    Canvas.SetLeft(hleuchte, 90 * mody + 25);
918
919                    Canvas.SetTop(hschalter, 0);
920                    Canvas.SetTop(hleuchte, 58);
921
922                    tastaturrow1.Children.Add(taste);
923                    schalterrow1.Children.Add(hschalter);
924                    schalterlist3.Add(hschalter);
925                    leuchtenlist3.Add(hleuchte);
926                    leuchten.Children.Add(hleuchte);
927
928                    mody++;
929                   
930                }
931                if (i % 3 == 2)
932                {
933                    Canvas hschalter = schalter(2,i);
934                    Canvas hleuchte = leuchte(2, i);
935
936                    Canvas.SetLeft(taste, 90 * modz + 55);
937                    Canvas.SetLeft(hschalter, 90 * modz + 50);
938                    Canvas.SetLeft(hleuchte, 90 * modz + 55);
939
940                    Canvas.SetTop(hleuchte, 118);
941
942                    leuchten.Children.Add(hleuchte);
943
944                    tastaturrow2.Children.Add(taste);
945                    schalterrow2.Children.Add(hschalter);
946                    leuchtenlist3.Add(hleuchte);
947                    schalterlist3.Add(hschalter);
948                    modz++;
949                }
950
951               
952
953                tList[i] = taste;
954            }
955
956            batterieMalen();
957
958             rotorlocks1 = rotorlocks();
959             rotorlocks2 = rotorlocks();
960             rotorlocks3 = rotorlocks();
961
962           
963
964            Canvas.SetLeft(rotorlocks1, 200);
965            Canvas.SetLeft(rotorlocks2, 430);
966            Canvas.SetLeft(rotorlocks3, 660);
967
968            rotorarea.Children.Add(rotorlocks1);
969            rotorarea.Children.Add(rotorlocks2);
970            rotorarea.Children.Add(rotorlocks3);
971
972            //String settingskey = settings.Key;
973
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;
980            rotor.fast = speed * 80;
981            rotor.Cursor =  Cursors.Hand;
982            Canvas.SetLeft(rotor,0);
983            rotorarea.Children.Add(rotor);
984            rotorarray[0] = rotor;
985
986            rotor.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
987            rotor.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
988           
989            dropBox.Drop += List_Drop2;
990            dropBoxWalze.Drop += List_Drop21;
991
992
993            Walze walze = new Walze(settings.Reflector+1, this.Width, this.Height);
994            walze.fast = speed * 80;
995            Canvas.SetLeft(walze, 0);
996            Canvas.SetTop(walze, 60);
997            walzenarea.Children.Add(walze);
998            walze.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
999            walze.PreviewMouseMove += new MouseEventHandler(Walze_MouseMove);
1000            this.walze = walze;
1001
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;
1005            rotor1.fast = speed * 80;
1006            rotor1.Cursor = Cursors.Hand;
1007            rotor1.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
1008            Canvas.SetLeft(rotor1, 230);
1009            rotorarea.Children.Add(rotor1);
1010            rotor1.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
1011
1012            rotorarray[1] = rotor1;
1013
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;
1017            rotor2.fast = speed * 80;
1018            rotor2.Cursor = Cursors.Hand;
1019            rotor2.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
1020            Canvas.SetLeft(rotor2, 460);
1021            rotorarea.Children.Add(rotor2);
1022            rotor2.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
1023            rotorarray[2] = rotor2;
1024
1025            rotorarray[2].helpNextAnimation += helptoanimate2;
1026            rotorarray[1].helpNextAnimation += helptoanimate3;
1027            rotorarray[0].helpNextAnimation += helptoanimate4;
1028            rotorarray[1].helpNextAnimation2 += helptoanimate7;
1029            rotorarray[2].helpNextAnimation2 += helptoanimate8;
1030            rotorarray[0].helpNextAnimation2 += helptoanimate6;
1031
1032            walze.helpNextAnimation += helptoanimate5;
1033
1034            /*
1035            TextBlock tebo = new TextBlock();
1036
1037            tebo.Background = Brushes.LightSkyBlue;
1038            tebo.Height = 100;
1039            tebo.Width = 50;
1040            tebo.TextAlignment = TextAlignment.Center;
1041            tebo.FontSize = 50;
1042            tebo.Text = "IV";
1043            tebo.Uid = "4";
1044            Canvas.SetLeft(tebo, 50 * 4);
1045            dropBoxCanvas.Children.Add(tebo);
1046            tebo.Cursor = Cursors.Hand;
1047            Image sponge = new Image();
1048           
1049               
1050               
1051
1052
1053            TextBlock tebo2 = new TextBlock();
1054            tebo2.Background = Brushes.LightSkyBlue;
1055            tebo2.Height = 100;
1056            tebo2.Width = 50;
1057            tebo2.TextAlignment = TextAlignment.Center;
1058            tebo2.FontSize = 50;
1059            tebo2.Uid = "5";
1060            tebo2.Text = "V";
1061            Canvas.SetLeft(tebo2, 50 * 5);
1062            dropBoxCanvas.Children.Add(tebo2);
1063            tebo2.Cursor = Cursors.Hand;
1064           
1065
1066            TextBlock tebo3 = new TextBlock();
1067
1068            tebo3.Background = Brushes.LightSkyBlue;
1069            tebo3.Height = 100;
1070            tebo3.Width = 50;
1071            tebo3.TextAlignment = TextAlignment.Center;
1072            tebo3.FontSize = 50;
1073            tebo3.Uid = "1";
1074            tebo3.Text = "A";
1075            Canvas.SetLeft(tebo3, 50 * 1);
1076            dropBoxCanvasWalze.Children.Add(tebo3);
1077            tebo3.Cursor = Cursors.Hand;
1078
1079           
1080
1081            TextBlock tebo4 = new TextBlock();
1082
1083            tebo4.Background = Brushes.LightSkyBlue;
1084            tebo4.Height = 100;
1085            tebo4.Width = 50;
1086            tebo4.TextAlignment = TextAlignment.Center;
1087            tebo4.FontSize = 50;
1088            tebo4.Uid = "3";
1089            tebo4.Text = "C";
1090            Canvas.SetLeft(tebo4, 50 * 3);
1091            dropBoxCanvasWalze.Children.Add(tebo4);
1092            tebo4.Cursor = Cursors.Hand;
1093*/
1094            Image img1 = new Image();
1095            img1.Height = 100;
1096            img1.Width = 50;
1097            BitmapImage bi11= new BitmapImage();
1098            bi11.BeginInit();
1099            bi11.UriSource = new Uri("Images/rotor5.jpg", UriKind.Relative);
1100            bi11.EndInit();
1101            img1.Source = bi11;
1102            dropBoxCanvasWalze.Children.Add(img1);
1103            Canvas.SetLeft(img1, 50 * 1);
1104            img1.Uid = "1";
1105            img1.Cursor = Cursors.Hand;
1106
1107            Image img2 = new Image();
1108            img2.Height = 100;
1109            img2.Width = 50;
1110            BitmapImage bi12 = new BitmapImage();
1111            bi12.BeginInit();
1112            bi12.UriSource = new Uri("Images/rotor4.jpg", UriKind.Relative);
1113            bi12.EndInit();
1114            img2.Source = bi12;
1115            dropBoxCanvasWalze.Children.Add(img2);
1116            Canvas.SetLeft(img2, 50 * 3);
1117            img2.Uid = "3";
1118            img2.Cursor = Cursors.Hand;
1119
1120            Image img4 = new Image();
1121            img4.Height = 100;
1122            img4.Width = 50;
1123            BitmapImage bi1 = new BitmapImage();
1124            bi1.BeginInit();
1125            bi1.UriSource = new Uri("Images/rotor5.jpg", UriKind.Relative);
1126            bi1.EndInit();
1127            img4.Source = bi1;
1128            dropBoxCanvas.Children.Add(img4);
1129            Canvas.SetLeft(img4, 50 * 5);
1130            img4.Uid = "4";
1131            img4.Cursor = Cursors.Hand;
1132
1133            Image img3 = new Image();
1134            img3.Height = 100;
1135            img3.Width = 50;
1136            BitmapImage bi = new BitmapImage();
1137            bi.BeginInit();
1138            bi.UriSource = new Uri("Images/rotor4.jpg", UriKind.Relative);
1139            bi.EndInit();
1140            img3.Source = bi;
1141            dropBoxCanvas.Children.Add(img3);
1142            Canvas.SetLeft(img3, 50 * 4);
1143            img3.Uid = "3";
1144            img3.Cursor = Cursors.Hand;
1145
1146            rotorimgs[3] = img3;
1147            rotorimgs[4] = img4;
1148
1149            walzeimgs[0] = img1;
1150            walzeimgs[2] = img2;
1151            img3.PreviewMouseMove += Rotor_MouseMove1;
1152            img4.PreviewMouseMove += Rotor_MouseMove1;
1153
1154            //tebo.PreviewMouseMove += Rotor_MouseMove1;
1155            //tebo2.PreviewMouseMove += Rotor_MouseMove1;
1156
1157           
1158
1159            img1.PreviewMouseMove += Walze_MouseMove1;
1160            img2.PreviewMouseMove += Walze_MouseMove1;
1161
1162
1163            nop.Duration = new Duration(TimeSpan.FromMilliseconds((1000)));
1164            nop.Completed += tasteClick2;
1165               
1166
1167            fadeIn.From = 0.0;
1168            fadeIn.To = 1.0;
1169            fadeIn.Duration = new Duration(TimeSpan.FromMilliseconds((1000)));
1170
1171            fadeOut.From = 1.0;
1172            fadeOut.To = 0.0;
1173            fadeOut.Duration = new Duration(TimeSpan.FromMilliseconds((1000)));
1174
1175            dummycanvas = new Canvas();
1176            mainmainmain.Children.Add(dummycanvas);
1177            input = "";
1178            /*
1179            String input = "LJPQHSVDWCLYXZQFXHIUVWDJOBJNZXRCWEOTVNJCIONTFQNSXWISXKHJDAGDJVAKUKVMJAJHSZQQJHZOIAVZOWMSCKASRDNXKKSRFHCXCMPJGXYIJCCKISYYSHETXVVOVDQLZYTNJXNUWKZRXUJFXMBDIBRVMJKRHTCUJQPTEEIYNYNJBEAQJCLMUODFWMARQCFOBWN";
1180            inputtebo = new List<TextBlock>();
1181
1182            for (int i = 0; i < input.Length; i++)
1183            {
1184                if (i % 5 == 0 && i != 0)
1185                {
1186                    TextBlock t1 = new TextBlock();
1187                    t1.Text = " ";
1188                    t1.FontSize = 40;
1189                    inputPanel.Children.Add(t1);
1190
1191                }
1192
1193                TextBlock t = new TextBlock();
1194                t.FontFamily = new FontFamily("Courier New");
1195                t.Text = input[i] + "" ;
1196                t.FontSize = 41;
1197                inputPanel.Children.Add(t);
1198                inputtebo.Add(t);
1199               
1200            }
1201            */
1202
1203        }
1204
1205        public void setinput(String input)
1206        {
1207            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
1208            {
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++)
1220                    {
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);
1237
1238                    }
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               
1350            }, null);
1351        }
1352
1353
1354        private Canvas rotorlocks() 
1355        {
1356            Canvas temp = new Canvas();
1357            StackPanel stack = new StackPanel();
1358            Canvas.SetTop(stack,60);
1359            stack.Orientation = Orientation.Vertical;
1360            for (int i = 0; i < 26; i++)
1361            {
1362                TextBlock t = new TextBlock();
1363                t.Text = "" + Convert.ToChar(i + 65);
1364                t.Width = 30.0;
1365                t.Height = 29.4;
1366
1367
1368                t.FontSize = 20;
1369                t.Background = Brushes.SkyBlue;
1370                t.TextAlignment = TextAlignment.Center;
1371                if (i % 2 == 0)
1372                    t.Background = Brushes.LightSeaGreen;
1373
1374
1375                stack.Children.Add(t);
1376            }
1377            temp.Children.Add(stack);
1378            return temp;
1379        }
1380
1381        private void batterieMalen() 
1382        {
1383            Line l = new Line();
1384            l.Stroke = Brushes.Black;
1385            l.X1 = 80;
1386            l.Y2 = 10;
1387            l.X2 = 80;
1388            l.Y1 = 68;
1389            l.Opacity = 0.3;
1390
1391            tobat2[0, 0] = l;
1392            batterie.Children.Add(l);
1393
1394            Line l01 = new Line();
1395            l01.Stroke = Brushes.Black;
1396            l01.X1 = 80;
1397            l01.Y2 = 68;
1398            l01.X2 = 80;
1399            l01.Y1 = 128;
1400            l01.Opacity = 0.3;
1401
1402            tobat2[1, 0] = l01;
1403            batterie.Children.Add(l01);
1404
1405            Line l02 = new Line();
1406            l02.Stroke = Brushes.Black;
1407            l02.X1 = 80;
1408            l02.Y2 = 128;
1409            l02.X2 = 80;
1410            l02.Y1 = 180;
1411            l02.Opacity = 0.3;
1412
1413            tobat2[2, 0] = l02;
1414            batterie.Children.Add(l02);
1415
1416
1417            Line l1 = new Line();
1418            l1.Stroke = Brushes.Black;
1419            l1.X2 = 77;
1420            l1.Y1 = 10;
1421            l1.X1 = 80;
1422            l1.Y2 = 10;
1423            l1.Opacity = 0.3;
1424
1425            tobat2[0, 1] = l1;
1426            batterie.Children.Add(l1);
1427
1428            Line l2 = new Line();
1429            l2.Stroke = Brushes.Black;
1430            l2.X1 = 80;
1431            l2.Y1 = 68;
1432            l2.X2 = 80;
1433            l2.Y2 = 68;
1434            l2.Opacity = 0.3;
1435
1436            tobat2[1, 1] = l2;
1437            batterie.Children.Add(l2);
1438
1439
1440            Line l3 = new Line();
1441            l3.Stroke = Brushes.Black;
1442            l3.X2 = 47;
1443            l3.Y1 = 128;
1444            l3.X1 = 80;
1445            l3.Y2 = 128;
1446            l3.Opacity = 0.3;
1447
1448            tobat2[2, 1] = l3;
1449            batterie.Children.Add(l3);
1450
1451
1452            Line l4 = new Line();
1453            l4.Stroke = Brushes.Black;
1454            l4.X1 = 50;
1455            l4.Y1 = 180;
1456            l4.X2 = 110;
1457            l4.Y2 = 180;
1458            l4.StrokeThickness = 3;
1459           
1460
1461            batterie.Children.Add(l4);
1462
1463            Line l5 = new Line();
1464            l5.Stroke = Brushes.Black;
1465            l5.X1 = 65;
1466            l5.Y1 = 190;
1467            l5.X2 = 95;
1468            l5.Y2 = 190;
1469            l5.StrokeThickness = 3;
1470
1471
1472            batterie.Children.Add(l5);
1473
1474
1475            Line l6 = new Line();
1476            l6.Stroke = Brushes.Black;
1477            l6.X1 = 80;
1478            l6.Y1 = 190;
1479            l6.X2 = 80;
1480            l6.Y2 = 274;
1481            l6.Opacity = 0.3;
1482
1483            frombat2[0, 0] = l6;
1484            batterie.Children.Add(l6);
1485
1486            Line l61 = new Line();
1487            l61.Stroke = Brushes.Black;
1488            l61.X1 = 80;
1489            l61.Y1 = 274;
1490            l61.X2 = 80;
1491            l61.Y2 = 363;
1492            l61.Opacity = 0.3;
1493
1494            frombat2[1, 0] = l61;
1495            batterie.Children.Add(l61);
1496
1497            Line l62 = new Line();
1498            l62.Stroke = Brushes.Black;
1499            l62.X1 = 80;
1500            l62.Y1 = 363;
1501            l62.X2 = 80;
1502            l62.Y2 = 452;
1503            l62.Opacity = 0.3;
1504
1505            frombat2[2, 0] = l62;
1506            batterie.Children.Add(l62);
1507
1508            Line l70 = new Line();
1509            l70.Stroke = Brushes.Black;
1510            l70.X1 = 80;
1511            l70.Y1 = 274;
1512            l70.X2 = 80;
1513            l70.Y2 = 274;
1514            l70.Opacity = 0.3;
1515
1516            frombat2[0, 1] = l70;
1517            batterie.Children.Add(l70);
1518
1519            Line l71 = new Line();
1520            l71.Stroke = Brushes.Black;
1521            l71.X1 = 80;
1522            l71.Y1 = 363;
1523            l71.X2 = 80;
1524            l71.Y2 = 363;
1525            l71.Opacity = 0.3;
1526
1527            frombat2[1, 1] = l71;
1528            batterie.Children.Add(l71);
1529
1530
1531            Line l72 = new Line();
1532            l72.Stroke = Brushes.Black;
1533            l72.X1 = 80;
1534            l72.Y1 = 452;
1535            l72.X2 = 34;
1536            l72.Y2 = 452;
1537            l72.Opacity = 0.3;
1538
1539            frombat2[2, 1] = l72;
1540            batterie.Children.Add(l72);
1541
1542
1543        }
1544
1545        private Canvas leuchte(int swint,int i)
1546        { 
1547            Canvas myCanvas = new Canvas();
1548
1549            Rectangle k = new Rectangle();
1550            k.RadiusX = 20;
1551            k.RadiusY = 20;
1552            k.Height = 40;
1553            k.Width = 40;
1554            k.Stroke = Brushes.Black;
1555            //k.Fill = Brushes.DimGray;
1556            Canvas.SetTop(k,20);
1557            Canvas.SetLeft(k, 3);
1558
1559            leuchtenList[i] = k;
1560            myCanvas.Children.Add(k);
1561
1562            TextBlock b = new TextBlock();
1563            b.Text = Convert.ToChar(i + 65)+"";
1564            b.FontSize = 25;
1565            b.Width = 40;
1566            b.TextAlignment = TextAlignment.Center;
1567            //b.Background = Brushes.GreenYellow;
1568            Canvas.SetTop(b, 22);
1569            Canvas.SetLeft(b, 3);
1570
1571            myCanvas.Children.Add(b);
1572
1573            Line l = new Line();
1574            l.Stroke = Brushes.Black;
1575            l.X1 = 23;
1576            l.Y1 = 10;
1577            l.X2 = 23;
1578            l.Y2 = 20;
1579            l.Opacity = 0.3;
1580
1581            toBat[i, 5] = l;
1582            myCanvas.Children.Add(l);
1583
1584            Line l1 = new Line();
1585            l1.Stroke = Brushes.Black;
1586            l1.X2 = 23;
1587            l1.Y1 = 10;
1588            l1.X1 = 112;
1589            l1.Y2 = 10;
1590            l1.Opacity = 0.3;
1591
1592            switch (swint)
1593            {
1594                case 0: tobat1[i / 3, swint] = l1;
1595                    break;
1596                case 1: tobat1[i / 3, swint] = l1;
1597                    break;
1598                case 2: tobat1[i / 3, swint] = l1;
1599                    break;
1600            }
1601
1602            if (i == 25) 
1603            {
1604                l1.X1 = 86;
1605            }
1606
1607            myCanvas.Children.Add(l1);
1608
1609
1610            return myCanvas;
1611        }
1612
1613        private Canvas schalter(int swint, int i) 
1614        {
1615            Line[] line = new Line[2];
1616            Line[] line2 = new Line[6];
1617
1618            Canvas myCanvas = new Canvas();
1619            myCanvas.Height = 40;
1620            myCanvas.Width = 40;
1621            Line l = new Line();
1622            l.Stroke = Brushes.Black;
1623            l.X1 = 40;
1624            l.Y1 = 5;
1625            l.X2 = 40;
1626            l.Y2 = 18;
1627           
1628            myCanvas.Children.Add(l);
1629           
1630            line[0] = l;
1631            Line ln0 = new Line();
1632            ln0.Stroke = Brushes.Black;
1633            ln0.X1 = 40;
1634            ln0.Y1 = 5;
1635            ln0.X2 = 25;
1636            ln0.Y2 = 5;
1637            myCanvas.Children.Add(ln0);
1638
1639            Line ln1 = new Line();
1640            ln1.Stroke = Brushes.Black;
1641            ln1.X1 = 25;
1642            ln1.Y1 = 5;
1643            ln1.X2 = 25;
1644            ln1.Y2 = 0;
1645            myCanvas.Children.Add(ln1);
1646
1647            Line l2 = new Line();
1648            l2.Stroke = Brushes.Black;
1649            l2.X1 = 40;
1650            l2.Y1 = 18;
1651            l2.X2 = 5;
1652            l2.Y2 = 23;
1653            myCanvas.Children.Add(l2);
1654
1655            line[1] = l2;
1656            line2[0] = l2;
1657            schalterlist.Add(line);
1658
1659
1660            Rectangle r = new Rectangle();
1661            r.Stroke = Brushes.Black;
1662            r.RadiusX = 3;
1663            r.RadiusY = 3;
1664            Canvas.SetLeft(r, 25);
1665            Canvas.SetTop(r, 13);
1666            r.Height = 7;
1667            r.Width = 7;
1668
1669
1670            myCanvas.Children.Add(r);
1671
1672           
1673
1674            Line l4 = new Line();
1675            l4.Stroke = Brushes.Black;
1676            l4.X2 = 28;
1677            l4.Y1 = 10;
1678            l4.X1 = 50;
1679            l4.Y2 = 10;
1680
1681            toBat[i, 0] = l4;
1682            myCanvas.Children.Add(l4);
1683
1684            Line ln4 = new Line();
1685            ln4.Stroke = Brushes.Black;
1686            ln4.X1 = 29;
1687            ln4.Y2 = 14;
1688            ln4.X2 = 29;
1689            ln4.Y1 = 10;
1690
1691            toBat[i, 1] = ln4;
1692            myCanvas.Children.Add(ln4);
1693
1694            Line ln41 = new Line();
1695            ln41.Stroke = Brushes.Black;
1696            ln41.X1 = 50;
1697            ln41.Y2 = 10;
1698            ln41.X2 = 50;
1699            ln41.Y1 = -45;
1700
1701            toBat[i, 2] = ln41;
1702            myCanvas.Children.Add(ln41);
1703
1704            Line ln42 = new Line();
1705            ln42.Stroke = Brushes.Black;
1706            ln42.X2 = 50;
1707            ln42.Y2 = -45;
1708            ln42.X1 = 28;
1709            ln42.Y1 = -45;
1710
1711            toBat[i, 3] = ln42;
1712            myCanvas.Children.Add(ln42);
1713
1714            Line ln43 = new Line();
1715            ln43.Stroke = Brushes.Black;
1716            ln43.X1 = 28;
1717            ln43.Y2 = -45;
1718            ln43.X2 = 28;
1719            switch (swint) 
1720            { 
1721                case 0:
1722                    ln43.Y1 = -180;
1723                    break;
1724                case 1:
1725                    ln43.Y1 = -210;
1726                    break;
1727                case 2:
1728                    ln43.Y1 = -240;
1729                    break;
1730
1731            }
1732           
1733            ln43.Opacity = 0.7;
1734            toBat[i, 4] = ln43;
1735            myCanvas.Children.Add(ln43);
1736           
1737
1738            Rectangle r1 = new Rectangle();
1739            r1.Stroke = Brushes.Black;
1740            r1.RadiusX = 3;
1741            r1.RadiusY = 3;
1742            Canvas.SetLeft(r1, 25);
1743            Canvas.SetTop(r1, 25);
1744            r1.Height = 7;
1745            r1.Width = 7;
1746
1747
1748            myCanvas.Children.Add(r1);
1749
1750            Line l5 = new Line();
1751            l5.Stroke = Brushes.Black;
1752            l5.X1 = 14;
1753            l5.Y1 = 28;
1754            l5.X2 = 25;
1755            l5.Y2 = 28;
1756            myCanvas.Children.Add(l5);
1757            line2[2] = l5;
1758
1759            Line l6 = new Line();
1760            l6.Stroke = Brushes.Black;
1761            l6.X1 = 14;
1762            l6.Y1 = 35;
1763            l6.X2 = 14;
1764            l6.Y2 = 28;
1765            myCanvas.Children.Add(l6);
1766
1767            line2[3] = l6;
1768            schalterlist2.Add(line2);
1769
1770
1771            Line ln6 = new Line();
1772            ln6.Stroke = Brushes.Black;
1773            ln6.X1 = 104;
1774            ln6.Y1 = 35;
1775            ln6.X2 = 14;
1776            ln6.Y2 = 35;
1777            ln6.Opacity = 0.3;
1778            myCanvas.Children.Add(ln6);
1779
1780            switch (swint)
1781            {
1782                case 0: frombat[i / 3,swint] = ln6;
1783                    break;
1784                case 1: frombat[i / 3, swint] = ln6;
1785                    break;
1786                case 2: frombat[i / 3, swint] = ln6;
1787                    break;
1788            }
1789
1790
1791            if (i == 24)
1792            {
1793                ln6.X1 = 120;
1794            }
1795
1796            if (i == 25) 
1797            {
1798                ln6.X1 = 90;
1799            }
1800
1801            Line l7 = new Line();
1802            l7.Stroke = Brushes.Black;
1803            l7.X1 = 5;
1804            l7.Y1 = 23;
1805            l7.X2 = 5;
1806            l7.Y2 = 45;
1807            myCanvas.Children.Add(l7);
1808            line2[5] = l7;
1809
1810            Line l8 = new Line();
1811            l8.Stroke = Brushes.Black;
1812            l8.X1 = 5;
1813            l8.Y1 = 45;
1814            l8.X2 = 25;
1815            l8.Y2 = 45;
1816            myCanvas.Children.Add(l8);
1817            line2[4] = l8;
1818
1819            Line l9 = new Line();
1820            l9.Stroke = Brushes.Black;
1821            l9.X1 = 25;
1822            l9.Y1 = 45;
1823            l9.X2 = 25;
1824            switch(swint)
1825            {
1826                case 0: l9.Y2 = 250;
1827                    break;
1828                case 1: l9.Y2 = 140;
1829                    break;
1830                case 2: l9.Y2 = 50;
1831                    break;
1832            }
1833            myCanvas.Children.Add(l9);
1834            line2[1] = l9;
1835            return myCanvas;
1836        }
1837
1838
1839
1840
1841       
1842        public void tastedruecken(object sender, KeyEventArgs e)
1843        {
1844            Key k = e.Key;
1845            string s = k.ToString();
1846            int x = (int)s[0] - 65;
1847            if(!playbool)
1848            tasteClick(bList[x], EventArgs.Empty);
1849            Debug.Text = s;
1850        }
1851       
1852
1853        private void List_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
1854        {
1855            // Store the mouse position
1856            startPoint = e.GetPosition(null);
1857        }
1858
1859        private int merken=-1;
1860
1861        private void everythingblack() 
1862        {
1863
1864            StackPanel dummyLock1 = (StackPanel)rotorlocks3.Children[0];
1865           
1866            foreach (TextBlock t in dummyLock1.Children) 
1867            {
1868                t.Background = Brushes.LightSeaGreen;
1869                String s = t.Text;
1870                if ((int)s[0] % 2 == 0)
1871                {
1872                    t.Background = Brushes.SkyBlue;
1873                }
1874            }
1875             dummyLock1 = (StackPanel)rotorlocks2.Children[0];
1876
1877            foreach (TextBlock t in dummyLock1.Children)
1878            {
1879                t.Background = Brushes.LightSeaGreen;
1880                String s = t.Text;
1881                if ((int)s[0] % 2 == 0)
1882                {
1883                    t.Background = Brushes.SkyBlue;
1884                }
1885            }
1886             dummyLock1 = (StackPanel)rotorlocks1.Children[0];
1887
1888            foreach (TextBlock t in dummyLock1.Children)
1889            {
1890                t.Background = Brushes.LightSeaGreen;
1891                String s = t.Text;
1892                if ((int)s[0] % 2 == 0)
1893                {
1894                    t.Background = Brushes.SkyBlue;
1895                }
1896            }
1897
1898            if(rotorlocks4 != null)
1899            {
1900                dummyLock1 = (StackPanel)rotorlocks4.Children[0];
1901
1902                foreach (TextBlock t in dummyLock1.Children)
1903                {
1904                    t.Background = Brushes.LightSeaGreen;
1905                    String s = t.Text;
1906                    if ((int)s[0] % 2 == 0)
1907                    {
1908                        t.Background = Brushes.SkyBlue;
1909                    }
1910                }
1911            }
1912
1913            foreach(Line l in linesToThrowAway)
1914            {
1915
1916                foreach (Canvas c in leuchtenlist3)
1917                {
1918                    if (c == l.Parent)
1919                    {
1920                        c.Children.Remove(l);
1921                    }
1922                }
1923
1924                if (batterie == l.Parent)
1925                {
1926                    batterie.Children.Remove(l);
1927                }
1928               
1929                foreach (Canvas c in schalterlist3)
1930                {
1931                    if (c == l.Parent)
1932                    {
1933                        c.Children.Remove(l);
1934                    }
1935                }
1936                if (mainmainmain == l.Parent)
1937                {
1938                    mainmainmain.Children.Remove(l);
1939                }
1940                if (maingrid == l.Parent)
1941                {
1942                    maingrid.Children.Remove(l);
1943                }
1944                if (maingrid2 == l.Parent)
1945                {
1946                    maingrid2.Children.Remove(l);
1947                }
1948               
1949                //System.GC.Collect();
1950               
1951
1952            }
1953            linesToThrowAway.Clear();
1954            linesToAnimate.Clear();
1955            linesToAnimate2.Clear();
1956           
1957            if(walze != null)
1958            walze.resetColors();
1959
1960            foreach (Rotor2 r in rotorarray)
1961            {
1962                if(r != null)
1963                r.resetColors();
1964            }
1965
1966            if(drawLines!=null)
1967            {
1968                foreach (Line l in drawLines)
1969                {
1970                   
1971                    mainmainmain.Children.Remove(l);
1972                    maingrid2.Children.Remove(l);
1973                }
1974            }
1975
1976
1977
1978            foreach (Rectangle r in leuchtenList)
1979            {
1980                r.Fill = Brushes.White;
1981            }
1982
1983            foreach (Line l in toBat)
1984            {
1985                l.Stroke =Brushes.Black;
1986                l.StrokeThickness = 1.0;
1987            }
1988
1989            foreach (Line l in frombat2)
1990            {
1991                l.Stroke = Brushes.Black;
1992                l.StrokeThickness = 1.0;
1993            }
1994
1995            foreach (Line[] l in schalterlist2)
1996            {
1997                l[0].Stroke=Brushes.Black;
1998                l[1].Stroke = Brushes.Black;
1999                l[2].Stroke = Brushes.Black;
2000                l[3].Stroke = Brushes.Black;
2001                l[4].Stroke = Brushes.Black;
2002                l[5].Stroke = Brushes.Black;
2003                l[0].StrokeThickness = 1.0;
2004                l[1].StrokeThickness = 1.0;
2005                l[2].StrokeThickness = 1.0;
2006                l[3].StrokeThickness = 1.0;
2007                l[4].StrokeThickness = 1.0;
2008                l[5].StrokeThickness = 1.0;
2009
2010
2011            }
2012
2013            foreach (Line l in frombat)
2014            {
2015                if (l != null)
2016                {
2017                    l.Stroke = Brushes.Black;
2018                    l.StrokeThickness = 1.0;
2019                }
2020            }
2021            foreach (Line l in tobat1)
2022            {
2023                if (l != null)
2024                {
2025                    l.Stroke = Brushes.Black;
2026                    l.StrokeThickness = 1.0;
2027                }
2028            }
2029
2030            foreach (Line l in tobat2)
2031            {
2032                if (l != null)
2033                {
2034                    l.Stroke = Brushes.Black;
2035                    l.StrokeThickness = 1.0;
2036                }
2037            }
2038
2039
2040            foreach (Line[] l in schalterlist) 
2041            {
2042                DoubleAnimation animax = new DoubleAnimation();
2043                animax.Duration = new Duration(TimeSpan.FromMilliseconds((0)));
2044                animax.From = l[0].Y2;
2045                animax.To = 18;
2046                l[0].BeginAnimation(Line.Y2Property,animax);
2047                l[1].BeginAnimation(Line.Y1Property, animax);
2048                l[0].Y2 = 18;
2049                l[1].Y1 = 18;
2050                l[0].StrokeThickness = 1.0;
2051                l[1].StrokeThickness = 1.0;
2052            }
2053            for (int i = 0; i < outputList.Length;i++ )
2054            {
2055                outputList[i].Background = Brushes.SkyBlue;
2056                if (i%2==0)
2057                    outputList[i].Background = Brushes.LightSeaGreen;
2058            }
2059            for (int i = 0; i < inputList.Length; i++)
2060            {
2061                inputList[i].Background = Brushes.SkyBlue;
2062                if (i % 2 == 0)
2063                    inputList[i].Background = Brushes.LightSeaGreen;
2064            }
2065           
2066            foreach (Line t in lList)
2067            {
2068                t.Stroke = Brushes.Black;
2069                t.StrokeThickness = 1.0;
2070            }
2071            foreach (Button t in bList)
2072            {
2073                t.Background = Brushes.LightBlue;
2074            }
2075            if(off)
2076            for (int i = 0; i < 1; i++)
2077            {
2078                try
2079                {
2080                    foreach (Object o in mainmainmain.Children)
2081                    {
2082                        if (o is Line)
2083                        {
2084                            Line l = o as Line;
2085                            if (l.StrokeThickness == 5.0)
2086                            {
2087                                mainmainmain.Children.Remove(l);
2088                            }
2089                        }
2090                    }
2091
2092                    foreach (Object o in maingrid2.Children)
2093                    {
2094                        if (o is Line)
2095                        {
2096                            Line l = o as Line;
2097                            if (l.StrokeThickness == 5.0)
2098                            {
2099                                maingrid2.Children.Remove(l);
2100                            }
2101                        }
2102                    }
2103
2104                }
2105                catch (Exception e) { i--; }
2106            }
2107
2108            /*
2109            foreach (Line t in umlList)
2110            {
2111                t.Stroke = Brushes.Black;
2112            }*/
2113           
2114        }
2115
2116        Button temp = new Button();
2117        Boolean blupp = true;
2118
2119        public void stopclick(object sender, EventArgs e)
2120        {
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);
2137        }
2138
2139        private void m4onClick(object sender, EventArgs e)
2140        {
2141            mfouron = true;
2142            everythingblack();
2143            rotorlocks4 = rotorlocks();
2144
2145            Canvas.SetLeft(rotorlocks4, 890);
2146           
2147            rotorarea.Children.Add(rotorlocks4);
2148
2149            Rotor2 rotor4 = new Rotor2(4, this.Width, this.Height, 0, 0);
2150            rotor4.fast = speed * 80;
2151            rotor4.Cursor = Cursors.Hand;
2152            rotor4.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
2153            Canvas.SetLeft(rotor4, 688);
2154            rotorarea.Children.Add(rotor4);
2155           
2156            rotor4.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
2157
2158            rotorarray[2].helpNextAnimation -= helptoanimate2;
2159            rotorarray[1].helpNextAnimation -= helptoanimate3;
2160            rotorarray[0].helpNextAnimation -= helptoanimate4;
2161            rotorarray[1].helpNextAnimation2 -= helptoanimate7;
2162            rotorarray[2].helpNextAnimation2 -= helptoanimate8;
2163            rotorarray[0].helpNextAnimation2 -= helptoanimate6;
2164
2165           
2166            rotorarray[3] = rotorarray[2];
2167            rotorarray[2] = rotorarray[1];
2168            rotorarray[1] = rotorarray[0];
2169            rotorarray[0] = rotor4;
2170
2171            Canvas.SetLeft(rotorarray[2], 460); Canvas.SetLeft(rotorarray[1], 230); Canvas.SetLeft(rotorarray[0], 0); Canvas.SetLeft(rotorarray[3], 688);
2172
2173            rotorarray[3].helpNextAnimation += helptoanimatem4;
2174            rotorarray[2].helpNextAnimation += helptoanimate2;
2175            rotorarray[1].helpNextAnimation += helptoanimate3;
2176            rotorarray[0].helpNextAnimation += helptoanimate4;
2177            rotorarray[0].helpNextAnimation2 += helptoanimate6;
2178            rotorarray[1].helpNextAnimation2 += helptoanimate7;
2179            rotorarray[2].helpNextAnimation2 += helptoanimate8;
2180            rotorarray[3].helpNextAnimation2 += helptoanimatem42;
2181           
2182
2183            textBlocksToAnimate = new TextBlock[8];
2184        }
2185
2186        Boolean playbool = false;
2187       
2188
2189
2190        public void playClick(object sender, EventArgs e)
2191        {
2192             Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
2193            {
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               
2205            everythingblack();
2206            ColorAnimation colorani = new ColorAnimation();
2207            SolidColorBrush brush = new SolidColorBrush();
2208            brush.Color = Colors.Transparent;
2209
2210            colorani.From = Colors.Transparent;
2211            colorani.To = Colors.Orange;
2212            colorani.Duration = new Duration(TimeSpan.FromMilliseconds((0)));
2213            inputtebo[0].Background = brush;
2214            colorani.Completed += prefadeout;
2215            brush.BeginAnimation(SolidColorBrush.ColorProperty, colorani);
2216           
2217
2218
2219            //inputtebo[0].Opacity = 0.0;
2220            playbool = true;}
2221                }, null);
2222       
2223        }
2224
2225        private void prefadeout(object sender, EventArgs e)
2226        {
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           
2241        }
2242
2243        private void prefadeout1(object sender, EventArgs e)
2244        {
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            }
2256           
2257
2258        }
2259
2260        private void prefadeout2(object sender, EventArgs e)
2261        {
2262            if (!stop)
2263            {
2264                int x = Convert.ToInt32(inputtebo[inputcounter].Text[0]) - 65;
2265                letterInput(bList[x], EventArgs.Empty);
2266            }
2267           
2268        }
2269
2270        int inputcounter = 0;
2271        Char outputchar;
2272
2273        private void nextPlease(object sender, EventArgs e)
2274        {
2275            Debug.Text = "" + outputchar;
2276            inputcounter++;
2277            if (inputtebo.Count > inputcounter && !stop) 
2278            { 
2279               
2280                //int x = Convert.ToInt32(inputtebo[inputcounter].Text[0]) - 65;
2281                //tasteClick(bList[x], EventArgs.Empty);
2282                //inputtebo[inputcounter].Opacity = 0.0;
2283                /*ColorAnimation colorani = new ColorAnimation();
2284                SolidColorBrush brush = new SolidColorBrush();
2285                brush.Color = Colors.Transparent;
2286
2287                colorani.From = Colors.Transparent;
2288                colorani.To = Colors.Orange;
2289                colorani.Duration = new Duration(TimeSpan.FromMilliseconds((1000)));
2290                inputtebo[inputcounter].Background = brush;
2291                //colorani.Completed += nextPlease0;
2292                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorani);
2293                */
2294
2295                if ((inputcounter-1) % 5 == 0 && inputcounter != 0)
2296                {
2297                    TextBlock t1 = new TextBlock();
2298                    t1.Text = " ";
2299                    t1.FontSize = 40;
2300                    outputPanel.Children.Add(t1);
2301
2302                }
2303
2304                TextBlock t = new TextBlock();
2305                t.Background = Brushes.Orange;
2306                t.Opacity = 0.0;
2307                t.Text = outputchar + "";
2308                t.FontSize = 42;
2309                t.FontFamily = new FontFamily("Courier New");
2310
2311                outputPanel.Children.Add(t);
2312                outputtebo.Add(t);
2313                DoubleAnimation fadeIn2 = new DoubleAnimation();
2314                fadeIn2.From = 0.0;
2315                fadeIn2.To = 1.0;
2316                fadeIn2.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
2317                fadeIn2.Completed += nextPlease0;
2318                t.BeginAnimation(OpacityProperty,fadeIn2);
2319            }
2320        }
2321
2322        private void nextPlease0(object sender, EventArgs e)
2323        {
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
2333                ColorAnimation colorani = new ColorAnimation();
2334                SolidColorBrush brush = new SolidColorBrush();
2335                brush.Color = Colors.Orange;
2336
2337                colorani.From = Colors.Orange;
2338                colorani.To = Colors.Transparent;
2339                colorani.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 160)));
2340                outputtebo[outputtebo.Count - 1].Background = brush;
2341                colorani.Completed += nextPlease1;
2342                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorani);
2343            }
2344       }
2345        private void nextPlease1(object sender, EventArgs e)
2346        {
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            }
2377        }
2378        private void deStopClick(object sender, EventArgs e)
2379        {
2380            off = true;
2381            speed = 0;
2382            nop.Duration = new Duration(TimeSpan.FromMilliseconds((80)));
2383           
2384            Debug.Text  = off + "" ;
2385        }
2386
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)
2403        {
2404           
2405            if (blupp)
2406            {
2407                if (!mfouron)
2408                {
2409                    if (rotorarray[0] != null && rotorarray[1] != null && rotorarray[2] != null && walze != null)
2410                    {
2411
2412                        stop = false;
2413                        blupp = false;
2414                        temp = sender as Button;
2415                        if(!playbool)
2416                        everythingblack();
2417                        rotorarray[2].upperclick(sender, EventArgs.Empty);
2418                        if (rotorarray[0].next)
2419                        {
2420
2421                            //rotorarray[1].upperclick(sender, EventArgs.Empty);
2422                        }
2423
2424                        if (rotorarray[2].next)
2425                        {
2426                            rotorarray[1].upperclick(sender, EventArgs.Empty);
2427                        }
2428
2429                        if (rotorarray[1].next)
2430                        {
2431                            rotorarray[1].upperclick(sender, EventArgs.Empty);
2432                            rotorarray[0].upperclick(sender, EventArgs.Empty);
2433
2434                        }
2435
2436
2437
2438
2439
2440                        Line l = new Line();
2441                        mainmainmain.Children.Add(l);
2442
2443                        DoubleAnimation animax = new DoubleAnimation();
2444                        DoubleAnimation animax2 = new DoubleAnimation();
2445
2446                        Line[] line = schalterlist[Int32.Parse(temp.Uid)];
2447                        //line[0].Y2 = 27;
2448                        //line[1].Y1 = 27;
2449
2450                        animax.From = line[0].Y2;
2451                        animax.To = 27;
2452
2453                        animax2.From = line[0].Y1;
2454                        animax2.To = 27;
2455
2456                        animax.Duration = new Duration(TimeSpan.FromMilliseconds((speed*80)));
2457                        line[0].BeginAnimation(Line.Y2Property, animax);
2458
2459                        animax2.Duration = new Duration(TimeSpan.FromMilliseconds((speed*80)));
2460                        line[1].BeginAnimation(Line.Y1Property, animax);
2461
2462
2463                        l.BeginAnimation(OpacityProperty, nop);
2464                        //stop = false;
2465                    }
2466                }
2467                else
2468                {
2469                    if (rotorarray[0] != null && rotorarray[1] != null && rotorarray[2] != null &&
2470                        rotorarray[3] != null && walze != null)
2471                    {
2472
2473                        //stop = true;
2474                        blupp = false;
2475                        temp = sender as Button;
2476                        everythingblack();
2477                        rotorarray[3].upperclick(sender, EventArgs.Empty);
2478                        if (rotorarray[3].next)
2479                        {
2480
2481                            rotorarray[2].upperclick(sender, EventArgs.Empty);
2482                        }
2483
2484                        if (rotorarray[2].next)
2485                        {
2486                            rotorarray[1].upperclick(sender, EventArgs.Empty);
2487                        }
2488
2489                        if (rotorarray[1].next)
2490                        {
2491                            rotorarray[1].upperclick(sender, EventArgs.Empty);
2492                            rotorarray[0].upperclick(sender, EventArgs.Empty);
2493
2494                        }
2495
2496
2497
2498
2499
2500                        Line l = new Line();
2501                        mainmainmain.Children.Add(l);
2502
2503                        DoubleAnimation animax = new DoubleAnimation();
2504                        DoubleAnimation animax2 = new DoubleAnimation();
2505
2506                        Line[] line = schalterlist[Int32.Parse(temp.Uid)];
2507                        //line[0].Y2 = 27;
2508                        //line[1].Y1 = 27;
2509
2510                        animax.From = line[0].Y2;
2511                        animax.To = 27;
2512
2513                        animax2.From = line[0].Y1;
2514                        animax2.To = 27;
2515
2516                        animax.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 80)));
2517                        line[0].BeginAnimation(Line.Y2Property, animax);
2518
2519                        animax2.Duration = new Duration(TimeSpan.FromMilliseconds((speed * 80)));
2520                        line[1].BeginAnimation(Line.Y1Property, animax);
2521
2522
2523                        l.BeginAnimation(OpacityProperty, nop);
2524                        //stop = false;
2525                    }
2526                }
2527            }
2528           
2529        }
2530   
2531           
2532
2533        private void tasteClick2(object sender, EventArgs e)
2534        {
2535            if (!stop)
2536            {
2537                Button button = temp as Button;
2538
2539
2540                for (int i = 0; i <= Int32.Parse(button.Uid) % 3; i++)
2541                {
2542                    frombat2[i, 0].Stroke = Brushes.Green;
2543                    linesToAnimate.Add(frombat2[i, 0]);
2544                    frombat2[i, 0].Opacity = 1.0;
2545                }
2546
2547
2548
2549                frombat2[Int32.Parse(button.Uid) % 3, 1].Stroke = Brushes.Green;
2550                linesToAnimate.Add(frombat2[Int32.Parse(button.Uid) % 3, 1]);
2551
2552                if (Int32.Parse(button.Uid) % 3 != 2)
2553                {
2554                    frombat[8, Int32.Parse(button.Uid) % 3].Stroke = Brushes.Green;
2555                    linesToAnimate.Add(frombat[8, Int32.Parse(button.Uid) % 3]);
2556                }
2557
2558                for (int i = 7; i >= Int32.Parse(button.Uid) / 3; i--)
2559                {
2560                    frombat[i, Int32.Parse(button.Uid) % 3].Stroke = Brushes.Green;
2561                    linesToAnimate.Add(frombat[i, Int32.Parse(button.Uid) % 3]);
2562                }
2563                Line[] line = schalterlist[Int32.Parse(button.Uid)];
2564                line[0].Y2 = 27;
2565                line[1].Y1 = 27;
2566
2567                Line[] line2 = schalterlist2[Int32.Parse(button.Uid)];
2568                line2[0].Stroke = Brushes.Green;
2569                line2[1].Stroke = Brushes.Green;
2570                line2[2].Stroke = Brushes.Green;
2571                line2[3].Stroke = Brushes.Green;
2572                line2[4].Stroke = Brushes.Green;
2573                line2[5].Stroke = Brushes.Green;
2574
2575                linesToAnimate.Add(line2[3]);
2576                linesToAnimate.Add(line2[2]);
2577                linesToAnimate.Add(line2[0]);
2578
2579
2580
2581                linesToAnimate.Add(line2[5]);
2582
2583                linesToAnimate.Add(line2[4]);
2584                linesToAnimate.Add(line2[1]);
2585
2586
2587
2588                //if (switchlist[umkehrlist[switchlist[Int32.Parse(button.Uid)]]] % 3 != 2)
2589                //  tobat1[8, switchlist[umkehrlist[switchlist[Int32.Parse(button.Uid)]]] % 3].Stroke = Brushes.Red;
2590
2591
2592
2593
2594
2595
2596                // int aus = DrawLines(switchlist[Int32.Parse(button.Uid)]);
2597
2598
2599                //inputList[Int32.Parse(button.Uid)].Background = Brushes.Green;
2600                linesToAnimate.Add(inputList[Int32.Parse(button.Uid)]);
2601                lList[switchlist[Int32.Parse(button.Uid)]].Stroke = Brushes.Green;
2602                linesToAnimate.Add(lList[switchlist[Int32.Parse(button.Uid)]]);
2603                //bList[switchlist[Int32.Parse(button.Uid)]].Background = Brushes.Green;
2604                linesToAnimate.Add(bList[switchlist[Int32.Parse(button.Uid)]]);
2605                //outputList[switchlist[Int32.Parse(button.Uid)]].Background = Brushes.Green;
2606                linesToAnimate.Add(outputList[switchlist[Int32.Parse(button.Uid)]]);
2607                /*umlList[switchlist[Int32.Parse(button.Uid)],0].Stroke = Brushes.Red ;
2608                umlList[switchlist[Int32.Parse(button.Uid)], 2].Stroke = Brushes.Red;
2609                umlList[switchlist[Int32.Parse(button.Uid)], 1].Stroke = Brushes.Red;
2610                umlList[umkehrlist[switchlist[Int32.Parse(button.Uid)]], 1].Stroke = Brushes.Red;
2611                umlList[umkehrlist[switchlist[Int32.Parse(button.Uid)]], 0].Stroke = Brushes.Red;
2612                umlList[umkehrlist[switchlist[Int32.Parse(button.Uid)]], 2].Stroke = Brushes.Red;
2613                */
2614
2615                int aus = DrawLines2(switchlist[Int32.Parse(button.Uid)]);
2616
2617               
2618
2619                linesToAnimate2.Add(outputList[aus]);
2620                linesToAnimate2.Add(bList[aus]);
2621
2622
2623                linesToAnimate2.Add(lList[aus]);
2624                linesToAnimate2.Add(inputList[switchlist[aus]]);
2625
2626
2627
2628                Line[] line3 = schalterlist2[switchlist[aus]];
2629                line3[0].Stroke = Brushes.Red;
2630                line3[1].Stroke = Brushes.Red;
2631                //line3[2].Stroke = Brushes.Red;
2632                //line3[3].Stroke = Brushes.Red;
2633                line3[4].Stroke = Brushes.Red;
2634                line3[5].Stroke = Brushes.Red;
2635
2636                linesToAnimate2.Add(line3[1]);
2637                linesToAnimate2.Add(line3[4]);
2638                linesToAnimate2.Add(line3[5]);
2639                linesToAnimate2.Add(line3[0]);
2640
2641
2642                toBat[switchlist[aus], 0].Stroke = Brushes.Red;
2643                toBat[switchlist[aus], 1].Stroke = Brushes.Red;
2644                toBat[switchlist[aus], 2].Stroke = Brushes.Red;
2645                toBat[switchlist[aus], 3].Stroke = Brushes.Red;
2646                toBat[switchlist[aus], 4].Stroke = Brushes.Red;
2647                toBat[switchlist[aus], 5].Stroke = Brushes.Red;
2648
2649                linesToAnimate2.Add(toBat[switchlist[aus], 1]);
2650                linesToAnimate2.Add(toBat[switchlist[aus], 0]);
2651                linesToAnimate2.Add(toBat[switchlist[aus], 2]);
2652                linesToAnimate2.Add(toBat[switchlist[aus], 3]);
2653                linesToAnimate2.Add(toBat[switchlist[aus], 4]);
2654
2655                linesToAnimate2.Add(leuchtenList[switchlist[aus]]);
2656                linesToAnimate2.Add(toBat[switchlist[aus], 5]);
2657
2658                outputchar = Convert.ToChar(switchlist[aus] + 65);
2659
2660
2661                List<Line> dummy = new List<Line>();
2662
2663
2664                for (int i = 7; i >= switchlist[aus] / 3; i--)
2665                {
2666                    tobat1[i, switchlist[aus] % 3].Stroke = Brushes.Red;
2667                    dummy.Add(tobat1[i, switchlist[aus] % 3]);
2668
2669                }
2670                for (int i = dummy.Count - 1; i >= 0; i--)
2671                    linesToAnimate2.Add(dummy[i]);
2672
2673
2674                if (switchlist[aus] % 3 != 2)
2675                {
2676                    tobat1[8, switchlist[aus] % 3].Stroke = Brushes.Red;
2677                    linesToAnimate2.Add(tobat1[8, switchlist[aus] % 3]);
2678                }
2679                linesToAnimate2.Add(tobat2[switchlist[aus] % 3, 1]);
2680                List<Line> dummy2 = new List<Line>();
2681                for (int i = 2; i >= switchlist[aus] % 3; i--)
2682                {
2683                    tobat2[i, 0].Stroke = Brushes.Red;
2684                    dummy2.Add(tobat2[i, 0]);
2685                    tobat2[i, 0].Opacity = 1.0;
2686                }
2687
2688
2689                for (int i = dummy2.Count - 1; i >= 0; i--)
2690                    linesToAnimate2.Add(dummy2[i]);
2691
2692                tobat2[switchlist[aus] % 3, 1].Stroke = Brushes.Red;
2693
2694
2695                //leuchtenList[switchlist[aus]].Fill = Brushes.Red;
2696
2697                //outputList[aus].Background = Brushes.Red;
2698                //bList[aus].Background = Brushes.Red;
2699                lList[aus].Stroke = Brushes.Red;
2700
2701                //inputList[switchlist[aus]].Background = Brushes.Red;
2702                whostoanimate = 0;
2703                if (!off)
2704                    animatelines(0);
2705
2706                else 
2707                {
2708                    foreach (Object o in linesToAnimate)
2709                    {
2710                        if (o is Line)
2711                        {
2712                            Line l = o as Line;
2713                            l.Stroke = Brushes.Green;
2714                            l.StrokeThickness = 5;
2715                        }
2716                        if (o is Button)
2717                        {
2718                            Button b = o as Button;
2719                            b.Background = Brushes.Green;
2720
2721                        }
2722                        if (o is TextBlock)
2723                        {
2724                            TextBlock b = o as TextBlock;
2725                            b.Background = Brushes.Green;
2726
2727                        }
2728                    }
2729
2730                    foreach (Object o in linesToAnimate2)
2731                    {
2732                        if (o is Line)
2733                        {
2734                            Line l = o as Line;
2735                            l.Stroke = Brushes.Red;
2736                            l.StrokeThickness = 5;
2737                        }
2738                        if (o is Button)
2739                        {
2740                            Button b = o as Button;
2741                            b.Background = Brushes.Red;
2742
2743                        }
2744                        if (o is TextBlock)
2745                        {
2746                            TextBlock b = o as TextBlock;
2747                            b.Background = Brushes.Red;
2748
2749                        }
2750                        if (o is Rectangle)
2751                        {
2752                            Rectangle r = o as Rectangle;
2753                            r.Fill = Brushes.Yellow;
2754
2755                        }
2756
2757                    }
2758
2759                    textBlocksToAnimate[0].Background = Brushes.Green;
2760                    textBlocksToAnimate[1].Background = Brushes.Green;
2761                    textBlocksToAnimate[2].Background = Brushes.Green;
2762                    textBlocksToAnimate[3].Background = Brushes.Red;
2763                    textBlocksToAnimate[4].Background = Brushes.Red;
2764                    textBlocksToAnimate[5].Background = Brushes.Red;
2765                   
2766                }
2767                //blupp = true;
2768            }
2769        }
2770
2771        private int DrawLines2(int fromboard)
2772        {
2773            if (!stop)
2774            {
2775                int m4 = 0;
2776                if (mfouron)
2777                    m4 = 228;
2778                Line l = new Line();
2779                l.Stroke = Brushes.Green;
2780                l.X1 = fromboard * 30 + 15;
2781                l.Y1 = -5;
2782                l.X2 = fromboard * 30 + 15;
2783                l.Y2 = 30.5;
2784                maingrid2.Children.Add(l);
2785                linesToAnimate.Add(l);
2786                drawLines[0] = l;
2787
2788                Line l1 = new Line();
2789                l1.Stroke = Brushes.Green;
2790                l1.X1 = fromboard * 30 + 15;
2791                l1.Y1 = 30.5;
2792                l1.X2 = 0;
2793                l1.Y2 = 30.5;
2794                maingrid2.Children.Add(l1);
2795
2796                drawLines[1] = l1;
2797                linesToAnimate.Add(l1);
2798                Line l2 = new Line();
2799                l2.Stroke = Brushes.Green;
2800                l2.X1 = 1300;
2801                l2.Y1 = 811.5;
2802                l2.X2 = 990 + m4;
2803                l2.Y2 = 811.5;
2804                mainmainmain.Children.Add(l2);
2805
2806                drawLines[2] = l2;
2807                linesToAnimate.Add(l2);
2808
2809                Line l3 = new Line();
2810                l3.Stroke = Brushes.Green;
2811                l3.X1 = 990 + m4;
2812                l3.Y1 = 811.5;
2813                l3.X2 = 990 + m4;
2814                l3.Y2 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
2815                mainmainmain.Children.Add(l3);
2816                linesToAnimate.Add(l3);
2817
2818                drawLines[3] = l3;
2819
2820                Line l4 = new Line();
2821                l4.Stroke = Brushes.Green;
2822                l4.X1 = 990 + m4;
2823                l4.Y1 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
2824                l4.X2 = 950 + m4;
2825                l4.Y2 = 74 + rotorarray[2].maparray[fromboard, 0] * 29.5;
2826                mainmainmain.Children.Add(l4);
2827                linesToAnimate.Add(l4);
2828                drawLines[4] = l4;
2829
2830                int fromboardhelp = fromboard;
2831                //textBlocksToAnimate[0].Background = Brushes.Green;
2832
2833                StackPanel dummyLock1 = (StackPanel)rotorlocks3.Children[0];
2834                int ein = 0;
2835                if(mfouron)
2836                {
2837                    dummyLock1 = (StackPanel)rotorlocks4.Children[0];
2838                    textBlocksToAnimate[6] = (TextBlock)dummyLock1.Children[fromboard];
2839                    int dummyfromboard = 0;
2840                    dummyfromboard = rotorarray[3].mapto(fromboard, off);
2841                    fromboard = dummyfromboard; 
2842                   
2843                }
2844                dummyLock1 = (StackPanel)rotorlocks3.Children[0];
2845                textBlocksToAnimate[0] = (TextBlock)dummyLock1.Children[fromboard];
2846                ein = rotorarray[2].mapto(fromboard,off);
2847                dummyLock1 = (StackPanel)rotorlocks2.Children[0];
2848                textBlocksToAnimate[1] = (TextBlock)dummyLock1.Children[ein];
2849                //textBlocksToAnimate[1].Background = Brushes.Green;
2850
2851                int ein1 = 0;
2852                ein1 = rotorarray[1].mapto(ein,off);
2853                dummyLock1 = (StackPanel)rotorlocks1.Children[0];
2854                textBlocksToAnimate[2] = (TextBlock)dummyLock1.Children[ein1];
2855                //textBlocksToAnimate[2].Background = Brushes.Green;
2856
2857                int ein2 = 0;
2858                ein2 = rotorarray[0].mapto(ein1,off);
2859                int ein3 = walze.umkehrlist0(ein2,off);
2860
2861                int ein4 = rotorarray[0].maptoreverse(ein3,off);
2862                dummyLock1 = (StackPanel)rotorlocks1.Children[0];
2863                textBlocksToAnimate[3] = (TextBlock)dummyLock1.Children[ein4];
2864                //textBlocksToAnimate[3].Background = Brushes.Red;
2865
2866
2867                int ein5 = rotorarray[1].maptoreverse(ein4, off);
2868
2869                dummyLock1 = (StackPanel)rotorlocks2.Children[0];
2870                textBlocksToAnimate[4] = (TextBlock)dummyLock1.Children[ein5];
2871                //textBlocksToAnimate[4].Background = Brushes.Red;
2872
2873
2874                int ein6 = rotorarray[2].maptoreverse(ein5, off);
2875
2876                dummyLock1 = (StackPanel)rotorlocks3.Children[0];
2877                textBlocksToAnimate[5] = (TextBlock)dummyLock1.Children[ein6];
2878                //textBlocksToAnimate[5].Background = Brushes.Red;
2879
2880                if (mfouron)
2881                {
2882                    int dummyein6 = 0;
2883                    dummyein6 = rotorarray[3].maptoreverse(ein6, off);
2884                    ein6 = dummyein6 ;
2885                    dummyLock1 = (StackPanel)rotorlocks4.Children[0];
2886                    textBlocksToAnimate[7] = (TextBlock)dummyLock1.Children[ein6];
2887                }
2888
2889
2890                if (ein6 > fromboardhelp)
2891                {
2892                    Line l41 = new Line();
2893                    l41.Stroke = Brushes.Red;
2894                    l41.X2 = 950 +m4;
2895                    l41.Y1 = 74 + ein6 * 29.5;
2896                    l41.X1 = 970 + m4;
2897                    l41.Y2 = 74 + ein6 * 29.5;
2898                    mainmainmain.Children.Add(l41);
2899                    linesToAnimate2.Add(l41);
2900                    drawLines[17] = l41;
2901
2902                    Line l31 = new Line();
2903                    l31.Stroke = Brushes.Red;
2904                    l31.X2 = 970 + m4;
2905                    l31.Y2 = 74 + ein6 * 29.5;
2906                    l31.X1 = 970 + m4;
2907                    l31.Y1 = 821.5;
2908                    mainmainmain.Children.Add(l31);
2909                    linesToAnimate2.Add(l31);
2910                    drawLines[18] = l31;
2911
2912                    Line l21 = new Line();
2913                    l21.Stroke = Brushes.Red;
2914                    l21.X2 = 970 + m4;
2915                    l21.Y1 = 821.5;
2916                    l21.X1 = 1300;
2917                    l21.Y2 = 821.5;
2918                    mainmainmain.Children.Add(l21);
2919                    linesToAnimate2.Add(l21);
2920                    drawLines[19] = l21;
2921
2922                    Line l11 = new Line();
2923                    l11.Stroke = Brushes.Red;
2924                    l11.X2 = 0;
2925                    l11.Y1 = 40.5;
2926                    l11.X1 = ein6 * 30 + 15;
2927                    l11.Y2 = 40.5;
2928                    maingrid2.Children.Add(l11);
2929                    linesToAnimate2.Add(l11);
2930                    drawLines[20] = l11;
2931
2932                    Line ln1 = new Line();
2933                    ln1.Stroke = Brushes.Red;
2934                    ln1.X2 = ein6 * 30 + 15;
2935                    ln1.Y2 = 40.5;
2936                    ln1.X1 = ein6 * 30 + 15;
2937                    ln1.Y1 = -5;
2938                    maingrid2.Children.Add(ln1);
2939                    linesToAnimate2.Add(ln1);
2940                    drawLines[21] = ln1;
2941                }
2942                else
2943                {
2944                    Line l41 = new Line();
2945                    l41.Stroke = Brushes.Red;
2946                    l41.X1 = 1050 + m4;
2947                    l41.Y1 = 74 + ein6 * 29.5;
2948                    l41.X2 = 950 + m4;
2949                    l41.Y2 = 74 + ein6 * 29.5;
2950                    mainmainmain.Children.Add(l41);
2951                    linesToAnimate2.Add(l41);
2952                    drawLines[17] = l41;
2953
2954                    Line l31 = new Line();
2955                    l31.Stroke = Brushes.Red;
2956                    l31.X2 = 1050 + m4;
2957                    l31.Y2 = 74 + ein6 * 29.5;
2958                    l31.X1 = 1050 + m4;
2959                    l31.Y1 = 800.5;
2960                    mainmainmain.Children.Add(l31);
2961                    linesToAnimate2.Add(l31);
2962                    drawLines[18] = l31;
2963
2964                    Line l21 = new Line();
2965                    l21.Stroke = Brushes.Red;
2966                    l21.X2 = 1050 + m4;
2967                    l21.Y1 = 800.5;
2968                    l21.X1 = 1300;
2969                    l21.Y2 = 800.5;
2970                    mainmainmain.Children.Add(l21);
2971                    linesToAnimate2.Add(l21);
2972                    drawLines[19] = l21;
2973
2974                    Line l11 = new Line();
2975                    l11.Stroke = Brushes.Red;
2976                    l11.X2 = 0;
2977                    l11.Y1 = 19.5;
2978                    l11.X1 = ein6 * 30 + 15;
2979                    l11.Y2 = 19.5;
2980                    maingrid2.Children.Add(l11);
2981                    linesToAnimate2.Add(l11);
2982                    drawLines[20] = l11;
2983
2984                    Line ln1 = new Line();
2985                    ln1.Stroke = Brushes.Red;
2986                    ln1.X1 = ein6 * 30 + 15;
2987                    ln1.Y2 = 19.5;
2988                    ln1.X2 = ein6 * 30 + 15;
2989                    ln1.Y1 = -5;
2990                    maingrid2.Children.Add(ln1);
2991                    linesToAnimate2.Add(ln1);
2992                    drawLines[21] = ln1;
2993                }
2994                return ein6;
2995            }
2996            else 
2997            {
2998                return 5;
2999            }
3000        }
3001        int whostoanimate = 1;
3002       
3003
3004        private void animatelines(int counter) 
3005        {
3006            if (!stop)
3007            {
3008                if (counter < linesToAnimate.Count)
3009                {
3010                    if (linesToAnimate[counter] is Line)
3011                        animateThisLine((Line)linesToAnimate[counter]);
3012                    if (linesToAnimate[counter] is TextBlock)
3013                        animateThisTebo2((TextBlock)linesToAnimate[counter], true);
3014                    if (linesToAnimate[counter] is Button)
3015                        animateThisTebo2((Button)linesToAnimate[counter], true);
3016
3017                    //Debug.Text += "i";
3018                }
3019                else
3020                {
3021                    if (!mfouron)
3022                    {
3023                        animateThisTebo(textBlocksToAnimate[0], true);
3024                        rotorarray[2].startAnimation();
3025                    }
3026                    else
3027                    {
3028                        animateThisTebo(textBlocksToAnimate[6], true);
3029                        rotorarray[3].startAnimation();
3030                    }
3031
3032                    Debug.Text += "i";
3033
3034                }
3035            }
3036        }
3037
3038        private void helptoanimatem4(object sender, EventArgs e)
3039        {
3040            animateThisTebo(textBlocksToAnimate[0], true);
3041            rotorarray[2].startAnimation();
3042        }
3043
3044        private void helptoanimate2(object sender, EventArgs e) 
3045        {
3046            if (!stop)
3047            {
3048                animateThisTebo(textBlocksToAnimate[1], true);
3049                rotorarray[1].startAnimation();
3050
3051                Debug.Text += "i";
3052            }
3053           
3054           
3055        }
3056
3057        private void helptoanimate3(object sender, EventArgs e)
3058        {
3059            if (!stop)
3060            {
3061                animateThisTebo(textBlocksToAnimate[2], true);
3062                rotorarray[0].startAnimation();
3063                Debug.Text += "i";
3064            }
3065           
3066        }
3067
3068        private void helptoanimate4(object sender, EventArgs e)
3069        {
3070
3071            if (!stop)
3072            {
3073                walze.startanimation();
3074                Debug.Text += "i";
3075            }
3076        }
3077
3078        private void helptoanimate5(object sender, EventArgs e)
3079        {
3080            if (!stop)
3081            {
3082                rotorarray[0].startAnimationReverse();
3083                Debug.Text += "i";
3084            }
3085        }
3086
3087
3088
3089
3090        private void helptoanimate6(object sender, EventArgs e)
3091        {
3092            if (!stop)
3093            {
3094                animateThisTebo(textBlocksToAnimate[3], false);
3095                rotorarray[1].startAnimationReverse();
3096                Debug.Text += "i";
3097            }
3098        }
3099
3100        private void helptoanimate7(object sender, EventArgs e)
3101        {
3102            if (!stop)
3103            {
3104                animateThisTebo(textBlocksToAnimate[4], false);
3105                rotorarray[2].startAnimationReverse();
3106                whostoanimate2 = 0;
3107                Debug.Text += "i";
3108            }
3109        }
3110
3111        private int whostoanimate2 = 0;
3112
3113        private void helptoanimate8(object sender, EventArgs e)
3114        {
3115            if (!stop)
3116            {
3117                if (!mfouron)
3118                {
3119                    animateThisTebo(textBlocksToAnimate[5], false);
3120                    animateThisLine2((Line) linesToAnimate2[0]);
3121                }
3122                else
3123                {
3124                    animateThisTebo(textBlocksToAnimate[5], false);
3125                    rotorarray[3].startAnimationReverse();
3126                }
3127            }
3128        }
3129        private void helptoanimatem42(object sender, EventArgs e)
3130        {
3131            if (!stop)
3132            {
3133                animateThisTebo(textBlocksToAnimate[7], false);
3134                animateThisLine2((Line)linesToAnimate2[0]);
3135            }
3136        }
3137       
3138
3139        private void animateLines2()
3140        {
3141           
3142
3143            if (whostoanimate2 < linesToAnimate2.Count &&!stop) 
3144            {
3145                //animateThisLine2((Line)linesToAnimate2[whostoanimate2]);
3146                if (linesToAnimate2[whostoanimate2] is Line)
3147                    animateThisLine2((Line)linesToAnimate2[whostoanimate2]);
3148                if (linesToAnimate2[whostoanimate2] is TextBlock)
3149                    animateThisTebo2((TextBlock)linesToAnimate2[whostoanimate2], false);
3150                if (linesToAnimate2[whostoanimate2] is Button)
3151                    animateThisTebo2((Button)linesToAnimate2[whostoanimate2], false);
3152                if (linesToAnimate2[whostoanimate2] is Rectangle)
3153                    animateThisTebo2((Rectangle)linesToAnimate2[whostoanimate2], false);
3154            }
3155           
3156        }
3157
3158        private void helptoanimate21(object sender, EventArgs e)
3159        {
3160            if (!stop)
3161            {
3162                mydouble.Completed -= helptoanimate21;
3163                whostoanimate2++;
3164                animateLines2();
3165            }
3166
3167        }
3168
3169        private void helptoanimate(object sender, EventArgs e)
3170        {
3171            if (!stop)
3172            {
3173                mydouble.Completed -= helptoanimate;
3174                whostoanimate++;
3175                animatelines(whostoanimate);
3176            }
3177               
3178        }
3179        DoubleAnimation mydouble;
3180        private void animateThisLine2(Line l)
3181        {
3182
3183            if (!stop)
3184            {
3185
3186                Line l1 = new Line();
3187
3188                Canvas.SetLeft(l, Canvas.GetLeft(l));
3189
3190                Canvas.SetTop(l, Canvas.GetTop(l));
3191
3192                l1.StrokeThickness = 5.0;
3193                l1.Stroke = Brushes.Tomato;
3194
3195
3196                l1.X1 = l.X2;
3197                l1.X2 = l.X2;
3198
3199                l1.Y1 = l.Y2;
3200                l1.Y2 = l.Y2;
3201
3202                double abst = Math.Sqrt(Math.Pow(l.X2 - l.X1, 2) + Math.Pow(l.Y2 - l.Y1, 2));
3203                if (abst == 0)
3204                    abst = 1;
3205
3206                mydouble = new DoubleAnimation();
3207                mydouble.From = l.X2;
3208                mydouble.To = l.X1;
3209                mydouble.Duration = new Duration(TimeSpan.FromMilliseconds((abst * speed)));
3210
3211                DoubleAnimation mydouble1 = new DoubleAnimation();
3212                mydouble1.From = l.Y2;
3213                mydouble1.To = l.Y1;
3214                mydouble1.Duration = new Duration(TimeSpan.FromMilliseconds((abst * speed)));
3215
3216                mydouble.Completed += helptoanimate21;
3217
3218                foreach (Canvas c in schalterlist3)
3219                {
3220                    if (c == l.Parent)
3221                    {
3222                        c.Children.Add(l1);
3223                    }
3224                }
3225
3226                foreach (Canvas c in leuchtenlist3)
3227                {
3228                    if (c == l.Parent)
3229                    {
3230                        c.Children.Add(l1);
3231                    }
3232                }
3233
3234                if (mainmainmain == l.Parent)
3235                {
3236                    mainmainmain.Children.Add(l1);
3237                }
3238                if (maingrid == l.Parent)
3239                {
3240                    maingrid.Children.Add(l1);
3241                }
3242                if (maingrid2 == l.Parent)
3243                {
3244                    maingrid2.Children.Add(l1);
3245                }
3246
3247                if (batterie == l.Parent)
3248                {
3249                    batterie.Children.Add(l1);
3250                }
3251
3252                if (l == batterie.Children[2])
3253                {
3254                    blupp = true;
3255                }
3256
3257                if (l == batterie.Children[2]&&playbool)
3258                {
3259                    Debug.Text = "tatütatatütatatatü";
3260                    mydouble.Completed -= helptoanimate21;
3261                    mydouble.Completed += nextPlease;
3262                   
3263                }
3264
3265                l1.BeginAnimation(Line.X2Property, mydouble);
3266                l1.BeginAnimation(Line.Y2Property, mydouble1);
3267                linesToThrowAway.Add(l1);
3268            }
3269        }
3270
3271       
3272       
3273
3274        private void animateThisLine(Line l) 
3275        {
3276
3277            if (!stop)
3278            {
3279
3280                Line l1 = new Line();
3281
3282                Canvas.SetLeft(l, Canvas.GetLeft(l));
3283
3284                Canvas.SetTop(l, Canvas.GetTop(l));
3285
3286                l1.StrokeThickness = 5.0;
3287                l1.Stroke = Brushes.LawnGreen;
3288
3289
3290                l1.X1 = l.X1;
3291                l1.X2 = l.X1;
3292
3293                l1.Y1 = l.Y1;
3294                l1.Y2 = l.Y1;
3295
3296                mydouble = new DoubleAnimation();
3297                mydouble.From = l.X1;
3298                mydouble.To = l.X2;
3299                Debug.Text = "" + Math.Sqrt(Math.Pow(l.X2 - l.X1, 2) + Math.Pow(l.Y2 - l.Y1, 2));
3300                double abst = Math.Sqrt(Math.Pow(l.X2 - l.X1, 2) + Math.Pow(l.Y2 - l.Y1, 2));
3301                if (abst == 0)
3302                    abst = 1;
3303                mydouble.Duration = new Duration(TimeSpan.FromMilliseconds((abst * speed)));
3304
3305                DoubleAnimation mydouble1 = new DoubleAnimation();
3306                mydouble1.From = l.Y1;
3307                mydouble1.To = l.Y2;
3308                mydouble1.Duration = new Duration(TimeSpan.FromMilliseconds((abst * speed)));
3309                mydouble.Completed += helptoanimate;
3310
3311                foreach (Canvas c in schalterlist3)
3312                {
3313                    if (c == l.Parent)
3314                    {
3315                        c.Children.Add(l1);
3316                    }
3317                }
3318
3319                foreach (Canvas c in leuchtenlist3)
3320                {
3321                    if (c == l.Parent)
3322                    {
3323                        c.Children.Add(l1);
3324                    }
3325                }
3326
3327                if (mainmainmain == l.Parent)
3328                {
3329                    mainmainmain.Children.Add(l1);
3330                }
3331                if (maingrid == l.Parent)
3332                {
3333                    maingrid.Children.Add(l1);
3334                }
3335                if (maingrid2 == l.Parent)
3336                {
3337                    maingrid2.Children.Add(l1);
3338                }
3339
3340                if (batterie == l.Parent)
3341                {
3342                    batterie.Children.Add(l1);
3343                }
3344
3345                l1.BeginAnimation(Line.X2Property, mydouble);
3346                l1.BeginAnimation(Line.Y2Property, mydouble1);
3347                linesToThrowAway.Add(l1);
3348            }
3349        }
3350
3351        private void animateThisTebo2(Rectangle tebo, Boolean c)
3352        {
3353            if (!stop)
3354            {
3355                SolidColorBrush brush = new SolidColorBrush();
3356                brush.Color = Colors.White;
3357
3358                ColorAnimation colorAni = new ColorAnimation();
3359
3360                colorAni.From = Colors.White;
3361                colorAni.To = Colors.Yellow;
3362
3363                colorAni.Duration = new Duration(TimeSpan.FromMilliseconds(speed * 80));
3364
3365                colorAni.Completed += helptoanimate21;
3366                tebo.Fill = brush;
3367                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorAni);
3368            }
3369        }
3370
3371        private void animateThisTebo2(Button tebo, Boolean c)
3372        {
3373            if (!stop)
3374            {
3375                SolidColorBrush brush = new SolidColorBrush();
3376                brush.Color = Colors.Transparent;
3377
3378                ColorAnimation colorAni = new ColorAnimation();
3379
3380                colorAni.From = Colors.SkyBlue;
3381                if (tebo.Background == Brushes.LightSeaGreen)
3382                    colorAni.From = Colors.LightSeaGreen;
3383                if (c)
3384                    colorAni.To = Colors.YellowGreen;
3385                else
3386                    colorAni.To = Colors.Tomato;
3387                colorAni.Duration = new Duration(TimeSpan.FromMilliseconds(speed * 80));
3388                if (c)
3389                    colorAni.Completed += helptoanimate;
3390                else
3391                    colorAni.Completed += helptoanimate21;
3392                tebo.Background = brush;
3393                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorAni);
3394            }
3395        }
3396
3397        private void animateThisTebo2(TextBlock tebo, Boolean c)
3398        {
3399            if (!stop)
3400            {
3401                SolidColorBrush brush = new SolidColorBrush();
3402                brush.Color = Colors.Transparent;
3403
3404                ColorAnimation colorAni = new ColorAnimation();
3405
3406                colorAni.From = Colors.SkyBlue;
3407                if (tebo.Background == Brushes.LightSeaGreen)
3408                    colorAni.From = Colors.LightSeaGreen;
3409                if (c)
3410                    colorAni.To = Colors.YellowGreen;
3411                else
3412                    colorAni.To = Colors.Tomato;
3413                colorAni.Duration = new Duration(TimeSpan.FromMilliseconds(speed * 80));
3414                if (c)
3415                    colorAni.Completed += helptoanimate;
3416                else
3417                    colorAni.Completed += helptoanimate21;
3418
3419                tebo.Background = brush;
3420                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorAni);
3421            }
3422        }
3423
3424        private void animateThisTebo(TextBlock tebo,Boolean c)
3425        {
3426            if (!stop)
3427            {
3428                SolidColorBrush brush = new SolidColorBrush();
3429                brush.Color = Colors.Transparent;
3430
3431                ColorAnimation colorAni = new ColorAnimation();
3432
3433                colorAni.From = Colors.SkyBlue;
3434                if (tebo.Background == Brushes.LightSeaGreen)
3435                    colorAni.From = Colors.LightSeaGreen;
3436                if (c)
3437                    colorAni.To = Colors.YellowGreen;
3438                else
3439                    colorAni.To = Colors.Tomato;
3440                colorAni.Duration = new Duration(TimeSpan.FromMilliseconds(speed * 80));
3441
3442                tebo.Background = brush;
3443                brush.BeginAnimation(SolidColorBrush.ColorProperty, colorAni);
3444            }
3445        }
3446
3447
3448
3449
3450 
3451
3452        private void List_MouseLeftButtonDown(object sender, EventArgs e)
3453        {
3454           // Debug.Text = "test";
3455            everythingblack();
3456            if (merken == -1)
3457            {
3458                Button button = sender as Button;
3459                merken = Int32.Parse(button.Uid);
3460                if (!button.Uid.Equals(button.Content.ToString()))
3461                {                   switchbuttons(Int32.Parse(button.Content.ToString()), Int32.Parse(button.Uid));}
3462               
3463                button.Background = Brushes.LawnGreen;
3464            }
3465
3466            else 
3467            {
3468               
3469                Button button = sender as Button;
3470                bList[merken].Background = Brushes.LightBlue;
3471                if ((button.Content.ToString().Equals(button.Uid) || Int32.Parse(button.Content.ToString()).Equals(merken)))
3472                { switchbuttons(Int32.Parse(button.Uid), merken); Debug.Text = "test1"; }
3473
3474                else 
3475                {
3476                    Debug.Text = "test1";
3477                    switchbuttons(Int32.Parse(button.Content.ToString()), merken);
3478                    switchbuttons(Int32.Parse(button.Uid), Int32.Parse(button.Content.ToString()));
3479                }
3480                //switchbuttons(Int32.Parse(button.Uid), merken);
3481                merken =-1;
3482            }
3483
3484            syncPluboardSettings();
3485        }
3486
3487
3488        Boolean justme = true;
3489        private void List_MouseMove(object sender, MouseEventArgs e)
3490        {
3491           
3492            // Get the current mouse position
3493            Point mousePos = e.GetPosition(null);
3494            Vector diff = startPoint - mousePos;
3495            Button button = sender as Button;
3496            Button button2 = new Button();
3497            button2.Width = button.Width;
3498            button2.Height = button.Height;
3499            button2.Opacity = 0.0;
3500           
3501
3502            if (e.LeftButton == MouseButtonState.Pressed &&
3503                Math.Abs(diff.X)+4 > SystemParameters.MinimumHorizontalDragDistance &&
3504                Math.Abs(diff.Y)+4 > SystemParameters.MinimumVerticalDragDistance&& button.IsPressed)
3505            {
3506                // Get the dragged ListViewItem
3507           
3508                everythingblack();
3509                //lList[Int32.Parse(button.Uid)].X2 = mousePos.X;
3510                // Find the data behind the ListViewItem
3511
3512                // Let's define our DragScope .. In this case it is every thing inside our main window ..
3513                DragScope = Application.Current.MainWindow.Content as FrameworkElement;
3514                System.Diagnostics.Debug.Assert(DragScope != null);
3515
3516                // We enable Drag & Drop in our scope ...  We are not implementing Drop, so it is OK, but this allows us to get DragOver
3517                bool previousDrop = DragScope.AllowDrop;
3518                //DragScope.AllowDrop = true;
3519                maingrid.AllowDrop = true;
3520               
3521
3522                // Let's wire our usual events..
3523                // GiveFeedback just tells it to use no standard cursors.. 
3524
3525                //GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
3526                //this.DragSource.GiveFeedback += feedbackhandler;
3527
3528                // The DragOver event ...
3529                DragEventHandler draghandler = new DragEventHandler(Window1_DragOver);
3530                DragScope.PreviewDragOver += draghandler;
3531                DragScope.PreviewMouseLeftButtonUp += aktuellupdate;
3532
3533                // Drag Leave is optional, but write up explains why I like it ..
3534                //DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
3535                //DragScope.DragLeave += dragleavehandler;
3536
3537                // QueryContinue Drag goes with drag leave...
3538                //QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
3539                //DragScope.QueryContinueDrag += queryhandler;
3540                steckerbrett.Children.Remove(button);
3541                steckerbrett.Children.Insert(Int32.Parse(button.Uid), button2);
3542               
3543                //Here we create our adorner..
3544                _adorner = new DragAdorner(DragScope, (UIElement)button, true, 1, this.ActualWidth, this.ActualHeight);
3545               
3546                _layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
3547                _layer.Add(_adorner);
3548               
3549
3550                IsDragging = true;
3551                //_dragHasLeftScope = false;
3552                //Finally lets drag drop
3553                if (!button.Uid.Equals(button.Content.ToString()))
3554                    switchbuttons(Int32.Parse(button.Content.ToString()), Int32.Parse(button.Uid));
3555                aktuell = Int32.Parse(button.Content.ToString());
3556               
3557                DataObject data = new DataObject("myFormat", button.Uid);
3558                DragDropEffects de = DragDrop.DoDragDrop(maingrid, data, DragDropEffects.Move);
3559                maingrid.AllowDrop = false;
3560                steckerbrett.Children.Remove(button2);
3561                steckerbrett.Children.Insert(Int32.Parse(button.Uid), button);
3562                // Clean up our mess :)
3563                //DragScope.AllowDrop = previousDrop;
3564                if (_adorner != null)
3565                    AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
3566               
3567                _adorner = null;
3568                lList[Int32.Parse(button.Content.ToString())].X2=15+Int32.Parse(button.Content.ToString()) * 30;
3569                lList[Int32.Parse(button.Content.ToString())].Y2 = 200;
3570                //           DragSource.GiveFeedback -= feedbackhandler;
3571                //         DragScope.DragLeave -= dragleavehandler;
3572                //       DragScope.QueryContinueDrag -= queryhandler;
3573                DragScope.PreviewDragOver -= draghandler;
3574
3575                //IsDragging = false;
3576               
3577
3578                // Initialize the drag & drop operation
3579                //DataObject dragData = new DataObject("myFormat", button.Uid);
3580           
3581                //DragDrop.DoDragDrop(button, dragData , DragDropEffects.Move);
3582            }
3583        }
3584
3585        private void Rotor_MouseMove(object sender, MouseEventArgs e)
3586        {
3587            // Get the current mouse position
3588            Point mousePos = e.GetPosition(null);
3589            Vector diff = startPoint - mousePos;
3590            Rotor2 rotor = sender as Rotor2;
3591           
3592
3593            if (e.LeftButton == MouseButtonState.Pressed &&
3594                Math.Abs(diff.X)  > SystemParameters.MinimumHorizontalDragDistance &&
3595                Math.Abs(diff.Y)  > SystemParameters.MinimumVerticalDragDistance )
3596            {
3597                // Get the dragged ListViewItem
3598               
3599                everythingblack();
3600                //lList[Int32.Parse(button.Uid)].X2 = mousePos.X;
3601                // Find the data behind the ListViewItem
3602
3603                // Let's define our DragScope .. In this case it is every thing inside our main window ..
3604                //DragScope = dropBox as FrameworkElement;
3605                DragScope = Application.Current.MainWindow.Content as FrameworkElement;
3606                System.Diagnostics.Debug.Assert(DragScope != null);
3607
3608                // We enable Drag & Drop in our scope ...  We are not implementing Drop, so it is OK, but this allows us to get DragOver
3609                bool previousDrop = DragScope.AllowDrop;
3610                //DragScope.AllowDrop = true;
3611
3612                // Let's wire our usual events..
3613                // GiveFeedback just tells it to use no standard cursors.. 
3614
3615                //GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
3616                //this.DragSource.GiveFeedback += feedbackhandler;
3617
3618                // The DragOver event ...
3619                DragEventHandler draghandler = new DragEventHandler(Window1_DragOver2);
3620                DragScope.PreviewDragOver += draghandler;
3621                DragScope.PreviewMouseLeftButtonUp += aktuellupdate;
3622
3623                // Drag Leave is optional, but write up explains why I like it ..
3624                //DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
3625                //DragScope.DragLeave += dragleavehandler;
3626
3627                // QueryContinue Drag goes with drag leave...
3628                //QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
3629                //DragScope.QueryContinueDrag += queryhandler;
3630                rotorarea.Children.Remove(rotor);
3631                Rectangle dummy = new Rectangle();
3632               
3633                dummy.Width = 200;
3634                dummy.Height = 900;
3635                dummy.Opacity = 0.0;
3636                dummy.Stroke=Brushes.Green;
3637                dummy.StrokeThickness = 5; 
3638                dummy.Fill=Brushes.LawnGreen;
3639                //dummy.AllowDrop = true;
3640                rotorarea.AllowDrop = true;
3641                dropBoxCanvas.AllowDrop = true;
3642
3643                Canvas.SetLeft(dummy,Canvas.GetLeft(rotor));
3644                int helpint = 5;
3645                rotor.PreviewMouseLeftButtonDown -= List_PreviewMouseLeftButtonDown;
3646                rotorarea.Children.Add(dummy);
3647
3648                if (rotorarray[0] == rotor)
3649                {
3650                    dummy.Drop += List_Drop30;
3651                    rotor.helpNextAnimation -=  helptoanimate4;
3652                    rotor.helpNextAnimation2 -= helptoanimate6;
3653                    dummyrec[0] = dummy;
3654                    rotorarray[0] = null;
3655                    helpint = 0;
3656                }
3657
3658             
3659                if (rotorarray[1] == rotor)
3660                    {
3661                        dummy.Drop += List_Drop31;
3662                        rotor.helpNextAnimation -= helptoanimate3;
3663                        dummyrec[1] = dummy;
3664                         rotor.helpNextAnimation2 -= helptoanimate7;
3665                         rotorarray[1] = null;
3666                         helpint = 1;
3667                    }
3668
3669                if (rotorarray[2] == rotor)
3670                        {
3671                            dummy.Drop += List_Drop32;
3672                            rotor.helpNextAnimation2 -= helptoanimate8;
3673                            rotor.helpNextAnimation -= helptoanimate2;
3674                            dummyrec[2] = dummy;
3675                            rotorarray[2] = null;
3676                            helpint = 2;
3677                        }
3678
3679                if (rotorarray[3] == rotor)
3680                {
3681                    dummy.Drop += List_Drop33;
3682                    rotor.helpNextAnimation2 -= helptoanimate8;
3683                    rotor.helpNextAnimation -= helptoanimate2;
3684                    dummyrec[3] = dummy; 
3685                    rotorarray[3] = null;
3686                    helpint = 3;
3687                }
3688
3689                //steckerbrett.Children.Insert(Int32.Parse(button.Uid), button2);
3690
3691                //Here we create our adorner..
3692                _adorner = new DragAdorner(DragScope, (UIElement)rotor.iAm, true, 1, this.ActualWidth, this.ActualHeight);
3693
3694                _layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
3695                _layer.Add(_adorner);
3696
3697                suc = false;
3698                IsDragging = true;
3699               
3700                //_dragHasLeftScope = false;
3701                //Finally lets drag drop
3702                //if (!button.Uid.Equals(button.Content.ToString()))
3703                  //  switchbuttons(Int32.Parse(button.Content.ToString()), Int32.Parse(button.Uid));
3704
3705               
3706                DataObject data = new DataObject("myFormat", rotor.returnMap()+"");
3707                DragDropEffects de = DragDrop.DoDragDrop(rotorarea, data, DragDropEffects.Move);
3708                Debug.Text += "k";
3709
3710
3711
3712                if (!suc) 
3713                {
3714                    if (0 == helpint)
3715                    {
3716                        dummy.Drop -= List_Drop30;
3717                        dummyrec[0] = null;
3718                        rotorarray[0] = rotor;
3719                    }
3720                    if (1 == helpint)
3721                    {
3722                        dummy.Drop -= List_Drop31;
3723                        dummyrec[1] = null;
3724                        rotorarray[1] = rotor;
3725                    }
3726
3727                    if (2 == helpint)
3728                    {
3729                        dummy.Drop -= List_Drop32;
3730                        dummyrec[2] = null;
3731                        rotorarray[2] = rotor;
3732                    }
3733
3734                    rotorarea.Children.Remove(dummy);
3735                    rotorarea.Children.Add(rotor);
3736                    dropBoxCanvas.AllowDrop = false;
3737                }
3738
3739                rotorarea.AllowDrop = false;
3740
3741                // Clean up our mess :)
3742                //DragScope.AllowDrop = previousDrop;
3743                if (_adorner != null)
3744                    AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
3745               
3746                _adorner = null;
3747               
3748                //           DragSource.GiveFeedback -= feedbackhandler;
3749                //         DragScope.DragLeave -= dragleavehandler;
3750                //       DragScope.QueryContinueDrag -= queryhandler;
3751                DragScope.PreviewDragOver -= draghandler;
3752
3753                //IsDragging = false;
3754
3755
3756                // Initialize the drag & drop operation
3757                //DataObject dragData = new DataObject("myFormat", button.Uid);
3758
3759                //DragDrop.DoDragDrop(button, dragData , DragDropEffects.Move);
3760                 
3761            }
3762        }
3763
3764        private void Walze_MouseMove(object sender, MouseEventArgs e)
3765        {
3766            // Get the current mouse position
3767            Point mousePos = e.GetPosition(null);
3768            Vector diff = startPoint - mousePos;
3769            Walze rotor = sender as Walze;
3770
3771
3772            if (e.LeftButton == MouseButtonState.Pressed &&
3773                Math.Abs(diff.X) > SystemParameters.MinimumHorizontalDragDistance &&
3774                Math.Abs(diff.Y) > SystemParameters.MinimumVerticalDragDistance)
3775            {
3776                // Get the dragged ListViewItem
3777
3778                everythingblack();
3779                //lList[Int32.Parse(button.Uid)].X2 = mousePos.X;
3780                // Find the data behind the ListViewItem
3781
3782                // Let's define our DragScope .. In this case it is every thing inside our main window ..
3783                DragScope = mainCanvas as FrameworkElement;
3784                System.Diagnostics.Debug.Assert(DragScope != null);
3785
3786                // We enable Drag & Drop in our scope ...  We are not implementing Drop, so it is OK, but this allows us to get DragOver
3787                bool previousDrop = DragScope.AllowDrop;
3788                //DragScope.AllowDrop = true;
3789
3790                // Let's wire our usual events..
3791                // GiveFeedback just tells it to use no standard cursors.. 
3792
3793                //GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
3794                //this.DragSource.GiveFeedback += feedbackhandler;
3795
3796                // The DragOver event ...
3797                DragEventHandler draghandler = new DragEventHandler(Window1_DragOver2);
3798                DragScope.PreviewDragOver += draghandler;
3799                DragScope.PreviewMouseLeftButtonUp += aktuellupdate;
3800
3801                // Drag Leave is optional, but write up explains why I like it ..
3802                //DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
3803                //DragScope.DragLeave += dragleavehandler;
3804
3805                // QueryContinue Drag goes with drag leave...
3806                //QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
3807                //DragScope.QueryContinueDrag += queryhandler;
3808                walzenarea.Children.Remove(rotor);
3809                Rectangle dummy = new Rectangle();
3810
3811                dummy.Width = 260;
3812                dummy.Height = 900;
3813                dummy.Opacity = 0.0;
3814                dummy.Stroke = Brushes.Green;
3815                dummy.StrokeThickness = 5;
3816                dummy.Fill = Brushes.LawnGreen;
3817                //dummy.AllowDrop = true;
3818                walzenarea.AllowDrop = true;
3819                dropBoxCanvasWalze.AllowDrop = true;
3820
3821                Canvas.SetLeft(dummy, Canvas.GetLeft(rotor));
3822
3823                rotor.PreviewMouseLeftButtonDown -= List_PreviewMouseLeftButtonDown;
3824                walzenarea.Children.Add(dummy);
3825
3826                dummy.Drop += List_Drop4;
3827                rotor.helpNextAnimation -= helptoanimate4;
3828                walze = null;
3829
3830                dummyrec[3] = dummy;
3831                   
3832                //steckerbrett.Children.Insert(Int32.Parse(button.Uid), button2);
3833
3834                //Here we create our adorner..
3835                _adorner = new DragAdorner(DragScope, (UIElement)rotor.iAm, true, 1, this.ActualWidth, this.ActualHeight);
3836
3837                _layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
3838                _layer.Add(_adorner);
3839
3840                suc = false;
3841                IsDragging = true;
3842
3843                //_dragHasLeftScope = false;
3844                //Finally lets drag drop
3845                //if (!button.Uid.Equals(button.Content.ToString()))
3846                //  switchbuttons(Int32.Parse(button.Content.ToString()), Int32.Parse(button.Uid));
3847
3848
3849                DataObject data = new DataObject("myFormat", rotor.typ + "");
3850                DragDropEffects de = DragDrop.DoDragDrop(rotorarea, data, DragDropEffects.Move);
3851                Debug.Text += "k";
3852
3853
3854
3855                if (!suc)
3856                {
3857                    dummyrec[3] = null;
3858                    dummy.Drop -= List_Drop4;
3859                    walzenarea.Children.Remove(dummy);
3860                    walzenarea.Children.Add(rotor);
3861                    dropBoxCanvas.AllowDrop = false;
3862                    walze = rotor;
3863                }
3864
3865                // Clean up our mess :)
3866                //DragScope.AllowDrop = previousDrop;
3867                if (_adorner != null)
3868                    AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
3869
3870                _adorner = null;
3871
3872                //           DragSource.GiveFeedback -= feedbackhandler;
3873                //         DragScope.DragLeave -= dragleavehandler;
3874                //       DragScope.QueryContinueDrag -= queryhandler;
3875                DragScope.PreviewDragOver -= draghandler;
3876
3877                //IsDragging = false;
3878
3879
3880                // Initialize the drag & drop operation
3881                //DataObject dragData = new DataObject("myFormat", button.Uid);
3882
3883                //DragDrop.DoDragDrop(button, dragData , DragDropEffects.Move);
3884
3885            }
3886        }
3887
3888        private void Walze_MouseMove1(object sender, MouseEventArgs e)
3889        {
3890            // Get the current mouse position
3891            Point mousePos = e.GetPosition(null);
3892            Vector diff = startPoint - mousePos;
3893            Image rotor = sender as Image;
3894
3895
3896            if (e.LeftButton == MouseButtonState.Pressed &&
3897                Math.Abs(diff.X) - 4 > SystemParameters.MinimumHorizontalDragDistance &&
3898                Math.Abs(diff.Y) - 4 > SystemParameters.MinimumVerticalDragDistance)
3899            {
3900                // Get the dragged ListViewItem
3901
3902                everythingblack();
3903                //lList[Int32.Parse(button.Uid)].X2 = mousePos.X;
3904                // Find the data behind the ListViewItem
3905
3906                // Let's define our DragScope .. In this case it is every thing inside our main window ..
3907                DragScope = mainCanvas as FrameworkElement;
3908                System.Diagnostics.Debug.Assert(DragScope != null);
3909
3910                // We enable Drag & Drop in our scope ...  We are not implementing Drop, so it is OK, but this allows us to get DragOver
3911                bool previousDrop = DragScope.AllowDrop;
3912                walzenarea.AllowDrop = true;
3913                dropBoxCanvasWalze.AllowDrop = true;
3914                //DragScope.AllowDrop = true;
3915
3916                // Let's wire our usual events..
3917                // GiveFeedback just tells it to use no standard cursors.. 
3918
3919                //GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
3920                //this.DragSource.GiveFeedback += feedbackhandler;
3921
3922                // The DragOver event ...
3923                DragEventHandler draghandler = new DragEventHandler(Window1_DragOver2);
3924                DragScope.PreviewDragOver += draghandler;
3925                DragScope.PreviewMouseLeftButtonUp += aktuellupdate;
3926
3927                // Drag Leave is optional, but write up explains why I like it ..
3928                //DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
3929                //DragScope.DragLeave += dragleavehandler;
3930
3931                // QueryContinue Drag goes with drag leave...
3932                //QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
3933                //DragScope.QueryContinueDrag += queryhandler;
3934                dropBoxCanvasWalze.Children.Remove(rotor);
3935               
3936                //steckerbrett.Children.Insert(Int32.Parse(button.Uid), button2);
3937
3938                //Here we create our adorner..
3939                _adorner = new DragAdorner(DragScope, (UIElement)rotor, true, 1, this.ActualWidth, this.ActualHeight);
3940
3941                _layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
3942                _layer.Add(_adorner);
3943
3944
3945                suc = false;
3946                IsDragging = true;
3947                //_dragHasLeftScope = false;
3948                //Finally lets drag drop
3949                //if (!button.Uid.Equals(button.Content.ToString()))
3950                //  switchbuttons(Int32.Parse(button.Content.ToString()), Int32.Parse(button.Uid));
3951
3952
3953
3954                DataObject data = new DataObject("myFormat", rotor.Uid);
3955                DragDropEffects de = DragDrop.DoDragDrop(mainmainmain, data, DragDropEffects.Move);
3956
3957                if (!suc)
3958                {
3959                    dropBoxCanvasWalze.Children.Add(rotor);
3960                    rotorarea.AllowDrop = false;
3961                    dropBoxCanvasWalze.AllowDrop = false;
3962                }
3963
3964                // Clean up our mess :)
3965                //DragScope.AllowDrop = previousDrop;
3966                if (_adorner != null)
3967                    AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
3968
3969                _adorner = null;
3970
3971                //           DragSource.GiveFeedback -= feedbackhandler;
3972                //         DragScope.DragLeave -= dragleavehandler;
3973                //       DragScope.QueryContinueDrag -= queryhandler;
3974                DragScope.PreviewDragOver -= draghandler;
3975
3976                IsDragging = false;
3977
3978
3979                // Initialize the drag & drop operation
3980                //DataObject dragData = new DataObject("myFormat", button.Uid);
3981
3982                //DragDrop.DoDragDrop(button, dragData , DragDropEffects.Move);
3983
3984            }
3985        }
3986
3987        private void Rotor_MouseMove1(object sender, MouseEventArgs e)
3988        {
3989            // Get the current mouse position
3990            Point mousePos = e.GetPosition(null);
3991            Vector diff = startPoint - mousePos;
3992            Image rotor = sender as Image;
3993           
3994
3995            if (e.LeftButton == MouseButtonState.Pressed &&
3996                Math.Abs(diff.X) - 4 > SystemParameters.MinimumHorizontalDragDistance &&
3997                Math.Abs(diff.Y) - 4 > SystemParameters.MinimumVerticalDragDistance)
3998            {
3999                // Get the dragged ListViewItem
4000
4001                everythingblack();
4002                //lList[Int32.Parse(button.Uid)].X2 = mousePos.X;
4003                // Find the data behind the ListViewItem
4004
4005                // Let's define our DragScope .. In this case it is every thing inside our main window ..
4006                //DragScope = rotorarea as FrameworkElement;
4007                DragScope = mainCanvas as FrameworkElement;
4008               
4009                System.Diagnostics.Debug.Assert(DragScope != null);
4010
4011                // We enable Drag & Drop in our scope ...  We are not implementing Drop, so it is OK, but this allows us to get DragOver
4012                bool previousDrop = DragScope.AllowDrop;
4013                rotorarea.AllowDrop = true;
4014                dropBoxCanvas.AllowDrop = true;
4015                //DragScope.AllowDrop = true;
4016               
4017                // Let's wire our usual events..
4018                // GiveFeedback just tells it to use no standard cursors.. 
4019
4020                //GiveFeedbackEventHandler feedbackhandler = new GiveFeedbackEventHandler(DragSource_GiveFeedback);
4021                //this.DragSource.GiveFeedback += feedbackhandler;
4022
4023                // The DragOver event ...
4024                //DragEventHandler draghandler = new DragEventHandler(Window1_DragOver);
4025                //DragScope.PreviewDragOver += draghandler;
4026
4027                DragEventHandler draghandler = new DragEventHandler(Window1_DragOver2);
4028                DragScope.PreviewDragOver += draghandler;
4029                DragScope.PreviewMouseLeftButtonUp += aktuellupdate;
4030
4031                // Drag Leave is optional, but write up explains why I like it ..
4032                //DragEventHandler dragleavehandler = new DragEventHandler(DragScope_DragLeave);
4033                //DragScope.DragLeave += dragleavehandler;
4034
4035                // QueryContinue Drag goes with drag leave...
4036                //QueryContinueDragEventHandler queryhandler = new QueryContinueDragEventHandler(DragScope_QueryContinueDrag);
4037                //DragScope.QueryContinueDrag += queryhandler;
4038                dropBoxCanvas.Children.Remove(rotor);
4039               
4040                //steckerbrett.Children.Insert(Int32.Parse(button.Uid), button2);
4041
4042                //Here we create our adorner..
4043                _adorner = new DragAdorner(DragScope, (UIElement)rotor, true, 1, this.ActualWidth, this.ActualHeight);
4044
4045                _layer = AdornerLayer.GetAdornerLayer(DragScope as Visual);
4046                _layer.Add(_adorner);
4047
4048                //maingrid.AllowDrop = true;
4049               
4050                suc = false;
4051                IsDragging = true;
4052                //_dragHasLeftScope = false;
4053                //Finally lets drag drop
4054                //if (!button.Uid.Equals(button.Content.ToString()))
4055                //  switchbuttons(Int32.Parse(button.Content.ToString()), Int32.Parse(button.Uid));
4056
4057
4058
4059                DataObject data = new DataObject("myFormat", rotor.Uid );
4060                DragDropEffects de = DragDrop.DoDragDrop(mainmainmain, data, DragDropEffects.Move);
4061
4062                if (!suc) 
4063               
4064                {
4065                    dropBoxCanvas.Children.Add(rotor);
4066                    rotorarea.AllowDrop = false;
4067                    dropBoxCanvas.AllowDrop = false;
4068                }
4069
4070                // Clean up our mess :)
4071                DragScope.AllowDrop = previousDrop;
4072                if (_adorner != null)
4073                    AdornerLayer.GetAdornerLayer(DragScope).Remove(_adorner);
4074
4075                _adorner = null;
4076
4077                //           DragSource.GiveFeedback -= feedbackhandler;
4078                //         DragScope.DragLeave -= dragleavehandler;
4079                //       DragScope.QueryContinueDrag -= queryhandler;
4080                DragScope.PreviewDragOver -= draghandler;
4081
4082                //IsDragging = false;
4083
4084
4085                // Initialize the drag & drop operation
4086                //DataObject dragData = new DataObject("myFormat", button.Uid);
4087
4088                //DragDrop.DoDragDrop(button, dragData , DragDropEffects.Move);
4089
4090            }
4091        }
4092
4093        Boolean b = true;
4094        Boolean suc = false;
4095
4096
4097        private void List_Drop(object sender, DragEventArgs e)
4098        {
4099           
4100                //Contact contact = e.Data.GetData("myFormat") as Contact;
4101                //ListView listView = sender as ListView;
4102                //listView.Items.Add(contact);
4103
4104                maingrid.AllowDrop = false;
4105
4106                aktuell = -1;
4107                Button dummy = new Button();
4108
4109                String uID = e.Data.GetData("myFormat") as String;
4110                Button button = sender as Button;
4111                int myInteger1 = Int32.Parse(uID);
4112                int myInteger2 = Int32.Parse(button.Uid);
4113
4114                Debug.Text += " " + myInteger1 + "" + myInteger2;
4115                Debug.Text = "hossa";
4116                if (b && (button.Content.ToString().Equals(button.Uid) || Int32.Parse(button.Content.ToString()).Equals(myInteger1)))
4117                {
4118                    switchbuttons(myInteger1, myInteger2);
4119                }
4120
4121                else if (b && !button.Content.ToString().Equals(button.Uid))
4122                {
4123                    switchbuttons(Int32.Parse(button.Content.ToString()), myInteger2);
4124                    switchbuttons(myInteger1, myInteger2);
4125                }
4126
4127
4128                else
4129                    b = true;
4130
4131                syncPluboardSettings();
4132
4133        }
4134       
4135        private void List_Drop2(object sender, DragEventArgs e)
4136        {
4137                suc = true;   
4138                String uID = e.Data.GetData("myFormat") as String;
4139                Debug.Text = "hello" + uID;
4140
4141                dropBoxCanvas.AllowDrop = false;
4142
4143                int urint = Int32.Parse(uID);
4144            /*
4145                TextBlock tebo = new TextBlock();
4146                tebo.Background = Brushes.LightSkyBlue;
4147                tebo.Height = 100;
4148                tebo.Width = 50;
4149                tebo.TextAlignment = TextAlignment.Center;
4150                tebo.FontSize = 50;
4151                switch (urint)
4152                {
4153                    case 1: tebo.Uid = "1";
4154                        tebo.Text = "I";
4155                        break;
4156                    case 2: tebo.Uid = "2";
4157                        tebo.Text = "II";
4158                        break;
4159                    case 3: tebo.Uid = "3";
4160                        tebo.Text = "III";
4161                        break;
4162                    case 4: tebo.Uid = "4";
4163                        tebo.Text = "IV";
4164                        break;
4165                    case 5: tebo.Uid = "5";
4166                        tebo.Text = "V";
4167                        break;
4168
4169                }
4170                Canvas.SetLeft(tebo, 50 * urint);
4171                dropBoxCanvas.Children.Add(tebo);
4172                tebo.Cursor = Cursors.Hand;
4173                tebo.PreviewMouseMove += Rotor_MouseMove1;*/
4174
4175                Image img = new Image();
4176                img.Height = 100;
4177                img.Width = 50;
4178                BitmapImage bi = new BitmapImage();
4179                bi.BeginInit();
4180                String path = "";
4181                switch (urint)
4182                {
4183                    case 1: img.Uid = "1";
4184                        path = "Images/rotor"+ urint +".jpg";
4185                        rotorimgs[urint-1] = img;
4186                        break;
4187                    case 2: img.Uid = "2";
4188                        path = "Images/rotor" + urint + ".jpg";
4189                        rotorimgs[urint-1] = img;
4190                        break;
4191                    case 3: img.Uid = "3";
4192                        path = "Images/rotor" + urint + ".jpg";
4193                        rotorimgs[urint-1] = img;
4194                        break;
4195                    case 4: img.Uid = "4";
4196                        path = "Images/rotor" + urint + ".jpg";
4197                        rotorimgs[urint-1] = img;
4198                        break;
4199                    case 5: img.Uid = "5";
4200                        path = "Images/rotor" + urint + ".jpg";
4201                        rotorimgs[urint-1] = img;
4202                        break;
4203
4204                }
4205
4206                bi.UriSource = new Uri(path, UriKind.Relative);
4207                bi.EndInit();
4208                img.Source = bi;
4209                dropBoxCanvas.Children.Add(img);
4210                Canvas.SetLeft(img, 50 * urint);
4211               
4212                img.Cursor = Cursors.Hand;
4213                img.PreviewMouseMove += Rotor_MouseMove1;
4214               
4215        }
4216
4217        private void List_Drop21(object sender, DragEventArgs e)
4218        {
4219            suc = true;
4220            String uID = e.Data.GetData("myFormat") as String;
4221            Debug.Text = "hello" + uID;
4222
4223            dropBoxCanvasWalze.AllowDrop = false;
4224            walzenarea.AllowDrop = false;
4225           
4226            int urint = Int32.Parse(uID);
4227            /*
4228            TextBlock tebo = new TextBlock();
4229            tebo.Background = Brushes.LightSkyBlue;
4230            tebo.Height = 100;
4231            tebo.Width = 50;
4232            tebo.TextAlignment = TextAlignment.Center;
4233            tebo.FontSize = 50;
4234           
4235
4236            switch(urint)
4237            {
4238                case 1: tebo.Uid = "1";
4239                    tebo.Text = "A";
4240                    break;
4241                case 2: tebo.Uid = "2";
4242                    tebo.Text = "B";
4243                    break;
4244                case 3: tebo.Uid = "3";
4245                    tebo.Text = "C";
4246                    break;
4247               
4248               
4249            }
4250            Canvas.SetLeft(tebo, 50 * urint);
4251            dropBoxCanvasWalze.Children.Add(tebo);
4252            tebo.Cursor = Cursors.Hand;
4253            tebo.PreviewMouseMove += Walze_MouseMove1;
4254            */
4255            Image img = new Image();
4256                img.Height = 100;
4257                img.Width = 50;
4258                BitmapImage bi = new BitmapImage();
4259                bi.BeginInit();
4260                String path = "";
4261                switch (urint)
4262                {
4263                    case 1: img.Uid = "1";
4264                        path = "Images/rotor" + urint + ".jpg";
4265                        walzeimgs[urint] = img;       
4266                        break;
4267                    case 2: img.Uid = "2";
4268                        path = "Images/rotor" + urint + ".jpg";
4269                        walzeimgs[urint] = img;
4270                        break;
4271                    case 3: img.Uid = "3";
4272                        path = "Images/rotor" + urint + ".jpg";
4273                        walzeimgs[urint] = img;
4274                        break;
4275                }
4276               
4277                bi.UriSource = new Uri(path, UriKind.Relative);
4278                bi.EndInit();
4279                img.Source = bi;
4280                Canvas.SetLeft(img, 50 * urint);
4281                dropBoxCanvasWalze.Children.Add(img);
4282                img.Cursor = Cursors.Hand;
4283                img.PreviewMouseMove += Walze_MouseMove1;
4284        }
4285
4286
4287           
4288        private void List_Drop31(object sender, DragEventArgs e)
4289        {
4290            suc = true;   
4291            rotorarea.AllowDrop = false;
4292
4293            dropBoxCanvas.AllowDrop = false;
4294            String uID = e.Data.GetData("myFormat") as String;
4295            Debug.Text = "hello" + uID;
4296
4297            int urint = Int32.Parse(uID);
4298            Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, settings.Key[1]-65, settings.Ring2);
4299            Canvas.SetLeft(rotor2, 230);
4300            rotorarea.Children.Add(rotor2);
4301            rotor2.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
4302            rotorarray[1] = rotor2;
4303            rotor2.helpNextAnimation += helptoanimate3;
4304            rotor2.helpNextAnimation2 += helptoanimate7;
4305            rotorarea.Children.Remove(dummyrec[1]);
4306            rotor2.fast = speed * 80;
4307            rotor2.Cursor = Cursors.Hand;
4308            rotor2.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
4309        }
4310
4311        private void List_Drop32(object sender, DragEventArgs e)
4312        {
4313            suc = true;   
4314            rotorarea.AllowDrop = false;
4315            dropBoxCanvas.AllowDrop = false;
4316            String uID = e.Data.GetData("myFormat") as String;
4317            Debug.Text = "hello" + uID;
4318     
4319            int urint = Int32.Parse(uID);
4320            Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, settings.Key[2] - 65, settings.Ring3);
4321            Canvas.SetLeft(rotor2, 460);
4322            rotorarea.Children.Add(rotor2);
4323            rotor2.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
4324            rotorarray[2] = rotor2;
4325            rotor2.helpNextAnimation += helptoanimate2;
4326            rotor2.helpNextAnimation2 += helptoanimate8;
4327            rotorarea.Children.Remove(dummyrec[2]);
4328            rotor2.fast = speed * 80;
4329            rotor2.Cursor = Cursors.Hand;
4330            rotor2.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
4331        }
4332
4333        private void List_Drop33(object sender, DragEventArgs e)
4334        {
4335            suc = true;
4336            rotorarea.AllowDrop = false;
4337            dropBoxCanvas.AllowDrop = false;
4338            String uID = e.Data.GetData("myFormat") as String;
4339            Debug.Text = "hello" + uID;
4340
4341            int urint = Int32.Parse(uID);
4342            Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, 0, 0);
4343            Canvas.SetLeft(rotor2, 690);
4344            rotorarea.Children.Add(rotor2);
4345            rotor2.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
4346            rotorarray[3] = rotor2;
4347            rotor2.helpNextAnimation += helptoanimatem4;
4348            rotor2.helpNextAnimation2 += helptoanimatem42;
4349            rotorarea.Children.Remove(dummyrec[3]);
4350            rotor2.fast = speed * 80;
4351            rotor2.Cursor = Cursors.Hand;
4352            rotor2.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
4353        }
4354
4355        private void List_Drop30(object sender, DragEventArgs e)
4356        {
4357            suc = true;   
4358            rotorarea.AllowDrop = false;
4359            dropBoxCanvas.AllowDrop = false;
4360            String uID = e.Data.GetData("myFormat") as String;
4361            Debug.Text = "hello" + uID;
4362
4363            int urint = Int32.Parse(uID);
4364            Rotor2 rotor2 = new Rotor2(urint, this.ActualWidth, this.ActualHeight, settings.Key[0] - 65, settings.Ring1);
4365            Canvas.SetLeft(rotor2, 0);
4366            rotorarea.Children.Add(rotor2);
4367            rotor2.PreviewMouseMove += new MouseEventHandler(Rotor_MouseMove);
4368            rotorarray[0] = rotor2;
4369
4370            rotor2.helpNextAnimation += helptoanimate4;
4371            rotor2.helpNextAnimation2 += helptoanimate6;
4372            rotorarea.Children.Remove(dummyrec[0]);
4373            rotor2.fast = speed * 80;
4374            rotor2.Cursor = Cursors.Hand;
4375            rotor2.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
4376
4377
4378        }
4379       
4380        private void List_Drop4(object sender, DragEventArgs e)
4381        {
4382            suc = true;
4383            walzenarea.AllowDrop = false;
4384            dropBoxCanvasWalze.AllowDrop = false;
4385            String uID = e.Data.GetData("myFormat") as String;
4386            Debug.Text = "hello" + uID;
4387
4388            int urint = Int32.Parse(uID);
4389            Walze walzetmp = new Walze(urint, this.Width, this.Height);
4390            Canvas.SetLeft(walzetmp, 0);
4391            walzenarea.Children.Add(walzetmp);
4392            walzetmp.PreviewMouseMove += new MouseEventHandler(Walze_MouseMove);
4393            Canvas.SetTop(walzetmp, 60);
4394            walze = walzetmp;
4395            walzetmp.helpNextAnimation += helptoanimate5;
4396            walzenarea.Children.Remove(dummyrec[3]);
4397            walzetmp.fast = speed * 80;
4398            walzetmp.Cursor = Cursors.Hand;
4399            walzetmp.PreviewMouseLeftButtonDown += List_PreviewMouseLeftButtonDown;
4400           
4401
4402        }
4403       
4404
4405        private void Help(object sender, EventArgs e)
4406        {
4407           
4408        }
4409
4410       
4411       
4412
4413        private void switchbuttons(int button1, int button2) 
4414        {
4415         
4416           
4417            Button dummy = new Button();
4418            double dummyl ;
4419
4420
4421           
4422           
4423
4424
4425           // Debug.Text += lList[button1].X1 + "" + lList[button2].X1;
4426            /*Storyboard stb = new Storyboard();
4427            Storyboard stb1 = new Storyboard();
4428           
4429            AnimationClock myclock =fadeIn.CreateClock();
4430           
4431
4432
4433
4434            Storyboard.SetTargetName(fadeIn, lList[Int32.Parse(bList[button1].Content.ToString())].Name);
4435            Storyboard.SetTargetProperty(fadeIn,new PropertyPath(Line.OpacityProperty));
4436           
4437            Storyboard.SetTargetName(fadeOut, lList[Int32.Parse(bList[button1].Content.ToString())].Name);
4438            Storyboard.SetTargetProperty(fadeOut, new PropertyPath(Line.OpacityProperty));
4439           
4440             
4441           
4442            stb.Children.Add(fadeOut);
4443           
4444           
4445           
4446            stb.Begin(this, true);
4447            stb.Children.Add(fadeIn);
4448           
4449            stb.BeginTime = new TimeSpan(0, 0, 0, 5);
4450            stb.Begin(this, true);*/
4451            //fadeOut.Completed += new EventHandler(Help);
4452            lList[Int32.Parse(bList[button1].Content.ToString())].BeginAnimation(OpacityProperty,fadeOut);
4453            lList[Int32.Parse(bList[button2].Content.ToString())].BeginAnimation(OpacityProperty, fadeOut);
4454            bList[Int32.Parse(bList[button2].Content.ToString())].BeginAnimation(OpacityProperty, fadeOut);
4455            bList[Int32.Parse(bList[button1].Content.ToString())].BeginAnimation(OpacityProperty, fadeOut);
4456            //Debug.Text="";
4457
4458
4459            int help = switchlist[button1];
4460            switchlist[button1] = switchlist[button2];
4461            switchlist[button2] = help;
4462
4463            for (int i = 0; i < switchlist.Length; i++)
4464            {
4465             //   Debug.Text += i + "" + switchlist[i] + " ";
4466            }
4467
4468            dummyl = lList[Int32.Parse(bList[button1].Content.ToString())].X1;
4469            dummy.Content = bList[button1].Content;
4470            //dummy.Uid = bList[button1].Uid;
4471            //dummy = bList[button1];
4472
4473
4474            //bList[button1] = bList[button2];
4475            lList[Int32.Parse(bList[button1].Content.ToString())].X1 = lList[Int32.Parse(bList[button2].Content.ToString())].X1;
4476            lList[Int32.Parse(bList[button1].Content.ToString())].X2 =15+Int32.Parse(bList[button1].Content.ToString()) * 30;
4477            lList[Int32.Parse(bList[button1].Content.ToString())].Y2 = 200;
4478            bList[button1].Content = bList[button2].Content;
4479            //bList[button1].Uid = bList[button2].Uid;
4480
4481
4482            lList[Int32.Parse(bList[button2].Content.ToString())].X1 = dummyl;
4483            lList[Int32.Parse(bList[button2].Content.ToString())].X2 = 15 + Int32.Parse(bList[button2].Content.ToString()) * 30;
4484            lList[Int32.Parse(bList[button2].Content.ToString())].Y2 = 200;
4485            bList[button2].Content = dummy.Content;
4486            //bList[button2].Uid = dummy.Uid;
4487
4488            fadeIn.Completed += new EventHandler(Help);
4489            lList[Int32.Parse(bList[button1].Content.ToString())].BeginAnimation(OpacityProperty, fadeIn);
4490            lList[Int32.Parse(bList[button2].Content.ToString())].BeginAnimation(OpacityProperty, fadeIn);
4491
4492            bList[Int32.Parse(bList[button1].Content.ToString())].BeginAnimation(OpacityProperty, fadeIn);
4493            bList[Int32.Parse(bList[button2].Content.ToString())].BeginAnimation(OpacityProperty, fadeIn);
4494
4495           // yield return; enumerators move next
4496
4497            b = true;
4498            //bList[button2] = dummy;
4499
4500
4501            //bList[button2].Content = "test";
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        }
4571
4572        private void List_DragEnter(object sender, DragEventArgs e)
4573        {
4574
4575            if (!e.Data.GetDataPresent("String") || sender == e.Source)
4576            {
4577                e.Effects = DragDropEffects.None;
4578               
4579            }
4580
4581        }
4582
4583        private void Window_KeyDown(object sender, KeyEventArgs e)
4584        {
4585
4586        }
4587
4588        //löschen ab hier
4589
4590
4591        private Point _startPoint;
4592        private bool _isDragging;
4593        FrameworkElement _dragScope;
4594        DragAdorner _adorner = null;
4595        AdornerLayer _layer;
4596
4597        public FrameworkElement DragScope
4598        {
4599            get { return _dragScope; }
4600            set { _dragScope = value; }
4601        }
4602
4603        public bool IsDragging
4604        {
4605            get { return _isDragging; }
4606            set { _isDragging = value; }
4607        }
4608
4609        void Window1_DragOver(object sender, DragEventArgs args)
4610        {
4611           
4612            if (_adorner != null)
4613            {
4614                if (aktuell != -1)
4615                {
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 */ ;
4622                }
4623                _adorner.LeftOffset = args.GetPosition(DragScope).X /* - _startPoint.X */ ;
4624                _adorner.TopOffset = args.GetPosition(DragScope).Y /* - _startPoint.Y */ ;
4625               
4626            }
4627        }
4628
4629        void Window1_DragOver2(object sender, DragEventArgs args)
4630        {
4631
4632            if (_adorner != null)
4633            {
4634               
4635                _adorner.LeftOffset = args.GetPosition(DragScope).X /* - _startPoint.X */ ;
4636                _adorner.TopOffset = args.GetPosition(DragScope).Y /* - _startPoint.Y */ ;
4637
4638            }
4639        }
4640
4641        void aktuellupdate(object sender, MouseButtonEventArgs args)
4642        {
4643            aktuell = -1;
4644        }
4645
4646        void DragSource_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
4647        {
4648            _startPoint = e.GetPosition(null);
4649        }
4650
4651        void DragSource_PreviewMouseMove(object sender, MouseEventArgs e)
4652        {
4653            Point position0 = e.GetPosition(null);
4654            lList[0].X2 = position0.X;
4655            lList[0].Y2 = position0.Y;
4656            if (e.LeftButton == MouseButtonState.Pressed && !IsDragging)
4657            {
4658                Point position = e.GetPosition(null);
4659
4660                if (Math.Abs(position.X - _startPoint.X) > SystemParameters.MinimumHorizontalDragDistance ||
4661                    Math.Abs(position.Y - _startPoint.Y) > SystemParameters.MinimumVerticalDragDistance)
4662                {
4663                    // StartDrag(e);
4664                    //  StartDragCustomCursor(e);
4665                    // StartDragWindow(e);
4666                    StartDragInProcAdorner(e);
4667
4668                }
4669            }
4670        }
4671
4672        private void StartDragInProcAdorner(MouseEventArgs e)
4673        {
4674
4675           
4676        }
4677
4678
4679
4680
4681
4682     
4683
4684    }
4685}
Note: See TracBrowser for help on using the repository browser.