X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fircuser.cpp;h=cf1aedaafe90b98dbb7332ed5ea78098e563b7ff;hp=dd60aa9097b3a3b5f2c9d6af04b61bcdbdcaa6e6;hb=8582c2ad5708a1972c85bea1cf8d81ad3ece4814;hpb=cfbd7e0ec3624307cfb612fe4804d58c34b7eec9 diff --git a/src/common/ircuser.cpp b/src/common/ircuser.cpp index dd60aa90..cf1aedaa 100644 --- a/src/common/ircuser.cpp +++ b/src/common/ircuser.cpp @@ -1,11 +1,11 @@ /*************************************************************************** - * Copyright (C) 2005-07 by The Quassel Team * + * Copyright (C) 2005-2018 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * - * (at your option) any later version. * + * (at your option) version 3. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * @@ -15,99 +15,415 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ #include "ircuser.h" #include "util.h" -IrcUser::IrcUser(QObject *parent) - : QObject(parent) { +#include "network.h" +#include "signalproxy.h" +#include "ircchannel.h" + +#include +#include + +IrcUser::IrcUser(const QString &hostmask, Network *network) : SyncableObject(network), + _initialized(false), + _nick(nickFromMask(hostmask)), + _user(userFromMask(hostmask)), + _host(hostFromMask(hostmask)), + _realName(), + _awayMessage(), + _away(false), + _server(), + // _idleTime(QDateTime::currentDateTime()), + _ircOperator(), + _lastAwayMessageTime(), + _whoisServiceReply(), + _encrypted(false), + _network(network), + _codecForEncoding(nullptr), + _codecForDecoding(nullptr) +{ + updateObjectName(); + _lastAwayMessageTime.setTimeSpec(Qt::UTC); + _lastAwayMessageTime.setMSecsSinceEpoch(0); } -IrcUser::IrcUser(const QString &hostmask, QObject *parent) - : QObject(parent), - nick_(nickFromMask(hostmask)), - user_(userFromMask(hostmask)), - host_(hostFromMask(hostmask)) { + +// ==================== +// PUBLIC: +// ==================== + +QString IrcUser::hostmask() const +{ + return QString("%1!%2@%3").arg(nick()).arg(user()).arg(host()); } -IrcUser::~IrcUser() { + +QDateTime IrcUser::idleTime() +{ + if ((QDateTime::currentDateTime().toMSecsSinceEpoch() - _idleTimeSet.toMSecsSinceEpoch()) + > 1200000) { + // 20 * 60 * 1000 = 1200000 + // 20 minutes have elapsed, clear the known idle time as it's likely inaccurate by now + _idleTime = QDateTime(); + } + return _idleTime; } -void IrcUser::setUser(const QString &user) { - user_ = user; + +QStringList IrcUser::channels() const +{ + QStringList chanList; + IrcChannel *channel; + foreach(channel, _channels) { + chanList << channel->name(); + } + return chanList; } -QString IrcUser::user() const { - return user_; + +void IrcUser::setCodecForEncoding(const QString &name) +{ + setCodecForEncoding(QTextCodec::codecForName(name.toLatin1())); } -void IrcUser::setHost(const QString &host) { - host_ = host; + +void IrcUser::setCodecForEncoding(QTextCodec *codec) +{ + _codecForEncoding = codec; } -QString IrcUser::host() const { - return host_; + +void IrcUser::setCodecForDecoding(const QString &name) +{ + setCodecForDecoding(QTextCodec::codecForName(name.toLatin1())); } -void IrcUser::setNick(const QString &nick) { - nick_ = nick; + +void IrcUser::setCodecForDecoding(QTextCodec *codec) +{ + _codecForDecoding = codec; } -QString IrcUser::nick() const { - return nick_; + +QString IrcUser::decodeString(const QByteArray &text) const +{ + if (!codecForDecoding()) return network()->decodeString(text); + return ::decodeString(text, codecForDecoding()); } -void IrcUser::setUsermodes(const QSet &usermodes) { - usermodes_ = usermodes; + +QByteArray IrcUser::encodeString(const QString &string) const +{ + if (codecForEncoding()) { + return codecForEncoding()->fromUnicode(string); + } + return network()->encodeString(string); } -QSet IrcUser::usermodes() const { - return usermodes_; + +// ==================== +// PUBLIC SLOTS: +// ==================== +void IrcUser::setUser(const QString &user) +{ + if (!user.isEmpty() && _user != user) { + _user = user; + SYNC(ARG(user)); + } } -void IrcUser::setChannelmode(const QString &channel, const QSet &channelmode) { - if(channelmodes_.contains(channel)) - channelmodes_[channel] |= channelmode; - else - channelmodes_[channel] = channelmode; + +void IrcUser::setRealName(const QString &realName) +{ + if (!realName.isEmpty() && _realName != realName) { + _realName = realName; + SYNC(ARG(realName)) + } } -QSet IrcUser::channelmode(const QString &channel) const { - if(channelmodes_.contains(channel)) - throw NoSuchChannelException(); - else - return QSet(); + +void IrcUser::setAccount(const QString &account) +{ + if (_account != account) { + _account = account; + SYNC(ARG(account)) + } } -void IrcUser::updateChannelmode(const QString &channel, const QString &channelmode, bool add) { - if(add) - addChannelmode(channel, channelmode); - else - removeChannelmode(channel, channelmode); + +void IrcUser::setAway(bool away) +{ + if (away != _away) { + _away = away; + markAwayChanged(); + SYNC(ARG(away)) + emit awaySet(away); + } } -void IrcUser::addChannelmode(const QString &channel, const QString &channelmode) { - if(!channelmodes_.contains(channel)) - channelmodes_[channel] = QSet(); - channelmodes_[channel] << channelmode; + +void IrcUser::setAwayMessage(const QString &awayMessage) +{ + if (!awayMessage.isEmpty() && _awayMessage != awayMessage) { + _awayMessage = awayMessage; + markAwayChanged(); + SYNC(ARG(awayMessage)) + } } -void IrcUser::removeChannelmode(const QString &channel, const QString &channelmode) { - if(channelmodes_.contains(channel)) - channelmodes_[channel].remove(channelmode); + +void IrcUser::setIdleTime(const QDateTime &idleTime) +{ + if (idleTime.isValid() && _idleTime != idleTime) { + _idleTime = idleTime; + _idleTimeSet = QDateTime::currentDateTime(); + SYNC(ARG(idleTime)) + } } -QStringList IrcUser::channels() const { - return channelmodes_.keys(); + +void IrcUser::setLoginTime(const QDateTime &loginTime) +{ + if (loginTime.isValid() && _loginTime != loginTime) { + _loginTime = loginTime; + SYNC(ARG(loginTime)) + } } -void IrcUser::joinChannel(const QString &channel) { - if(!channelmodes_.contains(channel)) - channelmodes_[channel] = QSet(); + +void IrcUser::setServer(const QString &server) +{ + if (!server.isEmpty() && _server != server) { + _server = server; + SYNC(ARG(server)) + } } -void IrcUser::partChannel(const QString &channel) { - channelmodes_.remove(channel); + +void IrcUser::setIrcOperator(const QString &ircOperator) +{ + if (!ircOperator.isEmpty() && _ircOperator != ircOperator) { + _ircOperator = ircOperator; + SYNC(ARG(ircOperator)) + } +} + + +// This function is only ever called by SYNC calls from legacy cores (pre-0.13). +// Therefore, no SYNC call is needed here. +void IrcUser::setLastAwayMessage(int lastAwayMessage) +{ +#if QT_VERSION >= 0x050800 + QDateTime lastAwayMessageTime = QDateTime::fromSecsSinceEpoch(lastAwayMessage); +#else + // toSecsSinceEpoch() was added in Qt 5.8. Manually downconvert to seconds for now. + // See https://doc.qt.io/qt-5/qdatetime.html#toMSecsSinceEpoch + QDateTime lastAwayMessageTime = QDateTime::fromMSecsSinceEpoch(lastAwayMessage * 1000); +#endif + lastAwayMessageTime.setTimeSpec(Qt::UTC); + setLastAwayMessageTime(lastAwayMessageTime); +} + + +void IrcUser::setLastAwayMessageTime(const QDateTime &lastAwayMessageTime) +{ + if (lastAwayMessageTime > _lastAwayMessageTime) { + _lastAwayMessageTime = lastAwayMessageTime; + SYNC(ARG(lastAwayMessageTime)) + } +} + + +void IrcUser::setHost(const QString &host) +{ + if (!host.isEmpty() && _host != host) { + _host = host; + SYNC(ARG(host)) + } +} + + +void IrcUser::setNick(const QString &nick) +{ + if (!nick.isEmpty() && nick != _nick) { + _nick = nick; + updateObjectName(); + SYNC(ARG(nick)) + emit nickSet(nick); + } +} + + +void IrcUser::setWhoisServiceReply(const QString &whoisServiceReply) +{ + if (!whoisServiceReply.isEmpty() && whoisServiceReply != _whoisServiceReply) { + _whoisServiceReply = whoisServiceReply; + SYNC(ARG(whoisServiceReply)) + } +} + + +void IrcUser::setSuserHost(const QString &suserHost) +{ + if (!suserHost.isEmpty() && suserHost != _suserHost) { + _suserHost = suserHost; + SYNC(ARG(suserHost)) + } +} + + +void IrcUser::setEncrypted(bool encrypted) +{ + _encrypted = encrypted; + emit encryptedSet(encrypted); + SYNC(ARG(encrypted)) +} + + +void IrcUser::updateObjectName() +{ + renameObject(QString::number(network()->networkId().toInt()) + "/" + _nick); +} + + +void IrcUser::updateHostmask(const QString &mask) +{ + if (mask == hostmask()) + return; + + QString user = userFromMask(mask); + QString host = hostFromMask(mask); + setUser(user); + setHost(host); +} + + +void IrcUser::joinChannel(IrcChannel *channel, bool skip_channel_join) +{ + Q_ASSERT(channel); + if (!_channels.contains(channel)) { + _channels.insert(channel); + if (!skip_channel_join) + channel->joinIrcUser(this); + } +} + + +void IrcUser::joinChannel(const QString &channelname) +{ + joinChannel(network()->newIrcChannel(channelname)); +} + + +void IrcUser::partChannel(IrcChannel *channel) +{ + if (_channels.contains(channel)) { + _channels.remove(channel); + disconnect(channel, nullptr, this, nullptr); + channel->part(this); + QString channelName = channel->name(); + SYNC_OTHER(partChannel, ARG(channelName)) + if (_channels.isEmpty() && !network()->isMe(this)) + quit(); + } +} + + +void IrcUser::partChannel(const QString &channelname) +{ + IrcChannel *channel = network()->ircChannel(channelname); + if (channel == nullptr) { + qWarning() << "IrcUser::partChannel(): received part for unknown Channel" << channelname; + } + else { + partChannel(channel); + } +} + + +void IrcUser::quit() +{ + QList channels = _channels.toList(); + _channels.clear(); + foreach(IrcChannel *channel, channels) { + disconnect(channel, nullptr, this, nullptr); + channel->part(this); + } + network()->removeIrcUser(this); + SYNC(NO_ARG) + emit quited(); +} + + +void IrcUser::channelDestroyed() +{ + // private slot! + auto *channel = static_cast(sender()); + if (_channels.contains(channel)) { + _channels.remove(channel); + if (_channels.isEmpty() && !network()->isMe(this)) + quit(); + } +} + + +void IrcUser::setUserModes(const QString &modes) +{ + if (_userModes != modes) { + _userModes = modes; + SYNC(ARG(modes)) + emit userModesSet(modes); + } +} + + +void IrcUser::addUserModes(const QString &modes) +{ + if (modes.isEmpty()) + return; + + // Don't needlessly sync when no changes are made + bool changesMade = false; + for (int i = 0; i < modes.count(); i++) { + if (!_userModes.contains(modes[i])) { + _userModes += modes[i]; + changesMade = true; + } + } + + if (changesMade) { + SYNC(ARG(modes)) + emit userModesAdded(modes); + } +} + + +void IrcUser::removeUserModes(const QString &modes) +{ + if (modes.isEmpty()) + return; + + for (int i = 0; i < modes.count(); i++) { + _userModes.remove(modes[i]); + } + SYNC(ARG(modes)) + emit userModesRemoved(modes); +} + + +void IrcUser::setLastChannelActivity(BufferId buffer, const QDateTime &time) +{ + _lastActivity[buffer] = time; + emit lastChannelActivityUpdated(buffer, time); +} + + +void IrcUser::setLastSpokenTo(BufferId buffer, const QDateTime &time) +{ + _lastSpokenTo[buffer] = time; + emit lastSpokenToUpdated(buffer, time); }