Ignore:
Timestamp:
Dec 1, 2009, 3:22:54 PM (12 years ago)
Author:
wiefels
Message:

status-messages added.
restructuring of the code.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Transposition/TranspositionPresentation.xaml.cs

    r930 r933  
    3838                                                       this.ActualHeight / this.Stack.ActualHeight);
    3939        }
    40        
    41 
    42        
     40
     41        #region variables declaration
     42
    4343        private TextBlock[,] teba;
    4444        private int von;
     
    7171        private int[] key;
    7272
     73        #endregion
     74
    7375        /// <summary>
    7476        /// Getter of the Speed the Visualisation is running
     
    133135
    134136            textBox2.Clear();
     137
     138       
     139           
    135140            if (per == 1  )
    136141                {
     
    201206        }
    202207
    203         private void postReadOut()
    204         {
    205             ColorAnimation myColorAnimation = new ColorAnimation();
    206             myColorAnimation.From = Colors.Orange;
    207             myColorAnimation.To = Colors.Transparent;
    208             myColorAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    209             Boolean no = true;
    210 
    211             if (reouta != null)
    212             { 
    213                 SolidColorBrush brush = new SolidColorBrush();
    214                 brush.Color = Colors.Transparent;
    215 
    216                 for (int i = precountup; i < countup1; i++)
    217                 {
    218                    reouta[i].Background = brush;
    219                 }
    220                              
    221                 if (reout == 0)
    222                 {                   
    223                     for (int i = 0; i < permuted_matrix.GetLength(0); i++)
    224                     {
    225                         if (i == permuted_matrix.GetLength(0) - 1 && outcount5 == permuted_matrix.GetLength(1) - 1 && !Stop)
    226                         {
    227                             myColorAnimation.Completed += new EventHandler(the_End);
    228                             no = false;
    229                         }
    230                     }
    231                 }
    232                 else
    233                 {
    234                         for (int i = 0; i < permuted_matrix.GetLength(1); i++)
    235                         {
    236                             if (i == permuted_matrix.GetLength(1) - 1 && outcount5 == permuted_matrix.GetLength(0) - 1 && !Stop)
    237                             {
    238                                 myColorAnimation.Completed += new EventHandler(the_End);
    239                                 no = false;
    240                             }
    241                         }
    242                 }
    243 
    244                 if (no)
    245                 myColorAnimation.Completed += new EventHandler(my_Help7);
    246                 if (!Stop)
    247                     brush.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation);
    248             }
    249         }
    250 
    251         private void preReadOut()
    252         {
    253             ColorAnimation myColorAnimation_green = new ColorAnimation();
    254             myColorAnimation_green.From = Colors.LawnGreen;
    255             myColorAnimation_green.To = Colors.Yellow;
    256             myColorAnimation_green.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    257 
    258             ColorAnimation myColorAnimation_blue = new ColorAnimation();
    259             myColorAnimation_blue.From = Colors.AliceBlue;
    260             myColorAnimation_blue.To = Colors.Yellow;
    261             myColorAnimation_blue.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    262 
    263             SolidColorBrush brush_green = new SolidColorBrush();
    264             SolidColorBrush brush_blue = new SolidColorBrush();
    265 
    266             if (teba != null)
    267             {
    268                 if (reout == 0)
    269                 {                   
    270                     for (int i = rowper; i < teba.GetLength(0); i++)
    271                     {
    272                         if (mat_back[i - rowper, outcount4 - colper] == Brushes.LawnGreen)
    273                             teba[i, outcount4].Background = brush_green;
    274                         else
    275                             teba[i, outcount4].Background = brush_blue;                       
    276                     }                   
    277                         myColorAnimation_green.Completed += new EventHandler(my_Help6);
    278                                        
    279                     if (!Stop)
    280                     {
    281                         brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
    282                         brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
    283                     }
    284                 }
    285                 else
    286                 {                   
    287                     for (int i = colper; i < teba.GetLength(1); i++)
    288                     {
    289                         if (mat_back[outcount4 - rowper, i - colper] == Brushes.LawnGreen)
    290                             teba[outcount4, i].Background = brush_green;
    291                         else
    292                             teba[outcount4, i].Background = brush_blue;
    293                     }
    294                    
    295                         myColorAnimation_blue.Completed += new EventHandler(my_Help6);
    296                     if (!Stop)
    297                     {
    298                         brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
    299                         brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
    300 
    301                     }
    302                 }
    303             }
    304 
    305         }
    306        
    307         public void readout()
    308         {
    309             DoubleAnimation myDoubleAnimation = new DoubleAnimation();
    310             myDoubleAnimation.From = 1.0;
    311             myDoubleAnimation.To = 0.0;
    312             myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001-speed));
    313 
    314             DoubleAnimation fadeIn = new DoubleAnimation();
    315             fadeIn.From = 0.0;
    316             fadeIn.To = 1.0;
    317             fadeIn.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));                 
    318 
    319             if (teba != null)
    320             {
    321                 if (reout == 1)
    322                 {
    323                     for (int i = 0; i < permuted_matrix.GetLength(1); i++)
    324                     {
    325                         if (Convert.ToInt64(permuted_matrix[outcount5, i]) != 0)
    326                             {
    327                                 reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    328                                 countup1++;
    329                             }   
    330                     }
    331 
    332                     for (int i = colper; i < teba.GetLength(1); i++)
    333                     {
    334                         if (i == teba.GetLength(1) - 1 && !Stop)
    335                         {
    336                             myDoubleAnimation.Completed += new EventHandler(my_Help1);
    337                         }
    338                         teba[outcount, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    339 
    340                     }
    341                 }
    342                 else
    343                 {
    344                     for (int i = 0; i < permuted_matrix.GetLength(0); i++)
    345                     {
    346                         if (Convert.ToInt64(permuted_matrix[ i,outcount5]) != 0)
    347                             {
    348                                 reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    349                                 countup1++;
    350                             }                               
    351                     }
    352 
    353                     for (int i = rowper; i < teba.GetLength(0); i++)
    354                     {
    355                         if (i == teba.GetLength(0) - 1 && !Stop)
    356                         {
    357                             myDoubleAnimation.Completed += new EventHandler(my_Help1);
    358                         }
    359                         teba[i, outcount].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    360                     }
    361                 }
    362             }
    363         }
    364         /// <summary>
    365         /// (Insertion Sort) algorithm for sorting the rows OR columns by index during the permutationphase
    366         /// </summary>
    367         /// <param name="i"></param>
    368         public void sort(int i)
    369         {
    370             if (per == 1)
    371             {
    372                 if (teba != null && key != null)
    373                 {
    374                     if (act == 0)
    375                     {
    376                         if (i < teba.GetLength(0) - 1)
    377                         {
    378                             if (Convert.ToInt32(teba[i, 0].Text) != i + 1)
    379                             {
    380                                 int s = 0;
    381                                 for (int ix = i + 1; ix < teba.GetLength(0); ix++)
    382                                 {
    383                                     if (Convert.ToInt32(teba[ix, 0].Text) == i + 1)
    384                                     {
    385                                         s = ix;
    386                                     }
    387                                 }
    388                                 preani(i, s);
    389 
    390                             }
    391                             else
    392                             {
    393                                 schleife++;
    394                                 sort(schleife);
    395                             }
    396 
    397                         }
    398 
    399                         else if (!Stop) { preReadOut(); }
    400                     }
    401                     else
    402                     {
    403                         if (i < teba.GetLength(0) - 1)
    404                         {
    405                             if (Convert.ToInt32(teba[i, 0].Text) != key[i])
    406                             {
    407                                 int s = 0;
    408                                 for (int ix = i + 1; ix < teba.GetLength(0); ix++)
    409                                 {
    410                                     if (Convert.ToInt32(teba[ix, 0].Text) == key[i])
    411                                     {
    412                                         s = ix;
    413                                     }
    414                                 }
    415                                 preani(i, s);
    416 
    417                             }
    418                             else
    419                             {
    420                                 textBox2.Text += key[i];
    421                                 schleife++;
    422                                 sort(schleife);
    423                             }
    424 
    425                         }
    426 
    427                         else if (!Stop) { preReadOut(); }
    428                     }
    429                 }
    430 
    431             }
    432             else
    433             {
    434                 if (teba != null && key != null)
    435                 {
    436                     if (act == 0)
    437                     {
    438                         if (i < teba.GetLength(1) - 1)
    439                         {
    440                             if (Convert.ToInt32(teba[0, i].Text) != i + 1)
    441                             {
    442                                 int s = 0;
    443                                 for (int ix = i + 1; ix < teba.GetLength(1); ix++)
    444                                 {
    445                                     if (Convert.ToInt32(teba[ 0,ix].Text) == i + 1)
    446                                     {
    447                                         s = ix;
    448                                     }
    449                                 }
    450                                 preani(i, s);
    451 
    452                             }
    453                             else
    454                             {
    455                                 schleife++;
    456                                 sort(schleife);
    457                             }
    458 
    459                         }
    460 
    461                         else if (!Stop) { preReadOut(); }
    462                     }
    463                     else
    464                     {
    465                         if (i < teba.GetLength(1) - 1)
    466                         {
    467                             if (Convert.ToInt32(teba[0, i].Text) != key[i])
    468                             {
    469                                 int s = 0;
    470                                 for (int ix = i + 1; ix < teba.GetLength(1); ix++)
    471                                 {
    472                                     if (Convert.ToInt32(teba[ 0,ix].Text) == key[i])
    473                                     {
    474                                         s = ix;
    475                                     }
    476                                 }
    477                                 preani(i, s);
    478 
    479                             }
    480                             else
    481                             {
    482                                 textBox2.Text += key[i];
    483                                 schleife++;
    484                                 sort(schleife);
    485                             }
    486 
    487                         }
    488 
    489                         else if (!Stop) { preReadOut(); }
    490                     }
    491                 }
    492 
    493             }
    494         }
    495         /// <summary>
    496         /// "emergengy break"
    497         /// </summary>
    498         /// <param name="sender"></param>
    499         /// <param name="e"></param>
    500         public void my_Stop(object sender, EventArgs e)
    501         {
    502             myGrid.Children.Clear();
    503             myGrid.ColumnDefinitions.Clear();
    504             myGrid.RowDefinitions.Clear();
    505             mywrap1.Children.Clear();
    506             mywrap2.Children.Clear();
    507            
    508             outcount = 0;           
    509 
    510             schleife = 0;
    511             textBox1.Clear();
    512             textBox2.Clear();
    513             Stop = true;
    514         }
    515 
    516         private void my_Help1(object sender, EventArgs e)
    517         {
    518             outcount++;
    519             if (!Stop)
    520                 postReadOut();
    521         }
    522 
    523         private void my_Help2(object sender, EventArgs e)
    524         {
    525             outcount1++;
    526             if (!Stop)
    527                 postReadIn();
    528         }
    529 
    530         private void my_Help3(object sender, EventArgs e)
    531         {
    532             sizeChanged(this, EventArgs.Empty);
    533            
    534             if (!Stop)
    535             preReadIn();
    536         }
    537        
    538         private void my_Help4(object sender, EventArgs e)
    539         {
    540            
    541             outcount2++;
    542             if (!Stop)
    543             readIn();
    544         }
    545 
    546         private void my_Help7(object sender, EventArgs e)
    547         {
    548             precountup = countup1;
    549            
    550             outcount5++;
    551             if (!Stop)
    552                 preReadOut();
    553         }
    554          
    555         private void my_Help5(object sender, EventArgs e)
    556         {
    557            
    558             outcount3++;
    559             if (!Stop)
    560             preReadIn();
    561         }
    562 
    563         private void my_Help6(object sender, EventArgs e)
    564         {
    565            
    566             outcount4++;
    567             if (!Stop)
    568                 readout();
    569         }
    570 
    571         private void my_Help8(object sender, EventArgs e)
    572         {
    573             ani();
    574         }
    575 
    576         private void my_Help(object sender, EventArgs e)
    577         {
    578             schleife++;
    579             if (!Stop)
    580                postani();
    581         }
    582 
    583         private void my_Help9(object sender, EventArgs e)
    584         {
    585             if (!Stop)
    586                 sort(schleife);
    587         }
    588 
    589         private void my_Help10(object sender, EventArgs e)
    590         {
    591             if (!Stop)
    592                 ani();
    593         }
    594         private void my_Help11(object sender, EventArgs e)
    595         {
    596             if (!Stop)
    597                 postani() ;
    598         }
    599 
    600         private void my_Help12(object sender, EventArgs e)
    601         {
    602             if (!Stop)
    603                 sort(schleife);
    604         }
    605 
    606 
    607         private void the_End(object sender, EventArgs e)
    608         {
    609             Stack.BeginAnimation(OpacityProperty, fadeOut);
    610         }
    611 
    612         private void my_Completed(object sender, EventArgs e)
    613         {
    614             Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    615             {
    616                 if (per == 1)
    617                 {
    618                     if (teba != null)
    619                     {
    620                         for (int i = 0; i < teba.GetLength(1); i++)
    621                         {
    622                             String help = teba[nach, i].Text.ToString();
    623                             teba[nach, i].Text = teba[von, i].Text.ToString();
    624                             teba[von, i].Text = help;
    625 
    626                             TextBlock help1 = new TextBlock();
    627                             help1.Background = teba[nach, i].Background;
    628                             teba[nach, i].Background = teba[von, i].Background;
    629                             teba[von, i].Background = help1.Background;
    630 
    631                             if (i > 1)
    632                             {
    633                                 Brush help2;
    634                                 help2 = mat_back[nach, i - 2];
    635                                 mat_back[nach, i - 2] = mat_back[von, i - 2];
    636                                 mat_back[von, i - 2] = help2;
    637                             }
    638 
    639                         }
    640                     }
    641 
    642                     DoubleAnimation myFadein = new DoubleAnimation();
    643                     myFadein.From = 0.0;
    644                     myFadein.To = 1.0;
    645                     myFadein.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    646 
    647                     if (teba != null)
    648                         for (int i = 0; i < teba.GetLength(1); i++)
    649                         {
    650                             teba[von, i].BeginAnimation(TextBlock.OpacityProperty, myFadein);
    651                             if (i == teba.GetLength(1) - 1 && !Stop)
    652                             {
    653                                 myFadein.Completed += new EventHandler(my_Help);
    654                             }
    655                             teba[nach, i].BeginAnimation(TextBlock.OpacityProperty, myFadein);
    656                         }
    657                 }
    658                 else
    659                 {
    660                    
    661                     if (teba != null)
    662                     {
    663                         for (int i = 0; i < teba.GetLength(0); i++)
    664                         {
    665                            
    666                             String help = teba[ i, nach].Text.ToString();
    667                             teba[i,nach].Text = teba[ i,von].Text.ToString();
    668                             teba[i,von].Text = help;
    669 
    670                             TextBlock help1 = new TextBlock();
    671                             help1.Background = teba[ i,nach].Background;
    672                             teba[i,nach].Background = teba[i,von].Background;
    673                             teba[i,von].Background = help1.Background;
    674 
    675                             if (i > 1)
    676                             {
    677                                 Brush help2;
    678                                 help2 = mat_back[i - 2,nach];
    679                                 mat_back[i - 2,nach] = mat_back[i - 2,von];
    680                                 mat_back[i - 2,von] = help2;
    681                             }
    682 
    683                         }
    684                     }
    685 
    686                     DoubleAnimation myFadein = new DoubleAnimation();
    687                     myFadein.From = 0.0;
    688                     myFadein.To = 1.0;
    689                     myFadein.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    690 
    691                     if (teba != null)
    692                         for (int i = 0; i < teba.GetLength(0); i++)
    693                         {
    694                             teba[i,von].BeginAnimation(TextBlock.OpacityProperty, myFadein);
    695                             if (i == teba.GetLength(0) - 1 && !Stop)
    696                             {
    697                                 myFadein.Completed += new EventHandler(my_Help11);
    698                             }
    699                             teba[ i,nach].BeginAnimation(TextBlock.OpacityProperty, myFadein);
    700                         }
    701                 }
    702             }, null);
    703         }
    704 
    705         public void preani(int von, int nach)
    706         {
    707             this.von = von;
    708             this.nach = nach;
    709            
    710             ColorAnimation myColorAnimation_gy = new ColorAnimation();
    711             myColorAnimation_gy.From = Colors.LawnGreen;
    712             myColorAnimation_gy.To = Colors.Yellow;
    713             myColorAnimation_gy.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    714 
    715             ColorAnimation myColorAnimation_by = new ColorAnimation();
    716             myColorAnimation_by.From = Colors.AliceBlue;
    717             myColorAnimation_by.To = Colors.Yellow;
    718             myColorAnimation_by.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    719 
    720             ColorAnimation myColorAnimation_ty = new ColorAnimation();
    721             myColorAnimation_ty.From = Colors.Transparent;
    722             myColorAnimation_ty.To = Colors.Yellow;
    723             myColorAnimation_ty.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    724 
    725 
    726             SolidColorBrush brush_gy = new SolidColorBrush();
    727             SolidColorBrush brush_by = new SolidColorBrush();
    728             SolidColorBrush brush_ty = new SolidColorBrush();
    729 
    730             ColorAnimation myColorAnimation_go = new ColorAnimation();
    731             myColorAnimation_go.From = Colors.LawnGreen;
    732             myColorAnimation_go.To = Colors.Orange;
    733             myColorAnimation_go.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    734 
    735             ColorAnimation myColorAnimation_bo = new ColorAnimation();
    736             myColorAnimation_bo.From = Colors.AliceBlue;
    737             myColorAnimation_bo.To = Colors.Orange;
    738             myColorAnimation_bo.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    739 
    740             ColorAnimation myColorAnimation_to = new ColorAnimation();
    741             myColorAnimation_to.From = Colors.Transparent;
    742             myColorAnimation_to.To = Colors.Orange;
    743             myColorAnimation_to.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    744 
    745 
    746             SolidColorBrush brush_go = new SolidColorBrush();
    747             SolidColorBrush brush_bo = new SolidColorBrush();
    748             SolidColorBrush brush_to = new SolidColorBrush();
    749 
    750             if (teba != null)
    751                 if (per == 1)
    752                 {
    753                     for (int i = 0; i < teba.GetLength(1); i++)
    754                     {
    755                         if (i > 1)
    756                         {
    757                             if (mat_back[von, i - 2].Equals(Brushes.LawnGreen))
    758                                 teba[von, i].Background = brush_gy;
    759 
    760                             if (mat_back[von, i - 2].Equals(Brushes.AliceBlue))
    761                                 teba[von, i].Background = brush_by;
    762 
    763                             if (mat_back[nach, i - 2].Equals(Brushes.LawnGreen))
    764                                 teba[nach, i].Background = brush_go;
    765 
    766                             if (mat_back[nach, i - 2].Equals(Brushes.AliceBlue))
    767                                 teba[nach, i].Background = brush_bo;
    768 
    769                         }
    770                         else
    771                         {
    772                             teba[von, i].Background = brush_ty;
    773                             teba[nach, i].Background = brush_to;
    774                         }
    775                     }
    776                     myColorAnimation_by.Completed += new EventHandler(my_Help8);
    777             }
    778                 else
    779                 {
    780                     for (int i = 0; i < teba.GetLength(0); i++)
    781                     {
    782                         if (i > 1)
    783                         {
    784                             if (mat_back[ i - 2,von].Equals(Brushes.LawnGreen))
    785                                 teba[i,von].Background = brush_gy;
    786 
    787                             if (mat_back[ i - 2,von].Equals(Brushes.AliceBlue))
    788                                 teba[i,von].Background = brush_by;
    789 
    790                             if (mat_back[ i - 2,nach].Equals(Brushes.LawnGreen))
    791                                 teba[i,nach].Background = brush_go;
    792 
    793                             if (mat_back[ i - 2,nach].Equals(Brushes.AliceBlue))
    794                                 teba[i,nach].Background = brush_bo;
    795 
    796                         }
    797                         else
    798                         {
    799                             teba[i,von].Background = brush_ty;
    800                             teba[i,nach].Background = brush_to;
    801                         }
    802 
    803                     }
    804                     myColorAnimation_by.Completed += new EventHandler(my_Help10);
    805                 }
    806            
    807             brush_ty.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_ty);
    808             brush_gy.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_gy);
    809             brush_to.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_to);
    810             brush_go.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_go);
    811             brush_bo.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_bo);
    812             brush_by.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_by);
    813 
    814         }
    815 
    816         public void postani()
    817        
    818         {
    819             ColorAnimation myColorAnimation_gy = new ColorAnimation();
    820             myColorAnimation_gy.From = Colors.Yellow;
    821             myColorAnimation_gy.To = Colors.LawnGreen;
    822             myColorAnimation_gy.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    823 
    824             ColorAnimation myColorAnimation_by = new ColorAnimation();
    825             myColorAnimation_by.From = Colors.Yellow;
    826             myColorAnimation_by.To = Colors.AliceBlue;
    827             myColorAnimation_by.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    828 
    829             ColorAnimation myColorAnimation_ty = new ColorAnimation();
    830             myColorAnimation_ty.From = Colors.Yellow;
    831             myColorAnimation_ty.To = Colors.Transparent;
    832             myColorAnimation_ty.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    833 
    834 
    835             SolidColorBrush brush_gy = new SolidColorBrush();
    836             SolidColorBrush brush_by = new SolidColorBrush();
    837             SolidColorBrush brush_ty = new SolidColorBrush();
    838 
    839             ColorAnimation myColorAnimation_go = new ColorAnimation();
    840             myColorAnimation_go.From = Colors.Orange;
    841             myColorAnimation_go.To = Colors.LawnGreen;
    842             myColorAnimation_go.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    843 
    844             ColorAnimation myColorAnimation_bo = new ColorAnimation();
    845             myColorAnimation_bo.From = Colors.Orange;
    846             myColorAnimation_bo.To = Colors.AliceBlue;
    847             myColorAnimation_bo.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    848 
    849             ColorAnimation myColorAnimation_to = new ColorAnimation();
    850             myColorAnimation_to.From = Colors.Orange;
    851             myColorAnimation_to.To = Colors.Transparent;
    852             myColorAnimation_to.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    853 
    854 
    855             SolidColorBrush brush_go = new SolidColorBrush();
    856             SolidColorBrush brush_bo = new SolidColorBrush();
    857             SolidColorBrush brush_to = new SolidColorBrush();
    858 
    859             if (teba != null)
    860                 if (per == 1)
    861                 {
    862                     for (int i = 0; i < teba.GetLength(1); i++)
    863                     {
    864                         if (i > 1)
    865                         {
    866                             if (mat_back[nach, i - 2].Equals(Brushes.LawnGreen))
    867                                 teba[nach, i].Background = brush_gy;
    868 
    869                             if (mat_back[nach, i - 2].Equals(Brushes.AliceBlue))
    870                                 teba[nach, i].Background = brush_by;
    871 
    872                             if (mat_back[von, i - 2].Equals(Brushes.LawnGreen))
    873                                 teba[von, i].Background = brush_go;
    874 
    875                             if (mat_back[von, i - 2].Equals(Brushes.AliceBlue))
    876                                 teba[von, i].Background = brush_bo;
    877 
    878                         }
    879                         else
    880                         {
    881                             teba[nach, i].Background = brush_ty;
    882                             teba[von, i].Background = brush_to;
    883                         }
    884                     }
    885                     myColorAnimation_by.Completed += new EventHandler(my_Help9);
    886             }
    887                 else
    888                     {
    889                         for (int i = 0; i < teba.GetLength(0); i++)
    890                         {
    891                             if (i > 1)
    892                             {
    893                                 if (mat_back[i - 2,nach].Equals(Brushes.LawnGreen))
    894                                     teba[i,nach].Background = brush_gy;
    895 
    896                                 if (mat_back[ i - 2,nach].Equals(Brushes.AliceBlue))
    897                                     teba[i,nach].Background = brush_by;
    898 
    899                                 if (mat_back[ i - 2,von].Equals(Brushes.LawnGreen))
    900                                     teba[i,von].Background = brush_go;
    901 
    902                                 if (mat_back[ i - 2,von].Equals(Brushes.AliceBlue))
    903                                     teba[i,von].Background = brush_bo;
    904 
    905                             }
    906                             else
    907                             {
    908                                 teba[i,nach].Background = brush_ty;
    909                                 teba[i,von].Background = brush_to;
    910                             }
    911                         }
    912                         myColorAnimation_by.Completed += new EventHandler(my_Help12);
    913                 }
    914 
    915             brush_ty.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_ty);
    916             brush_gy.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_gy);
    917             brush_to.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_to);
    918             brush_go.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_go);
    919             brush_bo.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_bo);
    920            
    921             brush_by.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_by);
    922 
    923         }
    924 
    925         public void prerowani(int von, int nach)
    926         {
    927             this.von = von;
    928             this.nach = nach;
    929             this.ani();
    930             textBox2.Text = "" + nach;
    931         }
    932         /// <summary>
    933         /// animation being used in the permutationphase while sorting
    934         /// </summary>
    935         /// <param name="von"></param>
    936         /// <param name="nach"></param>
    937         public void ani()
    938         {
    939             DoubleAnimation myDoubleAnimation = new DoubleAnimation();
    940             myDoubleAnimation.From = 1.0;
    941             myDoubleAnimation.To = 0.0;
    942             myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001-speed));
    943 
    944            
    945             if (teba != null)
    946                 if (per == 1)
    947                     for (int i = 0; i < teba.GetLength(1); i++)
    948                     {
    949                         teba[von, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    950                         if (i == teba.GetLength(1) - 1 && !Stop)
    951                         {
    952                             myDoubleAnimation.Completed += new EventHandler(my_Completed);
    953                         }
    954                         teba[nach, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    955                     }
    956 // die folgende ELSE ist abgeändert. ich: ungewiss ihrer absoluten richtigkeit.klappte einmal "zur hälfte" .. lösch' wie du bock hast.
    957                 else
    958                 {
    959                     for (int i = 0; i < teba.GetLength(0); i++)
    960                     {
    961                         teba[i, von].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    962                         if (i == teba.GetLength(0) - 1 && !Stop)
    963                         {
    964                             myDoubleAnimation.Completed += new EventHandler(my_Completed);
    965                         }
    966                         teba[i, nach].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    967                     }
    968                 }
    969         }
    970         /// <summary>
    971         /// coloranimation for the text in the left wrapper to be "eaten out" and getting marked
    972         /// </summary>
    973         public void preReadIn()
    974         {
    975            
    976             ColorAnimation myColorAnimation = new ColorAnimation();
    977             myColorAnimation.From = Colors.Transparent;
    978             myColorAnimation.To = Colors.Orange;
    979             myColorAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    980 
    981             if (reina != null)
    982             {
    983                 SolidColorBrush brush = new SolidColorBrush();
    984                 brush.Color = Colors.Transparent;
    985 
    986                 if (rein == 0)
    987                 {
    988                     for (int i = 0; i < read_in_matrix.GetLength(0); i++)
    989                     {
    990                         if (Convert.ToInt64(read_in_matrix[ i,outcount2]) != 0)
    991                         {
    992                             reina[countup].Background = brush;
    993                             countup++;
    994                         }
    995                     }
    996                 }               
    997                 else
    998                     {
    999                         for (int i = 0; i < read_in_matrix.GetLength(1); i++)
    1000                         {
    1001                             if (Convert.ToInt64(read_in_matrix[outcount2, i]) != 0)
    1002                             {
    1003                                 reina[countup].Background = brush;
    1004                                 countup++;
    1005                             }
    1006                         }
    1007                     }
    1008                 myColorAnimation.Completed += new EventHandler(my_Help4);
    1009                 if (!Stop)
    1010                 brush.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation);               
    1011             }
    1012         }
    1013         /// <summary>
    1014         /// method for fading text out from the left wrapper and fading into the grid (where it's already in but transparent)
    1015         /// </summary>
    1016         public void readIn()
    1017         {
    1018             DoubleAnimation fadeIn = new DoubleAnimation();
    1019             fadeIn.From = 0.0;
    1020             fadeIn.To = 1.0;
    1021             fadeIn.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    1022 
    1023             DoubleAnimation myFadeOut = new DoubleAnimation();
    1024             myFadeOut.From = 1.0;
    1025             myFadeOut.To = 0.0;
    1026             myFadeOut.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    1027 
    1028             for (int i = 0; i < countup; i++)
    1029             {
    1030                     if(reina[i].Opacity!=0.0) 
    1031                     reina[i].BeginAnimation(TextBlock.OpacityProperty, myFadeOut);                 
    1032             }
    1033                 if (teba != null)
    1034                 {
    1035                     if (rein == 0)
    1036                     {
    1037                         for (int i = rowper; i < teba.GetLength(0); i++)
    1038                         {
    1039                             if (i == teba.GetLength(0) - 1 && outcount1 < teba.GetLength(1) - 1 && !Stop)
    1040                             {
    1041                                 fadeIn.Completed += new EventHandler(my_Help2);
    1042                             }
    1043                             teba[i, outcount1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);                           
    1044                             if (i == teba.GetLength(0) - 1 && outcount1 == teba.GetLength(1) - 1 && !Stop)
    1045                             {
    1046                                 postReadIn();
    1047                             }
    1048                         }
    1049                     }
    1050                     else
    1051                     {
    1052                         for (int i = colper; i < teba.GetLength(1); i++)
    1053                         {
    1054                             if (i == teba.GetLength(1) - 1 && outcount1 < teba.GetLength(0) - 1 && !Stop)
    1055                             {
    1056                                 fadeIn.Completed += new EventHandler(my_Help2);
    1057                             }
    1058                             teba[outcount1, i].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    1059                             try
    1060                             {
    1061                                 textBox1.Text = textBox1.Text.Remove(0, 1);
    1062                             }
    1063                             catch (ArgumentOutOfRangeException) { }
    1064                             if (i == teba.GetLength(1) - 1 && outcount1 == teba.GetLength(0) - 1 && !Stop)
    1065                             { postReadIn(); }
    1066                         }
    1067                     }
    1068                 }
    1069         }
    1070 
    1071         public void postReadIn()
    1072         {
    1073             ColorAnimation myColorAnimation_green = new ColorAnimation();
    1074             myColorAnimation_green.From = Colors.Yellow;
    1075             myColorAnimation_green.To = Colors.LawnGreen;
    1076             myColorAnimation_green.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    1077 
    1078             ColorAnimation myColorAnimation_blue = new ColorAnimation();
    1079             myColorAnimation_blue.From = Colors.Yellow;
    1080             myColorAnimation_blue.To = Colors.AliceBlue;
    1081             myColorAnimation_blue.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    1082 
    1083             SolidColorBrush brush_green = new SolidColorBrush();
    1084             SolidColorBrush brush_blue = new SolidColorBrush();
    1085 
    1086             if (teba != null)
    1087             {
    1088                 if (rein == 0)
    1089                 {
    1090                     Boolean no = true;
    1091                     for (int i = rowper; i < teba.GetLength(0); i++)
    1092                     {
    1093                         if (mat_back[i-rowper, outcount3-colper] == Brushes.LawnGreen)
    1094                             teba[i, outcount3].Background = brush_green;
    1095                         else
    1096                             teba[i, outcount3].Background = brush_blue;
    1097                         if (i == teba.GetLength(0) - 1 && outcount3 == teba.GetLength(1) - 1 && !Stop)
    1098                         {
    1099                             sort(schleife);
    1100                             no = false;
    1101                         }
    1102                     }
    1103                     if (no)
    1104                     {
    1105                         myColorAnimation_green.Completed += new EventHandler(my_Help5);                       
    1106                     }
    1107                     if (!Stop)
    1108                     {
    1109                         brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
    1110                         brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
    1111                     }
    1112                 }
    1113                 else
    1114                 {
    1115                     Boolean no = true;
    1116                     for (int i = colper; i < teba.GetLength(1); i++)
    1117                     {
    1118                         if (mat_back[outcount3 - rowper, i - colper] == Brushes.LawnGreen)
    1119                             teba[ outcount3, i].Background = brush_green;
    1120                         else
    1121                             teba[outcount3, i].Background = brush_blue;
    1122                         if (i == teba.GetLength(1) - 1 && outcount3 == teba.GetLength(0) - 1 && !Stop)
    1123                         {
    1124                             sort(schleife);
    1125                             no = false;
    1126                         }
    1127                     }
    1128                     if (no)
    1129                         myColorAnimation_blue.Completed += new EventHandler(my_Help5);
    1130                     if (!Stop)
    1131                     {
    1132                         brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
    1133                         brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
    1134                     }
    1135                 }
    1136             }
    1137         }
     208        #region create
     209
    1138210        /// <summary>
    1139211        /// method for creating the grid
     
    1158230                    mywrap1.Children.Clear();
    1159231                    mywrap2.Children.Clear();
     232
     233                    //OLO
     234                    if (rein == 0) { textBox2.Text = "status: reading in by row"; }
     235                    else { textBox2.Text = "status: reading in by column"; }
     236                   
    1160237                   
    1161238                    teba = new TextBlock[read_in_matrix.GetLength(0) + rowper, read_in_matrix.GetLength(1) + colper];
     
    1354431         , null);
    1355432        }
     433        #endregion
     434
     435        #region readIn
     436
     437        /// <summary>
     438        /// coloranimation for the text in the left wrapper to be "eaten out" and getting marked
     439        /// </summary>
     440        public void preReadIn()
     441        {
     442
     443            ColorAnimation myColorAnimation = new ColorAnimation();
     444            myColorAnimation.From = Colors.Transparent;
     445            myColorAnimation.To = Colors.Orange;
     446            myColorAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     447
     448            if (reina != null)
     449            {
     450                SolidColorBrush brush = new SolidColorBrush();
     451                brush.Color = Colors.Transparent;
     452
     453                if (rein == 0)
     454                {
     455                    for (int i = 0; i < read_in_matrix.GetLength(0); i++)
     456                    {
     457                        if (Convert.ToInt64(read_in_matrix[i, outcount2]) != 0)
     458                        {
     459                            reina[countup].Background = brush;
     460                            countup++;
     461                        }
     462                    }
     463                }
     464                else
     465                {
     466                    for (int i = 0; i < read_in_matrix.GetLength(1); i++)
     467                    {
     468                        if (Convert.ToInt64(read_in_matrix[outcount2, i]) != 0)
     469                        {
     470                            reina[countup].Background = brush;
     471                            countup++;
     472                        }
     473                    }
     474                }
     475                myColorAnimation.Completed += new EventHandler(my_Help4);
     476                if (!Stop)
     477                    brush.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation);
     478            }
     479        }
     480        /// <summary>
     481        /// method for fading text out from the left wrapper and fading into the grid (where it's already in but transparent)
     482        /// </summary>
     483        public void readIn()
     484        {
     485            DoubleAnimation fadeIn = new DoubleAnimation();
     486            fadeIn.From = 0.0;
     487            fadeIn.To = 1.0;
     488            fadeIn.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     489
     490            DoubleAnimation myFadeOut = new DoubleAnimation();
     491            myFadeOut.From = 1.0;
     492            myFadeOut.To = 0.0;
     493            myFadeOut.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     494
     495            for (int i = 0; i < countup; i++)
     496            {
     497                if (reina[i].Opacity != 0.0)
     498                    reina[i].BeginAnimation(TextBlock.OpacityProperty, myFadeOut);
     499            }
     500            if (teba != null)
     501            {
     502                if (rein == 0)
     503                {
     504                    for (int i = rowper; i < teba.GetLength(0); i++)
     505                    {
     506                        if (i == teba.GetLength(0) - 1 && outcount1 < teba.GetLength(1) - 1 && !Stop)
     507                        {
     508                            fadeIn.Completed += new EventHandler(my_Help2);
     509                        }
     510                        teba[i, outcount1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
     511                        if (i == teba.GetLength(0) - 1 && outcount1 == teba.GetLength(1) - 1 && !Stop)
     512                        {
     513                            postReadIn();
     514                        }
     515                    }
     516                }
     517                else
     518                {
     519                    for (int i = colper; i < teba.GetLength(1); i++)
     520                    {
     521                        if (i == teba.GetLength(1) - 1 && outcount1 < teba.GetLength(0) - 1 && !Stop)
     522                        {
     523                            fadeIn.Completed += new EventHandler(my_Help2);
     524                        }
     525                        teba[outcount1, i].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
     526                        try
     527                        {
     528                            textBox1.Text = textBox1.Text.Remove(0, 1);
     529                        }
     530                        catch (ArgumentOutOfRangeException) { }
     531                        if (i == teba.GetLength(1) - 1 && outcount1 == teba.GetLength(0) - 1 && !Stop)
     532                        { postReadIn(); }
     533                    }
     534                }
     535            }
     536        }
     537
     538        public void postReadIn()
     539        {
     540            ColorAnimation myColorAnimation_green = new ColorAnimation();
     541            myColorAnimation_green.From = Colors.Yellow;
     542            myColorAnimation_green.To = Colors.LawnGreen;
     543            myColorAnimation_green.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     544
     545            ColorAnimation myColorAnimation_blue = new ColorAnimation();
     546            myColorAnimation_blue.From = Colors.Yellow;
     547            myColorAnimation_blue.To = Colors.AliceBlue;
     548            myColorAnimation_blue.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     549
     550            SolidColorBrush brush_green = new SolidColorBrush();
     551            SolidColorBrush brush_blue = new SolidColorBrush();
     552
     553            if (teba != null)
     554            {
     555                if (rein == 0)
     556                {
     557                    Boolean no = true;
     558                    for (int i = rowper; i < teba.GetLength(0); i++)
     559                    {
     560                        if (mat_back[i - rowper, outcount3 - colper] == Brushes.LawnGreen)
     561                            teba[i, outcount3].Background = brush_green;
     562                        else
     563                            teba[i, outcount3].Background = brush_blue;
     564                        if (i == teba.GetLength(0) - 1 && outcount3 == teba.GetLength(1) - 1 && !Stop)
     565                        {
     566                            sort(schleife);
     567                            no = false;
     568                        }
     569                    }
     570                    if (no)
     571                    {
     572                        myColorAnimation_green.Completed += new EventHandler(my_Help5);
     573                    }
     574                    if (!Stop)
     575                    {
     576                        brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
     577                        brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
     578                    }
     579                }
     580                else
     581                {
     582                    Boolean no = true;
     583                    for (int i = colper; i < teba.GetLength(1); i++)
     584                    {
     585                        if (mat_back[outcount3 - rowper, i - colper] == Brushes.LawnGreen)
     586                            teba[outcount3, i].Background = brush_green;
     587                        else
     588                            teba[outcount3, i].Background = brush_blue;
     589                        if (i == teba.GetLength(1) - 1 && outcount3 == teba.GetLength(0) - 1 && !Stop)
     590                        {
     591                            sort(schleife);
     592                            no = false;
     593                        }
     594                    }
     595                    if (no)
     596                        myColorAnimation_blue.Completed += new EventHandler(my_Help5);
     597                    if (!Stop)
     598                    {
     599                        brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
     600                        brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
     601                    }
     602                }
     603            }
     604        }
     605
     606        #endregion
     607
     608        #region sorting
     609
     610        /// <summary>
     611        /// (Insertion Sort) algorithm for sorting the rows OR columns by index during the permutationphase
     612        /// </summary>
     613        /// <param name="i"></param>
     614        public void sort(int i)
     615        {
     616            //OLOo
     617            if (per == 0) { textBox2.Text = "status: permuting by row"; }
     618            else { textBox2.Text = "status: permuting by column"; }
     619
     620            if (per == 1)
     621            {
     622                if (teba != null && key != null)
     623                {
     624                    if (act == 0)
     625                    {
     626                        if (i < teba.GetLength(0) - 1)
     627                        {
     628                            if (Convert.ToInt32(teba[i, 0].Text) != i + 1)
     629                            {
     630                                int s = 0;
     631                                for (int ix = i + 1; ix < teba.GetLength(0); ix++)
     632                                {
     633                                    if (Convert.ToInt32(teba[ix, 0].Text) == i + 1)
     634                                    {
     635                                        s = ix;
     636                                    }
     637                                }
     638                                preani(i, s);
     639
     640                            }
     641                            else
     642                            {
     643                                schleife++;
     644                                sort(schleife);
     645                            }
     646
     647                        }
     648
     649                        else if (!Stop) { preReadOut(); }
     650                    }
     651                    else
     652                    {
     653                        if (i < teba.GetLength(0) - 1)
     654                        {
     655                            if (Convert.ToInt32(teba[i, 0].Text) != key[i])
     656                            {
     657                                int s = 0;
     658                                for (int ix = i + 1; ix < teba.GetLength(0); ix++)
     659                                {
     660                                    if (Convert.ToInt32(teba[ix, 0].Text) == key[i])
     661                                    {
     662                                        s = ix;
     663                                    }
     664                                }
     665                                preani(i, s);
     666
     667                            }
     668                            else
     669                            {
     670                                textBox2.Text += key[i];
     671                                schleife++;
     672                                sort(schleife);
     673                            }
     674
     675                        }
     676
     677                        else if (!Stop) { preReadOut(); }
     678                    }
     679                }
     680
     681            }
     682            else
     683            {
     684                if (teba != null && key != null)
     685                {
     686                    if (act == 0)
     687                    {
     688                        if (i < teba.GetLength(1) - 1)
     689                        {
     690                            if (Convert.ToInt32(teba[0, i].Text) != i + 1)
     691                            {
     692                                int s = 0;
     693                                for (int ix = i + 1; ix < teba.GetLength(1); ix++)
     694                                {
     695                                    if (Convert.ToInt32(teba[0, ix].Text) == i + 1)
     696                                    {
     697                                        s = ix;
     698                                    }
     699                                }
     700                                preani(i, s);
     701
     702                            }
     703                            else
     704                            {
     705                                schleife++;
     706                                sort(schleife);
     707                            }
     708
     709                        }
     710
     711                        else if (!Stop) { preReadOut(); }
     712                    }
     713                    else
     714                    {
     715                        if (i < teba.GetLength(1) - 1)
     716                        {
     717                            if (Convert.ToInt32(teba[0, i].Text) != key[i])
     718                            {
     719                                int s = 0;
     720                                for (int ix = i + 1; ix < teba.GetLength(1); ix++)
     721                                {
     722                                    if (Convert.ToInt32(teba[0, ix].Text) == key[i])
     723                                    {
     724                                        s = ix;
     725                                    }
     726                                }
     727                                preani(i, s);
     728
     729                            }
     730                            else
     731                            {
     732                                textBox2.Text += key[i];
     733                                schleife++;
     734                                sort(schleife);
     735                            }
     736
     737                        }
     738
     739                        else if (!Stop) { preReadOut(); }
     740                    }
     741                }
     742
     743            }
     744        }
     745
     746        #endregion
     747
     748        #region readouts
     749
     750        private void postReadOut()
     751        {
     752            ColorAnimation myColorAnimation = new ColorAnimation();
     753            myColorAnimation.From = Colors.Orange;
     754            myColorAnimation.To = Colors.Transparent;
     755            myColorAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     756            Boolean no = true;
     757
     758            if (reouta != null)
     759            { 
     760                SolidColorBrush brush = new SolidColorBrush();
     761                brush.Color = Colors.Transparent;
     762
     763                for (int i = precountup; i < countup1; i++)
     764                {
     765                   reouta[i].Background = brush;
     766                }
     767                             
     768                if (reout == 0)
     769                {                   
     770                    for (int i = 0; i < permuted_matrix.GetLength(0); i++)
     771                    {
     772                        if (i == permuted_matrix.GetLength(0) - 1 && outcount5 == permuted_matrix.GetLength(1) - 1 && !Stop)
     773                        {
     774                            myColorAnimation.Completed += new EventHandler(the_End);
     775                            no = false;
     776                        }
     777                    }
     778                }
     779                else
     780                {
     781                        for (int i = 0; i < permuted_matrix.GetLength(1); i++)
     782                        {
     783                            if (i == permuted_matrix.GetLength(1) - 1 && outcount5 == permuted_matrix.GetLength(0) - 1 && !Stop)
     784                            {
     785                                myColorAnimation.Completed += new EventHandler(the_End);
     786                                no = false;
     787                            }
     788                        }
     789                }
     790
     791                if (no)
     792                myColorAnimation.Completed += new EventHandler(my_Help7);
     793                if (!Stop)
     794                    brush.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation);
     795            }
     796
     797            //OLO hier falsch
     798            //textBox2.Text = "status: accomplished";
     799        }
     800
     801        private void preReadOut()
     802        {
     803            ColorAnimation myColorAnimation_green = new ColorAnimation();
     804            myColorAnimation_green.From = Colors.LawnGreen;
     805            myColorAnimation_green.To = Colors.Yellow;
     806            myColorAnimation_green.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     807
     808            ColorAnimation myColorAnimation_blue = new ColorAnimation();
     809            myColorAnimation_blue.From = Colors.AliceBlue;
     810            myColorAnimation_blue.To = Colors.Yellow;
     811            myColorAnimation_blue.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     812
     813            SolidColorBrush brush_green = new SolidColorBrush();
     814            SolidColorBrush brush_blue = new SolidColorBrush();
     815
     816            if (teba != null)
     817            {
     818                if (reout == 0)
     819                {                   
     820                    for (int i = rowper; i < teba.GetLength(0); i++)
     821                    {
     822                        if (mat_back[i - rowper, outcount4 - colper] == Brushes.LawnGreen)
     823                            teba[i, outcount4].Background = brush_green;
     824                        else
     825                            teba[i, outcount4].Background = brush_blue;                       
     826                    }                   
     827                        myColorAnimation_green.Completed += new EventHandler(my_Help6);
     828                                       
     829                    if (!Stop)
     830                    {
     831                        brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
     832                        brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
     833                    }
     834                }
     835                else
     836                {                   
     837                    for (int i = colper; i < teba.GetLength(1); i++)
     838                    {
     839                        if (mat_back[outcount4 - rowper, i - colper] == Brushes.LawnGreen)
     840                            teba[outcount4, i].Background = brush_green;
     841                        else
     842                            teba[outcount4, i].Background = brush_blue;
     843                    }
     844                   
     845                        myColorAnimation_blue.Completed += new EventHandler(my_Help6);
     846                    if (!Stop)
     847                    {
     848                        brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
     849                        brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
     850
     851                    }
     852                }
     853            }
     854
     855        }
     856       
     857        public void readout()
     858        {
     859            //OLO?
     860            if (reout == 0) { textBox2.Text = "status: reading out by row"; }
     861            else { textBox2.Text = "status: reading out by column"; }
     862
     863            DoubleAnimation myDoubleAnimation = new DoubleAnimation();
     864            myDoubleAnimation.From = 1.0;
     865            myDoubleAnimation.To = 0.0;
     866            myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001-speed));
     867
     868            DoubleAnimation fadeIn = new DoubleAnimation();
     869            fadeIn.From = 0.0;
     870            fadeIn.To = 1.0;
     871            fadeIn.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));                 
     872
     873            if (teba != null)
     874            {
     875                if (reout == 1)
     876                {
     877                    for (int i = 0; i < permuted_matrix.GetLength(1); i++)
     878                    {
     879                        if (Convert.ToInt64(permuted_matrix[outcount5, i]) != 0)
     880                            {
     881                                reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
     882                                countup1++;
     883                            }   
     884                    }
     885
     886                    for (int i = colper; i < teba.GetLength(1); i++)
     887                    {
     888                        if (i == teba.GetLength(1) - 1 && !Stop)
     889                        {
     890                            myDoubleAnimation.Completed += new EventHandler(my_Help1);
     891                        }
     892                        teba[outcount, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     893
     894                    }
     895                }
     896                else
     897                {
     898                    for (int i = 0; i < permuted_matrix.GetLength(0); i++)
     899                    {
     900                        if (Convert.ToInt64(permuted_matrix[ i,outcount5]) != 0)
     901                            {
     902                                reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
     903                                countup1++;
     904                            }                               
     905                    }
     906
     907                    for (int i = rowper; i < teba.GetLength(0); i++)
     908                    {
     909                        if (i == teba.GetLength(0) - 1 && !Stop)
     910                        {
     911                            myDoubleAnimation.Completed += new EventHandler(my_Help1);
     912                        }
     913                        teba[i, outcount].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     914                    }
     915                }
     916            }       
     917        }
     918
     919        #endregion
     920
     921        #region events
     922
     923        /// <summary>
     924        /// "emergengy break"
     925        /// </summary>
     926        /// <param name="sender"></param>
     927        /// <param name="e"></param>
     928        public void my_Stop(object sender, EventArgs e)
     929        {
     930            myGrid.Children.Clear();
     931            myGrid.ColumnDefinitions.Clear();
     932            myGrid.RowDefinitions.Clear();
     933            mywrap1.Children.Clear();
     934            mywrap2.Children.Clear();
     935           
     936            outcount = 0;           
     937
     938            schleife = 0;
     939            textBox1.Clear();
     940            textBox2.Clear();
     941            Stop = true;
     942        }
     943
     944        private void my_Help1(object sender, EventArgs e)
     945        {
     946            outcount++;
     947            if (!Stop)
     948                postReadOut();
     949        }
     950
     951        private void my_Help2(object sender, EventArgs e)
     952        {
     953            outcount1++;
     954            if (!Stop)
     955                postReadIn();
     956        }
     957
     958        private void my_Help3(object sender, EventArgs e)
     959        {
     960            sizeChanged(this, EventArgs.Empty);
     961           
     962            if (!Stop)
     963            preReadIn();
     964        }
     965       
     966        private void my_Help4(object sender, EventArgs e)
     967        {
     968           
     969            outcount2++;
     970            if (!Stop)
     971            readIn();
     972        }
     973
     974        private void my_Help7(object sender, EventArgs e)
     975        {
     976            precountup = countup1;
     977           
     978            outcount5++;
     979            if (!Stop)
     980                preReadOut();
     981        }
     982         
     983        private void my_Help5(object sender, EventArgs e)
     984        {
     985           
     986            outcount3++;
     987            if (!Stop)
     988            preReadIn();
     989        }
     990
     991        private void my_Help6(object sender, EventArgs e)
     992        {
     993           
     994            outcount4++;
     995            if (!Stop)
     996                readout();
     997        }
     998
     999        private void my_Help8(object sender, EventArgs e)
     1000        {
     1001            ani();
     1002        }
     1003
     1004        private void my_Help(object sender, EventArgs e)
     1005        {
     1006            schleife++;
     1007            if (!Stop)
     1008               postani();
     1009        }
     1010
     1011        private void my_Help9(object sender, EventArgs e)
     1012        {
     1013            if (!Stop)
     1014                sort(schleife);
     1015        }
     1016
     1017        private void my_Help10(object sender, EventArgs e)
     1018        {
     1019            if (!Stop)
     1020                ani();
     1021        }
     1022        private void my_Help11(object sender, EventArgs e)
     1023        {
     1024            if (!Stop)
     1025                postani() ;
     1026        }
     1027
     1028        private void my_Help12(object sender, EventArgs e)
     1029        {
     1030            if (!Stop)
     1031                sort(schleife);
     1032        }
     1033
     1034
     1035        private void the_End(object sender, EventArgs e)
     1036        {
     1037            Stack.BeginAnimation(OpacityProperty, fadeOut);
     1038        }
     1039
     1040        private void my_Completed(object sender, EventArgs e)
     1041        {
     1042            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     1043            {
     1044                if (per == 1)
     1045                {
     1046                    if (teba != null)
     1047                    {
     1048                        for (int i = 0; i < teba.GetLength(1); i++)
     1049                        {
     1050                            String help = teba[nach, i].Text.ToString();
     1051                            teba[nach, i].Text = teba[von, i].Text.ToString();
     1052                            teba[von, i].Text = help;
     1053
     1054                            TextBlock help1 = new TextBlock();
     1055                            help1.Background = teba[nach, i].Background;
     1056                            teba[nach, i].Background = teba[von, i].Background;
     1057                            teba[von, i].Background = help1.Background;
     1058
     1059                            if (i > 1)
     1060                            {
     1061                                Brush help2;
     1062                                help2 = mat_back[nach, i - 2];
     1063                                mat_back[nach, i - 2] = mat_back[von, i - 2];
     1064                                mat_back[von, i - 2] = help2;
     1065                            }
     1066
     1067                        }
     1068                    }
     1069
     1070                    DoubleAnimation myFadein = new DoubleAnimation();
     1071                    myFadein.From = 0.0;
     1072                    myFadein.To = 1.0;
     1073                    myFadein.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1074
     1075                    if (teba != null)
     1076                        for (int i = 0; i < teba.GetLength(1); i++)
     1077                        {
     1078                            teba[von, i].BeginAnimation(TextBlock.OpacityProperty, myFadein);
     1079                            if (i == teba.GetLength(1) - 1 && !Stop)
     1080                            {
     1081                                myFadein.Completed += new EventHandler(my_Help);
     1082                            }
     1083                            teba[nach, i].BeginAnimation(TextBlock.OpacityProperty, myFadein);
     1084                        }
     1085                }
     1086                else
     1087                {
     1088                   
     1089                    if (teba != null)
     1090                    {
     1091                        for (int i = 0; i < teba.GetLength(0); i++)
     1092                        {
     1093                           
     1094                            String help = teba[ i, nach].Text.ToString();
     1095                            teba[i,nach].Text = teba[ i,von].Text.ToString();
     1096                            teba[i,von].Text = help;
     1097
     1098                            TextBlock help1 = new TextBlock();
     1099                            help1.Background = teba[ i,nach].Background;
     1100                            teba[i,nach].Background = teba[i,von].Background;
     1101                            teba[i,von].Background = help1.Background;
     1102
     1103                            if (i > 1)
     1104                            {
     1105                                Brush help2;
     1106                                help2 = mat_back[i - 2,nach];
     1107                                mat_back[i - 2,nach] = mat_back[i - 2,von];
     1108                                mat_back[i - 2,von] = help2;
     1109                            }
     1110
     1111                        }
     1112                    }
     1113
     1114                    DoubleAnimation myFadein = new DoubleAnimation();
     1115                    myFadein.From = 0.0;
     1116                    myFadein.To = 1.0;
     1117                    myFadein.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1118
     1119                    if (teba != null)
     1120                        for (int i = 0; i < teba.GetLength(0); i++)
     1121                        {
     1122                            teba[i,von].BeginAnimation(TextBlock.OpacityProperty, myFadein);
     1123                            if (i == teba.GetLength(0) - 1 && !Stop)
     1124                            {
     1125                                myFadein.Completed += new EventHandler(my_Help11);
     1126                            }
     1127                            teba[ i,nach].BeginAnimation(TextBlock.OpacityProperty, myFadein);
     1128                        }
     1129                }
     1130            }, null);
     1131        }
     1132
     1133        #endregion
     1134
     1135        #region animations   
     1136       
     1137        public void preani(int von, int nach)
     1138        {
     1139            this.von = von;
     1140            this.nach = nach;
     1141           
     1142            ColorAnimation myColorAnimation_gy = new ColorAnimation();
     1143            myColorAnimation_gy.From = Colors.LawnGreen;
     1144            myColorAnimation_gy.To = Colors.Yellow;
     1145            myColorAnimation_gy.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1146
     1147            ColorAnimation myColorAnimation_by = new ColorAnimation();
     1148            myColorAnimation_by.From = Colors.AliceBlue;
     1149            myColorAnimation_by.To = Colors.Yellow;
     1150            myColorAnimation_by.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1151
     1152            ColorAnimation myColorAnimation_ty = new ColorAnimation();
     1153            myColorAnimation_ty.From = Colors.Transparent;
     1154            myColorAnimation_ty.To = Colors.Yellow;
     1155            myColorAnimation_ty.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1156
     1157
     1158            SolidColorBrush brush_gy = new SolidColorBrush();
     1159            SolidColorBrush brush_by = new SolidColorBrush();
     1160            SolidColorBrush brush_ty = new SolidColorBrush();
     1161
     1162            ColorAnimation myColorAnimation_go = new ColorAnimation();
     1163            myColorAnimation_go.From = Colors.LawnGreen;
     1164            myColorAnimation_go.To = Colors.Orange;
     1165            myColorAnimation_go.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1166
     1167            ColorAnimation myColorAnimation_bo = new ColorAnimation();
     1168            myColorAnimation_bo.From = Colors.AliceBlue;
     1169            myColorAnimation_bo.To = Colors.Orange;
     1170            myColorAnimation_bo.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1171
     1172            ColorAnimation myColorAnimation_to = new ColorAnimation();
     1173            myColorAnimation_to.From = Colors.Transparent;
     1174            myColorAnimation_to.To = Colors.Orange;
     1175            myColorAnimation_to.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1176
     1177
     1178            SolidColorBrush brush_go = new SolidColorBrush();
     1179            SolidColorBrush brush_bo = new SolidColorBrush();
     1180            SolidColorBrush brush_to = new SolidColorBrush();
     1181
     1182            if (teba != null)
     1183                if (per == 1)
     1184                {
     1185                    for (int i = 0; i < teba.GetLength(1); i++)
     1186                    {
     1187                        if (i > 1)
     1188                        {
     1189                            if (mat_back[von, i - 2].Equals(Brushes.LawnGreen))
     1190                                teba[von, i].Background = brush_gy;
     1191
     1192                            if (mat_back[von, i - 2].Equals(Brushes.AliceBlue))
     1193                                teba[von, i].Background = brush_by;
     1194
     1195                            if (mat_back[nach, i - 2].Equals(Brushes.LawnGreen))
     1196                                teba[nach, i].Background = brush_go;
     1197
     1198                            if (mat_back[nach, i - 2].Equals(Brushes.AliceBlue))
     1199                                teba[nach, i].Background = brush_bo;
     1200
     1201                        }
     1202                        else
     1203                        {
     1204                            teba[von, i].Background = brush_ty;
     1205                            teba[nach, i].Background = brush_to;
     1206                        }
     1207                    }
     1208                    myColorAnimation_by.Completed += new EventHandler(my_Help8);
     1209            }
     1210                else
     1211                {
     1212                    for (int i = 0; i < teba.GetLength(0); i++)
     1213                    {
     1214                        if (i > 1)
     1215                        {
     1216                            if (mat_back[ i - 2,von].Equals(Brushes.LawnGreen))
     1217                                teba[i,von].Background = brush_gy;
     1218
     1219                            if (mat_back[ i - 2,von].Equals(Brushes.AliceBlue))
     1220                                teba[i,von].Background = brush_by;
     1221
     1222                            if (mat_back[ i - 2,nach].Equals(Brushes.LawnGreen))
     1223                                teba[i,nach].Background = brush_go;
     1224
     1225                            if (mat_back[ i - 2,nach].Equals(Brushes.AliceBlue))
     1226                                teba[i,nach].Background = brush_bo;
     1227
     1228                        }
     1229                        else
     1230                        {
     1231                            teba[i,von].Background = brush_ty;
     1232                            teba[i,nach].Background = brush_to;
     1233                        }
     1234
     1235                    }
     1236                    myColorAnimation_by.Completed += new EventHandler(my_Help10);
     1237                }
     1238           
     1239            brush_ty.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_ty);
     1240            brush_gy.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_gy);
     1241            brush_to.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_to);
     1242            brush_go.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_go);
     1243            brush_bo.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_bo);
     1244            brush_by.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_by);
     1245
     1246        }
     1247
     1248        public void postani()
     1249       
     1250        {
     1251            ColorAnimation myColorAnimation_gy = new ColorAnimation();
     1252            myColorAnimation_gy.From = Colors.Yellow;
     1253            myColorAnimation_gy.To = Colors.LawnGreen;
     1254            myColorAnimation_gy.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1255
     1256            ColorAnimation myColorAnimation_by = new ColorAnimation();
     1257            myColorAnimation_by.From = Colors.Yellow;
     1258            myColorAnimation_by.To = Colors.AliceBlue;
     1259            myColorAnimation_by.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1260
     1261            ColorAnimation myColorAnimation_ty = new ColorAnimation();
     1262            myColorAnimation_ty.From = Colors.Yellow;
     1263            myColorAnimation_ty.To = Colors.Transparent;
     1264            myColorAnimation_ty.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1265
     1266
     1267            SolidColorBrush brush_gy = new SolidColorBrush();
     1268            SolidColorBrush brush_by = new SolidColorBrush();
     1269            SolidColorBrush brush_ty = new SolidColorBrush();
     1270
     1271            ColorAnimation myColorAnimation_go = new ColorAnimation();
     1272            myColorAnimation_go.From = Colors.Orange;
     1273            myColorAnimation_go.To = Colors.LawnGreen;
     1274            myColorAnimation_go.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1275
     1276            ColorAnimation myColorAnimation_bo = new ColorAnimation();
     1277            myColorAnimation_bo.From = Colors.Orange;
     1278            myColorAnimation_bo.To = Colors.AliceBlue;
     1279            myColorAnimation_bo.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1280
     1281            ColorAnimation myColorAnimation_to = new ColorAnimation();
     1282            myColorAnimation_to.From = Colors.Orange;
     1283            myColorAnimation_to.To = Colors.Transparent;
     1284            myColorAnimation_to.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     1285
     1286
     1287            SolidColorBrush brush_go = new SolidColorBrush();
     1288            SolidColorBrush brush_bo = new SolidColorBrush();
     1289            SolidColorBrush brush_to = new SolidColorBrush();
     1290
     1291            if (teba != null)
     1292                if (per == 1)
     1293                {
     1294                    for (int i = 0; i < teba.GetLength(1); i++)
     1295                    {
     1296                        if (i > 1)
     1297                        {
     1298                            if (mat_back[nach, i - 2].Equals(Brushes.LawnGreen))
     1299                                teba[nach, i].Background = brush_gy;
     1300
     1301                            if (mat_back[nach, i - 2].Equals(Brushes.AliceBlue))
     1302                                teba[nach, i].Background = brush_by;
     1303
     1304                            if (mat_back[von, i - 2].Equals(Brushes.LawnGreen))
     1305                                teba[von, i].Background = brush_go;
     1306
     1307                            if (mat_back[von, i - 2].Equals(Brushes.AliceBlue))
     1308                                teba[von, i].Background = brush_bo;
     1309
     1310                        }
     1311                        else
     1312                        {
     1313                            teba[nach, i].Background = brush_ty;
     1314                            teba[von, i].Background = brush_to;
     1315                        }
     1316                    }
     1317                    myColorAnimation_by.Completed += new EventHandler(my_Help9);
     1318            }
     1319                else
     1320                    {
     1321                        for (int i = 0; i < teba.GetLength(0); i++)
     1322                        {
     1323                            if (i > 1)
     1324                            {
     1325                                if (mat_back[i - 2,nach].Equals(Brushes.LawnGreen))
     1326                                    teba[i,nach].Background = brush_gy;
     1327
     1328                                if (mat_back[ i - 2,nach].Equals(Brushes.AliceBlue))
     1329                                    teba[i,nach].Background = brush_by;
     1330
     1331                                if (mat_back[ i - 2,von].Equals(Brushes.LawnGreen))
     1332                                    teba[i,von].Background = brush_go;
     1333
     1334                                if (mat_back[ i - 2,von].Equals(Brushes.AliceBlue))
     1335                                    teba[i,von].Background = brush_bo;
     1336
     1337                            }
     1338                            else
     1339                            {
     1340                                teba[i,nach].Background = brush_ty;
     1341                                teba[i,von].Background = brush_to;
     1342                            }
     1343                        }
     1344                        myColorAnimation_by.Completed += new EventHandler(my_Help12);
     1345                }
     1346
     1347            brush_ty.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_ty);
     1348            brush_gy.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_gy);
     1349            brush_to.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_to);
     1350            brush_go.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_go);
     1351            brush_bo.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_bo);
     1352           
     1353            brush_by.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_by);
     1354
     1355        }
     1356
     1357        public void prerowani(int von, int nach)
     1358        {
     1359            this.von = von;
     1360            this.nach = nach;
     1361            this.ani();
     1362            textBox2.Text = "" + nach;
     1363        }
     1364        /// <summary>
     1365        /// animation being used in the permutationphase while sorting
     1366        /// </summary>
     1367        /// <param name="von"></param>
     1368        /// <param name="nach"></param>
     1369        public void ani()
     1370        {
     1371            DoubleAnimation myDoubleAnimation = new DoubleAnimation();
     1372            myDoubleAnimation.From = 1.0;
     1373            myDoubleAnimation.To = 0.0;
     1374            myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001-speed));
     1375
     1376           
     1377            if (teba != null)
     1378                if (per == 1)
     1379                    for (int i = 0; i < teba.GetLength(1); i++)
     1380                    {
     1381                        teba[von, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     1382                        if (i == teba.GetLength(1) - 1 && !Stop)
     1383                        {
     1384                            myDoubleAnimation.Completed += new EventHandler(my_Completed);
     1385                        }
     1386                        teba[nach, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     1387                    }
     1388// die folgende ELSE ist abgeändert. ich: ungewiss ihrer absoluten richtigkeit.klappte einmal "zur hälfte" .. lösch' wie du bock hast.
     1389                else
     1390                {
     1391                    for (int i = 0; i < teba.GetLength(0); i++)
     1392                    {
     1393                        teba[i, von].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     1394                        if (i == teba.GetLength(0) - 1 && !Stop)
     1395                        {
     1396                            myDoubleAnimation.Completed += new EventHandler(my_Completed);
     1397                        }
     1398                        teba[i, nach].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     1399                    }
     1400                }
     1401        }
     1402
     1403        #endregion
     1404
     1405   
     1406       
    13561407    }
    13571408}
Note: See TracChangeset for help on using the changeset viewer.