+
+void MainWin::connectedToCore()
+{
+ Q_CHECK_PTR(Client::bufferViewManager());
+ connect(Client::bufferViewManager(), SIGNAL(bufferViewConfigAdded(int)), this, SLOT(addBufferView(int)));
+ connect(Client::bufferViewManager(), SIGNAL(bufferViewConfigDeleted(int)), this, SLOT(removeBufferView(int)));
+ connect(Client::bufferViewManager(), SIGNAL(initDone()), this, SLOT(loadLayout()));
+
+ connect(Client::transferManager(), SIGNAL(transferAdded(QUuid)), SLOT(showNewTransferDlg(QUuid)));
+
+ setConnectedState();
+}
+
+
+void MainWin::setConnectedState()
+{
+ ActionCollection *coll = QtUi::actionCollection("General");
+
+ coll->action("ConnectCore")->setEnabled(false);
+ coll->action("DisconnectCore")->setEnabled(true);
+ coll->action("ChangePassword")->setEnabled(true);
+ coll->action("CoreInfo")->setEnabled(true);
+
+ foreach(QAction *action, _fileMenu->actions()) {
+ if (isRemoteCoreOnly(action))
+ action->setVisible(!Client::internalCore());
+ }
+
+ disconnect(Client::backlogManager(), SIGNAL(updateProgress(int, int)), _msgProcessorStatusWidget, SLOT(setProgress(int, int)));
+ disconnect(Client::backlogManager(), SIGNAL(messagesRequested(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ disconnect(Client::backlogManager(), SIGNAL(messagesProcessed(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ if (!Client::internalCore()) {
+ connect(Client::backlogManager(), SIGNAL(updateProgress(int, int)), _msgProcessorStatusWidget, SLOT(setProgress(int, int)));
+ connect(Client::backlogManager(), SIGNAL(messagesRequested(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ connect(Client::backlogManager(), SIGNAL(messagesProcessed(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ }
+
+ // _viewMenu->setEnabled(true);
+ if (!Client::internalCore())
+ statusBar()->showMessage(tr("Connected to core."));
+ else
+ statusBar()->clearMessage();
+
+ _coreConnectionStatusWidget->setVisible(!Client::internalCore());
+ updateIcon();
+ systemTray()->setState(SystemTray::Active);
+
+ if (Client::networkIds().isEmpty()) {
+ IrcConnectionWizard *wizard = new IrcConnectionWizard(this, Qt::Sheet);
+ wizard->show();
+ }
+ else {
+ // Monolithic always preselects last used buffer - Client only if the connection died
+ if (Client::coreConnection()->wasReconnect() || Quassel::runMode() == Quassel::Monolithic) {
+ QtUiSettings s;
+ BufferId lastUsedBufferId(s.value("LastUsedBufferId").toInt());
+ if (lastUsedBufferId.isValid())
+ Client::bufferModel()->switchToBuffer(lastUsedBufferId);
+ }
+ }
+}
+
+
+void MainWin::loadLayout()
+{
+ QtUiSettings s;
+ int accountId = Client::currentCoreAccount().accountId().toInt();
+ QByteArray state = s.value(QString("MainWinState-%1").arg(accountId)).toByteArray();
+ if (state.isEmpty()) {
+ foreach(BufferViewDock *view, _bufferViews)
+ view->show();
+ _layoutLoaded = true;
+ return;
+ }
+ _nickListWidget->setVisible(true);
+ restoreState(state, accountId);
+ int bufferViewId = s.value(QString("ActiveBufferView-%1").arg(accountId), -1).toInt();
+ if (bufferViewId >= 0)
+ changeActiveBufferView(bufferViewId);
+
+ _layoutLoaded = true;
+}
+
+
+void MainWin::saveLayout()
+{
+ QtUiSettings s;
+ int accountId = _bufferViews.count() ? Client::currentCoreAccount().accountId().toInt() : 0; // only save if we still have a layout!
+ if (accountId > 0) {
+ s.setValue(QString("MainWinState-%1").arg(accountId), saveState(accountId));
+ BufferView *view = activeBufferView();
+ s.setValue(QString("ActiveBufferView-%1").arg(accountId), view ? view->config()->bufferViewId() : -1);
+ }
+}
+
+
+void MainWin::disconnectedFromCore()
+{
+ // save core specific layout and remove bufferviews;
+ saveLayout();
+ _layoutLoaded = false;
+
+ QVariant actionData;
+ BufferViewDock *dock;
+ foreach(QAction *action, _bufferViewsMenu->actions()) {
+ actionData = action->data();
+ if (!actionData.isValid())
+ continue;
+
+ dock = qobject_cast<BufferViewDock *>(action->parent());
+ if (dock && actionData.toInt() != -1) {
+ removeAction(action);
+ _bufferViews.removeAll(dock);
+ dock->deleteLater();
+ }
+ }
+
+ // store last active buffer
+ QtUiSettings s;
+ BufferId lastBufId = _bufferWidget->currentBuffer();
+ if (lastBufId.isValid()) {
+ s.setValue("LastUsedBufferId", lastBufId.toInt());
+ // clear the current selection
+ Client::bufferModel()->standardSelectionModel()->clearSelection();
+ }
+ restoreState(s.value("MainWinState").toByteArray());
+ setDisconnectedState();
+}
+
+
+void MainWin::setDisconnectedState()
+{
+ ActionCollection *coll = QtUi::actionCollection("General");
+ //ui.menuCore->setEnabled(false);
+ coll->action("ConnectCore")->setEnabled(true);
+ coll->action("DisconnectCore")->setEnabled(false);
+ coll->action("CoreInfo")->setEnabled(false);
+ coll->action("ChangePassword")->setEnabled(false);
+ //_viewMenu->setEnabled(false);
+ statusBar()->showMessage(tr("Not connected to core."));
+ if (_msgProcessorStatusWidget)
+ _msgProcessorStatusWidget->setProgress(0, 0);
+ updateIcon();
+ systemTray()->setState(SystemTray::Passive);
+ _nickListWidget->setVisible(false);
+}
+
+
+void MainWin::userAuthenticationRequired(CoreAccount *account, bool *valid, const QString &errorMessage)
+{
+ Q_UNUSED(errorMessage)
+ CoreConnectAuthDlg dlg(account, this);
+ *valid = (dlg.exec() == QDialog::Accepted);
+}
+
+
+void MainWin::handleNoSslInClient(bool *accepted)
+{
+ QMessageBox box(QMessageBox::Warning, tr("Unencrypted Connection"), tr("<b>Your client does not support SSL encryption</b>"),
+ QMessageBox::Ignore|QMessageBox::Cancel, this);
+ box.setInformativeText(tr("Sensitive data, like passwords, will be transmitted unencrypted to your Quassel core."));
+ box.setDefaultButton(QMessageBox::Ignore);
+ *accepted = box.exec() == QMessageBox::Ignore;
+}
+
+
+void MainWin::handleNoSslInCore(bool *accepted)
+{
+ QMessageBox box(QMessageBox::Warning, tr("Unencrypted Connection"), tr("<b>Your core does not support SSL encryption</b>"),
+ QMessageBox::Ignore|QMessageBox::Cancel, this);
+ box.setInformativeText(tr("Sensitive data, like passwords, will be transmitted unencrypted to your Quassel core."));
+ box.setDefaultButton(QMessageBox::Ignore);
+ *accepted = box.exec() == QMessageBox::Ignore;
+}
+
+
+#ifdef HAVE_SSL
+
+void MainWin::handleSslErrors(const QSslSocket *socket, bool *accepted, bool *permanently)
+{
+ QString errorString = "<ul>";
+ foreach(const QSslError error, socket->sslErrors())
+ errorString += QString("<li>%1</li>").arg(error.errorString());
+ errorString += "</ul>";
+
+ QMessageBox box(QMessageBox::Warning,
+ tr("Untrusted Security Certificate"),
+ tr("<b>The SSL certificate provided by the core at %1 is untrusted for the following reasons:</b>").arg(socket->peerName()),
+ QMessageBox::Cancel, this);
+ box.setInformativeText(errorString);
+ box.addButton(tr("Continue"), QMessageBox::AcceptRole);
+ box.setDefaultButton(box.addButton(tr("Show Certificate"), QMessageBox::HelpRole));
+
+ QMessageBox::ButtonRole role;
+ do {
+ box.exec();
+ role = box.buttonRole(box.clickedButton());
+ if (role == QMessageBox::HelpRole) {
+ SslInfoDlg dlg(socket, this);
+ dlg.exec();
+ }
+ }
+ while (role == QMessageBox::HelpRole);
+
+ *accepted = role == QMessageBox::AcceptRole;
+ if (*accepted) {
+ QMessageBox box2(QMessageBox::Warning,
+ tr("Untrusted Security Certificate"),
+ tr("Would you like to accept this certificate forever without being prompted?"),
+ 0, this);
+ box2.setDefaultButton(box2.addButton(tr("Current Session Only"), QMessageBox::NoRole));
+ box2.addButton(tr("Forever"), QMessageBox::YesRole);
+ box2.exec();
+ *permanently = box2.buttonRole(box2.clickedButton()) == QMessageBox::YesRole;
+ }
+}
+
+
+#endif /* HAVE_SSL */
+
+void MainWin::handleCoreConnectionError(const QString &error)
+{
+ QMessageBox::critical(this, tr("Core Connection Error"), error, QMessageBox::Ok);
+}
+
+
+void MainWin::showCoreConnectionDlg()
+{
+ CoreConnectDlg dlg(this);
+ if (dlg.exec() == QDialog::Accepted) {
+ AccountId accId = dlg.selectedAccount();
+ if (accId.isValid())
+ Client::coreConnection()->connectToCore(accId);
+ }
+}
+
+
+void MainWin::showCoreConfigWizard(const QVariantList &backends)
+{
+ CoreConfigWizard *wizard = new CoreConfigWizard(Client::coreConnection(), backends, this);
+
+ wizard->show();
+}
+
+
+void MainWin::showChannelList(NetworkId netId)
+{
+ ChannelListDlg *channelListDlg = new ChannelListDlg();
+
+ if (!netId.isValid()) {
+ QAction *action = qobject_cast<QAction *>(sender());
+ if (action)
+ netId = action->data().value<NetworkId>();
+ }
+
+ channelListDlg->setAttribute(Qt::WA_DeleteOnClose);
+ channelListDlg->setNetwork(netId);
+ channelListDlg->show();
+}
+
+
+void MainWin::showIgnoreList(QString newRule)
+{
+ SettingsPageDlg dlg(new IgnoreListSettingsPage(this), this);
+ // prepare config dialog for new rule
+ if (!newRule.isEmpty())
+ qobject_cast<IgnoreListSettingsPage *>(dlg.currentPage())->editIgnoreRule(newRule);
+ dlg.exec();
+}
+
+
+void MainWin::showCoreInfoDlg()
+{
+ CoreInfoDlg(this).exec();
+}
+
+
+void MainWin::showAwayLog()
+{
+ if (_awayLog)
+ return;
+ AwayLogFilter *filter = new AwayLogFilter(Client::messageModel());
+ _awayLog = new AwayLogView(filter, 0);
+ filter->setParent(_awayLog);
+ connect(_awayLog, SIGNAL(destroyed()), this, SLOT(awayLogDestroyed()));
+ _awayLog->setAttribute(Qt::WA_DeleteOnClose);
+ _awayLog->show();
+}
+
+
+void MainWin::awayLogDestroyed()
+{
+ _awayLog = 0;
+}
+
+
+void MainWin::showSettingsDlg()
+{
+ SettingsDlg *dlg = new SettingsDlg();
+
+ //Category: Interface
+ dlg->registerSettingsPage(new AppearanceSettingsPage(dlg));
+ dlg->registerSettingsPage(new ChatViewSettingsPage(dlg));
+ dlg->registerSettingsPage(new ChatViewColorSettingsPage(dlg));
+ dlg->registerSettingsPage(new ChatMonitorSettingsPage(dlg));
+ dlg->registerSettingsPage(new ItemViewSettingsPage(dlg));
+ dlg->registerSettingsPage(new BufferViewSettingsPage(dlg));
+ dlg->registerSettingsPage(new InputWidgetSettingsPage(dlg));
+ dlg->registerSettingsPage(new TopicWidgetSettingsPage(dlg));
+#ifdef HAVE_SONNET
+ dlg->registerSettingsPage(new SonnetSettingsPage(dlg));
+#endif
+ dlg->registerSettingsPage(new HighlightSettingsPage(dlg));
+ dlg->registerSettingsPage(new NotificationsSettingsPage(dlg));
+ dlg->registerSettingsPage(new BacklogSettingsPage(dlg));
+
+ //Category: IRC
+ dlg->registerSettingsPage(new ConnectionSettingsPage(dlg));
+ dlg->registerSettingsPage(new IdentitiesSettingsPage(dlg));
+ dlg->registerSettingsPage(new NetworksSettingsPage(dlg));
+ dlg->registerSettingsPage(new AliasesSettingsPage(dlg));
+ dlg->registerSettingsPage(new IgnoreListSettingsPage(dlg));
+
+ // Category: Remote Cores
+ if (Quassel::runMode() != Quassel::Monolithic) {
+ dlg->registerSettingsPage(new CoreAccountSettingsPage(dlg));
+ dlg->registerSettingsPage(new CoreConnectionSettingsPage(dlg));
+ }
+
+ dlg->show();
+}
+
+
+void MainWin::showAboutDlg()
+{
+ AboutDlg(this).exec();
+}
+
+
+void MainWin::showShortcutsDlg()
+{
+#ifdef HAVE_KDE
+ KShortcutsDialog dlg(KShortcutsEditor::AllActions, KShortcutsEditor::LetterShortcutsDisallowed, this);
+ foreach(KActionCollection *coll, QtUi::actionCollections())
+ dlg.addCollection(coll, coll->property("Category").toString());
+ dlg.configure(true);
+#else
+ SettingsPageDlg dlg(new ShortcutsSettingsPage(QtUi::actionCollections(), this), this);
+ dlg.exec();
+#endif
+}
+
+
+void MainWin::showNewTransferDlg(const QUuid &transferId)
+{
+ auto transfer = Client::transferManager()->transfer(transferId);
+ if (transfer) {
+ ReceiveFileDlg *dlg = new ReceiveFileDlg(transfer, this);
+ dlg->show();
+ }
+ else {
+ qWarning() << "Unknown transfer ID" << transferId;
+ }
+}
+
+
+void MainWin::onFullScreenToggled()
+{
+ // Relying on QWidget::isFullScreen is discouraged, see the KToggleFullScreenAction docs
+ // Also, one should not use showFullScreen() or showNormal(), as those reset all other window flags
+
+#ifdef HAVE_KDE
+ static_cast<KToggleFullScreenAction*>(_fullScreenAction)->setFullScreen(this, _fullScreenAction->isChecked());
+#else
+ if (_fullScreenAction->isChecked())
+ setWindowState(windowState() | Qt::WindowFullScreen);
+ else
+ setWindowState(windowState() & ~Qt::WindowFullScreen);
+#endif
+}
+
+
+/********************************************************************************************************/
+
+bool MainWin::event(QEvent *event)
+{
+ switch(event->type()) {
+ case QEvent::WindowActivate: {
+ BufferId bufferId = Client::bufferModel()->currentBuffer();
+ if (bufferId.isValid())
+ Client::instance()->markBufferAsRead(bufferId);
+ break;
+ }
+ case QEvent::WindowDeactivate:
+ if (bufferWidget()->autoMarkerLineOnLostFocus())
+ bufferWidget()->setMarkerLine();
+ break;
+ default:
+ break;
+ }
+ 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);
+ // On OSX it can happen that the closeEvent occurs twice. (Especially if packaged with Frameworks)
+ // This messes up MainWinState/MainWinHidden save/restore.
+ // It's a bug in Qt: https://bugreports.qt.io/browse/QTBUG-43344
+ if (!_aboutToQuit && !app->isAboutToQuit() && QtUi::haveSystemTray() && s.value("MinimizeOnClose").toBool()) {
+ QtUi::hideMainWidget();