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

Last change on this file since 2277 was 2273, checked in by krueger, 11 years ago

This commit repairs CT2 build
Main features:

  • New peer2peer certificate system included
  • P2PEditor Password field added
  • Keysearcher is now using the Avatarname

You will need a certificate to join the peer2peer network

File size: 12.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;
23
24namespace Cryptool.P2PEditor
25{
26    internal class P2PEditorSettings : ISettings
27    {
28        private readonly P2PEditor p2PEditor;
29        private readonly P2PSettings settings;
30
31        private const string GroupExperienced = "experienced_settings";
32        private const string GroupExpert = "expert_settings";
33        private const string GroupServer = "server_settings";
34
35        public P2PEditorSettings(P2PEditor p2PEditor)
36        {
37            this.p2PEditor = p2PEditor;
38            settings = P2PSettings.Default;
39            UpdateSettings();
40        }
41
42        #region Update visibility of server group
43
44        public void UpdateSettings()
45        {
46            if (TaskPaneAttributeChanged == null)
47                return;
48
49            if (P2PSettings.Default.Architecture == P2PArchitecture.Server)
50                UpdateServerOptionVisibilitySetting(Visibility.Visible);
51            else
52                UpdateServerOptionVisibilitySetting(Visibility.Hidden);
53        }
54
55        private void UpdateServerOptionVisibilitySetting(Visibility newVisibility)
56        {
57            TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ServerHost", newVisibility)));
58            TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ServerPort", newVisibility)));
59        }
60
61        #endregion
62
63        #region Events
64        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
65        #endregion
66
67        #region ISettings Members
68
69        public event PropertyChangedEventHandler PropertyChanged;
70
71        public bool HasChanges { get; set; }
72
73        #endregion
74
75        #region Settings
76
77        [TaskPane("username_caption",
78            "username_tooltip"
79            , null, 0, false, DisplayLevel.Beginner, ControlType.TextBox)]
80        public string PeerName
81        {
82            get { return settings.PeerName; }
83            set
84            {
85                if (value != settings.PeerName)
86                {
87                    settings.PeerName = value;
88                    OnPropertyChanged("PeerName");
89                    HasChanges = true;
90                }
91            }
92        }
93
94        [TaskPane("password_caption",
95            "password_tooltip"
96            , null, 1, false, DisplayLevel.Beginner, ControlType.TextBoxHidden)]
97        public string Password
98        {
99            get { return settings.Password; }
100            set
101            {
102                if (value != settings.Password)
103                {
104                    settings.Password = value;
105                    OnPropertyChanged("Password");
106                    HasChanges = true;
107                }
108            }
109        }
110
111        [TaskPane("worldname_caption", "worldname_tooltip", null, 2, false, DisplayLevel.Beginner, ControlType.TextBox)]
112        public string WorldName
113        {
114            get { return settings.WorldName; }
115            set
116            {
117                if (value != settings.WorldName)
118                {
119                    settings.WorldName = value;
120                    OnPropertyChanged("WorldName");
121                    HasChanges = true;
122                }
123            }
124        }
125
126        // TODO New ControlType needed to choose dialogs? OpenFileDialog not fitting.
127        [TaskPane("workspacePath_caption", "workspacePath_tooltip", null, 3, true, DisplayLevel.Beginner, ControlType.TextBox)]
128        public string WorkspacePath
129        {
130            get { return settings.WorkspacePath; }
131            set
132            {
133                if (value != settings.WorkspacePath)
134                {
135                    settings.WorkspacePath = value;
136                    OnPropertyChanged("WorkspacePath");
137                    HasChanges = true;
138                }
139            }
140        }
141
142        [TaskPane("start_caption", "start_tooltip", null, 3, true, DisplayLevel.Beginner, ControlType.Button)]
143        public void ButtonStart()
144        {
145            if (!P2PManager.IsConnected)
146            {
147                P2PManager.Connect();
148                OnPropertyChanged("ButtonStart");
149                p2PEditor.GuiLogMessage(Resources.Attributes.start_launched, NotificationLevel.Info);
150                ((P2PEditorPresentation)p2PEditor.Presentation).UpdateConnectionState();
151            } else
152            {
153                p2PEditor.GuiLogMessage(Resources.Attributes.start_failed, NotificationLevel.Warning);
154            }
155        }
156
157        [TaskPane("stop_caption", "stop_tooltip", null, 4, true, DisplayLevel.Beginner, ControlType.Button)]
158        public void ButtonStop()
159        {
160            if (P2PManager.IsConnected)
161            {
162                P2PManager.Disconnect();
163                OnPropertyChanged("ButtonStop");
164                p2PEditor.GuiLogMessage(Resources.Attributes.stop_launched, NotificationLevel.Info);
165            }
166            else
167            {
168                p2PEditor.GuiLogMessage(Resources.Attributes.stop_failed, NotificationLevel.Warning);
169            }
170        }
171
172        [TaskPane("distributedJobListRefreshInterval_caption", "distributedJobListRefreshInterval_tooltip", GroupExperienced, 0, false, DisplayLevel.Experienced,
173            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
174        public int DistributedJobListRefreshInterval
175        {
176            get { return settings.DistributedJobListRefreshInterval; }
177            set
178            {
179                if (value != settings.DistributedJobListRefreshInterval)
180                {
181                    settings.DistributedJobListRefreshInterval = value;
182                    OnPropertyChanged("DistributedJobListRefreshInterval");
183                    HasChanges = true;
184                }
185            }
186        }
187
188        [TaskPane("connectOnStartup_caption", "connectOnStartup_tooltip", GroupExperienced, 1, true, DisplayLevel.Experienced,
189            ControlType.CheckBox)]
190        public bool ConnectOnStartup
191        {
192            get { return settings.ConnectOnStartup; }
193            set
194            {
195                if (value != settings.ConnectOnStartup)
196                {
197                    settings.ConnectOnStartup = value;
198                    OnPropertyChanged("ConnectOnStartup");
199                    HasChanges = true;
200                }
201            }
202        }
203
204        [TaskPane("linkmanager_caption", "linkmanager_tooltip", GroupExpert, 0, false, DisplayLevel.Expert,
205            ControlType.ComboBox, new[] {"Snal"})]
206        public int LinkManager
207        {
208            get { return (int) settings.LinkManager; }
209            set
210            {
211                if ((P2PLinkManagerType) value != settings.LinkManager)
212                {
213                    settings.LinkManager = (P2PLinkManagerType) value;
214                    OnPropertyChanged("LinkManager");
215                    HasChanges = true;
216                }
217            }
218        }
219
220        [TaskPane("bootstrapper_caption", "bootstrapper_tooltip", GroupExpert, 1, false, DisplayLevel.Expert
221            , ControlType.ComboBox, new[] {"LocalMachineBootstrapper", "IrcBootstrapper"})]
222        public int Bootstrapper
223        {
224            get { return (int) settings.Bootstrapper; }
225            set
226            {
227                if ((P2PBootstrapperType) value != settings.Bootstrapper)
228                {
229                    settings.Bootstrapper = (P2PBootstrapperType) value;
230                    OnPropertyChanged("Bootstrapper");
231                    HasChanges = true;
232                }
233            }
234        }
235
236        [TaskPane("architecture_caption", "architecture_tooltip", GroupExpert, 2, false, DisplayLevel.Expert,
237            ControlType.ComboBox, new[] { "FullMesh", "Chord", "Server" , "SQLDB" , "WebDHT" })]
238        public int Architecture
239        {
240            get { return (int)settings.Architecture; }
241            set
242            {
243                if ((P2PArchitecture)value != settings.Architecture)
244                {
245                    settings.Architecture = (P2PArchitecture)value;
246                    UpdateSettings();
247                    OnPropertyChanged("Architecture");
248                    HasChanges = true;
249                }
250            }
251        }
252
253        [TaskPane("localPort_caption", "localPort_tooltip", GroupExpert, 4, false, DisplayLevel.Expert,
254            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
255        public int LocalPort
256        {
257            get { return settings.LocalReceivingPort; }
258            set
259            {
260                if (value != settings.LocalReceivingPort)
261                {
262                    settings.LocalReceivingPort = value;
263                    OnPropertyChanged("LocalPort");
264                    HasChanges = true;
265                }
266            }
267        }
268
269        [TaskPane("useLocalAddressDetection_caption", "useLocalAddressDetection_tooltip", GroupExpert, 5, false, DisplayLevel.Expert,
270            ControlType.CheckBox)]
271        public bool UseLocalAddressDetection
272        {
273            get { return settings.UseLocalAddressDetection; }
274            set
275            {
276                if (value != settings.UseLocalAddressDetection)
277                {
278                    settings.UseLocalAddressDetection = value;
279                    OnPropertyChanged("UseLocalAddressDetection");
280                    HasChanges = true;
281                }
282            }
283        }
284
285        [TaskPane("log2monitor_caption", "log2monitor_tooltip", GroupExpert, 6, false, DisplayLevel.Expert,
286            ControlType.CheckBox)]
287        public bool Log2Monitor
288        {
289            get { return settings.Log2Monitor; }
290            set
291            {
292                if (value != settings.Log2Monitor)
293                {
294                    settings.Log2Monitor = value;
295                    OnPropertyChanged("Log2Monitor");
296                    HasChanges = true;
297                }
298            }
299        }
300
301        [TaskPane("serverHost_caption", "serverHost_tooltip", GroupServer, 1, false, DisplayLevel.Expert, ControlType.TextBox)]
302        public string ServerHost
303        {
304            get { return settings.ServerHost; }
305            set
306            {
307                if (value != settings.ServerHost)
308                {
309                    settings.ServerHost = value;
310                    OnPropertyChanged("ServerHost");
311                    HasChanges = true;
312                }
313            }
314        }
315
316        [TaskPane("serverPort_caption", "serverPort_tooltip", GroupServer, 4, false, DisplayLevel.Expert,
317            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
318        public int ServerPort
319        {
320            get { return settings.ServerPort; }
321            set
322            {
323                if (value != settings.ServerPort)
324                {
325                    settings.ServerPort = value;
326                    OnPropertyChanged("ServerPort");
327                    HasChanges = true;
328                }
329            }
330        }
331
332        #endregion
333
334        private void OnPropertyChanged(string p)
335        {
336            if (PropertyChanged != null)
337            {
338                PropertyChanged(this, new PropertyChangedEventArgs(p));
339            }
340
341            P2PSettings.Default.Save();
342        }
343    }
344}
Note: See TracBrowser for help on using the repository browser.