source: trunk/CrypPlugins/KeySearcher/KeySearcherSettings.cs @ 2295

Last change on this file since 2295 was 2295, checked in by Sven Rech, 11 years ago

Prepared KeySearcher for Localization

File size: 17.7 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Windows;
4using Cryptool.PluginBase;
5using System.ComponentModel;
6using System.Collections.ObjectModel;
7using KeySearcher.P2P.Storage;
8using KeySearcher.Properties;
9using OpenCLNet;
10
11namespace KeySearcher
12{
13    public class KeySearcherSettings : ISettings
14    {
15        private readonly KeySearcher keysearcher;
16        private int coresUsed;
17        private string csvPath = "";
18        private const string GroupPeerToPeer = "Peer-to-Peer network";
19        private const string GroupEvaluation = "Evaluation";
20        private const string GroupOpenCL = "OpenCL";
21        private const string GroupExternalClient = "External Client";
22        private const String GroupStatisticPath = "Statistic Save Path";
23
24        public class OpenCLDeviceSettings
25        {
26            public string name;
27            public int index;
28            public bool useDevice;
29            public int mode;
30        }
31
32        private List<OpenCLDeviceSettings> deviceSettings = new List<OpenCLDeviceSettings>();
33        public List<OpenCLDeviceSettings> DeviceSettings
34        {
35            get
36            {
37                return deviceSettings;
38            }
39        }
40
41        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
42
43        public KeySearcherSettings(KeySearcher ks, OpenCLManager oclManager)
44        {
45            keysearcher = ks;
46
47            devicesAvailable.Clear();
48            int c = 0;
49            if (oclManager != null)
50                foreach (var device in oclManager.Context.Devices)
51                {
52                    string deviceName = device.Vendor + ":" + device.Name;
53                    deviceSettings.Add(new OpenCLDeviceSettings() {name = deviceName, index = c, mode = 1, useDevice = false});
54                    devicesAvailable.Add(deviceName);
55                    c++;
56                }
57
58            CoresAvailable.Clear();
59            for (int i = -1; i < Environment.ProcessorCount; i++)
60                CoresAvailable.Add((i + 1).ToString());
61            CoresUsed = Environment.ProcessorCount - 1;
62
63            chunkSize = 21;
64        }
65
66        public void Initialize()
67        {
68            OpenCLGroupVisiblity();
69        }
70
71        private string key;
72        [TaskPane("Key", "Key pattern used to bruteforce", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
73        public String Key
74        {
75            get
76            {
77                return key;
78            }
79            set
80            {
81                key = value;
82                OnPropertyChanged("Key");
83                if (!(keysearcher.Pattern != null && keysearcher.Pattern.testWildcardKey(value)))
84                    keysearcher.GuiLogMessage(Resources.Wrong_key_pattern_, NotificationLevel.Error);
85                HasChanges = true;
86            }
87        }
88
89        [TaskPane("Reset", "Reset Key", null, 2, false, DisplayLevel.Beginner, ControlType.Button)]
90        public void Reset()
91        {
92            Key = keysearcher.Pattern.giveInputPattern();
93        }
94       
95        [TaskPane("CoresUsed", "Choose how many cores should be used", null, 3, false, DisplayLevel.Beginner, ControlType.DynamicComboBox, new string[] { "CoresAvailable" })]
96        public int CoresUsed
97        {
98            get { return this.coresUsed; }
99            set
100            {
101                if (value != this.coresUsed)
102                {
103                    this.coresUsed = value;
104                    OnPropertyChanged("CoresUsed");
105                    HasChanges = true;
106                }
107            }
108        }
109
110        private bool usePeerToPeer;
111        [TaskPane("Use Peer-to-Peer network", "Distributes the operation on available peers by using the built-in peer-to-peer network.", GroupPeerToPeer, 0, false, DisplayLevel.Beginner,
112            ControlType.CheckBox)]
113        public bool UsePeerToPeer
114        {
115            get { return usePeerToPeer; }
116            set
117            {
118                if (value != usePeerToPeer)
119                {
120                    usePeerToPeer = value;
121                    OnPropertyChanged("UsePeerToPeer");
122                    HasChanges = true;
123                }
124            }
125        }
126
127        private bool autoconnectPeerToPeer;
128        [TaskPane("Autoconnect network", "Establish a connection to the network if the workspace is started without the background connection being active.", GroupPeerToPeer, 1, false, DisplayLevel.Beginner,
129            ControlType.CheckBox)]
130        public bool AutoconnectPeerToPeer
131        {
132            get { return autoconnectPeerToPeer; }
133            set
134            {
135                if (value != autoconnectPeerToPeer)
136                {
137                    autoconnectPeerToPeer = value;
138                    OnPropertyChanged("AutoconnectPeerToPeer");
139                    HasChanges = true;
140                }
141            }
142        }
143
144        private bool verbosePeerToPeerDisplay;
145        [TaskPane("Display verbose information", "Display verbose information about network requests in the quick watch.", GroupPeerToPeer, 2, true, DisplayLevel.Beginner,
146            ControlType.CheckBox)]
147        public bool VerbosePeerToPeerDisplay
148        {
149            get { return verbosePeerToPeerDisplay; }
150            set
151            {
152                if (value != verbosePeerToPeerDisplay)
153                {
154                    verbosePeerToPeerDisplay = value;
155                    OnPropertyChanged("VerbosePeerToPeerDisplay");
156                    HasChanges = true;
157                }
158            }
159        }
160
161        private int chunkSize;
162        [TaskPane("Chunk size", "Amount of keys, that will be calculated by one peer at a time. This value is the exponent of the power of two used for the chunk size.", GroupPeerToPeer, 3, false, DisplayLevel.Professional,
163            ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 1000)]
164        public int ChunkSize
165        {
166            get { return chunkSize; }
167            set
168            {
169                if (value != chunkSize)
170                {
171                    chunkSize = value;
172                    OnPropertyChanged("ChunkSize");
173                    HasChanges = true;
174                }
175            }
176        }
177
178        [TaskPane("Copy status key", "Copy status key to clipboard. The key can than be used to upload it together with the job using the P2PEditor.", GroupPeerToPeer, 4, true, DisplayLevel.Professional, ControlType.Button)]
179        public void StatusKeyButton()
180        {
181            if (!keysearcher.IsKeySearcherRunning)
182            {
183                keysearcher.GuiLogMessage(Resources.KeySearcher_must_be_running_to_copy_the_status_key_, NotificationLevel.Error);
184                return;
185            }
186
187            var generator = new StorageKeyGenerator(keysearcher, this);
188            var statusKey = generator.GenerateStatusKey();
189
190            Clipboard.SetDataObject(statusKey, true);
191            keysearcher.GuiLogMessage(string.Format(Resources.Status_key___0___has_been_copied_to_clipboard_, statusKey),
192                                      NotificationLevel.Info);
193        }
194
195        private string evaluationHost;
196        [TaskPane("Host", "Database host with evaluation database", GroupEvaluation, 0, false, DisplayLevel.Expert, ControlType.TextBox)]
197        public String EvaluationHost
198        {
199            get
200            {
201                return evaluationHost;
202            }
203            set
204            {
205                if (value != evaluationHost)
206                {
207                    evaluationHost = value;
208                    OnPropertyChanged("EvaluationHost");
209                    HasChanges = true;
210                }
211            }
212        }
213
214        private string evaluationUser;
215        [TaskPane("User", "Username for evaluation database", GroupEvaluation, 1, false, DisplayLevel.Expert, ControlType.TextBox)]
216        public String EvaluationUser
217        {
218            get
219            {
220                return evaluationUser;
221            }
222            set
223            {
224                if (value != evaluationUser)
225                {
226                    evaluationUser = value;
227                    OnPropertyChanged("EvaluationUser");
228                    HasChanges = true;
229                }
230            }
231        }
232
233        private string evaluationPassword;
234        [TaskPane("Password", "Password for evaluation database", GroupEvaluation, 2, false, DisplayLevel.Expert, ControlType.TextBox)]
235        public String EvaluationPassword
236        {
237            get
238            {
239                return evaluationPassword;
240            }
241            set
242            {
243                if (value != evaluationPassword)
244                {
245                    evaluationPassword = value;
246                    OnPropertyChanged("EvaluationPassword");
247                    HasChanges = true;
248                }
249            }
250        }
251
252        private string evaluationDatabase;
253        [TaskPane("Database", "Name of the evaluation database", GroupEvaluation, 3, false, DisplayLevel.Expert, ControlType.TextBox)]
254        public String EvaluationDatabase
255        {
256            get
257            {
258                return evaluationDatabase;
259            }
260            set
261            {
262                if (value != evaluationDatabase)
263                {
264                    evaluationDatabase = value;
265                    OnPropertyChanged("EvaluationDatabase");
266                    HasChanges = true;
267                }
268            }
269        }
270
271        #region OpenCL
272
273        [TaskPane("No OpenCL available", null, GroupOpenCL, 1, false, DisplayLevel.Experienced, ControlType.TextBoxReadOnly)]
274        public string NoOpenCL
275        {
276            get { return Resources.No_OpenCL_Device_available_; }
277            set {}
278        }
279
280        private void OpenCLGroupVisiblity()
281        {
282            if (TaskPaneAttributeChanged == null)
283                return;
284
285            if (DevicesAvailable.Count == 0)
286            {
287                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Collapsed)));
288                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Collapsed)));
289                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Collapsed)));
290                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Visible)));
291            }
292            else
293            {
294                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Visible)));
295                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Visible)));
296                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Visible)));
297                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Collapsed)));
298            }
299        }
300
301        private int openCLDevice;
302        [TaskPane("OpenCL Device", "Choose the OpenCL device you want to use.", GroupOpenCL, 1, false, DisplayLevel.Experienced, ControlType.DynamicComboBox, new string[] { "DevicesAvailable" })]
303        public int OpenCLDevice
304        {
305            get { return this.openCLDevice; }
306            set
307            {
308                if (value != this.openCLDevice)
309                {
310                    this.openCLDevice = value;
311                    UseOpenCL = deviceSettings[value].useDevice;
312                    OpenCLMode = deviceSettings[value].mode;
313                    OnPropertyChanged("OpenCLDevice");
314                    HasChanges = true;
315                }
316            }
317        }
318
319        [TaskPane("Use selected device", "If checked, the selected OpenCL device is used for bruteforcing.",
320            GroupOpenCL, 2, false, DisplayLevel.Experienced, ControlType.CheckBox)]
321        public bool UseOpenCL
322        {
323            get
324            {
325                if (deviceSettings.Count > OpenCLDevice)
326                    return deviceSettings[OpenCLDevice].useDevice;
327                else
328                    return false;
329            }
330            set
331            {
332                if ((deviceSettings.Count > OpenCLDevice) && (value != deviceSettings[OpenCLDevice].useDevice))
333                {
334                    deviceSettings[OpenCLDevice].useDevice = value;
335                    hasChanges = true;
336                    OnPropertyChanged("UseOpenCL");
337                }
338            }
339        }
340
341        [TaskPane("OpenCL Mode", "Choose the OpenCL mode you want to use.", GroupOpenCL, 3, false, DisplayLevel.Experienced, ControlType.RadioButton, new string[] { "Low Load", "Normal Load", "High Load (use with caution)" })]
342        public int OpenCLMode
343        {
344            get
345            {
346                if (deviceSettings.Count > OpenCLDevice)
347                    return deviceSettings[OpenCLDevice].mode;
348                else
349                    return 0;
350            }
351            set
352            {
353                if ((deviceSettings.Count > OpenCLDevice) && (value != deviceSettings[OpenCLDevice].mode))
354                {
355                    deviceSettings[OpenCLDevice].mode = value;
356                    OnPropertyChanged("OpenCLMode");
357                    HasChanges = true;
358                }
359            }
360        }
361
362        private ObservableCollection<string> devicesAvailable = new ObservableCollection<string>();
363        public ObservableCollection<string> DevicesAvailable
364        {
365            get { return devicesAvailable; }
366            set
367            {
368                if (value != devicesAvailable)
369                {
370                    devicesAvailable = value;
371                }
372                OnPropertyChanged("DevicesAvailable");
373            }
374        }
375
376        #endregion
377
378        #region external client
379
380        private bool useExternalClient = false;
381        [TaskPane("Use external client", "If checked, external clients are allowed to connect to this CrypTool 2.0 instance to support the bruteforce process.",
382            GroupExternalClient, 1, false, DisplayLevel.Experienced, ControlType.CheckBox)]
383        public bool UseExternalClient
384        {
385            get { return useExternalClient; }
386            set
387            {
388                if (value != useExternalClient)
389                {
390                    useExternalClient = value;
391                    hasChanges = true;
392                    OnPropertyChanged("UseExternalClient");
393                }
394            }
395        }
396
397        private int port = 6234;
398        [TaskPane("Port", "Port on which to listen for external clients.", GroupExternalClient, 2, false, DisplayLevel.Experienced, ControlType.TextBox)]
399        public int Port
400        {
401            get { return port; }
402            set
403            {
404                if (value != port)
405                {
406                    port = value;
407                    hasChanges = true;
408                    OnPropertyChanged("Port");
409                }
410            }
411        }
412
413        #endregion
414
415        #region csv path
416        /// <summary>
417        /// Getter/Setter for the csv file
418        /// </summary>
419        [TaskPane("Select the Comma-Seperated-Values file", "Select the folder and csv file you want to use.", GroupStatisticPath, 1, false, DisplayLevel.Beginner, ControlType.SaveFileDialog, FileExtension = "Comma Seperated Values (*.csv)|*.csv")]
420        public string CsvPath
421        {
422            get { return csvPath; }
423            set
424            {
425                if (value != csvPath)
426                {
427                    csvPath = value;
428                    HasChanges = true;
429                    OnPropertyChanged("CsvPath");
430                }
431            }
432        }
433
434        /// <summary>
435        /// Button to "reset" the csv file. That means it will not appear any more in the text field
436        /// </summary>
437        [TaskPane("Default file", "Use the default folder %APPDATA%\\Local\\CrypTool2", GroupStatisticPath, 2, false, DisplayLevel.Beginner, ControlType.Button)]
438        public void DefaultPath()
439        {
440            csvPath = "";
441            OnPropertyChanged("CsvPath");
442        }
443        #endregion
444
445        private ObservableCollection<string> coresAvailable = new ObservableCollection<string>();
446        public ObservableCollection<string> CoresAvailable
447        {
448            get { return coresAvailable; }
449            set
450            {
451                if (value != coresAvailable)
452                {
453                    coresAvailable = value;
454                }
455                OnPropertyChanged("CoresAvailable");
456            }
457        }
458
459        #region ISettings Members
460
461        private bool hasChanges;
462
463        public bool HasChanges
464        {
465            get
466            {
467                return hasChanges;
468            }
469            set
470            {
471                hasChanges = value;
472                OnPropertyChanged("HasChanges");
473            }
474        }
475
476        #endregion
477
478        #region INotifyPropertyChanged Members
479
480        public event PropertyChangedEventHandler PropertyChanged;
481
482        private void OnPropertyChanged(string p)
483        {
484            if (PropertyChanged != null)
485            {
486                PropertyChanged(this, new PropertyChangedEventArgs(p));
487            }
488        }
489
490        #endregion
491    }
492}
Note: See TracBrowser for help on using the repository browser.