Mercurial Repositories > IRC client / file comparison

comparison: ExtensionIrc/IrcNetworkManager.py

ExtensionIrc/IrcNetworkManager.py

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

Mercurial Repository: IRC client

eric ide

mercurial