Merge branch 'HistoryBookmarksImprovements'

6 files changed, 658 insertions, 125 deletions

diff --git a/src/bookmarks/bookmarksmanager.cpp b/src/bookmarks/bookmarksmanager.cpp
index cfe26a55..9feed63a 100644
--- a/src/bookmarks/bookmarksmanager.cpp
+++ b/src/bookmarks/bookmarksmanager.cpp
@@ -178,7 +178,9 @@ BookmarkProvider::BookmarkProvider(QObject *parent)
             bookfile = KUrl(bookmarksPath);
         }
     }
-    m_manager = KBookmarkManager::managerForExternalFile(bookfile.path());
+    // A workaround to avoid a long delay between the two changed signals of the bookmark manager
+    m_manager = KBookmarkManager::managerForFile(bookfile.path(), "rekonq");
+    
     connect(m_manager, SIGNAL(changed(const QString &, const QString &)),
             this, SLOT(slotBookmarksChanged(const QString &, const QString &)));
 
diff --git a/src/bookmarks/bookmarksmanager.h b/src/bookmarks/bookmarksmanager.h
index d4afb997..e50148e4 100644
--- a/src/bookmarks/bookmarksmanager.h
+++ b/src/bookmarks/bookmarksmanager.h
@@ -210,7 +210,9 @@ public:
      */
     KBookmarkGroup rootGroup();
 
-	KBookmarkManager *bookmarkManager() { return m_manager; }
+    KBookmarkManager *bookmarkManager() { return m_manager; }
+    BookmarkOwner *bookmarkOwner() { return m_owner; }
+    
 signals:
     /**
     * @short This signal is emitted when an url has to be loaded
diff --git a/src/bookmarks/bookmarkspanel.cpp b/src/bookmarks/bookmarkspanel.cpp
index 48ca6537..2f530c6c 100644
--- a/src/bookmarks/bookmarkspanel.cpp
+++ b/src/bookmarks/bookmarkspanel.cpp
@@ -29,6 +29,7 @@
 #include "bookmarkspanel.moc"
 
 // Local Includes
+#include "bookmarksmanager.h"
 #include "bookmarkstreemodel.h"
 #include "bookmarksproxy.h"
 
@@ -44,12 +45,20 @@
 // KDE includes
 #include <KLineEdit>
 #include <KLocalizedString>
+#include <KAction>
+#include <KMenu>
+#include <KBookmarkDialog>
+#include <KMessageBox>
 
 
 BookmarksPanel::BookmarksPanel(const QString &title, QWidget *parent, Qt::WindowFlags flags)
-    : QDockWidget(title, parent, flags)
+    : QDockWidget(title, parent, flags),
+    m_treeView(new UrlTreeView(this)),
+    m_ac(new KActionCollection(this)),
+    m_loadingState(false)
 {
     setup();
+    setupActions();
     setShown(ReKonfig::showBookmarksPanel());
 }
 
@@ -60,13 +69,6 @@ BookmarksPanel::~BookmarksPanel()
 }
 
 
-void BookmarksPanel::bookmarkActivated( const QModelIndex &index )
-{
-    if( index.isValid() )
-        emit openUrl( qVariantValue< KUrl >( index.data( Qt::UserRole ) ) );
-}
-
-
 void BookmarksPanel::setup()
 {
     setObjectName("bookmarksPanel");
@@ -85,19 +87,20 @@ void BookmarksPanel::setup()
     searchLabel->setBuddy( search );
 
     // setup tree view
-    QTreeView *treeView = new QTreeView(ui);
-    treeView->setUniformRowHeights(true);
-    treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
-    treeView->setTextElideMode(Qt::ElideMiddle);
-    treeView->setAlternatingRowColors(true);
-    treeView->header()->hide();
-    treeView->setRootIsDecorated( false );
+    m_treeView->setUniformRowHeights(true);
+    m_treeView->setTextElideMode(Qt::ElideMiddle);
+    m_treeView->setAlternatingRowColors(true);
+    m_treeView->header()->hide();
+    m_treeView->setDragEnabled(true);
+    m_treeView->setAutoExpandDelay(750);
+    m_treeView->setDefaultDropAction(Qt::MoveAction);
+    m_treeView->viewport()->setAcceptDrops(true);
 
     // put everything together
     QVBoxLayout *vBoxLayout = new QVBoxLayout;
     vBoxLayout->setContentsMargins(0, 0, 0, 0);
     vBoxLayout->addLayout(searchLayout);
-    vBoxLayout->addWidget(treeView);
+    vBoxLayout->addWidget(m_treeView);
 
     // add it to the UI
     ui->setLayout(vBoxLayout);
@@ -106,8 +109,375 @@ void BookmarksPanel::setup()
     BookmarksTreeModel *model = new BookmarksTreeModel( this );
     BookmarksProxy *proxy = new BookmarksProxy(ui);
     proxy->setSourceModel( model );
-    treeView->setModel( proxy );
+    m_treeView->setModel( proxy );
+
+    connect(m_treeView, SIGNAL(contextMenuItemRequested(const QPoint &)), this, SLOT(contextMenuBk(const QPoint &)));
+    connect(m_treeView, SIGNAL(contextMenuGroupRequested(const QPoint &)), this, SLOT(contextMenuBkGroup(const QPoint &)));
+    connect(m_treeView, SIGNAL(contextMenuEmptyRequested(const QPoint &)), this, SLOT(contextMenuBlank(const QPoint &)));
+    connect(m_treeView, SIGNAL(delKeyPressed()), this, SLOT(deleteBookmark()));
+    connect(m_treeView, SIGNAL(collapsed(const QModelIndex &)), this, SLOT(onCollapse(const QModelIndex &)));
+    connect(m_treeView, SIGNAL(expanded(const QModelIndex &)), this, SLOT(onExpand(const QModelIndex &)));
+    connect(search, SIGNAL(textChanged(const QString &)), proxy, SLOT(setFilterFixedString(const QString &)));
+    loadFoldedState();
+}
+
+
+void BookmarksPanel::onCollapse(const QModelIndex &index)
+{
+    if(m_loadingState)
+        return;
+
+    KBookmark bookmark = bookmarkForIndex(index);
+    bookmark.internalElement().setAttribute("folded", "yes");
+    emit saveOnlyRequested();
+}
+
+
+void BookmarksPanel::onExpand(const QModelIndex &index)
+{
+    if(m_loadingState)
+        return;
+
+    KBookmark bookmark = bookmarkForIndex(index);
+    bookmark.internalElement().setAttribute("folded", "no");
+    emit saveOnlyRequested();
+}
+
+
+void BookmarksPanel::loadFoldedState()
+{
+    m_loadingState = true;
+    loadFoldedState(QModelIndex());
+    m_loadingState = false;
+}
+
+
+void BookmarksPanel::loadFoldedState(const QModelIndex &root)
+{
+
+    int count = m_treeView->model()->rowCount(root);
+    QModelIndex index;
+
+    for(int i = 0; i < count; i++)
+    {
+        index = m_treeView->model()->index(i, 0, root);
+        if(index.isValid() && bookmarkForIndex(index).isGroup())
+        {
+            m_treeView->setExpanded(index, bookmarkForIndex(index).toGroup().isOpen());
+            loadFoldedState(index);
+        }
+    }
+}
+
+
+void BookmarksPanel::setupActions()
+{
+    KAction* action;
+
+    action = new KAction(KIcon("tab-new"), i18n("Open"), this);
+    connect(action, SIGNAL(triggered()), m_treeView, SLOT(openInCurrentTab()));
+    m_ac->addAction("open", action);
+
+    action = new KAction(KIcon("tab-new"), i18n("Open in New Tab"), this);
+    connect(action, SIGNAL(triggered()), m_treeView, SLOT(openInNewTab()));
+    m_ac->addAction("open_tab", action);
+
+    action = new KAction(KIcon("window-new"), i18n("Open in New Window"), this);
+    connect(action, SIGNAL(triggered()), m_treeView, SLOT(openInNewWindow()));
+    m_ac->addAction("open_window", action);
+
+    action = new KAction(KIcon("bookmark-new"), i18n("Add Bookmark Here"), this);
+    connect(action, SIGNAL(triggered()), this, SLOT(bookmarkCurrentPage()));
+    m_ac->addAction("bookmark_page", action);
+
+    action = new KAction(KIcon("folder-new"), i18n("New Bookmark Folder"), this);
+    connect(action, SIGNAL(triggered()), this, SLOT(newBookmarkGroup()));
+    m_ac->addAction("folder_new", action);
+
+    action = new KAction(KIcon("edit-clear"), i18n("New Separator"), this);
+    connect(action, SIGNAL(triggered()), this, SLOT(newSeparator()));
+    m_ac->addAction("separator_new", action);
+
+    action = new KAction(KIcon("edit-copy"), i18n("Copy Link Address"), this);
+    connect(action, SIGNAL(triggered()), m_treeView, SLOT(copyToClipboard()));
+    m_ac->addAction("copy", action);
+
+    action = new KAction(KIcon("edit-delete"), i18n("Delete Bookmark"), this);
+    connect(action, SIGNAL(triggered()), this, SLOT(deleteBookmark()));
+    m_ac->addAction("delete", action);
+
+    action = new KAction(KIcon("configure"), i18n("Properties"), this);
+    connect(action, SIGNAL(triggered()), this, SLOT(editBookmark()));
+    m_ac->addAction("properties", action);
+
+    action = new KAction(KIcon("tab-new"), i18n("Open Folder in Tabs"), this);
+    connect(action, SIGNAL(triggered()), this, SLOT(openFolderInTabs()));
+    m_ac->addAction("open_all", action);
+}
+
+
+KBookmark BookmarksPanel::bookmarkForIndex(const QModelIndex &index)
+{
+    if(!index.isValid())
+        return KBookmark();
+
+    const QAbstractProxyModel* proxyModel = dynamic_cast< const QAbstractProxyModel* >(index.model());
+    QModelIndex originalIndex = proxyModel->mapToSource(index);
+
+    BtmItem *node = static_cast< BtmItem* >( originalIndex.internalPointer() );
+    return node->getBkm();
+}
+
+
+void BookmarksPanel::contextMenuBk(const QPoint &pos)
+{
+    QPoint position = m_treeView->mapToGlobal(pos);
+    QModelIndex index = m_treeView->indexAt(pos);
+    if(!index.isValid() || m_loadingState)
+        return;
+
+    KBookmark selected = bookmarkForIndex(index);
+
+    if(selected.isGroup())
+    {
+        contextMenuBkGroup(pos, true);
+        return;
+    }
+
+    if(selected.isSeparator())
+    {
+        contextMenuSeparator(pos);
+        return;
+    }
+
+    KMenu *menu = new KMenu(this);
+
+    menu->addAction(m_ac->action("open"));
+    menu->addAction(m_ac->action("open_tab"));
+    menu->addAction(m_ac->action("open_window"));
+
+    menu->addSeparator();
+
+    menu->addAction(m_ac->action("bookmark_page"));
+    menu->addAction(m_ac->action("folder_new"));
+    menu->addAction(m_ac->action("separator_new"));
+
+    menu->addSeparator();
+
+    menu->addAction(m_ac->action("copy"));
+
+    menu->addSeparator();
+
+    menu->addAction(m_ac->action("delete"));
+    menu->addAction(m_ac->action("properties"));
+
+    menu->popup(position);
+}
+
+
+void BookmarksPanel::contextMenuBkGroup(const QPoint &pos, bool emptyGroup)
+{
+    if(m_loadingState)
+        return;
+
+    QPoint position = m_treeView->mapToGlobal(pos);
+    KMenu *menu = new KMenu(this);
+
+    if(!emptyGroup)
+    {
+        menu->addAction(m_ac->action("open_all"));
+        menu->addSeparator();
+    }
+
+    menu->addAction(m_ac->action("bookmark_page"));
+    menu->addAction(m_ac->action("folder_new"));
+    menu->addAction(m_ac->action("separator_new"));
+
+    menu->addSeparator();
+
+    menu->addAction(m_ac->action("delete"));
+    menu->addAction(m_ac->action("properties"));
+
+    menu->popup(position);
+}
+
+
+void BookmarksPanel::contextMenuSeparator(const QPoint &pos)
+{
+    QPoint position = m_treeView->mapToGlobal(pos);
+    KMenu *menu = new KMenu(this);
+
+    menu->addAction(m_ac->action("bookmark_page"));
+    menu->addAction(m_ac->action("folder_new"));
+    menu->addAction(m_ac->action("separator_new"));
+
+    menu->addSeparator();
+
+    menu->addAction(m_ac->action("delete"));
+
+    menu->popup(position);
+}
+
+
+void BookmarksPanel::contextMenuBlank(const QPoint &pos)
+{
+    QPoint position = m_treeView->mapToGlobal(pos);
+    KMenu *menu = new KMenu(this);
+
+    menu->addAction(m_ac->action("bookmark_page"));
+    menu->addAction(m_ac->action("folder_new"));
+    menu->addAction(m_ac->action("separator_new"));
+
+    menu->popup(position);
+}
+
+
+void BookmarksPanel::deleteBookmark()
+{
+    QModelIndex index = m_treeView->currentIndex();
+    if(!index.isValid())
+        return;
+
+    KBookmark bm = bookmarkForIndex(index);
+    bool folder = bm.isGroup();
+
+    if (KMessageBox::warningContinueCancel(
+            QApplication::activeWindow(),
+            folder ? i18n("Are you sure you wish to remove the bookmark folder\n\"%1\"?", bm.text())
+                   : i18n("Are you sure you wish to remove the bookmark\n\"%1\"?", bm.text()),
+            folder ? i18n("Bookmark Folder Deletion")
+                   : i18n("Bookmark Deletion"),
+            KStandardGuiItem::del())
+          != KMessageBox::Continue
+        )
+        return;
+
+
+    bm.parentGroup().deleteBookmark(bm);
+    Application::instance()->bookmarkProvider()->bookmarkManager()->emitChanged();
+}
+
+
+void BookmarksPanel::editBookmark()
+{
+    QModelIndex index = m_treeView->currentIndex();
+    if(!index.isValid())
+        return;
+
+    KBookmark selected = bookmarkForIndex(index);
+
+    KBookmarkDialog *dialog = Application::bookmarkProvider()->bookmarkOwner()->bookmarkDialog(Application::bookmarkProvider()->bookmarkManager(), QApplication::activeWindow());
+    dialog->editBookmark(selected);
+    delete dialog;
+}
+
+
+void BookmarksPanel::openFolderInTabs()
+{
+    QModelIndex index = m_treeView->currentIndex();
+    if(!index.isValid() || !bookmarkForIndex(index).isGroup())
+        return;
+
+    QList<KUrl> allChild = bookmarkForIndex(index).toGroup().groupUrlList();
+
+    if(allChild.length() > 8) // 8, a good choice ?
+    {
+        if(!(KMessageBox::warningContinueCancel(this, i18n("You are about to open a lot of tabs : %1\nAre you sure  ?", QString::number(allChild.length()))) == KMessageBox::Continue))
+            return;
+    }
+
+    for(int i = 0; i < allChild.length(); i++)
+        emit openUrl(allChild.at(i).url(), Rekonq::SettingOpenTab);
+}
+
+
+void BookmarksPanel::newBookmarkGroup()
+{
+    QModelIndex index = m_treeView->currentIndex();
+    KBookmark newBk;
+
+    KBookmarkDialog *dialog = Application::bookmarkProvider()->bookmarkOwner()->bookmarkDialog(Application::bookmarkProvider()->bookmarkManager(), QApplication::activeWindow());
+
+    if(index.isValid())
+    {
+        KBookmark selected = bookmarkForIndex(index);
+
+        if(selected.isGroup())
+        {
+            newBk = dialog->createNewFolder("New folder", selected);
+        }
+
+        else
+        {
+            newBk = dialog->createNewFolder("New folder", selected.parentGroup());
+            selected.parentGroup().moveBookmark(newBk, selected);
+            Application::bookmarkProvider()->bookmarkManager()->emitChanged();
+        } 
+    }
+
+    else
+    {
+        dialog->createNewFolder("New folder");
+    }
+
+    delete dialog;
+}
+
+
+void BookmarksPanel::newSeparator()
+{
+    QModelIndex index = m_treeView->currentIndex();
+
+    KBookmark selected;
+    KBookmark newBk;
+
+    if(index.isValid())
+    {
+        selected = bookmarkForIndex(index);
+
+        if(selected.isGroup())
+            newBk = selected.toGroup().createNewSeparator();
+        else
+            newBk = selected.parentGroup().createNewSeparator();
+    }
+
+    else
+    {
+        newBk = Application::bookmarkProvider()->rootGroup().createNewSeparator();
+    }
+
+    KBookmarkGroup parent = newBk.parentGroup();
+    newBk.setIcon(("edit-clear"));
+    parent.addBookmark(newBk);
+
+    if(index.isValid())
+        parent.moveBookmark(newBk, selected);
+
+    Application::bookmarkProvider()->bookmarkManager()->emitChanged();
+}
+
+
+void BookmarksPanel::bookmarkCurrentPage()
+{
+    QModelIndex index = m_treeView->currentIndex();
+    KBookmarkGroup parent = Application::bookmarkProvider()->rootGroup();
+
+    if(index.isValid())
+    {
+        KBookmark selected = bookmarkForIndex(index);
+        parent = selected.parentGroup();
+
+        if(selected.isGroup())
+            parent = selected.toGroup();
+
+        KBookmark newBk = parent.addBookmark(Application::bookmarkProvider()->bookmarkOwner()->currentTitle(), KUrl(Application::bookmarkProvider()->bookmarkOwner()->currentUrl()), "text-html");
+        parent.moveBookmark(newBk, selected.parentGroup().previous(selected));
+    }
+
+    else
+    {
+       parent.addBookmark(Application::bookmarkProvider()->bookmarkOwner()->currentTitle(), KUrl(Application::bookmarkProvider()->bookmarkOwner()->currentUrl()), "text-html");
+    }
 
-    connect(search, SIGNAL(textChanged(QString)), proxy, SLOT(setFilterFixedString(QString)));
-    connect(treeView, SIGNAL( activated(QModelIndex) ), this, SLOT( bookmarkActivated(QModelIndex) ) );
+    Application::bookmarkProvider()->bookmarkManager()->emitChanged();
 }
diff --git a/src/bookmarks/bookmarkspanel.h b/src/bookmarks/bookmarkspanel.h
index f5376d98..f8528b71 100644
--- a/src/bookmarks/bookmarkspanel.h
+++ b/src/bookmarks/bookmarkspanel.h
@@ -31,10 +31,16 @@
 
 // Local Includes
 #include "rekonqprivate_export.h"
+#include "application.h"
+#include "urltreeview.h"
 
 // Qt Includes
 #include <QDockWidget>
 
+// KDE Includes
+#include <KBookmark>
+#include <KActionCollection>
+
 // Forward Declarations
 class KUrl;
 class QModelIndex;
@@ -49,13 +55,35 @@ public:
     ~BookmarksPanel();
 
 signals:
-    void openUrl(const KUrl &);
+    void openUrl(const KUrl &, const Rekonq::OpenType &);
+    void itemHovered(const QString &);
+    void saveOnlyRequested();
 
 private slots:
-    void bookmarkActivated( const QModelIndex &index );
+    void contextMenuBk(const QPoint &pos);
+    void contextMenuBkGroup(const QPoint &pos, const bool emptyGroup = false);
+    void contextMenuBlank(const QPoint &pos);
+    void deleteBookmark();
+    void openFolderInTabs();
+    void editBookmark();
+    void newBookmarkGroup();
+    void newSeparator();
+    void onCollapse(const QModelIndex &index);
+    void onExpand(const QModelIndex &index);
+    void bookmarkCurrentPage();
+    void loadFoldedState(const QModelIndex &root);
+    void loadFoldedState();
+
 
 private:
     void setup();
+    void setupActions();
+    void contextMenuSeparator(const QPoint &pos);
+    KBookmark bookmarkForIndex(const QModelIndex &index);
+
+    UrlTreeView *m_treeView;
+    KActionCollection *m_ac;
+    bool m_loadingState;
 };
 
 #endif // BOOKMARKSPANEL_H
diff --git a/src/bookmarks/bookmarkstreemodel.cpp b/src/bookmarks/bookmarkstreemodel.cpp
index 95e5ad41..836401a6 100644
--- a/src/bookmarks/bookmarkstreemodel.cpp
+++ b/src/bookmarks/bookmarkstreemodel.cpp
@@ -33,94 +33,112 @@
 #include "application.h"
 #include "bookmarksmanager.h"
 
+// Qt Includes
+#include <QMimeData>
+
 // KDE includes
 #include <KBookmarkGroup>
 #include <KLocalizedString>
 
 
-class BookmarksTreeModel::BtmItem
+BtmItem::BtmItem(const KBookmark &bm)
+    : m_parent(0)
+    , m_kbm(bm)
 {
-public:
-    BtmItem(const KBookmark &bm)
-        : m_parent(0)
-        , m_kbm(bm)
-    {
-    }
-    
-    
-    ~BtmItem()
-    {
-        qDeleteAll(m_children);
-    }
+}
 
 
-    QVariant data( int role = Qt::DisplayRole ) const
-    {
-        if( m_kbm.isNull() )
-            return QVariant();  // should only happen for root item
+BtmItem::~BtmItem()
+{
+    qDeleteAll(m_children);
+}
 
-        if( role == Qt::DisplayRole )
-            return m_kbm.text();
-        if( role == Qt::DecorationRole )
-            return KIcon( m_kbm.icon() );
-        if( role == Qt::UserRole )
-            return m_kbm.url();
 
-        return QVariant();
+QVariant BtmItem::data( int role ) const
+{
+    if( m_kbm.isNull() )
+        return QVariant();  // should only happen for root item
+
+    if( role == Qt::DisplayRole )
+        return m_kbm.text();
+    if( role == Qt::DecorationRole )
+        return KIcon( m_kbm.icon() );
+    if( role == Qt::UserRole )
+        return m_kbm.url();
+    if( role == Qt::ToolTipRole)
+    {
+        QString tooltip = "";
+	
+        if(!m_kbm.text().isEmpty())
+	{
+            tooltip += m_kbm.text();
+	}
+        if(m_kbm.isGroup())
+	{
+            tooltip += " [" + QString::number(childCount()) + " " + i18n("Items") + "]";
+	}
+        if(!m_kbm.url().url().isEmpty())
+        {
+            if(!tooltip.isEmpty())
+                tooltip += "\n";
+            tooltip += m_kbm.url().url();
+        }
+        return tooltip;
     }
 
+    return QVariant();
+}
 
-    int row() const
-    {
-        if(m_parent)
-            return m_parent->m_children.indexOf( const_cast< BtmItem* >( this ) );
-        return 0;
-    }
 
+int BtmItem::row() const
+{
+    if(m_parent)
+        return m_parent->m_children.indexOf( const_cast< BtmItem* >( this ) );
+    return 0;
+}
 
-    int childCount() const
-    {
-        return m_children.count();
-    }
 
+int BtmItem::childCount() const
+{
+    return m_children.count();
+}
 
-    BtmItem* child( int n )
-    {
-        Q_ASSERT(n>=0);
-        Q_ASSERT(n<childCount());
 
-        return m_children.at(n);
-    }
+BtmItem* BtmItem::child( int n )
+{
+    Q_ASSERT(n>=0);
+    Q_ASSERT(n<childCount());
 
+    return m_children.at(n);
+}
 
-    BtmItem* parent() const
-    {
-        return m_parent;
-    }
 
+BtmItem* BtmItem::parent() const
+{
+    return m_parent;
+}
 
-    void appendChild(BtmItem *child)
-    {
-        if( !child )
-            return;
 
-        child->m_parent = this;
-        m_children << child;
-    }
+void BtmItem::appendChild(BtmItem *child)
+{
+    if( !child )
+        return;
 
+    child->m_parent = this;
+    m_children << child;
+}
 
-    void clear()
-    {
-        qDeleteAll(m_children);
-        m_children.clear();
-    }
 
-private:
-    BtmItem *m_parent;
-    QList< BtmItem* > m_children;
-    KBookmark m_kbm;
-};
+void BtmItem::clear()
+{
+    qDeleteAll(m_children);
+    m_children.clear();
+}
 
+KBookmark BtmItem::getBkm() const
+{
+    return m_kbm;
+}
 
 // -------------------------------------------------------------------------------------
 
@@ -130,8 +148,9 @@ BookmarksTreeModel::BookmarksTreeModel(QObject *parent)
     , m_root(0)
 {
     resetModel();
-    connect( Application::bookmarkProvider()->bookmarkManager(), SIGNAL( changed(QString,QString) ), this, SLOT( bookmarksChanged(QString) ) );
-    connect( Application::bookmarkProvider()->bookmarkManager(), SIGNAL( bookmarksChanged(QString) ), this, SLOT( bookmarksChanged(QString) ) );
+    connect( this, SIGNAL(bookmarksUpdated()), parent, SLOT(loadFoldedState()));
+    connect( Application::bookmarkProvider()->bookmarkManager(), SIGNAL( changed(QString,QString) ), this, SLOT( bookmarksChanged() ) );
+    connect( parent, SIGNAL(saveOnlyRequested()), this, SLOT(saveOnly()) );
 }
 
 
@@ -179,8 +198,17 @@ QVariant BookmarksTreeModel::headerData(int section, Qt::Orientation orientation
 
 Qt::ItemFlags BookmarksTreeModel::flags(const QModelIndex &index) const
 {
-    Q_UNUSED(index)
-    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
+    Qt::ItemFlags flags = QAbstractItemModel::flags(index);
+    
+    if(!index.isValid())
+        return flags | Qt::ItemIsDropEnabled;
+
+    flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
+
+    if(bookmarkForIndex(index).isGroup())
+        flags |= Qt::ItemIsDropEnabled;
+    
+    return flags;
 }
 
 
@@ -256,32 +284,10 @@ QVariant BookmarksTreeModel::data(const QModelIndex &index, int role) const
 }
 
 
-void BookmarksTreeModel::bookmarksChanged( const QString &groupAddress )
+void BookmarksTreeModel::bookmarksChanged()
 {
-    if( groupAddress.isEmpty() )
-    {
-        resetModel();
-        return;
-    }
-
-    BtmItem *node = m_root;
-    QModelIndex nodeIndex;
-
-    QStringList indexChain( groupAddress.split( '/', QString::SkipEmptyParts) );
-    foreach( const QString &sIndex, indexChain ) 
-    {
-        bool ok;
-        int i = sIndex.toInt( &ok );
-        if( !ok )
-            break;
-
-        if( i < 0 || i >= node->childCount() )
-            break;
-
-        node = node->child( i );
-        nodeIndex = index( i, 0, nodeIndex );
-    }
-    emit dataChanged( index( 0, 0, nodeIndex ), index( node->childCount(), 0, nodeIndex ) );
+    resetModel();
+    emit bookmarksUpdated();
 }
 
 
@@ -322,3 +328,100 @@ void BookmarksTreeModel::populate( BtmItem *node, KBookmarkGroup bmg)
         bm = bmg.next( bm );
     }
 }
+
+
+KBookmark BookmarksTreeModel::bookmarkForIndex(const QModelIndex index) const
+{
+    return static_cast<BtmItem*>(index.internalPointer())->getBkm();
+}
+
+
+void BookmarksTreeModel::saveOnly()
+{
+    disconnect(Application::bookmarkProvider()->bookmarkManager(), SIGNAL(changed(QString,QString)), this, SLOT(bookmarksChanged()));
+    connect(Application::bookmarkProvider()->bookmarkManager(), SIGNAL(changed(QString,QString)), this, SLOT(reconnectManager()));
+    Application::bookmarkProvider()->bookmarkManager()->emitChanged();
+}
+
+
+void BookmarksTreeModel::reconnectManager()
+{
+    connect(Application::bookmarkProvider()->bookmarkManager(), SIGNAL( changed(QString,QString) ), this, SLOT(bookmarksChanged()));
+}
+
+
+Qt::DropActions BookmarksTreeModel::supportedDropActions () const
+{
+    return Qt::MoveAction;
+}
+
+
+QStringList BookmarksTreeModel::mimeTypes () const
+{
+    return KBookmark::List::mimeDataTypes();
+}
+
+
+QMimeData* BookmarksTreeModel::mimeData( const QModelIndexList & indexes ) const
+{
+    QMimeData *mimeData = new QMimeData;
+
+    QByteArray addresse = bookmarkForIndex(indexes.first()).address().toLatin1();
+    mimeData->setData( "application/rekonq-bookmark", addresse);
+    bookmarkForIndex(indexes.first()).populateMimeData(mimeData);
+
+    return mimeData;
+}
+
+
+bool BookmarksTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex & parent)
+{
+    if(action == Qt::MoveAction)
+    {
+        if(data->hasFormat("application/rekonq-bookmark"))
+        {
+            QByteArray addresses = data->data("application/rekonq-bookmark");
+            KBookmark bookmark = Application::bookmarkProvider()->bookmarkManager()->findByAddress(QString::fromLatin1(addresses.data()));
+
+            QModelIndex destIndex = index(row, column, parent);
+
+            KBookmark dropDestBookmark;
+            if(destIndex.isValid())
+                dropDestBookmark = bookmarkForIndex(destIndex);
+
+            KBookmarkGroup root = Application::bookmarkProvider()->rootGroup();
+            if(parent.isValid())
+                root = bookmarkForIndex(parent).toGroup();
+
+            if(!destIndex.isValid())
+            {
+                if(!parent.isValid()) // Drop into a blank area
+                {
+                    Application::bookmarkProvider()->rootGroup().deleteBookmark(bookmark);
+                    Application::bookmarkProvider()->rootGroup().addBookmark(bookmark);
+                }
+                else // Drop at the last item of the group or directly on the main item of the group
+                {
+                    root.deleteBookmark(bookmark);
+                    root.addBookmark(bookmark);
+                }
+            }
+
+            else
+            {
+                if(row == -1)
+                {
+                    root.deleteBookmark(bookmark);
+                    root.addBookmark(bookmark);
+                }
+                else // A classic drop
+                {
+                    root.moveBookmark(bookmark, root.previous(dropDestBookmark));
+                }
+            }
+
+            Application::bookmarkProvider()->bookmarkManager()->emitChanged(root);
+        }
+    }
+    return true;
+}
diff --git a/src/bookmarks/bookmarkstreemodel.h b/src/bookmarks/bookmarkstreemodel.h
index dfad52ba..b312ab2d 100644
--- a/src/bookmarks/bookmarkstreemodel.h
+++ b/src/bookmarks/bookmarkstreemodel.h
@@ -38,6 +38,26 @@
 // Qt Includes
 #include <QAbstractItemModel>
 
+class BtmItem
+{
+public:
+    BtmItem(const KBookmark &bm);
+    ~BtmItem();
+    QVariant data( int role = Qt::DisplayRole ) const;
+    int row() const;
+    int childCount() const;
+    BtmItem* child( int n );
+    BtmItem* parent() const;
+    void appendChild(BtmItem *child);
+    void clear();
+    KBookmark getBkm() const;
+
+private:
+    BtmItem *m_parent;
+    QList< BtmItem* > m_children;
+    KBookmark m_kbm;
+};
+
 
 class REKONQ_TESTS_EXPORT BookmarksTreeModel : public QAbstractItemModel
 {
@@ -48,28 +68,36 @@ public:
     explicit BookmarksTreeModel(QObject *parent = 0);
     ~BookmarksTreeModel();
 
-	virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
     virtual int columnCount(const QModelIndex &parent = QModelIndex()) const;
 
-	virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
-	virtual Qt::ItemFlags flags(const QModelIndex &index) const;
+    virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const;
 
-	virtual QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+    virtual QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
     virtual QModelIndex parent(const QModelIndex &index) const;
-	virtual QVariant data(const QModelIndex &index, int role) const;
-//     virtual bool setData(const QModelIndex &index, const QVariant &value, int role);
+    virtual QVariant data(const QModelIndex &index, int role) const;
+
+    virtual QStringList mimeTypes () const;
+    virtual bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent);
+    virtual Qt::DropActions supportedDropActions () const;
+    virtual QMimeData *mimeData( const QModelIndexList & indexes ) const;
 
 private slots:
-	void bookmarksChanged( const QString &groupAddress );
+    void bookmarksChanged();
+    void saveOnly();
+    void reconnectManager();
 
-private:
-	class BtmItem;
-	BtmItem *m_root;
+signals:
+    void bookmarksUpdated();
 
-	void resetModel();
+private:
+    BtmItem *m_root;
 
+    void resetModel();
     void setRoot(KBookmarkGroup bmg);
-	void populate( BtmItem *node, KBookmarkGroup bmg);
+    void populate( BtmItem *node, KBookmarkGroup bmg);
+    KBookmark bookmarkForIndex(const QModelIndex index) const;
 };
 
 #endif // BOOKMARKSTREEMODEL_H