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

Last change on this file since 2020 was 2020, checked in by Christian Geihe, 11 years ago

Added MySQLDHT as a new architecture to the P2P-Interface expert settings tab as well as all necessary dlls.

override-bad-extension: MySql.Data.dll
override-bad-extension: MySQLDHT.dll
override-bad-extension: MySQLDHT.dll.config
override-bad-extension: MySQLDHT.pdb

File size: 12.2 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        private 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("worldname_caption", "worldname_tooltip", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
95        public string WorldName
96        {
97            get { return settings.WorldName; }
98            set
99            {
100                if (value != settings.WorldName)
101                {
102                    settings.WorldName = value;
103                    OnPropertyChanged("WorldName");
104                    HasChanges = true;
105                }
106            }
107        }
108
109        // TODO New ControlType needed to choose dialogs? OpenFileDialog not fitting.
110        [TaskPane("workspacePath_caption", "workspacePath_tooltip", null, 2, true, DisplayLevel.Beginner, ControlType.TextBox)]
111        public string WorkspacePath
112        {
113            get { return settings.WorkspacePath; }
114            set
115            {
116                if (value != settings.WorkspacePath)
117                {
118                    settings.WorkspacePath = value;
119                    OnPropertyChanged("WorkspacePath");
120                    HasChanges = true;
121                }
122            }
123        }
124
125        [TaskPane("start_caption", "start_tooltip", null, 3, true, DisplayLevel.Beginner, ControlType.Button)]
126        public void ButtonStart()
127        {
128            if (!P2PManager.IsConnected)
129            {
130                P2PManager.Connect();
131                OnPropertyChanged("ButtonStart");
132                p2PEditor.GuiLogMessage(Resources.Attributes.start_launched, NotificationLevel.Info);
133                ((P2PEditorPresentation)p2PEditor.Presentation).UpdateConnectionState();
134            } else
135            {
136                p2PEditor.GuiLogMessage(Resources.Attributes.start_failed, NotificationLevel.Warning);
137            }
138        }
139
140        [TaskPane("stop_caption", "stop_tooltip", null, 4, true, DisplayLevel.Beginner, ControlType.Button)]
141        public void ButtonStop()
142        {
143            if (P2PManager.IsConnected)
144            {
145                P2PManager.Disconnect();
146                OnPropertyChanged("ButtonStop");
147                p2PEditor.GuiLogMessage(Resources.Attributes.stop_launched, NotificationLevel.Info);
148            }
149            else
150            {
151                p2PEditor.GuiLogMessage(Resources.Attributes.stop_failed, NotificationLevel.Warning);
152            }
153        }
154
155        [TaskPane("distributedJobListRefreshInterval_caption", "distributedJobListRefreshInterval_tooltip", GroupExperienced, 0, false, DisplayLevel.Experienced,
156            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
157        public int DistributedJobListRefreshInterval
158        {
159            get { return settings.DistributedJobListRefreshInterval; }
160            set
161            {
162                if (value != settings.DistributedJobListRefreshInterval)
163                {
164                    settings.DistributedJobListRefreshInterval = value;
165                    OnPropertyChanged("DistributedJobListRefreshInterval");
166                    HasChanges = true;
167                }
168            }
169        }
170
171        [TaskPane("connectOnStartup_caption", "connectOnStartup_tooltip", GroupExperienced, 1, true, DisplayLevel.Experienced,
172            ControlType.CheckBox)]
173        public bool ConnectOnStartup
174        {
175            get { return settings.ConnectOnStartup; }
176            set
177            {
178                if (value != settings.ConnectOnStartup)
179                {
180                    settings.ConnectOnStartup = value;
181                    OnPropertyChanged("ConnectOnStartup");
182                    HasChanges = true;
183                }
184            }
185        }
186
187        [TaskPane("linkmanager_caption", "linkmanager_tooltip", GroupExpert, 0, false, DisplayLevel.Expert,
188            ControlType.ComboBox, new[] {"Snal"})]
189        public int LinkManager
190        {
191            get { return (int) settings.LinkManager; }
192            set
193            {
194                if ((P2PLinkManagerType) value != settings.LinkManager)
195                {
196                    settings.LinkManager = (P2PLinkManagerType) value;
197                    OnPropertyChanged("LinkManager");
198                    HasChanges = true;
199                }
200            }
201        }
202
203        [TaskPane("bootstrapper_caption", "bootstrapper_tooltip", GroupExpert, 1, false, DisplayLevel.Expert
204            , ControlType.ComboBox, new[] {"LocalMachineBootstrapper", "IrcBootstrapper"})]
205        public int Bootstrapper
206        {
207            get { return (int) settings.Bootstrapper; }
208            set
209            {
210                if ((P2PBootstrapperType) value != settings.Bootstrapper)
211                {
212                    settings.Bootstrapper = (P2PBootstrapperType) value;
213                    OnPropertyChanged("Bootstrapper");
214                    HasChanges = true;
215                }
216            }
217        }
218
219        [TaskPane("architecture_caption", "architecture_tooltip", GroupExpert, 2, false, DisplayLevel.Expert,
220            ControlType.ComboBox, new[] { "FullMesh", "Chord", "Server" , "SQLDB" })]
221        public int Architecture
222        {
223            get { return (int)settings.Architecture; }
224            set
225            {
226                if ((P2PArchitecture)value != settings.Architecture)
227                {
228                    settings.Architecture = (P2PArchitecture)value;
229                    UpdateSettings();
230                    OnPropertyChanged("Architecture");
231                    HasChanges = true;
232                }
233            }
234        }
235
236        [TaskPane("transportprotocol_caption", "transportprotocol_tooltip", GroupExpert, 3, false, DisplayLevel.Expert,
237            ControlType.ComboBox, new[] { "TCP", "TCP_UDP", "UDP" })]
238        public int TransportProtocol
239        {
240            get { return (int)settings.TransportProtocol; }
241            set
242            {
243                if ((P2PTransportProtocol)value != settings.TransportProtocol)
244                {
245                    settings.TransportProtocol = (P2PTransportProtocol)value;
246                    OnPropertyChanged("TransportProtocol");
247                    HasChanges = true;
248                }
249            }
250        }
251
252        [TaskPane("localPort_caption", "localPort_tooltip", GroupExpert, 4, false, DisplayLevel.Expert,
253            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
254        public int LocalPort
255        {
256            get { return settings.LocalReceivingPort; }
257            set
258            {
259                if (value != settings.LocalReceivingPort)
260                {
261                    settings.LocalReceivingPort = value;
262                    OnPropertyChanged("LocalPort");
263                    HasChanges = true;
264                }
265            }
266        }
267
268        [TaskPane("useLocalAddressDetection_caption", "useLocalAddressDetection_tooltip", GroupExpert, 5, false, DisplayLevel.Expert,
269            ControlType.CheckBox)]
270        public bool UseLocalAddressDetection
271        {
272            get { return settings.UseLocalAddressDetection; }
273            set
274            {
275                if (value != settings.UseLocalAddressDetection)
276                {
277                    settings.UseLocalAddressDetection = value;
278                    OnPropertyChanged("UseLocalAddressDetection");
279                    HasChanges = true;
280                }
281            }
282        }
283
284        [TaskPane("log2monitor_caption", "log2monitor_tooltip", GroupExpert, 6, false, DisplayLevel.Expert,
285            ControlType.CheckBox)]
286        public bool Log2Monitor
287        {
288            get { return settings.Log2Monitor; }
289            set
290            {
291                if (value != settings.Log2Monitor)
292                {
293                    settings.Log2Monitor = value;
294                    OnPropertyChanged("Log2Monitor");
295                    HasChanges = true;
296                }
297            }
298        }
299
300        [TaskPane("serverHost_caption", "serverHost_tooltip", GroupServer, 1, false, DisplayLevel.Expert, ControlType.TextBox)]
301        public string ServerHost
302        {
303            get { return settings.ServerHost; }
304            set
305            {
306                if (value != settings.ServerHost)
307                {
308                    settings.ServerHost = value;
309                    OnPropertyChanged("ServerHost");
310                    HasChanges = true;
311                }
312            }
313        }
314
315        [TaskPane("serverPort_caption", "serverPort_tooltip", GroupServer, 4, false, DisplayLevel.Expert,
316            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
317        public int ServerPort
318        {
319            get { return settings.ServerPort; }
320            set
321            {
322                if (value != settings.ServerPort)
323                {
324                    settings.ServerPort = value;
325                    OnPropertyChanged("ServerPort");
326                    HasChanges = true;
327                }
328            }
329        }
330
331        #endregion
332
333        private void OnPropertyChanged(string p)
334        {
335            if (PropertyChanged != null)
336            {
337                PropertyChanged(this, new PropertyChangedEventArgs(p));
338            }
339
340            P2PSettings.Default.Save();
341        }
342    }
343}
Note: See TracBrowser for help on using the repository browser.