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

Last change on this file since 2533 was 2533, checked in by Arno Wacker, 11 years ago

Network Manager:

  • Added simple estimation of network size (SENS) protocol on Top of the FullMesh overlay (works only with FullMesh)
  • Just proof of concept; protocol will be moved inside the overlay later
  • Beware, that under some conditions it might break...
File size: 13.5 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 { return P2PBase.DecryptString(settings.Password); }
120            set
121            {
122                if (P2PBase.EncryptString(value) != settings.Password)
123                {
124                    settings.Password = P2PBase.EncryptString(value);
125                    OnPropertyChanged("Password");
126                    HasChanges = true;
127                }
128            }
129        }
130
131        [TaskPane("worldname_caption", "worldname_tooltip", null, 2, false, ControlType.TextBox)]
132        public string WorldName
133        {
134            get { return settings.WorldName; }
135            set
136            {
137                if (value != settings.WorldName)
138                {
139                    settings.WorldName = value;
140                    OnPropertyChanged("WorldName");
141                    HasChanges = true;
142                }
143            }
144        }
145
146       
147        [TaskPane("start_caption", "start_tooltip", null, 3, true, ControlType.Button)]
148        public void ButtonStart()
149        {
150            if (!P2PManager.IsConnected)
151            {
152                P2PManager.Connect();
153                OnPropertyChanged("ButtonStart");
154                p2PEditor.GuiLogMessage(Resources.Attributes.start_launched, NotificationLevel.Info);
155                ((P2PEditorPresentation)p2PEditor.Presentation).UpdateConnectionState();
156            } else
157            {
158                p2PEditor.GuiLogMessage(Resources.Attributes.start_failed, NotificationLevel.Warning);
159            }
160        }
161
162        [TaskPane("stop_caption", "stop_tooltip", null, 4, true, ControlType.Button)]
163        public void ButtonStop()
164        {
165            if (P2PManager.IsConnected)
166            {
167                P2PManager.Disconnect();
168                OnPropertyChanged("ButtonStop");
169                p2PEditor.GuiLogMessage(Resources.Attributes.stop_launched, NotificationLevel.Info);
170            }
171            else
172            {
173                p2PEditor.GuiLogMessage(Resources.Attributes.stop_failed, NotificationLevel.Warning);
174            }
175        }
176
177
178
179        [TaskPane("networksize_caption", "networksize_tooltip", null, 6, false, ControlType.TextBoxReadOnly)]
180        public string NetSize
181        {
182            get { return settings.NetSize; }
183            set
184            {
185                if (value != settings.NetSize)
186                {
187                    settings.NetSize = value;
188                    OnPropertyChanged("NetSize");   
189                }
190            }
191        }
192
193
194        // TODO New ControlType needed to choose dialogs? OpenFileDialog not fitting.
195        [TaskPane("workspacePath_caption", "workspacePath_tooltip", GroupExperienced, 0, true, ControlType.TextBox)]
196        public string WorkspacePath
197        {
198            get { return settings.WorkspacePath; }
199            set
200            {
201                if (value != settings.WorkspacePath)
202                {
203                    settings.WorkspacePath = value;
204                    OnPropertyChanged("WorkspacePath");
205                    HasChanges = true;
206                }
207            }
208        }
209
210
211        [TaskPane("distributedJobListRefreshInterval_caption", "distributedJobListRefreshInterval_tooltip", GroupExperienced, 1, false,
212            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
213        public int DistributedJobListRefreshInterval
214        {
215            get { return settings.DistributedJobListRefreshInterval; }
216            set
217            {
218                if (value != settings.DistributedJobListRefreshInterval)
219                {
220                    settings.DistributedJobListRefreshInterval = value;
221                    OnPropertyChanged("DistributedJobListRefreshInterval");
222                    HasChanges = true;
223                }
224            }
225        }
226
227        [TaskPane("connectOnStartup_caption", "connectOnStartup_tooltip", GroupExperienced, 2, true,
228            ControlType.CheckBox)]
229        public bool ConnectOnStartup
230        {
231            get { return settings.ConnectOnStartup; }
232            set
233            {
234                if (value != settings.ConnectOnStartup)
235                {
236                    settings.ConnectOnStartup = value;
237                    OnPropertyChanged("ConnectOnStartup");
238                    HasChanges = true;
239                }
240            }
241        }
242
243        [TaskPane("linkmanager_caption", "linkmanager_tooltip", GroupExpert, 3, false,
244            ControlType.ComboBox, new[] {"Snal"})]
245        public int LinkManager
246        {
247            get { return (int) settings.LinkManager; }
248            set
249            {
250                if ((P2PLinkManagerType) value != settings.LinkManager)
251                {
252                    settings.LinkManager = (P2PLinkManagerType) value;
253                    OnPropertyChanged("LinkManager");
254                    HasChanges = true;
255                }
256            }
257        }
258
259        [TaskPane("bootstrapper_caption", "bootstrapper_tooltip", GroupExpert, 4, false
260            , ControlType.ComboBox, new[] {"LocalMachineBootstrapper", "IrcBootstrapper", "DnsBootstrapper"})]
261        public int Bootstrapper
262        {
263            get { return (int) settings.Bootstrapper; }
264            set
265            {
266                if ((P2PBootstrapperType) value != settings.Bootstrapper)
267                {
268                    settings.Bootstrapper = (P2PBootstrapperType) value;
269                    OnPropertyChanged("Bootstrapper");
270                    HasChanges = true;
271                }
272            }
273        }
274
275        [TaskPane("architecture_caption", "architecture_tooltip", GroupExpert, 5, false,
276            ControlType.ComboBox, new[] { "FullMesh", "Chord", "Server" , "WebDHT" })]
277        public int Architecture
278        {
279            get { return (int)settings.Architecture; }
280            set
281            {
282                if ((P2PArchitecture)value != settings.Architecture)
283                {
284                    settings.Architecture = (P2PArchitecture)value;
285                    UpdateSettings();
286                    OnPropertyChanged("Architecture");
287                    HasChanges = true;
288                }
289            }
290        }
291
292        [TaskPane("localPort_caption", "localPort_tooltip", GroupExpert, 6, false,
293            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
294        public int LocalPort
295        {
296            get { return settings.LocalReceivingPort; }
297            set
298            {
299                if (value != settings.LocalReceivingPort)
300                {
301                    settings.LocalReceivingPort = value;
302                    OnPropertyChanged("LocalPort");
303                    HasChanges = true;
304                }
305            }
306        }
307
308        [TaskPane("useLocalAddressDetection_caption", "useLocalAddressDetection_tooltip", GroupExpert, 7, false,
309            ControlType.CheckBox)]
310        public bool UseLocalAddressDetection
311        {
312            get { return settings.UseLocalAddressDetection; }
313            set
314            {
315                if (value != settings.UseLocalAddressDetection)
316                {
317                    settings.UseLocalAddressDetection = value;
318                    OnPropertyChanged("UseLocalAddressDetection");
319                    HasChanges = true;
320                }
321            }
322        }
323
324        [TaskPane("log2monitor_caption", "log2monitor_tooltip", GroupExpert, 8, false,
325            ControlType.CheckBox)]
326        public bool Log2Monitor
327        {
328            get { return settings.Log2Monitor; }
329            set
330            {
331                if (value != settings.Log2Monitor)
332                {
333                    settings.Log2Monitor = value;
334                    OnPropertyChanged("Log2Monitor");
335                    HasChanges = true;
336                }
337            }
338        }
339
340        [TaskPane("serverHost_caption", "serverHost_tooltip", GroupServer, 9, false, ControlType.TextBox)]
341        public string ServerHost
342        {
343            get { return settings.ServerHost; }
344            set
345            {
346                if (value != settings.ServerHost)
347                {
348                    settings.ServerHost = value;
349                    OnPropertyChanged("ServerHost");
350                    HasChanges = true;
351                }
352            }
353        }
354
355        [TaskPane("serverPort_caption", "serverPort_tooltip", GroupServer, 10, false,
356            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
357        public int ServerPort
358        {
359            get { return settings.ServerPort; }
360            set
361            {
362                if (value != settings.ServerPort)
363                {
364                    settings.ServerPort = value;
365                    OnPropertyChanged("ServerPort");
366                    HasChanges = true;
367                }
368            }
369        }
370
371        #endregion
372
373        /// <summary>
374        /// This is needed, if some settings are changed via "P2PSettings.Default.xyz". In some cases (e.g. controltype: TextBoxreadonly)
375        /// the GUI will not be updated automatically without this additionaly firing of the event
376        /// </summary>
377        /// <param name="sender"></param>
378        /// <param name="e"></param>
379        private void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
380        {
381            OnPropertyChanged(e.PropertyName);
382            //this.p2PEditor.GuiLogMessage("Property changed: " + e.PropertyName, NotificationLevel.Debug);
383        }
384
385        private void OnPropertyChanged(string p)
386        {
387            if (PropertyChanged != null)
388            {
389                PropertyChanged(this, new PropertyChangedEventArgs(p));
390            }
391
392            P2PSettings.Default.Save();
393        }
394
395    }
396}
Note: See TracBrowser for help on using the repository browser.