Changeset 956


Ignore:
Timestamp:
Dec 5, 2009, 6:47:14 PM (12 years ago)
Author:
Sören Rinne
Message:
  • new Appender plugin
  • some bugfixing
Location:
trunk/CrypPlugins
Files:
11 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/BerlekampMassey/BerlekampMassey.cs

    r689 r956  
    220220{
    221221    [Author("Soeren Rinne", "soeren.rinne@cryptool.org", "Ruhr-Universitaet Bochum, Chair for System Security", "http://www.trust.rub.de/")]
    222     [PluginInfo(false, "BerlekampMassey", "Berlekamp-Massey-Algorithm", "BerlekampMassey/DetailedDescription/Description.xaml", "BerlekampMassey/Images/icon2.png", "BerlekampMassey/Images/icon2.png", "BerlekampMassey/Images/icon2.png")]
     222    [PluginInfo(false, "Berlekamp-Massey Algorithm", "Berlekamp-Massey Algorithm", "BerlekampMassey/DetailedDescription/Description.xaml", "BerlekampMassey/Images/icon2.png", "BerlekampMassey/Images/icon2.png", "BerlekampMassey/Images/icon2.png")]
    223223    public class BerlekampMassey : IThroughput
    224224    {
     
    243243        {
    244244            this.settings = new BerlekampMasseySettings();
    245             ((BerlekampMasseySettings)(this.settings)).LogMessage += BerlekampMasseyLogMessage;
    246245
    247246            berlekampMasseyPresentation = new BerlekampMasseyPresentation();
     
    263262        public String Input
    264263        {
    265             [MethodImpl(MethodImplOptions.Synchronized)]
    266264            get { return this.input; }
    267             [MethodImpl(MethodImplOptions.Synchronized)]
    268265            set
    269266            {
    270                 this.input = value.ToString();
     267                this.input = value;
    271268                OnPropertyChanged("Input");
    272                 // clean inputOne
    273269            }
    274270        }
     
    277273        public int Output
    278274        {
     275            get
     276            {
     277                return output;
     278            }
     279            set
     280            {   // is readonly
     281            }
     282        }
     283
     284        [PropertyInfo(Direction.OutputData, "Feedback Polynomial C(D)", "", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     285        public String PolynomialOutput
     286        {
    279287            [MethodImpl(MethodImplOptions.Synchronized)]
    280288            get
    281289            {
    282                 return output;
     290                return polynomialOutput;
    283291            }
    284292            set
     
    287295        }
    288296
    289         [PropertyInfo(Direction.OutputData, "Feedback Polynomial C(D)", "", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    290         public String PolynomialOutput
    291         {
    292             [MethodImpl(MethodImplOptions.Synchronized)]
    293             get
    294             {
    295                 return polynomialOutput;
    296             }
    297             set
    298             {   // is readonly
    299             }
    300         }
    301 
    302297        #endregion
    303298
     
    351346        private void BerlekampMasseyLogMessage(string msg, NotificationLevel logLevel)
    352347        {
    353             /*if (OnGuiLogNotificationOccured != null)
    354             {
    355                 OnGuiLogNotificationOccured(this, new GuiLogEventArgs(msg, this, logLevel));
    356             }*/
    357348        }
    358349
     
    562553            finally
    563554            {
    564                 //ProgressChanged(1, 1);
     555                ProgressChanged(1.0, 1.0);
    565556            }
    566557        }
     
    571562
    572563        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
     564        private void ProgressChanged(double value, double max)
     565        {
     566            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
     567        }
    573568
    574569        private void GuiLogMessage(string message, NotificationLevel logLevel)
  • trunk/CrypPlugins/BerlekampMassey/BerlekampMasseySettings.cs

    r841 r956  
    220220        #endregion
    221221
    222         #region Public Xor specific interface
    223 
    224         /// <summary>
    225         /// We use this delegate to send log messages from the settings class to the Xor plugin
    226         /// </summary>
    227         /// <param name="sender"></param>
    228         /// <param name="msg"></param>
    229         /// <param name="logLevel"></param>
    230         public delegate void XorLogMessage(string msg, NotificationLevel logLevel);
    231 
    232         /// <summary>
    233         /// Fire if a new message has to be shown in the status bar
    234         /// </summary>
    235         public event XorLogMessage LogMessage;
    236        
     222        #region Public BMA specific interface
     223
    237224        /// <summary>
    238225        /// Returns true if some settigns have been changed. This value should be set
    239226        /// externally to false e.g. when a project was saved.
    240227        /// </summary>
    241         [PropertySaveOrder(0)]
    242228        public bool HasChanges
    243229        {
  • trunk/CrypPlugins/BooleanFunctionParser/BooleanFunctionParser.cs

    r890 r956  
    9898        }
    9999
    100         [PropertyInfo(Direction.InputData, "Boolean Function f(i)", "Boolean function f(i) to compute.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     100        [PropertyInfo(Direction.InputData, "Boolean Function f(i)", "Boolean function f(i) to compute.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    101101        public String InputFunction
    102102        {
     
    131131            }
    132132        }
    133 
    134         [PropertyInfo(Direction.InputData, "Function Variable Two (i_2.j)", "Input a boolean value to be processed by the function", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    135         public bool[] InputTwo
    136         {
    137             [MethodImpl(MethodImplOptions.Synchronized)]
    138             get
    139             {
    140                 return this.inputVariableTwo;
    141             }
    142 
    143             [MethodImpl(MethodImplOptions.Synchronized)]
    144             set
    145             {
    146                 this.inputVariableTwo = value;
    147                 lastInputWasFunction = false;
    148                 OnPropertyChanged("InputTwo");
    149                 // clean inputOne
    150                 inputTwoFlag = 1;
    151             }
    152         }
    153 
    154         [PropertyInfo(Direction.InputData, "Function Variable Three (i_3.j)", "Input a boolean value to be processed by the function", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    155         public bool[] InputThree
    156         {
    157             [MethodImpl(MethodImplOptions.Synchronized)]
    158             get
    159             {
    160                 return this.inputVariableThree;
    161             }
    162 
    163             [MethodImpl(MethodImplOptions.Synchronized)]
    164             set
    165             {
    166                 this.inputVariableThree = value;
    167                 lastInputWasFunction = false;
    168                 OnPropertyChanged("InputThree");
    169                 // clean inputOne
    170                 inputThreeFlag = 1;
    171             }
    172         }*/
     133         */
     134
    173135
    174136        [PropertyInfo(Direction.OutputData, "Function output", "Output after procesing the given function.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     
    226188                //GuiLogMessage("sumOfFlags: " + sumOfFlags + ", addIFl: " + allFlags, NotificationLevel.Info);
    227189
    228                 //if (sumOfFlags == additionalInputsFlag.Length || (lastInputWasFunction == true && sumOfFlags == 0))
    229                 if (sumOfFlags == additionalInputsFlag.Length)
     190                if (sumOfFlags == additionalInputsFlag.Length || (lastInputWasFunction == true && sumOfFlags == 0))
     191                //if (sumOfFlags == additionalInputsFlag.Length)
    230192                {
    231193                    // set all flags to zero
     
    303265                CreateInputOutput(true);
    304266            }
    305             else if (e.PropertyName == "UseBFPforCube")
     267            if (e.PropertyName == "UseBFPforCube")
    306268            {
    307269                booleanFunctionParserPresentation.SwitchCubeView(settings.UseBFPforCube);
     270            }
     271            if (e.PropertyName == "evalFunction")
     272            {
     273                Execute();
    308274            }
    309275        }
     
    562528                }
    563529            }
    564             // replace quickwatch data (xq.*) (if there is any)
     530            // replace quickwatch data (xq*) (if there is any)
    565531            if (settings.UseBFPforCube == false)
    566532            {
     
    575541                    for (int i = quickwatchData.Length - 1; i >= 0; i--)
    576542                    {
    577                         //string replacement = "xq." + i;
     543                        //string replacement = "xq" + i;
    578544                        //strExpression = strExpression.Replace(replacement, strInputVariableQuickwatch[i].ToString());
    579                         tokens.Add("xq." + i, strInputVariableQuickwatch[i].ToString());
     545                        tokens.Add("xq" + i, strInputVariableQuickwatch[i].ToString());
    580546                    }
    581547                }
  • trunk/CrypPlugins/BooleanFunctionParser/BooleanFunctionParserSettings.cs

    r832 r956  
    122122        }
    123123
     124        [TaskPane("Evaluate function", "", null, 2, false, DisplayLevel.Beginner, ControlType.Button)]
     125        public void evalFunction()
     126        {
     127            OnPropertyChanged("evalFunction");
     128        }
     129
    124130        public bool HasChanges
    125131        {
  • trunk/CrypPlugins/CLK/CLK.cs

    r841 r956  
    5353        cLKPresentation.CLKButtonImage.MouseLeftButtonUp += cLKButton_MouseLeftButtonUp;
    5454        cLKPresentation.CLKButtonImage.MouseLeftButtonDown += cLKButton_MouseLeftButtonUp;
    55 
    56         // set picture according to settings value
    57         /* BRINGT NIX - WARUM?
    58         if (settings.SetClockToTrue) StatusChanged((int)CLKImage.True);
    59         else StatusChanged((int)CLKImage.False);*/
    6055    }
    6156
     
    258253        else StatusChanged((int)CLKImage.False);
    259254        settings.CLKTimeout = timeout;
     255        settings.UpdateTaskPaneVisibility();
    260256    }
    261257
  • trunk/CrypPlugins/CLK/CLKSettings.cs

    r841 r956  
    111111    }
    112112
     113    internal void UpdateTaskPaneVisibility()
     114    {
     115        if (TaskPaneAttributeChanged == null)
     116            return;
     117
     118        if (this.useEvent)
     119            SettingChanged("CLKTimeout", Visibility.Collapsed);
     120        else
     121            SettingChanged("CLKTimeout", Visibility.Visible);
     122    }
     123
    113124    #endregion
    114125
  • trunk/CrypPlugins/LFSR/LFSR.cs

    r900 r956  
    3636        private String inputTapSequence;
    3737        private String inputSeed;
    38         private CryptoolStream outputStream;
    3938        private String outputString;
    4039        private bool outputBool;
     
    8584                try
    8685                {
    87                     preprocessingLFSR(true);
     86                    preprocessLFSR(true);
    8887                } catch (Exception ex) {}
    8988            if (e.PropertyName == "SaveCurrentState")
     
    157156        }
    158157
    159         /*[PropertyInfo(Direction.OutputData, "Output stream", "LFSR Stream Output. Use this for bulk output.", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    160         public CryptoolStream OutputStream
    161         {
    162             //[MethodImpl(MethodImplOptions.Synchronized)]
    163             get
    164             {
    165                 if (this.outputStream != null)
    166                 {
    167                     CryptoolStream cs = new CryptoolStream();
    168                     listCryptoolStreamsOut.Add(cs);
    169                     cs.OpenRead(this.outputStream.FileName);
    170                     return cs;
    171                 }
    172                 return null;
    173             }
    174             //[MethodImpl(MethodImplOptions.Synchronized)]
    175             set
    176             {
    177                 outputStream = value;
    178                 if (value != null) listCryptoolStreamsOut.Add(value);
    179                 OnPropertyChanged("OutputStream");
    180             }
    181         }*/
    182 
    183158        [PropertyInfo(Direction.OutputData, "String Output", "Produces the output bits as a string with length==rounds. Use this output without a clock input.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    184159        public String OutputString
     
    228203            {
    229204                stop = false;
    230                 outputStream = null;
    231205                outputString = null;
    232206                outputStringBuffer = null;
     
    245219                myClock = true;
    246220                seedCharArray = null;
    247 
    248                 if (outputStream != null)
    249                 {
    250                     outputStream.Flush();
    251                     outputStream.Close();
    252                     outputStream = null;
    253                 }
    254                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    255                 {
    256                     stream.Close();
    257                 }
    258                 listCryptoolStreamsOut.Clear();
    259221            }
    260222            catch (Exception ex)
     
    439401            try
    440402            {
    441                 preprocessingLFSR(false);
     403                preprocessLFSR(false);
    442404            }
    443405            catch (Exception ex) { }
     
    504466        }
    505467
    506         private void preprocessingLFSR(bool createLog)
     468        private void preprocessLFSR(bool createLog)
    507469        {
    508470            if (checkForInputTapSequence() == 1) return;
    509471            if (checkForInputSeed() == 1) return;
    510 
    511             /*if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
    512             {
    513                 GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error, true);
    514                 if (!settings.UseBoolClock) inputClock.Close();
    515                 return;
    516             }
    517 
    518             if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
    519             {
    520                 GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error, true);
    521                 if (!settings.UseBoolClock) inputClock.Close();
    522                 return;
    523             }*/
    524472
    525473            // read tapSequence
     
    530478
    531479            //read seed
    532             if (settings.CurrentState != null && settings.CurrentState.Length != 0)
     480            if (settings.SaveCurrentState && settings.CurrentState != null && settings.CurrentState.Length != 0 && settings.CurrentState != "0")
    533481                seedbuffer = settings.CurrentState;
    534482            else if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
     
    607555            seedBits = seedbuffer.Length;
    608556
    609             GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug, createLog);
    610             GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug, createLog);
     557            //GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug, createLog);
     558            //GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug, createLog);
    611559
    612560            //check if last tap is 1, otherwise stop
     
    640588            }
    641589            else clocking = -1;
    642 
    643             /*// check which clock to use
    644             if (settings.UseBoolClock)
    645             {
    646                 myClock = inputClockBool;
    647             }
    648             else if (!settings.UseBoolClock)
    649             {
    650                 // read stream clock
    651                 checkForInputClock();
    652                 inputClock.OpenWrite("LFSR Restart");
    653                 String stringClock = inputClock.ReadByte().ToString();
    654                 inputClock.Position = 0;
    655                 if (String.Equals(stringClock, "49")) myClock = true; else myClock = false;
    656                 //inputClock.Close();
    657             }*/
    658590
    659591            // check if Rounds are given
     
    698630            try
    699631            {
    700                 /*char[] tapSequenceCharArray = null;
    701                 int seedBits = 1; // dummy value for compiler
    702                 int actualRounds = 1; // dummy value for compiler
    703                 Boolean myClock = true;
    704                 char[] seedCharArray = null;
    705 
    706                 // open output stream
    707                 outputStream = new CryptoolStream();
    708                 listCryptoolStreamsOut.Add(outputStream);
    709                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
    710                 */
    711 
    712632                // make all this stuff only one time at the beginning of our chainrun
    713633                if (newSeed)
     
    715635                    try
    716636                    {
    717                         preprocessingLFSR(true);
     637                        preprocessLFSR(true);
    718638                        int myPeriod = computePeriod();
    719639                        if (myPeriod == ((int)Math.Pow(2.0, (double)seedbuffer.Length) - 1))
     
    742662                }
    743663
    744                 // open output stream
    745                 outputStream = new CryptoolStream();
    746                 listCryptoolStreamsOut.Add(outputStream);
    747                 outputStream.OpenWrite();
    748 
    749664                //GuiLogMessage("Action is: Now!", NotificationLevel.Debug, true);
    750                 DateTime startTime = DateTime.Now;
     665                //DateTime startTime = DateTime.Now;
    751666
    752667                //////////////////////////////////////////////////////
    753668                // compute LFSR //////////////////////////////////////
    754669                //////////////////////////////////////////////////////
    755                 GuiLogMessage("Starting computation", NotificationLevel.Debug, true);
     670                //GuiLogMessage("Starting computation", NotificationLevel.Debug, true);
    756671               
    757672                int i = 0;
     
    771686                        // write last bit to output buffer, output stream buffer, stream and bool
    772687                        outputbuffer = seedCharArray[seedBits - 1];
    773                         outputStream.Write((Byte)outputbuffer);
    774688                        outputStringBuffer += seedCharArray[seedBits - 1];
    775689
    776690                        // update outputs
    777691                        OnPropertyChanged("OutputBool");
    778                         OnPropertyChanged("OutputStream");
    779692
    780693                        // shift seed array
     
    824737                        //GuiLogMessage("New Bit: " + newBit.ToString(), NotificationLevel.Info, true);
    825738                    }
    826                     else
     739                    else // clock is false
    827740                    {
    828741                        StatusChanged((int)LFSRImage.Decode);
     
    847760                            //GuiLogMessage("OutputBool is: " + outputBool.ToString(), NotificationLevel.Info, true);
    848761
    849                             // write bit to output buffer, stream and bool
    850                            
    851                             outputStream.Write((Byte)outputbuffer);
    852762                            OnPropertyChanged("OutputBool");
    853                             OnPropertyChanged("OutputStream");
    854763
    855764                            // update quickwatch presentation
     
    885794                }
    886795
    887                 //controllerOutput = true;
    888                 //OnPropertyChanged("ControllerOutput");
    889 
    890796                // stop counter
    891                 DateTime stopTime = DateTime.Now;
     797                //DateTime stopTime = DateTime.Now;
    892798                // compute overall time
    893                 TimeSpan duration = stopTime - startTime;
     799                //TimeSpan duration = stopTime - startTime;
    894800
    895801                if (!stop)
     
    899805                    OnPropertyChanged("OutputString");
    900806
    901                     GuiLogMessage("Complete!", NotificationLevel.Debug, true);
    902 
    903                     GuiLogMessage("Time used: " + duration, NotificationLevel.Debug, true);
    904                     outputStream.Close();
    905                     OnPropertyChanged("OutputStream");
     807                    //GuiLogMessage("Complete!", NotificationLevel.Debug, true);
     808
     809                    //GuiLogMessage("Time used: " + duration, NotificationLevel.Debug, true);
    906810                }
    907811
    908812                if (stop)
    909813                {
    910                     outputStream.Close();
    911814                    outputStringBuffer = null;
    912815                    GuiLogMessage("Aborted!", NotificationLevel.Debug, true);
     
    928831        {
    929832            lFSRPresentation.ChangeBackground(NotificationLevel.Info);
     833            settings.UpdateTaskPaneVisibility();
    930834        }
    931835
  • trunk/CrypPlugins/LFSR/LFSRPresentation.xaml

    r875 r956  
    44             Height="Auto" Width="Auto" Margin="0" Background="White" BorderBrush="Black" BorderThickness="1">
    55    <Grid Name="completeGrid">
     6        <Ellipse Name="innercircle" Height="10" Width="10" StrokeThickness="0" Fill="White" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="5,5,5,5" />
    67        <Grid Height="50" Width="Auto" Margin="5,0,0,60" Name="polynomialGrid" HorizontalAlignment="Left" VerticalAlignment="Center">
    7             <Label Name="polynomialText"></Label>
     8            <Label Name="polynomialText" />
    89        </Grid>
    910        <Grid Height="Auto" Width="Auto" Margin="0,40,0,0" Name="myGrid" HorizontalAlignment="Center" VerticalAlignment="Center" />
  • trunk/CrypPlugins/LFSR/LFSRPresentation.xaml.cs

    r875 r956  
    4747                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    4848                {
    49                     // hide initial textbox
    50                     infoText.Visibility = Visibility.Hidden;
    51                     polynomialText.Visibility = Visibility.Visible;
    52 
    53                     // add lines and triangles
    54                     Line HoriLine1 = new Line();
    55                     HoriLine1.X1 = 5;
    56                     HoriLine1.Y1 = 18;
    57                     HoriLine1.X2 = 60 + state.Length * 30;
    58                     HoriLine1.Y2 = 18;
    59                     HoriLine1.Stroke = Brushes.Black;
    60                     HoriLine1.StrokeThickness = 1;
    61                     myGrid.Children.Add(HoriLine1);
    62 
    63                     Line HoriLine2 = new Line();
    64                     HoriLine2.X1 = 5;
    65                     HoriLine2.Y1 = 47;
    66                     HoriLine2.X2 = 35 + (state.Length - 1) * 29;
    67                     HoriLine2.Y2 = 47;
    68                     HoriLine2.Stroke = Brushes.Black;
    69                     HoriLine1.StrokeThickness = 1;
    70                     myGrid.Children.Add(HoriLine2);
    71 
    72                     Line VertLine1 = new Line();
    73                     VertLine1.X1 = 5;
    74                     VertLine1.Y1 = 17.5;
    75                     VertLine1.X2 = 5;
    76                     VertLine1.Y2 = 47.5;
    77                     VertLine1.Stroke = Brushes.Black;
    78                     VertLine1.StrokeThickness = 1;
    79                     myGrid.Children.Add(VertLine1);
    80 
    81                     Line VertLine2 = new Line();
    82                     VertLine2.X1 = 35 + (state.Length - 1) * 29;
    83                     VertLine2.Y1 = 32;
    84                     VertLine2.X2 = 35 + (state.Length - 1) * 29;
    85                     VertLine2.Y2 = 47;
    86                     VertLine2.Stroke = Brushes.Black;
    87                     VertLine2.StrokeThickness = 1;
    88                     myGrid.Children.Add(VertLine2);
    89 
    90                     // add connection circle
    91                     /*Ellipse ConnectionCircle = new Ellipse();
    92                     ConnectionCircle.HorizontalAlignment = HorizontalAlignment.Left;
    93                     ConnectionCircle.VerticalAlignment = VerticalAlignment.Top;
    94                     ConnectionCircle.Fill = Brushes.Black;
    95                     ConnectionCircle.Width = 4;
    96                     ConnectionCircle.Height = 4;
    97                     ConnectionCircle.Margin = new Thickness(27.5 + state.Length * 30, 15.5, 0, 0);
    98                     myGrid.Children.Add(ConnectionCircle);*/
    99 
    100                     // add left triangle ////////////////////
    101                     // Create a path to draw a geometry with.
    102                     Path leftTriangle = new Path();
    103                     leftTriangle.Stroke = Brushes.Black;
    104                     leftTriangle.StrokeThickness = 1;
    105                     leftTriangle.Fill = Brushes.Black;
    106 
    107                     // Create a StreamGeometry to use to specify myPath.
    108                     StreamGeometry geometryLT = new StreamGeometry();
    109                     geometryLT.FillRule = FillRule.EvenOdd;
    110 
    111                     // Open a StreamGeometryContext that can be used to describe this StreamGeometry
    112                     // object's contents.
    113                     using (StreamGeometryContext ctx = geometryLT.Open())
     49                    try
    11450                    {
    115 
    116                         // Begin the triangle at the point specified. Notice that the shape is set to
    117                         // be closed so only two lines need to be specified below to make the triangle.
    118                         ctx.BeginFigure(new Point(13, 15), true /* is filled */, true /* is closed */);
    119 
    120                         // Draw a line to the next specified point.
    121                         ctx.LineTo(new Point(13, 21), true /* is stroked */, false /* is smooth join */);
    122 
    123                         // Draw another line to the next specified point.
    124                         ctx.LineTo(new Point(20, 18), true /* is stroked */, false /* is smooth join */);
     51                        // hide initial textbox
     52                        infoText.Visibility = Visibility.Hidden;
     53                        polynomialText.Visibility = Visibility.Visible;
     54
     55                        // add lines and triangles
     56                        Line HoriLine1 = new Line();
     57                        HoriLine1.X1 = 5;
     58                        HoriLine1.Y1 = 18;
     59                        HoriLine1.X2 = 60 + state.Length * 30;
     60                        HoriLine1.Y2 = 18;
     61                        HoriLine1.Stroke = Brushes.Black;
     62                        HoriLine1.StrokeThickness = 1;
     63                        myGrid.Children.Add(HoriLine1);
     64
     65                        Line HoriLine2 = new Line();
     66                        HoriLine2.X1 = 5;
     67                        HoriLine2.Y1 = 47;
     68                        HoriLine2.X2 = 35 + (state.Length - 1) * 29;
     69                        HoriLine2.Y2 = 47;
     70                        HoriLine2.Stroke = Brushes.Black;
     71                        HoriLine1.StrokeThickness = 1;
     72                        myGrid.Children.Add(HoriLine2);
     73
     74                        Line VertLine1 = new Line();
     75                        VertLine1.X1 = 5;
     76                        VertLine1.Y1 = 17.5;
     77                        VertLine1.X2 = 5;
     78                        VertLine1.Y2 = 47.5;
     79                        VertLine1.Stroke = Brushes.Black;
     80                        VertLine1.StrokeThickness = 1;
     81                        myGrid.Children.Add(VertLine1);
     82
     83                        Line VertLine2 = new Line();
     84                        VertLine2.X1 = 35 + (state.Length - 1) * 29;
     85                        VertLine2.Y1 = 32;
     86                        VertLine2.X2 = 35 + (state.Length - 1) * 29;
     87                        VertLine2.Y2 = 47;
     88                        VertLine2.Stroke = Brushes.Black;
     89                        VertLine2.StrokeThickness = 1;
     90                        myGrid.Children.Add(VertLine2);
     91
     92                        // add connection circle
     93                        /*Ellipse ConnectionCircle = new Ellipse();
     94                        ConnectionCircle.HorizontalAlignment = HorizontalAlignment.Left;
     95                        ConnectionCircle.VerticalAlignment = VerticalAlignment.Top;
     96                        ConnectionCircle.Fill = Brushes.Black;
     97                        ConnectionCircle.Width = 4;
     98                        ConnectionCircle.Height = 4;
     99                        ConnectionCircle.Margin = new Thickness(27.5 + state.Length * 30, 15.5, 0, 0);
     100                        myGrid.Children.Add(ConnectionCircle);*/
     101
     102                        // add left triangle ////////////////////
     103                        // Create a path to draw a geometry with.
     104                        Path leftTriangle = new Path();
     105                        leftTriangle.Stroke = Brushes.Black;
     106                        leftTriangle.StrokeThickness = 1;
     107                        leftTriangle.Fill = Brushes.Black;
     108
     109                        // Create a StreamGeometry to use to specify myPath.
     110                        StreamGeometry geometryLT = new StreamGeometry();
     111                        geometryLT.FillRule = FillRule.EvenOdd;
     112
     113                        // Open a StreamGeometryContext that can be used to describe this StreamGeometry
     114                        // object's contents.
     115                        using (StreamGeometryContext ctx = geometryLT.Open())
     116                        {
     117
     118                            // Begin the triangle at the point specified. Notice that the shape is set to
     119                            // be closed so only two lines need to be specified below to make the triangle.
     120                            ctx.BeginFigure(new Point(13, 15), true /* is filled */, true /* is closed */);
     121
     122                            // Draw a line to the next specified point.
     123                            ctx.LineTo(new Point(13, 21), true /* is stroked */, false /* is smooth join */);
     124
     125                            // Draw another line to the next specified point.
     126                            ctx.LineTo(new Point(20, 18), true /* is stroked */, false /* is smooth join */);
     127                        }
     128
     129                        // Freeze the geometry (make it unmodifiable)
     130                        // for additional performance benefits.
     131                        geometryLT.Freeze();
     132
     133                        // Specify the shape (triangle) of the Path using the StreamGeometry.
     134                        leftTriangle.Data = geometryLT;
     135
     136                        myGrid.Children.Add(leftTriangle);
     137
     138                        // add right triangle ///////////////////
     139                        // Create a path to draw a geometry with.
     140                        Path rightTriangle = new Path();
     141                        rightTriangle.Stroke = Brushes.Black;
     142                        rightTriangle.StrokeThickness = 1;
     143                        rightTriangle.Fill = Brushes.Black;
     144
     145                        // Create a StreamGeometry to use to specify myPath.
     146                        StreamGeometry geometryRT = new StreamGeometry();
     147                        geometryRT.FillRule = FillRule.EvenOdd;
     148
     149                        // Open a StreamGeometryContext that can be used to describe this StreamGeometry
     150                        // object's contents.
     151                        using (StreamGeometryContext ctx = geometryRT.Open())
     152                        {
     153
     154                            // Begin the triangle at the point specified. Notice that the shape is set to
     155                            // be closed so only two lines need to be specified below to make the triangle.
     156                            ctx.BeginFigure(new Point(60 + state.Length * 30, 15), true /* is filled */, true /* is closed */);
     157
     158                            // Draw a line to the next specified point.
     159                            ctx.LineTo(new Point(60 + state.Length * 30, 21), true /* is stroked */, false /* is smooth join */);
     160
     161                            // Draw another line to the next specified point.
     162                            ctx.LineTo(new Point(67 + state.Length * 30, 18), true /* is stroked */, false /* is smooth join */);
     163                        }
     164
     165                        // Freeze the geometry (make it unmodifiable)
     166                        // for additional performance benefits.
     167                        geometryRT.Freeze();
     168
     169                        // Specify the shape (triangle) of the Path using the StreamGeometry.
     170                        rightTriangle.Data = geometryRT;
     171
     172                        // Data="M180,14 L180,22 L187,18 Z"
     173                        myGrid.Children.Add(rightTriangle);
     174
     175
     176
     177                        TextBox[] myTextBoxes = new TextBox[state.Length];
     178                        Grid[] myGrids = new Grid[state.Length];
     179                        Ellipse[] myEllipses = new Ellipse[state.Length];
     180                        Line[] myLinesVert = new Line[state.Length];
     181                        Line[] myLinesVertRed = new Line[state.Length];
     182                        Line[] myLinesHori = new Line[state.Length];
     183
     184                        // add TextBoxes
     185                        int i;
     186                        double left;
     187                        for (i = 0; i < state.Length; i++)
     188                        {
     189                            // add textboxes
     190                            left = (double)i * 29 + 20;
     191                            myTextBoxes[i] = new TextBox();
     192                            myTextBoxes[i].Margin = new Thickness(left, 3, 0, 0);
     193                            myTextBoxes[i].Width = 30;
     194                            myTextBoxes[i].Height = 30;
     195                            myTextBoxes[i].HorizontalAlignment = HorizontalAlignment.Left;
     196                            myTextBoxes[i].VerticalAlignment = VerticalAlignment.Top;
     197                            myTextBoxes[i].Name = "textBoxBit" + i;
     198                            myTextBoxes[i].Visibility = Visibility.Visible;
     199                            myTextBoxes[i].BorderThickness = new Thickness(1);
     200                            myTextBoxes[i].IsReadOnly = true;
     201                            myTextBoxes[i].TextAlignment = TextAlignment.Center;
     202                            myTextBoxes[i].VerticalContentAlignment = VerticalAlignment.Center;
     203                            myTextBoxes[i].BorderBrush = Brushes.Black;
     204                            //if (tapSequence[i] == '1') myTextBoxes[i].Background = Brushes.DodgerBlue;
     205                            if (clockingBit == i) myTextBoxes[i].Background = Brushes.Orange;
     206
     207                            myGrid.Children.Add(myTextBoxes[i]);
     208
     209                            // add XORs
     210                            myGrids[i] = new Grid();
     211                            myGrids[i].Name = "XORGrid" + i;
     212                            myGrids[i].Height = 30;
     213                            myGrids[i].Width = 30;
     214                            myGrids[i].HorizontalAlignment = HorizontalAlignment.Left;
     215                            myGrids[i].VerticalAlignment = VerticalAlignment.Top;
     216                            myGrids[i].Margin = new Thickness(left, 32, 0, 0);
     217
     218                            myGrid.Children.Add(myGrids[i]);
     219
     220                            if (tapSequence[i] == '0') myGrids[i].Visibility = Visibility.Hidden;
     221                            else
     222                            {
     223                                myEllipses[i] = new Ellipse();
     224                                myEllipses[i].Name = "ellipseXOR" + i;
     225                                myEllipses[i].Stroke = Brushes.DodgerBlue;
     226                                myEllipses[i].Margin = new Thickness(9, 9, 9, 9);
     227
     228                                myLinesVert[i] = new Line();
     229                                myLinesVert[i].Name = "VertLineXOR" + i;
     230                                myLinesVert[i].Stroke = Brushes.Black;
     231                                myLinesVert[i].StrokeThickness = 1;
     232                                myLinesVert[i].X1 = 15;
     233                                myLinesVert[i].Y1 = 0.5;
     234                                myLinesVert[i].X2 = 15;
     235                                myLinesVert[i].Y2 = 9;
     236
     237                                myLinesVertRed[i] = new Line();
     238                                myLinesVertRed[i].Name = "VertLineXORRed" + i;
     239                                myLinesVertRed[i].Stroke = Brushes.DodgerBlue;
     240                                myLinesVertRed[i].StrokeThickness = 1;
     241                                myLinesVertRed[i].X1 = 15;
     242                                myLinesVertRed[i].Y1 = 9;
     243                                myLinesVertRed[i].X2 = 15;
     244                                myLinesVertRed[i].Y2 = 20;
     245
     246                                myLinesHori[i] = new Line();
     247                                myLinesHori[i].Name = "HoriLineXOR" + i;
     248                                myLinesHori[i].Stroke = Brushes.DodgerBlue;
     249                                myLinesHori[i].StrokeThickness = 1;
     250                                myLinesHori[i].X1 = 9;
     251                                myLinesHori[i].Y1 = 15;
     252                                myLinesHori[i].X2 = 20;
     253                                myLinesHori[i].Y2 = 15;
     254
     255                                myGrids[i].Children.Add(myEllipses[i]);
     256                                myGrids[i].Children.Add(myLinesVert[i]);
     257                                myGrids[i].Children.Add(myLinesVertRed[i]);
     258                                myGrids[i].Children.Add(myLinesHori[i]);
     259                            }
     260                        }
     261                        // disable /*last*/ and first XOR
     262                        //myGrids[0].Visibility = Visibility.Hidden;
     263                        myGrids[state.Length - 1].Visibility = Visibility.Hidden;
     264
     265                        // add output bit label
     266                        Label outPutLabel = new Label();
     267                        left = (double)i * 30 + 65;
     268                        outPutLabel.Margin = new Thickness(left, 3, 0, 0);
     269                        outPutLabel.Width = 30;
     270                        outPutLabel.Height = 30;
     271                        outPutLabel.HorizontalContentAlignment = HorizontalAlignment.Center;
     272                        outPutLabel.VerticalContentAlignment = VerticalAlignment.Center;
     273                        outPutLabel.HorizontalAlignment = HorizontalAlignment.Left;
     274                        outPutLabel.VerticalAlignment = VerticalAlignment.Top;
     275                        outPutLabel.Name = "outputLabel";
     276                        myGrid.Children.Add(outPutLabel);
    125277                    }
    126 
    127                     // Freeze the geometry (make it unmodifiable)
    128                     // for additional performance benefits.
    129                     geometryLT.Freeze();
    130 
    131                     // Specify the shape (triangle) of the Path using the StreamGeometry.
    132                     leftTriangle.Data = geometryLT;
    133 
    134                     myGrid.Children.Add(leftTriangle);
    135 
    136                     // add right triangle ///////////////////
    137                     // Create a path to draw a geometry with.
    138                     Path rightTriangle = new Path();
    139                     rightTriangle.Stroke = Brushes.Black;
    140                     rightTriangle.StrokeThickness = 1;
    141                     rightTriangle.Fill = Brushes.Black;
    142 
    143                     // Create a StreamGeometry to use to specify myPath.
    144                     StreamGeometry geometryRT = new StreamGeometry();
    145                     geometryRT.FillRule = FillRule.EvenOdd;
    146 
    147                     // Open a StreamGeometryContext that can be used to describe this StreamGeometry
    148                     // object's contents.
    149                     using (StreamGeometryContext ctx = geometryRT.Open())
     278                    catch (Exception ex)
    150279                    {
    151280
    152                         // Begin the triangle at the point specified. Notice that the shape is set to
    153                         // be closed so only two lines need to be specified below to make the triangle.
    154                         ctx.BeginFigure(new Point(60 + state.Length * 30, 15), true /* is filled */, true /* is closed */);
    155 
    156                         // Draw a line to the next specified point.
    157                         ctx.LineTo(new Point(60 + state.Length * 30, 21), true /* is stroked */, false /* is smooth join */);
    158 
    159                         // Draw another line to the next specified point.
    160                         ctx.LineTo(new Point(67 + state.Length * 30, 18), true /* is stroked */, false /* is smooth join */);
    161281                    }
    162 
    163                     // Freeze the geometry (make it unmodifiable)
    164                     // for additional performance benefits.
    165                     geometryRT.Freeze();
    166 
    167                     // Specify the shape (triangle) of the Path using the StreamGeometry.
    168                     rightTriangle.Data = geometryRT;
    169 
    170                     // Data="M180,14 L180,22 L187,18 Z"
    171                     myGrid.Children.Add(rightTriangle);
    172 
    173 
    174 
    175                     TextBox[] myTextBoxes = new TextBox[state.Length];
    176                     Grid[] myGrids = new Grid[state.Length];
    177                     Ellipse[] myEllipses = new Ellipse[state.Length];
    178                     Line[] myLinesVert = new Line[state.Length];
    179                     Line[] myLinesVertRed = new Line[state.Length];
    180                     Line[] myLinesHori = new Line[state.Length];
    181 
    182                     // add TextBoxes
    183                     int i;
    184                     double left;
    185                     for (i = 0; i < state.Length; i++)
    186                     {
    187                         // add textboxes
    188                         left = (double)i * 29 + 20;
    189                         myTextBoxes[i] = new TextBox();
    190                         myTextBoxes[i].Margin = new Thickness(left, 3, 0, 0);
    191                         myTextBoxes[i].Width = 30;
    192                         myTextBoxes[i].Height = 30;
    193                         myTextBoxes[i].HorizontalAlignment = HorizontalAlignment.Left;
    194                         myTextBoxes[i].VerticalAlignment = VerticalAlignment.Top;
    195                         myTextBoxes[i].Name = "textBoxBit" + i;
    196                         myTextBoxes[i].Visibility = Visibility.Visible;
    197                         myTextBoxes[i].BorderThickness = new Thickness(1);
    198                         myTextBoxes[i].IsReadOnly = true;
    199                         myTextBoxes[i].TextAlignment = TextAlignment.Center;
    200                         myTextBoxes[i].VerticalContentAlignment = VerticalAlignment.Center;
    201                         myTextBoxes[i].BorderBrush = Brushes.Black;
    202                         //if (tapSequence[i] == '1') myTextBoxes[i].Background = Brushes.DodgerBlue;
    203                         if (clockingBit == i) myTextBoxes[i].Background = Brushes.Orange;
    204 
    205                         myGrid.Children.Add(myTextBoxes[i]);
    206 
    207                         // add XORs
    208                         myGrids[i] = new Grid();
    209                         myGrids[i].Name = "XORGrid" + i;
    210                         myGrids[i].Height = 30;
    211                         myGrids[i].Width = 30;
    212                         myGrids[i].HorizontalAlignment = HorizontalAlignment.Left;
    213                         myGrids[i].VerticalAlignment = VerticalAlignment.Top;
    214                         myGrids[i].Margin = new Thickness(left, 32, 0, 0);
    215 
    216                         myGrid.Children.Add(myGrids[i]);
    217 
    218                         if (tapSequence[i] == '0') myGrids[i].Visibility = Visibility.Hidden;
    219                         else
    220                         {
    221                             myEllipses[i] = new Ellipse();
    222                             myEllipses[i].Name = "ellipseXOR" + i;
    223                             myEllipses[i].Stroke = Brushes.DodgerBlue;
    224                             myEllipses[i].Margin = new Thickness(9, 9, 9, 9);
    225 
    226                             myLinesVert[i] = new Line();
    227                             myLinesVert[i].Name = "VertLineXOR" + i;
    228                             myLinesVert[i].Stroke = Brushes.Black;
    229                             myLinesVert[i].StrokeThickness = 1;
    230                             myLinesVert[i].X1 = 15;
    231                             myLinesVert[i].Y1 = 0.5;
    232                             myLinesVert[i].X2 = 15;
    233                             myLinesVert[i].Y2 = 9;
    234 
    235                             myLinesVertRed[i] = new Line();
    236                             myLinesVertRed[i].Name = "VertLineXORRed" + i;
    237                             myLinesVertRed[i].Stroke = Brushes.DodgerBlue;
    238                             myLinesVertRed[i].StrokeThickness = 1;
    239                             myLinesVertRed[i].X1 = 15;
    240                             myLinesVertRed[i].Y1 = 9;
    241                             myLinesVertRed[i].X2 = 15;
    242                             myLinesVertRed[i].Y2 = 20;
    243 
    244                             myLinesHori[i] = new Line();
    245                             myLinesHori[i].Name = "HoriLineXOR" + i;
    246                             myLinesHori[i].Stroke = Brushes.DodgerBlue;
    247                             myLinesHori[i].StrokeThickness = 1;
    248                             myLinesHori[i].X1 = 9;
    249                             myLinesHori[i].Y1 = 15;
    250                             myLinesHori[i].X2 = 20;
    251                             myLinesHori[i].Y2 = 15;
    252 
    253                             myGrids[i].Children.Add(myEllipses[i]);
    254                             myGrids[i].Children.Add(myLinesVert[i]);
    255                             myGrids[i].Children.Add(myLinesVertRed[i]);
    256                             myGrids[i].Children.Add(myLinesHori[i]);
    257                         }
    258                     }
    259                     // disable /*last*/ and first XOR
    260                     //myGrids[0].Visibility = Visibility.Hidden;
    261                     myGrids[state.Length - 1].Visibility = Visibility.Hidden;
    262 
    263                     // add output bit label
    264                     Label outPutLabel = new Label();
    265                     left = (double)i * 30 + 65;
    266                     outPutLabel.Margin = new Thickness(left, 3, 0, 0);
    267                     outPutLabel.Width = 30;
    268                     outPutLabel.Height = 30;
    269                     outPutLabel.HorizontalContentAlignment = HorizontalAlignment.Center;
    270                     outPutLabel.VerticalContentAlignment = VerticalAlignment.Center;
    271                     outPutLabel.HorizontalAlignment = HorizontalAlignment.Left;
    272                     outPutLabel.VerticalAlignment = VerticalAlignment.Top;
    273                     outPutLabel.Name = "outputLabel";
    274                     myGrid.Children.Add(outPutLabel);
    275282
    276283                }, null);
     
    334341            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    335342            {
    336                 if (logLevel == NotificationLevel.Warning) completeGrid.Background = Brushes.Gold;
    337                 if (logLevel == NotificationLevel.Error) completeGrid.Background = Brushes.Red;
    338                 if (logLevel == NotificationLevel.Info) completeGrid.Background = Brushes.White;
     343                if (logLevel == NotificationLevel.Warning) innercircle.Fill = Brushes.Gold;
     344                if (logLevel == NotificationLevel.Error) innercircle.Fill = Brushes.Red;
     345                if (logLevel == NotificationLevel.Info) innercircle.Fill = Brushes.White;
    339346            }, null);
    340347        }
     
    346353            {
    347354                if (completeGrid != null)
    348                     myBrush = completeGrid.Background;
     355                    myBrush = innercircle.Fill;
    349356            }, null);
    350357
  • trunk/CrypPlugins/LFSR/LFSRSettings.cs

    r875 r956  
    2323        #region ISettings Members
    2424
    25         private string currentState = null;
     25        private string currentState;
    2626        public string CurrentState
    2727        {
     
    2929            set
    3030            {
    31                 if (value != currentState) hasChanges = true;
    32                 currentState = value;
     31                if (value != currentState)
     32                {
     33                    currentState = value;
     34                    hasChanges = true;
     35                }
    3336            }
    3437        }
     
    5760
    5861        string polynomial;
    59         [TaskPane("Polynomial", "Define the feedback polynomial either in a textual or a numeric way. For example x^5 + x^2 + 1 which is equal to 10010.", null, 0, false, DisplayLevel.Beginner, ControlType.TextBox)]
     62        [TaskPane("Feedback polynomial", "Define the feedback polynomial either in a textual or a numeric way. For example x^5 + x^2 + 1 which is equal to 10010.", null, 0, false, DisplayLevel.Beginner, ControlType.TextBox)]
    6063        public string Polynomial
    6164        {
     
    7073       
    7174        string seed;
    72         [TaskPane("Seed", "Define the seed of the LFSR. For example 11100", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
     75        [TaskPane("Seed", "Define the seed (initial state) of the LFSR. For example 11100", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
    7376        public string Seed
    7477        {
     
    191194        }
    192195
     196        internal void UpdateTaskPaneVisibility()
     197        {
     198            if (TaskPaneAttributeChanged == null)
     199                return;
     200
     201            if (this.useBoolClock)
     202                SettingChanged("Rounds", Visibility.Collapsed);
     203            else
     204                SettingChanged("Rounds", Visibility.Visible);
     205
     206            if (this.useAdditionalOutputBit)
     207                SettingChanged("ClockingBit", Visibility.Visible);
     208            else
     209                SettingChanged("ClockingBit", Visibility.Collapsed);
     210        }
     211
    193212        #endregion
    194213
  • trunk/CrypPlugins/NLFSR/NLFSR.cs

    r900 r956  
    3636        private String inputTapSequence;
    3737        private String inputSeed;
    38         //private CryptoolStream outputStream;
    3938        private String outputString;
    4039        private bool outputBool;
     
    4443       
    4544        private NLFSRPresentation NLFSRPresentation;
    46         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4745
    4846        #endregion
     
    142140        }
    143141
    144         /*[PropertyInfo(Direction.OutputData, "Output stream", "NLFSR Stream Output. Use this for bulk output.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    145         public CryptoolStream OutputStream
    146         {
    147             //[MethodImpl(MethodImplOptions.Synchronized)]
    148             get
    149             {
    150                 if (this.outputStream != null)
    151                 {
    152                     CryptoolStream cs = new CryptoolStream();
    153                     listCryptoolStreamsOut.Add(cs);
    154                     cs.OpenRead(this.outputStream.FileName);
    155                     return cs;
    156                 }
    157                 return null;
    158             }
    159             //[MethodImpl(MethodImplOptions.Synchronized)]
    160             set
    161             {
    162                 outputStream = value;
    163                 if (value != null) listCryptoolStreamsOut.Add(value);
    164                 OnPropertyChanged("OutputStream");
    165             }
    166         }*/
    167 
    168142        [PropertyInfo(Direction.OutputData, "String Output", "Produces the output bits as a string with length==rounds. Use this output without a clock input.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    169143        public String OutputString
     
    216190            {
    217191                stop = false;
    218                 //outputStream = null;
    219192                outputString = null;
    220193                outputStringBuffer = null;
    221194                inputTapSequence = null;
    222195                inputSeed = null;
    223 
    224                 /*if (outputStream != null)
    225                 {
    226                     outputStream.Flush();
    227                     outputStream.Close();
    228                     outputStream = null;
    229                 }
    230                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    231                 {
    232                     stream.Close();
    233                 }
    234                 listCryptoolStreamsOut.Clear();
    235                  */
    236196            }
    237197            catch (Exception ex)
     
    524484            if (checkForInputSeed() == 1) return;
    525485
    526             /*if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
    527             {
    528                 GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error);
    529                 if (!settings.UseBoolClock) inputClock.Close();
    530                 return;
    531             }
    532 
    533             if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
    534             {
    535                 GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error);
    536                 if (!settings.UseBoolClock) inputClock.Close();
    537                 return;
    538             }*/
    539 
    540486            // read tapSequence
    541487            if (settings.Polynomial == null || (settings.Polynomial != null && settings.Polynomial.Length == 0))
     
    545491
    546492            //read seed
    547             if (settings.CurrentState != null && settings.CurrentState.Length != 0)
     493            if (settings.SaveCurrentState && settings.CurrentState != null && settings.CurrentState.Length != 0 && settings.CurrentState != "0")
    548494                seedbuffer = settings.CurrentState;
    549495            else if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
     
    643589            try
    644590            {
    645                 /*char[] tapSequenceCharArray = null;
    646                 int seedBits = 1; // dummy value for compiler
    647                 int actualRounds = 1; // dummy value for compiler
    648                 Boolean myClock = true;
    649                 char[] seedCharArray = null;
    650 
    651                 // open output stream
    652                 outputStream = new CryptoolStream();
    653                 listCryptoolStreamsOut.Add(outputStream);
    654                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
    655                 */
    656 
    657591                // make all this stuff only one time at the beginning of our chainrun
    658592                if (newSeed)
     
    678612                    NLFSRPresentation.DrawNLFSR(seedCharArray, tapSequenceCharArray, clocking);
    679613                }
    680 
    681                 // open output stream
    682                 /*outputStream = new CryptoolStream();
    683                 listCryptoolStreamsOut.Add(outputStream);
    684                 outputStream.OpenWrite();*/
    685614
    686615                //GuiLogMessage("Action is: Now!", NotificationLevel.Debug);
     
    696625                for (i = 0; i < actualRounds; i++)
    697626                {
     627                    if (stop) return;
    698628                    // compute only if clock = 1 or true
    699629                    if (myClock)
     
    795725
    796726                            // write bit to output buffer, stream and bool
    797 
    798                             //outputStream.Write((Byte)outputbuffer);
    799727                            outputBoolArray[0] = outputBool;
    800728                            OnPropertyChanged("OutputBool");
    801729                            OnPropertyChanged("OutputBoolArray");
    802                             //OnPropertyChanged("OutputStream");
    803730
    804731                            // update quickwatch presentation
     
    835762                    // reset newSeed after first round
    836763                    newSeed = false;
     764                    if (!settings.UseBoolClock)
     765                    {
     766                        ProgressChanged((double)i, (double)actualRounds);
     767                    }
    837768                }
    838769
     
    842773                TimeSpan duration = stopTime - startTime;
    843774
     775                // change progress to 100%
     776                ProgressChanged(1.0, 1.0);
     777
    844778                if (!stop)
    845779                {
     
    849783
    850784                    GuiLogMessage("Complete!", NotificationLevel.Debug);
    851 
    852785                    GuiLogMessage("Time used: " + duration, NotificationLevel.Debug);
    853                     //outputStream.Close();
    854                     //OnPropertyChanged("OutputStream");
    855786                }
    856787
    857788                if (stop)
    858789                {
    859                     //outputStream.Close();
    860790                    outputStringBuffer = null;
    861791                    GuiLogMessage("Aborted!", NotificationLevel.Debug);
  • trunk/CrypPlugins/NLFSR/NLFSRPresentation.xaml.cs

    r841 r956  
    4444            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    4545            {
    46                 // hide initial textbox
    47                 infoText.Visibility = Visibility.Hidden;
    48 
    49                 // add lines and triangles
    50                 Line HoriLine1 = new Line();
    51                 HoriLine1.X1 = 5;
    52                 HoriLine1.Y1 = 18;
    53                 HoriLine1.X2 = 60 + state.Length * 30;
    54                 HoriLine1.Y2 = 18;
    55                 HoriLine1.Stroke = Brushes.Black;
    56                 HoriLine1.StrokeThickness = 1;
    57                 myGrid.Children.Add(HoriLine1);
    58 
    59                 Line HoriLine2 = new Line();
    60                 HoriLine2.X1 = 5;
    61                 HoriLine2.Y1 = 57;
    62                 HoriLine2.X2 = 35 + (state.Length - 1) * 29;
    63                 HoriLine2.Y2 = 57;
    64                 HoriLine2.Stroke = Brushes.Black;
    65                 HoriLine1.StrokeThickness = 1;
    66                 myGrid.Children.Add(HoriLine2);
    67 
    68                 Line VertLine1 = new Line();
    69                 VertLine1.X1 = 5;
    70                 VertLine1.Y1 = 17.5;
    71                 VertLine1.X2 = 5;
    72                 VertLine1.Y2 = 57.5;
    73                 VertLine1.Stroke = Brushes.Black;
    74                 VertLine1.StrokeThickness = 1;
    75                 myGrid.Children.Add(VertLine1);
    76 
    77                 /*Line VertLine2 = new Line();
    78                 VertLine2.X1 = 35 + (state.Length - 1) * 29;
    79                 VertLine2.Y1 = 32;
    80                 VertLine2.X2 = 35 + (state.Length - 1) * 29;
    81                 VertLine2.Y2 = 47;
    82                 VertLine2.Stroke = Brushes.Black;
    83                 VertLine2.StrokeThickness = 1;
    84                 myGrid.Children.Add(VertLine2);*/
    85 
    86                 // add connection circle
    87                 /*Ellipse ConnectionCircle = new Ellipse();
    88                 ConnectionCircle.HorizontalAlignment = HorizontalAlignment.Left;
    89                 ConnectionCircle.VerticalAlignment = VerticalAlignment.Top;
    90                 ConnectionCircle.Fill = Brushes.Black;
    91                 ConnectionCircle.Width = 4;
    92                 ConnectionCircle.Height = 4;
    93                 ConnectionCircle.Margin = new Thickness(27.5 + state.Length * 30, 15.5, 0, 0);
    94                 myGrid.Children.Add(ConnectionCircle);*/
    95 
    96                 // add left triangle ////////////////////
    97                 // Create a path to draw a geometry with.
    98                 Path leftTriangle = new Path();
    99                 leftTriangle.Stroke = Brushes.Black;
    100                 leftTriangle.StrokeThickness = 1;
    101                 leftTriangle.Fill = Brushes.Black;
    102 
    103                 // Create a StreamGeometry to use to specify myPath.
    104                 StreamGeometry geometryLT = new StreamGeometry();
    105                 geometryLT.FillRule = FillRule.EvenOdd;
    106 
    107                 // Open a StreamGeometryContext that can be used to describe this StreamGeometry
    108                 // object's contents.
    109                 using (StreamGeometryContext ctx = geometryLT.Open())
     46                try
    11047                {
    111 
    112                     // Begin the triangle at the point specified. Notice that the shape is set to
    113                     // be closed so only two lines need to be specified below to make the triangle.
    114                     ctx.BeginFigure(new Point(13, 15), true /* is filled */, true /* is closed */);
    115 
    116                     // Draw a line to the next specified point.
    117                     ctx.LineTo(new Point(13, 21), true /* is stroked */, false /* is smooth join */);
    118 
    119                     // Draw another line to the next specified point.
    120                     ctx.LineTo(new Point(20, 18), true /* is stroked */, false /* is smooth join */);
     48                    // hide initial textbox
     49                    infoText.Visibility = Visibility.Hidden;
     50
     51                    // add lines and triangles
     52                    Line HoriLine1 = new Line();
     53                    HoriLine1.X1 = 5;
     54                    HoriLine1.Y1 = 18;
     55                    HoriLine1.X2 = 60 + state.Length * 30;
     56                    HoriLine1.Y2 = 18;
     57                    HoriLine1.Stroke = Brushes.Black;
     58                    HoriLine1.StrokeThickness = 1;
     59                    myGrid.Children.Add(HoriLine1);
     60
     61                    Line HoriLine2 = new Line();
     62                    HoriLine2.X1 = 5;
     63                    HoriLine2.Y1 = 57;
     64                    HoriLine2.X2 = 35 + (state.Length - 1) * 29;
     65                    HoriLine2.Y2 = 57;
     66                    HoriLine2.Stroke = Brushes.Black;
     67                    HoriLine1.StrokeThickness = 1;
     68                    myGrid.Children.Add(HoriLine2);
     69
     70                    Line VertLine1 = new Line();
     71                    VertLine1.X1 = 5;
     72                    VertLine1.Y1 = 17.5;
     73                    VertLine1.X2 = 5;
     74                    VertLine1.Y2 = 57.5;
     75                    VertLine1.Stroke = Brushes.Black;
     76                    VertLine1.StrokeThickness = 1;
     77                    myGrid.Children.Add(VertLine1);
     78
     79                    /*Line VertLine2 = new Line();
     80                    VertLine2.X1 = 35 + (state.Length - 1) * 29;
     81                    VertLine2.Y1 = 32;
     82                    VertLine2.X2 = 35 + (state.Length - 1) * 29;
     83                    VertLine2.Y2 = 47;
     84                    VertLine2.Stroke = Brushes.Black;
     85                    VertLine2.StrokeThickness = 1;
     86                    myGrid.Children.Add(VertLine2);*/
     87
     88                    // add connection circle
     89                    /*Ellipse ConnectionCircle = new Ellipse();
     90                    ConnectionCircle.HorizontalAlignment = HorizontalAlignment.Left;
     91                    ConnectionCircle.VerticalAlignment = VerticalAlignment.Top;
     92                    ConnectionCircle.Fill = Brushes.Black;
     93                    ConnectionCircle.Width = 4;
     94                    ConnectionCircle.Height = 4;
     95                    ConnectionCircle.Margin = new Thickness(27.5 + state.Length * 30, 15.5, 0, 0);
     96                    myGrid.Children.Add(ConnectionCircle);*/
     97
     98                    // add left triangle ////////////////////
     99                    // Create a path to draw a geometry with.
     100                    Path leftTriangle = new Path();
     101                    leftTriangle.Stroke = Brushes.Black;
     102                    leftTriangle.StrokeThickness = 1;
     103                    leftTriangle.Fill = Brushes.Black;
     104
     105                    // Create a StreamGeometry to use to specify myPath.
     106                    StreamGeometry geometryLT = new StreamGeometry();
     107                    geometryLT.FillRule = FillRule.EvenOdd;
     108
     109                    // Open a StreamGeometryContext that can be used to describe this StreamGeometry
     110                    // object's contents.
     111                    using (StreamGeometryContext ctx = geometryLT.Open())
     112                    {
     113
     114                        // Begin the triangle at the point specified. Notice that the shape is set to
     115                        // be closed so only two lines need to be specified below to make the triangle.
     116                        ctx.BeginFigure(new Point(13, 15), true /* is filled */, true /* is closed */);
     117
     118                        // Draw a line to the next specified point.
     119                        ctx.LineTo(new Point(13, 21), true /* is stroked */, false /* is smooth join */);
     120
     121                        // Draw another line to the next specified point.
     122                        ctx.LineTo(new Point(20, 18), true /* is stroked */, false /* is smooth join */);
     123                    }
     124
     125                    // Freeze the geometry (make it unmodifiable)
     126                    // for additional performance benefits.
     127                    geometryLT.Freeze();
     128
     129                    // Specify the shape (triangle) of the Path using the StreamGeometry.
     130                    leftTriangle.Data = geometryLT;
     131
     132                    myGrid.Children.Add(leftTriangle);
     133
     134                    // add right triangle ///////////////////
     135                    // Create a path to draw a geometry with.
     136                    Path rightTriangle = new Path();
     137                    rightTriangle.Stroke = Brushes.Black;
     138                    rightTriangle.StrokeThickness = 1;
     139                    rightTriangle.Fill = Brushes.Black;
     140
     141                    // Create a StreamGeometry to use to specify myPath.
     142                    StreamGeometry geometryRT = new StreamGeometry();
     143                    geometryRT.FillRule = FillRule.EvenOdd;
     144
     145                    // Open a StreamGeometryContext that can be used to describe this StreamGeometry
     146                    // object's contents.
     147                    using (StreamGeometryContext ctx = geometryRT.Open())
     148                    {
     149
     150                        // Begin the triangle at the point specified. Notice that the shape is set to
     151                        // be closed so only two lines need to be specified below to make the triangle.
     152                        ctx.BeginFigure(new Point(60 + state.Length * 30, 15), true /* is filled */, true /* is closed */);
     153
     154                        // Draw a line to the next specified point.
     155                        ctx.LineTo(new Point(60 + state.Length * 30, 21), true /* is stroked */, false /* is smooth join */);
     156
     157                        // Draw another line to the next specified point.
     158                        ctx.LineTo(new Point(67 + state.Length * 30, 18), true /* is stroked */, false /* is smooth join */);
     159                    }
     160
     161                    // Freeze the geometry (make it unmodifiable)
     162                    // for additional performance benefits.
     163                    geometryRT.Freeze();
     164
     165                    // Specify the shape (triangle) of the Path using the StreamGeometry.
     166                    rightTriangle.Data = geometryRT;
     167
     168                    // Data="M180,14 L180,22 L187,18 Z"
     169                    myGrid.Children.Add(rightTriangle);
     170
     171
     172
     173                    TextBox[] myTextBoxes = new TextBox[state.Length];
     174                    Grid[] myGrids = new Grid[state.Length];
     175                    Ellipse[] myEllipses = new Ellipse[state.Length];
     176                    Line[] myLinesVert = new Line[state.Length];
     177                    Line[] myLinesVertRed = new Line[state.Length];
     178                    Line[] myLinesHori = new Line[state.Length];
     179
     180                    // add TextBoxes
     181                    int i;
     182                    double left;
     183                    for (i = 0; i < state.Length; i++)
     184                    {
     185                        // add textboxes
     186                        left = (double)i * 29 + 20;
     187                        myTextBoxes[i] = new TextBox();
     188                        myTextBoxes[i].Margin = new Thickness(left, 3, 0, 0);
     189                        myTextBoxes[i].Width = 30;
     190                        myTextBoxes[i].Height = 30;
     191                        myTextBoxes[i].HorizontalAlignment = HorizontalAlignment.Left;
     192                        myTextBoxes[i].VerticalAlignment = VerticalAlignment.Top;
     193                        myTextBoxes[i].Name = "textBoxBit" + i;
     194                        myTextBoxes[i].Visibility = Visibility.Visible;
     195                        myTextBoxes[i].BorderThickness = new Thickness(1);
     196                        myTextBoxes[i].IsReadOnly = true;
     197                        myTextBoxes[i].TextAlignment = TextAlignment.Center;
     198                        myTextBoxes[i].VerticalContentAlignment = VerticalAlignment.Center;
     199                        myTextBoxes[i].BorderBrush = Brushes.Black;
     200                        if (clockingBit == i) myTextBoxes[i].Background = Brushes.Orange;
     201
     202                        myGrid.Children.Add(myTextBoxes[i]);
     203
     204                        // add XORs
     205                        myGrids[i] = new Grid();
     206                        myGrids[i].Name = "XORGrid" + i;
     207                        myGrids[i].Height = 30;
     208                        myGrids[i].Width = 30;
     209                        myGrids[i].HorizontalAlignment = HorizontalAlignment.Left;
     210                        myGrids[i].VerticalAlignment = VerticalAlignment.Top;
     211                        myGrids[i].Margin = new Thickness(left, 32, 0, 0);
     212
     213                        myGrid.Children.Add(myGrids[i]);
     214
     215                        if (tapSequence[i] == '0') myGrids[i].Visibility = Visibility.Hidden;
     216                        else
     217                        {
     218                            /*myEllipses[i] = new Ellipse();
     219                            myEllipses[i].Name = "ellipseXOR" + i;
     220                            myEllipses[i].Stroke = Brushes.DodgerBlue;
     221                            myEllipses[i].Margin = new Thickness(9, 9, 9, 9);
     222                            */
     223                            myLinesVert[i] = new Line();
     224                            myLinesVert[i].Name = "VertLineXOR" + i;
     225                            myLinesVert[i].Stroke = Brushes.Black;
     226                            myLinesVert[i].StrokeThickness = 1;
     227                            myLinesVert[i].X1 = 15;
     228                            myLinesVert[i].Y1 = 0.5;
     229                            myLinesVert[i].X2 = 15;
     230                            myLinesVert[i].Y2 = 15;
     231
     232                            /*myLinesVertRed[i] = new Line();
     233                            myLinesVertRed[i].Name = "VertLineXORRed" + i;
     234                            myLinesVertRed[i].Stroke = Brushes.DodgerBlue;
     235                            myLinesVertRed[i].StrokeThickness = 1;
     236                            myLinesVertRed[i].X1 = 15;
     237                            myLinesVertRed[i].Y1 = 9;
     238                            myLinesVertRed[i].X2 = 15;
     239                            myLinesVertRed[i].Y2 = 20;
     240                       
     241                            myLinesHori[i] = new Line();
     242                            myLinesHori[i].Name = "HoriLineXOR" + i;
     243                            myLinesHori[i].Stroke = Brushes.DodgerBlue;
     244                            myLinesHori[i].StrokeThickness = 1;
     245                            myLinesHori[i].X1 = 9;
     246                            myLinesHori[i].Y1 = 15;
     247                            myLinesHori[i].X2 = 20;
     248                            myLinesHori[i].Y2 = 15;
     249                            */
     250                            //myGrids[i].Children.Add(myEllipses[i]);
     251                            myGrids[i].Children.Add(myLinesVert[i]);
     252                            //myGrids[i].Children.Add(myLinesVertRed[i]);
     253                            //myGrids[i].Children.Add(myLinesHori[i]);
     254                        }
     255                    }
     256                    // disable /*last*/ and first XOR
     257                    //myGrids[0].Visibility = Visibility.Hidden;
     258                    //myGrids[state.Length - 1].Visibility = Visibility.Hidden;
     259
     260                    // add output bit label
     261                    Label outPutLabel = new Label();
     262                    left = (double)i * 30 + 65;
     263                    outPutLabel.Margin = new Thickness(left, 3, 0, 0);
     264                    outPutLabel.Width = 30;
     265                    outPutLabel.Height = 30;
     266                    outPutLabel.HorizontalContentAlignment = HorizontalAlignment.Center;
     267                    outPutLabel.VerticalContentAlignment = VerticalAlignment.Center;
     268                    outPutLabel.HorizontalAlignment = HorizontalAlignment.Left;
     269                    outPutLabel.VerticalAlignment = VerticalAlignment.Top;
     270                    outPutLabel.Name = "outputLabel";
     271                    myGrid.Children.Add(outPutLabel);
     272
     273                    // add function box underneath
     274                    TextBox functionTextBox = new TextBox();
     275                    functionTextBox.Margin = new Thickness(20, 43, 0, 0);
     276                    functionTextBox.Width = 29 * i + 1;
     277                    functionTextBox.Height = 30;
     278                    functionTextBox.HorizontalAlignment = HorizontalAlignment.Left;
     279                    functionTextBox.VerticalAlignment = VerticalAlignment.Top;
     280                    functionTextBox.Name = "functionTextBox";
     281                    functionTextBox.Visibility = Visibility.Visible;
     282                    functionTextBox.BorderThickness = new Thickness(1);
     283                    functionTextBox.IsReadOnly = true;
     284                    functionTextBox.TextAlignment = TextAlignment.Center;
     285                    functionTextBox.VerticalContentAlignment = VerticalAlignment.Center;
     286                    functionTextBox.BorderBrush = Brushes.DodgerBlue;
     287                    functionTextBox.Foreground = Brushes.Black;
     288
     289                    myGrid.Children.Add(functionTextBox);
     290                } catch (Exception ex) {
    121291                }
    122 
    123                 // Freeze the geometry (make it unmodifiable)
    124                 // for additional performance benefits.
    125                 geometryLT.Freeze();
    126 
    127                 // Specify the shape (triangle) of the Path using the StreamGeometry.
    128                 leftTriangle.Data = geometryLT;
    129 
    130                 myGrid.Children.Add(leftTriangle);
    131 
    132                 // add right triangle ///////////////////
    133                 // Create a path to draw a geometry with.
    134                 Path rightTriangle = new Path();
    135                 rightTriangle.Stroke = Brushes.Black;
    136                 rightTriangle.StrokeThickness = 1;
    137                 rightTriangle.Fill = Brushes.Black;
    138 
    139                 // Create a StreamGeometry to use to specify myPath.
    140                 StreamGeometry geometryRT = new StreamGeometry();
    141                 geometryRT.FillRule = FillRule.EvenOdd;
    142 
    143                 // Open a StreamGeometryContext that can be used to describe this StreamGeometry
    144                 // object's contents.
    145                 using (StreamGeometryContext ctx = geometryRT.Open())
    146                 {
    147 
    148                     // Begin the triangle at the point specified. Notice that the shape is set to
    149                     // be closed so only two lines need to be specified below to make the triangle.
    150                     ctx.BeginFigure(new Point(60 + state.Length * 30, 15), true /* is filled */, true /* is closed */);
    151 
    152                     // Draw a line to the next specified point.
    153                     ctx.LineTo(new Point(60 + state.Length * 30, 21), true /* is stroked */, false /* is smooth join */);
    154 
    155                     // Draw another line to the next specified point.
    156                     ctx.LineTo(new Point(67 + state.Length * 30, 18), true /* is stroked */, false /* is smooth join */);
    157                 }
    158 
    159                 // Freeze the geometry (make it unmodifiable)
    160                 // for additional performance benefits.
    161                 geometryRT.Freeze();
    162 
    163                 // Specify the shape (triangle) of the Path using the StreamGeometry.
    164                 rightTriangle.Data = geometryRT;
    165 
    166                 // Data="M180,14 L180,22 L187,18 Z"
    167                 myGrid.Children.Add(rightTriangle);
    168 
    169 
    170 
    171                 TextBox[] myTextBoxes = new TextBox[state.Length];
    172                 Grid[] myGrids = new Grid[state.Length];
    173                 Ellipse[] myEllipses = new Ellipse[state.Length];
    174                 Line[] myLinesVert = new Line[state.Length];
    175                 Line[] myLinesVertRed = new Line[state.Length];
    176                 Line[] myLinesHori = new Line[state.Length];
    177 
    178                 // add TextBoxes
    179                 int i;
    180                 double left;
    181                 for (i = 0; i < state.Length; i++)
    182                 {
    183                     // add textboxes
    184                     left = (double)i * 29 + 20;
    185                     myTextBoxes[i] = new TextBox();
    186                     myTextBoxes[i].Margin = new Thickness(left, 3, 0, 0);
    187                     myTextBoxes[i].Width = 30;
    188                     myTextBoxes[i].Height = 30;
    189                     myTextBoxes[i].HorizontalAlignment = HorizontalAlignment.Left;
    190                     myTextBoxes[i].VerticalAlignment = VerticalAlignment.Top;
    191                     myTextBoxes[i].Name = "textBoxBit" + i;
    192                     myTextBoxes[i].Visibility = Visibility.Visible;
    193                     myTextBoxes[i].BorderThickness = new Thickness(1);
    194                     myTextBoxes[i].IsReadOnly = true;
    195                     myTextBoxes[i].TextAlignment = TextAlignment.Center;
    196                     myTextBoxes[i].VerticalContentAlignment = VerticalAlignment.Center;
    197                     myTextBoxes[i].BorderBrush = Brushes.Black;
    198                     if (clockingBit == i) myTextBoxes[i].Background = Brushes.Orange;
    199 
    200                     myGrid.Children.Add(myTextBoxes[i]);
    201 
    202                     // add XORs
    203                     myGrids[i] = new Grid();
    204                     myGrids[i].Name = "XORGrid" + i;
    205                     myGrids[i].Height = 30;
    206                     myGrids[i].Width = 30;
    207                     myGrids[i].HorizontalAlignment = HorizontalAlignment.Left;
    208                     myGrids[i].VerticalAlignment = VerticalAlignment.Top;
    209                     myGrids[i].Margin = new Thickness(left, 32, 0, 0);
    210 
    211                     myGrid.Children.Add(myGrids[i]);
    212 
    213                     if (tapSequence[i] == '0') myGrids[i].Visibility = Visibility.Hidden;
    214                     else
    215                     {
    216                         /*myEllipses[i] = new Ellipse();
    217                         myEllipses[i].Name = "ellipseXOR" + i;
    218                         myEllipses[i].Stroke = Brushes.DodgerBlue;
    219                         myEllipses[i].Margin = new Thickness(9, 9, 9, 9);
    220                         */
    221                         myLinesVert[i] = new Line();
    222                         myLinesVert[i].Name = "VertLineXOR" + i;
    223                         myLinesVert[i].Stroke = Brushes.Black;
    224                         myLinesVert[i].StrokeThickness = 1;
    225                         myLinesVert[i].X1 = 15;
    226                         myLinesVert[i].Y1 = 0.5;
    227                         myLinesVert[i].X2 = 15;
    228                         myLinesVert[i].Y2 = 15;
    229 
    230                         /*myLinesVertRed[i] = new Line();
    231                         myLinesVertRed[i].Name = "VertLineXORRed" + i;
    232                         myLinesVertRed[i].Stroke = Brushes.DodgerBlue;
    233                         myLinesVertRed[i].StrokeThickness = 1;
    234                         myLinesVertRed[i].X1 = 15;
    235                         myLinesVertRed[i].Y1 = 9;
    236                         myLinesVertRed[i].X2 = 15;
    237                         myLinesVertRed[i].Y2 = 20;
    238                        
    239                         myLinesHori[i] = new Line();
    240                         myLinesHori[i].Name = "HoriLineXOR" + i;
    241                         myLinesHori[i].Stroke = Brushes.DodgerBlue;
    242                         myLinesHori[i].StrokeThickness = 1;
    243                         myLinesHori[i].X1 = 9;
    244                         myLinesHori[i].Y1 = 15;
    245                         myLinesHori[i].X2 = 20;
    246                         myLinesHori[i].Y2 = 15;
    247                         */
    248                         //myGrids[i].Children.Add(myEllipses[i]);
    249                         myGrids[i].Children.Add(myLinesVert[i]);
    250                         //myGrids[i].Children.Add(myLinesVertRed[i]);
    251                         //myGrids[i].Children.Add(myLinesHori[i]);
    252                     }
    253                 }
    254                 // disable /*last*/ and first XOR
    255                 //myGrids[0].Visibility = Visibility.Hidden;
    256                 //myGrids[state.Length - 1].Visibility = Visibility.Hidden;
    257 
    258                 // add output bit label
    259                 Label outPutLabel = new Label();
    260                 left = (double)i * 30 + 65;
    261                 outPutLabel.Margin = new Thickness(left, 3, 0, 0);
    262                 outPutLabel.Width = 30;
    263                 outPutLabel.Height = 30;
    264                 outPutLabel.HorizontalContentAlignment = HorizontalAlignment.Center;
    265                 outPutLabel.VerticalContentAlignment = VerticalAlignment.Center;
    266                 outPutLabel.HorizontalAlignment = HorizontalAlignment.Left;
    267                 outPutLabel.VerticalAlignment = VerticalAlignment.Top;
    268                 outPutLabel.Name = "outputLabel";
    269                 myGrid.Children.Add(outPutLabel);
    270 
    271                 // add function box underneath
    272                 TextBox functionTextBox = new TextBox();
    273                 functionTextBox.Margin = new Thickness(20, 43, 0, 0);
    274                 functionTextBox.Width = 29 * i + 1;
    275                 functionTextBox.Height = 30;
    276                 functionTextBox.HorizontalAlignment = HorizontalAlignment.Left;
    277                 functionTextBox.VerticalAlignment = VerticalAlignment.Top;
    278                 functionTextBox.Name = "functionTextBox";
    279                 functionTextBox.Visibility = Visibility.Visible;
    280                 functionTextBox.BorderThickness = new Thickness(1);
    281                 functionTextBox.IsReadOnly = true;
    282                 functionTextBox.TextAlignment = TextAlignment.Center;
    283                 functionTextBox.VerticalContentAlignment = VerticalAlignment.Center;
    284                 functionTextBox.BorderBrush = Brushes.DodgerBlue;
    285                 functionTextBox.Foreground = Brushes.Black;
    286 
    287                 myGrid.Children.Add(functionTextBox);
    288292
    289293            }, null);
  • trunk/CrypPlugins/NLFSR/NLFSRSettings.cs

    r841 r956  
    2424        private bool hasChanges = false;
    2525
    26         private string currentState = null;
     26        private string currentState;
    2727        public string CurrentState
    2828        {
     
    3030            set
    3131            {
    32                 if (value != currentState) hasChanges = true;
    33                 currentState = value;
     32                if (value != currentState)
     33                {
     34                    currentState = value;
     35                    hasChanges = true;
     36                }
    3437            }
    3538        }
     
    5659
    5760        string polynomial;
    58         [TaskPane("Polynomial", "Define the feedback polynomial. For example x^5 * x^2 + 1.", null, 0, false, DisplayLevel.Beginner, ControlType.TextBox)]
     61        [TaskPane("Feedback function", "Define the feedback function. For example x5 * x2 + 1.", null, 0, false, DisplayLevel.Beginner, ControlType.TextBox)]
    5962        public string Polynomial
    6063        {
Note: See TracChangeset for help on using the changeset viewer.