eric: eric7/Network/IRC/IrcChannelWidget.py@68ec9c3d4de5 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2012 - 2021 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the IRC channel widget.
 """
 from itertools import zip_longest
 import re
 from PyQt6.QtCore import (
     pyqtSlot, pyqtSignal, QDateTime, QPoint, QFileInfo, QTimer, QUrl,
     QCoreApplication
 )
 from PyQt6.QtGui import QIcon, QPainter, QTextCursor, QDesktopServices
 from PyQt6.QtWidgets import (
     QWidget, QListWidgetItem, QMenu, QApplication, QInputDialog, QLineEdit
 )
 from E5Gui import EricMessageBox, EricFileDialog
 from E5Gui.EricApplication import ericApp
 from .Ui_IrcChannelWidget import Ui_IrcChannelWidget
 from .IrcUtilities import ircFilter, ircTimestamp, getChannelModesDict
 import Utilities
 import UI.PixmapCache
 import Preferences
 from UI.Info import Version, Copyright
 class IrcUserItem(QListWidgetItem):
     """
     Class implementing a list widget item containing an IRC channel user.
     """
     Normal = 0x00       # no privileges
     Operator = 0x01     # channel operator
     Voice = 0x02        # voice operator
     Admin = 0x04        # administrator
     Halfop = 0x08       # half operator
     Owner = 0x10        # channel owner
     Away = 0x80         # user away
     PrivilegeMapping = {
         "a": Away,
         "o": Operator,
         "O": Owner,
         "v": Voice,
     }
     def __init__(self, name, parent=None):
         """
         Constructor
         @param name string with user name and privilege prefix (string)
         @param parent reference to the parent widget (QListWidget or
             QListWidgetItem)
         """
         super().__init__(name, parent)
         self.__privilege = IrcUserItem.Normal
         self.__name = name
         self.__ignored = False
         self.__setText()
         self.__setIcon()
     def name(self):
         """
         Public method to get the user name.
         @return user name (string)
         """
         return self.__name
     def setName(self, name):
         """
         Public method to set a new nick name.
         @param name new nick name for the user (string)
         """
         self.__name = name
         self.__setText()
     def changePrivilege(self, privilege):
         """
         Public method to set or unset a user privilege.
         @param privilege privilege to set or unset (string)
         """
         oper = privilege[0]
         priv = privilege[1]
         if priv in IrcUserItem.PrivilegeMapping:
             if oper == "+":
                 self.__privilege |= IrcUserItem.PrivilegeMapping[priv]
             elif oper == "-":
                 self.__privilege &= ~IrcUserItem.PrivilegeMapping[priv]
         self.__setIcon()
     def clearPrivileges(self):
         """
         Public method to clear the user privileges.
         """
         self.__privilege = IrcUserItem.Normal
         self.__setIcon()
     def __setText(self):
         """
         Private method to set the user item text.
         """
         if self.__ignored:
             self.setText(QCoreApplication.translate(
                 "IrcUserItem",
                 "{0} (ignored)").format(self.__name))
         else:
             self.setText(self.__name)
     def __setIcon(self):
         """
         Private method to set the icon dependent on user privileges.
         """
         # step 1: determine the icon
         if self.__privilege & IrcUserItem.Voice:
             icon = UI.PixmapCache.getIcon("ircVoice")
         elif self.__privilege & IrcUserItem.Owner:
             icon = UI.PixmapCache.getIcon("ircOwner")
         elif self.__privilege & IrcUserItem.Operator:
             icon = UI.PixmapCache.getIcon("ircOp")
         elif self.__privilege & IrcUserItem.Halfop:
             icon = UI.PixmapCache.getIcon("ircHalfop")
         elif self.__privilege & IrcUserItem.Admin:
             icon = UI.PixmapCache.getIcon("ircAdmin")
         else:
             icon = UI.PixmapCache.getIcon("ircNormal")
         if self.__privilege & IrcUserItem.Away:
             icon = self.__awayIcon(icon)
         # step 2: set the icon
         self.setIcon(icon)
     def __awayIcon(self, icon):
         """
         Private method to convert an icon to an away icon.
         @param icon icon to be converted (QIcon)
         @return away icon (QIcon)
         """
         pix1 = icon.pixmap(16, 16)
         pix2 = UI.PixmapCache.getPixmap("ircAway")
         painter = QPainter(pix1)
         painter.drawPixmap(0, 0, pix2)
         painter.end()
         return QIcon(pix1)
     def parseWhoFlags(self, flags):
         """
         Public method to parse the user flags reported by a WHO command.
         @param flags user flags as reported by WHO (string)
         """
         # H The user is not away.
         # G The user is set away.
         # * The user is an IRC operator.
         # @ The user is a channel op in the channel listed in the first field.
         # + The user is voiced in the channel listed.
         if flags.endswith("@"):
             privilege = IrcUserItem.Operator
         elif flags.endswith("+"):
             privilege = IrcUserItem.Voice
         else:
             privilege = IrcUserItem.Normal
         if "*" in flags:
             privilege = IrcUserItem.Admin
         if flags.startswith("G"):
             privilege |= IrcUserItem.Away
         self.__privilege = privilege
         self.__setIcon()
     def canChangeTopic(self):
         """
         Public method to check, if the user is allowed to change the topic.
         @return flag indicating that the topic can be changed (boolean)
         """
         return(bool(self.__privilege & IrcUserItem.Operator) or
                bool(self.__privilege & IrcUserItem.Admin) or
                bool(self.__privilege & IrcUserItem.Owner))
     def setIgnored(self, ignored):
         """
         Public method to set the user status to ignored.
         @param ignored flag indicating the new ignored status
         @type bool
         """
         self.__ignored = ignored
         self.__setText()
     def isIgnored(self):
         """
         Public method to check, if this user is ignored.
         @return flag indicating the ignored status
         @rtype bool
         """
         return self.__ignored
 class IrcChannelWidget(QWidget, Ui_IrcChannelWidget):
     """
     Class implementing the IRC channel widget.
     @signal sendData(str) emitted to send a message to the channel
     @signal sendCtcpRequest(str, str, str) emitted to send a CTCP request
     @signal sendCtcpReply(str, str) emitted to send a CTCP reply
     @signal channelClosed(str) emitted after the user has left the channel
     @signal openPrivateChat(str) emitted to open a "channel" for private
         messages
     @signal awayCommand(str) emitted to set the away status via the /away
         command
     @signal leaveChannels(list) emitted to leave a list of channels
     @signal leaveAllChannels() emitted to leave all channels
     """
     sendData = pyqtSignal(str)
     sendCtcpRequest = pyqtSignal(str, str, str)
     sendCtcpReply = pyqtSignal(str, str)
     channelClosed = pyqtSignal(str)
     openPrivateChat = pyqtSignal(str)
     awayCommand = pyqtSignal(str)
     leaveChannels = pyqtSignal(list)
     leaveAllChannels = pyqtSignal()
     UrlRe = re.compile(
         r"""((?:http|ftp|https):\/\/[\w\-_]+(?:\.[\w\-_]+)+"""
         r"""(?:[\w\-\.,@?^=%&amp;:/~\+#]*[\w\-\@?^=%&amp;/~\+#])?)""")
     JoinIndicator = "--&gt;"
     LeaveIndicator = "&lt;--"
     MessageIndicator = "***"
     def __init__(self, parent=None):
         """
         Constructor
         @param parent reference to the parent widget (QWidget)
         """
         super().__init__(parent)
         self.setupUi(self)
         self.__ui = ericApp().getObject("UserInterface")
         self.__ircWidget = parent
         self.editTopicButton.setIcon(
             UI.PixmapCache.getIcon("ircEditTopic"))
         self.editTopicButton.hide()
         height = self.usersList.height() + self.messages.height()
         self.splitter.setSizes([height * 0.3, height * 0.7])
         self.__initMessagesMenu()
         self.__initUsersMenu()
         self.__name = ""
         self.__userName = ""
         self.__partMessage = ""
         self.__prefixToPrivilege = {}
         self.__private = False
         self.__privatePartner = ""
         self.__whoIsNick = ""
         self.__markerLine = ""
         self.__hidden = True
         self.__serviceNamesLower = ["nickserv", "chanserv", "memoserv"]
         self.__patterns = [
             # :foo_!n=foo@foohost.bar.net PRIVMSG #eric-ide :some long message
             # :foo_!n=foo@foohost.bar.net PRIVMSG bar_ :some long message
             (re.compile(r":([^!]+)!([^ ]+)\sPRIVMSG\s([^ ]+)\s:(.*)"),
              self.__message),
             # :foo_!n=foo@foohost.bar.net JOIN :#eric-ide
             (re.compile(r":([^!]+)!([^ ]+)\sJOIN\s:?([^ ]+)"),
              self.__userJoin),
             # :foo_!n=foo@foohost.bar.net PART #eric-ide :part message
             (re.compile(r":([^!]+).*\sPART\s([^ ]+)\s:(.*)"), self.__userPart),
             # :foo_!n=foo@foohost.bar.net PART #eric-ide
             (re.compile(r":([^!]+).*\sPART\s([^ ]+)\s*"), self.__userPart),
             # :foo_!n=foo@foohost.bar.net QUIT :quit message
             (re.compile(r":([^!]+).*\sQUIT\s:(.*)"), self.__userQuit),
             # :foo_!n=foo@foohost.bar.net QUIT
             (re.compile(r":([^!]+).*\sQUIT\s*"), self.__userQuit),
             # :foo_!n=foo@foohost.bar.net NICK :newnick
             (re.compile(r":([^!]+).*\sNICK\s:(.*)"), self.__userNickChange),
             # :foo_!n=foo@foohost.bar.net MODE #eric-ide +o foo_
             (re.compile(r":([^!]+).*\sMODE\s([^ ]+)\s([+-][ovO]+)\s([^ ]+).*"),
                 self.__setUserPrivilege),
             # :cameron.freenode.net MODE #eric-ide +ns
             (re.compile(r":([^ ]+)\sMODE\s([^ ]+)\s(.+)"),
              self.__updateChannelModes),
             # :foo_!n=foo@foohost.bar.net TOPIC #eric-ide :eric - Python IDE
             (re.compile(r":.*\sTOPIC\s([^ ]+)\s:(.*)"), self.__setTopic),
             # :sturgeon.freenode.net 301 foo_ bar :Gone away for now
             (re.compile(r":.*\s301\s([^ ]+)\s([^ ]+)\s:(.+)"),
              self.__userAway),
             # :sturgeon.freenode.net 315 foo_ #eric-ide :End of /WHO list.
             (re.compile(r":.*\s315\s[^ ]+\s([^ ]+)\s:(.*)"), self.__whoEnd),
             # :zelazny.freenode.net 324 foo_ #eric-ide +cnt
             (re.compile(r":.*\s324\s.*\s([^ ]+)\s(.+)"), self.__channelModes),
             # :zelazny.freenode.net 328 foo_ #eric-ide :http://www.bugger.com/
             (re.compile(r":.*\s328\s.*\s([^ ]+)\s:(.+)"), self.__channelUrl),
             # :zelazny.freenode.net 329 foo_ #eric-ide 1353001005
             (re.compile(r":.*\s329\s.*\s([^ ]+)\s(.+)"),
              self.__channelCreated),
             # :zelazny.freenode.net 332 foo_ #eric-ide :eric support channel
             (re.compile(r":.*\s332\s.*\s([^ ]+)\s:(.*)"), self.__setTopic),
             # :zelazny.freenode.net foo_ 333 #eric-ide foo 1353089020
             (re.compile(r":.*\s333\s.*\s([^ ]+)\s([^ ]+)\s(\d+)"),
              self.__topicCreated),
             # :cameron.freenode.net 352 detlev_ #eric-ide ~foo foohost.bar.net
             # cameron.freenode.net foo_ H :0 Foo Bar
             (re.compile(
                 r":.*\s352\s[^ ]+\s([^ ]+)\s([^ ]+)\s([^ ]+)\s[^ ]+\s([^ ]+)"
                 r"\s([^ ]+)\s:\d+\s(.*)"), self.__whoEntry),
             # :zelazny.freenode.net 353 foo_ @ #eric-ide :@user1 +user2 user3
             (re.compile(r":.*\s353\s.*\s.\s([^ ]+)\s:(.*)"), self.__userList),
             # :sturgeon.freenode.net 354 foo_ 42 ChanServ H@
             (re.compile(r":.*\s354\s[^ ]+\s42\s([^ ]+)\s(.*)"),
              self.__autoWhoEntry),
             # :zelazny.freenode.net 366 foo_ #eric-ide :End of /NAMES list.
             (re.compile(r":.*\s366\s.*\s([^ ]+)\s:(.*)"), self.__ignore),
             # :sturgeon.freenode.net 704 foo_ index :Help topics available:
             (re.compile(r":.*\s70[456]\s[^ ]+\s([^ ]+)\s:(.*)"), self.__help),
             # WHOIS replies
             # :sturgeon.freenode.net 311 foo_ bar ~bar barhost.foo.net * :Bar
             (re.compile(
                 r":.*\s311\s[^ ]+\s([^ ]+)\s([^ ]+)\s([^ ]+)\s\*\s:(.*)"),
              self.__whoIsUser),
             # :sturgeon.freenode.net 319 foo_ bar :@#eric-ide
             (re.compile(r":.*\s319\s[^ ]+\s([^ ]+)\s:(.*)"),
              self.__whoIsChannels),
             # :sturgeon.freenode.net 312 foo_ bar sturgeon.freenode.net :London
             (re.compile(r":.*\s312\s[^ ]+\s([^ ]+)\s([^ ]+)\s:(.*)"),
              self.__whoIsServer),
             # :sturgeon.freenode.net 671 foo_ bar :is using a secure connection
             (re.compile(r":.*\s671\s[^ ]+\s([^ ]+)\s:.*"), self.__whoIsSecure),
             # :sturgeon.freenode.net 317 foo_ bar 3758 1355046912 :seconds
             # idle, signon time
             (re.compile(r":.*\s317\s[^ ]+\s([^ ]+)\s(\d+)\s(\d+)\s:.*"),
                 self.__whoIsIdle),
             # :sturgeon.freenode.net 330 foo_ bar bar :is logged in as
             (re.compile(r":.*\s330\s[^ ]+\s([^ ]+)\s([^ ]+)\s:.*"),
              self.__whoIsAccount),
             # :sturgeon.freenode.net 318 foo_ bar :End of /WHOIS list.
             (re.compile(r":.*\s318\s[^ ]+\s([^ ]+)\s:(.*)"), self.__whoIsEnd),
             # :sturgeon.freenode.net 307 foo_ bar :is an identified user
             (re.compile(r":.*\s307\s[^ ]+\s([^ ]+)\s:(.*)"),
              self.__whoIsIdentify),
             # :sturgeon.freenode.net 320 foo_ bar :is an identified user
             (re.compile(r":.*\s320\s[^ ]+\s([^ ]+)\s:(.*)"),
              self.__whoIsIdentify),
             # :sturgeon.freenode.net 310 foo_ bar :is available for help
             (re.compile(r":.*\s310\s[^ ]+\s([^ ]+)\s:(.*)"),
              self.__whoIsHelper),
             # :sturgeon.freenode.net 338 foo_ bar real.ident@real.host
             # 12.34.56.78 :Actual user@host, Actual IP
             (re.compile(r":.*\s338\s[^ ]+\s([^ ]+)\s([^ ]+)\s([^ ]+)\s:.*"),
              self.__whoIsActually),
             # :sturgeon.freenode.net 313 foo_ bar :is an IRC Operator
             (re.compile(r":.*\s313\s[^ ]+\s([^ ]+)\s:(.*)"),
              self.__whoIsOperator),
             # :sturgeon.freenode.net 378 foo_ bar :is connecting from
             # *@mnch-4d044d5a.pool.mediaWays.net 77.4.77.90
             (re.compile(r":.*\s378\s[^ ]+\s([^ ]+)\s:.*\s([^ ]+)\s([^ ]+)"),
              self.__whoIsConnection),
         ]
         self.__autoWhoTemplate = "WHO {0} %tnf,42"
         self.__autoWhoTimer = QTimer()
         self.__autoWhoTimer.setSingleShot(True)
         self.__autoWhoTimer.timeout.connect(self.__sendAutoWhoCommand)
         self.__autoWhoRequested = False
     @pyqtSlot()
     def on_messageEdit_returnPressed(self):
         """
         Private slot to send a message to the channel.
         """
         msg = self.messageEdit.text()
         if msg:
             self.__processUserMessage(msg)
     def __processUserMessage(self, msg):
         """
         Private method to process a message entered by the user or via the
         user list context menu.
         @param msg message to be processed
         @type str
         """
         self.messages.append(
             '<font color="{0}">{2} <b>&lt;</b><font color="{1}">{3}</font>'
             '<b>&gt;</b> {4}</font>'.format(
                 Preferences.getIrc("ChannelMessageColour"),
                 Preferences.getIrc("OwnNickColour"),
                 ircTimestamp(), self.__userName,
                 Utilities.html_encode(msg)))
         if msg.startswith("/"):
             if self.__private:
                 EricMessageBox.information(
                     self,
                     self.tr("Send Message"),
                     self.tr(
                         """Messages starting with a '/' are not allowed"""
                         """ in private chats."""))
             else:
                 sendData = True
                 # flag set to False, if command was handled
                 msgList = msg.split()
                 cmd = msgList[0][1:].upper()
                 if cmd in ["MSG", "QUERY"]:
                     cmd = "PRIVMSG"
                     if len(msgList) > 1:
                         if (
                             msgList[1].strip().lower() in
                             self.__serviceNamesLower
                         ):
                             msg = (
                                 "PRIVMSG " +
                                 msgList[1].strip().lower() +
                                 " :" + " ".join(msgList[2:])
                             )
                         else:
                             msg = "PRIVMSG {0} :{1}".format(
                                 msgList[1], " ".join(msgList[2:]))
                     else:
                         msgList[0] = cmd
                         msg = " ".join(msgList)
                 elif cmd == "NOTICE":
                     if len(msgList) > 2:
                         msg = "NOTICE {0} :{1}".format(
                             msgList[1], " ".join(msgList[2:]))
                     else:
                         msg = "NOTICE {0}".format(" ".join(msgList[1:]))
                 elif cmd == "PING":
                     receiver = msgList[1]
                     msg = "PING {0} "
                     self.sendCtcpRequest.emit(receiver, "PING", "")
                     sendData = False
                 elif cmd == "IGNORE":
                     sendData = False
                     if len(msgList) > 1:
                         if msgList[1] == "-r":
                             ignored = False
                             userNamesList = msgList[2:]
                         else:
                             ignored = True
                             userNamesList = msgList[1:]
                     else:
                         userNamesList = []
                     userNames = ",".join(
                         u.rstrip(",") for u in userNamesList).split(",")
                     for userName in userNames:
                         itm = self.__findUser(userName)
                         if itm:
                             itm.setIgnored(ignored)
                 elif cmd == "UNIGNORE":
                     sendData = False
                     if len(msgList) > 1:
                         userNamesList = msgList[1:]
                     else:
                         userNamesList = []
                     userNames = ",".join(
                         u.rstrip(",") for u in userNamesList).split(",")
                     for userName in userNames:
                         itm = self.__findUser(userName)
                         if itm:
                             itm.setIgnored(False)
                 elif cmd == "AWAY":
                     sendData = False
                     if len(msgList) > 1:
                         msg = " ".join(msgList[1:])
                     else:
                         msg = ""
                     self.awayCommand.emit(msg)
                 elif cmd == "JOIN":
                     sendData = False
                     if len(msgList) > 1:
                         channels = msgList[1].split(",")
                         if len(msgList) > 2:
                             keys = msgList[2].split(",")
                         else:
                             keys = []
                         for channel, key in zip_longest(
                                 channels, keys, fillvalue=""):
                             self.__ircWidget.joinChannel(channel, key)
                 elif cmd == "PART":
                     sendData = False
                     if len(msgList) == 1:
                         self.leaveChannel()
                     else:
                         self.leaveChannels.emit(msgList[1:])
                 elif cmd == "PARTALL":
                     sendData = False
                     self.leaveAllChannels.emit()
                 else:
                     msg = msg[1:]
                 if sendData:
                     self.sendData.emit(msg)
         else:
             if self.__private:
                 self.sendData.emit(
                     "PRIVMSG " + self.__privatePartner + " :" + msg)
             else:
                 self.sendData.emit(
                     "PRIVMSG " + self.__name + " :" + msg)
         self.messageEdit.clear()
         self.unsetMarkerLine()
     def requestLeave(self):
         """
         Public method to leave the channel.
         """
         ok = EricMessageBox.yesNo(
             self,
             self.tr("Leave IRC channel"),
             self.tr(
                 """Do you really want to leave the IRC channel"""
                 """ <b>{0}</b>?""").format(self.__name))
         if ok:
             self.leaveChannel()
     def leaveChannel(self):
         """
         Public slot to leave the channel.
         """
         if not self.__private:
             self.sendData.emit(
                 "PART " + self.__name + " :" + self.__partMessage)
         self.channelClosed.emit(self.__name)
     def name(self):
         """
         Public method to get the name of the channel.
         @return name of the channel (string)
         """
         return self.__name
     def setName(self, name):
         """
         Public method to set the name of the channel.
         @param name of the channel (string)
         """
         self.__name = name
     def getUsersCount(self):
         """
         Public method to get the users count of the channel.
         @return users count of the channel (integer)
         """
         return self.usersList.count()
     def userName(self):
         """
         Public method to get the nick name of the user.
         @return nick name of the user (string)
         """
         return self.__userName
     def setUserName(self, name):
         """
         Public method to set the user name for the channel.
         @param name user name for the channel (string)
         """
         self.__userName = name
     def partMessage(self):
         """
         Public method to get the part message.
         @return part message (string)
         """
         return self.__partMessage
     def setPartMessage(self, message):
         """
         Public method to set the part message.
         @param message message to be used for PART messages (string)
         """
         self.__partMessage = message
     def setPrivate(self, private, partner=""):
         """
         Public method to set the private chat mode.
         @param private flag indicating private chat mode (boolean)
         @param partner name of the partner user (string)
         """
         self.__private = private
         self.__privatePartner = partner
         self.editTopicButton.setEnabled(private)
     def setPrivateInfo(self, infoText):
         """
         Public method to set some info text for private chat mode.
         @param infoText info text to be shown (string)
         """
         if self.__private:
             self.topicLabel.setText(infoText)
     def handleMessage(self, line):
         """
         Public method to handle the message sent by the server.
         @param line server message (string)
         @return flag indicating, if the message was handled (boolean)
         """
         for patternRe, patternFunc in self.__patterns:
             match = patternRe.match(line)
             if match is not None and patternFunc(match):
                 return True
         return False
     def __message(self, match):
         """
         Private method to handle messages to the channel.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         # group(1)   sender user name
         # group(2)   sender user@host
         # group(3)   target nick
         # group(4)   message
         if match.group(3).lower() == self.__name.lower():
             senderName = match.group(1)
             itm = self.__findUser(senderName)
             if itm and itm.isIgnored():
                 # user should be ignored
                 return True
             if match.group(4).startswith("\x01"):
                 return self.__handleCtcp(match)
             self.addMessage(senderName, match.group(4))
             if self.__private and not self.topicLabel.text():
                 self.setPrivateInfo(
                     "{0} - {1}".format(match.group(1), match.group(2)))
             return True
         return False
     def addMessage(self, sender, msg):
         """
         Public method to add a message from external.
         @param sender nick name of the sender (string)
         @param msg message received from sender (string)
         """
         self.__appendMessage(
             '<font color="{0}">{2} <b>&lt;</b><font color="{1}">{3}</font>'
             '<b>&gt;</b> {4}</font>'.format(
                 Preferences.getIrc("ChannelMessageColour"),
                 Preferences.getIrc("NickColour"),
                 ircTimestamp(), sender, ircFilter(msg)))
         if Preferences.getIrc("ShowNotifications"):
             if Preferences.getIrc("NotifyMessage"):
                 self.__ui.showNotification(
                     UI.PixmapCache.getPixmap("irc48"),
                     self.tr("Channel Message"), msg)
             elif (
                 Preferences.getIrc("NotifyNick") and
                 self.__userName.lower() in msg.lower()
             ):
                 self.__ui.showNotification(
                     UI.PixmapCache.getPixmap("irc48"),
                     self.tr("Nick mentioned"), msg)
     def addUsers(self, users):
         """
         Public method to add users to the channel.
         @param users list of user names to add (list of string)
         """
         for user in users:
             itm = self.__findUser(user)
             if itm is None:
                 IrcUserItem(user, self.usersList)
     def __userJoin(self, match):
         """
         Private method to handle a user joining the channel.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(3).lower() == self.__name.lower():
             if self.__userName != match.group(1):
                 IrcUserItem(match.group(1), self.usersList)
                 msg = self.tr(
                     "{0} has joined the channel {1} ({2}).").format(
                     match.group(1), self.__name, match.group(2))
                 self.__addManagementMessage(
                     IrcChannelWidget.JoinIndicator, msg)
             else:
                 msg = self.tr(
                     "You have joined the channel {0} ({1}).").format(
                     self.__name, match.group(2))
                 self.__addManagementMessage(
                     IrcChannelWidget.JoinIndicator, msg)
             if (
                 Preferences.getIrc("ShowNotifications") and
                 Preferences.getIrc("NotifyJoinPart")
             ):
                 self.__ui.showNotification(
                     UI.PixmapCache.getPixmap("irc48"),
                     self.tr("Join Channel"), msg)
             return True
         return False
     def __userPart(self, match):
         """
         Private method to handle a user leaving the channel.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(2).lower() == self.__name.lower():
             itm = self.__findUser(match.group(1))
             self.usersList.takeItem(self.usersList.row(itm))
             del itm
             if match.lastindex == 2:
                 msg = self.tr("{0} has left {1}.").format(
                     match.group(1), self.__name)
                 nmsg = msg
                 self.__addManagementMessage(
                     IrcChannelWidget.LeaveIndicator, msg)
             else:
                 msg = self.tr("{0} has left {1}: {2}.").format(
                     match.group(1), self.__name, ircFilter(match.group(3)))
                 nmsg = self.tr("{0} has left {1}: {2}.").format(
                     match.group(1), self.__name, match.group(3))
                 self.__addManagementMessage(
                     IrcChannelWidget.LeaveIndicator, msg)
             if (
                 Preferences.getIrc("ShowNotifications") and
                 Preferences.getIrc("NotifyJoinPart")
             ):
                 self.__ui.showNotification(
                     UI.PixmapCache.getPixmap("irc48"),
                     self.tr("Leave Channel"), nmsg)
             return True
         return False
     def __userQuit(self, match):
         """
         Private method to handle a user logging off the server.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         itm = self.__findUser(match.group(1))
         if itm:
             self.usersList.takeItem(self.usersList.row(itm))
             del itm
             if match.lastindex == 1:
                 msg = self.tr("{0} has quit {1}.").format(
                     match.group(1), self.__name)
                 self.__addManagementMessage(
                     IrcChannelWidget.MessageIndicator, msg)
             else:
                 msg = self.tr("{0} has quit {1}: {2}.").format(
                     match.group(1), self.__name, ircFilter(match.group(2)))
                 self.__addManagementMessage(
                     IrcChannelWidget.MessageIndicator, msg)
             if (
                 Preferences.getIrc("ShowNotifications") and
                 Preferences.getIrc("NotifyJoinPart")
             ):
                 self.__ui.showNotification(
                     UI.PixmapCache.getPixmap("irc48"),
                     self.tr("Quit"), msg)
         # always return False for other channels and server to process
         return False
     def __userNickChange(self, match):
         """
         Private method to handle a nickname change of a user.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         itm = self.__findUser(match.group(1))
         if itm:
             itm.setName(match.group(2))
             if match.group(1) == self.__userName:
                 self.__addManagementMessage(
                     IrcChannelWidget.MessageIndicator,
                     self.tr("You are now known as {0}.").format(
                         match.group(2)))
                 self.__userName = match.group(2)
             else:
                 self.__addManagementMessage(
                     IrcChannelWidget.MessageIndicator,
                     self.tr("User {0} is now known as {1}.").format(
                         match.group(1), match.group(2)))
         # always return False for other channels and server to process
         return False
     def __userList(self, match):
         """
         Private method to handle the receipt of a list of users of the channel.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(1).lower() == self.__name.lower():
             users = match.group(2).split()
             for user in users:
                 userPrivileges, userName = self.__extractPrivilege(user)
                 itm = self.__findUser(userName)
                 if itm is None:
                     itm = IrcUserItem(userName, self.usersList)
                 for privilege in userPrivileges:
                     itm.changePrivilege(privilege)
             self.__setEditTopicButton()
             return True
         return False
     def __userAway(self, match):
         """
         Private method to handle a topic change of the channel.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(1).lower() == self.__name.lower():
             self.__addManagementMessage(
                 self.tr("Away"),
                 self.tr("{0} is away: {1}").format(
                     match.group(2), match.group(3)))
             return True
         return False
     def __setTopic(self, match):
         """
         Private method to handle a topic change of the channel.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(1).lower() == self.__name.lower():
             self.topicLabel.setText(match.group(2))
             self.__addManagementMessage(
                 IrcChannelWidget.MessageIndicator,
                 ircFilter(self.tr('The channel topic is: "{0}".').format(
                     match.group(2))))
             return True
         return False
     def __topicCreated(self, match):
         """
         Private method to handle a topic created message.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(1).lower() == self.__name.lower():
             self.__addManagementMessage(
                 IrcChannelWidget.MessageIndicator,
                 self.tr("The topic was set by {0} on {1}.").format(
                     match.group(2), QDateTime.fromTime_t(int(match.group(3)))
                     .toString("yyyy-MM-dd hh:mm")))
             return True
         return False
     def __channelUrl(self, match):
         """
         Private method to handle a channel URL message.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(1).lower() == self.__name.lower():
             self.__addManagementMessage(
                 IrcChannelWidget.MessageIndicator,
                 ircFilter(self.tr("Channel URL: {0}").format(
                     match.group(2))))
             return True
         return False
     def __channelModes(self, match):
         """
         Private method to handle a message reporting the channel modes.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(1).lower() == self.__name.lower():
             modesDict = getChannelModesDict()
             modesParameters = match.group(2).split()
             modeString = modesParameters.pop(0)
             modes = []
             for modeChar in modeString:
                 if modeChar == "+":
                     continue
                 elif modeChar == "k":
                     parameter = modesParameters.pop(0)
                     modes.append(self.tr(
                         "password protected ({0})").format(parameter))
                 elif modeChar == "l":
                     parameter = modesParameters.pop(0)
                     modes.append(self.tr(
                         "limited to %n user(s)", "", int(parameter)))
                 elif modeChar in modesDict:
                     modes.append(modesDict[modeChar])
                 else:
                     modes.append(modeChar)
             self.__addManagementMessage(
                 IrcChannelWidget.MessageIndicator,
                 self.tr("Channel modes: {0}.").format(", ".join(modes)))
             return True
         return False
     def __channelCreated(self, match):
         """
         Private method to handle a channel created message.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         if match.group(1).lower() == self.__name.lower():
             self.__addManagementMessage(
                 IrcChannelWidget.MessageIndicator,
                 self.tr("This channel was created on {0}.").format(
                     QDateTime.fromTime_t(int(match.group(2)))
                     .toString("yyyy-MM-dd hh:mm")))
             return True
         return False
     def __updateChannelModes(self, match):
         """
         Private method to handle a message reporting the channel modes.
         @param match match object that matched the pattern
         @return flag indicating whether the message was handled (boolean)
         """
         # group(1)  user or server
         # group(2)  channel
         # group(3)  modes and parameter list
         if match.group(2).lower() == self.__name.lower():
             nick = match.group(1)
             modesParameters = match.group(3).split()
             modeString = modesParameters.pop(0)
             isPlus = True
             message = ""
             for mode in modeString:
                 if mode == "+":
                     isPlus = True
                     continue
                 elif mode == "-":
                     isPlus = False
                     continue
                 elif mode == "a":
                     if isPlus:
                         message = self.tr(
                             "{0} sets the channel mode to 'anonymous'."
                         ).format(nick)
                     else:
                         message = self.tr(
                             "{0} removes the 'anonymous' mode from the"
                             " channel.").format(nick)
                 elif mode == "b":
                     if isPlus:
                         message = self.tr(
                             "{0} sets a ban on {1}.").format(
                             nick, modesParameters.pop(0))
                     else:
                         message = self.tr(
                             "{0} removes the ban on {1}.").format(
                             nick, modesParameters.pop(0))
                 elif mode == "c":
                     if isPlus:
                         message = self.tr(
                             "{0} sets the channel mode to 'no colors"
                             " allowed'.").format(nick)
                     else:
                         message = self.tr(
                             "{0} sets the channel mode to 'allow color"
                             " codes'.").format(nick)
                 elif mode == "e":
                     if isPlus:
                         message = self.tr(
                             "{0} sets a ban exception on {1}.").format(
                             nick, modesParameters.pop(0))
                     else:
                         message = self.tr(
                             "{0} removes the ban exception on {1}.").format(
                             nick, modesParameters.pop(0))
                 elif mode == "i":
                     if isPlus:
                         message = self.tr(
                             "{0} sets the channel mode to 'invite only'."
                         ).format(nick)
                     else:
                         message = self.tr(
                             "{0} removes the 'invite only' mode from the"
                             " channel.").format(nick)
                 elif mode == "k":
                     if isPlus:
                         message = self.tr(
                             "{0} sets the channel key to '{1}'.").format(
                             nick, modesParameters.pop(0))
 ba2af1ff7

Mercurial Repositories > eric / annotate

eric7/Network/IRC/IrcChannelWidget.py@68ec9c3d4de5 (annotated)

eric7/Network/IRC/IrcChannelWidget.py