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

Last change on this file since 1611 was 1611, checked in by Paul Lelgemann, 12 years ago

o CrypWin: P2P world button always visible
o Changed behaviour of command line option "-p2p" and "-peer2peer": triggers autoconnect to peer-to-peer network during startup of CrypTool
o P2PEditor: "Start" button disabled and moved to settings pane for consistency
o CrypP2P: local workspace path is set to "%TEMP%/CrypTool", if not specified before
+ PeerToPeerProxy has a new setting to enable autoconnecting the peer-to-peer network, if it is not connected during workspace start

File size: 10.9 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 Cryptool.P2P;
19using Cryptool.P2P.Worker;
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
34        public P2PEditorSettings(P2PEditor p2PEditor)
35        {
36            _p2PEditor = p2PEditor;
37            _settings = P2PSettings.Default;
38        }
39
40        #region ISettings Members
41
42        public event PropertyChangedEventHandler PropertyChanged;
43
44        public bool HasChanges { get; set; }
45
46        #endregion
47
48        #region Settings
49
50        [TaskPane("username_caption",
51            "username_tooltip"
52            , null, 0, false, DisplayLevel.Beginner, ControlType.TextBox)]
53        public string PeerName
54        {
55            get { return _settings.PeerName; }
56            set
57            {
58                if (value != _settings.PeerName)
59                {
60                    _settings.PeerName = value;
61                    OnPropertyChanged("PeerName");
62                    HasChanges = true;
63                }
64            }
65        }
66
67        [TaskPane("worldname_caption", "worldname_tooltip", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
68        public string WorldName
69        {
70            get { return _settings.WorldName; }
71            set
72            {
73                if (value != _settings.WorldName)
74                {
75                    _settings.WorldName = value;
76                    OnPropertyChanged("WorldName");
77                    HasChanges = true;
78                }
79            }
80        }
81
82        // TODO New ControlType needed to choose dialogs? OpenFileDialog not fitting.
83        [TaskPane("workspacePath_caption", "workspacePath_tooltip", null, 2, true, DisplayLevel.Beginner, ControlType.TextBox)]
84        public string WorkspacePath
85        {
86            get { return _settings.WorkspacePath; }
87            set
88            {
89                if (value != _settings.WorkspacePath)
90                {
91                    _settings.WorkspacePath = value;
92                    OnPropertyChanged("WorkspacePath");
93                    HasChanges = true;
94                }
95            }
96        }
97
98        [TaskPane("start_caption", "start_tooltip", null, 3, true, DisplayLevel.Beginner, ControlType.Button)]
99        public void ButtonStart()
100        {
101            if (!P2PManager.Instance.IsP2PConnected() && !P2PManager.Instance.IsP2PConnecting)
102            {
103                RunConnectionWorker();
104                OnPropertyChanged("ButtonStart");
105                _p2PEditor.GuiLogMessage(Resources.Attributes.start_launched, NotificationLevel.Info);
106            } else
107            {
108                _p2PEditor.GuiLogMessage(Resources.Attributes.start_failed, NotificationLevel.Warning);
109            }
110        }
111
112        [TaskPane("stop_caption", "stop_tooltip", null, 4, true, DisplayLevel.Beginner, ControlType.Button)]
113        public void ButtonStop()
114        {
115            if (P2PManager.Instance.IsP2PConnected() && !P2PManager.Instance.IsP2PConnecting)
116            {
117                RunConnectionWorker();
118                OnPropertyChanged("ButtonStop");
119                _p2PEditor.GuiLogMessage(Resources.Attributes.stop_launched, NotificationLevel.Info);
120            }
121            else
122            {
123                _p2PEditor.GuiLogMessage(Resources.Attributes.stop_failed, NotificationLevel.Warning);
124            }
125        }
126
127        [TaskPane("distributedJobListRefreshInterval_caption", "distributedJobListRefreshInterval_tooltip", GroupExperienced, 0, false, DisplayLevel.Experienced,
128            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
129        public int DistributedJobListRefreshInterval
130        {
131            get { return _settings.DistributedJobListRefreshInterval; }
132            set
133            {
134                if (value != _settings.DistributedJobListRefreshInterval)
135                {
136                    _settings.DistributedJobListRefreshInterval = value;
137                    OnPropertyChanged("DistributedJobListRefreshInterval");
138                    HasChanges = true;
139                }
140            }
141        }
142
143        [TaskPane("connectOnStartup_caption", "connectOnStartup_tooltip", GroupExperienced, 1, true, DisplayLevel.Experienced,
144            ControlType.CheckBox)]
145        public bool ConnectOnStartup
146        {
147            get { return _settings.ConnectOnStartup; }
148            set
149            {
150                if (value != _settings.ConnectOnStartup)
151                {
152                    _settings.ConnectOnStartup = value;
153                    OnPropertyChanged("ConnectOnStartup");
154                    HasChanges = true;
155                }
156            }
157        }
158
159        [TaskPane("linkmanager_caption", "linkmanager_tooltip", GroupExpert, 0, false, DisplayLevel.Expert,
160            ControlType.ComboBox, new[] {"Snal"})]
161        public int LinkManager
162        {
163            get { return (int) _settings.LinkManager; }
164            set
165            {
166                if ((P2PLinkManagerType) value != _settings.LinkManager)
167                {
168                    _settings.LinkManager = (P2PLinkManagerType) value;
169                    OnPropertyChanged("LinkManager");
170                    HasChanges = true;
171                }
172            }
173        }
174
175        [TaskPane("bootstrapper_caption", "bootstrapper_tooltip", GroupExpert, 1, false, DisplayLevel.Expert
176            , ControlType.ComboBox, new[] {"LocalMachineBootstrapper", "IrcBootstrapper"})]
177        public int Bootstrapper
178        {
179            get { return (int) _settings.Bootstrapper; }
180            set
181            {
182                if ((P2PBootstrapperType) value != _settings.Bootstrapper)
183                {
184                    _settings.Bootstrapper = (P2PBootstrapperType) value;
185                    OnPropertyChanged("Bootstrapper");
186                    HasChanges = true;
187                }
188            }
189        }
190
191        [TaskPane("overlay_caption", "overlay_tooltip", GroupExpert, 2, false, DisplayLevel.Expert,
192            ControlType.ComboBox, new[] {"FullMeshOverlay"})]
193        public int Overlay
194        {
195            get { return (int) _settings.Overlay; }
196            set
197            {
198                if ((P2POverlayType) value != _settings.Overlay)
199                {
200                    _settings.Overlay = (P2POverlayType) value;
201                    OnPropertyChanged("Overlay");
202                    HasChanges = true;
203                }
204            }
205        }
206
207        [TaskPane("dht_caption", "dht_tooltip", GroupExpert, 3, false, DisplayLevel.Expert,
208            ControlType.ComboBox, new[] {"FullMeshDHT"})]
209        public int Dht
210        {
211            get { return (int) _settings.Dht; }
212            set
213            {
214                if ((P2PDHTType) value != _settings.Dht)
215                {
216                    _settings.Dht = (P2PDHTType) value;
217                    OnPropertyChanged("Dht");
218                    HasChanges = true;
219                }
220            }
221        }
222
223        [TaskPane("transportprotocol_caption", "transportprotocol_tooltip", GroupExpert, 3, false, DisplayLevel.Expert,
224            ControlType.ComboBox, new[] { "TCP", "TCP_UDP", "UDP" })]
225        public int TransportProtocol
226        {
227            get { return (int)_settings.TransportProtocol; }
228            set
229            {
230                if ((P2PTransportProtocol)value != _settings.TransportProtocol)
231                {
232                    _settings.TransportProtocol = (P2PTransportProtocol)value;
233                    OnPropertyChanged("TransportProtocol");
234                    HasChanges = true;
235                }
236            }
237        }
238
239        [TaskPane("localPort_caption", "localPort_tooltip", GroupExpert, 4, false, DisplayLevel.Expert,
240            ControlType.NumericUpDown, ValidationType.RangeInteger, 0, 65535)]
241        public int LocalPort
242        {
243            get { return _settings.LocalReceivingPort; }
244            set
245            {
246                if (value != _settings.LocalReceivingPort)
247                {
248                    _settings.LocalReceivingPort = value;
249                    OnPropertyChanged("LocalPort");
250                    HasChanges = true;
251                }
252            }
253        }
254
255        [TaskPane("useLocalAddressDetection_caption", "useLocalAddressDetection_tooltip", GroupExpert, 5, false, DisplayLevel.Expert,
256            ControlType.CheckBox)]
257        public bool UseLocalAddressDetection
258        {
259            get { return _settings.UseLocalAddressDetection; }
260            set
261            {
262                if (value != _settings.UseLocalAddressDetection)
263                {
264                    _settings.UseLocalAddressDetection = value;
265                    OnPropertyChanged("UseLocalAddressDetection");
266                    HasChanges = true;
267                }
268            }
269        }
270
271        [TaskPane("log2monitor_caption", "log2monitor_tooltip", GroupExpert, 6, false, DisplayLevel.Expert,
272            ControlType.CheckBox)]
273        public bool Log2Monitor
274        {
275            get { return _settings.Log2Monitor; }
276            set
277            {
278                if (value != _settings.Log2Monitor)
279                {
280                    _settings.Log2Monitor = value;
281                    OnPropertyChanged("Log2Monitor");
282                    HasChanges = true;
283                }
284            }
285        }
286
287        #endregion
288
289        private void OnPropertyChanged(string p)
290        {
291            if (PropertyChanged != null)
292            {
293                PropertyChanged(this, new PropertyChangedEventArgs(p));
294            }
295
296            P2PSettings.Default.Save();
297        }
298
299        private void RunConnectionWorker()
300        {
301            var connectionWorker = new ConnectionWorker(P2PManager.Instance.P2PBase);
302            connectionWorker.BackgroundWorker.RunWorkerCompleted += ((P2PEditorPresentation)_p2PEditor.Presentation).ConnectionWorkerCompleted;
303            connectionWorker.Start();
304        }
305    }
306}
Note: See TracBrowser for help on using the repository browser.