File indexing completed on 2024-04-21 04:58:20

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 2008 Eduardo Robles Elvira <edulix@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "konqsessionmanager.h"
 #include "konqmisc.h"
 #include "konqmainwindow.h"
 #include "konqsessionmanager_interface.h"
 #include "konqsessionmanageradaptor.h"
 #include "konqviewmanager.h"
 #include "konqsettingsxt.h"
 
 #ifdef KActivities_FOUND
 #include "activitymanager.h"
 #if QT_VERSION_MAJOR < 6
 #include <KActivities/Consumer>
 #else //QT_VERSION_MAJOR
 #include <PlasmaActivities/Consumer>
 #endif //QT_VERSION_MAJOR
 #endif //KActivities_FOUND
 
 #include "konqdebug.h"
 #include <kio/deletejob.h>
 #include <KLocalizedString>
 #include <KWindowInfo>
 #include <KX11Extras>
 
 #include <QUrl>
 #include <QIcon>
 #include <ksqueezedtextlabel.h>
 
 #include <QPushButton>
 #include <QCheckBox>
 #include <QFileInfo>
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QtAlgorithms>
 #include <QDirIterator>
 #include <QDir>
 #include <QFile>
 #include <QSize>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QTreeWidget>
 #include <QScrollBar>
 #include <QApplication>
 #include <QStandardPaths>
 #include <QSessionManager>
 #include <KConfigGroup>
 #include <QDialogButtonBox>
 #include <KGuiItem>
 #include <QScreen>
 #include <KSharedConfig>
 
 #include "konqapplication.h"
 #include <QMessageBox>
 
 class KonqSessionManagerPrivate
 {
 public:
     KonqSessionManagerPrivate()
         : instance(nullptr)
     {
     }
 
     ~KonqSessionManagerPrivate()
     {
         delete instance;
     }
 
     KonqSessionManager *instance;
 };
 
 Q_GLOBAL_STATIC(KonqSessionManagerPrivate, myKonqSessionManagerPrivate)
 
 static QString viewIdFor(const QString &sessionFile, const QString &viewId)
 {
     return (sessionFile + viewId);
 }
 
 static const QList<KConfigGroup> windowConfigGroups(/*NOT const, we'll use writeEntry*/ KConfig &config)
 {
     QList<KConfigGroup> groups;
     KConfigGroup generalGroup(&config, "General");
     const int size = generalGroup.readEntry("Number of Windows", 0);
     for (int i = 0; i < size; i++) {
         groups << KConfigGroup(&config, "Window" + QString::number(i));
     }
     return groups;
 }
 
 SessionRestoreDialog::SessionRestoreDialog(const QStringList &sessionFilePaths, QWidget *parent)
     : QDialog(parent)
     , m_sessionItemsCount(0)
     , m_dontShowChecked(false)
 {
     setObjectName(QStringLiteral("restoresession"));
     setWindowTitle(i18nc("@title:window", "Restore Session?"));
     setModal(true);
 
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
 
     QHBoxLayout *hLayout = new QHBoxLayout();
     hLayout->setContentsMargins(0, 0, 0, 0);
     mainLayout->addLayout(hLayout, 5);
 
     QIcon icon = QIcon::fromTheme(QLatin1String("dialog-warning"));
     if (!icon.isNull()) {
         QLabel *iconLabel = new QLabel(this);
         iconLabel->setPixmap(icon.pixmap(style()->pixelMetric(QStyle::PM_MessageBoxIconSize)));
         QVBoxLayout *iconLayout = new QVBoxLayout();
         iconLayout->addStretch(1);
         iconLayout->addWidget(iconLabel);
         iconLayout->addStretch(5);
         hLayout->addLayout(iconLayout, 0);
         hLayout->addSpacing(style()->pixelMetric(QStyle::PM_LayoutHorizontalSpacing));
     }
 
     const QString text(i18n("Konqueror did not close correctly. Would you like to restore these previous sessions?"));
     QLabel *messageLabel = new QLabel(text, this);
     Qt::TextInteractionFlags flags = (Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
     messageLabel->setTextInteractionFlags(flags);
     messageLabel->setWordWrap(true);
 
     hLayout->addWidget(messageLabel, 5);
 
     Q_ASSERT(!sessionFilePaths.isEmpty());
     m_treeWidget = new QTreeWidget(this);
     m_treeWidget->setHeader(nullptr);
     m_treeWidget->setHeaderHidden(true);
     m_treeWidget->setToolTip(i18nc("@tooltip:session list", "Uncheck the sessions you do not want to be restored"));
 
     QStyleOptionViewItem styleOption;
     styleOption.initFrom(m_treeWidget);
     QFontMetrics fm(styleOption.font);
     int w = m_treeWidget->width();
     const QRect desktop = screen()->geometry();
 
     // Collect info from the sessions to restore
     for (const QString &sessionFile: sessionFilePaths) {
         qCDebug(KONQUEROR_LOG) << sessionFile;
         QTreeWidgetItem *windowItem = nullptr;
         KConfig config(sessionFile, KConfig::SimpleConfig);
         const QList<KConfigGroup> groups = windowConfigGroups(config);
         for (const KConfigGroup &group: groups) {
             // To avoid a recursive search, let's do linear search on Foo_CurrentHistoryItem=1
             for (const QString &key: group.keyList()) {
                 if (key.endsWith(QLatin1String("_CurrentHistoryItem"))) {
                     const QString viewId = key.left(key.length() - qstrlen("_CurrentHistoryItem"));
                     const QString historyIndex = group.readEntry(key, QString());
                     const QString prefix = "HistoryItem" + viewId + '_' + historyIndex;
                     // Ignore the sidebar views
                     if (group.readEntry(prefix + "StrServiceName", QString()).startsWith(QLatin1String("konq_sidebar"))) {
                         continue;
                     }
                     const QString url = group.readEntry(prefix + "Url", QString());
                     const QString title = group.readEntry(prefix + "Title", QString());
                     qCDebug(KONQUEROR_LOG) << viewId << url << title;
                     const QString displayText = (title.trimmed().isEmpty() ? url : title);
                     if (!displayText.isEmpty()) {
                         if (!windowItem) {
                             windowItem = new QTreeWidgetItem(m_treeWidget);
                             const int index = sessionFilePaths.indexOf(sessionFile) + 1;
                             windowItem->setText(0, i18nc("@item:treewidget", "Window %1", index));
                             windowItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
                             windowItem->setCheckState(0, Qt::Checked);
                             windowItem->setExpanded(true);
                         }
                         QTreeWidgetItem *item = new QTreeWidgetItem(windowItem);
                         item->setText(0, displayText);
                         item->setData(0, Qt::UserRole, viewIdFor(sessionFile, viewId));
                         item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
                         item->setCheckState(0, Qt::Checked);
                         w = qMax(w, fm.horizontalAdvance(displayText));
                         m_sessionItemsCount++;
                     }
                 }
             }
         }
 
         if (windowItem) {
             m_checkedSessionItems.insert(windowItem, windowItem->childCount());
         }
     }
 
     const int borderWidth = m_treeWidget->width() - m_treeWidget->viewport()->width() + m_treeWidget->verticalScrollBar()->height();
     w += borderWidth;
     if (w > desktop.width() * 0.85) { // limit treeWidget size to 85% of screen width
         w = qRound(desktop.width() * 0.85);
     }
     m_treeWidget->setMinimumWidth(w);
     mainLayout->addWidget(m_treeWidget, 50);
     m_treeWidget->setSelectionMode(QTreeWidget::NoSelection);
     messageLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
 
     // Do not connect the itemChanged signal until after the treewidget
     // is completely populated to prevent the firing of the itemChanged
     // signal while in the process of adding the original session items.
     connect(m_treeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
             this, SLOT(slotItemChanged(QTreeWidgetItem*,int)));
 
     QCheckBox *checkbox = new QCheckBox(i18n("Do not ask again"), this);
     connect(checkbox, &QCheckBox::clicked, this, &SessionRestoreDialog::slotClicked);
     mainLayout->addWidget(checkbox);
 
     m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel|QDialogButtonBox::No|QDialogButtonBox::Yes);
     mainLayout->addWidget(m_buttonBox);
     QPushButton *yesButton = m_buttonBox->button(QDialogButtonBox::Yes);
     QPushButton *noButton = m_buttonBox->button(QDialogButtonBox::No);
     QPushButton *cancelButton = m_buttonBox->button(QDialogButtonBox::Cancel);
 
     connect(yesButton, &QPushButton::clicked, this, [this]() { done(QDialogButtonBox::Yes); });
     connect(noButton, &QPushButton::clicked, this, [this]() { done(QDialogButtonBox::No); });
     connect(cancelButton, &QPushButton::clicked, this, [this]() { reject(); });
 
     KGuiItem::assign(yesButton, KGuiItem(i18nc("@action:button yes", "Restore Session"), QStringLiteral("window-new")));
     KGuiItem::assign(noButton, KGuiItem(i18nc("@action:button no", "Do Not Restore"), QStringLiteral("dialog-close")));
     KGuiItem::assign(cancelButton, KGuiItem(i18nc("@action:button ask later", "Ask Me Later"), QStringLiteral("chronometer")));
 
     yesButton->setDefault(true);
     yesButton->setFocus();
 }
 
 SessionRestoreDialog::~SessionRestoreDialog()
 {
 }
 
 bool SessionRestoreDialog::isEmpty() const
 {
     return m_treeWidget->topLevelItemCount() == 0;
 }
 
 QStringList SessionRestoreDialog::discardedSessionList() const
 {
     return m_discardedSessionList;
 }
 
 bool SessionRestoreDialog::isDontShowChecked() const
 {
     return m_dontShowChecked;
 }
 
 void SessionRestoreDialog::slotClicked(bool checked)
 {
     m_dontShowChecked = checked;
 }
 
 void SessionRestoreDialog::slotItemChanged(QTreeWidgetItem *item, int column)
 {
     Q_ASSERT(item);
 
     const int itemChildCount = item->childCount();
     QTreeWidgetItem *parentItem = nullptr;
 
     const bool blocked = item->treeWidget()->blockSignals(true);
     if (itemChildCount > 0) {
         parentItem = item;
         for (int i = 0; i < itemChildCount; ++i) {
             QTreeWidgetItem *childItem = item->child(i);
             if (childItem) {
                 childItem->setCheckState(column, item->checkState(column));
                 switch (childItem->checkState(column)) {
                 case Qt::Checked:
                     m_sessionItemsCount++;
                     m_discardedSessionList.removeAll(childItem->data(column, Qt::UserRole).toString());
                     m_checkedSessionItems[item]++;
                     break;
                 case Qt::Unchecked:
                     m_sessionItemsCount--;
                     m_discardedSessionList.append(childItem->data(column, Qt::UserRole).toString());
                     m_checkedSessionItems[item]--;
                     break;
                 default:
                     break;
                 }
             }
         }
     } else {
         parentItem = item->parent();
         switch (item->checkState(column)) {
         case Qt::Checked:
             m_sessionItemsCount++;
             m_discardedSessionList.removeAll(item->data(column, Qt::UserRole).toString());
             m_checkedSessionItems[parentItem]++;
             break;
         case Qt::Unchecked:
             m_sessionItemsCount--;
             m_discardedSessionList.append(item->data(column, Qt::UserRole).toString());
             m_checkedSessionItems[parentItem]--;
             break;
         default:
             break;
         }
     }
 
     const int numCheckSessions = m_checkedSessionItems.value(parentItem);
     switch (parentItem->checkState(column)) {
     case Qt::Checked:
         if (numCheckSessions == 0) {
             parentItem->setCheckState(column, Qt::Unchecked);
         }
         break;
     case Qt::Unchecked:
         if (numCheckSessions > 0) {
             parentItem->setCheckState(column, Qt::Checked);
         }
     default:
         break;
     }
 
     m_buttonBox->button(QDialogButtonBox::Yes)->setEnabled(m_sessionItemsCount>0);
     item->treeWidget()->blockSignals(blocked);
 }
 
 void SessionRestoreDialog::saveDontShow(const QString &dontShowAgainName, int result)
 {
     if (dontShowAgainName.isEmpty()) {
         return;
     }
 
     KConfigGroup::WriteConfigFlags flags = KConfig::Persistent;
     if (dontShowAgainName[0] == ':') {
         flags |= KConfigGroup::Global;
     }
 
     KConfigGroup cg(KSharedConfig::openConfig().data(), "Notification Messages");
     cg.writeEntry(dontShowAgainName, result == QDialogButtonBox::Yes, flags);
     cg.sync();
 }
 
 bool SessionRestoreDialog::shouldBeShown(const QString &dontShowAgainName, int *result)
 {
     if (dontShowAgainName.isEmpty()) {
         return true;
     }
 
     KConfigGroup cg(KSharedConfig::openConfig().data(), "Notification Messages");
     const QString dontAsk = cg.readEntry(dontShowAgainName, QString()).toLower();
 
     if (dontAsk == QLatin1String("yes") || dontAsk == QLatin1String("true")) {
         if (result) {
             *result = QDialogButtonBox::Yes;
         }
         return false;
     }
 
     if (dontAsk == QLatin1String("no") || dontAsk == QLatin1String("false")) {
         if (result) {
             *result = QDialogButtonBox::No;
         }
         return false;
     }
 
     return true;
 }
 
 KonqSessionManager::KonqSessionManager()
     : m_autosaveDir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QLatin1Char('/') + "autosave")
     , m_autosaveEnabled(false) // so that enableAutosave works
     , m_createdOwnedByDir(false)
     , m_sessionConfig(nullptr)
 #ifdef KActivities_FOUND
     , m_activityManager(new ActivityManager(this))
 #endif
 {
     // Initialize dbus interfaces
     new KonqSessionManagerAdaptor(this);
 
     const QString dbusPath = QStringLiteral("/KonqSessionManager");
     const QString dbusInterface = QStringLiteral("org.kde.Konqueror.SessionManager");
 
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(dbusPath, this);
     m_baseService = KonqMisc::encodeFilename(dbus.baseService());
     dbus.connect(QString(), dbusPath, dbusInterface, QStringLiteral("saveCurrentSession"), this, SLOT(slotSaveCurrentSession(QString)));
 
     // Initialize the timer
     const int interval = KonqSettings::autoSaveInterval();
     if (interval > 0) {
         m_autoSaveTimer.setInterval(interval * 1000);
         connect(&m_autoSaveTimer, &QTimer::timeout, this, &KonqSessionManager::autoSaveSession);
     }
     enableAutosave();
 
     connect(qApp, &QGuiApplication::commitDataRequest, this, &KonqSessionManager::slotCommitData);
     connect(qApp, &QGuiApplication::lastWindowClosed, this, &KonqSessionManager::saveSessionAtExit);
 }
 
 KonqSessionManager::~KonqSessionManager()
 {
     if (m_sessionConfig) {
         QFile::remove(m_sessionConfig->name());
     }
     delete m_sessionConfig;
 }
 
 void KonqSessionManager::restoreSessionSavedAtLogout()
 {
     askUserToRestoreAutosavedAbandonedSessions();
 
     m_preloadedWindowsNumber.clear();
     int n = 1;
     while (KonqMainWindow::canBeRestored(n)) {
         const QString className = KXmlGuiWindow::classNameOfToplevel(n);
 
         //The !m_preloadedWindowsNumber.contains(n) check avoid restoring preloaded windows
         if (className == QLatin1String("KonqMainWindow") && !m_preloadedWindowsNumber.contains(n)) {
             KonqMainWindow * mw = new KonqMainWindow();
             mw->restore(n);
 
             //m_preloadedWindowsNumber is set from the readGlobalProperties of the first (n==1) window.
             //This means that the first window is always restored, even if it was preloaded (because readGlobalProperties
             //is called from restore). For the first window, we need to check whether it was preloaded, and in that case
             //delete it afterwards
             if (n == 1 && m_preloadedWindowsNumber.contains(1)) {
                 mw->deleteLater();
             }
         } else  {
             qCWarning(KONQUEROR_LOG) << "Unknown class" << className << "in session saved data!";
         }
         ++n;
     }
     m_preloadedWindowsNumber.clear();
 }
 
 
 // Don't restore preloaded konquerors
 void KonqSessionManager::slotCommitData(QSessionManager &sm)
 {
     QList<KonqMainWindow*> const *windows = KonqMainWindow::mainWindowList();
     if (std::all_of(windows->constBegin(), windows->constEnd(), [](KonqMainWindow *w){return w->isPreloaded();})) {
         sm.setRestartHint(QSessionManager::RestartNever);
     }
 }
 
 void KonqSessionManager::disableAutosave()
 {
     if (!m_autosaveEnabled) {
         return;
     }
 
     m_autosaveEnabled = false;
     m_autoSaveTimer.stop();
     if (m_sessionConfig) {
         QFile::remove(m_sessionConfig->name());
         delete m_sessionConfig;
         m_sessionConfig = nullptr;
     }
 }
 
 void KonqSessionManager::enableAutosave()
 {
     if (m_autosaveEnabled) {
         return;
     }
 
     // Create the config file for autosaving current session
     QString filename = QLatin1String("autosave/") + m_baseService;
     const QString filePath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QLatin1Char('/') + filename;
 
     delete m_sessionConfig;
     m_sessionConfig = new KConfig(filePath, KConfig::SimpleConfig);
     //qCDebug(KONQUEROR_LOG) << "config filename:" << m_sessionConfig->name();
 
     m_autosaveEnabled = true;
     m_autoSaveTimer.start();
 }
 
 void KonqSessionManager::deleteOwnedSessions()
 {
     // Not dealing with the sessions about to remove anymore
     if (m_createdOwnedByDir && QDir(dirForMyOwnedSessionFiles()).removeRecursively()) {
         m_createdOwnedByDir = false;
     }
 }
 
 KonqSessionManager *KonqSessionManager::self()
 {
     if (!myKonqSessionManagerPrivate->instance) {
         myKonqSessionManagerPrivate->instance = new KonqSessionManager();
     }
 
     return myKonqSessionManagerPrivate->instance;
 }
 
 void KonqSessionManager::autoSaveSession()
 {
     if (!m_autosaveEnabled) {
         return;
     }
 
     const bool isActive = m_autoSaveTimer.isActive();
     if (isActive) {
         m_autoSaveTimer.stop();
     }
 
     saveCurrentSessionToFile(m_sessionConfig);
     m_sessionConfig->sync();
     m_sessionConfig->markAsClean();
 
     // Now that we have saved current session it's safe to remove our owned_by
     // directory
     deleteOwnedSessions();
 
     if (isActive) {
         m_autoSaveTimer.start();
     }
 }
 
 void KonqSessionManager::saveCurrentSessions(const QString &path)
 {
     emit saveCurrentSession(path);
 }
 
 void KonqSessionManager::slotSaveCurrentSession(const QString &path)
 {
     const QString filename = path + '/' + m_baseService;
     saveCurrentSessionToFile(filename);
 }
 
 void KonqSessionManager::saveCurrentSessionToFile(const QString &sessionConfigPath, KonqMainWindow *mainWindow)
 {
     QFile::remove(sessionConfigPath);
     KConfig config(sessionConfigPath, KConfig::SimpleConfig);
 
     QList<KonqMainWindow *> mainWindows;
     if (mainWindow) {
         mainWindows << mainWindow;
     }
     saveCurrentSessionToFile(&config, mainWindows);
 }
 
 void KonqSessionManager::saveCurrentSessionToFile(KConfig *config, const QList<KonqMainWindow *> &theMainWindows)
 {
     QList<KonqMainWindow *> mainWindows = theMainWindows;
 
     if (mainWindows.isEmpty() && KonqMainWindow::mainWindowList()) {
         mainWindows = *KonqMainWindow::mainWindowList();
     }
 
     unsigned int counter = 0;
 
     if (mainWindows.isEmpty()) {
         return;
     }
 
     for (KonqMainWindow *window: mainWindows) {
         if (!window->isPreloaded()) {
             KConfigGroup configGroup(config, "Window" + QString::number(counter));
             window->saveProperties(configGroup);
             KWindowInfo info(window->winId(), NET::Properties(), NET::WM2Activities);
             configGroup.writeEntry("Activities", info.activities());
             counter++;
         }
     }
 
     KConfigGroup configGroup(config, "General");
     configGroup.writeEntry("Number of Windows", counter);
 }
 
 void KonqSessionManager::saveSessionAtExit()
 {
     if (qApp->isSavingSession()) {
         return;
     }
     bool saveSessions = KSharedConfig::openConfig()->group(QStringLiteral("UserSettings")).readEntry(QStringLiteral("RestoreLastState"), false);
     if (!saveSessions) {
         return;
     }
     QString path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
     if (!path.isEmpty()) {
         const QList<KonqMainWindow*> windows = KonqMainWindow::mainWindows();
         if (windows.count() == 1 && windows.at(0)->isPreloaded())  {
             return;
         }
         saveCurrentSessionToFile(QDir(path).absoluteFilePath("last_session"));
     }
 }
 
 QString KonqSessionManager::autosaveDirectory() const
 {
     return m_autosaveDir;
 }
 
 QStringList KonqSessionManager::takeSessionsOwnership()
 {
     // Tell to other konqueror instances that we are the one dealing with
     // these sessions
     QDir dir(dirForMyOwnedSessionFiles());
     QDir parentDir(m_autosaveDir);
 
     if (!dir.exists()) {
         m_createdOwnedByDir = parentDir.mkdir("owned_by" + m_baseService);
     }
 
     QDirIterator it(m_autosaveDir, QDir::Writable | QDir::Files | QDir::Dirs |
                     QDir::NoDotAndDotDot);
 
     QStringList sessionFilePaths;
     QDBusConnectionInterface *idbus = QDBusConnection::sessionBus().interface();
 
     while (it.hasNext()) {
         it.next();
         // this is the case where another konq started to restore that session,
         // but crashed immediately. So we try to restore that session again
         if (it.fileInfo().isDir()) {
             // The remove() removes the "owned_by" part
             if (!idbus->isServiceRegistered(
                         KonqMisc::decodeFilename(it.fileName().remove(0, 8)))) {
                 QDirIterator it2(it.filePath(), QDir::Writable | QDir::Files);
                 while (it2.hasNext()) {
                     it2.next();
                     // take ownership of the abandoned file
                     const QString newFileName = dirForMyOwnedSessionFiles() +
                                                 '/' + it2.fileName();
                     QFile::rename(it2.filePath(), newFileName);
                     sessionFilePaths.append(newFileName);
                 }
                 // Remove the old directory
                 QDir(it.filePath()).removeRecursively();
             }
         } else { // it's a file
             if (!idbus->isServiceRegistered(KonqMisc::decodeFilename(it.fileName()))) {
                 // and it's abandoned: take its ownership
                 const QString newFileName = dirForMyOwnedSessionFiles() + '/' +
                                             it.fileName();
                 QFile::rename(it.filePath(), newFileName);
                 sessionFilePaths.append(newFileName);
             }
         }
     }
 
     return sessionFilePaths;
 }
 
 void KonqSessionManager::restoreSessions(const QStringList &sessionFilePathsList,
         bool openTabsInsideCurrentWindow, KonqMainWindow *parent)
 {
     for (const QString &sessionFilePath: sessionFilePathsList) {
         restoreSession(sessionFilePath, openTabsInsideCurrentWindow, parent);
     }
 }
 
 void KonqSessionManager::restoreSessions(const QString &sessionsDir, bool
         openTabsInsideCurrentWindow, KonqMainWindow *parent)
 {
     QDirIterator it(sessionsDir, QDir::Readable | QDir::Files);
 
     while (it.hasNext()) {
         QFileInfo fi(it.next());
         restoreSession(fi.filePath(), openTabsInsideCurrentWindow, parent);
     }
 }
 
 void KonqSessionManager::restoreSession(const QString &sessionFilePath, bool
                                         openTabsInsideCurrentWindow, KonqMainWindow *parent)
 {
     if (!QFile::exists(sessionFilePath)) {
         return;
     }
 
     KConfig config(sessionFilePath, KConfig::SimpleConfig);
     const QList<KConfigGroup> groups = windowConfigGroups(config);
     for (const KConfigGroup &configGroup: groups) {
         if (!openTabsInsideCurrentWindow) {
             KonqViewManager::openSavedWindow(configGroup)->show();
         } else {
             parent->viewManager()->openSavedWindow(configGroup, true);
         }
     }
 }
 
 bool KonqSessionManager::restoreSessionSavedAtExit()
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(QStringLiteral("UserSettings"));
     if (!grp.readEntry(QStringLiteral("RestoreLastState"), false)) {
         return false;
     }
 
     QString lastSessionPath = QStandardPaths::locate(QStandardPaths::AppDataLocation, QStringLiteral("last_session"));
     if (lastSessionPath.isEmpty()) {
         return false;
     }
 
     restoreSession(lastSessionPath);
     QFile(lastSessionPath).remove();
 
     return !KonqMainWindow::mainWindows().isEmpty();
 }
 
 static void removeDiscardedSessions(const QStringList &sessionFiles, const QStringList &discardedSessions)
 {
     if (discardedSessions.isEmpty()) {
         return;
     }
 
     for (const QString &sessionFile: sessionFiles) {
         KConfig config(sessionFile, KConfig::SimpleConfig);
         QList<KConfigGroup> groups = windowConfigGroups(config);
         for (int i = 0, count = groups.count(); i < count; ++i) {
             KConfigGroup &group = groups[i];
             const QString rootItem = group.readEntry("RootItem", "empty");
             const QString viewsKey(rootItem + QLatin1String("_Children"));
             QStringList views = group.readEntry(viewsKey, QStringList());
             QMutableStringListIterator it(views);
             while (it.hasNext()) {
                 if (discardedSessions.contains(viewIdFor(sessionFile, it.next()))) {
                     it.remove();
                 }
             }
             group.writeEntry(viewsKey, views);
         }
     }
 }
 
 bool KonqSessionManager::askUserToRestoreAutosavedAbandonedSessions()
 {
     const QStringList sessionFilePaths = takeSessionsOwnership();
     if (sessionFilePaths.isEmpty()) {
         return false;
     }
 
     disableAutosave();
 
     int result;
     QStringList discardedSessionList;
     const QLatin1String dontAskAgainName("Restore session when konqueror didn't close correctly");
 
     if (SessionRestoreDialog::shouldBeShown(dontAskAgainName, &result)) {
         SessionRestoreDialog *restoreDlg = new SessionRestoreDialog(sessionFilePaths);
         if (restoreDlg->isEmpty()) {
             result = QDialogButtonBox::No;
         } else {
             result = restoreDlg->exec();
             discardedSessionList = restoreDlg->discardedSessionList();
             if (restoreDlg->isDontShowChecked()) {
                 SessionRestoreDialog::saveDontShow(dontAskAgainName, result);
             }
         }
         delete restoreDlg;
     }
 
     switch (result) {
     case QDialogButtonBox::Yes:
         // Remove the discarded session list files.
         removeDiscardedSessions(sessionFilePaths, discardedSessionList);
         restoreSessions(sessionFilePaths);
         enableAutosave();
         return true;
     case QDialogButtonBox::No:
         deleteOwnedSessions();
         enableAutosave();
         return false;
     default:
         // Remove the ownership of the currently owned files
         QDirIterator it(dirForMyOwnedSessionFiles(),
                         QDir::Writable | QDir::Files);
 
         while (it.hasNext()) {
             it.next();
             // remove ownership of the abandoned file
             QFile::rename(it.filePath(), m_autosaveDir + '/' + it.fileName());
         }
         // Remove the owned_by directory
         QDir(dirForMyOwnedSessionFiles()).removeRecursively();
         enableAutosave();
         return false;
     }
 }
 
 void KonqSessionManager::setPreloadedWindowsNumber(const QList<int> &numbers)
 {
     m_preloadedWindowsNumber = numbers;
 }
 
 void KonqSessionManager::registerMainWindow(KonqMainWindow* window)
 {
 #ifdef KActivities_FOUND
     m_activityManager->registerMainWindow(window);
 #else
     Q_UNUSED(window);
 #endif
 }
 
 #ifdef KActivities_FOUND
 ActivityManager * KonqSessionManager::activityManager()
 {
     return m_activityManager;
 }
 #endif