Mercurial Repositories > eric / file comparison

comparison: eric6/Network/IRC/IrcNetworkManager.py

eric6/Network/IRC/IrcNetworkManager.py

changeset 6942
2602857055c5
parent 6645
ad476851d7e0
child 7229
53054eb5b15a
equal deleted inserted replaced
6941:f99d60d6b59b 6942:2602857055c5
1 # -*- coding: utf-8 -*-
2
3 # Copyright (c) 2012 - 2019 Detlev Offenbach <detlev@die-offenbachs.de>
4 #
5
6 """
7 Module implementing the IRC data structures and their manager.
8 """
9
10 from __future__ import unicode_literals
11
12 import copy
13
14 from PyQt5.QtCore import pyqtSignal, QObject, QCoreApplication
15
16 import Utilities
17 from Utilities.AutoSaver import AutoSaver
18 from Utilities.crypto import pwConvert
19 import Preferences
20
21
22 class IrcIdentity(object):
23 """
24 Class implementing the IRC identity object.
25 """
26 DefaultIdentityName = "0default"
27 DefaultIdentityDisplay = QCoreApplication.translate(
28 "IrcIdentity", "Default Identity")
29
30 DefaultAwayMessage = QCoreApplication.translate(
31 "IrcIdentity", "Gone away for now.")
32 DefaultQuitMessage = QCoreApplication.translate(
33 "IrcIdentity", "IRC for eric6 IDE")
34 DefaultPartMessage = QCoreApplication.translate(
35 "IrcIdentity", "IRC for eric6 IDE")
36
37 def __init__(self, name):
38 """
39 Constructor
40
41 @param name name of the identity (string)
42 """
43 super(IrcIdentity, self).__init__()
44
45 self.__name = name
46 self.__realName = ""
47 self.__nickNames = []
48 self.__serviceName = ""
49 self.__password = ""
50 self.__ident = Utilities.getUserName()
51
52 self.__rememberPosOnAway = True
53 self.__awayMessage = IrcIdentity.DefaultAwayMessage
54
55 self.__quitMessage = IrcIdentity.DefaultQuitMessage
56 self.__partMessage = IrcIdentity.DefaultPartMessage
57
58 def save(self, settings):
59 """
60 Public method to save the identity data.
61
62 @param settings reference to the settings object (QSettings)
63 """
64 # no need to save the name because that is the group key
65 settings.setValue("Ident", self.__ident)
66 settings.setValue("RealName", self.__realName)
67 settings.setValue("NickNames", self.__nickNames)
68 settings.setValue("ServiceName", self.__serviceName)
69 settings.setValue("Password", self.__password)
70 settings.setValue("QuitMessage", self.__quitMessage)
71 settings.setValue("PartMessage", self.__partMessage)
72 settings.setValue("RememberAwayPosition", self.__rememberPosOnAway)
73 settings.setValue("AwayMessage", self.__awayMessage)
74
75 def load(self, settings):
76 """
77 Public method to load the identity data.
78
79 @param settings reference to the settings object (QSettings)
80 """
81 self.__ident = settings.value("Ident", Utilities.getUserName())
82 self.__realName = settings.value("RealName", "")
83 self.__nickNames = Preferences.toList(settings.value("NickNames", []))
84 self.__serviceName = settings.value("ServiceName", "")
85 self.__password = settings.value("Password", "")
86 self.__quitMessage = settings.value(
87 "QuitMessage", IrcIdentity.DefaultQuitMessage)
88 self.__partMessage = settings.value(
89 "PartMessage", IrcIdentity.DefaultPartMessage)
90 self.__rememberPosOnAway = Preferences.toBool(
91 settings.value("RememberAwayPosition", True))
92 self.__awayMessage = settings.value(
93 "AwayMessage", IrcIdentity.DefaultAwayMessage)
94
95 def setName(self, name):
96 """
97 Public method to set the identity name.
98
99 @param name identity name (string)
100 """
101 self.__name = name
102
103 def getName(self):
104 """
105 Public method to get the identity name.
106
107 @return identity name (string)
108 """
109 return self.__name
110
111 def setIdent(self, name):
112 """
113 Public method to set the real identity name.
114
115 @param name real identity name (string)
116 """
117 self.__ident = name
118
119 def getIdent(self):
120 """
121 Public method to get the real identity name.
122
123 @return real identity name (string)
124 """
125 return self.__ident
126
127 def setRealName(self, name):
128 """
129 Public method to set the real name of the identity.
130
131 @param name real name (string)
132 """
133 self.__realName = name
134
135 def getRealName(self):
136 """
137 Public method to get the real name.
138
139 @return real name (string)
140 """
141 return self.__realName
142
143 def setNickNames(self, names):
144 """
145 Public method to set the nick names of the identity.
146
147 @param names nick names (list of string)
148 """
149 self.__nickNames = names[:]
150
151 def getNickNames(self):
152 """
153 Public method to get the nick names.
154
155 @return nick names (list of string)
156 """
157 return self.__nickNames
158
159 def setServiceName(self, name):
160 """
161 Public method to set the service name of the identity used for
162 identification.
163
164 @param name service name (string)
165 """
166 self.__serviceName = name
167
168 def getServiceName(self):
169 """
170 Public method to get the service name of the identity used for
171 identification.
172
173 @return service name (string)
174 """
175 return self.__serviceName
176
177 def setPassword(self, password):
178 """
179 Public method to set a new password.
180
181 @param password password to set (string)
182 """
183 self.__password = pwConvert(password, encode=True)
184
185 def getPassword(self):
186 """
187 Public method to get the password.
188
189 @return password (string)
190 """
191 return pwConvert(self.__password, encode=False)
192
193 def setQuitMessage(self, message):
194 """
195 Public method to set the QUIT message.
196
197 @param message QUIT message (string)
198 """
199 if message:
200 self.__quitMessage = message
201 else:
202 self.__quitMessage = IrcIdentity.DefaultQuitMessage
203
204 def getQuitMessage(self):
205 """
206 Public method to get the QUIT message.
207
208 @return QUIT message (string)
209 """
210 return self.__quitMessage
211
212 def setPartMessage(self, message):
213 """
214 Public method to set the PART message.
215
216 @param message PART message (string)
217 """
218 if message:
219 self.__partMessage = message
220 else:
221 self.__partMessage = IrcIdentity.DefaultPartMessage
222
223 def getPartMessage(self):
224 """
225 Public method to get the PART message.
226
227 @return PART message (string)
228 """
229 return self.__partMessage
230
231 def setRememberAwayPosition(self, remember):
232 """
233 Public method to set to remember the chat position upon AWAY.
234
235 @param remember flag indicating to remember the chat position (boolean)
236 """
237 self.__rememberPosOnAway = remember
238
239 def rememberAwayPosition(self):
240 """
241 Public method to get a flag indicating to remember the chat position
242 upon AWAY.
243
244 @return flag indicating to remember the chat position (boolean)
245 """
246 return self.__rememberPosOnAway
247
248 def setAwayMessage(self, message):
249 """
250 Public method to set the AWAY message.
251
252 @param message AWAY message (string)
253 """
254 if message:
255 self.__awayMessage = message
256 else:
257 self.__awayMessage = IrcIdentity.DefaultAwayMessage
258
259 def getAwayMessage(self):
260 """
261 Public method to get the AWAY message.
262
263 @return AWAY message (string)
264 """
265 return self.__awayMessage
266
267 @classmethod
268 def createDefaultIdentity(cls):
269 """
270 Class method to create the default identity.
271
272 @return default identity (IrcIdentity)
273 """
274 userName = Utilities.getUserName()
275 realName = Utilities.getRealName()
276 if not realName:
277 realName = "eric IDE chat"
278 identity = IrcIdentity(IrcIdentity.DefaultIdentityName)
279 identity.setNickNames([userName, userName + "_", userName + "__"])
280 identity.setRealName(realName)
281 identity.setIdent(userName)
282 return identity
283
284
285 class IrcServer(object):
286 """
287 Class implementing the IRC identity object.
288 """
289 DefaultPort = 6667
290 DefaultSslPort = 6697
291
292 def __init__(self, name):
293 """
294 Constructor
295
296 @param name name of the server (string)
297 """
298 super(IrcServer, self).__init__()
299
300 self.__server = name
301 self.__port = IrcServer.DefaultPort
302 self.__ssl = False
303 self.__password = ""
304
305 def save(self, settings):
306 """
307 Public method to save the server data.
308
309 @param settings reference to the settings object (QSettings)
310 """
311 settings.setValue("Name", self.__server)
312 settings.setValue("Port", self.__port)
313 settings.setValue("SSL", self.__ssl)
314 settings.setValue("Password", self.__password)
315
316 def load(self, settings):
317 """
318 Public method to load the server data.
319
320 @param settings reference to the settings object (QSettings)
321 """
322 self.__server = settings.value("Name", "")
323 self.__port = int(settings.value("Port", IrcServer.DefaultPort))
324 self.__ssl = Preferences.toBool(settings.value("SSL", False))
325 self.__password = settings.value("Password", "")
326
327 def getName(self):
328 """
329 Public method to get the server name.
330
331 @return server name (string)
332 """
333 return self.__server
334
335 def setName(self, name):
336 """
337 Public method to set the server name.
338
339 @param name server name (string)
340 """
341 self.__server = name
342
343 def getPort(self):
344 """
345 Public method to get the server port number.
346
347 @return port number (integer)
348 """
349 return self.__port
350
351 def setPort(self, port):
352 """
353 Public method to set the server port number.
354
355 @param port server port number (integer)
356 """
357 self.__port = port
358
359 def useSSL(self):
360 """
361 Public method to check for SSL usage.
362
363 @return flag indicating SSL usage (boolean)
364 """
365 return self.__ssl
366
367 def setUseSSL(self, on):
368 """
369 Public method to set the SSL usage.
370
371 @param on flag indicating SSL usage (boolean)
372 """
373 self.__ssl = on
374
375 def setPassword(self, password):
376 """
377 Public method to set a new password.
378
379 @param password password to set (string)
380 """
381 self.__password = pwConvert(password, encode=True)
382
383 def getPassword(self):
384 """
385 Public method to get the password.
386
387 @return password (string)
388 """
389 return pwConvert(self.__password, encode=False)
390
391
392 class IrcChannel(object):
393 """
394 Class implementing the IRC channel object.
395 """
396 def __init__(self, name):
397 """
398 Constructor
399
400 @param name name of the network (string)
401 """
402 super(IrcChannel, self).__init__()
403
404 self.__name = name
405 self.__key = ""
406 self.__autoJoin = False
407
408 def save(self, settings):
409 """
410 Public method to save the channel data.
411
412 @param settings reference to the settings object (QSettings)
413 """
414 # no need to save the channel name because that is the group key
415 settings.setValue("Key", self.__key)
416 settings.setValue("AutoJoin", self.__autoJoin)
417
418 def load(self, settings):
419 """
420 Public method to load the network data.
421
422 @param settings reference to the settings object (QSettings)
423 """
424 self.__key = settings.value("Key", "")
425 self.__autoJoin = Preferences.toBool(settings.value("AutoJoin", False))
426
427 def getName(self):
428 """
429 Public method to get the channel name.
430
431 @return channel name (string)
432 """
433 return self.__name
434
435 def setKey(self, key):
436 """
437 Public method to set a new channel key.
438
439 @param key channel key to set (string)
440 """
441 self.__key = pwConvert(key, encode=True)
442
443 def getKey(self):
444 """
445 Public method to get the channel key.
446
447 @return channel key (string)
448 """
449 return pwConvert(self.__key, encode=False)
450
451 def autoJoin(self):
452 """
453 Public method to check the auto join status.
454
455 @return flag indicating if the channel should be
456 joined automatically (boolean)
457 """
458 return self.__autoJoin
459
460 def setAutoJoin(self, enable):
461 """
462 Public method to set the auto join status of the channel.
463
464 @param enable flag indicating if the channel should be
465 joined automatically (boolean)
466 """
467 self.__autoJoin = enable
468
469
470 class IrcNetwork(object):
471 """
472 Class implementing the IRC network object.
473 """
474 def __init__(self, name):
475 """
476 Constructor
477
478 @param name name of the network (string)
479 """
480 super(IrcNetwork, self).__init__()
481
482 self.__name = name
483 self.__identity = ""
484 self.__server = None
485 self.__channels = {}
486 self.__autoConnect = False
487
488 def save(self, settings):
489 """
490 Public method to save the network data.
491
492 @param settings reference to the settings object (QSettings)
493 """
494 # no need to save the network name because that is the group key
495 settings.setValue("Identity", self.__identity)
496 settings.setValue("AutoConnect", self.__autoConnect)
497
498 settings.beginGroup("Server")
499 self.__server.save(settings)
500 settings.endGroup()
501
502 settings.beginGroup("Channels")
503 for key in self.__channels:
504 settings.beginGroup(key)
505 self.__channels[key].save(settings)
506 settings.endGroup()
507 settings.endGroup()
508
509 def load(self, settings):
510 """
511 Public method to load the network data.
512
513 @param settings reference to the settings object (QSettings)
514 """
515 self.__identity = settings.value("Identity", "")
516 self.__autoConnect = Preferences.toBool(
517 settings.value("AutoConnect", False))
518
519 settings.beginGroup("Server")
520 self.__server = IrcServer("")
521 self.__server.load(settings)
522 settings.endGroup()
523
524 settings.beginGroup("Channels")
525 for key in settings.childGroups():
526 self.__channels[key] = IrcChannel(key)
527 settings.beginGroup(key)
528 self.__channels[key].load(settings)
529 settings.endGroup()
530 settings.endGroup()
531
532 def setName(self, name):
533 """
534 Public method to set the network name.
535
536 @param name network name (string)
537 """
538 self.__name = name
539
540 def getName(self):
541 """
542 Public method to get the network name.
543
544 @return network name (string)
545 """
546 return self.__name
547
548 def setIdentityName(self, name):
549 """
550 Public method to set the name of the identity.
551
552 @param name identity name (string)
553 """
554 self.__identity = name
555
556 def getIdentityName(self):
557 """
558 Public method to get the name of the identity.
559
560 @return identity name (string)
561 """
562 return self.__identity
563
564 def getServerName(self):
565 """
566 Public method to get the server name.
567
568 @return server name (string)
569 """
570 if self.__server:
571 return self.__server.getName()
572 else:
573 return ""
574
575 def getServer(self):
576 """
577 Public method to get the server object.
578
579 @return reference to the server (IrcServer)
580 """
581 return self.__server
582
583 def setServer(self, server):
584 """
585 Public method to set the server.
586
587 @param server server object to set (IrcServer)
588 """
589 self.__server = server
590
591 def setChannels(self, channels):
592 """
593 Public method to set the list of channels.
594
595 @param channels list of channels for the network (list of IrcChannel)
596 """
597 self.__channels = {}
598 for channel in channels:
599 self.__channels[channel.getName()] = channel
600
601 def getChannels(self):
602 """
603 Public method to get the channels.
604
605 @return list of channels for the network (list of IrcChannel)
606 """
607 return list(copy.deepcopy(self.__channels).values())
608
609 def getChannelNames(self):
610 """
611 Public method to get the list of channels.
612
613 @return list of channel names (list of string)
614 """
615 return list(sorted(self.__channels.keys()))
616
617 def getChannel(self, channelName):
618 """
619 Public method to get a channel.
620
621 @param channelName name of the channel to retrieve (string)
622 @return reference to the channel (IrcChannel)
623 """
624 if channelName in self.__channels:
625 return self.__channels[channelName]
626 else:
627 return None
628
629 def setChannel(self, channel):
630 """
631 Public method to set a channel.
632
633 @param channel channel object to set (IrcChannel)
634 """
635 channelName = channel.getName()
636 if channelName in self.__channels:
637 self.__channels[channelName] = channel
638
639 def addChannel(self, channel):
640 """
641 Public method to add a channel.
642
643 @param channel channel object to add (IrcChannel)
644 """
645 channelName = channel.getName()
646 if channelName not in self.__channels:
647 self.__channels[channelName] = channel
648
649 def deleteChannel(self, channelName):
650 """
651 Public method to delete the given channel.
652
653 @param channelName name of the channel to be deleted (string)
654 """
655 if channelName in self.__channels:
656 del self.__channels[channelName]
657
658 def setAutoConnect(self, enable):
659 """
660 Public method to set the auto connect flag.
661
662 @param enable flag indicate to connect to the network at start-up.
663 """
664 self.__autoConnect = enable
665
666 def autoConnect(self):
667 """
668 Public method to check, if the network should be connected to at
669 start-up.
670
671 @return flag indicating an auto connect (boolean)
672 """
673 return self.__autoConnect
674
675 @classmethod
676 def createDefaultNetwork(cls, ssl=False):
677 """
678 Class method to create the default network.
679
680 @param ssl flag indicating to create a SSL network configuration
681 (boolean)
682 @return default network object (IrcNetwork)
683 """
684 # network
685 if ssl:
686 networkName = "Freenode (SSL)"
687 else:
688 networkName = "Freenode"
689 network = IrcNetwork(networkName)
690 network.setIdentityName(IrcIdentity.DefaultIdentityName)
691
692 # server
693 serverName = "chat.freenode.net"
694 server = IrcServer(serverName)
695 if ssl:
696 server.setPort(IrcServer.DefaultSslPort)
697 server.setUseSSL(True)
698 else:
699 server.setPort(IrcServer.DefaultPort)
700 network.setServer(server)
701
702 # channel
703 channel = IrcChannel("#eric-ide")
704 channel.setAutoJoin(False)
705 network.addChannel(channel)
706
707 # auto connect
708 network.setAutoConnect(False)
709
710 return network
711
712
713 class IrcNetworkManager(QObject):
714 """
715 Class implementing the IRC identity object.
716
717 @signal dataChanged() emitted after some data has changed
718 @signal networksChanged() emitted after a network object has changed
719 @signal identitiesChanged() emitted after an identity object has changed
720 """
721 dataChanged = pyqtSignal()
722 networksChanged = pyqtSignal()
723 identitiesChanged = pyqtSignal()
724
725 def __init__(self, parent=None):
726 """
727 Constructor
728
729 @param parent reference to the parent object (QObject)
730 """
731 super(IrcNetworkManager, self).__init__(parent)
732
733 self.__loaded = False
734 self.__saveTimer = AutoSaver(self, self.save)
735
736 self.__settings = Preferences.Prefs.settings
737
738 self.__networks = {}
739 self.__identities = {}
740
741 self.dataChanged.connect(self.__saveTimer.changeOccurred)
742
743 def close(self):
744 """
745 Public method to close the open search engines manager.
746 """
747 self.__saveTimer.saveIfNeccessary()
748
749 def save(self):
750 """
751 Public slot to save the IRC data.
752 """
753 if not self.__loaded:
754 return
755
756 # save IRC data
757 self.__settings.beginGroup("IRC")
758
759 # identities
760 self.__settings.remove("Identities")
761 self.__settings.beginGroup("Identities")
762 for key in self.__identities:
763 self.__settings.beginGroup(key)
764 self.__identities[key].save(self.__settings)
765 self.__settings.endGroup()
766 self.__settings.endGroup()
767
768 # networks
769 self.__settings.remove("Networks")
770 self.__settings.beginGroup("Networks")
771 for key in self.__networks:
772 self.__settings.beginGroup(key)
773 self.__networks[key].save(self.__settings)
774 self.__settings.endGroup()
775 self.__settings.endGroup()
776
777 self.__settings.endGroup()
778
779 def __load(self):
780 """
781 Private slot to load the IRC data.
782 """
783 if self.__loaded:
784 return
785
786 # load IRC data
787 self.__settings.beginGroup("IRC")
788
789 # identities
790 self.__settings.beginGroup("Identities")
791 for key in self.__settings.childGroups():
792 self.__identities[key] = IrcIdentity(key)
793 self.__settings.beginGroup(key)
794 self.__identities[key].load(self.__settings)
795 self.__settings.endGroup()
796 self.__settings.endGroup()
797
798 # networks
799 self.__settings.beginGroup("Networks")
800 for key in self.__settings.childGroups():
801 self.__networks[key] = IrcNetwork(key)
802 self.__settings.beginGroup(key)
803 self.__networks[key].load(self.__settings)
804 self.__settings.endGroup()
805 self.__settings.endGroup()
806
807 self.__settings.endGroup()
808
809 if not self.__identities or \
810 not self.__networks:
811 # data structures got corrupted; load defaults
812 self.__loadDefaults()
813
814 if IrcIdentity.DefaultIdentityName not in self.__identities:
815 self.__loadDefaults(identityOnly=True)
816
817 self.__loaded = True
818
819 def __loadDefaults(self, identityOnly=False):
820 """
821 Private method to load default values.
822
823 @param identityOnly flag indicating to just load the default
824 identity (boolean)
825 """
826 if not identityOnly:
827 self.__networks = {}
828 self.__identities = {}
829
830 # identity
831 identity = IrcIdentity.createDefaultIdentity()
832 self.__identities[identity.getName()] = identity
833
834 if not identityOnly:
835 network = IrcNetwork.createDefaultNetwork()
836 self.__networks[network.getName()] = network
837 network = IrcNetwork.createDefaultNetwork(True)
838 self.__networks[network.getName()] = network
839
840 self.dataChanged.emit()
841
842 ##################################################################
843 ## Identity related methods below
844 ##################################################################
845
846 def getIdentity(self, name, create=False):
847 """
848 Public method to get an identity object.
849
850 @param name name of the identity to get (string)
851 @param create flag indicating to create a new object,
852 if none exists (boolean)
853 @return reference to the identity (IrcIdentity)
854 """
855 if not name:
856 return None
857
858 if not self.__loaded:
859 self.__load()
860
861 if name in self.__identities:
862 return self.__identities[name]
863 elif create:
864 ircId = IrcIdentity(name)
865 self.__identities[name] = ircId
866
867 self.dataChanged.emit()
868
869 return ircId
870 else:
871 return None
872
873 def getIdentities(self):
874 """
875 Public method to get a copy of all identities.
876
877 @return dictionary of all identities (dict of IrcIdentity)
878 """
879 return copy.deepcopy(self.__identities)
880
881 def setIdentities(self, identities):
882 """
883 Public method to set the identities.
884
885 @param identities dictionary of all identities (dict of IrcIdentity)
886 """
887 self.__identities = copy.deepcopy(identities)
888 self.identityChanged()
889
890 # Check all networks, if the identity they use is still available.
891 # If it isn't, change them to use the default identity.
892 for network in self.__networks.values():
893 if network.getIdentityName() not in self.__identities:
894 network.setIdentityName(IrcIdentity.DefaultIdentityName)
895
896 def getIdentityNames(self):
897 """
898 Public method to get the names of all identities.
899
900 @return names of all identities (list of string)
901 """
902 return list(self.__identities.keys())
903
904 def addIdentity(self, identity):
905 """
906 Public method to add a new identity.
907
908 @param identity reference to the identity to add (IrcIdentity)
909 """
910 name = identity.getName()
911 self.__identities[name] = identity
912 self.identityChanged()
913
914 def deleteIdentity(self, name):
915 """
916 Public method to delete the given identity.
917
918 @param name name of the identity to delete (string)
919 """
920 if name in self.__identities and \
921 name != IrcIdentity.DefaultIdentityName:
922 del self.__identities[name]
923 self.identityChanged()
924
925 def renameIdentity(self, oldName, newName):
926 """
927 Public method to rename an identity.
928
929 @param oldName old name of the identity (string)
930 @param newName new name of the identity (string)
931 """
932 if oldName in self.__identities:
933 self.__identities[newName] = self.__identities[oldName]
934 del self.__identities[oldName]
935
936 for network in self.__networks:
937 if network.getIdentityName() == oldName:
938 network.setIdentityName(newName)
939
940 self.identityChanged()
941
942 def identityChanged(self):
943 """
944 Public method to indicate a change of an identity object.
945 """
946 self.dataChanged.emit()
947 self.identitiesChanged.emit()
948
949 ##################################################################
950 ## Network related methods below
951 ##################################################################
952
953 def getNetwork(self, name):
954 """
955 Public method to get a network object.
956
957 @param name name of the network (string)
958 @return reference to the network object (IrcNetwork)
959 """
960 if not self.__loaded:
961 self.__load()
962
963 if name in self.__networks:
964 return self.__networks[name]
965 else:
966 return None
967
968 def setNetwork(self, network, networkName=""):
969 """
970 Public method to set a network.
971
972 @param network network object to set (IrcNetwork)
973 @param networkName name the network was known for (string)
974 """
975 name = network.getName()
976 if networkName and name != networkName:
977 # the network name has changed
978 self.deleteNetwork(networkName)
979 self.addNetwork(network)
980 elif name in self.__networks:
981 self.__networks[name] = network
982 self.networkChanged()
983
984 def addNetwork(self, network):
985 """
986 Public method to add a network.
987
988 @param network network object to add (IrcNetwork)
989 """
990 name = network.getName()
991 if name not in self.__networks:
992 self.__networks[name] = network
993 self.networkChanged()
994
995 def deleteNetwork(self, name):
996 """
997 Public method to delete the given network.
998
999 @param name name of the network to delete (string)
1000 """
1001 if name in self.__networks:
1002 del self.__networks[name]
1003 self.networkChanged()
1004
1005 def networkChanged(self):
1006 """
1007 Public method to indicate a change of a network object.
1008 """
1009 self.dataChanged.emit()
1010 self.networksChanged.emit()
1011
1012 def getNetworkNames(self):
1013 """
1014 Public method to get a list of all known network names.
1015
1016 @return list of network names (list of string)
1017 """
1018 if not self.__loaded:
1019 self.__load()
1020
1021 return list(sorted(self.__networks.keys()))

Mercurial Repository: eric

eric ide

mercurial