Bookmarks classes refactored

2 files changed, 277 insertions, 130 deletions

diff --git a/src/bookmarks.cpp b/src/bookmarks.cpp
index 92947fd6..fc69b88f 100644
--- a/src/bookmarks.cpp
+++ b/src/bookmarks.cpp
@@ -26,75 +26,137 @@
 // Local Includes
 #include "mainwindow.h"
 #include "webview.h"
+#include "application.h"
 
 // KDE Includes
-#include <KMimeType>
+#include <KActionCollection>
+#include <KBookmark>
+#include <KBookmarkAction>
+#include <KBookmarkActionMenu>
+#include <KBookmarkGroup>
+#include <KBookmarkMenu>
+#include <KToolBar>
+#include <KDebug>
 #include <KMenu>
+#include <KMimeType>
 #include <KStandardDirs>
-#include <KDebug>
+#include <KUrl>
 
 // Qt Includes
+#include <QActionGroup>
 #include <QFile>
 
 
-OwnBookMarks::OwnBookMarks(KMainWindow *parent)
+BookmarkOwner::BookmarkOwner(QObject *parent)
         : QObject(parent)
         , KBookmarkOwner()
 {
-    m_parent = qobject_cast<MainWindow*>(parent);
-    connect(this, SIGNAL(openUrl(const KUrl &)) , parent , SLOT(loadUrl(const KUrl &)));
 }
 
 
-void OwnBookMarks::openBookmark(const KBookmark & b, Qt::MouseButtons mb, Qt::KeyboardModifiers km)
+void BookmarkOwner::openBookmark(const KBookmark & bookmark, 
+                                 Qt::MouseButtons mouseButtons, 
+                                 Qt::KeyboardModifiers keyboardModifiers)
 {
-    Q_UNUSED(mb);
-    Q_UNUSED(km);
-    emit openUrl(b.url());
+    Q_UNUSED(mouseButtons) 
+    Q_UNUSED(keyboardModifiers)
+
+    // FIXME this is workaround for double call issue
+    // When middle mouse button is clicked this method is called twice
+    static bool isDouble = false;
+    if (isDouble)
+    {
+        isDouble = false;
+        return;
+    }
+    //--
+
+    emit openUrl(bookmark.url());
 }
 
 
-QString OwnBookMarks::currentUrl() const
+QString BookmarkOwner::currentUrl() const
 {
-    QUrl url = m_parent->currentTab()->url();
-    return url.path();
+    return Application::instance()->mainWindow()->currentTab()->url().url();
 }
 
 
-QString OwnBookMarks::currentTitle() const
+QString BookmarkOwner::currentTitle() const
 {
-    QString title = m_parent->windowTitle();
-    return title.remove(" - rekonq");
+    return Application::instance()->mainWindow()->currentTab()->title();
 }
 
 
+// QList< QPair<QString, QString> > BookmarkOwner::currentBookmarkList() const
+// {
+//     QList< QPair<QString, QString> > list;
+//     QList<WebView *> tabs = Application::instance()->mainWindow()->mainView()->tabs();
+//     foreach(WebView *tab, tabs)
+//     {
+//         QString url = tab->url().url();
+//         QString title = tab->title();
+//         list.append(QPair<QString, QString>(url, title));
+//     }
+//     return list;
+// }
+
+
 // ------------------------------------------------------------------------------------------------------
 
 
-BookmarksMenu::BookmarksMenu(KBookmarkManager* manager, KBookmarkOwner* owner, KMenu* menu, KActionCollection* ac)
-        : KBookmarkMenu(manager, owner, menu, ac)
+BookmarkMenu::BookmarkMenu(KBookmarkManager *manager,
+                           KBookmarkOwner *owner,
+                           KMenu *menu,
+                           KActionCollection* actionCollection)
+        : KBookmarkMenu(manager, owner, menu, actionCollection) 
+        
 {
+    actionCollection->addAction(KStandardAction::AddBookmark,
+                                QLatin1String("add_bookmark_payload"), 
+                                this, SLOT(slotAddBookmark()));
+
 }
 
+BookmarkMenu::~BookmarkMenu()
+{
+}
 
-KMenu* BookmarksMenu::viewContextMenu(QAction* action)
+        
+KMenu *BookmarkMenu::viewContextMenu(QAction *action)
 {
     return contextMenu(action);
 }
 
 
+void BookmarkMenu::slotAddBookmark()
+{
+    KAction *action = qobject_cast<KAction *>(sender());
+    if (action && !action->data().isNull())
+    {
+        KBookmarkGroup parentBookmark = manager()->findByAddress(parentAddress()).toGroup();
+        /// TODO Add bookmark Icon
+        parentBookmark.addBookmark(owner()->currentTitle(), action->data().toUrl());
+        manager()->emitChanged();
+        return;
+    }
+    
+    KBookmarkMenu::slotAddBookmark();
+}
+
+
 // ------------------------------------------------------------------------------------------------------
 
 
-BookmarksProvider::BookmarksProvider(KMainWindow* parent)
-        : QObject(parent)
-        , m_owner(new OwnBookMarks(parent))
-        , m_bmMenu(0)
-        , m_bmToolbar(0)
+BookmarkProvider::BookmarkProvider(QWidget *parent)
+        : QWidget(parent)
+        , m_manager(NULL)
+        , m_owner(NULL)
+        , m_menu(new KMenu(this))
+        , m_actionCollection(new KActionCollection(this))
+        , m_bookmarkMenu(NULL)
+        , m_bookmarkToolBar(NULL)
 {
-    m_parent = parent;
-
-    KUrl bookfile = KUrl("~/.kde/share/apps/konqueror/bookmarks.xml");      // share konqueror bookmarks
+    KUrl bookfile = KUrl("~/.kde/share/apps/konqueror/bookmarks.xml");  // share konqueror bookmarks
 
     if (!QFile::exists(bookfile.path()))
     {
@@ -112,73 +174,114 @@ BookmarksProvider::BookmarksProvider(KMainWindow* parent)
         }
     }
     m_manager = KBookmarkManager::managerForExternalFile(bookfile.path());
-    m_ac = new KActionCollection(this);
+    connect(m_manager, SIGNAL(changed(const QString &, const QString &)), 
+            this, SLOT(slotBookmarksChanged(const QString &, const QString &)));
 
-    connect(m_manager, SIGNAL(changed(const QString &, const QString &)), this, SLOT(slotBookmarksChanged(const QString &)));
-}
+    // setup menu
+    m_owner = new BookmarkOwner(this);
+    connect(m_owner, SIGNAL(openUrl(const KUrl& )), this, SIGNAL(openUrl(const KUrl& )));
+    m_bookmarkMenu = new BookmarkMenu(m_manager, m_owner, m_menu, m_actionCollection);
+
+    // setup toolbar
+    setupToolBar();
 
+}
 
-void BookmarksProvider::slotBookmarksChanged(const QString & group)
+BookmarkProvider::~BookmarkProvider()
 {
-    KBookmarkGroup toolbarGroup = m_manager->toolbar();
-    kWarning() << "KBookmarkBar::slotBookmarksChanged( " << group << " )";
+    delete m_bookmarkToolBar;
+    delete m_bookmarkMenu;
+    delete m_actionCollection;
+    delete m_menu;
+    delete m_owner;
+    delete m_manager;
+}
 
-    if (toolbarGroup.isNull())
-        return;
 
-    m_bmToolbar->clear();
-    provideBmToolbar(m_bmToolbar);
+void BookmarkProvider::setupToolBar()
+{
+    m_bookmarkToolBar = new KToolBar(this);
+    m_bookmarkToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
+    m_bookmarkToolBar->setIconDimensions(16);
+    m_bookmarkToolBar->setAcceptDrops(true);
+    m_bookmarkToolBar->setContentsMargins(0, 0, 0, 0);
+    m_bookmarkToolBar->setMinimumHeight(16);
+    m_bookmarkToolBar->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(m_bookmarkToolBar, SIGNAL(customContextMenuRequested(const QPoint &)), 
+            this, SLOT(contextMenu(const QPoint &)));
+             
+    slotBookmarksChanged("", "");
 }
 
 
-void BookmarksProvider::provideBmToolbar(KToolBar* toolbar)
+void BookmarkProvider::slotBookmarksChanged(const QString &group, const QString &caller)
 {
-    m_bmToolbar = toolbar;
-    toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
+    Q_UNUSED(group)
+    Q_UNUSED(caller)
 
-    toolbar->setContextMenuPolicy(Qt::CustomContextMenu);
-    connect(toolbar, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(contextMenu(const QPoint &)));
-
-    KBookmarkGroup toolbarGroup = m_manager->toolbar();
-    KBookmark bm = toolbarGroup.first();
-    while (!bm.isNull())
+    if (!m_bookmarkToolBar)
     {
-        if (bm.isGroup())
-        {
-            // do nothing!
-        }
-        else
+        kWarning() << "There is no bookmark toolbar";
+        return;
+    }
+    
+    KActionCollection bookmarkCollection(this);
+    
+    KBookmarkGroup toolBarGroup = m_manager->toolbar();
+    if (toolBarGroup.isNull())
+        return;
+    
+    KBookmark bookmark = toolBarGroup.first();
+    while (!bookmark.isNull()) {
+        if (!bookmark.isGroup())
         {
-            if (bm.isSeparator())
-            {
-                toolbar->addSeparator();
-            }
-            else
-            {
-                KAction *a = new KBookmarkAction(bm, m_owner, m_ac);
-                toolbar->addAction(a);
-            }
+            KAction *action = new KBookmarkAction(bookmark, m_owner, this);
+            QString text = bookmark.address();
+            bookmarkCollection.addAction(text, action);
         }
-        // go ahead!
-        bm = toolbarGroup.next(bm);
+        bookmark = toolBarGroup.next(bookmark);
     }
+    m_bookmarkToolBar->clear();
+    m_bookmarkToolBar->addActions(bookmarkCollection.actions());
 }
 
 
-KMenu *BookmarksProvider::bookmarksMenu()
-{
-    KMenu *menu = new KMenu(m_parent);
-    m_bmMenu = new BookmarksMenu(m_manager, m_owner, menu, m_ac);
-    return menu;
+QAction *BookmarkProvider::actionByName(const QString &name)
+{   
+    QAction *action = m_actionCollection->action(name);
+    if (action)
+        return action;
+    /* else */
+    kWarning() << "Action named: " << name << " not found, returning empty action.";
+    return new QAction(this);  // return empty object instead of NULL pointer
 }
 
 
-void BookmarksProvider::contextMenu(const QPoint & point)
+void BookmarkProvider::contextMenu(const QPoint &point)
 {
-    KAction* action = dynamic_cast<KAction*>(m_bmToolbar->actionAt(point));
+    KAction* action = dynamic_cast<KAction*>(m_bookmarkToolBar->actionAt(point));
     if (!action)
         return;
-    KMenu *menu = m_bmMenu->viewContextMenu(action);
-    menu->setAttribute(Qt::WA_DeleteOnClose);
-    menu->popup(m_bmToolbar->mapToGlobal(point));
+    KMenu *menu = m_bookmarkMenu->viewContextMenu(action);
+    menu->popup(m_bookmarkToolBar->mapToGlobal(point));
+}
+
+
+KActionMenu* BookmarkProvider::bookmarkActionMenu()
+{
+    KActionMenu *bookmarkActionMenu = new KActionMenu(this);
+    bookmarkActionMenu->setMenu(m_menu);
+    bookmarkActionMenu->setText(i18n("&Bookmarks"));
+    return bookmarkActionMenu;
 }
+
+
+KAction* BookmarkProvider::bookmarkToolBarAction()
+{
+    KAction *bookmarkToolBarAction = new KAction(this);
+    bookmarkToolBarAction->setDefaultWidget(m_bookmarkToolBar);  // The ownership is transferred to action
+    bookmarkToolBarAction->setText(i18n("Bookmarks Bar"));
+    bookmarkToolBarAction->setShortcutConfigurable(false);
+    return bookmarkToolBarAction;
+}
+
diff --git a/src/bookmarks.h b/src/bookmarks.h
index f31cea62..6a476a97 100644
--- a/src/bookmarks.h
+++ b/src/bookmarks.h
@@ -22,54 +22,55 @@
 #ifndef BOOKMARKS_H
 #define BOOKMARKS_H
 
+// Qt Includes
+#include <QWidget>
 
 // KDE Includes
 #include <KBookmarkOwner>
-#include <KBookmarkManager>
-#include <KBookmarkMenu>
-#include <KUrl>
-#include <KMenu>
-#include <KActionCollection>
-#include <KMainWindow>
-
 
 // Forward Declarations
-class MainWindow;
+class BookmarkProvider;
+
+class KAction;
+class KActionCollection;
+class KActionMenu;
+class KUrl;
+class KToolBar;
+class KBookmarkManager;
 
 
 /**
- * Inherited from KBookmarkOwner, this class allows to manage
+ * Reimplementation of KBookmarkOwner, this class allows to manage
  * bookmarks as actions
  *
- * @author Andrea Diamantini <adjam7@gmail.com>
- * @since 4.x
  */
-class OwnBookMarks : public QObject , public KBookmarkOwner
+class BookmarkOwner : public QObject , public KBookmarkOwner
 {
     Q_OBJECT
 
 public:
 
     /**
-     * The class ctor.
+     * @short The class constructor.
      *
-     * @param parent the pointer to the browser mainwindow. We need it
-     *               to link bookmarks actions with the right window
-     *               where load url in
+     * @param parent the pointer parent Bookmark provider. We need it
+     *               to get pointer to MainWindow
      */
-    OwnBookMarks(KMainWindow *parent);
+    BookmarkOwner(QObject *parent=0);
+    virtual ~BookmarkOwner() {}
 
     /**
      * This function is called when a bookmark is selected and belongs to
      * the ancestor class.
-     * This method actually emits signal to load bookmark's url without
-     * considering mousebuttons or keyboard modifiers.
+     * This method actually emits signal to load bookmark's url.
      *
-     * @param b  the bookmark to open
-     * @param mb the mouse buttons clicked to select the bookmark
-     * @param km the keyboard modifiers pushed when the bookmark was selected
+     * @param bookmark          the bookmark to open
+     * @param mouseButtons      the mouse buttons clicked to select the bookmark
+     * @param keyboardModifiers the keyboard modifiers pushed when the bookmark was selected
      */
-    virtual void openBookmark(const KBookmark &b , Qt::MouseButtons mb, Qt::KeyboardModifiers km);
+    virtual void openBookmark(const KBookmark &bookmark, 
+                              Qt::MouseButtons mouseButtons, 
+                              Qt::KeyboardModifiers keyboardModifiers);
 
 
     /**
@@ -88,6 +89,11 @@ public:
      */
     virtual QString currentTitle() const;
 
+    /**
+    * This function returns whether the owner supports tabs.
+    */
+    virtual bool supportsTabs() const { return true; }
+
 signals:
     /**
      * This signal is emitted when an url has to be loaded
@@ -98,30 +104,36 @@ signals:
     void openUrl(const KUrl &);
 
 private:
-    // the MainWindow pointer
-    MainWindow *m_parent;
-};
 
+};
 
 // ------------------------------------------------------------------------------
 
 
+#include <KBookmarkMenu>
+
+
 /**
  * This class represent the rekonq bookmarks menu.
  * It's just a simple class inherited from KBookmarkMenu
  *
- * @author Andrea Diamantini <adjam7@gmail.com>
- * @since 4.x
- *
  */
-class BookmarksMenu : public KBookmarkMenu
+class BookmarkMenu : public KBookmarkMenu
 {
     Q_OBJECT
 
 public:
-    BookmarksMenu(KBookmarkManager* manager, KBookmarkOwner* owner, KMenu* menu, KActionCollection* ac);
-
-    KMenu *viewContextMenu(QAction* action);
+    BookmarkMenu(KBookmarkManager* manager, 
+                 KBookmarkOwner* owner, 
+                 KMenu* menu, 
+                 KActionCollection* actionCollection);
+    ~BookmarkMenu();
+    
+    virtual KMenu *viewContextMenu(QAction* action);
+    
+protected slots:
+    void slotAddBookmark();
+        
 };
 
 
@@ -134,50 +146,82 @@ public:
  * from this class.
  * So it implements code to have each one
  *
- * @author Andrea Diamantini <adjam7@gmail.com>
- * @since 4.x
  *
  */
-class BookmarksProvider : public QObject
+class BookmarkProvider : public QWidget
 {
     Q_OBJECT
 
 public:
     /**
-     * Class constructor. Connect BookmarksProvider with bookmarks source
-     * (actually konqueror's bookmarks)
-     *
-     * @param parent The MainWindow to provide bookmarks objects
-     *
+    * @short Class constructor.
+    * Connect BookmarksProvider with bookmarks source
+    * (actually konqueror's bookmarks)
+    * @param parent The MainWindow to provide bookmarks objects
+    *
+    */
+    BookmarkProvider(QWidget* parent=0);
+    ~BookmarkProvider();
+    
+    /**
+     * @short Get the Bookmarks Menu Action
+     * @return the Bookmarks Menu
      */
-    BookmarksProvider(KMainWindow* parent);
+    KActionMenu *bookmarkActionMenu();
+
 
     /**
-     * Customize bookmarks toolbar
-     *
-     * @param toolbar the toolbar to customize
-     */
-    void provideBmToolbar(KToolBar* toolbar);
+    * @short Get the Bookmarks Toolbar Action
+    * @return the Bookmarks Toolbar Action
+    */
+    KAction *bookmarkToolBarAction();
+
 
     /**
-     * Generate the Bookmarks Menu
-     *
-     * @return the Bookmarks Menu
-     *
+     * @short Get action by name
+     * This method returns poiner bookmark action of given name.
+     * @pre m_actionCollection != NULL
+     * @param name Name of action you want to get
+     * @return It returns actions if one exists or empty object
      */
-    KMenu *bookmarksMenu();
+    QAction *actionByName(const QString &name);
+
+signals:
+    /**
+    * @short This signal is emitted when an url has to be loaded
+    *
+    * @param url the URL to load
+    */
+    void openUrl(const KUrl &url);
+
 
 public slots:
-    void contextMenu(const QPoint & point);
-    void slotBookmarksChanged(const QString &);
+    /**
+     * @short Opens the context menu on given position
+     * @param point Point on whitch you want to open this menu
+     */
+    void contextMenu(const QPoint &point);
+    
+    /**
+     * @short Waits for signal that the group with the address has been modified by the caller.
+     * Waits for signal that the group (or any of its children) with the address
+     * @p groupAddress (e.g. "/4/5") has been modified by the caller @p caller.
+     * 
+     * @param group bookmark group adress
+     * @param caller caller that modified the bookmarks
+     * @see  KBookmarkManager::changed
+     */
+    void slotBookmarksChanged(const QString &group, const QString &caller);
 
 private:
-    KMainWindow *m_parent;
-    OwnBookMarks *m_owner;
+    void setupToolBar();
+
     KBookmarkManager *m_manager;
-    KActionCollection *m_ac;
-    BookmarksMenu *m_bmMenu;
-    KToolBar *m_bmToolbar;
+    BookmarkOwner *m_owner;
+    KMenu *m_menu;
+    KActionCollection *m_actionCollection;
+    BookmarkMenu *m_bookmarkMenu;
+    KToolBar *m_bookmarkToolBar;
 };
 
 #endif