src/bookmarkssidebarpage.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Peter Penz <peter.penz@gmx.at>                  *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  18  ***************************************************************************/
  19
  20 #include "bookmarkssidebarpage.h"
  21
  22 #include <q3listbox.h>
  23 #include <qlayout.h>
  24 #include <qpainter.h>
  25 //Added by qt3to4:
  26 #include <QPixmap>
  27 #include <Q3VBoxLayout>
  28 #include <QPaintEvent>
  29 #include <assert.h>
  30 #include <kmenu.h>
  31
  32 #include <kbookmark.h>
  33 #include <kbookmarkmanager.h>
  34 #include <kmessagebox.h>
  35 #include <kiconloader.h>
  36 #include <klocale.h>
  37
  38 #include "dolphinsettings.h"
  39 #include "dolphinmainwindow.h"
  40 #include "editbookmarkdialog.h"
  41
  42 BookmarksSidebarPage::BookmarksSidebarPage(DolphinMainWindow* mainWindow, QWidget* parent) :
  43     SidebarPage(mainWindow, parent)
  44 {
  45     Q3VBoxLayout* layout = new Q3VBoxLayout(this);
  46     m_bookmarksList = new BookmarksListBox(this);
  47     m_bookmarksList->setPaletteBackgroundColor(palette().brush(QPalette::Background).color());
  48
  49     layout->addWidget(m_bookmarksList);
  50     connect(m_bookmarksList, SIGNAL(mouseButtonClicked(int, Q3ListBoxItem*, const QPoint&)),
  51             this, SLOT(slotMouseButtonClicked(int, Q3ListBoxItem*)));
  52     connect(m_bookmarksList, SIGNAL(contextMenuRequested(Q3ListBoxItem*, const QPoint&)),
  53             this, SLOT(slotContextMenuRequested(Q3ListBoxItem*, const QPoint&)));
  54
  55     KBookmarkManager* manager = DolphinSettings::instance().bookmarkManager();
  56     connect(manager, SIGNAL(changed(const QString&, const QString&)),
  57             this, SLOT(updateBookmarks()));
  58
  59     updateBookmarks();
  60 }
  61
  62 BookmarksSidebarPage::~BookmarksSidebarPage()
  63 {
  64 }
  65
  66 void BookmarksSidebarPage::activeViewChanged()
  67 {
  68     connectToActiveView();
  69 }
  70
  71 void BookmarksSidebarPage::updateBookmarks()
  72 {
  73     m_bookmarksList->clear();
  74
  75     KIconLoader iconLoader;
  76
  77     KBookmarkGroup root = DolphinSettings::instance().bookmarkManager()->root();
  78     KBookmark bookmark = root.first();
  79     while (!bookmark.isNull()) {
  80         QPixmap icon(iconLoader.loadIcon(bookmark.icon(),
  81                                          K3Icon::NoGroup,
  82                                          K3Icon::SizeMedium));
  83         BookmarkItem* item = new BookmarkItem(icon, bookmark.text());
  84         m_bookmarksList->insertItem(item);
  85
  86         bookmark = root.next(bookmark);
  87     }
  88
  89     connectToActiveView();
  90 }
  91
  92 void BookmarksSidebarPage::slotMouseButtonClicked(int button, Q3ListBoxItem* item)
  93 {
  94     if ((button != Qt::LeftButton) || (item == 0)) {
  95         return;
  96     }
  97
  98     const int index = m_bookmarksList->index(item);
  99     KBookmark bookmark = DolphinSettings::instance().bookmark(index);
 100     mainWindow()->activeView()->setUrl(bookmark.url());
 101 }
 102
 103 void BookmarksSidebarPage::slotContextMenuRequested(Q3ListBoxItem* item,
 104                                                     const QPoint& pos)
 105 {
 106     const int insertID = 1;
 107     const int editID = 2;
 108     const int deleteID = 3;
 109     const int addID = 4;
 110
 111     KMenu* popup = new KMenu();
 112     if (item == 0) {
 113         QAction *action = popup->addAction(SmallIcon("document-new"), i18n("Add Bookmark..."));
 114         action->setData(addID);
 115     }
 116     else {
 117         QAction *action = popup->addAction(SmallIcon("document-new"), i18n("Insert Bookmark..."));
 118         action->setData(insertID);
 119         action = popup->addAction(SmallIcon("edit"), i18n("Edit..."));
 120         action->setData(editID);
 121         action = popup->addAction(SmallIcon("edit-delete"), i18n("Delete"));
 122         action->setData(deleteID);
 123
 124     }
 125
 126     KBookmarkManager* manager = DolphinSettings::instance().bookmarkManager();
 127     KBookmarkGroup root = manager->root();
 128     const int index = m_bookmarksList->index(m_bookmarksList->selectedItem());
 129     QAction *result = popup->exec(pos);
 130     if( result)
 131     {
 132     switch(result->data().toInt()) {
 133         case insertID: {
 134             KBookmark newBookmark = EditBookmarkDialog::getBookmark(i18n("Insert Bookmark"),
 135                                                                     "New bookmark",
 136                                                                     KUrl(),
 137                                                                     "bookmark");
 138             if (!newBookmark.isNull()) {
 139                 root.addBookmark(manager, newBookmark);
 140                 if (index > 0) {
 141                     KBookmark prevBookmark = DolphinSettings::instance().bookmark(index - 1);
 142                     root.moveItem(newBookmark, prevBookmark);
 143                 }
 144                 else {
 145                     // insert bookmark at first position (is a little bit tricky as KBookmarkGroup
 146                     // only allows to move items after existing items)
 147                     KBookmark firstBookmark = root.first();
 148                     root.moveItem(newBookmark, firstBookmark);
 149                     root.moveItem(firstBookmark, newBookmark);
 150                 }
 151                 manager->emitChanged(root);
 152             }
 153             break;
 154         }
 155
 156         case editID: {
 157             KBookmark oldBookmark = DolphinSettings::instance().bookmark(index);
 158             KBookmark newBookmark = EditBookmarkDialog::getBookmark(i18n("Edit Bookmark"),
 159                                                                     oldBookmark.text(),
 160                                                                     oldBookmark.url(),
 161                                                                     oldBookmark.icon());
 162             if (!newBookmark.isNull()) {
 163                 root.addBookmark(manager, newBookmark);
 164                 root.moveItem(newBookmark, oldBookmark);
 165                 root.deleteBookmark(oldBookmark);
 166                 manager->emitChanged(root);
 167             }
 168             break;
 169         }
 170
 171         case deleteID: {
 172             KBookmark bookmark = DolphinSettings::instance().bookmark(index);
 173             root.deleteBookmark(bookmark);
 174             manager->emitChanged(root);
 175             break;
 176         }
 177
 178         case addID: {
 179             KBookmark bookmark = EditBookmarkDialog::getBookmark(i18n("Add Bookmark"),
 180                                                                  "New bookmark",
 181                                                                  KUrl(),
 182                                                                  "bookmark");
 183             if (!bookmark.isNull()) {
 184                 root.addBookmark(manager, bookmark);
 185                 manager->emitChanged(root);
 186             }
 187         }
 188
 189         default: break;
 190     }
 191    }
 192     delete popup;
 193     popup = 0;
 194
 195     DolphinView* view = mainWindow()->activeView();
 196     adjustSelection(view->url());
 197 }
 198
 199
 200 void BookmarksSidebarPage::adjustSelection(const KUrl& url)
 201 {
 202     // TODO (remarked in dolphin/TODO): the following code is quite equal
 203     // to BookmarkSelector::updateSelection().
 204
 205     KBookmarkGroup root = DolphinSettings::instance().bookmarkManager()->root();
 206     KBookmark bookmark = root.first();
 207
 208     int maxLength = 0;
 209     int selectedIndex = -1;
 210
 211     // Search the bookmark which is equal to the Url or at least is a parent Url.
 212     // If there are more than one possible parent Url candidates, choose the bookmark
 213     // which covers the bigger range of the Url.
 214     int i = 0;
 215     while (!bookmark.isNull()) {
 216         const KUrl bookmarkUrl = bookmark.url();
 217         if (bookmarkUrl.isParentOf(url)) {
 218             const int length = bookmarkUrl.prettyUrl().length();
 219             if (length > maxLength) {
 220                 selectedIndex = i;
 221                 maxLength = length;
 222             }
 223         }
 224         bookmark = root.next(bookmark);
 225         ++i;
 226     }
 227
 228     const bool block = m_bookmarksList->signalsBlocked();
 229     m_bookmarksList->blockSignals(true);
 230     if (selectedIndex < 0) {
 231         // no bookmark matches, hence deactivate any selection
 232         const int currentIndex = m_bookmarksList->index(m_bookmarksList->selectedItem());
 233         m_bookmarksList->setSelected(currentIndex, false);
 234     }
 235     else {
 236         // select the bookmark which is part of the current Url
 237         m_bookmarksList->setSelected(selectedIndex, true);
 238     }
 239     m_bookmarksList->blockSignals(block);
 240 }
 241
 242 void BookmarksSidebarPage::slotUrlChanged(const KUrl& url)
 243 {
 244     adjustSelection(url);
 245 }
 246
 247 void BookmarksSidebarPage::connectToActiveView()
 248 {
 249     DolphinView* view = mainWindow()->activeView();
 250     adjustSelection(view->url());
 251     connect(view, SIGNAL(urlChanged(const KUrl&)),
 252             this, SLOT(slotUrlChanged(const KUrl&)));
 253 }
 254
 255 BookmarksListBox::BookmarksListBox(QWidget* parent) :
 256     Q3ListBox(parent)
 257 {
 258 }
 259 BookmarksListBox::~BookmarksListBox()
 260 {
 261 }
 262
 263 void BookmarksListBox::paintEvent(QPaintEvent* /* event */)
 264 {
 265     // don't invoke QListBox::paintEvent(event) to prevent
 266     // that any kind of frame is drawn
 267 }
 268
 269 BookmarkItem::BookmarkItem(const QPixmap& pixmap, const QString& text) :
 270     Q3ListBoxPixmap(pixmap, text)
 271 {
 272 }
 273
 274 BookmarkItem::~BookmarkItem()
 275 {
 276 }
 277
 278 int BookmarkItem::height(const Q3ListBox* listBox) const
 279 {
 280     return Q3ListBoxPixmap::height(listBox) + 8;
 281 }
 282
 283 #include "bookmarkssidebarpage.moc"