+}
+
+
+void MainWin::toggleFullscreen()
+{
+ if (isFullScreen())
+ showNormal();
+ else
+ showFullScreen();
+}
+
+
+/********************************************************************************************************/
+
+bool MainWin::event(QEvent *event)
+{
+ if (event->type() == QEvent::WindowActivate) {
+ BufferId buffer = Client::bufferModel()->currentBuffer();
+ if (buffer.isValid())
+ Client::instance()->markBufferAsRead(buffer);
+ }
+ return QMainWindow::event(event);
+}
+
+
+void MainWin::moveEvent(QMoveEvent *event)
+{
+ if (!(windowState() & Qt::WindowMaximized))
+ _normalPos = event->pos();
+
+ QMainWindow::moveEvent(event);
+}
+
+
+void MainWin::resizeEvent(QResizeEvent *event)
+{
+ if (!(windowState() & Qt::WindowMaximized))
+ _normalSize = event->size();
+
+ QMainWindow::resizeEvent(event);
+}
+
+
+void MainWin::closeEvent(QCloseEvent *event)
+{
+ QtUiSettings s;
+ QtUiApplication *app = qobject_cast<QtUiApplication *> qApp;
+ Q_ASSERT(app);
+ if (!app->isAboutToQuit() && QtUi::haveSystemTray() && s.value("MinimizeOnClose").toBool()) {
+ QtUi::hideMainWidget();
+ event->ignore();
+ }
+ else {
+ event->accept();
+ quit();
+ }
+}
+
+
+void MainWin::messagesInserted(const QModelIndex &parent, int start, int end)
+{
+ Q_UNUSED(parent);
+
+ bool hasFocus = QApplication::activeWindow() != 0;
+
+ for (int i = start; i <= end; i++) {
+ QModelIndex idx = Client::messageModel()->index(i, ChatLineModel::ContentsColumn);
+ if (!idx.isValid()) {
+ qDebug() << "MainWin::messagesInserted(): Invalid model index!";
+ continue;
+ }
+ Message::Flags flags = (Message::Flags)idx.data(ChatLineModel::FlagsRole).toInt();
+ if (flags.testFlag(Message::Backlog) || flags.testFlag(Message::Self))
+ continue;
+
+ BufferId bufId = idx.data(ChatLineModel::BufferIdRole).value<BufferId>();
+ BufferInfo::Type bufType = Client::networkModel()->bufferType(bufId);
+
+ // check if bufferId belongs to the shown chatlists
+ if (!(Client::bufferViewOverlay()->bufferIds().contains(bufId) ||
+ Client::bufferViewOverlay()->tempRemovedBufferIds().contains(bufId)))
+ continue;
+
+ // check if it's the buffer currently displayed
+ if (hasFocus && bufId == Client::bufferModel()->currentBuffer())
+ continue;
+
+ // only show notifications for higlights or queries
+ if (bufType != BufferInfo::QueryBuffer && !(flags & Message::Highlight))
+ continue;
+
+ // and of course: don't notify for ignored messages
+ if (Client::ignoreListManager() && Client::ignoreListManager()->match(idx.data(MessageModel::MessageRole).value<Message>(), Client::networkModel()->networkName(bufId)))
+ continue;
+
+ // seems like we have a legit notification candidate!
+ QModelIndex senderIdx = Client::messageModel()->index(i, ChatLineModel::SenderColumn);
+ QString sender = senderIdx.data(ChatLineModel::EditRole).toString();
+ QString contents = idx.data(ChatLineModel::DisplayRole).toString();
+ AbstractNotificationBackend::NotificationType type;
+
+ if (bufType == BufferInfo::QueryBuffer && !hasFocus)
+ type = AbstractNotificationBackend::PrivMsg;
+ else if (bufType == BufferInfo::QueryBuffer && hasFocus)
+ type = AbstractNotificationBackend::PrivMsgFocused;
+ else if (flags & Message::Highlight && !hasFocus)
+ type = AbstractNotificationBackend::Highlight;
+ else
+ type = AbstractNotificationBackend::HighlightFocused;
+
+ QtUi::instance()->invokeNotification(bufId, type, sender, contents);
+ }
+}
+
+
+void MainWin::currentBufferChanged(BufferId buffer)
+{
+ if (buffer.isValid())
+ Client::instance()->markBufferAsRead(buffer);
+}
+
+
+void MainWin::clientNetworkCreated(NetworkId id)
+{
+ const Network *net = Client::network(id);
+ QAction *act = new QAction(net->networkName(), this);
+ act->setObjectName(QString("NetworkAction-%1").arg(id.toInt()));
+ act->setData(QVariant::fromValue<NetworkId>(id));
+ connect(net, SIGNAL(updatedRemotely()), this, SLOT(clientNetworkUpdated()));
+ connect(act, SIGNAL(triggered()), this, SLOT(connectOrDisconnectFromNet()));
+
+ QAction *beforeAction = 0;
+ foreach(QAction *action, _networksMenu->actions()) {
+ if (!action->data().isValid()) // ignore stock actions
+ continue;
+ if (net->networkName().localeAwareCompare(action->text()) < 0) {
+ beforeAction = action;
+ break;
+ }
+ }
+ _networksMenu->insertAction(beforeAction, act);
+}
+
+
+void MainWin::clientNetworkUpdated()
+{
+ const Network *net = qobject_cast<const Network *>(sender());
+ if (!net)
+ return;
+
+ QAction *action = findChild<QAction *>(QString("NetworkAction-%1").arg(net->networkId().toInt()));
+ if (!action)
+ return;
+
+ action->setText(net->networkName());
+
+ switch (net->connectionState()) {
+ case Network::Initialized:
+ action->setIcon(SmallIcon("network-connect"));
+ // if we have no currently selected buffer, jump to the first connecting statusbuffer
+ if (!bufferWidget()->currentBuffer().isValid()) {
+ QModelIndex idx = Client::networkModel()->networkIndex(net->networkId());
+ if (idx.isValid()) {
+ BufferId statusBufferId = idx.data(NetworkModel::BufferIdRole).value<BufferId>();
+ Client::bufferModel()->switchToBuffer(statusBufferId);
+ }
+ }
+ break;
+ case Network::Disconnected:
+ action->setIcon(SmallIcon("network-disconnect"));
+ break;
+ default:
+ action->setIcon(SmallIcon("network-wired"));
+ }
+}
+
+
+void MainWin::clientNetworkRemoved(NetworkId id)
+{
+ QAction *action = findChild<QAction *>(QString("NetworkAction-%1").arg(id.toInt()));
+ if (!action)
+ return;
+
+ action->deleteLater();
+}
+
+
+void MainWin::connectOrDisconnectFromNet()
+{
+ QAction *act = qobject_cast<QAction *>(sender());
+ if (!act) return;
+ const Network *net = Client::network(act->data().value<NetworkId>());
+ if (!net) return;
+ if (net->connectionState() == Network::Disconnected) net->requestConnect();
+ else net->requestDisconnect();
+}
+
+
+void MainWin::on_jumpHotBuffer_triggered()
+{
+ if (!_bufferHotList->rowCount())
+ return;
+
+ QModelIndex topIndex = _bufferHotList->index(0, 0);
+ BufferId bufferId = _bufferHotList->data(topIndex, NetworkModel::BufferIdRole).value<BufferId>();
+ Client::bufferModel()->switchToBuffer(bufferId);
+}
+
+
+void MainWin::onJumpKey()
+{
+ QAction *action = qobject_cast<QAction *>(sender());
+ if (!action || !Client::bufferModel())
+ return;
+ int idx = action->property("Index").toInt();
+
+ if (_jumpKeyMap.isEmpty())
+ _jumpKeyMap = CoreAccountSettings().jumpKeyMap();
+
+ if (!_jumpKeyMap.contains(idx))
+ return;
+
+ BufferId buffer = _jumpKeyMap.value(idx);
+ if (buffer.isValid())
+ Client::bufferModel()->switchToBuffer(buffer);
+}
+
+
+void MainWin::bindJumpKey()
+{
+ QAction *action = qobject_cast<QAction *>(sender());
+ if (!action || !Client::bufferModel())
+ return;
+ int idx = action->property("Index").toInt();
+
+ _jumpKeyMap[idx] = Client::bufferModel()->currentBuffer();
+ CoreAccountSettings().setJumpKeyMap(_jumpKeyMap);
+}
+
+
+void MainWin::on_actionDebugNetworkModel_triggered()
+{
+ QTreeView *view = new QTreeView;
+ view->setAttribute(Qt::WA_DeleteOnClose);
+ view->setWindowTitle("Debug NetworkModel View");
+ view->setModel(Client::networkModel());
+ view->setColumnWidth(0, 250);
+ view->setColumnWidth(1, 250);
+ view->setColumnWidth(2, 80);
+ view->resize(610, 300);
+ view->show();
+}
+
+
+void MainWin::on_actionDebugHotList_triggered()
+{
+ QTreeView *view = new QTreeView;
+ view->setAttribute(Qt::WA_DeleteOnClose);
+ view->setModel(_bufferHotList);
+ view->show();
+}
+
+
+void MainWin::on_actionDebugBufferViewOverlay_triggered()
+{
+ DebugBufferViewOverlay *overlay = new DebugBufferViewOverlay(0);
+ overlay->setAttribute(Qt::WA_DeleteOnClose);
+ overlay->show();
+}
+
+
+void MainWin::on_actionDebugMessageModel_triggered()
+{
+ QTableView *view = new QTableView(0);
+ DebugMessageModelFilter *filter = new DebugMessageModelFilter(view);
+ filter->setSourceModel(Client::messageModel());
+ view->setModel(filter);
+ view->setAttribute(Qt::WA_DeleteOnClose, true);
+ view->verticalHeader()->hide();
+ view->horizontalHeader()->setStretchLastSection(true);
+ view->show();
+}
+
+
+void MainWin::on_actionDebugLog_triggered()
+{
+ DebugLogWidget *logWidget = new DebugLogWidget(0);
+ logWidget->show();
+}
+