source: trunk/CrypPlugins/P2PEditor/P2PEditorSettings.cs @ 2540

Last change on this file since 2540 was 2540, checked in by kopal, 11 years ago

added "Remember my password" button. So the user can decide if he wants to save his password on the machine or not

File size: 15.1 KB
Line 
1/*
2   Copyright 2010 Paul Lelgemann, University of Duisburg-Essen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System.ComponentModel;
18using System.Windows;
19using Cryptool.P2P;
20using Cryptool.P2PEditor.GUI;
21using Cryptool.PluginBase;
22using Cryptool.Plugins.PeerToPeer.Internal;
23using System.Text;
24using System.Security.Cryptography;
25using System;
26using Cryptool.P2P.Internal;
27
28namespace Cryptool.P2PEditor
29{
30    internal class P2PEditorSettings : ISettings
31    {
32        private readonly P2PEditor p2PEditor;
33        private readonly P2PSettings settings;
34
35        private const string GroupExperienced = "experienced_settings";
36        private const string GroupExpert = "expert_settings";
37        private const string GroupServer = "server_settings";
38
39        public P2PEditorSettings(P2PEditor p2PEditor)
40        {
41            this.p2PEditor = p2PEditor;
42            settings = P2PSettings.Default;
43            try
44            {
45                if (settings.UpdateFlag)
46                {
47                    settings.Upgrade();
48                    settings.UpdateFlag = false;
49                    this.p2PEditor.GuiLogMessage("Upgrading settings", NotificationLevel.Debug);
50                }
51            }catch
52            {
53           
54            }
55
56            settings.PropertyChanged += new PropertyChangedEventHandler(settings_PropertyChanged);
57
58            UpdateSettings();
59        }
60
61
62        #region Update visibility of server group
63
64        public void UpdateSettings()
65        {
66            if (TaskPaneAttributeChanged == null)
67                return;
68
69            if (P2PSettings.Default.Architecture == P2PArchitecture.Server)
70                UpdateServerOptionVisibilitySetting(Visibility.Visible);
71            else
72                UpdateServerOptionVisibilitySetting(Visibility.Hidden);
73        }
74
75        private void UpdateServerOptionVisibilitySetting(Visibility newVisibility)
76        {
77            TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ServerHost", newVisibility)));
78            TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ServerPort", newVisibility)));
79        }
80
81        #endregion
82
83        #region Events
84        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
85        #endregion
86
87        #region ISettings Members
88
89        public event PropertyChangedEventHandler PropertyChanged;
90
91        public bool HasChanges { get; set; }
92
93        #endregion
94
95        #region Settings
96
97        /*[TaskPane("username_caption",
98            "username_tooltip"
99            , null, 0, false, ControlType.TextBox)]*/
100        public string PeerName
101        {
102            get { return settings.PeerName; }
103            set
104            {
105                if (value != settings.PeerName)
106                {
107                    settings.PeerName = value;
108                    OnPropertyChanged("PeerName");
109                    HasChanges = true;
110                }
111            }
112        }
113
114        /*[TaskPane("password_caption",
115            "password_tooltip"
116            , null, 1, false, ControlType.TextBoxHidden)]*/
117        public string Password
118        {
119            get {
120                if (RememberPassword)
121                {
122                    return P2PBase.DecryptString(settings.Password); 
123                }
124                else
125                {
126                    return P2PBase.DecryptString(P2PBase.Password); 
127                }
128                }
129            set
130            {
131                if (RememberPassword)
132                {
133                    if (P2PBase.EncryptString(value) != settings.Password)
134                    {
135                        settings.Password = P2PBase.EncryptString(value);
136                        OnPropertyChanged("Password");
137                        HasChanges = true;
138                    }
139                }
140                else
141                {
142                    if (P2PBase.EncryptString(value) != P2PBase.Password)
143                    {
144                        P2PBase.Password = P2PBase.EncryptString(value);
145                        OnPropertyChanged("Password");
146                        HasChanges = true;
147                    }                   
148                }
149            }
150        }
151
152        /*[TaskPane("rememberPassword_caption",
153            "rememberPassword_tooltip"
154            , null, 1, false, ControlType.CheckBox)]*/
155        public bool RememberPassword
156        {
157            get { return settings.RememberPassword; }
158            set
159            {
160                if (value != settings.RememberPassword)
161                {
162                    settings.RememberPassword = value;
163                    if (value)
164                    {
165                        settings.Password = P2PBase.Password;
166                        P2PBase.Password = "";
167                    }
168                    else
169                    {
170                        P2PBase.Password = settings.Password;
171                        settings.Password = "";
172                    }
173                    HasChanges = true;
174                    OnPropertyChanged("RememberPassword");
175                }
176            }
177        }
178
179        [TaskPane("worldname_caption", "worldname_tooltip", null, 2, false, ControlType.TextBox)]
180        public string WorldName
181        {
182            get { return settings.WorldName; }
183            set
184            {
185                if (value != settings.WorldName)
186                {
187                    settings.WorldName = value;
188                    OnPropertyChanged("WorldName");
189                    HasChanges = true;
190                }
191            }
192        }
193
194       
195        [TaskPane("start_caption", "start_tooltip", null, 3, true, ControlType.Button)]
196        public void ButtonStart()
197        {
198            if (!P2PManager.IsConnected)
199            {
200                P2PManager.Connect();
201                OnPropertyChanged("ButtonStart");
202                p2PEditor.GuiLogMessage(Resources.Attributes.start_launched, NotificationLevel.Info);
203                ((P2PEditorPresentation)p2PEditor.Presentation).UpdateConnectionState();
204            } else
205            {
206                p2PEditor.GuiLogMessage(Resources.Attributes.start_failed, NotificationLevel.Warning);
207            }
208        }
209
210        [TaskPane("stop_caption", "stop_tooltip", null, 4, true, ControlType.Button)]
211        public void ButtonStop()
212        {
213            if (P2PManager.IsConnected)
214            {
215                P2PManager.Disconnect();
216                OnPropertyChanged("ButtonStop");
217                p2PEditor.GuiLogMessage(Resources.Attributes.stop_launched, NotificationLevel.Info);
218            }
219            else
220            {
221                p2PEditor.GuiLogMessage(Resources.Attributes.stop_failed, NotificationLevel.Warning);
222            }
223        }
224
225
226
227        [TaskPane("networksize_caption", "networksize_tooltip", null, 6, false, ControlType.TextBoxReadOnly)]
228        public string NetSize
229        {
230            get { return settings.NetSize; }
231            set
232            {
233                if (value != settings.NetSize)
234                {
235                    settings.NetSize = value;
236                    OnPropertyChanged("NetSize");   
237                }
238            }
239        }
240
241
242        // TODO New ControlType needed to choose dialogs? OpenFileDialog not fitting.
243        [TaskPane("workspacePath_caption", "workspacePath_tooltip", GroupExperienced, 0, true, ControlType.TextBox)]
244        public string WorkspacePath
245        {
246            get { return settings.WorkspacePath; }
247            set
248            {
249                if (value != settings.WorkspacePath)
250                {
251                    settings.WorkspacePath = value;
252                    OnPropertyChanged("WorkspacePath");
253                    HasChanges = true;
254                }
255            }
256        }
257
258
259        [TaskPane("distributedJobListRefreshInterval_caption", "distributedJobListRefreshInterval_tooltip", GroupExperienced, 1, false,
260            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
261        public int DistributedJobListRefreshInterval
262        {
263            get { return settings.DistributedJobListRefreshInterval; }
264            set
265            {
266                if (value != settings.DistributedJobListRefreshInterval)
267                {
268                    settings.DistributedJobListRefreshInterval = value;
269                    OnPropertyChanged("DistributedJobListRefreshInterval");
270                    HasChanges = true;
271                }
272            }
273        }
274
275        [TaskPane("connectOnStartup_caption", "connectOnStartup_tooltip", GroupExperienced, 2, true,
276            ControlType.CheckBox)]
277        public bool ConnectOnStartup
278        {
279            get { return settings.ConnectOnStartup; }
280            set
281            {
282                if (value != settings.ConnectOnStartup)
283                {
284                    settings.ConnectOnStartup = value;
285                    OnPropertyChanged("ConnectOnStartup");
286                    HasChanges = true;
287                }
288            }
289        }
290
291        [TaskPane("linkmanager_caption", "linkmanager_tooltip", GroupExpert, 3, false,
292            ControlType.ComboBox, new[] {"Snal"})]
293        public int LinkManager
294        {
295            get { return (int) settings.LinkManager; }
296            set
297            {
298                if ((P2PLinkManagerType) value != settings.LinkManager)
299                {
300                    settings.LinkManager = (P2PLinkManagerType) value;
301                    OnPropertyChanged("LinkManager");
302                    HasChanges = true;
303                }
304            }
305        }
306
307        [TaskPane("bootstrapper_caption", "bootstrapper_tooltip", GroupExpert, 4, false
308            , ControlType.ComboBox, new[] {"LocalMachineBootstrapper", "IrcBootstrapper", "DnsBootstrapper"})]
309        public int Bootstrapper
310        {
311            get { return (int) settings.Bootstrapper; }
312            set
313            {
314                if ((P2PBootstrapperType) value != settings.Bootstrapper)
315                {
316                    settings.Bootstrapper = (P2PBootstrapperType) value;
317                    OnPropertyChanged("Bootstrapper");
318                    HasChanges = true;
319                }
320            }
321        }
322
323        [TaskPane("architecture_caption", "architecture_tooltip", GroupExpert, 5, false,
324            ControlType.ComboBox, new[] { "FullMesh", "Chord", "Server" , "WebDHT" })]
325        public int Architecture
326        {
327            get { return (int)settings.Architecture; }
328            set
329            {
330                if ((P2PArchitecture)value != settings.Architecture)
331                {
332                    settings.Architecture = (P2PArchitecture)value;
333                    UpdateSettings();
334                    OnPropertyChanged("Architecture");
335                    HasChanges = true;
336                }
337            }
338        }
339
340        [TaskPane("localPort_caption", "localPort_tooltip", GroupExpert, 6, false,
341            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
342        public int LocalPort
343        {
344            get { return settings.LocalReceivingPort; }
345            set
346            {
347                if (value != settings.LocalReceivingPort)
348                {
349                    settings.LocalReceivingPort = value;
350                    OnPropertyChanged("LocalPort");
351                    HasChanges = true;
352                }
353            }
354        }
355
356        [TaskPane("useLocalAddressDetection_caption", "useLocalAddressDetection_tooltip", GroupExpert, 7, false,
357            ControlType.CheckBox)]
358        public bool UseLocalAddressDetection
359        {
360            get { return settings.UseLocalAddressDetection; }
361            set
362            {
363                if (value != settings.UseLocalAddressDetection)
364                {
365                    settings.UseLocalAddressDetection = value;
366                    OnPropertyChanged("UseLocalAddressDetection");
367                    HasChanges = true;
368                }
369            }
370        }
371
372        [TaskPane("log2monitor_caption", "log2monitor_tooltip", GroupExpert, 8, false,
373            ControlType.CheckBox)]
374        public bool Log2Monitor
375        {
376            get { return settings.Log2Monitor; }
377            set
378            {
379                if (value != settings.Log2Monitor)
380                {
381                    settings.Log2Monitor = value;
382                    OnPropertyChanged("Log2Monitor");
383                    HasChanges = true;
384                }
385            }
386        }
387
388        [TaskPane("serverHost_caption", "serverHost_tooltip", GroupServer, 9, false, ControlType.TextBox)]
389        public string ServerHost
390        {
391            get { return settings.ServerHost; }
392            set
393            {
394                if (value != settings.ServerHost)
395                {
396                    settings.ServerHost = value;
397                    OnPropertyChanged("ServerHost");
398                    HasChanges = true;
399                }
400            }
401        }
402
403        [TaskPane("serverPort_caption", "serverPort_tooltip", GroupServer, 10, false,
404            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
405        public int ServerPort
406        {
407            get { return settings.ServerPort; }
408            set
409            {
410                if (value != settings.ServerPort)
411                {
412                    settings.ServerPort = value;
413                    OnPropertyChanged("ServerPort");
414                    HasChanges = true;
415                }
416            }
417        }
418
419        #endregion
420
421        /// <summary>
422        /// This is needed, if some settings are changed via "P2PSettings.Default.xyz". In some cases (e.g. controltype: TextBoxreadonly)
423        /// the GUI will not be updated automatically without this additionaly firing of the event
424        /// </summary>
425        /// <param name="sender"></param>
426        /// <param name="e"></param>
427        private void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
428        {
429            OnPropertyChanged(e.PropertyName);
430            //this.p2PEditor.GuiLogMessage("Property changed: " + e.PropertyName, NotificationLevel.Debug);
431        }
432
433        private void OnPropertyChanged(string p)
434        {
435            if (PropertyChanged != null)
436            {
437                PropertyChanged(this, new PropertyChangedEventArgs(p));
438            }
439
440            P2PSettings.Default.Save();
441        }
442
443    }
444}
Note: See TracBrowser for help on using the repository browser.