Ignore:
Timestamp:
Oct 7, 2009, 5:57:57 PM (12 years ago)
Author:
falk
Message:

converter can do a lot more now.

Location:
trunk/CrypPlugins/Converter
Files:
2 edited

Legend:

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

    r672 r679  
    4545        public Converter()
    4646        {
    47            // this.settings = new ConverterSettings();
     47            // this.settings = new ConverterSettings();
    4848            this.settings.OnPluginStatusChanged += settings_OnPluginStatusChanged;
    4949        }
     
    8686        }
    8787
    88      
     88
    8989
    9090        [PropertyInfo(Direction.OutputData, "Output", "Output.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     
    116116        public void Execute()
    117117        {
    118            
    119                 if (!(InputOne is int[] || InputOne is byte[] || InputOne is CryptoolStream))
    120                 {
    121                     //Wenn der Input ein Bool ist
    122                     if (InputOne is bool)
     118
     119            if (!(InputOne is int[] || InputOne is byte[] || InputOne is CryptoolStream))
     120            {
     121                if (inputOne is bool)
     122                {
     123                    switch (this.settings.Converter)
    123124                    {
    124                         switch (this.settings.Converter)
    125                         {
    126                             case 0: // bool -> String
    127                                 {
    128                                     string inpString = Convert.ToString(InputOne);
    129                                     Output = inpString;
     125                        case 0:
     126                            {
     127                                Output = inputOne.ToString();
     128                                ProgressChanged(100, 100);
     129                                break;
     130                            }
     131                        case 1:
     132                            {
     133                                if ((bool)inputOne)
     134                                {
     135                                    Output = 1;
    130136                                    ProgressChanged(100, 100);
    131137                                    break;
    132138                                }
    133                             case 1: //int
    134                                 {
    135                                     try // bool -> int Läuft
    136                                     {
    137                                         int inpInt;
    138 
    139                                         if ((bool)InputOne)
    140                                         {
    141                                             inpInt = 1;
    142                                         }
    143                                         else
    144                                         {
    145                                             inpInt = 0;
    146                                         }
    147                                         GuiLogMessage("cast klappt", NotificationLevel.Info);
    148                                         Output = inpInt;
    149                                         ProgressChanged(100, 100);
    150                                     }
    151                                     catch (Exception e)
    152                                     {
    153                                         GuiLogMessage("The given Inputs are not convertable: " + e.Message, NotificationLevel.Error);
    154                                     }
    155                                     break;
    156                                 }
    157                             default: GuiLogMessage("The given Inputs are not convertable: ", NotificationLevel.Error); break;
    158                         }
    159                     }
    160                     else
    161                     {
    162                         string inpString = Convert.ToString(InputOne);
    163 
    164                        
    165 
    166                         switch (this.settings.Converter)
    167                         {
    168                             case 0: //String
    169                                 {
    170                                     Output = inpString;
     139                                else
     140                                {
     141                                    Output = 0;
    171142                                    ProgressChanged(100, 100);
    172143                                    break;
    173144                                }
    174                             case 1: //int
    175                                 {
    176                                     try // string -> int Läuft
     145                            }
     146                        default:
     147                            {
     148                                GuiLogMessage("Could not convert from bool to chosen type: ", NotificationLevel.Error);
     149                                break;
     150
     151                            }
     152                    }
     153                    return;
     154                }
     155
     156                string inpString = Convert.ToString(InputOne);
     157
     158
     159
     160                switch (this.settings.Converter)
     161                {
     162                    case 0: //String
     163                        {
     164                            Output = inpString;
     165                            ProgressChanged(100, 100);
     166                            break;
     167                        }
     168                    case 1: //int
     169                        {
     170
     171                            try // string -> int Läuft
     172                            {
     173                                int temp = Convert.ToInt32(inpString);
     174                                //int temp2 = (int)temp;
     175                                GuiLogMessage("int erkannt", NotificationLevel.Info);
     176                                Output = temp;
     177                                ProgressChanged(100, 100);
     178                            }
     179                            catch (Exception e)
     180                            {
     181                                GuiLogMessage("Could not convert input to integer: " + e.Message, NotificationLevel.Error);
     182                            }
     183                            break;
     184                        }
     185                    case 2: //short
     186                        {
     187
     188                            try // string -> short Läuft
     189                            {
     190                                short temp = Convert.ToInt16(inpString);
     191                                // short temp2 = (short)temp;
     192                                GuiLogMessage("short erkannt ", NotificationLevel.Info);
     193                                Output = temp;
     194                                ProgressChanged(100, 100);
     195                            }
     196                            catch (Exception e)
     197                            {
     198                                GuiLogMessage("Could not convert input to short: " + e.Message, NotificationLevel.Error);
     199                            }
     200                            break;
     201                        }
     202                    case 3: //byte
     203                        {
     204                            try // string -> byte Läuft
     205                            {
     206                                byte temp = Convert.ToByte(inpString);
     207                                GuiLogMessage("byte erkannt ", NotificationLevel.Info);
     208                                Output = temp;
     209                                ProgressChanged(100, 100);
     210                            }
     211                            catch (Exception e)
     212                            {
     213                                GuiLogMessage("Could not convert input to byte: " + e.Message, NotificationLevel.Error);
     214                            }
     215                            break;
     216                        }
     217                    case 4: //double
     218                        {
     219                            try // string -> double Läuft
     220                            {
     221                                String cleanInputString = DoubleCleanup(inpString);
     222
     223                                double temp = Convert.ToDouble(cleanInputString);
     224                                GuiLogMessage("double erkannt ", NotificationLevel.Info);
     225                                Output = temp;
     226                                ProgressChanged(100, 100);
     227                            }
     228
     229                            catch (Exception e)
     230                            {
     231                                GuiLogMessage("Could not convert input to double: " + e.Message, NotificationLevel.Error);
     232                            }
     233                            break;
     234
     235                        }
     236                    case 5: //bigint
     237                        {
     238                            try // string -> bigint Läuft
     239                            {
     240
     241                                BigInteger temp = BigInteger.parseExpression(inpString);
     242                                GuiLogMessage("big int erkannt ", NotificationLevel.Info);
     243                                Output = temp;
     244                                ProgressChanged(100, 100);
     245                            }
     246                            catch (Exception e)
     247                            {
     248                                GuiLogMessage("Could not convert input to biginteger: " + e.Message, NotificationLevel.Error);
     249                            }
     250                            break;
     251                        }
     252                    case 6: // int[]
     253                        {
     254                            GuiLogMessage("Conversion from String to int[] not defined: ", NotificationLevel.Error);
     255                            break;
     256                        }
     257                    case 7: // byte[]
     258                        {
     259                            if (settings.Numeric)
     260                            {
     261                                try // lässt sich als int verstehen?
     262                                {
     263                                    int tempint = Convert.ToInt32(inpString);
     264                                    byte[] temp = new byte[4];
     265                                    temp = BitConverter.GetBytes(tempint);
     266
     267                                    int test = BitConverter.ToInt32(temp, 0);
     268                                    GuiLogMessage("int erkannt " + test.ToString(), NotificationLevel.Info);
     269
     270                                    Output = temp;
     271
     272                                    ProgressChanged(100, 100);
     273                                    break;
     274                                }
     275                                catch (Exception e)
     276                                {
     277
     278                                }
     279
     280                                try // lässt sich als bigint verstehen?
     281                                {
     282                                    BigInteger tempbigint = new BigInteger(inpString, 10);
     283
     284                                    int numBits = tempbigint.bitCount();
     285
     286                                    int numBytes = numBits >> 3;
     287                                    if ((numBits & 0x7) != 0)
     288                                        numBytes++;
     289                                    byte[] temp = new byte[numBytes];
     290                                    temp = tempbigint.getBytes();
     291
     292                                    BigInteger test = new BigInteger(temp);
     293                                    GuiLogMessage("bigint erkannt " + test.ToString(), NotificationLevel.Info);
     294                                    Output = temp;
     295
     296                                    ProgressChanged(100, 100);
     297                                    break;
     298                                }
     299                                catch (Exception e)
     300                                {
     301
     302                                }
     303                                try // lässt sich als double verstehen?
     304                                {   
     305                                    double number=0.0;
     306                                   
     307                                    if (Double.TryParse(DoubleCleanup(inpString), out number))
    177308                                    {
    178                                         double temp = Convert.ToDouble(inpString);
    179                                         int temp2 = (int)temp;
    180                                         GuiLogMessage("cast klappt", NotificationLevel.Info);
    181                                         Output = temp2;
     309                                       
     310                                        double tempDouble = Convert.ToDouble(DoubleCleanup(inpString));
     311                                        byte[] temp = BitConverter.GetBytes(tempDouble);
     312
     313                                        double test = BitConverter.ToDouble(temp, 0);
     314                                        GuiLogMessage("double erkannt " + test.ToString(), NotificationLevel.Info);
     315
     316                                        Output = temp;
     317
    182318                                        ProgressChanged(100, 100);
     319                                        break;
    183320                                    }
    184                                     catch (Exception e)
    185                                     {
    186                                         GuiLogMessage("The given Inputs are not convertable: " + e.Message, NotificationLevel.Error);
    187                                     }
    188                                     break;
    189                                 }
    190                             case 2: //short
    191                                 {
    192 
    193                                     try // string -> short Läuft
    194                                     {
    195                                         int temp = Convert.ToInt32(inpString);
    196                                         short temp2 = (short)temp;
    197                                         GuiLogMessage("cast klappt", NotificationLevel.Info);
    198                                         Output = temp2;
    199                                         ProgressChanged(100, 100);
    200                                     }
    201                                     catch (Exception e)
    202                                     {
    203                                         GuiLogMessage("The given Inputs are not convertable: " + e.Message, NotificationLevel.Error);
    204                                     }
    205                                     break;
    206                                 }
    207                             case 3: //byte
    208                                 {
    209                                     try // string -> byte Läuft
    210                                     {
    211                                         byte temp = Convert.ToByte(inpString);
    212                                         GuiLogMessage("cast klappt", NotificationLevel.Info);
    213                                         Output = temp;
    214                                         ProgressChanged(100, 100);
    215                                     }
    216                                     catch (Exception e)
    217                                     {
    218                                         GuiLogMessage("The given Inputs are not convertable: " + e.Message, NotificationLevel.Error);
    219                                     }
    220                                     break;
    221                                 }
    222                             case 4: //double
    223                                 {
    224                                     try // string -> double Läuft
    225                                     {
    226                                         if (inpString.Contains(".") && (inpString.IndexOf(".") == inpString.LastIndexOf(".")) && !inpString.Contains(","))
    227                                         {
    228                                             string stringtemp=inpString.Replace(".", ","); 
    229                                             double temp = Convert.ToDouble(stringtemp);
    230                                            
    231                                             Output = temp;
    232                                             ProgressChanged(100, 100);
    233                                         }
    234                                         else
    235                                         {
    236                                             double temp = Convert.ToDouble(inpString);
    237                                            
    238                                             Output = temp;
    239                                             ProgressChanged(100, 100);
    240                                         }
    241                                     }
    242                                     catch (Exception e)
    243                                     {
    244                                         GuiLogMessage("The given Inputs are not convertable: " + e.Message, NotificationLevel.Error);
    245                                     }
    246                                     break;
    247 
    248                                 }
    249                             case 5: //bigint
    250                                 {
    251                                     try // string -> bigint Läuft
    252                                     {
    253                                         string temp1 = (string)inpString;
    254                                         BigInteger temp = BigInteger.parseExpression(temp1);
    255                                         GuiLogMessage("cast klappt", NotificationLevel.Info);
    256                                         Output = temp;
    257                                         ProgressChanged(100, 100);
    258                                     }
    259                                     catch (Exception e)
    260                                     {
    261                                         GuiLogMessage("The given Inputs are not convertable: " + e.Message, NotificationLevel.Error);
    262                                     }
    263                                     break;
    264                                 }
    265                             case 6: // int[]
    266                                 {
    267                                     GuiLogMessage("Conversion from String to int[] not defined: ", NotificationLevel.Error);
    268                                     break;
    269                                 }
    270                             case 7: // byte[]
    271                                 {
    272                                     GuiLogMessage("Conversion from String to byte[] not defined: ", NotificationLevel.Error);
    273                                     break;
    274                                 }
    275                             case 8: //cryptoolstream
    276                                 {
    277                                     GuiLogMessage("redundant", NotificationLevel.Error);
    278                                     break;
    279                                 }
    280 
    281                         }
    282                     }
     321                                 
     322                                 
     323                                }
     324                                catch (Exception e)
     325                                {
     326
     327                                }
     328                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
     329                                Output = enc.GetBytes(inpString);
     330
     331
     332                                GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
     333                                ProgressChanged(100, 100);
     334                                break;
     335                               
     336                               
     337                               
     338                            }
     339                            else
     340                            {
     341                                System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
     342                                Output = enc.GetBytes(inpString);
     343
     344
     345                                GuiLogMessage("byte[] wiederherstellung " + Output.ToString(), NotificationLevel.Info);
     346                                ProgressChanged(100, 100);
     347                                break;
     348                            }
     349                            break;
     350                        }
     351                    case 8: //cryptoolstream
     352                        {
     353                            GuiLogMessage("redundant", NotificationLevel.Error);
     354                            break;
     355                        }
     356                    default:
     357                        {
     358                            GuiLogMessage("kein fall getriggert ", NotificationLevel.Error);
     359                            break;
     360                        }
     361                }
     362
     363            }
     364            else
     365            {
     366                GuiLogMessage("not yet implemented", NotificationLevel.Error);
     367            }
     368
     369
     370        }
     371
     372        public String DoubleCleanup(String inpString)
     373        {
     374            if (this.settings.FormatAmer)
     375            {
     376                String temp1 = inpString.Replace(",", "");
     377                if (!(temp1.IndexOf(".") == temp1.LastIndexOf(".")))
     378                {
     379                    String tempXY = temp1.Insert(0, "X");
     380                    return tempXY;
     381                }
     382                if (temp1.Contains(".") && temp1.IndexOf(".") == temp1.LastIndexOf("."))
     383                {
     384                    String temp2 = temp1.Replace(".", ",");
     385                    return temp2;
    283386                }
    284387                else
    285388                {
    286                     GuiLogMessage("array and cryptoolstream input not yet implemented", NotificationLevel.Error);
    287                 }
    288 
    289            
    290         }
    291 
     389                    String temp3 = inpString.Replace(".", "");
     390                    return temp3;
     391                }
     392            }
     393            else
     394            {
     395                return inpString;
     396            }
     397
     398        }
    292399
    293400        public void Initialize()
  • trunk/CrypPlugins/Converter/ConverterSettings.cs

    r674 r679  
    3232        private int converter = 9; // 0 = String, 1 = int, 2 = short, 3 = byte, 4 = double, 5 = bigInteger, 6= Int[] , 7=Byte[], 8=CryptoolStream, 9 = default
    3333        private bool hasChanges;
     34        private bool numeric = false;
     35        private bool formatAmer = false;
    3436        #endregion
    3537
    3638        #region taskpane
     39     //   [ContextMenu("Numeric Interpretation", "Choose whether inputs are treated as numeric values if possible", 1, DisplayLevel.Beginner, ContextMenuControlType.ComboBox, new int[] { 1, 2 }, "numeric", "non numeric")]
    3740        [TaskPane("Converter", "Choose the output type", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "string", "int", "short", "byte", "double", "BigInteger", "int[]", "byte[]","Cryptoolstream" })]
     41       
    3842     
    3943        public int Converter
     
    4953
    5054                   ChangePluginIcon(converter+1);
     55                }
     56            }
     57        }
     58        [TaskPane("Numeric", "Choose whether inputs are interpreted as numeric values if possible", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "no", "yes" })]
     59        public bool Numeric
     60        {
     61            get { return this.numeric; }
     62            set
     63            {
     64                if (value != this.numeric)
     65                {
     66                    this.numeric = value;
     67                    OnPropertyChanged("Numeric");
     68                    HasChanges = true;
     69                }
     70            }
     71        }
     72
     73        [TaskPane("Format", "Choose whether double values are recognized via german or american syntax. German: \"123.345.34,34\" American: \"123,345,34.34 ", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "german", "american" })]
     74        public bool FormatAmer
     75        {
     76            get { return this.formatAmer; }
     77            set
     78            {
     79                if (value != this.formatAmer)
     80                {
     81                    this.formatAmer = value;
     82                    OnPropertyChanged("Format");
     83                    HasChanges = true;
    5184                }
    5285            }
Note: See TracChangeset for help on using the changeset viewer.