Ignore:
Timestamp:
Jan 20, 2010, 2:32:17 PM (12 years ago)
Author:
wiefels
Message:

transosition presentation code was cleaned

File:
1 edited

Legend:

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

    r1065 r1096  
    2424    {
    2525
    26         public event EventHandler feuerEnde;
     26        public event EventHandler feuerEnde; //for granting Transposition to fire output after Presentation has finished
    2727        public event EventHandler updateProgress;
    2828        /// <summary>
     
    3333            InitializeComponent();
    3434            SizeChanged += sizeChanged;
    35 
    36         }
    37 
    38        
    39 
     35        }
     36        /// <summary>
     37        /// making the presentation scalable
     38        /// </summary>
     39        /// <param name="sender"></param>
     40        /// <param name="eventArgs"></param>
    4041        public void sizeChanged(Object sender, EventArgs eventArgs)
    4142        {
    4243            this.Stack.RenderTransform = new ScaleTransform(this.ActualWidth / this.Stack.ActualWidth,
    43                                                        this.ActualHeight / this.Stack.ActualHeight);
    44         }
    45 
    46         #region variables declaration
     44                                                            this.ActualHeight / this.Stack.ActualHeight);
     45        }
     46
     47        #region declarating variables
    4748
    4849        private TextBlock[,] teba;
     
    7374        private byte[,] permuted_matrix;
    7475        private Brush[,] mat_back;
    75         //private ColorAnimation backFlip;
    7676        private DoubleAnimation nop;
    7777        private DoubleAnimation fadeIn;
     
    7979        private int[] key;
    8080        public int progress;
    81 
     81       
    8282        #endregion
    8383
     84        #region main
    8485        /// <summary>
    85         /// Getter of the Speed the Visualisation is running
     86        /// main method calling init + create, while keeping the scalability and abortability
    8687        /// </summary>
    87         /// <param name="speed"></param>
    88         public void UpdateSpeed(int speed)
    89         {
    90             this.speed = speed;
    91         }
    92 
     88        /// <param name="read_in_matrix"></param>
     89        /// <param name="permuted_matrix"></param>
     90        /// <param name="key"></param>
     91        /// <param name="keyword"></param>
     92        /// <param name="input"></param>
     93        /// <param name="output"></param>
     94        /// <param name="per"></param>
     95        /// <param name="rein"></param>
     96        /// <param name="reout"></param>
     97        /// <param name="act"></param>
     98        /// <param name="number"></param>
     99        public void main(byte[,] read_in_matrix, byte[,] permuted_matrix, int[] key, String keyword, byte[] input, byte[] output, int per, int rein, int reout, int act, int number)
     100        {
     101            this.my_Stop(this, EventArgs.Empty);
     102            if (keyword != null && input != null)
     103            {
     104                schleife = 0;
     105                init(read_in_matrix, permuted_matrix, keyword, per, rein, reout, act, key, number);
     106                create(read_in_matrix, permuted_matrix, key, keyword, input, output);
     107                sizeChanged(this, EventArgs.Empty);
     108            }
     109        }
     110        #endregion
     111
     112        #region init
    93113        /// <summary>
    94         /// Initialisation of all Params the Visualisation needs from the Caller
     114        /// initialisation of all params the visualisation needs from the caller
    95115        /// </summary>
    96116        /// <param name="read_in_matrix"></param>
     
    102122        private void init(byte[,] read_in_matrix, byte[,] permuted_matrix, String keyword, int per, int rein, int reout, int act, int[] key,int number)
    103123        {
    104             //background being created
     124            //background color being created
    105125            GradientStop gs = new GradientStop();
    106126            LinearGradientBrush myBrush = new LinearGradientBrush();
     
    108128            myBrush.GradientStops.Add(new GradientStop(Colors.Pink, 0.5));
    109129            myBrush.GradientStops.Add(new GradientStop(Colors.PaleVioletRed, 0.0));
    110                      
    111130            mycanvas.Background = myBrush;
    112 
     131           
     132            //cleaning the display for new presentation
    113133            try
    114134            {
     
    116136                mainGrid.Children.Add(mywrap1);
    117137                mainGrid.Children.Add(myGrid);
    118 
    119138            }
    120139            catch { }
    121140            mainGrid.Children.Add(mywrap2);
     141
     142            #region animation declarations
    122143            DoubleAnimation fadeIn = new DoubleAnimation();
    123144            fadeIn.From = 0.0;
     
    134155            nop.To = 0.0;
    135156            nop.Duration = new Duration(TimeSpan.FromMilliseconds((1001 - speed)));
    136                        
     157            #endregion
     158
    137159            if (act == 0)
    138160            {
     
    163185            if (keyword == null)
    164186                Stop = true;
    165 
    166187            textBox2.Clear();
    167188
    168189            if (per == 1)
    169190            {
    170 
    171191                rowper = 0;
    172192                colper = 2;
     
    175195                else
    176196                    outcount = 2;
    177 
    178197                if (this.reout == 1)
    179198                    outcount4 = 0;
    180199                else
    181200                    outcount4 = 2;
    182 
    183201                if (this.rein == 1)
    184202                    outcount1 = 0;
    185203                else
    186204                    outcount1 = 2;
    187 
    188205                if (this.rein == 1)
    189206                    outcount3 = 0;
    190 
    191207                else
    192208                    outcount3 = 2;
     
    196212                rowper = 2;
    197213                colper = 0;
    198 
    199214                if (this.reout == 1)
    200215                    outcount = 2;
    201216                else
    202217                    outcount = 0;
    203 
    204218                if (this.reout == 1)
    205219                    outcount4 = 2;
    206220                else
    207221                    outcount4 = 0;
    208 
    209222                if (this.rein == 1)
    210223                    outcount1 = 2;
    211224                else
    212225                    outcount1 = 0;
    213 
    214226                if (this.rein == 1)
    215227                    outcount3 = 2;
     
    218230            }
    219231        }
    220 
    221         public void main(byte[,] read_in_matrix, byte[,] permuted_matrix, int[] key, String keyword, byte[] input, byte[] output, int per, int rein, int reout, int act,int number)
    222         {
    223 
    224             //Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    225             //{
    226                 this.my_Stop(this, EventArgs.Empty);
    227                 if (keyword != null && input != null)
    228                 {
    229                     schleife = 0;
    230                     init(read_in_matrix, permuted_matrix, keyword, per, rein, reout, act, key, number);
    231                     create(read_in_matrix, permuted_matrix, key, keyword, input, output);
    232                     sizeChanged(this, EventArgs.Empty);
    233                 }
    234             //}, null);
    235         }
    236 
     232        #endregion
     233       
    237234        #region create
    238235
     
    247244        /// <param name="output"></param>
    248245        public void create(byte[,] read_in_matrix, byte[,] permuted_matrix, int[] key, String keyword, byte[] input, byte[] output)
    249         {
    250            
     246        {   
    251247                if (read_in_matrix != null && key != null)
    252                 {
     248                {//clearing display
    253249                    myGrid.Children.Clear();
    254250                    myGrid.RowDefinitions.Clear();
     
    261257                    label1.Width = 20;
    262258                    label2.Width = 20;
    263 
    264259                    textBox1.Clear();
    265260                    textBox2.Clear();
    266261                    mywrap1.Children.Clear();
    267262                    mywrap2.Children.Clear();
    268 
    269                    
     263                    //statusbar at the left bottom
    270264                    if (rein == 0) { textBox2.Text = "reading in by row"; }
    271265                    else { textBox2.Text = "reading in by column"; }
    272266
    273 
    274267                    teba = new TextBlock[read_in_matrix.GetLength(0) + rowper, read_in_matrix.GetLength(1) + colper];
    275268
     
    282275                        myGrid.RowDefinitions.Add(new RowDefinition());
    283276                    }
    284 
    285277                    for (int i = 0; i < key.Length; i++)
    286278                    {
     
    296288                        txt.TextAlignment = TextAlignment.Center;
    297289                        txt.Width = 17;
    298                         // txt.Opacity = 0.0;
    299 
    300290                        if (per == 1)
    301291                        {
     
    304294                            myGrid.Children.Add(txt);
    305295                            teba[i, 0] = txt;
    306                             //teba[i, 0].BeginAnimation(TextBlock.OpacityProperty,fadeIn);                           
    307296                        }
    308297                        else
     
    312301                            myGrid.Children.Add(txt);
    313302                            teba[0, i] = txt;
    314                             //teba[0, i].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    315                         }
    316                     }
    317 
     303                        }
     304                    }
     305                    //getting the order of transposition from the keyword or by direct input with commas
    318306                    if (keyword != null)
    319307                    {
     
    323311                        if (!keyword.Contains(','))
    324312                            for (int i = 0; i < key.Length; i++)
    325                             {
     313                            {//writing values into the grid
    326314                                TextBlock txt = new TextBlock();
    327315                                txt.VerticalAlignment = VerticalAlignment.Center;
     
    331319                                txt.TextAlignment = TextAlignment.Center;
    332320                                txt.Width = 17;
    333 
     321               
    334322                                if (per == 1)
    335323                                {
     
    338326                                    myGrid.Children.Add(txt);
    339327                                    teba[i, 1] = txt;
    340                                     //teba[i, 1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    341328                                }
    342329                                else
     
    346333                                    myGrid.Children.Add(txt);
    347334                                    teba[1, i] = txt;
    348                                     //teba[1, i].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    349335                                }
    350336                            }
     
    362348                                    myGrid.Children.Add(txt);
    363349                                    teba[i, 1] = txt;
    364                                     //teba[i, 1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    365350                                }
    366351                                else
     
    370355                                    myGrid.Children.Add(txt);
    371356                                    teba[1, i] = txt;
    372                                     //teba[1, i].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    373357                                }
    374358                            }
     
    376360
    377361                    }
     362                    //creating the chess-like backgroundpattern
    378363                    mat_back = new Brush[read_in_matrix.GetLength(0), read_in_matrix.GetLength(1)];
    379364                    for (int i = 0; i < read_in_matrix.GetLength(1); i++)
     
    409394                            txt.TextAlignment = TextAlignment.Center;
    410395                            txt.Width = 17;
    411 
    412396                            Grid.SetRow(txt, (i + colper));
    413397                            Grid.SetColumn(txt, (ix + rowper));
     
    421405                    else
    422406                        reina = new TextBlock[key.Length];
    423 
    424407                    for (int i = 0; i < input.Length; i++)
    425408                    {
     
    427410                        txt.FontSize = 12;
    428411                        txt.FontWeight = FontWeights.ExtraBold;
    429                         if(number==0)
     412                        if(number==0) //special hexmode handling
    430413                            if (31 < Convert.ToInt64(input[i]) && Convert.ToInt64(input[i]) != 127)
    431414                                {
     
    436419                                    txt.Text = "/" + Convert.ToInt64(input[i]).ToString("X"); 
    437420                                }
    438 
    439 
    440421                            else
    441422                                txt.Text = input[i].ToString();
    442423                        reina[i] = txt;
    443424                        reina[i].Background = Brushes.Transparent;
    444                         //reina[i].Opacity = 0.0;
    445425                        mywrap1.Children.Add(txt);
    446                         // if (i == input.Length-1)
    447                         //   { fadeIn.Completed += new EventHandler(my_Help3); }
    448                         //if (!Stop)
    449                         // reina[i].BeginAnimation(TextBlock.OpacityProperty,fadeIn);
    450426                    }
    451427                    if (input.Length < key.Length)
     
    459435                            reina[i] = txt;
    460436                            reina[i].Background = Brushes.Transparent;
    461                             //reina[i].Opacity = 0.0;
    462437                            mywrap1.Children.Add(txt);
    463438                        }
     
    481456                               //  }
    482457                        txt.Text = Convert.ToChar(output[i]).ToString();
    483                         //if you comment the line above and re-comment the lines to the "---marker"
    484                         //you will get shown the whitespaces in hexcode in the READOUT of the Presentation
     458                        /*if you comment the line above
     459                         * and re-comment the lines to the "---marker"
     460                         * you will get shown the whitespaces in hexcode in the READOUT of the Presentation*/
    485461                       
    486462                        else
    487                             txt.Text = output[i].ToString("X");
     463                        txt.Text = output[i].ToString("X");
    488464                        reouta[i] = txt;
    489465                        reouta[i].Background = Brushes.Orange;
     
    492468                    }
    493469                }
    494 
    495470                nop.Completed += new EventHandler(my_Helpnop);
    496471                Stack.BeginAnimation(OpacityProperty, nop);
    497 
    498            
    499472        }
    500473        #endregion
     
    506479        /// </summary>
    507480        public void preReadIn()
    508         {
    509 
     481        {   //declaring color animations
    510482            ColorAnimation myColorAnimation = new ColorAnimation();
    511483            myColorAnimation.From = Colors.Transparent;
     
    513485            myColorAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    514486
    515 
    516487            if (reina != null)
    517488            {
     
    522493                {
    523494                    myupdateprogress(outcount2 * 1000 / read_in_matrix.GetLength(1));
    524 
    525495                    for (int i = 0; i < read_in_matrix.GetLength(0); i++)
    526496                    {
     
    534504                else
    535505                {
    536 
    537506                    myupdateprogress(outcount2 * 1000 / read_in_matrix.GetLength(0));
    538507                    for (int i = 0; i < read_in_matrix.GetLength(1); i++)
     
    554523        /// </summary>
    555524        public void readIn()
    556         {
     525        {   //declarting fading animations
    557526            DoubleAnimation fadeIn = new DoubleAnimation();
    558527            fadeIn.From = 0.0;
     
    581550                        }
    582551                        teba[i, outcount1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    583 
    584552                    }
    585553                }
     
    593561                        }
    594562                        teba[outcount1, i].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    595 
    596563                    }
    597564                }
    598565            }
    599566        }
    600 
     567        /// <summary>
     568        /// post highlithing of the read in values
     569        /// </summary>
    601570        public void postReadIn()
    602         {
     571        {   //declaring coloranimations
    603572            ColorAnimation myColorAnimation_green = new ColorAnimation();
    604573            myColorAnimation_green.From = Colors.Yellow;
     
    627596                        if (i == teba.GetLength(0) - 1 && outcount3 == teba.GetLength(1) - 1 && !Stop)
    628597                        {
    629 
    630598                            if (mat_back[0, outcount3 - colper] == Brushes.LawnGreen)
    631599                                myColorAnimation_green.Completed += new EventHandler(my_Help14);
    632600                            else
    633601                                myColorAnimation_blue.Completed += new EventHandler(my_Help14);
    634 
    635602                            no = false;
    636603                        }
     
    694661        {
    695662            myupdateprogress(i * 1000 / teba.GetLength(0) + 1000);
    696            
    697 
     663            //statusbar update
    698664            if (per == 0) { textBox2.Text = "permuting by row"; }
    699665            else { textBox2.Text = "permuting by column"; }
     
    718684                                }
    719685                                preani(i, s);
    720 
    721686                            }
    722687                            else
     
    725690                                sort(schleife);
    726691                            }
    727 
    728                         }
    729 
     692                        }
    730693                        else if (!Stop) { preReadOut_help(); }
    731694                    }
     
    745708                                }
    746709                                preani(i, s);
    747 
    748710                            }
    749711                            else
     
    753715                                sort(schleife);
    754716                            }
    755 
    756                         }
    757 
     717                        }
    758718                        else if (!Stop) { preReadOut_help(); }
    759719                    }
    760720                }
    761 
    762721            }
    763722            else
     
    780739                                }
    781740                                preani(i, s);
    782 
    783741                            }
    784742                            else
     
    787745                                sort(schleife);
    788746                            }
    789 
    790                         }
    791 
     747                        }
    792748                        else if (!Stop) { preReadOut_help(); }
    793749                    }
     
    807763                                }
    808764                                preani(i, s);
    809 
    810765                            }
    811766                            else
     
    815770                                sort(schleife);
    816771                            }
    817 
    818                         }
    819 
     772                        }
    820773                        else if (!Stop) { preReadOut_help(); }
    821774                    }
    822775                }
    823 
    824776            }
    825777        }
     
    829781        #region readouts
    830782
     783        private void preReadOut()
     784        {   //declarating coloranimations and brushes
     785            ColorAnimation myColorAnimation_green = new ColorAnimation();
     786            myColorAnimation_green.From = Colors.LawnGreen;
     787            myColorAnimation_green.To = Colors.Yellow;
     788            myColorAnimation_green.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     789
     790            ColorAnimation myColorAnimation_blue = new ColorAnimation();
     791            myColorAnimation_blue.From = Colors.AliceBlue;
     792            myColorAnimation_blue.To = Colors.Yellow;
     793            myColorAnimation_blue.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     794
     795            SolidColorBrush brush_green = new SolidColorBrush();
     796            SolidColorBrush brush_blue = new SolidColorBrush();
     797
     798            if (teba != null)
     799            {
     800                if (reout == 0)
     801                { 
     802                    for (int i = rowper; i < teba.GetLength(0); i++)
     803                    {
     804                        if (mat_back[i - rowper, outcount4 - colper] == Brushes.LawnGreen)
     805                            teba[i, outcount4].Background = brush_green;
     806                        else
     807                            teba[i, outcount4].Background = brush_blue;
     808                    }
     809                    if (mat_back[0, outcount4 - colper] == Brushes.LawnGreen)
     810                        myColorAnimation_green.Completed += new EventHandler(my_Help6);
     811                    else
     812                        myColorAnimation_blue.Completed += new EventHandler(my_Help6);
     813                    if (!Stop)
     814                    {
     815                        brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
     816                        brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
     817                    }
     818                }
     819                else
     820                {
     821                    for (int i = colper; i < teba.GetLength(1); i++)
     822                    {
     823                        if (mat_back[outcount4 - rowper, i - colper] == Brushes.LawnGreen)
     824                            teba[outcount4, i].Background = brush_green;
     825                        else
     826                            teba[outcount4, i].Background = brush_blue;
     827                    }
     828                    if (mat_back[outcount4 - rowper, 2 - colper] == Brushes.LawnGreen)
     829                        myColorAnimation_green.Completed += new EventHandler(my_Help6);
     830                    else
     831                        myColorAnimation_blue.Completed += new EventHandler(my_Help6);
     832                    if (!Stop)
     833                    {
     834                        brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
     835                        brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
     836                    }
     837                }
     838            }
     839        }
     840        /// <summary>
     841        /// method for "eating out" the grid feeding the output wrapper (right one)
     842        /// </summary>
     843        public void readout()
     844        {   //statusbar update
     845            if (reout == 0) { textBox2.Text = "reading out by row"; }
     846            else { textBox2.Text = "reading out by column"; }
     847            //declarating fading animations
     848            DoubleAnimation myDoubleAnimation = new DoubleAnimation();
     849            myDoubleAnimation.From = 1.0;
     850            myDoubleAnimation.To = 0.0;
     851            myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     852
     853            DoubleAnimation fadeIn = new DoubleAnimation();
     854            fadeIn.From = 0.0;
     855            fadeIn.To = 1.0;
     856            fadeIn.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
     857
     858            if (teba != null)
     859            {
     860                if (reout == 1)
     861                {
     862                    for (int i = 0; i < permuted_matrix.GetLength(1); i++)
     863                    {
     864                        if (Convert.ToInt64(permuted_matrix[outcount5, i]) != 0)
     865                        {
     866                            reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
     867                            countup1++;
     868                        }
     869                    }
     870                    for (int i = colper; i < teba.GetLength(1); i++)
     871                    {
     872                        if (i == teba.GetLength(1) - 1 && !Stop)
     873                        {
     874                            myDoubleAnimation.Completed += new EventHandler(my_Help1);
     875                        }
     876                        teba[outcount, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     877                    }
     878                }
     879                else
     880                {
     881                    for (int i = 0; i < permuted_matrix.GetLength(0); i++)
     882                    {
     883                        if (Convert.ToInt64(permuted_matrix[i, outcount5]) != 0)
     884                        {
     885                            reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
     886                            countup1++;
     887                        }
     888                    }
     889
     890                    for (int i = rowper; i < teba.GetLength(0); i++)
     891                    {
     892                        if (i == teba.GetLength(0) - 1 && !Stop)
     893                        {
     894                            myDoubleAnimation.Completed += new EventHandler(my_Help1);
     895                        }
     896                        teba[i, outcount].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
     897                    }
     898                }
     899            }
     900        }
     901
     902        //post highlighting of the read out values
    831903        private void postReadOut()
    832         {
     904        {   //declaration of coloranimations
    833905            ColorAnimation myColorAnimation = new ColorAnimation();
    834906            myColorAnimation.From = Colors.Orange;
     
    846918                    reouta[i].Background = brush;
    847919                }
    848 
    849920                if (reout == 0)
    850921                {
     
    871942                    }
    872943                }
    873 
    874944                if (no)
    875945                    myColorAnimation.Completed += new EventHandler(my_Help7);
    876946                if (!Stop)
    877947                    brush.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation);
    878 
    879              
    880948            }
    881 
    882 
    883         }
    884 
    885         private void preReadOut()
    886         {
    887             ColorAnimation myColorAnimation_green = new ColorAnimation();
    888             myColorAnimation_green.From = Colors.LawnGreen;
    889             myColorAnimation_green.To = Colors.Yellow;
    890             myColorAnimation_green.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    891 
    892             ColorAnimation myColorAnimation_blue = new ColorAnimation();
    893             myColorAnimation_blue.From = Colors.AliceBlue;
    894             myColorAnimation_blue.To = Colors.Yellow;
    895             myColorAnimation_blue.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    896 
    897             SolidColorBrush brush_green = new SolidColorBrush();
    898             SolidColorBrush brush_blue = new SolidColorBrush();
    899 
    900             if (teba != null)
    901             {
    902                 if (reout == 0)
    903                 {
    904                    
    905                     for (int i = rowper; i < teba.GetLength(0); i++)
    906                     {
    907                         if (mat_back[i - rowper, outcount4 - colper] == Brushes.LawnGreen)
    908                             teba[i, outcount4].Background = brush_green;
    909                         else
    910                             teba[i, outcount4].Background = brush_blue;
    911                     }
    912                     if (mat_back[0, outcount4 - colper] == Brushes.LawnGreen)
    913                         myColorAnimation_green.Completed += new EventHandler(my_Help6);
    914                     else
    915                         myColorAnimation_blue.Completed += new EventHandler(my_Help6);
    916 
    917                     if (!Stop)
    918                     {
    919                         brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
    920                         brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
    921                     }
    922                 }
    923                 else
    924                 {
    925                     for (int i = colper; i < teba.GetLength(1); i++)
    926                     {
    927                         if (mat_back[outcount4 - rowper, i - colper] == Brushes.LawnGreen)
    928                             teba[outcount4, i].Background = brush_green;
    929                         else
    930                             teba[outcount4, i].Background = brush_blue;
    931                     }
    932                     if (mat_back[outcount4 - rowper, 2 - colper] == Brushes.LawnGreen)
    933                         myColorAnimation_green.Completed += new EventHandler(my_Help6);
    934                     else
    935                         myColorAnimation_blue.Completed += new EventHandler(my_Help6);
    936 
    937                     if (!Stop)
    938                     {
    939                         brush_blue.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_blue);
    940                         brush_green.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_green);
    941 
    942                     }
    943                 }
    944             }
    945 
    946         }
    947 
    948         public void readout()
    949         {
    950            
    951 
    952             if (reout == 0) { textBox2.Text = "reading out by row"; }
    953             else { textBox2.Text = "reading out by column"; }
    954 
    955            DoubleAnimation myDoubleAnimation = new DoubleAnimation();
    956             myDoubleAnimation.From = 1.0;
    957             myDoubleAnimation.To = 0.0;
    958             myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    959 
    960             DoubleAnimation fadeIn = new DoubleAnimation();
    961             fadeIn.From = 0.0;
    962             fadeIn.To = 1.0;
    963             fadeIn.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    964 
    965             if (teba != null)
    966             {
    967                 if (reout == 1)
    968                 {
    969                     for (int i = 0; i < permuted_matrix.GetLength(1); i++)
    970                     {
    971                         if (Convert.ToInt64(permuted_matrix[outcount5, i]) != 0)
    972                         {
    973                             reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    974                             countup1++;
    975                         }
    976                     }
    977 
    978 
    979                     for (int i = colper; i < teba.GetLength(1); i++)
    980                     {
    981                         if (i == teba.GetLength(1) - 1 && !Stop)
    982                         {
    983                             myDoubleAnimation.Completed += new EventHandler(my_Help1);
    984                         }
    985                         teba[outcount, i].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    986 
    987                     }
    988                 }
    989                 else
    990                 {
    991                     for (int i = 0; i < permuted_matrix.GetLength(0); i++)
    992                     {
    993                         if (Convert.ToInt64(permuted_matrix[i, outcount5]) != 0)
    994                         {
    995                             reouta[countup1].BeginAnimation(TextBlock.OpacityProperty, fadeIn);
    996                             countup1++;
    997                         }
    998                     }
    999 
    1000 
    1001 
    1002                     for (int i = rowper; i < teba.GetLength(0); i++)
    1003                     {
    1004                         if (i == teba.GetLength(0) - 1 && !Stop)
    1005                         {
    1006                             myDoubleAnimation.Completed += new EventHandler(my_Help1);
    1007                         }
    1008                         teba[i, outcount].BeginAnimation(TextBlock.OpacityProperty, myDoubleAnimation);
    1009                     }
    1010                 }
    1011             }
    1012          
    1013         }
    1014 
     949        }
    1015950        #endregion
    1016951
     
    1023958        /// <param name="e"></param>
    1024959        public void my_Stop(object sender, EventArgs e)
    1025         {
     960        {   //resetting the grid
    1026961            myGrid.Children.Clear();
    1027962            myGrid.ColumnDefinitions.Clear();
     
    1030965            mywrap2.Children.Clear();
    1031966
    1032 
    1033967            textBox2.BeginAnimation(OpacityProperty, fadeOut);
    1034 
    1035968            outcount = 0;
    1036 
    1037969            schleife = 0;
    1038 
    1039970            textBox2.Clear();
    1040971            Stop = true;
    1041972        }
    1042 
     973        #region eventhandler
    1043974        private void my_Help1(object sender, EventArgs e)
    1044975        {
     
    1065996            if (!Stop)
    1066997                Stack.BeginAnimation(OpacityProperty, fadeIn);
    1067 
    1068 
    1069998        }
    1070999
     
    10721001        {
    10731002            sizeChanged(this, EventArgs.Empty);
    1074 
    10751003            if (!Stop)
    10761004                preReadIn();
     
    10791007        private void my_Help4(object sender, EventArgs e)
    10801008        {
    1081 
    10821009            outcount2++;
    10831010            if (!Stop)
     
    10981025            GradientStop gs2 = new GradientStop(Colors.Pink, 0.5);
    10991026            GradientStop gs3 = new GradientStop(Colors.PaleVioletRed, 0.0);
    1100 
    11011027            ColorAnimation myColorAnimation_rg = new ColorAnimation();
    11021028            myColorAnimation_rg.From = Colors.CornflowerBlue;
     
    11301056        private void my_Help5(object sender, EventArgs e)
    11311057        {
    1132 
    11331058            outcount3++;
    11341059            if (!Stop)
     
    11381063        private void my_Help6(object sender, EventArgs e)
    11391064        {
    1140 
    11411065            outcount4++;
    11421066            if (!Stop)
     
    11791103        }
    11801104
    1181 
    11821105        private void the_End(object sender, EventArgs e)
    11831106        {
    1184 
    11851107            DoubleAnimation fadeOut2 = new DoubleAnimation();
    11861108            fadeOut2.From = 1.0;
     
    11921114            myGrid.BeginAnimation(OpacityProperty, fadeOut);
    11931115            textBox2.BeginAnimation(OpacityProperty, fadeOut);
    1194 
    1195            
    1196         }
    1197 
     1116        }
    11981117
    11991118        private void my_Help13(object sender, EventArgs e)
    1200         {
    1201            
     1119        {   
    12021120            sizeChanged(this, EventArgs.Empty);
    1203             //LinearGradientBrush myBrush1 = new LinearGradientBrush();
    1204             //myBrush1.GradientStops.Add(new GradientStop(Colors.CornflowerBlue, 0.0));
    1205             //myBrush1.GradientStops.Add(new GradientStop(Colors.SkyBlue, 0.5));
    1206             //myBrush1.GradientStops.Add(new GradientStop(Colors.PowderBlue, 1.0));
    1207            // mycanvas.Background = myBrush1;
    12081121            textBox2.Text = "accomplished"; //finish
    12091122            feuerEnde(this, EventArgs.Empty);
     
    12301143
    12311144        private void my_Help14(object sender, EventArgs e)
    1232         {
    1233            
     1145        {   
    12341146            GradientStop gs1 = new GradientStop(Colors.Red, 1.0);
    12351147            GradientStop gs2 = new GradientStop(Colors.Pink, 0.5);
    12361148            GradientStop gs3 = new GradientStop(Colors.PaleVioletRed, 0.0);
    1237 
    12381149            ColorAnimation myColorAnimation_rg = new ColorAnimation();
    12391150            myColorAnimation_rg.From = Colors.Red;
     
    12611172           
    12621173            mycanvas.Background = myBrush;
    1263 
    12641174            sort(schleife);
    12651175        }
    12661176
    12671177        private void my_Completed(object sender, EventArgs e)
    1268         {
    1269          
     1178        {
    12701179                if (per == 1)
    12711180                {
     
    12901199                                mat_back[von, i - 2] = help2;
    12911200                            }
    1292 
    12931201                        }
    12941202                    }
     
    13121220                else
    13131221                {
    1314 
    13151222                    if (teba != null)
    13161223                    {
    13171224                        for (int i = 0; i < teba.GetLength(0); i++)
    13181225                        {
    1319 
    13201226                            String help = teba[i, nach].Text.ToString();
    13211227                            teba[i, nach].Text = teba[i, von].Text.ToString();
     
    13341240                                mat_back[i - 2, von] = help2;
    13351241                            }
    1336 
    1337                         }
    1338                     }
    1339 
     1242                        }
     1243                    }
    13401244                    DoubleAnimation myFadein = new DoubleAnimation();
    13411245                    myFadein.From = 0.0;
     
    13541258                        }
    13551259                }
    1356            
    1357         }
    1358 
     1260        }
     1261        #endregion
    13591262        #endregion
    13601263
    13611264        #region animations
    1362 
     1265        /// <summary>
     1266        /// method for preanimating
     1267        /// </summary>
     1268        /// <param name="von"></param>
     1269        /// <param name="nach"></param>
    13631270        public void preani(int von, int nach)
    13641271        {
     
    13661273            this.nach = nach;
    13671274
     1275            #region declarating coloranimations und brushes
    13681276            ColorAnimation myColorAnimation_gy = new ColorAnimation();
    13691277            myColorAnimation_gy.From = Colors.LawnGreen;
     
    13811289            myColorAnimation_ty.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    13821290
    1383 
    13841291            SolidColorBrush brush_gy = new SolidColorBrush();
    13851292            SolidColorBrush brush_by = new SolidColorBrush();
     
    14051312            SolidColorBrush brush_bo = new SolidColorBrush();
    14061313            SolidColorBrush brush_to = new SolidColorBrush();
     1314            #endregion
    14071315
    14081316            if (teba != null)
     
    14241332                            if (mat_back[nach, i - 2].Equals(Brushes.AliceBlue))
    14251333                                teba[nach, i].Background = brush_bo;
    1426 
    14271334                        }
    14281335                        else
     
    14421349                            if (mat_back[i - 2, von].Equals(Brushes.LawnGreen))
    14431350                                teba[i, von].Background = brush_gy;
    1444 
    14451351                            if (mat_back[i - 2, von].Equals(Brushes.AliceBlue))
    14461352                                teba[i, von].Background = brush_by;
    1447 
    14481353                            if (mat_back[i - 2, nach].Equals(Brushes.LawnGreen))
    14491354                                teba[i, nach].Background = brush_go;
     
    14511356                            if (mat_back[i - 2, nach].Equals(Brushes.AliceBlue))
    14521357                                teba[i, nach].Background = brush_bo;
    1453 
    14541358                        }
    14551359                        else
     
    14581362                            teba[i, nach].Background = brush_to;
    14591363                        }
    1460 
    14611364                    }
    14621365                    myColorAnimation_ty.Completed += new EventHandler(my_Help10);
    14631366                }
    1464 
    14651367            brush_ty.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_ty);
    14661368            brush_gy.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_gy);
     
    14691371            brush_bo.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_bo);
    14701372            brush_by.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_by);
    1471 
    1472         }
    1473 
     1373        }
     1374        //method for post-animation
    14741375        public void postani()
    14751376        {
     1377            #region declaring animations and brushes
    14761378            ColorAnimation myColorAnimation_gy = new ColorAnimation();
    14771379            myColorAnimation_gy.From = Colors.Yellow;
     
    14881390            myColorAnimation_ty.To = Colors.Transparent;
    14891391            myColorAnimation_ty.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    1490 
    1491 
     1392           
    14921393            SolidColorBrush brush_gy = new SolidColorBrush();
    14931394            SolidColorBrush brush_by = new SolidColorBrush();
     
    15091410            myColorAnimation_to.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    15101411
    1511 
    15121412            SolidColorBrush brush_go = new SolidColorBrush();
    15131413            SolidColorBrush brush_bo = new SolidColorBrush();
    15141414            SolidColorBrush brush_to = new SolidColorBrush();
     1415            #endregion
    15151416
    15161417            if (teba != null)
     
    15321433                            if (mat_back[von, i - 2].Equals(Brushes.AliceBlue))
    15331434                                teba[von, i].Background = brush_bo;
    1534 
    15351435                        }
    15361436                        else
     
    15591459                            if (mat_back[i - 2, von].Equals(Brushes.AliceBlue))
    15601460                                teba[i, von].Background = brush_bo;
    1561 
    15621461                        }
    15631462                        else
     
    15751474            brush_go.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_go);
    15761475            brush_bo.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_bo);
    1577 
    15781476            brush_by.BeginAnimation(SolidColorBrush.ColorProperty, myColorAnimation_by);
    1579 
    1580         }
    1581 
     1477        }
     1478        //preanimation method especially for ROW-mode
    15821479        public void prerowani(int von, int nach)
    15831480        {
     
    15991496            myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(1001 - speed));
    16001497
    1601 
    16021498            if (teba != null)
    16031499                if (per == 1)
     
    16271523        #endregion
    16281524
     1525        #region misc
     1526
     1527        /// <summary>
     1528        /// getter of the speed the visualisation is running
     1529        /// </summary>
     1530        /// <param name="speed"></param>
     1531        public void UpdateSpeed(int speed)
     1532        {
     1533            this.speed = speed;
     1534        }
     1535
    16291536        private void myupdateprogress(int value)
    16301537        {
     
    16321539            updateProgress(this, EventArgs.Empty);
    16331540        }
    1634 
     1541        #endregion
    16351542    }
    16361543}
Note: See TracChangeset for help on using the changeset viewer.