awayButtons.diff

         _networkName(QString("<not initialized>")),
         _currentServer(QString()),
         _connected(false),
         _away(false),
         _connectionState(Disconnected),
         _prefixes(QString()),
         _prefixModes(QString()),
-...
       if(!_myNick.isEmpty() && !ircUser(myNick())) {
         newIrcUser(myNick());
+      }
       //Avoid duplicating connection if nick is changed
       disconnect(me(), SIGNAL(awaySet(bool)), this, 0);
       connect(me(), SIGNAL(awaySet(bool)), this, SLOT(setAway(bool)));
       emit myNickSet(nickname);
+    }
-...
       emit identitySet(id);
+    }
     void Network::setAway(const bool &away) {
       if(away != _away) {
         _away = away;
         emit awaySet(away);
+      }
+    }
     void Network::setServerList(const QVariantList &serverList) {
       _serverList = fromVariantList<Server>(serverList);
       emit serverListSet(serverList);

       Q_PROPERTY(QByteArray codecForDecoding READ codecForDecoding WRITE setCodecForDecoding STORED false)
       Q_PROPERTY(IdentityId identityId READ identity WRITE setIdentity STORED false)
       Q_PROPERTY(bool isConnected READ isConnected WRITE setConnected STORED false)
       Q_PROPERTY(bool away READ isAway WRITE setAway STORED false)
       //Q_PROPERTY(Network::ConnectionState connectionState READ connectionState WRITE setConnectionState STORED false)
       Q_PROPERTY(int connectionState READ connectionState WRITE setConnectionState STORED false)
       Q_PROPERTY(bool useRandomServer READ useRandomServer WRITE setUseRandomServer STORED false)
-...
       inline const QString &myNick() const { return _myNick; }
       inline int latency() const { return _latency; }
       inline IrcUser *me() const { return ircUser(myNick()); }
       inline bool isAway() const { return _away; }
       inline IdentityId identity() const { return _identity; }
       QStringList nicks() const;
       inline QStringList channels() const { return _ircChannels.keys(); }
-...
       virtual void setMyNick(const QString &mynick);
       void setLatency(int latency);
       void setIdentity(IdentityId);
       void setAway(const bool &away);
       void setServerList(const QVariantList &serverList);
       void setUseRandomServer(bool);
-...
       void myNickSet(const QString &mynick);
       void latencySet(int latency);
       void identitySet(IdentityId);
       void awaySet(bool away);
       void serverListSet(QVariantList serverList);
       void useRandomServerSet(bool);
-...
       QString _networkName;
       QString _currentServer;
       bool _connected;
       bool _away;
       ConnectionState _connectionState;
       QString _prefixes;

+    }
     void NetworkModelController::handleNetworkAction(ActionType type, QAction *) {
       if(type == NetworkConnectAll || type == NetworkDisconnectAll) {
       if(type == NetworkConnectAll || type == NetworkDisconnectAll || type == NetworkAwayAll || type == NetworkBackAll) {
         foreach(NetworkId id, Client::networkIds()) {
           const Network *net = Client::network(id);
           if(type == NetworkConnectAll && net->connectionState() == Network::Disconnected)
             net->requestConnect();
           if(type == NetworkDisconnectAll && net->connectionState() != Network::Disconnected)
           else if(type == NetworkDisconnectAll && net->connectionState() != Network::Disconnected)
             net->requestDisconnect();
           else if(type == NetworkBackAll && net->connectionState() != Network::Disconnected && net->isAway())
             Client::userInput(BufferInfo::fakeStatusBuffer(id), QString("/AWAY"));
           else if(type == NetworkAwayAll && net->connectionState() != Network::Disconnected && !net->isAway())
             Client::userInput(BufferInfo::fakeStatusBuffer(id), QString("/AWAY %1").arg(Client::identity(net->identity())->awayReason()));
+        }
         return;
+      }
       if(!indexList().count())
         return;
       const Network *network = Client::network(indexList().at(0).data(NetworkModel::NetworkIdRole).value<NetworkId>());
       Q_CHECK_PTR(network);
       if(!network)
-...
         case NetworkDisconnect:
           network->requestDisconnect();
           break;
         case NetworkBack:
           Client::userInput(BufferInfo::fakeStatusBuffer(network->networkId()), QString("/AWAY"));
           break;
         case NetworkAway:
           Client::userInput(BufferInfo::fakeStatusBuffer(network->networkId()),
                             QString("/AWAY %1").arg(Client::identity(network->identity())->awayReason()));
         default:
           break;
+      }

         NetworkDisconnect = 0x02,
         NetworkConnectAll = 0x03,
         NetworkDisconnectAll = 0x04,
         NetworkAway = 0x05,
         NetworkBack = 0x06,
         NetworkAwayAll = 0x07,
         NetworkBackAll = 0x08,
         // Buffer actions
         BufferMask = 0xf0,

     #include "toolbaractionprovider.h"
     #include "iconloader.h"
     #include "identity.h"
     ToolBarActionProvider::ToolBarActionProvider(QObject *parent)
     : NetworkModelController(parent)
+    {
       registerAction(NetworkConnectAll, MainBarIcon("network-connect"), tr("Connect"))->setToolTip(tr("Connect to IRC"));
       registerAction(NetworkDisconnectAll, MainBarIcon("network-disconnect"), tr("Disconnect"))->setToolTip(tr("Disconnect from IRC"));
       registerAction(NetworkBackAll, MainBarIcon("im-user"), tr("Back"))->setToolTip(tr("Set as back"));
       registerAction(NetworkAwayAll, MainBarIcon("im-user-away"), tr("Away"))->setToolTip(tr("Set as away"));
       registerAction(BufferPart, MainBarIcon("irc-close-channel"), tr("Part"))->setToolTip(tr("Leave currently selected channel"));
       registerAction(JoinChannel, MainBarIcon("irc-join-channel"), tr("Join"))->setToolTip(tr("Join a channel"));
-...
       _networksDisconnectMenu->addAction(tr("Disconnect from all"));
       action(NetworkDisconnectAll)->setMenu(_networksDisconnectMenu);
       action(NetworkDisconnectAll)->setEnabled(false);
       _networksBackMenu = new QMenu();
       _networksBackMenu->setSeparatorsCollapsible(false);
       _networksBackMenu->addSeparator();
       _networksBackMenu->addAction(tr("Back to all"));
       action(NetworkBackAll)->setMenu(_networksBackMenu);
       action(NetworkBackAll)->setEnabled(false);
       _networksAwayMenu = new QMenu();
       _networksAwayMenu->setSeparatorsCollapsible(false);
       _networksAwayMenu->addSeparator();
       _networksAwayMenu->addAction(tr("Away from all"));
       action(NetworkAwayAll)->setMenu(_networksAwayMenu);
       action(NetworkAwayAll)->setEnabled(false);
       connect(Client::instance(), SIGNAL(networkCreated(NetworkId)), SLOT(networkCreated(NetworkId)));
       connect(Client::instance(), SIGNAL(networkRemoved(NetworkId)), SLOT(networkRemoved(NetworkId)));
-...
         case MainToolBar:
           bar->addAction(action(NetworkConnectAll));
           bar->addAction(action(NetworkDisconnectAll));
           bar->addAction(action(NetworkBackAll));
           bar->addAction(action(NetworkAwayAll));
           bar->addAction(action(JoinChannel));
           bar->addAction(action(BufferPart));
           break;
-...
     void ToolBarActionProvider::networkCreated(NetworkId id) {
       const Network *net = Client::network(id);
       Action *act = new Action(net->networkName(), this);
       _networkActions[id] = act;
       act->setObjectName(QString("NetworkAction-%1").arg(id.toInt()));
       act->setData(QVariant::fromValue<NetworkId>(id));
       Action *connectAct = new Action(net->networkName(), this);
       _connectActions[id] = connectAct;
       connectAct->setObjectName(QString("ConnectAction-%1").arg(id.toInt()));
       connectAct->setData(QVariant::fromValue<NetworkId>(id));
       Action *awayAct = new Action(net->networkName(), this);
       _awayActions[id] = awayAct;
       awayAct->setObjectName(QString("AwayAction-%1").arg(id.toInt()));
       awayAct->setData(QVariant::fromValue<NetworkId>(id));
       connect(net, SIGNAL(updatedRemotely()), SLOT(networkUpdated()));
       connect(act, SIGNAL(triggered()), SLOT(connectOrDisconnectNet()));
       connect(net, SIGNAL(awaySet(bool)), SLOT(awayUpdated()));
       connect(connectAct, SIGNAL(triggered()), SLOT(connectOrDisconnectNet()));
       connect(awayAct, SIGNAL(triggered()), SLOT(awayOrBackNet()));
       networkUpdated(net);
+    }
     void ToolBarActionProvider::networkRemoved(NetworkId id) {
       Action *act = _networkActions.take(id);
       if(act)
         act->deleteLater();
       Action *awayAct = _awayActions.take(id);
       if(awayAct)
         awayAct->deleteLater();
       Action *connectAct = _connectActions.take(id);
       if(connectAct)
         connectAct->deleteLater();
+    }
     void ToolBarActionProvider::networkUpdated(const Network *net) {
-...
         net = qobject_cast<const Network *>(sender());
       if(!net)
         return;
       Action *act = _networkActions.value(net->networkId());
       if(!act)
       Action *connectAct = _connectActions.value(net->networkId());
       Action *awayAct = _awayActions.value(net->networkId());
       if(!connectAct || !awayAct)
         return;
       _networksConnectMenu->removeAction(act);
       _networksDisconnectMenu->removeAction(act);
       _networksConnectMenu->removeAction(connectAct);
       _networksDisconnectMenu->removeAction(connectAct);
       _networksBackMenu->removeAction(awayAct);
       _networksAwayMenu->removeAction(awayAct);
       connectAct->setText(net->networkName());
       awayAct->setText(net->networkName());
       if (net->connectionState() == Network::Disconnected) {
         addActionToMenu(connectAct, _networksConnectMenu);
       } else {
         addActionToMenu(connectAct, _networksDisconnectMenu);
         if (net->isAway())
           addActionToMenu(awayAct, _networksBackMenu);
         else
           addActionToMenu(awayAct, _networksAwayMenu);
+      }
       action(NetworkConnectAll)->setEnabled(_networksConnectMenu->actions().count() > 2);
       action(NetworkDisconnectAll)->setEnabled(_networksDisconnectMenu->actions().count() > 2);
       action(NetworkBackAll)->setEnabled(_networksBackMenu->actions().count() > 2);
       action(NetworkAwayAll)->setEnabled(_networksAwayMenu->actions().count() > 2);
       action(JoinChannel)->setEnabled(_networksDisconnectMenu->actions().count() > 2);
+    }
       QMenu *newMenu = net->connectionState() != Network::Disconnected ? _networksDisconnectMenu : _networksConnectMenu;
       act->setText(net->networkName());
     void ToolBarActionProvider::awayUpdated(const Network *net) {
       if(!net)
         net = qobject_cast<const Network *>(sender());
       if(!net || net->connectionState() == Network::Disconnected)
         return;
       Action *awayAct = _awayActions.value(net->networkId());
       if (!awayAct)
         return;
       _networksBackMenu->removeAction(awayAct);
       _networksAwayMenu->removeAction(awayAct);
       if (net->isAway())
         addActionToMenu(awayAct, _networksBackMenu);
       else
         addActionToMenu(awayAct, _networksAwayMenu);
       action(NetworkBackAll)->setEnabled(_networksBackMenu->actions().count() > 2);
       action(NetworkAwayAll)->setEnabled(_networksAwayMenu->actions().count() > 2);
+    }
       const int lastidx = newMenu->actions().count() - 2;
       QAction *beforeAction = newMenu->actions().at(lastidx);
       for(int i = 0; i < newMenu->actions().count() - 2; i++) {
         QAction *action = newMenu->actions().at(i);
         if(net->networkName().localeAwareCompare(action->text()) < 0) {
     void ToolBarActionProvider::addActionToMenu(Action *act, QMenu *menu) {
       const int lastidx = menu->actions().count() - 2;
       QAction *beforeAction = menu->actions().at(lastidx);
       for(int i = 0; i < menu->actions().count() - 2; i++) {
         QAction *action = menu->actions().at(i);
         if(act->text().localeAwareCompare(action->text()) < 0) {
           beforeAction = action;
           break;
+        }
+      }
       newMenu->insertAction(beforeAction, act);
       action(NetworkConnectAll)->setEnabled(_networksConnectMenu->actions().count() > 2);
       action(NetworkDisconnectAll)->setEnabled(_networksDisconnectMenu->actions().count() > 2);
       action(JoinChannel)->setEnabled(_networksDisconnectMenu->actions().count() > 2);
       menu->insertAction(beforeAction, act);
+    }
     void ToolBarActionProvider::connectOrDisconnectNet() {
-...
       if(!net)
         return;
       if(net->connectionState() == Network::Disconnected) net->requestConnect();
       else net->requestDisconnect();
       if(net->connectionState() == Network::Disconnected)
         net->requestConnect();
       else
         net->requestDisconnect();
+    }
     void ToolBarActionProvider::awayOrBackNet() {
       QAction *act = qobject_cast<QAction *>(sender());
       if(!act)
         return;
       const Network *net = Client::network(act->data().value<NetworkId>());
       if(!net)
         return;
       BufferInfo bufferInfo = BufferInfo::fakeStatusBuffer(net->networkId());
       if(net->isAway())
         Client::userInput(bufferInfo, QString("/AWAY"));
       else
         Client::userInput(bufferInfo, QString("/AWAY %1").arg(Client::identity(net->identity())->awayReason()));
+    }
     //void ToolBarActionProvider::

       void networkCreated(NetworkId id);
       void networkRemoved(NetworkId id);
       void networkUpdated(const Network *net = 0);
       void awayUpdated(const Network *net = 0);
       void connectOrDisconnectNet();
       void awayOrBackNet();
       void currentBufferChanged(const QModelIndex &);
       void nickSelectionChanged(const QModelIndexList &);
-...
       void updateStates();
     private:
       QMenu *_networksConnectMenu, *_networksDisconnectMenu;
       QHash<NetworkId, Action *> _networkActions;
       QMenu *_networksConnectMenu, *_networksDisconnectMenu, *_networksBackMenu, *_networksAwayMenu;
       QHash<NetworkId, Action *> _connectActions, _awayActions;
       QModelIndex _currentBuffer;
       QModelIndexList _selectedNicks;
       void addActionToMenu(Action *action, QMenu *menu);
     };
     #endif

Project

General

Profile

Quassel IRC