Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-23 18:32:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

kfile: drop support for reading bookmarks from user-places.xbel

Browse source 
Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
This commit is contained in:
Ivailo Monev 2023-06-08 14:31:14 +03:00
parent 451ad3c859
commit a05e71695c
5 changed files with 5 additions and 369 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
kfile/CMakeLists.txt
View file

@ -23,7 +23,6 @@ set(kfile_LIB_SRCS
kfilewidget.cpp
kfileplacesitem.cpp
kfileplacesmodel.cpp
kfileplacessharedbookmarks.cpp
kfileplacesview.cpp
kfileplaceeditdialog.cpp
kfilepreviewgenerator.cpp

32
kfile/kfileplacesmodel.cpp
View file

@ -19,8 +19,6 @@
*/
#include "kfileplacesmodel.h"
#include "kfileplacesitem_p.h"
#include "kfileplacessharedbookmarks_p.h"
#include <QtCore/QMimeData>
#include <QtCore/QTimer>
@ -37,13 +35,10 @@
#include <kicon.h>
#include <kmimetype.h>
#include <kdebug.h>
#include <kbookmarkmanager.h>
#include <kbookmark.h>
#include <kio/netaccess.h>
#include <kprotocolinfo.h>
#include <solid/devicenotifier.h>
#include <solid/storageaccess.h>
#include <solid/storagedrive.h>
@ -56,10 +51,9 @@
class KFilePlacesModel::Private
{
public:
Private(KFilePlacesModel *self) : q(self), bookmarkManager(0), sharedBookmarks(0) {}
Private(KFilePlacesModel *self) : q(self), bookmarkManager(0) {}
~Private()
{
delete sharedBookmarks;
qDeleteAll(items);
}
@ -71,7 +65,6 @@ public:
Solid::Predicate predicate;
KBookmarkManager *bookmarkManager;
KFilePlacesSharedBookmarks * sharedBookmarks;
void reloadAndSignal();
QList<KFilePlacesItem *> loadBookmarkList();
@ -89,20 +82,12 @@ public:
KFilePlacesModel::KFilePlacesModel(QObject *parent)
: QAbstractItemModel(parent), d(new Private(this))
{
// TODO: use XDG shortcuts.xbel instead, see:
// https://www.freedesktop.org/wiki/Specifications/desktop-bookmark-spec/
const QString file = KStandardDirs::locateLocal("data", "kfileplaces/bookmarks.xml");
d->bookmarkManager = KBookmarkManager::managerForFile(file, "kfilePlaces");
// Let's put some places in there if it's empty. We have a corner case here:
// Given you have bookmarked some folders (which have been saved on
// ~/.local/share/user-places.xbel (according to freedesktop bookmarks spec), and
// deleted the home directory ~/.kde, the call managerForFile() will return the
// bookmark manager for the fallback "kfilePlaces", making root.first().isNull() being
// false (you have your own items bookmarked), resulting on only being added your own
// bookmarks, and not the default ones too. So, we also check if kfileplaces/bookmarks.xml
// file exists, and if it doesn't, we also add the default places. (ereslibre)
KBookmarkGroup root = d->bookmarkManager->root();
if (root.first().isNull() || !QFile::exists(file)) {
if (root.first().isNull()) {
// NOTE: The context for these I18N_NOOP2 calls has to be "KFile System Bookmarks".
// The real i18nc call is made later, with this context, so the two must match.
//
@ -124,17 +109,10 @@ KFilePlacesModel::KFilePlacesModel(QObject *parent)
"Trash", I18N_NOOP2("KFile System Bookmarks", "Trash"),
KUrl("trash:/"), "user-trash");
// Force bookmarks to be saved. If on open/save dialog and the bookmarks are not saved, QFile::exists
// will always return false, which opening/closing all the time the open/save dialog would case the
// bookmarks to be added once each time, having lots of times each bookmark. This forces the defaults
// to be saved on the bookmarks.xml file. Of course, the complete list of bookmarks (those that come from
// user-places.xbel will be filled later). (ereslibre)
// Force bookmarks to be saved.
d->bookmarkManager->saveAs(file);
}
// create after, so if we have own places, they are added afterwards, in case of equal priorities
d->sharedBookmarks = new KFilePlacesSharedBookmarks(d->bookmarkManager);
QString predicate("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
" OR "
"[ IS StorageAccess AND StorageDrive.driveType == 'Floppy' ]]"

281
kfile/kfileplacessharedbookmarks.cpp
View file

@ -1,281 +0,0 @@
/* This file is part of the KDE project
Copyright (C) 2008 Norbert Frese <nf2@scheinwelt.at>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "kfileplacessharedbookmarks_p.h"
#include <QtCore/QObject>
#include <QtCore/QTextStream>
#include <QtCore/QFile>
#include <kstandarddirs.h>
#include <kbookmarkmanager.h>
#include <kbookmark.h>
#include <kdebug.h>
//////////////// utility functions
static bool compareBookmarks(const KBookmark & bookmark1, const KBookmark & bookmark2)
{
return (bookmark1.url() == bookmark2.url() || bookmark1.text() == bookmark2.text());
}
static bool deepCompareDomNodes(const QDomNode & node1, const QDomNode & node2)
{
// compare name and value
if (node1.nodeName() != node2.nodeName() || node1.nodeValue() != node2.nodeValue())
return false;
// recursively compare children
const QDomNodeList node1Children = node1.childNodes();
const QDomNodeList node2Children = node2.childNodes();
if (node1Children.count () != node2Children.count ())
return false;
for (int i=0; i<node1Children.count ();i++) {
if (!deepCompareDomNodes(node1Children.at(i), node2Children.at(i) ))
return false;
}
return true;
}
/*
static QString nodeAsString(const QDomNode & node1)
{
QString str;
QTextStream ts( &str, QIODevice::WriteOnly );
ts << node1;
return str;
}
*/
static bool exactCompareBookmarks(const KBookmark & bookmark1, const KBookmark & bookmark2)
{
//kDebug() << "excat comparing:\n" << nodeAsString(bookmark1.internalElement()) << "\nwith:\n" << nodeAsString(bookmark2.internalElement());
return deepCompareDomNodes(bookmark1.internalElement(), bookmark2.internalElement());
}
static void cloneBookmarkContents(const KBookmark & target, const KBookmark & source)
{
const QDomElement targetEl = target.internalElement();
QDomNode parent = targetEl.parentNode ();
QDomNode clonedNode = source.internalElement().cloneNode(true);
parent.replaceChild (clonedNode , targetEl );
}
static KBookmark cloneBookmark(const KBookmark & toClone)
{
const QDomNode cloned = toClone.internalElement().cloneNode(true);
return KBookmark(cloned.toElement ());
}
static void emptyBookmarkGroup(KBookmarkGroup & root)
{
KBookmark bookmark = root.first();
while (!bookmark.isNull()) {
KBookmark bookmarkToRemove = bookmark;
bookmark = root.next(bookmark);
root.deleteBookmark(bookmarkToRemove);
}
}
static int bookmarkGroupSize(KBookmarkGroup & root)
{
int count=0;
KBookmark bookmark = root.first();
while (!bookmark.isNull()) {
count++;
bookmark = root.next(bookmark);
}
return count;
}
//////////////// class KFilePlacesSharedBookmarks
KFilePlacesSharedBookmarks::KFilePlacesSharedBookmarks(KBookmarkManager * mgr)
{
m_placesBookmarkManager = mgr;
// we check later if the directory exists
KStandardDirs::makeDir(KStandardDirs().localxdgdatadir());
const QString file = KStandardDirs().localxdgdatadir() + "user-places.xbel";
m_sharedBookmarkManager = KBookmarkManager::managerForExternalFile(file);
connect(m_sharedBookmarkManager, SIGNAL(changed(QString,QString)),
this, SLOT(slotSharedBookmarksChanged()));
connect(m_sharedBookmarkManager, SIGNAL(bookmarksChanged(QString)),
this, SLOT(slotSharedBookmarksChanged()));
connect(m_placesBookmarkManager, SIGNAL(changed(QString,QString)),
this, SLOT(slotBookmarksChanged()));
connect(m_placesBookmarkManager, SIGNAL(bookmarksChanged(QString)),
this, SLOT(slotBookmarksChanged()));
integrateSharedBookmarks();
}
bool KFilePlacesSharedBookmarks::integrateSharedBookmarks()
{
KBookmarkGroup root = m_placesBookmarkManager->root();
KBookmark bookmark = root.first();
KBookmarkGroup sharedRoot = m_sharedBookmarkManager->root();
KBookmark sharedBookmark = sharedRoot.first();
bool dirty = false;
while (!bookmark.isNull()) {
//kDebug() << "importing" << bookmark.text();
// skip over system items
if (bookmark.metaDataItem("isSystemItem") == "true") {
bookmark = root.next(bookmark);
continue;
}
// do the bookmarks match?
if (!sharedBookmark.isNull() && compareBookmarks(bookmark, sharedBookmark)) {
//kDebug() << "excat comparing: targetbk:\n" << nodeAsString(bookmark.internalElement()) << "\nsourcbk:\n" << nodeAsString(sharedBookmark.internalElement());
if (!exactCompareBookmarks(bookmark, sharedBookmark)) {
KBookmark cloneTarget=bookmark;
KBookmark cloneSource = sharedBookmark;
sharedBookmark = sharedRoot.next(sharedBookmark);
bookmark = root.next(bookmark);
//kDebug() << "cloning" << cloneSource.text();
//kDebug() << "cloning: target=\n" << nodeAsString(cloneTarget.internalElement()) << "\n source:\n" << nodeAsString(cloneSource.internalElement());
cloneBookmarkContents(cloneTarget, cloneSource);
dirty = true;
continue;
} else {
//kDebug() << "keeping" << bookmark.text();
}
sharedBookmark = sharedRoot.next(sharedBookmark);
bookmark = root.next(bookmark);
continue;
}
// they don't match -> remove
//kDebug() << "removing" << bookmark.text();
KBookmark bookmarkToRemove = bookmark;
bookmark = root.next(bookmark);
root.deleteBookmark(bookmarkToRemove);
dirty = true;
}
// append the remaining shared bookmarks
while(!sharedBookmark.isNull()) {
root.addBookmark(cloneBookmark(sharedBookmark));
sharedBookmark = sharedRoot.next(sharedBookmark);
dirty = true;
}
return dirty;
}
bool KFilePlacesSharedBookmarks::exportSharedBookmarks()
{
KBookmarkGroup root = m_placesBookmarkManager->root();
KBookmark bookmark = root.first();
KBookmarkGroup sharedRoot = m_sharedBookmarkManager->root();
KBookmark sharedBookmark = sharedRoot.first();
bool dirty = false;
// first check if they are the same
int count=0;
while (!bookmark.isNull()) {
//kDebug() << "exporting..." << bookmark.text();
// skip over system items
if (bookmark.metaDataItem("isSystemItem") == "true") {
bookmark = root.next(bookmark);
continue;
}
count++;
// end of sharedBookmarks?
if (sharedBookmark.isNull()) {
dirty=true;
break;
}
// do the bookmarks match?
if (compareBookmarks(bookmark, sharedBookmark)) {
if (!exactCompareBookmarks(bookmark, sharedBookmark)) {
dirty = true;
break;
}
} else {
dirty=true;
break;
}
sharedBookmark = sharedRoot.next(sharedBookmark);
bookmark = root.next(bookmark);
}
//kDebug() << "dirty=" << dirty << " oldsize=" << bookmarkGroupSize(sharedRoot) << " count=" << count;
if (bookmarkGroupSize(sharedRoot) != count)
dirty=true;
if (dirty) {
emptyBookmarkGroup(sharedRoot);
// append all bookmarks
KBookmark bookmark = root.first();
while(!bookmark.isNull()) {
if (bookmark.metaDataItem("isSystemItem") == "true") {
bookmark = root.next(bookmark);
continue;
}
sharedRoot.addBookmark(cloneBookmark(bookmark));
bookmark = root.next(bookmark);
dirty = true;
}
}
return dirty;
}
void KFilePlacesSharedBookmarks::slotSharedBookmarksChanged()
{
//kDebug() << "shared bookmarks changed";
bool dirty = integrateSharedBookmarks();
if (dirty) m_placesBookmarkManager->emitChanged();
}
void KFilePlacesSharedBookmarks::slotBookmarksChanged()
{
//kDebug() << "places bookmarks changed";
bool dirty = exportSharedBookmarks();
if (dirty) m_sharedBookmarkManager->emitChanged();
}
#include "moc_kfileplacessharedbookmarks_p.cpp"

56
kfile/kfileplacessharedbookmarks_p.h
View file

@ -1,56 +0,0 @@
/* This file is part of the KDE project
Copyright (C) 2008 Norbert Frese <nf2@scheinwelt.at>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef KFILEPLACESSHAREDBOOKMARKS_P_H
#define KFILEPLACESSHAREDBOOKMARKS_P_H
#include <QtCore/QObject>
#include <kbookmarkmanager.h>
/**
* keeps the KFilePlacesModel bookmarks and the shared bookmark spec
* shortcuts in sync
*/
class KFilePlacesSharedBookmarks : public QObject
{
Q_OBJECT
public:
KFilePlacesSharedBookmarks(KBookmarkManager * mgr);
~KFilePlacesSharedBookmarks() { /* delete m_sharedBookmarkManager; */}
private:
bool integrateSharedBookmarks();
bool exportSharedBookmarks();
KBookmarkManager *m_placesBookmarkManager;
KBookmarkManager *m_sharedBookmarkManager;
private Q_SLOTS:
void slotSharedBookmarksChanged();
void slotBookmarksChanged();
};
#endif /*KFILEPLACESSHARED_P_H_*/

4
kfile/tests/kfileplacesmodeltest.cpp
View file

@ -77,10 +77,6 @@ void KFilePlacesModelTest::initTestCase()
// Ensure we'll have a clean bookmark file to start
const QString file = KStandardDirs::locateLocal("data", "kfileplaces/bookmarks.xml");
QFile::remove(file);
// Erase the shared bookmarks file also
const QString sharedBookmarksFile = KStandardDirs().localxdgdatadir() + "/user-places.xbel";
QFile::remove(sharedBookmarksFile);
qRegisterMetaType<QModelIndex>();
setenv("SOLID_FAKEHW", TEST_DATA, 1);