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

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

EnigmaPresentation Settings synchronisation and start on play update and bugfixes, Pictures updated as .png, Rotor2 synchronisation update, Reflector bugfix

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