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

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

worked on KeySearcher settings tab

File size: 18.2 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
19        public class OpenCLDeviceSettings
20        {
21            public string name;
22            public int index;
23            public bool useDevice;
24            public int mode;
25        }
26
27        private List<OpenCLDeviceSettings> deviceSettings = new List<OpenCLDeviceSettings>();
28        public List<OpenCLDeviceSettings> DeviceSettings
29        {
30            get
31            {
32                return deviceSettings;
33            }
34        }
35
36        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
37
38        public KeySearcherSettings(KeySearcher ks, OpenCLManager oclManager)
39        {
40            keysearcher = ks;
41
42            devicesAvailable.Clear();
43            int c = 0;
44            if (oclManager != null)
45                foreach (var device in oclManager.Context.Devices)
46                {
47                    string deviceName = device.Vendor + ":" + device.Name;
48                    deviceSettings.Add(new OpenCLDeviceSettings() {name = deviceName, index = c, mode = 1, useDevice = false});
49                    devicesAvailable.Add(deviceName);
50                    c++;
51                }
52
53            CoresAvailable.Clear();
54            for (int i = -1; i < Environment.ProcessorCount; i++)
55                CoresAvailable.Add((i + 1).ToString());
56            CoresUsed = Environment.ProcessorCount - 1;
57
58            chunkSize = 21;
59        }
60
61        public void Initialize()
62        {
63            OpenCLGroupVisiblity();
64            Settings.Default.PropertyChanged += delegate
65                                                    {
66                                                        OpenCLGroupVisiblity();
67                                                    };
68        }
69
70        private string key;
71        [TaskPane("KeySettings", "KeySettingsDesc", null, 1, false, ControlType.TextBox)]
72        public String Key
73        {
74            get
75            {
76                return key;
77            }
78            set
79            {
80                key = value;
81                OnPropertyChanged("Key");
82                if (!(keysearcher.Pattern != null && keysearcher.Pattern.testWildcardKey(value)))
83                    keysearcher.GuiLogMessage(Resources.Wrong_key_pattern_, NotificationLevel.Error);
84                HasChanges = true;
85            }
86        }
87
88        [TaskPane("ResetSettings", "ResetSettingsDesc", null, 2, false, ControlType.Button)]
89        public void Reset()
90        {
91            Key = keysearcher.Pattern.giveInputPattern();
92        }
93       
94        [TaskPane("CoresUsedSettings", "CoresUsedSettingsDesc", null, 3, false, ControlType.DynamicComboBox, new string[] { "CoresAvailable" })]
95        public int CoresUsed
96        {
97            get { return this.coresUsed; }
98            set
99            {
100                if (value != this.coresUsed)
101                {
102                    this.coresUsed = value;
103                    OnPropertyChanged("CoresUsed");
104                    HasChanges = true;
105                }
106            }
107        }
108
109        private bool usePeerToPeer;
110        [TaskPane("UseP2PSettings", "UseP2PSettingsDesc", "GroupPeerToPeer", 0, false,
111            ControlType.CheckBox)]
112        public bool UsePeerToPeer
113        {
114            get { return usePeerToPeer; }
115            set
116            {
117                if (value != usePeerToPeer)
118                {
119                    usePeerToPeer = value;
120                    OnPropertyChanged("UsePeerToPeer");
121                    HasChanges = true;
122                }
123            }
124        }
125
126        private bool autoconnectPeerToPeer;
127        [TaskPane("AutoconnectSettings", "AutoconnectSettingsDesc", "GroupPeerToPeer", 1, false,
128            ControlType.CheckBox)]
129        public bool AutoconnectPeerToPeer
130        {
131            get { return autoconnectPeerToPeer; }
132            set
133            {
134                if (value != autoconnectPeerToPeer)
135                {
136                    autoconnectPeerToPeer = value;
137                    OnPropertyChanged("AutoconnectPeerToPeer");
138                    HasChanges = true;
139                }
140            }
141        }
142
143        private bool verbosePeerToPeerDisplay;
144        [TaskPane("DisplayVerboseInformationSettings", "DisplayVerboseInformationSettingsDesc", "GroupPeerToPeer", 2, true,
145            ControlType.CheckBox)]
146        public bool VerbosePeerToPeerDisplay
147        {
148            get { return verbosePeerToPeerDisplay; }
149            set
150            {
151                if (value != verbosePeerToPeerDisplay)
152                {
153                    verbosePeerToPeerDisplay = value;
154                    OnPropertyChanged("VerbosePeerToPeerDisplay");
155                    HasChanges = true;
156                }
157            }
158        }
159
160        private int chunkSize;
161        [TaskPane("ChunkSizeSettings", "ChunkSizeSettingsDesc", "GroupPeerToPeer", 3, false,
162            ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 1000)]
163        public int ChunkSize
164        {
165            get { return chunkSize; }
166            set
167            {
168                if (value != chunkSize)
169                {
170                    chunkSize = value;
171                    OnPropertyChanged("ChunkSize");
172                    HasChanges = true;
173                }
174            }
175        }
176
177        [TaskPane("CopyStatusKeySettings", "CopyStatusKeySettingsDesc", "GroupPeerToPeer", 4, true, ControlType.Button)]
178        public void StatusKeyButton()
179        {
180            if (!keysearcher.IsKeySearcherRunning)
181            {
182                keysearcher.GuiLogMessage(Resources.KeySearcher_must_be_running_to_copy_the_status_key_, NotificationLevel.Error);
183                return;
184            }
185
186            var generator = new StorageKeyGenerator(keysearcher, this);
187            var statusKey = generator.GenerateStatusKey();
188
189            Clipboard.SetDataObject(statusKey, true);
190            keysearcher.GuiLogMessage(string.Format(Resources.Status_key___0___has_been_copied_to_clipboard_, statusKey),
191                                      NotificationLevel.Info);
192        }
193
194        private string evaluationHost;
195        [TaskPane("HostSettings", "HostSettingsDesc", "GroupEvaluation", 0, false, ControlType.TextBox)]
196        public String EvaluationHost
197        {
198            get
199            {
200                return evaluationHost;
201            }
202            set
203            {
204                if (value != evaluationHost)
205                {
206                    evaluationHost = value;
207                    OnPropertyChanged("EvaluationHost");
208                    HasChanges = true;
209                }
210            }
211        }
212
213        private string evaluationUser;
214        [TaskPane("UserSettings", "UserSettingsDesc", "GroupEvaluation", 1, false, ControlType.TextBox)]
215        public String EvaluationUser
216        {
217            get
218            {
219                return evaluationUser;
220            }
221            set
222            {
223                if (value != evaluationUser)
224                {
225                    evaluationUser = value;
226                    OnPropertyChanged("EvaluationUser");
227                    HasChanges = true;
228                }
229            }
230        }
231
232        private string evaluationPassword;
233        [TaskPane("PasswordSettings", "PasswordSettingsDesc", "GroupEvaluation", 2, false, ControlType.TextBox)]
234        public String EvaluationPassword
235        {
236            get
237            {
238                return evaluationPassword;
239            }
240            set
241            {
242                if (value != evaluationPassword)
243                {
244                    evaluationPassword = value;
245                    OnPropertyChanged("EvaluationPassword");
246                    HasChanges = true;
247                }
248            }
249        }
250
251        private string evaluationDatabase;
252        [TaskPane("DatabaseSettings", "DatabaseSettingsDesc", "GroupEvaluation", 3, false, ControlType.TextBox)]
253        public String EvaluationDatabase
254        {
255            get
256            {
257                return evaluationDatabase;
258            }
259            set
260            {
261                if (value != evaluationDatabase)
262                {
263                    evaluationDatabase = value;
264                    OnPropertyChanged("EvaluationDatabase");
265                    HasChanges = true;
266                }
267            }
268        }
269
270        #region OpenCL
271
272        [TaskPane("NoOpenCLSettings", null, "GroupOpenCL", 1, false, ControlType.TextBoxReadOnly)]
273        public string NoOpenCL
274        {
275            get { return Resources.No_OpenCL_Device_available_; }
276            set {}
277        }
278
279        private void OpenCLGroupVisiblity()
280        {
281            if (TaskPaneAttributeChanged == null)
282                return;
283
284            if (!Settings.Default.UseOpenCL)
285            {
286                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Collapsed)));
287                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Collapsed)));
288                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Collapsed)));
289                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Collapsed)));
290            }
291            else
292            {
293                if (DevicesAvailable.Count == 0)
294                {
295                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Collapsed)));
296                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Collapsed)));
297                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Collapsed)));
298                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Visible)));
299                }
300                else
301                {
302                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Visible)));
303                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Visible)));
304                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Visible)));
305                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Collapsed)));
306                }
307            }
308        }
309
310        private int openCLDevice;
311        [TaskPane("OpenCLDeviceSettings", "OpenCLDeviceSettingsDesc", "GroupOpenCL", 1, false, ControlType.DynamicComboBox, new string[] { "DevicesAvailable" })]
312        public int OpenCLDevice
313        {
314            get { return this.openCLDevice; }
315            set
316            {
317                if (value != this.openCLDevice)
318                {
319                    this.openCLDevice = value;
320                    UseOpenCL = deviceSettings[value].useDevice;
321                    OpenCLMode = deviceSettings[value].mode;
322                    OnPropertyChanged("OpenCLDevice");
323                    HasChanges = true;
324                }
325            }
326        }
327
328        [TaskPane("UseSelectedDeviceSettings", "UseSelectedDeviceSettingsDesc",
329            "GroupOpenCL", 2, false, ControlType.CheckBox)]
330        public bool UseOpenCL
331        {
332            get
333            {
334                if (deviceSettings.Count > OpenCLDevice)
335                    return deviceSettings[OpenCLDevice].useDevice;
336                else
337                    return false;
338            }
339            set
340            {
341                if ((deviceSettings.Count > OpenCLDevice) && (value != deviceSettings[OpenCLDevice].useDevice))
342                {
343                    deviceSettings[OpenCLDevice].useDevice = value;
344                    hasChanges = true;
345                    OnPropertyChanged("UseOpenCL");
346                }
347            }
348        }
349
350        [TaskPane("OpenCLModeSettings", "OpenCLModeSettingsDesc", "GroupOpenCL", 3, false, ControlType.RadioButton, new string[] { "Low Load", "Normal Load", "High Load (use with caution)" })]
351        public int OpenCLMode
352        {
353            get
354            {
355                if (deviceSettings.Count > OpenCLDevice)
356                    return deviceSettings[OpenCLDevice].mode;
357                else
358                    return 0;
359            }
360            set
361            {
362                if ((deviceSettings.Count > OpenCLDevice) && (value != deviceSettings[OpenCLDevice].mode))
363                {
364                    if (Settings.Default.EnableHighLoad || value != 2)
365                        deviceSettings[OpenCLDevice].mode = value;
366                    else
367                        keysearcher.GuiLogMessage(
368                            "Using \"High Load\" is disabled. Please check your CrypTool 2.0 settings.", NotificationLevel.Error);
369
370                    OnPropertyChanged("OpenCLMode");
371                    HasChanges = true;
372                }
373            }
374        }
375
376        private ObservableCollection<string> devicesAvailable = new ObservableCollection<string>();
377        public ObservableCollection<string> DevicesAvailable
378        {
379            get { return devicesAvailable; }
380            set
381            {
382                if (value != devicesAvailable)
383                {
384                    devicesAvailable = value;
385                }
386                OnPropertyChanged("DevicesAvailable");
387            }
388        }
389
390        #endregion
391
392        #region external client
393
394        private bool useExternalClient = false;
395        [TaskPane("UseExternalClientSettings", "UseExternalClientSettingsDesc",
396            "GroupExternalClient", 1, false, ControlType.CheckBox)]
397        public bool UseExternalClient
398        {
399            get { return useExternalClient; }
400            set
401            {
402                if (value != useExternalClient)
403                {
404                    useExternalClient = value;
405                    hasChanges = true;
406                    OnPropertyChanged("UseExternalClient");
407                }
408            }
409        }
410
411        private int port = 6234;
412        [TaskPane("PortSettings", "PortSettingsDesc", "GroupExternalClient", 2, false, ControlType.TextBox)]
413        public int Port
414        {
415            get { return port; }
416            set
417            {
418                if (value != port)
419                {
420                    port = value;
421                    hasChanges = true;
422                    OnPropertyChanged("Port");
423                }
424            }
425        }
426
427        private String externalClientPassword = "";
428        [TaskPane("ExternalClientPasswordSettings", "ExternalClientPasswordSettingsDesc", "GroupExternalClient", 3, false, ControlType.TextBoxHidden)]
429        public String ExternalClientPassword
430        {
431            get { return externalClientPassword; }
432            set
433            {
434                if (value != externalClientPassword)
435                {
436                    externalClientPassword = value;
437                    hasChanges = true;
438                    OnPropertyChanged("ExternalClientPassword");
439                }
440            }
441        }
442        #endregion
443
444        #region csv path
445        /// <summary>
446        /// Getter/Setter for the csv file
447        /// </summary>
448        [TaskPane("CSVPathSettings", "CSVPathSettings", "GroupStatisticPath", 1, false, ControlType.SaveFileDialog, FileExtension = "Comma Seperated Values (*.csv)|*.csv")]
449        public string CsvPath
450        {
451            get { return csvPath; }
452            set
453            {
454                if (value != csvPath)
455                {
456                    csvPath = value;
457                    HasChanges = true;
458                    OnPropertyChanged("CsvPath");
459                }
460            }
461        }
462
463        /// <summary>
464        /// Button to "reset" the csv file. That means it will not appear any more in the text field
465        /// </summary>
466        [TaskPane("DefaultPathSettings", "DefaultPathSettingsDesc", "GroupStatisticPath", 2, false, ControlType.Button)]
467        public void DefaultPath()
468        {
469            csvPath = "";
470            OnPropertyChanged("CsvPath");
471        }
472        #endregion
473
474        private ObservableCollection<string> coresAvailable = new ObservableCollection<string>();
475        public ObservableCollection<string> CoresAvailable
476        {
477            get { return coresAvailable; }
478            set
479            {
480                if (value != coresAvailable)
481                {
482                    coresAvailable = value;
483                }
484                OnPropertyChanged("CoresAvailable");
485            }
486        }
487
488        #region ISettings Members
489
490        private bool hasChanges;
491
492        public bool HasChanges
493        {
494            get
495            {
496                return hasChanges;
497            }
498            set
499            {
500                hasChanges = value;
501                OnPropertyChanged("HasChanges");
502            }
503        }
504
505        #endregion
506
507        #region INotifyPropertyChanged Members
508
509        public event PropertyChangedEventHandler PropertyChanged;
510
511        private void OnPropertyChanged(string p)
512        {
513            if (PropertyChanged != null)
514            {
515                PropertyChanged(this, new PropertyChangedEventArgs(p));
516            }
517        }
518
519        #endregion
520    }
521}
Note: See TracBrowser for help on using the repository browser.