Restructure source foldersr14.1.x

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 086012dcad8a976a0dabbb7cbc20c9cb612cdfa9)

9 files changed, 1008 insertions, 0 deletions

diff --git a/src/app/BookMan/Makefile.am b/src/app/BookMan/Makefile.am
new file mode 100644
index 0000000..3f602d3
--- /dev/null
+++ b/src/app/BookMan/Makefile.am
@@ -0,0 +1,11 @@
+noinst_LIBRARIES = libBookMan.a
+
+INCLUDES = $(all_includes)
+
+libBookMan_a_METASOURCES = AUTO
+
+libBookMan_a_SOURCES = \
+	krbookmark.cpp \
+	krbookmarkbutton.cpp \
+	krbookmarkhandler.cpp \
+	kraddbookmarkdlg.cpp
diff --git a/src/app/BookMan/kraddbookmarkdlg.cpp b/src/app/BookMan/kraddbookmarkdlg.cpp
new file mode 100644
index 0000000..1af3736
--- /dev/null
+++ b/src/app/BookMan/kraddbookmarkdlg.cpp
@@ -0,0 +1,117 @@
+#include "kraddbookmarkdlg.h"
+#include "../krusader.h"
+#include "krbookmarkhandler.h"
+#include <tdelocale.h>
+#include <tqheader.h>
+#include <tqlayout.h>
+#include <tqlabel.h>
+#include <kinputdialog.h>
+#include <kiconloader.h>
+#include <kdebug.h>
+
+KrAddBookmarkDlg::KrAddBookmarkDlg(TQWidget *parent, KURL url):
+	KDialogBase(KDialogBase::Swallow, i18n("Add Bookmark"),
+				 KDialogBase::User1 | KDialogBase::Ok | KDialogBase::Cancel, KDialogBase::Ok, parent) {
+	// create the 'new folder' button
+	setButtonText(KDialogBase::User1, i18n("New Folder"));
+	showButton(KDialogBase::User1, false); // hide it until _createIn is shown
+	connect(this, TQ_SIGNAL(user1Clicked()), this, TQ_SLOT(newFolder()));
+
+	// create the main widget
+	TQWidget *page = new TQWidget(this);
+	setMainWidget(page);
+
+	TQGridLayout *layout = new TQGridLayout(page, 1, 1, 0, spacingHint()); // expanding
+	// name and url
+	TQLabel *lb1 = new TQLabel(i18n("Name:"), page);
+	_name = new KLineEdit(page);
+	_name->setText(url.prettyURL()); // default name is the url
+	_name->selectAll(); // make the text selected
+	layout->addWidget(lb1, 0, 0);	
+	layout->addWidget(_name, 0, 1);
+	
+	TQLabel *lb2 = new TQLabel(i18n("URL:"), page);
+	_url = new KLineEdit(page);
+	layout->addWidget(lb2, 1, 0);	
+	layout->addWidget(_url, 1, 1);
+	_url->setText(url.prettyURL()); // set the url in the field
+
+	// create in linedit and button
+	TQLabel *lb3 = new TQLabel(i18n("Create in:"), page);
+	_folder = new KLineEdit(page);
+	layout->addWidget(lb3, 2, 0);
+	layout->addWidget(_folder, 2, 1);
+	_folder->setReadOnly(true);
+
+	_createInBtn = new TQToolButton(page);
+	_createInBtn->setPixmap(krLoader->loadIcon("go-down", TDEIcon::Small));
+	_createInBtn->setToggleButton(true);
+	connect(_createInBtn, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(toggleCreateIn(bool )));
+	layout->addWidget(_createInBtn, 2, 2);
+
+	setDetailsWidget(createInWidget());
+	
+	_name->setFocus();
+}
+
+void KrAddBookmarkDlg::toggleCreateIn(bool show) {
+	_createInBtn->setPixmap(krLoader->loadIcon(show ? "go-up" :"go-down", TDEIcon::Small));
+	showButton(KDialogBase::User1, show);
+	setDetails(show);
+}
+
+// creates the widget that lets you decide where to put the new bookmark
+TQWidget *KrAddBookmarkDlg::createInWidget() {
+	_createIn = new TDEListView(this);
+	_createIn->addColumn("Folders");
+	_createIn->header()->hide();
+	_createIn->setRootIsDecorated(true);
+	_createIn->setAlternateBackground(TQColor()); // disable alternate coloring 
+	
+	TDEListViewItem *item = new TDEListViewItem(_createIn, i18n("Bookmarks"));
+	item->setOpen(true);
+	item->setSelected(true);
+	_xr[item] = krBookMan->_root;
+
+	populateCreateInWidget(krBookMan->_root, item);
+	_createIn->setCurrentItem(item);
+	createInSelection(item);
+	connect(_createIn, TQ_SIGNAL(selectionChanged(TQListViewItem*)), this, TQ_SLOT(createInSelection(TQListViewItem*)));
+	
+	return _createIn;
+}
+
+void KrAddBookmarkDlg::createInSelection(TQListViewItem *item) {
+	if (item) {
+		_folder->setText(_xr[static_cast<TDEListViewItem*>(item)]->text());
+	}
+}
+
+void KrAddBookmarkDlg::populateCreateInWidget(KrBookmark *root, TDEListViewItem *parent) {
+	for (KrBookmark *bm = root->children().first(); bm; bm = root->children().next()) {
+		if (bm->isFolder()) {
+			TDEListViewItem *item = new TDEListViewItem(parent, bm->text());
+			item->setOpen(true);
+			_xr[item] = bm;
+			populateCreateInWidget(bm, item);
+		}
+	}
+}
+
+void KrAddBookmarkDlg::newFolder() {
+	// get the name
+	TQString newFolder = KInputDialog::getText(i18n("New Folder"), i18n("Folder name:"), TQString(), 0, this);
+	if (newFolder == TQString())
+		return;
+	// add to the list in bookman
+	KrBookmark *bm = new KrBookmark(newFolder);
+	krBookMan->addBookmark(bm, _xr[static_cast<TDEListViewItem*>(_createIn->selectedItem())]);
+	// fix the gui
+	TDEListViewItem *item = new TDEListViewItem(_createIn->selectedItem(), bm->text());
+	_xr[item] = bm;
+
+	_createIn->setCurrentItem(item);
+	item->setSelected(true);
+}
+
+#include "kraddbookmarkdlg.moc"
diff --git a/src/app/BookMan/kraddbookmarkdlg.h b/src/app/BookMan/kraddbookmarkdlg.h
new file mode 100644
index 0000000..b270781
--- /dev/null
+++ b/src/app/BookMan/kraddbookmarkdlg.h
@@ -0,0 +1,40 @@
+#ifndef KRADDBOOKMARKDLG_H
+#define KRADDBOOKMARKDLG_H
+
+#include "krbookmark.h"
+#include "../VFS/vfs.h"
+#include <kdialogbase.h>
+#include <kurl.h>
+#include <klineedit.h>
+#include <tqmap.h>
+#include <tdelistview.h>
+#include <tqtoolbutton.h>
+
+class KrAddBookmarkDlg: public KDialogBase {
+	TQ_OBJECT
+  
+public:
+	KrAddBookmarkDlg(TQWidget *parent, KURL url = 0);
+	KURL url() const { return vfs::fromPathOrURL(_url->text()); }
+	TQString name() const { return _name->text(); }
+	KrBookmark *folder() const { return _xr[static_cast<TDEListViewItem*>(_createIn->selectedItem())]; }
+
+protected:
+	TQWidget *createInWidget();
+	void populateCreateInWidget(KrBookmark *root, TDEListViewItem *parent);
+
+protected slots:
+	void toggleCreateIn(bool show);
+	void createInSelection(TQListViewItem *item);
+	void newFolder();
+	
+private:
+	KLineEdit *_name;
+	KLineEdit *_url;
+	KLineEdit *_folder;
+	TDEListView *_createIn;
+	TQMap<TDEListViewItem*, KrBookmark*> _xr;
+	TQToolButton *_createInBtn;
+};
+
+#endif // KRADDBOOKMARKDLG_H
diff --git a/src/app/BookMan/krbookmark.cpp b/src/app/BookMan/krbookmark.cpp
new file mode 100644
index 0000000..cc67228
--- /dev/null
+++ b/src/app/BookMan/krbookmark.cpp
@@ -0,0 +1,92 @@
+#include "krbookmark.h"
+#include "../krusader.h"
+#include "../VFS/krarchandler.h"
+#include <tdeactioncollection.h>
+#include <kiconloader.h>
+#include <tdelocale.h>
+#include <kdebug.h>
+
+#define BM_NAME(X)		(TQString("Bookmark:")+X)
+
+#if KDE_IS_VERSION(3,4,0)
+static const char* NAME_DEVICES = I18N_NOOP("Media");
+#else
+static const char* NAME_DEVICES = I18N_NOOP("Devices");
+#endif
+static const char* NAME_VIRTUAL = I18N_NOOP("Virtual Filesystem");
+static const char* NAME_LAN = I18N_NOOP("Local Network");
+
+KrBookmark::KrBookmark(TQString name, KURL url, TDEActionCollection *parent, TQString icon, TQString actionName ):
+	TDEAction(name, 0, 0, 0, parent, actionName.isNull() ? BM_NAME(name).latin1() : BM_NAME(actionName).latin1()), 
+	_url(url), _folder(false), _separator(false) {
+	connect(this, TQ_SIGNAL(activated()), this, TQ_SLOT(activatedProxy()));
+	// do we have an icon?
+	if (!icon.isEmpty())
+		setIcon(icon);
+	else {
+		// what kind of a url is it?
+		if (_url.isLocalFile()) {
+			setIcon("folder");
+		} else { // is it an archive?
+			if (KRarcHandler::isArchive(_url))
+				setIcon("application-x-tar");
+			else setIcon("folder_html");
+		}
+	}
+
+	_children.setAutoDelete(true);
+}
+
+KrBookmark::KrBookmark(TQString name, TQString icon):
+	TDEAction(name, 0, 0, 0, 0), _folder(true), _separator(false) {
+	setIcon(icon=="" ? "folder" : icon);
+}
+
+KrBookmark* KrBookmark::getExistingBookmark(TQString actionName, TDEActionCollection *collection) {
+	return static_cast<KrBookmark*>(collection->action(BM_NAME(actionName).latin1()));
+}
+
+KrBookmark* KrBookmark::devices(TDEActionCollection *collection) {
+	KrBookmark *bm = getExistingBookmark(i18n(NAME_DEVICES), collection);	
+	if (!bm) {
+#if KDE_IS_VERSION(3,4,0)
+		bm = new KrBookmark(i18n(NAME_DEVICES), "media:/", collection);
+#else
+		bm = new KrBookmark(i18n(NAME_DEVICES), "devices:/", collection);
+#endif
+		bm->setIconSet(krLoader->loadIcon("blockdevice", TDEIcon::Small));
+	}
+	return bm;
+}
+
+KrBookmark* KrBookmark::virt(TDEActionCollection *collection) {
+	KrBookmark *bm = getExistingBookmark(i18n(NAME_VIRTUAL), collection);	
+	if (!bm) {
+		bm = new KrBookmark(i18n(NAME_VIRTUAL), "virt:/", collection);
+		bm->setIconSet(krLoader->loadIcon("pipe", TDEIcon::Small));
+	}
+	return bm;
+}
+
+KrBookmark* KrBookmark::lan(TDEActionCollection *collection) {
+	KrBookmark *bm = getExistingBookmark(i18n(NAME_LAN), collection);	
+	if (!bm) {
+		bm = new KrBookmark(i18n(NAME_LAN), "lan:/", collection);
+		bm->setIconSet(krLoader->loadIcon("network", TDEIcon::Small));
+	}
+	return bm;
+}
+
+KrBookmark* KrBookmark::separator() {
+	KrBookmark *bm = new KrBookmark("");
+	bm->_separator = true;
+	bm->_folder = false;
+	return bm;
+}
+
+
+void KrBookmark::activatedProxy() {
+	emit activated(url());
+}
+
+#include "krbookmark.moc"
diff --git a/src/app/BookMan/krbookmark.h b/src/app/BookMan/krbookmark.h
new file mode 100644
index 0000000..567b3c8
--- /dev/null
+++ b/src/app/BookMan/krbookmark.h
@@ -0,0 +1,46 @@
+#ifndef KRBOOKMARK_H
+#define KRBOOKMARK_H
+
+#include <tdeaction.h>
+#include <tqptrlist.h>
+#include <kurl.h>
+
+class TDEActionCollection;
+
+class KrBookmark: public TDEAction {
+	TQ_OBJECT
+  
+public:
+	KrBookmark(TQString name, KURL url, TDEActionCollection *parent, TQString icon = "", TQString actionName = TQString() );
+	KrBookmark(TQString name, TQString icon = ""); // creates a folder
+	// text() and setText() to change the name of the bookmark
+	// icon() and setIcon() to change icons (by name)
+	inline const KURL& url() const { return _url; }
+	inline void setURL(const KURL& url) { _url = url; }
+	inline bool isFolder() const { return _folder; }
+	inline bool isSeparator() const { return _separator; }
+	TQPtrList<KrBookmark>& children() { return _children; }
+
+	static KrBookmark* getExistingBookmark(TQString actionName, TDEActionCollection *collection);	
+	// ----- special bookmarks
+	static KrBookmark* devices(TDEActionCollection *collection);
+	static KrBookmark* virt(TDEActionCollection *collection);
+	static KrBookmark* lan(TDEActionCollection *collection);
+	static KrBookmark* separator();
+
+signals:
+	void activated(const KURL& url);
+
+protected slots:
+	void activatedProxy();
+	
+	
+private:
+	KURL _url;
+	TQString _icon;
+	bool _folder;
+	bool _separator;
+	TQPtrList<KrBookmark> _children;
+};
+
+#endif // KRBOOKMARK_H
diff --git a/src/app/BookMan/krbookmarkbutton.cpp b/src/app/BookMan/krbookmarkbutton.cpp
new file mode 100644
index 0000000..b7ac61c
--- /dev/null
+++ b/src/app/BookMan/krbookmarkbutton.cpp
@@ -0,0 +1,38 @@
+#include "krbookmarkbutton.h"
+#include "krbookmarkhandler.h"
+#include "../krusader.h"
+#include <tqpixmap.h>
+#include <kiconloader.h>
+#include <tdeaction.h>
+#include <tdelocale.h>
+#include <tdepopupmenu.h>
+#include <kdebug.h>
+
+KrBookmarkButton::KrBookmarkButton(TQWidget *parent): TQToolButton(parent) {
+	TQPixmap icon = krLoader->loadIcon("bookmark", TDEIcon::Toolbar, 16);
+	setFixedSize(icon.width() + 4, icon.height() + 4);
+	setPixmap(icon);
+	setTextLabel(i18n("BookMan II"), true);
+	setPopupDelay(10); // 0.01 seconds press
+	setAcceptDrops(false);
+
+	acmBookmarks = new TDEActionMenu(i18n("Bookmarks"), "bookmark", 0, 0);
+	acmBookmarks->setDelayed(false);
+	acmBookmarks->popupMenu()->setKeyboardShortcutsEnabled(true);
+	acmBookmarks->popupMenu()->setKeyboardShortcutsExecute(true);
+
+	setPopup(acmBookmarks->popupMenu());
+	connect(this, TQ_SIGNAL(pressed()), this, TQ_SLOT(populate()));
+	populate();
+}
+
+void KrBookmarkButton::populate() {
+	krBookMan->populate(static_cast<TDEPopupMenu*>(popup()));
+}
+
+void KrBookmarkButton::openPopup() {
+	populate();
+	popup()->exec(mapToGlobal(TQPoint(0, height())));
+}
+
+#include "krbookmarkbutton.moc"
diff --git a/src/app/BookMan/krbookmarkbutton.h b/src/app/BookMan/krbookmarkbutton.h
new file mode 100644
index 0000000..54136f2
--- /dev/null
+++ b/src/app/BookMan/krbookmarkbutton.h
@@ -0,0 +1,24 @@
+#ifndef KRBOOKMARK_BUTTON_H
+#define KRBOOKMARK_BUTTON_H
+
+#include <tqtoolbutton.h>
+#include "krbookmarkhandler.h"
+
+class KrBookmarkButton: public TQToolButton {
+	TQ_OBJECT
+  
+public:
+	KrBookmarkButton(TQWidget *parent);
+	void openPopup();
+
+signals:
+	void openUrl(const KURL &url);
+
+protected slots:
+	void populate();
+	
+private:
+	TDEActionMenu *acmBookmarks;
+};
+
+#endif // KRBOOKMARK_BUTTON_H
diff --git a/src/app/BookMan/krbookmarkhandler.cpp b/src/app/BookMan/krbookmarkhandler.cpp
new file mode 100644
index 0000000..e62515c
--- /dev/null
+++ b/src/app/BookMan/krbookmarkhandler.cpp
@@ -0,0 +1,576 @@
+#include "krbookmarkhandler.h"
+#include "kraddbookmarkdlg.h"
+#include "../krusader.h"
+#include "../krslots.h"
+#include "../Dialogs/popularurls.h"
+#include "../VFS/vfs.h"
+#include <kiconloader.h>
+#include <tdemessagebox.h>
+#include <tqptrlist.h>
+#include <tdeactioncollection.h>
+#include <tdelocale.h>
+#include <kdebug.h>
+#include <kbookmarkmanager.h>
+#include <kstandarddirs.h>
+#include <tqfile.h>
+#include <tqcursor.h>
+
+#define SPECIAL_BOOKMARKS	true
+
+// ------------------------ for internal use
+#define BOOKMARKS_FILE	"krusader/krbookmarks.xml"
+#define CONNECT_BM(X)	{ disconnect(X, TQ_SIGNAL(activated(const KURL&)), 0, 0); connect(X, TQ_SIGNAL(activated(const KURL&)), this, TQ_SLOT(slotActivated(const KURL&))); }
+											
+KrBookmarkHandler::KrBookmarkHandler(): TQObject(0), _middleClick(false), _mainBookmarkPopup( 0 ), _specialBookmarkIDs(), _bookmarkIDTable() {
+	// create our own action collection and make the shortcuts apply only to parent
+	_privateCollection = new TDEActionCollection(krApp, "private collection");
+	_collection = krApp->actionCollection();
+
+	// create _root: father of all bookmarks. it is a dummy bookmark and never shown
+	_root = new KrBookmark(i18n("Bookmarks"));
+	
+	_bookmarkIDTable.setAutoDelete( true );
+	
+	// load bookmarks 
+	importFromFile();
+
+	// hack
+	manager = KBookmarkManager::managerForFile(locateLocal( "data", BOOKMARKS_FILE ), false);
+	connect(manager, TQ_SIGNAL(changed(const TQString&, const TQString& )), this, TQ_SLOT(bookmarksChanged(const TQString&, const TQString& )));
+}
+
+KrBookmarkHandler::~KrBookmarkHandler() {
+	delete manager;
+	delete _privateCollection;
+}
+
+void KrBookmarkHandler::menuOperation(int id) {
+	switch (id) {
+		case BookmarkCurrent:
+			bookmarkCurrent(ACTIVE_PANEL->virtualPath());
+			break;
+		case ManageBookmarks:
+			manager->slotEditBookmarks();
+			break;
+	}
+}
+
+void KrBookmarkHandler::bookmarkCurrent(KURL url) {
+	KrAddBookmarkDlg dlg(krApp, url);
+	if (dlg.exec() == KDialog::Accepted) {
+		KrBookmark *bm = new KrBookmark(dlg.name(), dlg.url(), _collection);
+		addBookmark(bm, dlg.folder());
+	}
+}
+
+void KrBookmarkHandler::addBookmark(KrBookmark *bm, KrBookmark *folder) {
+	if (folder == 0)
+		folder = _root;
+		
+	// add to the list (bottom)
+	folder->children().append(bm);
+
+	exportToFile();
+}
+
+void KrBookmarkHandler::deleteBookmark(KrBookmark *bm) {
+	if( bm->isFolder() )
+		clearBookmarks( bm ); // remove the child bookmarks
+	removeReferences( _root, bm );
+	bm->unplugAll();
+	delete bm;
+	
+	exportToFile();
+}
+
+void KrBookmarkHandler::removeReferences( KrBookmark *root, KrBookmark *bmToRemove ) {
+	int index = root->children().find( bmToRemove );
+	if( index >= 0 )
+		root->children().take( index );
+	
+	KrBookmark *bm = root->children().first();
+	while (bm) {
+		if (bm->isFolder())
+			removeReferences(bm, bmToRemove);
+		bm = root->children().next();
+	}
+}
+
+void KrBookmarkHandler::exportToFileBookmark(TQDomDocument &doc, TQDomElement &where, KrBookmark *bm) {
+	if( bm->isSeparator() ) {
+		TQDomElement bookmark = doc.createElement("separator");
+		where.appendChild(bookmark);
+	}
+	else {
+		TQDomElement bookmark = doc.createElement("bookmark");
+		// url
+		bookmark.setAttribute("href", bm->url().prettyURL());
+		// icon
+		bookmark.setAttribute("icon", bm->icon());
+		// title
+		TQDomElement title = doc.createElement("title");	
+		title.appendChild(doc.createTextNode(bm->text()));
+		bookmark.appendChild(title);
+		
+		where.appendChild(bookmark);
+	}
+}
+
+void KrBookmarkHandler::exportToFileFolder(TQDomDocument &doc, TQDomElement &parent, KrBookmark *folder) {
+	for (KrBookmark *bm = folder->children().first(); bm; bm = folder->children().next()) {
+		if (bm->isFolder()) {
+			TQDomElement newFolder = doc.createElement("folder");
+			newFolder.setAttribute("icon", bm->icon());
+			parent.appendChild(newFolder);
+			TQDomElement title = doc.createElement("title");
+			title.appendChild(doc.createTextNode(bm->text()));
+			newFolder.appendChild(title);
+			exportToFileFolder(doc, newFolder, bm);
+		} else {
+			exportToFileBookmark(doc, parent, bm);
+		}
+	}
+}
+
+// export to file using the xbel standard
+//
+//  <xbel>
+//    <bookmark href="http://developer.kde.org"><title>Developer Web Site</title></bookmark>
+//    <folder folded="no">
+//      <title>Title of this folder</title>
+//      <bookmark icon="kde" href="http://www.kde.org"><title>KDE Web Site</title></bookmark>
+//      <folder toolbar="yes">
+//        <title>My own bookmarks</title>
+//        <bookmark href="http://www.koffice.org"><title>KOffice Web Site</title></bookmark>
+//        <separator/>
+//        <bookmark href="http://www.kdevelop.org"><title>KDevelop Web Site</title></bookmark>
+//      </folder>
+//    </folder>
+//  </xbel>
+void KrBookmarkHandler::exportToFile() {
+	TQDomDocument doc( "xbel" );
+   TQDomElement root = doc.createElement( "xbel" );
+   doc.appendChild( root );
+
+	exportToFileFolder(doc, root, _root);
+	if (!doc.firstChild().isProcessingInstruction()) {
+		// adding: <?xml version="1.0" encoding="UTF-8" ?> if not already present 
+		TQDomProcessingInstruction instr = doc.createProcessingInstruction( "xml", 
+				"version=\"1.0\" encoding=\"UTF-8\" ");
+		doc.insertBefore( instr, doc.firstChild() ); 
+	}
+
+	
+	TQString filename = locateLocal( "data", BOOKMARKS_FILE );
+	TQFile file(filename);
+	if ( file.open( IO_WriteOnly ) ) {
+		TQTextStream stream( &file );
+		stream.setEncoding(stream.UnicodeUTF8);
+		stream << doc.toString();
+		file.close();
+	} else {
+		KMessageBox::error(krApp, i18n("Unable to write to %1").arg(filename), i18n("Error"));
+	}
+}
+
+bool KrBookmarkHandler::importFromFileBookmark(TQDomElement &e, KrBookmark *parent, TQString path, TQString *errorMsg) {
+	TQString url, name, icon;
+	// verify tag
+	if (e.tagName() != "bookmark") {
+		*errorMsg = e.tagName() + i18n(" instead of ")+"bookmark";
+		return false;
+	}
+	// verify href
+	if (!e.hasAttribute("href")) {
+		*errorMsg = i18n("missing tag ")+ "href";
+		return false;
+	} else url = e.attribute("href");
+	// verify title
+	TQDomElement te = e.firstChild().toElement();
+	if (te.tagName() != "title") {
+		*errorMsg = i18n("missing tag ")+"title";
+		return false;
+	} else name = te.text();
+	// do we have an icon?
+	if (e.hasAttribute("icon")) {
+		icon=e.attribute("icon");
+	}
+	// ok: got name and url, let's add a bookmark
+	KrBookmark *bm = KrBookmark::getExistingBookmark(path+name, _collection);
+	if (!bm) {
+		bm = new KrBookmark(name, vfs::fromPathOrURL( url ), _collection, icon, path+name);
+	parent->children().append(bm);
+	}
+
+	return true;
+}
+
+bool KrBookmarkHandler::importFromFileFolder(TQDomNode &first, KrBookmark *parent, TQString path, TQString *errorMsg) {
+	TQString name;
+	TQDomNode n = first;
+	while (!n.isNull()) {
+		TQDomElement e = n.toElement();
+		if (e.tagName() == "bookmark") {
+			if (!importFromFileBookmark(e, parent, path, errorMsg))
+				return false;
+		} else if (e.tagName() == "folder") {
+			TQString iconName = "";
+			if (e.hasAttribute("icon")) iconName=e.attribute("icon");
+			// the title is the first child of the folder
+			TQDomElement tmp = e.firstChild().toElement();
+			if (tmp.tagName() != "title") {
+				*errorMsg = i18n("missing tag ")+"title";
+				return false;
+			} else name = tmp.text();
+			KrBookmark *folder = new KrBookmark(name, iconName);
+			parent->children().append(folder);
+
+			TQDomNode nextOne = tmp.nextSibling();
+			if (!importFromFileFolder(nextOne, folder, path + name + "/", errorMsg))
+				return false;
+		} else if (e.tagName() == "separator") {
+			parent->children().append(KrBookmark::separator());
+		}
+		n = n.nextSibling();
+	}
+	return true;
+}
+
+
+void KrBookmarkHandler::importFromFile() {
+	clearBookmarks(_root);
+	
+	TQString filename = locateLocal( "data", BOOKMARKS_FILE );
+	TQFile file( filename );
+	if ( !file.open(IO_ReadOnly))
+		return; // no bookmarks file
+
+	TQString errorMsg;
+	TQDomNode n;
+	TQDomElement e;
+	TQDomDocument doc( "xbel" );
+	if ( !doc.setContent( &file, &errorMsg ) ) {
+		goto ERROR;
+	}
+	// iterate through the document: first child should be "xbel" (skip all until we find it)
+	n = doc.firstChild();	
+	while (!n.isNull() && n.toElement().tagName()!="xbel")
+		n = n.nextSibling();
+
+	if (n.isNull() || n.toElement().tagName()!="xbel") {
+		errorMsg = i18n("%1 doesn't seem to be a valid Bookmarks file").arg(filename);
+		goto ERROR;
+	} else n = n.firstChild(); // skip the xbel part
+	importFromFileFolder(n, _root, "", &errorMsg);
+	goto SUCCESS;
+	
+ERROR:
+	KMessageBox::error(krApp, i18n("Error reading bookmarks file: %1").arg(errorMsg), i18n( "Error" ));
+
+SUCCESS:
+	file.close();
+}
+
+void KrBookmarkHandler::populate(TDEPopupMenu *menu) {
+	_mainBookmarkPopup = menu;
+	menu->clear();
+	_bookmarkIDTable.clear();
+	_specialBookmarkIDs.clear();
+	buildMenu(_root, menu);
+}
+
+void KrBookmarkHandler::buildMenu(KrBookmark *parent, TDEPopupMenu *menu) {
+	static int inSecondaryMenu = 0; // used to know if we're on the top menu
+
+	// run the loop twice, in order to put the folders on top. stupid but easy :-)
+	// note: this code drops the separators put there by the user
+	for (KrBookmark *bm = parent->children().first(); bm; bm = parent->children().next()) {
+		if (!bm->isFolder()) continue;
+		TDEPopupMenu *newMenu = new TDEPopupMenu(menu);
+		int id = menu->insertItem(TQIconSet(krLoader->loadIcon(bm->icon(), TDEIcon::Small)),
+									bm->text(), newMenu, -1 /* dummy id */, -1 /* end of list */);
+		
+		if( !_bookmarkIDTable.find( menu ) )
+			_bookmarkIDTable.insert( menu, new TQMap<int, KrBookmark *> );
+		(*_bookmarkIDTable[ menu ])[ id ] = bm;
+		
+		++inSecondaryMenu;
+		buildMenu(bm, newMenu);
+		--inSecondaryMenu;
+	}
+	for (KrBookmark *bm = parent->children().first(); bm; bm = parent->children().next()) {
+		if (bm->isFolder()) continue;
+		if (bm->isSeparator() ) {
+			menu->insertSeparator();
+			continue;
+		}
+		int itemIndex = bm->plug(menu, -1 /* end of list */);
+		CONNECT_BM(bm);
+		
+		int id = bm->itemId( itemIndex );
+		if( !_bookmarkIDTable.find( menu ) )
+			_bookmarkIDTable.insert( menu, new TQMap<int, KrBookmark *> );
+		(*_bookmarkIDTable[ menu ])[ id ] = bm;
+	}
+
+	if (!inSecondaryMenu) {
+		krConfig->setGroup( "Private" );
+		bool hasPopularURLs = krConfig->readBoolEntry( "BM Popular URLs", true );
+		bool hasDevices     = krConfig->readBoolEntry( "BM Devices",      true );
+		bool hasLan         = krConfig->readBoolEntry( "BM Lan",          true );
+		bool hasVirtualFS   = krConfig->readBoolEntry( "BM Virtual FS",   true );
+		bool hasJumpback    = krConfig->readBoolEntry( "BM Jumpback",     true );
+		
+		int itemIndex;
+		
+		if( hasPopularURLs ) {
+			menu->insertSeparator();
+			
+			// add the popular links submenu
+			TDEPopupMenu *newMenu = new TDEPopupMenu(menu);
+			itemIndex = menu->insertItem(TQIconSet(krLoader->loadIcon("bookmark_folder", TDEIcon::Small)),
+										i18n("Popular URLs"), newMenu, -1 /* dummy id */, -1 /* end of list */);
+			_specialBookmarkIDs.append( itemIndex );
+			// add the top 15 urls
+			#define MAX 15
+			KURL::List list = krApp->popularUrls->getMostPopularUrls(MAX);
+			KURL::List::Iterator it;
+			for (it = list.begin(); it != list.end(); ++it) {
+				TQString name;
+				if ((*it).isLocalFile()) name = (*it).path();
+				else name = (*it).prettyURL();
+				// note: these bookmark are put into the private collection
+				// as to not spam the general collection
+				KrBookmark *bm = KrBookmark::getExistingBookmark(name, _privateCollection);
+				if (!bm)
+					bm = new KrBookmark(name, *it, _privateCollection);
+				bm->plug(newMenu);
+				CONNECT_BM(bm);
+			}
+			
+			newMenu->insertSeparator();
+			krPopularUrls->plug(newMenu);
+			newMenu->installEventFilter(this);
+		}
+		
+		// do we need to add special bookmarks?
+		if (SPECIAL_BOOKMARKS) {
+			if( hasDevices || hasLan || hasVirtualFS || hasJumpback )
+				menu->insertSeparator();
+			
+			KrBookmark *bm;
+			
+			// note: special bookmarks are not kept inside the _bookmarks list and added ad-hoc
+			if( hasDevices ) {
+				bm = KrBookmark::devices(_collection);
+				itemIndex = bm->plug(menu);
+				_specialBookmarkIDs.append( bm->itemId( itemIndex ) );
+				CONNECT_BM(bm);
+			}
+			
+			if( hasLan ) {
+				bm = KrBookmark::lan(_collection);
+				itemIndex = bm->plug(menu);
+				_specialBookmarkIDs.append( bm->itemId( itemIndex ) );
+				CONNECT_BM(bm);
+			}
+			
+			if( hasVirtualFS ) {
+				bm = KrBookmark::virt(_collection);
+				itemIndex = bm->plug(menu);
+				_specialBookmarkIDs.append( bm->itemId( itemIndex ) );
+				CONNECT_BM(bm);
+			}
+			
+			if( hasJumpback ) {
+				// add the jump-back button
+				itemIndex = krJumpBack->plug(menu);
+				_specialBookmarkIDs.append( krJumpBack->itemId( itemIndex ) );
+				menu->insertSeparator();
+				itemIndex = krSetJumpBack->plug(menu);
+				_specialBookmarkIDs.append( krSetJumpBack->itemId( itemIndex ) );
+			}
+		} 
+		
+		if( !hasJumpback )
+			menu->insertSeparator();
+		
+		itemIndex = menu->insertItem(krLoader->loadIcon("bookmark_add", TDEIcon::Small),
+			i18n("Bookmark Current"), BookmarkCurrent);
+		_specialBookmarkIDs.append( itemIndex );
+		itemIndex = menu->insertItem(krLoader->loadIcon("bookmark", TDEIcon::Small),
+			i18n("Manage Bookmarks"), ManageBookmarks);
+		_specialBookmarkIDs.append( itemIndex );
+	
+		// make sure the menu is connected to us
+		disconnect(menu, TQ_SIGNAL(activated(int)), 0, 0);
+		connect(menu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(menuOperation(int)));
+	}
+
+	menu->installEventFilter(this);
+}
+
+void KrBookmarkHandler::clearBookmarks(KrBookmark *root) {
+	KrBookmark *bm = root->children().first();
+	while (bm) {	
+		if (bm->isFolder())
+			clearBookmarks(bm);
+		else {
+			bm->unplugAll();
+			delete bm;
+		}
+
+		bm = root->children().next();
+	}
+	root->children().clear();
+}
+
+void KrBookmarkHandler::bookmarksChanged(const TQString&, const TQString&) {
+	importFromFile();
+}
+
+bool KrBookmarkHandler::eventFilter( TQObject *obj, TQEvent *ev ) {
+	if (ev->type() == TQEvent::MouseButtonRelease) {
+		switch (static_cast<TQMouseEvent*>(ev)->button()) {
+			case TQt::RightButton:
+				_middleClick = false;
+				if( obj->inherits( "TQPopupMenu" ) ) {
+					int id = static_cast<TQPopupMenu*>(obj)->idAt( static_cast<TQMouseEvent*>(ev)->pos() );
+					
+					if( obj == _mainBookmarkPopup && _specialBookmarkIDs.contains( id ) ) {
+						rightClickOnSpecialBookmark();
+						return true;
+					}
+					
+					if( _bookmarkIDTable.find( obj ) ) {
+						TQMap<int, KrBookmark*> * table = _bookmarkIDTable[ obj ];
+						if( table && table->count( id ) ) {
+							KrBookmark *bm = (*table)[ id ];
+							rightClicked( static_cast<TQPopupMenu*>(obj), id, bm );
+							return true;
+						}
+					}
+				}
+			case TQt::LeftButton:
+				_middleClick = false;
+				break;
+			case TQt::MidButton:
+				_middleClick = true;
+				break;
+			default:
+				break;
+		}
+	}
+	return TQObject::eventFilter(obj, ev);
+}
+
+#define POPULAR_URLS_ID        100100
+#define DEVICES_ID             100101
+#define LAN_ID                 100103
+#define VIRTUAL_FS_ID          100102
+#define JUMP_BACK_ID           100104
+
+void KrBookmarkHandler::rightClickOnSpecialBookmark() {
+	krConfig->setGroup( "Private" );
+	bool hasPopularURLs = krConfig->readBoolEntry( "BM Popular URLs", true );
+	bool hasDevices     = krConfig->readBoolEntry( "BM Devices",      true );
+	bool hasLan         = krConfig->readBoolEntry( "BM Lan",          true );
+	bool hasVirtualFS   = krConfig->readBoolEntry( "BM Virtual FS",   true );
+	bool hasJumpback    = krConfig->readBoolEntry( "BM Jumpback",     true );
+	
+	TQPopupMenu menu( _mainBookmarkPopup );
+	menu.setCaption( i18n( "Enable special bookmarks" ) );
+	menu.setCheckable( true );
+	
+	menu.insertItem( i18n( "Popular URLs" ), POPULAR_URLS_ID );
+	menu.setItemChecked( POPULAR_URLS_ID, hasPopularURLs );
+	menu.insertItem( i18n( "Devices" ), DEVICES_ID );
+	menu.setItemChecked( DEVICES_ID, hasDevices );
+	menu.insertItem( i18n( "Local Network" ), LAN_ID );
+	menu.setItemChecked( LAN_ID, hasLan );
+	menu.insertItem( i18n( "Virtual Filesystem" ), VIRTUAL_FS_ID );
+	menu.setItemChecked( VIRTUAL_FS_ID, hasVirtualFS );
+	menu.insertItem( i18n( "Jump back" ), JUMP_BACK_ID );
+	menu.setItemChecked( JUMP_BACK_ID, hasJumpback );
+	
+	connect( _mainBookmarkPopup, TQ_SIGNAL( highlighted( int ) ), &menu, TQ_SLOT( close() ) );
+	connect( _mainBookmarkPopup, TQ_SIGNAL( activated( int ) ), &menu, TQ_SLOT( close() ) );
+	
+	int result = menu.exec( TQCursor::pos() );
+	bool doCloseMain = true;
+	
+	krConfig->setGroup( "Private" );
+	
+	switch( result ) {
+	case POPULAR_URLS_ID:
+		krConfig->writeEntry( "BM Popular URLs", !hasPopularURLs );
+		break;
+	case DEVICES_ID:
+		krConfig->writeEntry( "BM Devices", !hasDevices );
+		break;
+	case LAN_ID:
+		krConfig->writeEntry( "BM Lan", !hasLan );
+		break;
+	case VIRTUAL_FS_ID:
+		krConfig->writeEntry( "BM Virtual FS", !hasVirtualFS );
+		break;
+	case JUMP_BACK_ID:
+		krConfig->writeEntry( "BM Jumpback", !hasJumpback );
+		break;
+	default:
+		doCloseMain = false;
+		break;
+	}
+	
+	menu.close();
+	
+	if( doCloseMain && _mainBookmarkPopup )
+		_mainBookmarkPopup->close();
+}
+
+#define OPEN_ID           100200
+#define OPEN_NEW_TAB_ID   100201
+#define DELETE_ID         100202
+
+void KrBookmarkHandler::rightClicked( TQPopupMenu *menu, int /*id*/, KrBookmark * bm ) {
+	TQPopupMenu popup( _mainBookmarkPopup );
+	
+	popup.insertItem( krLoader->loadIcon( "document-open", TDEIcon::Panel ), i18n( "Open" ), OPEN_ID );
+	popup.insertItem( krLoader->loadIcon( "tab_new", TDEIcon::Panel ), i18n( "Open in a new tab" ), OPEN_NEW_TAB_ID );
+	popup.insertSeparator();
+	popup.insertItem( krLoader->loadIcon( "edit-delete", TDEIcon::Panel ), i18n( "Delete" ), DELETE_ID );
+	
+	connect( menu, TQ_SIGNAL( highlighted( int ) ), &popup, TQ_SLOT( close() ) );
+	connect( menu, TQ_SIGNAL( activated( int ) ), &popup, TQ_SLOT( close() ) );
+	
+	int result = popup.exec( TQCursor::pos() );
+	
+	popup.close();
+	if( _mainBookmarkPopup && result >= OPEN_ID && result <= DELETE_ID ) {
+		_mainBookmarkPopup->close();
+	}
+	
+	switch( result ) {
+	case OPEN_ID:
+		SLOTS->refresh( bm->url() );
+		break;
+	case OPEN_NEW_TAB_ID:
+		SLOTS->newTab( bm->url() );
+		break;
+	case DELETE_ID:
+		deleteBookmark( bm );
+		break;
+	}
+}
+
+// used to monitor middle clicks. if mid is found, then the
+// bookmark is opened in a new tab. ugly, but easier than overloading
+// TDEAction and TDEActionCollection.
+void KrBookmarkHandler::slotActivated(const KURL& url) {
+	if (_middleClick)
+		SLOTS->newTab(url);
+	else SLOTS->refresh(url);
+}
+
+
+#include "krbookmarkhandler.moc"
diff --git a/src/app/BookMan/krbookmarkhandler.h b/src/app/BookMan/krbookmarkhandler.h
new file mode 100644
index 0000000..818c3c9
--- /dev/null
+++ b/src/app/BookMan/krbookmarkhandler.h
@@ -0,0 +1,64 @@
+#ifndef KRBOOKMARK_HANDLER_H
+#define KRBOOKMARK_HANDLER_H
+
+#include "krbookmark.h"
+#include <tqobject.h>
+#include <tqguardedptr.h>
+#include <tdepopupmenu.h>
+#include <kurl.h>
+#include <tqptrdict.h>
+#include <tqvaluelist.h>
+#include <tqdom.h>
+#include <tqmap.h>
+
+class TDEActionCollection;
+class KBookmarkManager;
+
+class KrBookmarkHandler: public TQObject {
+	TQ_OBJECT
+  
+	friend class KrAddBookmarkDlg;
+	enum Actions { BookmarkCurrent=0, ManageBookmarks };
+public:
+	KrBookmarkHandler();
+	~KrBookmarkHandler();
+	void populate(TDEPopupMenu *menu);
+	void addBookmark(KrBookmark *bm, KrBookmark *parent = 0);
+	void bookmarkCurrent(KURL url);
+
+protected:
+	void deleteBookmark(KrBookmark *bm);
+	void importFromFile();
+	bool importFromFileBookmark(TQDomElement &e, KrBookmark *parent, TQString path, TQString *errorMsg);
+	bool importFromFileFolder(TQDomNode &first, KrBookmark *parent, TQString path, TQString *errorMsg);
+	void exportToFile();
+	void exportToFileFolder(TQDomDocument &doc, TQDomElement &parent, KrBookmark *folder);
+	void exportToFileBookmark(TQDomDocument &doc, TQDomElement &where, KrBookmark *bm);
+	void clearBookmarks(KrBookmark *root);
+	void buildMenu(KrBookmark *parent, TDEPopupMenu *menu);
+
+	bool eventFilter( TQObject *obj, TQEvent *ev );
+	
+	void rightClicked( TQPopupMenu *menu, int id, KrBookmark *bm );
+	void rightClickOnSpecialBookmark();
+	
+	void removeReferences( KrBookmark *root, KrBookmark *bmToRemove );
+	
+protected slots:
+	void menuOperation(int id);
+	void bookmarksChanged(const TQString&, const TQString&);
+	void slotActivated(const KURL& url);
+
+private:
+	TDEActionCollection *_collection, *_privateCollection;
+	KrBookmark *_root;
+	// the whole KBookmarkManager is an ugly hack. use it until we have our own
+	KBookmarkManager *manager;
+	bool _middleClick; // if true, the user clicked the middle button to open the bookmark
+	
+	TQGuardedPtr<TDEPopupMenu>            _mainBookmarkPopup; // main bookmark popup menu
+	TQValueList<int>                    _specialBookmarkIDs; // the ID list of the special bookmarks
+	TQPtrDict<TQMap<int,KrBookmark*> >   _bookmarkIDTable;    // the IDs of the bookmarks
+};
+
+#endif // KRBOOKMARK_HANDLER_H