summaryrefslogtreecommitdiffstats
path: root/src/app/BookMan
diff options
context:
space:
mode:
Diffstat (limited to 'src/app/BookMan')
-rw-r--r--src/app/BookMan/Makefile.am11
-rw-r--r--src/app/BookMan/kraddbookmarkdlg.cpp117
-rw-r--r--src/app/BookMan/kraddbookmarkdlg.h40
-rw-r--r--src/app/BookMan/krbookmark.cpp92
-rw-r--r--src/app/BookMan/krbookmark.h46
-rw-r--r--src/app/BookMan/krbookmarkbutton.cpp38
-rw-r--r--src/app/BookMan/krbookmarkbutton.h24
-rw-r--r--src/app/BookMan/krbookmarkhandler.cpp576
-rw-r--r--src/app/BookMan/krbookmarkhandler.h64
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
generated by cgit v1.2.3 (git 2.46.0) at 2025-09-14 12:30:01 +0000