Quassel IRC

    _away(false),

  //Sets this->_away and avoids duplicating connection if nick is changed, there's probably a better way of doing this?

  setAway(me()->isAway());

  disconnect(me(), SIGNAL(awaySet(bool)), this, 0);

  connect(me(), SIGNAL(awaySet(bool)), this, SLOT(setAway(bool)));

void Network::setAway(const bool &away) {

  if(away != _away) {

    _away = away;

    emit awaySet(away);

  }

}

  Q_PROPERTY(bool away READ isAway WRITE setAway STORED false)

  inline bool isAway() const { return _away; }

  void setAway(const bool &away);

  void awaySet(bool away);

  bool _away;

  if(type == NetworkConnectAll || type == NetworkDisconnectAll || type == NetworkAwayAll || type == NetworkBackAll) {

      else if(type == NetworkDisconnectAll && net->connectionState() != Network::Disconnected)

      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()));

    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()));

    NetworkAway = 0x05,

    NetworkBack = 0x06,

    NetworkAwayAll = 0x07,

    NetworkBackAll = 0x08,

  QRegExp regex(QString("^[^a-zA-Z#]*").append(QRegExp::escape(tabAbbrev)), Qt::CaseInsensitive);

  //Adds each channel on network to CompletionMap for all buffers.

  foreach(QString channel, _currentNetwork->channels()) {

    if(regex.indexIn(channel) > -1)

      completionMap[channel.toLower()] = channel;

  }

#include "identity.h"

  registerAction(NetworkConnectAll, MainBarIcon("network-connect"), tr("Connect"))->setToolTip(tr("Connect to all"));

  registerAction(NetworkDisconnectAll, MainBarIcon("network-disconnect"), tr("Disconnect"))->setToolTip(tr("Disconnect from all"));

  registerAction(NetworkBackAll, MainBarIcon("im-user"), tr("Back"))->setToolTip(tr("Back to all"));

  registerAction(NetworkAwayAll, MainBarIcon("im-user-away"), tr("Away"))->setToolTip(tr("Away from all"));

  //A cleaner way to do this, rather than basically copy-pasting code. Allows for easy adding of menus if needed.

  _actionMenus[NetworkConnectAll] = new QMenu();

  _actionMenus[NetworkDisconnectAll] = new QMenu();

  _actionMenus[NetworkBackAll] = new QMenu();

  _actionMenus[NetworkAwayAll] = new QMenu();

  foreach(ActionType type, _actionMenus.keys()) {

    _actionMenus[type] = new QMenu();

    Action *act = action(type);

    QMenu *menu = _actionMenus[type];

    menu->setSeparatorsCollapsible(false);

    menu->addSeparator();

    menu->addAction(act->toolTip(), act, SLOT(trigger()));

    act->setMenu(menu);

    act->setEnabled(false);

  }

      bar->addAction(action(NetworkBackAll));

      bar->addAction(action(NetworkAwayAll));

  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(awaySet(bool)), SLOT(awayUpdated()));

  connect(connectAct, SIGNAL(triggered()), SLOT(connectOrDisconnectNet()));

  connect(awayAct, SIGNAL(triggered()), SLOT(awayOrBackNet()));

  Action *awayAct = _awayActions.take(id);

  if(awayAct)

    awayAct->deleteLater();

  Action *connectAct = _connectActions.take(id);

  if(connectAct)

    connectAct->deleteLater();

  Action *connectAct = _connectActions.value(net->networkId());

  Action *awayAct = _awayActions.value(net->networkId());

  if(!connectAct || !awayAct)

  foreach(QMenu *menu, _actionMenus) {

    menu->removeAction(connectAct);

    menu->removeAction(awayAct);

  }

  connectAct->setText(net->networkName());

  awayAct->setText(net->networkName());

  if (net->connectionState() == Network::Disconnected) {

    addActionToMenu(connectAct, menu(NetworkConnectAll));

  } else {

    addActionToMenu(connectAct, menu(NetworkDisconnectAll));

    if (net->isAway())

      addActionToMenu(awayAct, menu(NetworkBackAll));

    else

      addActionToMenu(awayAct, menu(NetworkAwayAll));

  }

  foreach(ActionType type, _actionMenus.keys())

    action(type)->setEnabled(menu(type)->actions().count() > 2);

  action(JoinChannel)->setEnabled(menu(NetworkDisconnectAll)->actions().count() > 2);

}

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;

  menu(NetworkBackAll)->removeAction(awayAct);

  menu(NetworkAwayAll)->removeAction(awayAct);

  if (net->isAway())

    addActionToMenu(awayAct, menu(NetworkBackAll));

  else

    addActionToMenu(awayAct, menu(NetworkAwayAll));

  action(NetworkBackAll)->setEnabled(menu(NetworkBackAll)->actions().count() > 2);

  action(NetworkAwayAll)->setEnabled(menu(NetworkAwayAll)->actions().count() > 2);

}

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) {

  menu->insertAction(beforeAction, act);

  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()));

  inline QMenu *menu(ActionType action) const;

  void awayUpdated(const Network *net = 0);

  void awayOrBackNet();

  QHash<ActionType, QMenu *> _actionMenus;

  QHash<NetworkId, Action *> _connectActions, _awayActions;

  void addActionToMenu(Action *action, QMenu *menu);

QMenu *ToolBarActionProvider::menu(ActionType type) const { return _actionMenus.value(type); }