#include <QAbstractItemView>
#include <QMimeData>
+#include <utility>
#include "buffermodel.h"
#include "buffersettings.h"
NetworkItem::NetworkItem(const NetworkId &netid, AbstractTreeItem *parent)
: PropertyMapItem(parent),
_networkId(netid),
- _statusBufferItem(0)
+ _statusBufferItem(nullptr)
{
// DO NOT EMIT dataChanged() DIRECTLY IN NetworkItem
// use networkDataChanged() instead. Otherwise you will end up in a infinite loop
// FIXME shouldn't we check the bufferItemCache here?
BufferItem *NetworkItem::findBufferItem(BufferId bufferId)
{
- BufferItem *bufferItem = 0;
+ BufferItem *bufferItem = nullptr;
for (int i = 0; i < childCount(); i++) {
bufferItem = qobject_cast<BufferItem *>(child(i));
if (bufferItem->bufferId() == bufferId)
return bufferItem;
}
- return 0;
+ return nullptr;
}
switch (bufferInfo.type()) {
case BufferInfo::ChannelBuffer:
{
- ChannelBufferItem *channelBufferItem = static_cast<ChannelBufferItem *>(bufferItem);
+ auto *channelBufferItem = static_cast<ChannelBufferItem *>(bufferItem);
if (_network) {
IrcChannel *ircChannel = _network->ircChannel(bufferInfo.bufferName());
if (ircChannel)
void NetworkItem::attachIrcUser(IrcUser *ircUser)
{
- QueryBufferItem *queryItem = 0;
+ QueryBufferItem *queryItem = nullptr;
for (int i = 0; i < childCount(); i++) {
queryItem = qobject_cast<QueryBufferItem *>(child(i));
if (!queryItem)
void NetworkItem::onBeginRemoveChilds(int start, int end)
{
for (int i = start; i <= end; i++) {
- StatusBufferItem *statusBufferItem = qobject_cast<StatusBufferItem *>(child(i));
+ auto *statusBufferItem = qobject_cast<StatusBufferItem *>(child(i));
if (statusBufferItem) {
- _statusBufferItem = 0;
+ _statusBufferItem = nullptr;
break;
}
}
void NetworkItem::onNetworkDestroyed()
{
- _network = 0;
+ _network = nullptr;
emit networkDataChanged();
removeAllChilds();
}
/*****************************************
* Fancy Buffer Items
*****************************************/
-BufferItem::BufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
+BufferItem::BufferItem(BufferInfo bufferInfo, AbstractTreeItem *parent)
: PropertyMapItem(parent),
- _bufferInfo(bufferInfo),
+ _bufferInfo(std::move(bufferInfo)),
_activity(BufferInfo::NoActivity)
{
setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);
QString StatusBufferItem::toolTip(int column) const
{
- NetworkItem *networkItem = qobject_cast<NetworkItem *>(parent());
+ auto *networkItem = qobject_cast<NetworkItem *>(parent());
if (networkItem)
return networkItem->toolTip(column);
else
*****************************************/
QueryBufferItem::QueryBufferItem(const BufferInfo &bufferInfo, NetworkItem *parent)
: BufferItem(bufferInfo, parent),
- _ircUser(0)
+ _ircUser(nullptr)
{
setFlags(flags() | Qt::ItemIsDropEnabled | Qt::ItemIsEditable);
return;
if (_ircUser) {
- disconnect(_ircUser, 0, this, 0);
+ disconnect(_ircUser, nullptr, this, nullptr);
}
if (ircUser) {
// SIGNAL destroyed(QObject*) to SLOT removeIrcUser().
// This fixes removing an active IrcUser if the user had quit then rejoined in a nonstandard
// manner (e.g. updateNickFromHost calling newIrcUser, triggered by an away-notify message).
- disconnect(_ircUser, 0, this, 0);
+ disconnect(_ircUser, nullptr, this, nullptr);
// Clear IrcUser (only set to 0 if not already 0)
- _ircUser = 0;
+ _ircUser = nullptr;
// Only emit dataChanged() if data actually changed. This might serve as a small
// optimization, but it can be moved outside the if statement if other behavior depends on
*****************************************/
ChannelBufferItem::ChannelBufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
: BufferItem(bufferInfo, parent),
- _ircChannel(0)
+ _ircChannel(nullptr)
{
setFlags(flags() | Qt::ItemIsDropEnabled);
}
{
if (_ircChannel) {
qWarning() << Q_FUNC_INFO << "IrcChannel already set; cleanup failed!?";
- disconnect(_ircChannel, 0, this, 0);
+ disconnect(_ircChannel, nullptr, this, nullptr);
}
_ircChannel = ircChannel;
void ChannelBufferItem::ircChannelParted()
{
Q_CHECK_PTR(_ircChannel);
- disconnect(_ircChannel, 0, this, 0);
- _ircChannel = 0;
+ disconnect(_ircChannel, nullptr, this, nullptr);
+ _ircChannel = nullptr;
emit dataChanged();
removeAllChilds();
}
void ChannelBufferItem::ircChannelDestroyed()
{
if (_ircChannel) {
- _ircChannel = 0;
+ _ircChannel = nullptr;
emit dataChanged();
removeAllChilds();
}
UserCategoryItem *ChannelBufferItem::findCategoryItem(int categoryId)
{
- UserCategoryItem *categoryItem = 0;
+ UserCategoryItem *categoryItem = nullptr;
for (int i = 0; i < childCount(); i++) {
categoryItem = qobject_cast<UserCategoryItem *>(child(i));
if (categoryItem->categoryId() == categoryId)
return categoryItem;
}
- return 0;
+ return nullptr;
}
QHash<UserCategoryItem *, QList<IrcUser *> > categories;
int categoryId = -1;
- UserCategoryItem *categoryItem = 0;
+ UserCategoryItem *categoryItem = nullptr;
foreach(IrcUser *ircUser, ircUsers) {
categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
return;
}
- disconnect(ircUser, 0, this, 0);
+ disconnect(ircUser, nullptr, this, nullptr);
removeUserFromCategory(ircUser);
emit dataChanged(2);
}
return;
}
- UserCategoryItem *categoryItem = 0;
+ UserCategoryItem *categoryItem = nullptr;
for (int i = 0; i < childCount(); i++) {
categoryItem = qobject_cast<UserCategoryItem *>(child(i));
if (categoryItem->removeUser(ircUser)) {
}
// find the item that needs reparenting
- IrcUserItem *ircUserItem = 0;
+ IrcUserItem *ircUserItem = nullptr;
for (int i = 0; i < childCount(); i++) {
- UserCategoryItem *oldCategoryItem = qobject_cast<UserCategoryItem *>(child(i));
+ auto *oldCategoryItem = qobject_cast<UserCategoryItem *>(child(i));
Q_ASSERT(oldCategoryItem);
IrcUserItem *userItem = oldCategoryItem->findIrcUser(ircUser);
if (userItem) {
int n = childCount();
switch (_category) {
case 0:
- return tr("%n Owner(s)", 0, n);
+ return tr("%n Owner(s)", "", n);
case 1:
- return tr("%n Admin(s)", 0, n);
+ return tr("%n Admin(s)", "", n);
case 2:
- return tr("%n Operator(s)", 0, n);
+ return tr("%n Operator(s)", "", n);
case 3:
- return tr("%n Half-Op(s)", 0, n);
+ return tr("%n Half-Op(s)", "", n);
case 4:
- return tr("%n Voiced", 0, n);
+ return tr("%n Voiced", "", n);
default:
- return tr("%n User(s)", 0, n);
+ return tr("%n User(s)", "", n);
}
}
IrcUserItem *UserCategoryItem::findIrcUser(IrcUser *ircUser)
{
- IrcUserItem *userItem = 0;
+ IrcUserItem *userItem = nullptr;
for (int i = 0; i < childCount(); i++) {
userItem = qobject_cast<IrcUserItem *>(child(i));
if (userItem->ircUser() == ircUser)
return userItem;
}
- return 0;
+ return nullptr;
}
bool UserCategoryItem::removeUser(IrcUser *ircUser)
{
IrcUserItem *userItem = findIrcUser(ircUser);
- bool success = (bool)userItem;
+ auto success = (bool)userItem;
if (success) {
removeChild(userItem);
emit dataChanged(0);
{
// IrcUserItems are parented to UserCategoryItem, which are parented to ChannelBufferItem.
// We want the channel buffer item in order to get the channel-specific user modes.
- UserCategoryItem *category = qobject_cast<UserCategoryItem *>(parent());
+ auto *category = qobject_cast<UserCategoryItem *>(parent());
if (!category)
return QString();
- ChannelBufferItem *channel = qobject_cast<ChannelBufferItem *>(category->parent());
+ auto *channel = qobject_cast<ChannelBufferItem *>(category->parent());
if (!channel)
return QString();
int NetworkModel::networkRow(NetworkId networkId) const
{
- NetworkItem *netItem = 0;
+ NetworkItem *netItem = nullptr;
for (int i = 0; i < rootItem->childCount(); i++) {
netItem = qobject_cast<NetworkItem *>(rootItem->child(i));
if (!netItem)
{
int netRow = networkRow(networkId);
if (netRow == -1)
- return QModelIndex();
+ return {};
else
return indexByItem(qobject_cast<NetworkItem *>(rootItem->child(netRow)));
}
{
int netRow = networkRow(networkId);
if (netRow == -1)
- return 0;
+ return nullptr;
else
return qobject_cast<NetworkItem *>(rootItem->child(netRow));
}
{
NetworkItem *netItem = findNetworkItem(networkId);
- if (netItem == 0) {
+ if (netItem == nullptr) {
netItem = new NetworkItem(networkId, rootItem);
rootItem->newChild(netItem);
}
QModelIndex NetworkModel::bufferIndex(BufferId bufferId)
{
if (!_bufferItemCache.contains(bufferId))
- return QModelIndex();
+ return {};
return indexByItem(_bufferItemCache[bufferId]);
}
if (_bufferItemCache.contains(bufferId))
return _bufferItemCache[bufferId];
else
- return 0;
+ return nullptr;
}
QMimeData *NetworkModel::mimeData(const QModelIndexList &indexes) const
{
- QMimeData *mimeData = new QMimeData();
+ auto *mimeData = new QMimeData();
QStringList bufferlist;
QString netid, uid, bufferid;
MsgId NetworkModel::lastSeenMsgId(BufferId bufferId) const
{
if (!_bufferItemCache.contains(bufferId))
- return MsgId();
+ return {};
return _bufferItemCache[bufferId]->lastSeenMsgId();
}
MsgId NetworkModel::markerLineMsgId(BufferId bufferId) const
{
if (!_bufferItemCache.contains(bufferId))
- return MsgId();
+ return {};
return _bufferItemCache[bufferId]->markerLineMsgId();
}
if (!bufferItem) {
qDebug() << "NetworkModel::lastSeenMsgId(): buffer is unknown:" << bufferId;
Client::purgeKnownBufferIds();
- return MsgId();
+ return {};
}
return bufferItem->lastSeenMsgId();
}
case Message::Action:
if (bufferType(msg.bufferId()) == BufferInfo::ChannelBuffer) {
const Network *net = Client::network(msg.bufferInfo().networkId());
- IrcUser *user = net ? net->ircUser(nickFromMask(msg.sender())) : 0;
+ IrcUser *user = net ? net->ircUser(nickFromMask(msg.sender())) : nullptr;
if (user)
user->setLastChannelActivity(msg.bufferId(), msg.timestamp());
}
{
QVariant netVariant = index.data(NetworkIdRole);
if (!netVariant.isValid())
- return 0;
+ return nullptr;
NetworkId networkId = netVariant.value<NetworkId>();
return Client::network(networkId);
NetworkId NetworkModel::networkId(BufferId bufferId) const
{
if (!_bufferItemCache.contains(bufferId))
- return NetworkId();
+ return {};
- NetworkItem *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
+ auto *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
if (netItem)
return netItem->networkId();
else
- return NetworkId();
+ return {};
}
if (!_bufferItemCache.contains(bufferId))
return QString();
- NetworkItem *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
+ auto *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
if (netItem)
return netItem->networkName();
else
{
const NetworkItem *netItem = findNetworkItem(networkId);
if (!netItem)
- return BufferId();
+ return {};
for (int i = 0; i < netItem->childCount(); i++) {
- BufferItem *bufferItem = qobject_cast<BufferItem *>(netItem->child(i));
+ auto *bufferItem = qobject_cast<BufferItem *>(netItem->child(i));
if (bufferItem && !bufferItem->bufferName().compare(bufferName, cs))
return bufferItem->bufferId();
}
- return BufferId();
+ return {};
}
projects / quassel.git / blobdiff