eric: comparison Network/IRC/IrcWidget.py

-:226481ff40d1
+:dbdf27746da5
 from .IrcNetworkManager import IrcNetworkManager
 self.__ircNetworkManager = IrcNetworkManager(self)
 self.__leaveButton = QToolButton(self)
-self.__leaveButton.setIcon(UI.PixmapCache.getIcon("ircCloseChannel.png"))
+self.__leaveButton.setIcon(
-self.__leaveButton.setToolTip(self.trUtf8("Press to leave the current channel"))
+UI.PixmapCache.getIcon("ircCloseChannel.png"))
+self.__leaveButton.setToolTip(
+self.trUtf8("Press to leave the current channel"))
 self.__leaveButton.clicked[()].connect(self.__leaveChannel)
 self.__leaveButton.setEnabled(False)
-self.channelsWidget.setCornerWidget(self.__leaveButton, Qt.BottomRightCorner)
+self.channelsWidget.setCornerWidget(
+self.__leaveButton, Qt.BottomRightCorner)
 self.channelsWidget.setTabsClosable(False)
 if not isMacPlatform():
 self.channelsWidget.setTabPosition(QTabWidget.South)
 height = self.height()
 else:
 self.__sslErrorHandler = None
 self.__patterns = [
 # :foo_!n=foo@foohost.bar.net PRIVMSG bar_ :some long message
-(re.compile(r":([^!]+)!([^ ]+)\sPRIVMSG\s([^ ]+)\s:(.*)"), self.__query),
+(re.compile(r":([^!]+)!([^ ]+)\sPRIVMSG\s([^ ]+)\s:(.*)"),
+self.__query),
 # :foo.bar.net COMMAND some message
-(re.compile(r""":([^ ]+)\s+([A-Z]+)\s+(.+)"""), self.__handleNamedMessage),
+(re.compile(r""":([^ ]+)\s+([A-Z]+)\s+(.+)"""),
+self.__handleNamedMessage),
 # :foo.bar.net 123 * :info
-(re.compile(r""":([^ ]+)\s+(\d{3})\s+(.+)"""), self.__handleNumericMessage),
+(re.compile(r""":([^ ]+)\s+(\d{3})\s+(.+)"""),
+self.__handleNumericMessage),
 # PING :ping message
 (re.compile(r"""PING\s+:(.*)"""), self.__ping),
 ]
 self.__prefixRe = re.compile(r""".*\sPREFIX=\((.*)\)([^ ]+).*""")
 self.__chanTypesRe = re.compile(r""".*\sCHANTYPES=([^ ]+).*""")
 """
 if self.__server:
 if Preferences.getIrc("AskOnShutdown"):
 ok = E5MessageBox.yesNo(self,
 self.trUtf8("Disconnect from Server"),
-self.trUtf8("""<p>Do you really want to disconnect from"""
+self.trUtf8(
-""" <b>{0}</b>?</p><p>All channels will be closed."""
+"""<p>Do you really want to disconnect from"""
-"""</p>""").format(self.__server.getName()))
+""" <b>{0}</b>?</p><p>All channels will be closed."""
+"""</p>""").format(self.__server.getName()))
 else:
 ok = True
 if ok:
 self.__socket.blockSignals(True)
 if connect:
 network = self.__ircNetworkManager.getNetwork(name)
 if network:
 self.__server = network.getServer()
 self.__identityName = network.getIdentityName()
-identity = self.__ircNetworkManager.getIdentity(self.__identityName)
+identity = self.__ircNetworkManager.getIdentity(
+self.__identityName)
 self.__userName = identity.getIdent()
 self.__quitMessage = identity.getQuitMessage()
 if self.__server:
 useSSL = self.__server.useSSL()
 if useSSL and not SSL_AVAILABLE:
 E5MessageBox.critical(self,
 self.trUtf8("SSL Connection"),
-self.trUtf8("""An encrypted connection to the IRC network"""
+self.trUtf8(
-""" was requested but SSL is not available."""
+"""An encrypted connection to the IRC"""
-""" Please change the server configuration."""))
+""" network was requested but SSL is not"""
+""" available. Please change the server"""
+""" configuration."""))
 return
 if useSSL:
 # create SSL socket
 self.__socket = QSslSocket(self)
 self.__socket.readyRead.connect(self.__readyRead)
 self.__socket.error.connect(self.__tcpError)
 self.__connectionState = IrcWidget.ServerConnecting
 if useSSL:
-self.networkWidget.addServerMessage(self.trUtf8("Info"),
+self.networkWidget.addServerMessage(
-self.trUtf8("Looking for server {0} (port {1}) using"
+self.trUtf8("Info"),
-" an SSL encrypted connection...").format(
+self.trUtf8("Looking for server {0} (port {1})"
-self.__server.getName(), self.__server.getPort()))
+" using an SSL encrypted connection"
-self.__socket.connectToHostEncrypted(self.__server.getName(),
+"...").format(self.__server.getName(),
-self.__server.getPort())
+self.__server.getPort()))
+self.__socket.connectToHostEncrypted(
+self.__server.getName(), self.__server.getPort())
 else:
-self.networkWidget.addServerMessage(self.trUtf8("Info"),
+self.networkWidget.addServerMessage(
-self.trUtf8("Looking for server {0} (port {1})...").format(
+self.trUtf8("Info"),
-self.__server.getName(), self.__server.getPort()))
+self.trUtf8(
+"Looking for server {0} (port {1})...").format(
+self.__server.getName(),
+self.__server.getPort()))
 self.__socket.connectToHost(self.__server.getName(),
 self.__server.getPort())
 else:
 if silent:
 ok = True
 self.__openPrivate(match.group(1))
 # the above call sets the new channel as the current widget
 channel = self.channelsWidget.currentWidget()
 channel.addMessage(match.group(1), match.group(4))
-channel.setPrivateInfo("{0} - {1}".format(match.group(1), match.group(2)))
+channel.setPrivateInfo(
+"{0} - {1}".format(match.group(1), match.group(2)))
 return True
 @pyqtSlot(str)
 def __openPrivate(self, name):
 @param name name of the closed channel (string)
 """
 for channel in self.__channelList:
 if channel.name() == name:
-self.channelsWidget.removeTab(self.channelsWidget.indexOf(channel))
+self.channelsWidget.removeTab(
+self.channelsWidget.indexOf(channel))
 self.__channelList.remove(channel)
 channel.deleteLater()
 if self.channelsWidget.count() == 0:
 self.channelsWidget.addTab(self.__emptyLabel, "")
 Private slot to send data to the IRC server.
 @param data data to be sent (string)
 """
 if self.__socket:
-self.__socket.write(QByteArray("{0}\r\n".format(data).encode("utf-8")))
+self.__socket.write(
+QByteArray("{0}\r\n".format(data).encode("utf-8")))
 def __sendCtcpReply(self, receiver, text):
 """
 Private slot to send a CTCP reply.
 self.networkWidget.addServerMessage(self.trUtf8("Info"),
 self.trUtf8("Server found,connecting..."))
 def __hostConnected(self):
 """
-Private slot to log in to the server after the connection was established.
+Private slot to log in to the server after the connection was
+established.
 """
 self.networkWidget.addServerMessage(self.trUtf8("Info"),
 self.trUtf8("Connected,logging in..."))
 self.networkWidget.setConnected(True)
 self.__send("PASS " + serverPassword)
 nick = self.networkWidget.getNickname()
 if not nick:
 self.__nickIndex = 0
 try:
-nick = self.__ircNetworkManager.getIdentity(self.__identityName)\
+nick = self.__ircNetworkManager.getIdentity(
-.getNickNames()[self.__nickIndex]
+self.__identityName).getNickNames()[self.__nickIndex]
 except IndexError:
 nick = ""
 if not nick:
 nick = self.__userName
 self.__nickName = nick
 self.networkWidget.setNickName(nick)
-realName = self.__ircNetworkManager.getIdentity(self.__identityName).getRealName()
+realName = self.__ircNetworkManager.getIdentity(
+self.__identityName).getRealName()
 if not realName:
 realName = "eric IDE chat"
 self.__send("NICK " + nick)
 self.__send("USER " + self.__userName + " 0 * :" + realName)
 break
 else:
 # Oops, the message wasn't handled
 self.networkWidget.addErrorMessage(
 self.trUtf8("Message Error"),
-self.trUtf8("Unknown message received from server:"
+self.trUtf8(
-"<br/>{0}").format(line))
+"Unknown message received from server:"
+"<br/>{0}").format(line))
 self.__updateUsersCount()
 self.__buffer = ""
 def __handleNamedMessage(self, match):
 sourceNick = match.group(1)
 if not self.isChannelName(name):
 if name == self.__nickName:
 if sourceNick == self.__nickName:
 msg = self.trUtf8(
-"You have set your personal modes to <b>[{0}]</b>.")\
+"You have set your personal modes to"
-.format(modes)
+" <b>[{0}]</b>.").format(modes)
 else:
 msg = self.trUtf8(
-"{0} has changed your personal modes to <b>[{1}]</b>.")\
+"{0} has changed your personal modes to"
-.format(sourceNick, modes)
+" <b>[{1}]</b>.").format(sourceNick, modes)
 self.networkWidget.addServerMessage(
 self.trUtf8("Mode"), msg, filterMsg=False)
 return True
 elif name == "PART":
 nick = match.group(1).split("!", 1)[0]
 @param match reference to the match object
 @return flag indicating, if the message was handled (boolean)
 """
 code = int(match.group(2))
 if code < 400:
-return self.__handleServerReply(code, match.group(1), match.group(3))
+return self.__handleServerReply(
+code, match.group(1), match.group(3))
 else:
-return self.__handleServerError(code, match.group(1), match.group(3))
+return self.__handleServerError(
+code, match.group(1), match.group(3))
 def __handleServerError(self, code, server, message):
 """
 Private slot to handle a server error reply.
 elif code == 376:
 message = self.trUtf8("End of message of the day")
 elif code == 4:
 parts = message.strip().split()
 message = self.trUtf8("Server {0} (Version {1}), User-Modes: {2},"
-" Channel-Modes: {3}").format(parts[1], parts[2], parts[3], parts[4])
+" Channel-Modes: {3}").format(
+parts[1], parts[2], parts[3], parts[4])
 elif code == 265:
 parts = message.strip().split()
-message = self.trUtf8("Current users on {0}: {1}, max. {2}").format(
+message = self.trUtf8(
-server, parts[1], parts[2])
+"Current users on {0}: {1}, max. {2}").format(
+server, parts[1], parts[2])
 elif code == 266:
 parts = message.strip().split()
-message = self.trUtf8("Current users on the network: {0}, max. {1}").format(
+message = self.trUtf8(
-parts[1], parts[2])
+"Current users on the network: {0}, max. {1}").format(
+parts[1], parts[2])
 elif code == 305:
 message = self.trUtf8("You are no longer marked as being away.")
 elif code == 306:
 message = self.trUtf8("You have been marked as being away.")
 else:
 if service and password:
 self.__send("PRIVMSG " + service + " :identify " + password)
 def __autoJoinChannels(self):
 """
-Private slot to join channels automatically once a server got connected.
+Private slot to join channels automatically once a server got
+connected.
 """
 for channel in self.networkWidget.getNetworkChannels():
 if channel.autoJoin():
 name = channel.getName()
 key = channel.getKey()
 """
 if error == QAbstractSocket.RemoteHostClosedError:
 # ignore this one, it's a disconnect
 if self.__sslErrorLock:
 self.networkWidget.addErrorMessage(self.trUtf8("SSL Error"),
-self.trUtf8("""Connection to server {0} (port {1}) lost while"""
+self.trUtf8(
-""" waiting for user response to an SSL error.""").format(
+"""Connection to server {0} (port {1}) lost while"""
-self.__server.getName(), self.__server.getPort()))
+""" waiting for user response to an SSL error.""")
+.format(self.__server.getName(), self.__server.getPort()))
 self.__connectionState = IrcWidget.ServerDisconnected
 elif error == QAbstractSocket.HostNotFoundError:
 self.networkWidget.addErrorMessage(self.trUtf8("Socket Error"),
-self.trUtf8("The host was not found. Please check the host name"
+self.trUtf8(
-" and port settings."))
+"The host was not found. Please check the host name"
+" and port settings."))
 elif error == QAbstractSocket.ConnectionRefusedError:
 self.networkWidget.addErrorMessage(self.trUtf8("Socket Error"),
-self.trUtf8("The connection was refused by the peer. Please check the"
+self.trUtf8(
-" host name and port settings."))
+"The connection was refused by the peer. Please check the"
+" host name and port settings."))
 elif error == QAbstractSocket.SslHandshakeFailedError:
 self.networkWidget.addErrorMessage(self.trUtf8("Socket Error"),
 self.trUtf8("The SSL handshake failed."))
 else:
 if self.__socket:
 self.networkWidget.addErrorMessage(self.trUtf8("Socket Error"),
-self.trUtf8("The following network error occurred:<br/>{0}").format(
+self.trUtf8(
-self.__socket.errorString()))
+"The following network error occurred:<br/>{0}")
+.format(self.__socket.errorString()))
 else:
 self.networkWidget.addErrorMessage(self.trUtf8("Socket Error"),
 self.trUtf8("A network error occurred."))
 def __sslErrors(self, errors):
 """
 ignored, defaultChanged = self.__sslErrorHandler.sslErrors(
 errors, self.__server.getName(), self.__server.getPort())
 if ignored == E5SslErrorHandler.NotIgnored:
 self.networkWidget.addErrorMessage(self.trUtf8("SSL Error"),
-self.trUtf8("""Could not connect to {0} (port {1}) using an SSL"""
+self.trUtf8(
-""" encrypted connection. Either the server does not"""
+"""Could not connect to {0} (port {1}) using an SSL"""
-""" support SSL (did you use the correct port?) or"""
+""" encrypted connection. Either the server does not"""
-""" you rejected the certificate.""").format(
+""" support SSL (did you use the correct port?) or"""
+""" you rejected the certificate.""").format(
 self.__server.getName(), self.__server.getPort()))
 self.__socket.close()
 else:
 if defaultChanged:
 self.__socket.setSslConfiguration(
 QSslConfiguration.defaultConfiguration())
 if ignored == E5SslErrorHandler.UserIgnored:
 self.networkWidget.addErrorMessage(self.trUtf8("SSL Error"),
-self.trUtf8("""The SSL certificate for the server {0} (port {1})"""
+self.trUtf8(
-""" failed the authenticity check. SSL errors"""
+"""The SSL certificate for the server {0} (port {1})"""
-""" were accepted by you.""").format(
+""" failed the authenticity check. SSL errors"""
+""" were accepted by you.""").format(
 self.__server.getName(), self.__server.getPort()))
 if self.__connectionState == IrcWidget.ServerConnecting:
 self.__socket.ignoreSslErrors()
 def __setUserPrivilegePrefix(self, prefix1, prefix2):
 self.__sendCtcpReply(match.group(1), "VERSION " + msg)
 elif ctcpRequest == "ping":
 self.networkWidget.addServerMessage(self.trUtf8("CTCP"),
 self.trUtf8("Received CTCP-PING request from {0},"
 " sending answer.").format(match.group(1)))
-self.__sendCtcpReply(match.group(1), "PING {0}".format(ctcpArg))
+self.__sendCtcpReply(
+match.group(1), "PING {0}".format(ctcpArg))
 elif ctcpRequest == "clientinfo":
 self.networkWidget.addServerMessage(self.trUtf8("CTCP"),
 self.trUtf8("Received CTCP-CLIENTINFO request from {0},"
 " sending answer.").format(match.group(1)))
 self.__sendCtcpReply(match.group(1),
 "CLIENTINFO CLIENTINFO PING VERSION")
 else:
 self.networkWidget.addServerMessage(self.trUtf8("CTCP"),
-self.trUtf8("Received unknown CTCP-{0} request from {1}.").format(
+self.trUtf8(
+"Received unknown CTCP-{0} request from {1}.").format(
 ctcpRequest, match.group(1)))
 return True
 return False
 try:
 nick = self.__ircNetworkManager.getIdentity(self.__identityName)\
 .getNickNames()[self.__nickIndex]
 self.__nickName = nick
 except IndexError:
-self.networkWidget.addServerMessage(self.trUtf8("Critical"),
+self.networkWidget.addServerMessage(
-self.trUtf8("No nickname acceptable to the server configured"
+self.trUtf8("Critical"),
-" for <b>{0}</b>. Disconnecting...").format(self.__userName),
+self.trUtf8(
-filterMsg=False)
+"No nickname acceptable to the server configured"
+" for <b>{0}</b>. Disconnecting...").format(
+self.__userName),
+filterMsg=False)
 self.__connectNetwork("", False, silent=True)
 self.__nickName = ""
 self.__nickIndex = -1
 return
 Private slot handling the change of the away state.
 @param isAway flag indicating the current away state (boolean)
 """
 if isAway and self.__identityName:
-identity = self.__ircNetworkManager.getIdentity(self.__identityName)
+identity = self.__ircNetworkManager.getIdentity(
+self.__identityName)
 if identity.rememberAwayPosition():
 for channel in self.__channelList:
 channel.setMarkerLine()

Mercurial Repositories > eric / file comparison

comparison: Network/IRC/IrcWidget.py

Network/IRC/IrcWidget.py