--- a/src/eric7/Network/IRC/IrcWidget.py Wed Jul 13 11:16:20 2022 +0200
+++ b/src/eric7/Network/IRC/IrcWidget.py Wed Jul 13 14:55:47 2022 +0200
@@ -10,16 +10,14 @@
import re
import logging
-from PyQt6.QtCore import (
- pyqtSlot, pyqtSignal, Qt, QByteArray, QTimer, QDateTime
-)
+from PyQt6.QtCore import pyqtSlot, pyqtSignal, Qt, QByteArray, QTimer, QDateTime
from PyQt6.QtWidgets import QWidget, QToolButton, QLabel, QTabWidget
from PyQt6.QtNetwork import QTcpSocket, QAbstractSocket
+
try:
from PyQt6.QtNetwork import QSslSocket, QSslConfiguration
- from EricNetwork.EricSslErrorHandler import (
- EricSslErrorHandler, EricSslErrorState
- )
+ from EricNetwork.EricSslErrorHandler import EricSslErrorHandler, EricSslErrorState
+
SSL_AVAILABLE = True
except ImportError:
SSL_AVAILABLE = False
@@ -39,43 +37,44 @@
class IrcWidget(QWidget, Ui_IrcWidget):
"""
Class implementing the IRC window.
-
+
@signal autoConnected() emitted after an automatic connection was initiated
"""
+
autoConnected = pyqtSignal()
-
+
ServerDisconnected = 1
ServerConnected = 2
ServerConnecting = 3
-
+
def __init__(self, parent=None):
"""
Constructor
-
+
@param parent reference to the parent widget (QWidget)
"""
super().__init__(parent)
self.setupUi(self)
-
+
from .IrcNetworkManager import IrcNetworkManager
+
self.__ircNetworkManager = IrcNetworkManager(self)
-
+
self.__leaveButton = QToolButton(self)
- self.__leaveButton.setIcon(
- UI.PixmapCache.getIcon("ircCloseChannel"))
- self.__leaveButton.setToolTip(
- self.tr("Press to leave the current channel"))
+ self.__leaveButton.setIcon(UI.PixmapCache.getIcon("ircCloseChannel"))
+ self.__leaveButton.setToolTip(self.tr("Press to leave the current channel"))
self.__leaveButton.clicked.connect(self.__leaveChannel)
self.__leaveButton.setEnabled(False)
self.channelsWidget.setCornerWidget(
- self.__leaveButton, Qt.Corner.BottomRightCorner)
+ self.__leaveButton, Qt.Corner.BottomRightCorner
+ )
self.channelsWidget.setTabsClosable(False)
if not isMacPlatform():
self.channelsWidget.setTabPosition(QTabWidget.TabPosition.South)
-
+
height = self.height()
self.splitter.setSizes([int(height * 0.6), int(height * 0.4)])
-
+
self.__channelList = []
self.__channelTypePrefixes = ""
self.__userName = ""
@@ -85,42 +84,40 @@
self.__nickName = ""
self.__server = None
self.__registering = False
-
+
self.__connectionState = IrcWidget.ServerDisconnected
self.__sslErrorLock = False
-
+
self.__buffer = ""
self.__userPrefix = {}
-
+
self.__socket = None
if SSL_AVAILABLE:
self.__sslErrorHandler = EricSslErrorHandler(self)
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=([^ ]+).*""")
-
+
ircPic = UI.PixmapCache.getPixmap("irc128")
self.__emptyLabel = QLabel()
self.__emptyLabel.setPixmap(ircPic)
self.__emptyLabel.setAlignment(
- Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignHCenter)
+ Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignHCenter
+ )
self.channelsWidget.addTab(self.__emptyLabel, "")
-
+
# all initialized, do connections now
self.__ircNetworkManager.dataChanged.connect(self.__networkDataChanged)
self.networkWidget.initialize(self.__ircNetworkManager)
@@ -131,11 +128,11 @@
self.networkWidget.sendData.connect(self.__send)
self.networkWidget.away.connect(self.__away)
self.networkWidget.autoConnected.connect(self.autoConnected)
-
+
def shutdown(self):
"""
Public method to shut down the widget.
-
+
@return flag indicating successful shutdown (boolean)
"""
if self.__server:
@@ -146,19 +143,21 @@
self.tr(
"""<p>Do you really want to disconnect from"""
""" <b>{0}</b>?</p><p>All channels will be closed."""
- """</p>""").format(self.__server.getName()))
+ """</p>"""
+ ).format(self.__server.getName()),
+ )
else:
ok = True
if ok:
self.__connectNetwork("", False, True)
else:
ok = True
-
+
if ok:
self.__ircNetworkManager.close()
-
+
return ok
-
+
def autoConnect(self):
"""
Public method to initiate the IRC auto connection.
@@ -168,7 +167,7 @@
def __connectNetwork(self, name, connect, silent):
"""
Private slot to connect to or disconnect from the given network.
-
+
@param name name of the network to connect to (string)
@param connect flag indicating to connect (boolean)
@param silent flag indicating a silent connect/disconnect (boolean)
@@ -178,8 +177,7 @@
if network:
self.__server = network.getServer()
self.__identityName = network.getIdentityName()
- identity = self.__ircNetworkManager.getIdentity(
- self.__identityName)
+ identity = self.__ircNetworkManager.getIdentity(self.__identityName)
if identity:
self.__userName = identity.getIdent()
self.__quitMessage = identity.getQuitMessage()
@@ -193,53 +191,50 @@
"""An encrypted connection to the IRC"""
""" network was requested but SSL is not"""
""" available. Please change the server"""
- """ configuration."""))
+ """ configuration."""
+ ),
+ )
return
-
+
if useSSL:
# create SSL socket
self.__socket = QSslSocket(self)
- self.__socket.encrypted.connect(
- self.__hostConnected)
- self.__socket.sslErrors.connect(
- self.__sslErrors)
+ self.__socket.encrypted.connect(self.__hostConnected)
+ self.__socket.sslErrors.connect(self.__sslErrors)
else:
# create TCP socket
self.__socket = QTcpSocket(self)
- self.__socket.connected.connect(
- self.__hostConnected)
- self.__socket.hostFound.connect(
- self.__hostFound)
- self.__socket.disconnected.connect(
- self.__hostDisconnected)
- self.__socket.readyRead.connect(
- self.__readyRead)
- self.__socket.errorOccurred.connect(
- self.__tcpError)
-
+ self.__socket.connected.connect(self.__hostConnected)
+ self.__socket.hostFound.connect(self.__hostFound)
+ self.__socket.disconnected.connect(self.__hostDisconnected)
+ self.__socket.readyRead.connect(self.__readyRead)
+ self.__socket.errorOccurred.connect(self.__tcpError)
+
self.__connectionState = IrcWidget.ServerConnecting
if useSSL:
self.networkWidget.addServerMessage(
self.tr("Info"),
- self.tr("Looking for server {0} (port {1})"
- " using an SSL encrypted connection"
- "...").format(self.__server.getName(),
- self.__server.getPort()))
+ self.tr(
+ "Looking for server {0} (port {1})"
+ " using an SSL encrypted connection"
+ "..."
+ ).format(
+ self.__server.getName(), self.__server.getPort()
+ ),
+ )
self.__socket.connectToHostEncrypted(
- self.__server.getName(),
- self.__server.getPort()
+ self.__server.getName(), self.__server.getPort()
)
else:
self.networkWidget.addServerMessage(
self.tr("Info"),
- self.tr(
- "Looking for server {0} (port {1})...")
- .format(
- self.__server.getName(),
- self.__server.getPort()))
+ self.tr("Looking for server {0} (port {1})...").format(
+ self.__server.getName(), self.__server.getPort()
+ ),
+ )
self.__socket.connectToHost(
- self.__server.getName(),
- self.__server.getPort())
+ self.__server.getName(), self.__server.getPort()
+ )
else:
if silent:
ok = True
@@ -247,25 +242,29 @@
ok = EricMessageBox.yesNo(
self,
self.tr("Disconnect from Server"),
- self.tr("""<p>Do you really want to disconnect from"""
- """ <b>{0}</b>?</p><p>All channels will be"""
- """ closed.</p>""")
- .format(self.__server.getName()))
+ self.tr(
+ """<p>Do you really want to disconnect from"""
+ """ <b>{0}</b>?</p><p>All channels will be"""
+ """ closed.</p>"""
+ ).format(self.__server.getName()),
+ )
if ok:
if self.__server is not None:
self.networkWidget.addServerMessage(
self.tr("Info"),
self.tr("Disconnecting from server {0}...").format(
- self.__server.getName()))
+ self.__server.getName()
+ ),
+ )
elif name:
self.networkWidget.addServerMessage(
self.tr("Info"),
- self.tr("Disconnecting from network {0}...").format(
- name))
+ self.tr("Disconnecting from network {0}...").format(name),
+ )
else:
self.networkWidget.addServerMessage(
- self.tr("Info"),
- self.tr("Disconnecting from server."))
+ self.tr("Info"), self.tr("Disconnecting from server.")
+ )
self.__closeAllChannels()
self.__send("QUIT :" + self.__quitMessage)
if self.__socket:
@@ -278,17 +277,18 @@
self.__userName = ""
self.__identityName = ""
self.__quitMessage = ""
-
+
def __editNetwork(self, name):
"""
Private slot to edit the network configuration.
-
+
@param name name of the network to edit (string)
"""
from .IrcNetworkListDialog import IrcNetworkListDialog
+
dlg = IrcNetworkListDialog(self.__ircNetworkManager, self)
dlg.exec()
-
+
def __networkDataChanged(self):
"""
Private slot handling changes of the network and identity definitions.
@@ -298,11 +298,11 @@
partMsg = identity.getPartMessage()
for channel in self.__channelList:
channel.setPartMessage(partMsg)
-
+
def joinChannel(self, name, key=""):
"""
Public slot to join a channel.
-
+
@param name name of the channel (string)
@param key key of the channel (string)
"""
@@ -310,8 +310,9 @@
for channel in self.__channelList:
if channel.name() == name:
return
-
+
from .IrcChannelWidget import IrcChannelWidget
+
channel = IrcChannelWidget(self)
channel.setName(name)
channel.setUserName(self.__nickName)
@@ -320,7 +321,7 @@
channel.setPartMessage(identity.getPartMessage())
channel.setUserPrivilegePrefix(self.__userPrefix)
channel.initAutoWho()
-
+
channel.sendData.connect(self.__send)
channel.sendCtcpRequest.connect(self.__sendCtcpRequest)
channel.sendCtcpReply.connect(self.__sendCtcpReply)
@@ -329,27 +330,27 @@
channel.awayCommand.connect(self.networkWidget.handleAwayCommand)
channel.leaveChannels.connect(self.__leaveChannels)
channel.leaveAllChannels.connect(self.__leaveAllChannels)
-
+
self.channelsWidget.addTab(channel, name)
self.__channelList.append(channel)
self.channelsWidget.setCurrentWidget(channel)
-
+
joinCommand = ["JOIN", name]
if key:
joinCommand.append(key)
self.__send(" ".join(joinCommand))
self.__send("MODE " + name)
-
+
emptyIndex = self.channelsWidget.indexOf(self.__emptyLabel)
if emptyIndex > -1:
self.channelsWidget.removeTab(emptyIndex)
self.__leaveButton.setEnabled(True)
self.channelsWidget.setTabsClosable(True)
-
+
def __query(self, match):
"""
Private method to handle a new private connection.
-
+
@param match reference to the match object
@return flag indicating, if the message was handled (boolean)
"""
@@ -359,24 +360,24 @@
# group(4) message
if match.group(4).startswith("\x01"):
return self.__handleCtcp(match)
-
+
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):
"""
Private slot to open a private chat with the given user.
-
+
@param name name of the user (string)
"""
from .IrcChannelWidget import IrcChannelWidget
+
channel = IrcChannelWidget(self)
channel.setName(self.__nickName)
channel.setUserName(self.__nickName)
@@ -386,7 +387,7 @@
channel.setUserPrivilegePrefix(self.__userPrefix)
channel.setPrivate(True, name)
channel.addUsers([name, self.__nickName])
-
+
channel.sendData.connect(self.__send)
channel.sendCtcpRequest.connect(self.__sendCtcpRequest)
channel.sendCtcpReply.connect(self.__sendCtcpReply)
@@ -394,11 +395,11 @@
channel.awayCommand.connect(self.networkWidget.handleAwayCommand)
channel.leaveChannels.connect(self.__leaveChannels)
channel.leaveAllChannels.connect(self.__leaveAllChannels)
-
+
self.channelsWidget.addTab(channel, name)
self.__channelList.append(channel)
self.channelsWidget.setCurrentWidget(channel)
-
+
@pyqtSlot()
def __leaveChannel(self):
"""
@@ -406,13 +407,13 @@
"""
channel = self.channelsWidget.currentWidget()
channel.requestLeave()
-
+
@pyqtSlot(list)
def __leaveChannels(self, channelNames):
"""
Private slot to leave a list of channels and close their associated
tabs.
-
+
@param channelNames list of channels to leave
@type list of str
"""
@@ -420,7 +421,7 @@
for channel in self.__channelList:
if channel.name() == channelName:
channel.leaveChannel()
-
+
@pyqtSlot()
def __leaveAllChannels(self):
"""
@@ -429,7 +430,7 @@
while self.__channelList:
channel = self.__channelList[0]
channel.leaveChannel()
-
+
def __closeAllChannels(self):
"""
Private method to close all channels.
@@ -439,56 +440,54 @@
self.channelsWidget.removeTab(self.channelsWidget.indexOf(channel))
channel.deleteLater()
channel = None
-
+
self.channelsWidget.addTab(self.__emptyLabel, "")
self.__emptyLabel.show()
self.__leaveButton.setEnabled(False)
self.channelsWidget.setTabsClosable(False)
-
+
def __closeChannel(self, name):
"""
Private slot handling the closing of a channel.
-
+
@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, "")
self.__emptyLabel.show()
self.__leaveButton.setEnabled(False)
self.channelsWidget.setTabsClosable(False)
-
+
@pyqtSlot(int)
def on_channelsWidget_tabCloseRequested(self, index):
"""
Private slot to close a channel by pressing the close button of
the channels widget.
-
+
@param index index of the tab to be closed (integer)
"""
channel = self.channelsWidget.widget(index)
channel.requestLeave()
-
+
def __send(self, data):
"""
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 __sendCtcpRequest(self, receiver, request, arguments):
"""
Private slot to send a CTCP request.
-
+
@param receiver nick name of the receiver
@type str
@param request CTCP request to be sent
@@ -498,48 +497,45 @@
"""
request = request.upper()
if request == "PING":
- arguments = "Eric IRC {0}".format(
- QDateTime.currentMSecsSinceEpoch())
-
- self.__send("PRIVMSG {0} :\x01{1} {2}\x01".format(
- receiver, request, arguments))
-
+ arguments = "Eric IRC {0}".format(QDateTime.currentMSecsSinceEpoch())
+
+ self.__send("PRIVMSG {0} :\x01{1} {2}\x01".format(receiver, request, arguments))
+
def __sendCtcpReply(self, receiver, text):
"""
Private slot to send a CTCP reply.
-
+
@param receiver nick name of the receiver
@type str
@param text text to be sent
@type str
"""
self.__send("NOTICE {0} :\x01{1}\x01".format(receiver, text))
-
+
def __hostFound(self):
"""
Private slot to indicate the host was found.
"""
self.networkWidget.addServerMessage(
- self.tr("Info"),
- self.tr("Server found,connecting..."))
-
+ self.tr("Info"), self.tr("Server found,connecting...")
+ )
+
def __hostConnected(self):
"""
Private slot to log in to the server after the connection was
established.
"""
self.networkWidget.addServerMessage(
- self.tr("Info"),
- self.tr("Connected,logging in..."))
+ self.tr("Info"), self.tr("Connected,logging in...")
+ )
self.networkWidget.setConnected(True)
-
+
self.__registering = True
serverPassword = self.__server.getPassword()
if serverPassword:
self.__send("PASS " + serverPassword)
-
- identity = self.__ircNetworkManager.getIdentity(
- self.__identityName)
+
+ identity = self.__ircNetworkManager.getIdentity(self.__identityName)
nick = self.networkWidget.getNickname()
if not nick and identity:
self.__nickIndex = 0
@@ -557,7 +553,7 @@
realName = "eric IDE chat"
self.__send("NICK " + nick)
self.__send("USER " + self.__userName + " 0 * :" + realName)
-
+
def __hostDisconnected(self):
"""
Private slot to indicate the host was disconnected.
@@ -565,31 +561,30 @@
if self.networkWidget.isConnected():
self.__closeAllChannels()
self.networkWidget.addServerMessage(
- self.tr("Info"),
- self.tr("Server disconnected."))
+ self.tr("Info"), self.tr("Server disconnected.")
+ )
self.networkWidget.setRegistered(False)
self.networkWidget.setConnected(False)
self.__server = None
self.__nickName = ""
self.__nickIndex = -1
self.__channelTypePrefixes = ""
-
+
if self.__socket:
self.__socket.deleteLater()
self.__socket = None
-
+
self.__connectionState = IrcWidget.ServerDisconnected
self.__sslErrorLock = False
-
+
def __readyRead(self):
"""
Private slot to read data from the socket.
"""
if self.__socket:
self.__buffer += str(
- self.__socket.readAll(),
- Preferences.getSystem("IOEncoding"),
- 'replace')
+ self.__socket.readAll(), Preferences.getSystem("IOEncoding"), "replace"
+ )
if self.__buffer.endswith("\r\n"):
for line in self.__buffer.splitlines():
line = line.strip()
@@ -613,20 +608,22 @@
self.tr("Message Error"),
self.tr(
"Unknown message received from server:"
- "<br/>{0}").format(line))
-
+ "<br/>{0}"
+ ).format(line),
+ )
+
self.__updateUsersCount()
self.__buffer = ""
-
+
def __handleCtcpReply(self, match):
"""
Private method to handle a server message containing a CTCP reply.
-
+
@param match reference to the match object
"""
if "!" in match.group(1):
sender = match.group(1).split("!", 1)[0]
-
+
try:
ctcpCommand = match.group(3).split(":", 1)[1]
except IndexError:
@@ -637,7 +634,7 @@
else:
ctcpReply, ctcpArg = ctcpCommand, ""
ctcpReply = ctcpReply.upper()
-
+
if ctcpReply == "PING" and ctcpArg.startswith("Eric IRC "):
# it is a response to a ping request
pingDateTime = int(ctcpArg.split()[-1])
@@ -646,18 +643,21 @@
self.tr("CTCP"),
self.tr(
"Received CTCP-PING response from {0} with latency"
- " of {1} ms.").format(sender, latency))
+ " of {1} ms."
+ ).format(sender, latency),
+ )
else:
self.networkWidget.addServerMessage(
self.tr("CTCP"),
- self.tr(
- "Received unknown CTCP-{0} response from {1}.")
- .format(ctcpReply, sender))
-
+ self.tr("Received unknown CTCP-{0} response from {1}.").format(
+ ctcpReply, sender
+ ),
+ )
+
def __handleNamedMessage(self, match):
"""
Private method to handle a server message containing a message name.
-
+
@param match reference to the match object
@return flag indicating, if the message was handled (boolean)
"""
@@ -667,11 +667,11 @@
msg = match.group(3).split(":", 1)[1]
except IndexError:
msg = match.group(3)
-
+
if msg.startswith("\x01"):
self.__handleCtcpReply(match)
return True
-
+
if "!" in match.group(1):
name = match.group(1).split("!", 1)[0]
msg = "-{0}- {1}".format(name, msg)
@@ -683,27 +683,26 @@
# :foo MODE foo :+i
name, modes = match.group(3).split(" :")
sourceNick = match.group(1)
- if (
- not self.isChannelName(name) and
- name == self.__nickName
- ):
+ if not self.isChannelName(name) and name == self.__nickName:
if sourceNick == self.__nickName:
msg = self.tr(
- "You have set your personal modes to"
- " <b>[{0}]</b>.").format(modes)
+ "You have set your personal modes to" " <b>[{0}]</b>."
+ ).format(modes)
else:
msg = self.tr(
- "{0} has changed your personal modes to"
- " <b>[{1}]</b>.").format(sourceNick, modes)
+ "{0} has changed your personal modes to" " <b>[{1}]</b>."
+ ).format(sourceNick, modes)
self.networkWidget.addServerMessage(
- self.tr("Mode"), msg, filterMsg=False)
+ self.tr("Mode"), msg, filterMsg=False
+ )
return True
elif name == "PART":
nick = match.group(1).split("!", 1)[0]
if nick == self.__nickName:
channel = match.group(3).split(None, 1)[0]
self.networkWidget.addMessage(
- self.tr("You have left channel {0}.").format(channel))
+ self.tr("You have left channel {0}.").format(channel)
+ )
return True
elif name == "QUIT":
# don't do anything with it here
@@ -714,45 +713,46 @@
newNick = match.group(3).split(":", 1)[1]
if oldNick == self.__nickName:
self.networkWidget.addMessage(
- self.tr("You are now known as {0}.").format(newNick))
+ self.tr("You are now known as {0}.").format(newNick)
+ )
self.__nickName = newNick
self.networkWidget.setNickName(newNick)
else:
self.networkWidget.addMessage(
- self.tr("User {0} is now known as {1}.").format(
- oldNick, newNick))
+ self.tr("User {0} is now known as {1}.").format(oldNick, newNick)
+ )
return True
elif name == "PONG":
nick = match.group(3).split(":", 1)[1]
self.networkWidget.addMessage(
- self.tr("Received PONG from {0}").format(nick))
+ self.tr("Received PONG from {0}").format(nick)
+ )
return True
elif name == "ERROR":
self.networkWidget.addErrorMessage(
- self.tr("Server Error"), match.group(3).split(":", 1)[1])
+ self.tr("Server Error"), match.group(3).split(":", 1)[1]
+ )
return True
-
+
return False
-
+
def __handleNumericMessage(self, match):
"""
Private method to handle a server message containing a numeric code.
-
+
@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.
-
+
@param code numerical code sent by the server (integer)
@param server name of the server (string)
@param message message sent by the server (string)
@@ -765,13 +765,13 @@
self.__handleNickInUse()
else:
self.networkWidget.addServerMessage(self.tr("Error"), message)
-
+
return True
-
+
def __handleServerReply(self, code, server, message):
"""
Private slot to handle a server reply.
-
+
@param code numerical code sent by the server (integer)
@param server name of the server (string)
@param message message sent by the server (string)
@@ -790,7 +790,7 @@
msgType = self.tr("Away")
else:
msgType = self.tr("Info ({0})").format(code)
-
+
# special treatment for some messages
if code == 375:
message = self.tr("Message of the day")
@@ -799,19 +799,18 @@
elif code == 4:
parts = message.strip().split()
message = self.tr(
- "Server {0} (Version {1}), User-Modes: {2},"
- " Channel-Modes: {3}"
+ "Server {0} (Version {1}), User-Modes: {2}," " Channel-Modes: {3}"
).format(parts[1], parts[2], parts[3], parts[4])
elif code == 265:
parts = message.strip().split()
- message = self.tr(
- "Current users on {0}: {1}, max. {2}").format(
- server, parts[1], parts[2])
+ message = self.tr("Current users on {0}: {1}, max. {2}").format(
+ server, parts[1], parts[2]
+ )
elif code == 266:
parts = message.strip().split()
- message = self.tr(
- "Current users on the network: {0}, max. {1}").format(
- parts[1], parts[2])
+ message = self.tr("Current users on the network: {0}, max. {1}").format(
+ parts[1], parts[2]
+ )
elif code == 305:
message = self.tr("You are no longer marked as being away.")
elif code == 306:
@@ -822,9 +821,9 @@
message = message[1:]
else:
message = message.replace(":", "", 1)
-
+
self.networkWidget.addServerMessage(msgType, message)
-
+
if code == 1:
# register with services after the welcome message
self.__connectionState = IrcWidget.ServerConnected
@@ -842,9 +841,9 @@
m = self.__chanTypesRe.match(message)
if m:
self.__setChannelTypePrefixes(m.group(1))
-
+
return True
-
+
def __registerWithServices(self):
"""
Private method to register to services.
@@ -855,7 +854,7 @@
password = identity.getPassword()
if service and password:
self.__send("PRIVMSG " + service + " :identify " + password)
-
+
def __autoJoinChannels(self):
"""
Private slot to join channels automatically once a server got
@@ -866,11 +865,11 @@
name = channel.getName()
key = channel.getKey()
self.joinChannel(name, key)
-
+
def __tcpError(self, error):
"""
Private slot to handle errors reported by the TCP socket.
-
+
@param error error code reported by the socket
(QAbstractSocket.SocketError)
"""
@@ -881,45 +880,52 @@
self.tr("SSL Error"),
self.tr(
"""Connection to server {0} (port {1}) lost while"""
- """ waiting for user response to an SSL error.""")
- .format(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.SocketError.HostNotFoundError:
self.networkWidget.addErrorMessage(
self.tr("Socket Error"),
self.tr(
"The host was not found. Please check the host name"
- " and port settings."))
+ " and port settings."
+ ),
+ )
elif error == QAbstractSocket.SocketError.ConnectionRefusedError:
self.networkWidget.addErrorMessage(
self.tr("Socket Error"),
self.tr(
"The connection was refused by the peer. Please check the"
- " host name and port settings."))
+ " host name and port settings."
+ ),
+ )
elif error == QAbstractSocket.SocketError.SslHandshakeFailedError:
self.networkWidget.addErrorMessage(
- self.tr("Socket Error"),
- self.tr("The SSL handshake failed."))
+ self.tr("Socket Error"), self.tr("The SSL handshake failed.")
+ )
else:
if self.__socket:
self.networkWidget.addErrorMessage(
self.tr("Socket Error"),
- self.tr(
- "The following network error occurred:<br/>{0}")
- .format(self.__socket.errorString()))
+ self.tr("The following network error occurred:<br/>{0}").format(
+ self.__socket.errorString()
+ ),
+ )
else:
self.networkWidget.addErrorMessage(
- self.tr("Socket Error"),
- self.tr("A network error occurred."))
-
+ self.tr("Socket Error"), self.tr("A network error occurred.")
+ )
+
def __sslErrors(self, errors):
"""
Private slot to handle SSL errors.
-
+
@param errors list of SSL errors (list of QSslError)
"""
ignored, defaultChanged = self.__sslErrorHandler.sslErrors(
- errors, self.__server.getName(), self.__server.getPort())
+ errors, self.__server.getName(), self.__server.getPort()
+ )
if ignored == EricSslErrorState.NOT_IGNORED:
self.networkWidget.addErrorMessage(
self.tr("SSL Error"),
@@ -927,28 +933,31 @@
"""Could not connect to {0} (port {1}) using an SSL"""
""" encrypted connection. Either the server does not"""
""" support SSL (did you use the correct port?) or"""
- """ you rejected the certificate.""")
- .format(self.__server.getName(), self.__server.getPort()))
+ """ you rejected the certificate."""
+ ).format(self.__server.getName(), self.__server.getPort()),
+ )
self.__socket.close()
else:
if defaultChanged:
self.__socket.setSslConfiguration(
- QSslConfiguration.defaultConfiguration())
+ QSslConfiguration.defaultConfiguration()
+ )
if ignored == EricSslErrorState.USER_IGNORED:
self.networkWidget.addErrorMessage(
self.tr("SSL Error"),
self.tr(
"""The SSL certificate for the server {0} (port {1})"""
""" failed the authenticity check. SSL errors"""
- """ were accepted by you.""")
- .format(self.__server.getName(), self.__server.getPort()))
+ """ were accepted by you."""
+ ).format(self.__server.getName(), self.__server.getPort()),
+ )
if self.__connectionState == IrcWidget.ServerConnecting:
self.__socket.ignoreSslErrors()
-
+
def __setUserPrivilegePrefix(self, prefix1, prefix2):
"""
Private method to set the user privilege prefix.
-
+
@param prefix1 first part of the prefix (string)
@param prefix2 indictors the first part gets mapped to (string)
"""
@@ -958,21 +967,21 @@
for i in range(len(prefix1)):
self.__userPrefix["+" + prefix1[i]] = prefix2[i]
self.__userPrefix["-" + prefix1[i]] = ""
-
+
def __ping(self, match):
"""
Private method to handle a PING message.
-
+
@param match reference to the match object
@return flag indicating, if the message was handled (boolean)
"""
self.__send("PONG " + match.group(1))
return True
-
+
def __handleCtcp(self, match):
"""
Private method to handle a CTCP command.
-
+
@param match reference to the match object
@return flag indicating, if the message was handled (boolean)
"""
@@ -996,35 +1005,39 @@
self.networkWidget.addServerMessage(
self.tr("CTCP"),
self.tr("Received Version request from {0}.").format(
- match.group(1)))
+ match.group(1)
+ ),
+ )
self.__sendCtcpReply(match.group(1), "VERSION " + msg)
elif ctcpRequest == "ping":
self.networkWidget.addServerMessage(
self.tr("CTCP"),
self.tr(
- "Received CTCP-PING request from {0},"
- " sending answer.").format(match.group(1)))
- self.__sendCtcpReply(
- match.group(1), "PING {0}".format(ctcpArg))
+ "Received CTCP-PING request from {0}," " sending answer."
+ ).format(match.group(1)),
+ )
+ self.__sendCtcpReply(match.group(1), "PING {0}".format(ctcpArg))
elif ctcpRequest == "clientinfo":
self.networkWidget.addServerMessage(
self.tr("CTCP"),
self.tr(
- "Received CTCP-CLIENTINFO request from {0},"
- " sending answer.").format(match.group(1)))
+ "Received CTCP-CLIENTINFO request from {0}," " sending answer."
+ ).format(match.group(1)),
+ )
self.__sendCtcpReply(
- match.group(1),
- "CLIENTINFO CLIENTINFO PING VERSION")
+ match.group(1), "CLIENTINFO CLIENTINFO PING VERSION"
+ )
else:
self.networkWidget.addServerMessage(
self.tr("CTCP"),
- self.tr(
- "Received unknown CTCP-{0} request from {1}.")
- .format(ctcpRequest, match.group(1)))
+ self.tr("Received unknown CTCP-{0} request from {1}.").format(
+ ctcpRequest, match.group(1)
+ ),
+ )
return True
-
+
return False
-
+
def __updateUsersCount(self):
"""
Private method to update the users count on the channel tabs.
@@ -1034,16 +1047,17 @@
self.channelsWidget.setTabText(
index,
self.tr("{0} ({1})", "channel name, users count").format(
- channel.name(), channel.getUsersCount()))
-
+ channel.name(), channel.getUsersCount()
+ ),
+ )
+
def __handleNickInUseLogin(self):
"""
Private method to handle a 443 server error at login.
"""
self.__nickIndex += 1
try:
- identity = self.__ircNetworkManager.getIdentity(
- self.__identityName)
+ identity = self.__ircNetworkManager.getIdentity(self.__identityName)
if identity:
nick = identity.getNickNames()[self.__nickIndex]
self.__nickName = nick
@@ -1057,66 +1071,66 @@
self.tr("Critical"),
self.tr(
"No nickname acceptable to the server configured"
- " for <b>{0}</b>. Disconnecting...")
- .format(self.__userName),
- filterMsg=False)
+ " for <b>{0}</b>. Disconnecting..."
+ ).format(self.__userName),
+ filterMsg=False,
+ )
self.__connectNetwork("", False, True)
self.__nickName = ""
self.__nickIndex = -1
return
-
+
self.networkWidget.setNickName(nick)
self.__send("NICK " + nick)
-
+
def __handleNickInUse(self):
"""
Private method to handle a 443 server error.
"""
self.networkWidget.addServerMessage(
- self.tr("Critical"),
- self.tr("The given nickname is already in use."))
-
+ self.tr("Critical"), self.tr("The given nickname is already in use.")
+ )
+
def __changeNick(self, nick):
"""
Private slot to use a new nick name.
-
+
@param nick nick name to use (str)
"""
if nick and nick != self.__nickName:
self.__send("NICK " + nick)
-
+
def __setChannelTypePrefixes(self, prefixes):
"""
Private method to set the channel type prefixes.
-
+
@param prefixes channel prefix characters (string)
"""
self.__channelTypePrefixes = prefixes
-
+
def isChannelName(self, name):
"""
Public method to check, if the given name is a channel name.
-
+
@param name name to check (string)
@return flag indicating a channel name (boolean)
"""
if not name:
return False
-
+
if self.__channelTypePrefixes:
return name[0] in self.__channelTypePrefixes
else:
return name[0] in "#&"
-
+
def __away(self, isAway):
"""
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 and identity.rememberAwayPosition():
for channel in self.__channelList:
channel.setMarkerLine()
