Merge branch 'master' of git://gitorious.org/rekonq/mainline into i18n

1 files changed, 228 insertions, 50 deletions

diff --git a/src/bookmarks/bookmarksmanager.cpp b/src/bookmarks/bookmarksmanager.cpp
index 6442192a..df6bc54b 100644
--- a/src/bookmarks/bookmarksmanager.cpp
+++ b/src/bookmarks/bookmarksmanager.cpp
@@ -2,9 +2,10 @@
 *
 * This file is a part of the rekonq project
 *
-* Copyright (C) 2008-2009 by Andrea Diamantini <adjam7 at gmail dot com>
+* Copyright (C) 2008-2010 by Andrea Diamantini <adjam7 at gmail dot com>
 * Copyright (C) 2009 by Paweł Prażak <pawelprazak at gmail dot com>
-* Copyright (C) 2009 by Lionel Chauvin <megabigbug@yahoo.fr>
+* Copyright (C) 2009-2010 by Lionel Chauvin <megabigbug@yahoo.fr>
+* Copyright (C) 2010 by Yoann Laissus <yoann dot laissus at gmail dot com>
 *
 *
 * This program is free software; you can redistribute it and/or
@@ -34,28 +35,28 @@
 #include "mainwindow.h"
 #include "webtab.h"
 #include "webview.h"
+#include "mainview.h"
+#include "bookmarkcontextmenu.h"
 
 // KDE Includes
 #include <KActionCollection>
-#include <KBookmark>
 #include <KBookmarkAction>
 #include <KBookmarkGroup>
-#include <KBookmarkMenu>
 #include <KToolBar>
 #include <KDebug>
 #include <KMenu>
 #include <KStandardDirs>
 #include <KUrl>
+#include <KMessageBox>
 
 // Qt Includes
 #include <QtCore/QFile>
 #include <QtGui/QActionGroup>
 
 
-
 BookmarkOwner::BookmarkOwner(QObject *parent)
-        : QObject(parent)
-        , KBookmarkOwner()
+    : QObject(parent)
+    , KBookmarkOwner()
 {
 }
 
@@ -66,7 +67,7 @@ void BookmarkOwner::openBookmark(const KBookmark & bookmark,
 {
     if (keyboardModifiers & Qt::ControlModifier || mouseButtons == Qt::MidButton)
     {
-        emit openUrl(bookmark.url(), Rekonq::NewCurrentTab);
+        emit openUrl(bookmark.url(), Rekonq::SettingOpenTab);
     }
     else
     {
@@ -93,14 +94,37 @@ QString BookmarkOwner::currentTitle() const
 }
 
 
-void BookmarkOwner::openFolderinTabs(const KBookmarkGroup &bm)
+void BookmarkOwner::openFolderinTabs(const KBookmarkGroup &bookmark)
 {
-    QList<KUrl> urlList = bm.groupUrlList();
+    QList<KUrl> urlList = bookmark.groupUrlList();
+
+    if(urlList.length() > 8)
+    {
+        if(!(KMessageBox::warningContinueCancel(Application::instance()->mainWindow(), i18n("You are about to open %1 tabs.\nAre you sure  ?", QString::number(urlList.length()))) == KMessageBox::Continue))
+            return;
+    }
+
     QList<KUrl>::iterator url;
     for (url = urlList.begin(); url != urlList.end(); ++url)
     {
-        Application::instance()->loadUrl(*url, Rekonq::NewCurrentTab);
+        emit openUrl(*url, Rekonq::NewCurrentTab);
+    }
+}
+
+
+QList< QPair<QString, QString> > BookmarkOwner::currentBookmarkList() const
+{
+    QList< QPair<QString, QString> > bkList;
+    int tabNumber = Application::instance()->mainWindow()->mainView()->count();
+
+    for(int i = 0; i < tabNumber; i++)
+    {
+        QPair<QString, QString> item;
+        item.first = Application::instance()->mainWindow()->mainView()->webTab(i)->view()->title();
+        item.second = Application::instance()->mainWindow()->mainView()->webTab(i)->url().url();
+        bkList += item;
     }
+    return bkList;
 }
 
 
@@ -111,27 +135,36 @@ BookmarkMenu::BookmarkMenu(KBookmarkManager *manager,
                            KBookmarkOwner *owner,
                            KMenu *menu,
                            KActionCollection* actionCollection)
-        : KBookmarkMenu(manager, owner, menu, actionCollection)
-
+    : KBookmarkMenu(manager, owner, menu, actionCollection)
 {
     KAction *a = KStandardAction::addBookmark(this, SLOT(slotAddBookmark()), this);
-//     a->setText(i18n("Bookmark this Page"));
     actionCollection->addAction(QLatin1String("rekonq_add_bookmark"),a);
+    refill();
 }
 
+
+BookmarkMenu::BookmarkMenu(KBookmarkManager  *manager,
+                           KBookmarkOwner  *owner,
+                           KMenu  *parentMenu,
+                           const QString &parentAddress)
+    : KBookmarkMenu(manager, owner, parentMenu, parentAddress)
+{
+    refill();
+}
+
+
 BookmarkMenu::~BookmarkMenu()
 {
 }
 
 
-KMenu *BookmarkMenu::viewContextMenu(QAction *action)
+KMenu * BookmarkMenu::contextMenu(QAction *act)
 {
-    // contextMenu() returns an invalid  KMenu (seg fault) for the folders in the toolbar
-    KMenu *menu = contextMenu(action);
-    if(menu)
-        return menu;
 
-    return 0;   // new KMenu();
+    KBookmarkActionInterface* action = dynamic_cast<KBookmarkActionInterface *>(act);
+     if (!action)
+         return 0;
+     return new BookmarkContextMenu(action->bookmark(), manager(), owner());
 }
 
 
@@ -151,6 +184,76 @@ void BookmarkMenu::slotAddBookmark()
 }
 
 
+QAction * BookmarkMenu::actionForBookmark(const KBookmark &bookmark)
+{
+    if(bookmark.isGroup())
+    {
+        KBookmarkActionMenu *actionMenu = new KBookmarkActionMenu(bookmark, this);
+        new BookmarkMenu(manager(), owner(), actionMenu->menu(), bookmark.address());
+        return actionMenu;
+    }
+    else if(bookmark.isSeparator())
+    {
+        return KBookmarkMenu::actionForBookmark(bookmark);
+    }
+    else
+    {
+        Application::bookmarkProvider()->completionObject()->addItem(bookmark.url().url());
+        return  new KBookmarkAction( bookmark, owner(), this );
+    }
+}
+
+
+void BookmarkMenu::refill()
+{
+    fillBookmarks();
+
+    if(parentMenu()->actions().count() > 0)
+        parentMenu()->addSeparator();
+
+    if(isRoot())
+    {
+        addAddBookmark();
+        addAddBookmarksList();
+        addNewFolder();
+        addEditBookmarks();
+
+    }
+    else
+    {
+        addOpenFolderInTabs();
+        addAddBookmark();
+        addAddBookmarksList();
+        addNewFolder();
+    }
+}
+
+
+void BookmarkMenu::addOpenFolderInTabs()
+{
+    KAction *action;
+    KBookmarkGroup group = manager()->findByAddress(parentAddress()).toGroup();
+
+    if(!group.first().isNull())
+    {
+        KBookmark bookmark = group.first();
+
+        while(bookmark.isGroup() || bookmark.isSeparator())
+        {
+            bookmark = group.next(bookmark);
+        }
+
+        if(!bookmark.isNull())
+        {
+            action = new KAction(KIcon("tab-new"), i18n("Open Folder in Tabs"), this);
+            action->setHelpText( i18n( "Open all bookmarks in this folder as a new tab." ) );
+            connect(action, SIGNAL(triggered(bool)), this, SLOT(slotOpenFolderInTabs()));
+            parentMenu()->addAction(action);
+        }
+    }
+}
+
+
 // ------------------------------------------------------------------------------------------------------
 
 
@@ -160,8 +263,12 @@ BookmarkProvider::BookmarkProvider(QObject *parent)
         , m_owner(0)
         , m_actionCollection(new KActionCollection(this))
         , m_bookmarkMenu(0)
-        , m_bookmarkToolBar(0)
+        , m_completion(0)
 {
+    // take care of the completion object
+    m_completion = new KCompletion;
+    m_completion->setOrder( KCompletion::Weighted );
+
     KUrl bookfile = KUrl("~/.kde/share/apps/konqueror/bookmarks.xml");  // share konqueror bookmarks
 
     if (!QFile::exists(bookfile.path()))
@@ -178,7 +285,9 @@ BookmarkProvider::BookmarkProvider(QObject *parent)
             bookfile = KUrl(bookmarksPath);
         }
     }
-    m_manager = KBookmarkManager::managerForExternalFile(bookfile.path());
+
+    m_manager = KBookmarkManager::managerForFile(bookfile.path(), "rekonq");
+    
     connect(m_manager, SIGNAL(changed(const QString &, const QString &)),
             this, SLOT(slotBookmarksChanged(const QString &, const QString &)));
 
@@ -197,37 +306,47 @@ BookmarkProvider::~BookmarkProvider()
 }
 
 
-void BookmarkProvider::setupBookmarkBar(KToolBar *t)
+void BookmarkProvider::setupBookmarkBar(KToolBar *toolbar)
 {
-    m_bookmarkToolBar = t;
-    connect(m_bookmarkToolBar, SIGNAL(customContextMenuRequested(const QPoint &)),
+    KToolBar *bookmarkToolBar = toolbar;
+    m_bookmarkToolBars.append(bookmarkToolBar);
+    bookmarkToolBar->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(bookmarkToolBar, SIGNAL(customContextMenuRequested(const QPoint &)),
             this, SLOT(contextMenu(const QPoint &)));
 
     slotBookmarksChanged("", "");
 }
 
 
+void BookmarkProvider::removeToolBar(KToolBar *toolbar)
+{
+    m_bookmarkToolBars.removeOne(toolbar);
+}
+
+
 void BookmarkProvider::slotBookmarksChanged(const QString &group, const QString &caller)
 {
     Q_UNUSED(group)
     Q_UNUSED(caller)
 
-    if (!m_bookmarkToolBar)
-        return;
-
-    KBookmarkGroup toolBarGroup = m_manager->toolbar();
-    if (toolBarGroup.isNull())
-        return;
+    m_completion->clear();
 
-    if(m_bookmarkToolBar)
+    foreach(KToolBar *bookmarkToolBar, m_bookmarkToolBars)
     {
-        m_bookmarkToolBar->clear(); // FIXME CRASH
-
-        KBookmark bookmark = toolBarGroup.first();
-        while (!bookmark.isNull())
+        if (bookmarkToolBar)
         {
-            m_bookmarkToolBar->addAction(fillBookmarkBar(bookmark));
-            bookmark = toolBarGroup.next(bookmark);
+            KBookmarkGroup toolBarGroup = m_manager->toolbar();
+            if (toolBarGroup.isNull())
+                return;
+
+            bookmarkToolBar->clear();
+
+            KBookmark bookmark = toolBarGroup.first();
+            while (!bookmark.isNull())
+            {
+                bookmarkToolBar->addAction(fillBookmarkBar(bookmark));
+                bookmark = toolBarGroup.next(bookmark);
+            }
         }
     }
 }
@@ -244,13 +363,22 @@ QAction *BookmarkProvider::actionByName(const QString &name)
 
 void BookmarkProvider::contextMenu(const QPoint &point)
 {
-    KAction* action = dynamic_cast<KAction*>(m_bookmarkToolBar->actionAt(point));
+    if(m_bookmarkToolBars.isEmpty())
+        return;
+
+    KToolBar *bookmarkToolBar = m_bookmarkToolBars.at(0);
+    if(!bookmarkToolBar)
+        return;
+
+    KBookmarkActionInterface* action = dynamic_cast<KBookmarkActionInterface *>(bookmarkToolBar->actionAt(point));
     if (!action)
         return;
-    KMenu *menu = m_bookmarkMenu->viewContextMenu(action);
+
+    KMenu *menu = new BookmarkContextMenu(action->bookmark(), bookmarkManager(), bookmarkOwner());
     if (!menu)
         return;
-    menu->popup(m_bookmarkToolBar->mapToGlobal(point));
+
+    menu->popup(bookmarkToolBar->mapToGlobal(point));
 }
 
 
@@ -269,21 +397,18 @@ KAction *BookmarkProvider::fillBookmarkBar(const KBookmark &bookmark)
 {
     if (bookmark.isGroup())
     {
-        KBookmarkGroup group = bookmark.toGroup();
-        KBookmark bm = group.first();
-        KActionMenu *menuAction = new KActionMenu(KIcon(bookmark.icon()), bookmark.text(), this);
+        KBookmarkActionMenu *menuAction = new KBookmarkActionMenu(bookmark.toGroup(), this);
         menuAction->setDelayed(false);
-        while (!bm.isNull())
-        {
-            menuAction->addAction(fillBookmarkBar(bm));
-            bm = group.next(bm);
-        }
+        new BookmarkMenu(bookmarkManager(), bookmarkOwner(), menuAction->menu(), bookmark.address());
+
         return menuAction;
     }
  
     if(bookmark.isSeparator())
     {
-        KAction *a = new KAction(this);
+        KAction *a = new KBookmarkAction(bookmark, m_owner, this);
+        a->setText("");
+        a->setIcon(QIcon());
         a->setSeparator(true);
         return a;
     }
@@ -298,3 +423,56 @@ KBookmarkGroup BookmarkProvider::rootGroup()
 {
     return m_manager->root();
 }
+
+
+KCompletion *BookmarkProvider::completionObject() const
+{
+    return m_completion;
+}
+
+
+QString BookmarkProvider::titleForBookmarkUrl(QString url)
+{
+    QString title = "";
+    KBookmarkGroup bookGroup = Application::bookmarkProvider()->rootGroup();
+    if (bookGroup.isNull())
+    {
+        return title;
+    }
+
+    KBookmark bookmark = bookGroup.first();
+    while (!bookmark.isNull() && title.isEmpty())
+    {
+        title = titleForBookmarkUrl(bookmark, url);
+        bookmark = bookGroup.next(bookmark);
+    }
+    
+    if (title.isEmpty())
+    {
+        title = url;
+    }
+    
+    return title;
+}
+
+
+QString BookmarkProvider::titleForBookmarkUrl(const KBookmark &bookmark, QString url)
+{
+    QString title = "";
+    if (bookmark.isGroup())
+    {
+        KBookmarkGroup group = bookmark.toGroup();
+        KBookmark bm = group.first();
+        while (!bm.isNull() && title.isEmpty())
+        {
+            title = titleForBookmarkUrl(bm, url); // it is .bookfolder
+            bm = group.next(bm);
+        }
+    }
+    else if(!bookmark.isSeparator() && bookmark.url()==url)
+    {
+        title = bookmark.fullText();
+    }
+    
+    return title;
+}