kde/dolphin
kde/dolphin
1
0
Fork 0
mirror of https://invent.kde.org/system/dolphin synced 2024-09-20 00:41:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "In the session restore dialog, allow the user to select which sessions should"

Browse source 
Not meant for 4.9.
CCBUG: 260282

This reverts commit a78c6a50dc.
This commit is contained in:
Pino Toscano 2012-10-12 13:12:28 +02:00
parent a78c6a50dc
commit ac70302ee0
2 changed files with 56 additions and 387 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

392
konqueror/src/konqsessionmanager.cpp
View file

@ -33,14 +33,12 @@
#include <kvbox.h>
#include <khbox.h>
#include <klocale.h>
#include <kdialog.h>
#include <kmessagebox.h>
#include <kurl.h>
#include <ktempdir.h>
#include <ksqueezedtextlabel.h>
#include <QPushButton>
#include <QCheckBox>
#include <QFileInfo>
#include <QtCore/QFileInfo>
#include <QPoint>
#include <QtDBus/QtDBus>
#include <QtAlgorithms>
@ -49,12 +47,6 @@
#include <QDBusArgument>
#include <QFile>
#include <QSize>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QTreeWidget>
#include <QScrollArea>
#include <QScrollBar>
class KonqSessionManagerPrivate
{
@ -74,291 +66,8 @@ public:
K_GLOBAL_STATIC(KonqSessionManagerPrivate, myKonqSessionManagerPrivate)
static QString viewIdFor(const QString& sessionFile, const QString& viewId)
{
return (sessionFile + viewId);
}
static const QList<KConfigGroup> windowConfigGroups(const 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)
: KDialog(parent, 0)
,m_sessionItemsCount(0)
,m_dontShowChecked(false)
{
setCaption(i18nc("@title:window", "Restore Session?"));
setButtons(KDialog::Yes | KDialog::No | KDialog::Cancel);
setObjectName(QLatin1String("restoresession"));
setButtonGuiItem(KDialog::Yes, KGuiItem(i18nc("@action:button yes", "Restore Session"), "window-new"));
setButtonGuiItem(KDialog::No, KGuiItem(i18nc("@action:button no","Do Not Restore"), "dialog-close"));
setButtonGuiItem(KDialog::Cancel, KGuiItem(i18nc("@action:button ask later","Ask Me Later"), "chronometer"));
setDefaultButton(KDialog::Yes);
setButtonFocus(KDialog::Yes);
setModal(true);
QWidget *mainWidget = new QWidget(this);
QVBoxLayout *mainLayout = new QVBoxLayout(mainWidget);
mainLayout->setSpacing(KDialog::spacingHint() * 2); // provide extra spacing
mainLayout->setMargin(0);
QHBoxLayout *hLayout = new QHBoxLayout();
hLayout->setMargin(0);
hLayout->setSpacing(-1); // use default spacing
mainLayout->addLayout(hLayout,5);
KIcon icon (QLatin1String("dialog-warning"));
if (!icon.isNull()) {
QLabel *iconLabel = new QLabel(mainWidget);
QStyleOption option;
option.initFrom(mainWidget);
iconLabel->setPixmap(icon.pixmap(mainWidget->style()->pixelMetric(QStyle::PM_MessageBoxIconSize, &option, mainWidget)));
QVBoxLayout *iconLayout = new QVBoxLayout();
iconLayout->addStretch(1);
iconLayout->addWidget(iconLabel);
iconLayout->addStretch(5);
hLayout->addLayout(iconLayout,0);
}
const QString text (i18n("Konqueror did not close correctly. Would you like to restore these previous sessions?"));
QLabel *messageLabel = new QLabel(text, mainWidget);
Qt::TextInteractionFlags flags = (Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
messageLabel->setTextInteractionFlags(flags);
messageLabel->setWordWrap(true);
hLayout->addSpacing(KDialog::spacingHint());
hLayout->addWidget(messageLabel,5);
QTreeWidget* treeWidget = 0;
if (!sessionFilePaths.isEmpty()) {
treeWidget = new QTreeWidget(mainWidget);
treeWidget->setHeader(0);
treeWidget->setHeaderHidden(true);
treeWidget->setToolTip(i18nc("@tooltip:session list", "Uncheck the sessions you do not want to be restored"));
QStyleOptionViewItem styleOption;
styleOption.initFrom(treeWidget);
QFontMetrics fm(styleOption.font);
int w = treeWidget->width();
const QRect desktop = KGlobalSettings::desktopGeometry(this);
// Collect info from the sessions to restore
Q_FOREACH(const QString& sessionFile, sessionFilePaths) {
kDebug() << sessionFile;
QTreeWidgetItem* windowItem = 0;
const KConfig config(sessionFile, KConfig::SimpleConfig);
const QList<KConfigGroup> groups = windowConfigGroups(config);
Q_FOREACH(const KConfigGroup& group, groups) {
// To avoid a recursive search, let's do linear search on Foo_CurrentHistoryItem=1
Q_FOREACH(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("konq_sidebar"))
continue;
const QString url = group.readEntry(prefix + "Url", QString());
const QString title = group.readEntry(prefix + "Title", QString());
kDebug() << viewId << url << title;
const QString displayText = (title.trimmed().isEmpty() ? url : title);
if (!displayText.isEmpty()) {
if (!windowItem) {
windowItem = new QTreeWidgetItem(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.width(displayText));
m_sessionItemsCount++;
}
}
}
}
if (windowItem) {
m_checkedSessionItems.insert(windowItem, windowItem->childCount());
}
}
const int borderWidth = treeWidget->width() - treeWidget->viewport()->width() + 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);
}
treeWidget->setMinimumWidth(w);
mainLayout->addWidget(treeWidget, 50);
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.
if (treeWidget && treeWidget->topLevelItemCount() > 0) {
connect(treeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
this, SLOT(slotItemChanged(QTreeWidgetItem*,int)));
}
QCheckBox* checkbox = new QCheckBox(i18n("Do not ask again"), mainWidget);
connect(checkbox, SIGNAL(clicked(bool)), this, SLOT(slotClicked(bool)));
mainLayout->addWidget(checkbox);
setMainWidget(mainWidget);
}
SessionRestoreDialog::~SessionRestoreDialog()
{
}
QStringList SessionRestoreDialog::discardedSessionList() const
{
return m_discardedSessionList;
}
bool SessionRestoreDialog::isDontShowChecked() const
{
return m_dontShowChecked;
}
void SessionRestoreDialog::slotClicked(bool checked)
{
m_dontShowChecked = checked;
}
static void setCheckState(QTreeWidgetItem* item, int column, Qt::CheckState state)
{
const bool blocked = item->treeWidget()->blockSignals(true);
item->setCheckState(column, state);
item->treeWidget()->blockSignals(blocked);
}
void SessionRestoreDialog::slotItemChanged(QTreeWidgetItem* item, int column)
{
Q_ASSERT(item);
const int itemChildCount = item->childCount();
QTreeWidgetItem* parentItem = 0;
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);
}
case Qt::Unchecked:
if (numCheckSessions > 0) {
parentItem->setCheckState(column, Qt::Checked);
}
default:
break;
}
enableButton(KDialog::Yes, 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(KGlobal::config().data(), "Notification Messages");
cg.writeEntry( dontShowAgainName, result==Yes, flags );
cg.sync();
}
bool SessionRestoreDialog::shouldBeShown(const QString& dontShowAgainName, int* result)
{
if (dontShowAgainName.isEmpty()) {
return true;
}
KConfigGroup cg(KGlobal::config().data(), "Notification Messages");
const QString dontAsk = cg.readEntry(dontShowAgainName, QString()).toLower();
if (dontAsk == "yes" || dontAsk == "true") {
if (result) {
*result = Yes;
}
return false;
}
if (dontAsk == "no" || dontAsk == "false") {
if (result) {
*result = No;
}
return false;
}
return true;
}
KonqSessionManager::KonqSessionManager()
: m_autosaveDir(KStandardDirs::locateLocal("appdata", "autosave"))
, m_autosaveEnabled(false) // so that enableAutosave works
{
// Initialize dbus interfaces
new KonqSessionManagerAdaptor ( this );
@ -378,6 +87,7 @@ KonqSessionManager::KonqSessionManager()
connect( &m_autoSaveTimer, SIGNAL(timeout()), this,
SLOT(autoSaveSession()) );
}
m_autosaveEnabled = false; // so that enableAutosave works
enableAutosave();
}
@ -551,6 +261,17 @@ void KonqSessionManager::restoreSessions(const QString &sessionsDir, bool
}
}
static const QList<KConfigGroup> windowConfigGroups(const 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;
}
void KonqSessionManager::restoreSession(const QString &sessionFilePath, bool
openTabsInsideCurrentWindow, KonqMainWindow *parent)
{
@ -567,30 +288,6 @@ void KonqSessionManager::restoreSession(const QString &sessionFilePath, bool
}
}
static void removeDiscardedSessions(const QStringList& sessionFiles, const QStringList& discardedSessions)
{
if (discardedSessions.isEmpty()) {
return;
}
Q_FOREACH(const QString& sessionFile, sessionFiles) {
const 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()
{
@ -598,30 +295,52 @@ bool KonqSessionManager::askUserToRestoreAutosavedAbandonedSessions()
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);
result = restoreDlg->exec();
discardedSessionList = restoreDlg->discardedSessionList();
if (restoreDlg->isDontShowChecked()) {
SessionRestoreDialog::saveDontShow(dontAskAgainName, result);
QStringList detailsList;
// Collect info from the sessions to restore
Q_FOREACH(const QString& sessionFile, sessionFilePaths) {
kDebug() << sessionFile;
const KConfig config(sessionFile, KConfig::SimpleConfig);
const QList<KConfigGroup> groups = windowConfigGroups(config);
Q_FOREACH(const KConfigGroup& group, groups) {
// To avoid a recursive search, let's do linear search on Foo_CurrentHistoryItem=1
Q_FOREACH(const QString& key, group.keyList()) {
if (key.endsWith("_CurrentHistoryItem")) {
const QString viewId = key.left(key.length() - strlen("_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("konq_sidebar"))
continue;
const QString url = group.readEntry(prefix + "Url", QString());
const QString title = group.readEntry(prefix + "Title", QString());
kDebug() << viewId << url << title;
if (title.trimmed().isEmpty()) {
detailsList << url;
} else {
detailsList << title;
}
}
}
}
delete restoreDlg;
}
switch (result) {
case KDialog::Yes:
// Remove the discarded session list files.
removeDiscardedSessions(sessionFilePaths, discardedSessionList);
disableAutosave();
switch(KMessageBox::warningYesNoCancelList(0, // there is no questionYesNoCancelList
i18n("Konqueror did not close correctly. Would you like to restore the previous session?"),
detailsList,
i18nc("@title:window", "Restore Session?"),
KGuiItem(i18n("Restore Session"), "window-new"),
KGuiItem(i18n("Do Not Restore"), "dialog-close"),
KGuiItem(i18n("Ask Me Later"), "chronometer"),
"Restore session when konqueror didn't close correctly"
))
{
case KMessageBox::Yes:
restoreSessions(sessionFilePaths);
enableAutosave();
return true;
case KDialog::No:
case KMessageBox::No:
deleteOwnedSessions();
enableAutosave();
return false;
@ -630,7 +349,8 @@ bool KonqSessionManager::askUserToRestoreAutosavedAbandonedSessions()
QDirIterator it(dirForMyOwnedSessionFiles(),
QDir::Writable|QDir::Files);
while (it.hasNext()) {
while (it.hasNext())
{
it.next();
// remove ownership of the abandoned file
QFile::rename(it.filePath(), m_autosaveDir + '/' + it.fileName());

51
konqueror/src/konqsessionmanager.h
View file

@ -27,61 +27,10 @@
#include <QString>
#include <kconfig.h>
#include <kdialog.h>
#include <konqprivate_export.h>
class QDBusMessage;
class KonqMainWindow;
class QTreeWidgetItem;
class SessionRestoreDialog : public KDialog
{
Q_OBJECT
public:
explicit SessionRestoreDialog(const QStringList& sessionFilePaths, QWidget* parent=0);
virtual ~SessionRestoreDialog();
/**
* Returns the list of session discarded/unselected by the user.
*/
QStringList discardedSessionList() const;
/**
* Returns true if the don't show checkbox is checked.
*/
bool isDontShowChecked() const;
/**
* Returns true if the corresponding session restore dialog should be shown.
*
* @param dontShowAgainName the name that identify the session restore dialog box.
* @param result if not null, it will be set to the result that was chosen the last
* time the dialog box was shown. This is only useful if the restore dialog box should
* be shown.
*/
static bool shouldBeShown(const QString &dontShowAgainName, int* result);
/**
* Save the fact that the session restore dialog should not be shown again.
*
* @param dontShowAgainName the name that identify the session restore dialog. If
* empty, this method does nothing.
* @param result the value (Yes or No) that should be used as the result
* for the message box.
*/
static void saveDontShow(const QString &dontShowAgainName, int result);
private Q_SLOTS:
void slotClicked(bool);
void slotItemChanged(QTreeWidgetItem*, int);
private:
QStringList m_discardedSessionList;
QHash<QTreeWidgetItem*, int> m_checkedSessionItems;
int m_sessionItemsCount;
bool m_dontShowChecked;
};
/**
* This class is a singleton. It does some session related tasks: