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

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

Enigma Presentation first implementation attempt.

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