void KBookmarkDialog::accept()
{
if (d->mode == KBookmarkDialogPrivate::NewFolder) {
KBookmarkGroup parent = d->parentBookmark();
if (d->title->text().isEmpty()) {
d->title->setText(QStringLiteral("New Folder"));
}
d->bm = parent.createNewFolder(d->title->text());
d->bm.setDescription(d->comment->text());
d->mgr->emitChanged(parent);
} else if (d->mode == KBookmarkDialogPrivate::NewBookmark) {
KBookmarkGroup parent = d->parentBookmark();
if (d->title->text().isEmpty()) {
d->title->setText(QStringLiteral("New Bookmark"));
}
d->bm = parent.addBookmark(d->title->text(), QUrl(d->url->text()), d->icon);
d->bm.setDescription(d->comment->text());
d->mgr->emitChanged(parent);
} else if (d->mode == KBookmarkDialogPrivate::NewMultipleBookmarks) {
KBookmarkGroup parent = d->parentBookmark();
if (d->title->text().isEmpty()) {
d->title->setText(QStringLiteral("New Folder"));
}
d->bm = parent.createNewFolder(d->title->text());
d->bm.setDescription(d->comment->text());
foreach (const KBookmarkOwner::FutureBookmark &fb, d->list) {
d->bm.toGroup().addBookmark(fb.title(), fb.url(), fb.icon());
}
d->mgr->emitChanged(parent);
} else if (d->mode == KBookmarkDialogPrivate::EditBookmark) {
void CreateCommand::redo()
{
QString parentAddress = KBookmark::parentAddress(m_to);
KBookmarkGroup parentGroup =
m_model->bookmarkManager()->findByAddress(parentAddress).toGroup();
QString previousSibling = KBookmark::previousAddress(m_to);
// kDebug() << "previousSibling=" << previousSibling;
KBookmark prev = (previousSibling.isEmpty())
? KBookmark(QDomElement())
: m_model->bookmarkManager()->findByAddress(previousSibling);
KBookmark bk = KBookmark(QDomElement());
const int pos = KBookmark::positionInParent(m_to);
m_model->beginInsert(parentGroup, pos, pos);
if (m_separator) {
bk = parentGroup.createNewSeparator();
} else if (m_group) {
Q_ASSERT(!m_text.isEmpty());
bk = parentGroup.createNewFolder(m_text);
bk.internalElement().setAttribute("folded", (m_open ? "no" : "yes"));
if (!m_iconPath.isEmpty()) {
bk.setIcon(m_iconPath);
}
} else if(!m_originalBookmark.isNull()) {
QDomElement element = m_originalBookmark.internalElement().cloneNode().toElement();
bk = KBookmark(element);
parentGroup.addBookmark(bk);
} else {
bk = parentGroup.addBookmark(m_text, m_url, m_iconPath);
}
// move to right position
parentGroup.moveBookmark(bk, prev);
if (!(text().isEmpty()) && !parentAddress.isEmpty() ) {
// open the parent (useful if it was empty) - only for manual commands
Q_ASSERT( parentGroup.internalElement().tagName() != "xbel" );
parentGroup.internalElement().setAttribute("folded", "no");
}
Q_ASSERT(bk.address() == m_to);
m_model->endInsert();
}
void BookmarksListBox::dropEvent( QDropEvent *event )
{
KURL::List urls;
if (KURLDrag::decode(event, urls) && !urls.isEmpty()) {
KBookmarkManager* manager = DolphinSettings::instance().bookmarkManager();
KBookmarkGroup root = manager->root();
KURL::List::iterator it;
for(it=urls.begin(); it!=urls.end(); ++it) {
root.addBookmark(manager, (*it).fileName(), (*it), "", false);
}
manager->emitChanged(root);
}
}
void KonqPopupMenuPrivate::slotPopupAddToBookmark()
{
KBookmarkGroup root;
if (m_popupItemProperties.urlList().count() == 1) {
const QUrl url = m_popupItemProperties.urlList().first();
const QString title = m_urlTitle.isEmpty() ? url.toDisplayString() : m_urlTitle;
KBookmarkDialog dlg(m_bookmarkManager, m_parentWidget);
dlg.addBookmark(title, url, QString());
} else {
root = m_bookmarkManager->root();
Q_FOREACH (const QUrl &url, m_popupItemProperties.urlList()) {
root.addBookmark(url.toDisplayString(), url, QString());
}
m_bookmarkManager->emitChanged(root);
}
}
void KBookmarkMenu::slotAddBookmark()
{
if (!m_pOwner) {
return;
}
if (m_pOwner->currentTitle().isEmpty() && m_pOwner->currentUrl().isEmpty()) {
return;
}
KBookmarkGroup parentBookmark = m_pManager->findByAddress(m_parentAddress).toGroup();
if (KBookmarkSettings::self()->m_advancedaddbookmark) {
KBookmarkDialog *dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow());
dlg->addBookmark(m_pOwner->currentTitle(), m_pOwner->currentUrl(), m_pOwner->currentIcon(), parentBookmark);
delete dlg;
} else {
parentBookmark.addBookmark(m_pOwner->currentTitle(), m_pOwner->currentUrl(), m_pOwner->currentIcon());
m_pManager->emitChanged(parentBookmark);
}
}
void BookmarksSettingsPage::applySettings()
{
// delete all bookmarks
KBookmarkManager* manager = DolphinSettings::instance().bookmarkManager();
KBookmarkGroup root = manager->root();
KBookmark bookmark = root.first();
while (!bookmark.isNull()) {
root.deleteBookmark(bookmark);
bookmark = root.first();
}
// add all items as bookmarks
QListViewItem* item = m_listView->firstChild();
while (item != 0) {
root.addBookmark(manager,
item->text(NameIdx),
KURL(item->text(URLIdx)),
item->text(IconIdx)); // hidden column
item = item->itemBelow();
}
manager->emitChanged(root);
}
bool BookmarkToolBar::eventFilter(QObject *watched, QEvent *event)
{
if (m_currentMenu && m_currentMenu->isVisible()
&& !m_currentMenu->rect().contains(m_currentMenu->mapFromGlobal(QCursor::pos())))
{
// To switch root folders as in a menubar
KBookmarkActionMenu* act = dynamic_cast<KBookmarkActionMenu *>(actionAt(mapFromGlobal(QCursor::pos())));
if (event->type() == QEvent::MouseMove && act && act->menu() != m_currentMenu)
{
m_currentMenu->hide();
QPoint pos = mapToGlobal(widgetForAction(act)->pos());
act->menu()->popup(QPoint(pos.x(), pos.y() + widgetForAction(act)->height()));
}
else if (event->type() == QEvent::MouseButtonPress && act)
{
m_currentMenu->hide();
}
return QObject::eventFilter(watched, event);
}
switch (event->type())
{
case QEvent::Show:
{
if (!m_filled)
{
BookmarkManager::self()->fillBookmarkBar(this);
m_filled = true;
}
}
break;
case QEvent::ActionRemoved:
{
QActionEvent *actionEvent = static_cast<QActionEvent*>(event);
if (actionEvent && actionEvent->action() != m_dropAction)
{
QWidget *widget = widgetForAction(actionEvent->action());
if (widget)
{
widget->removeEventFilter(this);
}
}
}
break;
case QEvent::ParentChange:
{
QActionEvent *actionEvent = static_cast<QActionEvent*>(event);
if (actionEvent && actionEvent->action() != m_dropAction)
{
QWidget *widget = widgetForAction(actionEvent->action());
if (widget)
{
widget->removeEventFilter(this);
}
}
}
break;
case QEvent::DragEnter:
{
QDragEnterEvent *dragEvent = static_cast<QDragEnterEvent*>(event);
if (dragEvent->mimeData()->hasFormat(BookmarkManager::bookmark_mime_type())
|| dragEvent->mimeData()->hasFormat("text/uri-list")
|| dragEvent->mimeData()->hasFormat("text/plain"))
{
QFrame* dropIndicatorWidget = new QFrame(this);
dropIndicatorWidget->setFrameShape(QFrame::VLine);
m_dropAction = insertWidget(actionAt(dragEvent->pos()), dropIndicatorWidget);
dragEvent->accept();
}
}
break;
case QEvent::DragLeave:
{
QDragLeaveEvent *dragEvent = static_cast<QDragLeaveEvent*>(event);
if (m_checkedAction)
{
m_checkedAction->setCheckable(false);
m_checkedAction->setChecked(false);
}
delete m_dropAction;
m_dropAction = 0;
dragEvent->accept();
}
break;
case QEvent::DragMove:
{
QDragMoveEvent *dragEvent = static_cast<QDragMoveEvent*>(event);
if (dragEvent->mimeData()->hasFormat(BookmarkManager::bookmark_mime_type())
|| dragEvent->mimeData()->hasFormat("text/uri-list")
|| dragEvent->mimeData()->hasFormat("text/plain"))
{
QAction *overAction = actionAt(dragEvent->pos());
KBookmarkActionInterface *overActionBK = dynamic_cast<KBookmarkActionInterface*>(overAction);
QWidget *widgetAction = widgetForAction(overAction);
if (overAction != m_dropAction && overActionBK && widgetAction && m_dropAction)
{
removeAction(m_dropAction);
if (m_checkedAction)
{
m_checkedAction->setCheckable(false);
m_checkedAction->setChecked(false);
}
if (!overActionBK->bookmark().isGroup())
{
if ((dragEvent->pos().x() - widgetAction->pos().x()) > (widgetAction->width() / 2))
{
if (actions().count() > actions().indexOf(overAction) + 1)
{
insertAction(actions().at(actions().indexOf(overAction) + 1), m_dropAction);
}
else
{
addAction(m_dropAction);
}
}
else
{
insertAction(overAction, m_dropAction);
}
}
else
{
if ((dragEvent->pos().x() - widgetAction->pos().x()) >= (widgetAction->width() * 0.75))
{
if (actions().count() > actions().indexOf(overAction) + 1)
{
insertAction(actions().at(actions().indexOf(overAction) + 1), m_dropAction);
}
else
{
addAction(m_dropAction);
}
}
else if ((dragEvent->pos().x() - widgetAction->pos().x()) <= (widgetAction->width() * 0.25))
{
insertAction(overAction, m_dropAction);
}
else
{
overAction->setCheckable(true);
overAction->setChecked(true);
m_checkedAction = overAction;
}
}
dragEvent->accept();
}
}
}
break;
case QEvent::Drop:
{
QDropEvent *dropEvent = static_cast<QDropEvent*>(event);
KBookmark bookmark;
KBookmarkGroup root = BookmarkManager::self()->manager()->toolbar();
if (m_checkedAction)
{
m_checkedAction->setCheckable(false);
m_checkedAction->setChecked(false);
}
if (dropEvent->mimeData()->hasFormat(BookmarkManager::bookmark_mime_type()))
{
QByteArray addresses = dropEvent->mimeData()->data(BookmarkManager::bookmark_mime_type());
bookmark = BookmarkManager::self()->findByAddress(QString::fromLatin1(addresses.data()));
if (bookmark.isNull())
return false;
}
else if (dropEvent->mimeData()->hasFormat("text/uri-list"))
{
// DROP is URL
QString url = dropEvent->mimeData()->urls().at(0).toString();
WebWindow *w = qobject_cast<WebWindow *>(parent());
QString title = url.contains(w->url().url())
? w->title()
: url;
bookmark = root.addBookmark(title, url);
}
else if (dropEvent->mimeData()->hasFormat("text/plain"))
{
// DROP is TEXT
QString url = dropEvent->mimeData()->text();
KUrl u(url);
if (u.isValid())
{
WebWindow *w = qobject_cast<WebWindow *>(parent());
QString title = url.contains(w->url().url())
? w->title()
: url;
bookmark = root.addBookmark(title, url);
}
}
else
{
return false;
}
QAction *destAction = actionAt(dropEvent->pos());
if (destAction && destAction == m_dropAction)
{
if (actions().indexOf(m_dropAction) > 0)
{
destAction = actions().at(actions().indexOf(m_dropAction) - 1);
}
else
{
destAction = actions().at(1);
}
}
if (destAction)
{
KBookmarkActionInterface *destBookmarkAction = dynamic_cast<KBookmarkActionInterface *>(destAction);
QWidget *widgetAction = widgetForAction(destAction);
if (destBookmarkAction && !destBookmarkAction->bookmark().isNull() && widgetAction
&& bookmark.address() != destBookmarkAction->bookmark().address())
{
KBookmark destBookmark = destBookmarkAction->bookmark();
if (!destBookmark.isGroup())
{
if ((dropEvent->pos().x() - widgetAction->pos().x()) >= (widgetAction->width() / 2))
{
root.moveBookmark(bookmark, destBookmark);
}
else
{
root.moveBookmark(bookmark, destBookmark.parentGroup().previous(destBookmark));
}
}
else
{
if ((dropEvent->pos().x() - widgetAction->pos().x()) >= (widgetAction->width() * 0.75))
{
root.moveBookmark(bookmark, destBookmark);
}
else if ((dropEvent->pos().x() - widgetAction->pos().x()) <= (widgetAction->width() * 0.25))
{
root.moveBookmark(bookmark, destBookmark.parentGroup().previous(destBookmark));
}
else
{
destBookmark.toGroup().addBookmark(bookmark);
}
}
BookmarkManager::self()->emitChanged();
}
}
else
{
root.deleteBookmark(bookmark);
bookmark = root.addBookmark(bookmark);
if (dropEvent->pos().x() < widgetForAction(actions().first())->pos().x())
{
root.moveBookmark(bookmark, KBookmark());
}
BookmarkManager::self()->emitChanged();
}
dropEvent->accept();
}
break;
default:
break;
}
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
// These events need to be handled only for Bookmark actions and not the bar
if (watched != this && mouseEvent)
{
switch (event->type())
{
case QEvent::MouseButtonPress: // drag handling
{
QPoint pos = mapFromGlobal(QCursor::pos());
KBookmarkActionInterface *action = dynamic_cast<KBookmarkActionInterface *>(actionAt(pos));
if (action && mouseEvent->button() != Qt::MiddleButton)
{
m_dragAction = actionAt(pos);
m_startDragPos = pos;
// The menu is displayed only when the mouse button is released
if (action->bookmark().isGroup())
return true;
}
}
break;
case QEvent::MouseMove:
{
int distance = (mapFromGlobal(QCursor::pos()) - m_startDragPos).manhattanLength();
if (!m_currentMenu && distance >= QApplication::startDragDistance())
{
startDrag();
}
}
break;
case QEvent::MouseButtonRelease:
{
QPoint destPos = mapFromGlobal(QCursor::pos());
int distance = (destPos - m_startDragPos).manhattanLength();
KBookmarkActionInterface *action = dynamic_cast<KBookmarkActionInterface *>(actionAt(destPos));
if (action)
{
if (action->bookmark().isGroup())
{
if (mouseEvent->button() == Qt::MiddleButton)
{
BookmarkManager::self()->owner()->loadBookmarkFolder(action->bookmark());
}
else if (distance < QApplication::startDragDistance())
{
KBookmarkActionMenu *menu = dynamic_cast<KBookmarkActionMenu *>(actionAt(m_startDragPos));
QPoint actionPos = mapToGlobal(widgetForAction(menu)->pos());
menu->menu()->popup(QPoint(actionPos.x(), actionPos.y() + widgetForAction(menu)->height()));
}
}
else
{
if (!action->bookmark().isNull() && !action->bookmark().isSeparator())
{
if (mouseEvent->button() == Qt::MiddleButton)
{
BookmarkManager::self()->owner()->loadBookmarkInNewTab(action->bookmark());
}
}
}
}
}
break;
default:
break;
}
}
return QObject::eventFilter(watched, event);
}
void DolphinContextMenu::openViewportContextMenu()
{
// Parts of the following code have been taken
// from the class KonqOperations located in
// libqonq/konq_operations.h of Konqueror.
// (Copyright (C) 2000 David Faure <*****@*****.**>)
assert(m_fileInfo == 0);
const int propertiesID = 100;
const int bookmarkID = 101;
KPopupMenu* popup = new KPopupMenu(m_dolphinView);
Dolphin& dolphin = Dolphin::mainWin();
// setup 'Create New' menu
KPopupMenu* createNewMenu = new KPopupMenu();
KAction* createFolderAction = dolphin.actionCollection()->action("create_folder");
if (createFolderAction != 0) {
createFolderAction->plug(createNewMenu);
}
createNewMenu->insertSeparator();
KAction* action = 0;
QPtrListIterator<KAction> fileGrouptIt(dolphin.fileGroupActions());
while ((action = fileGrouptIt.current()) != 0) {
action->plug(createNewMenu);
++fileGrouptIt;
}
// TODO: not used yet. See documentation of Dolphin::linkGroupActions()
// and Dolphin::linkToDeviceActions() in the header file for details.
//
//createNewMenu->insertSeparator();
//
//QPtrListIterator<KAction> linkGroupIt(dolphin.linkGroupActions());
//while ((action = linkGroupIt.current()) != 0) {
// action->plug(createNewMenu);
// ++linkGroupIt;
//}
//
//KPopupMenu* linkToDeviceMenu = new KPopupMenu();
//QPtrListIterator<KAction> linkToDeviceIt(dolphin.linkToDeviceActions());
//while ((action = linkToDeviceIt.current()) != 0) {
// action->plug(linkToDeviceMenu);
// ++linkToDeviceIt;
//}
//
//createNewMenu->insertItem(i18n("Link to Device"), linkToDeviceMenu);
const KURL& url = dolphin.activeView()->url();
if (url.protocol() == "trash")
{
popup->insertItem(i18n("Empty Deleted Items Folder"), emptyID);
}
else
{
popup->insertItem(SmallIcon("filenew"), i18n("Create New"), createNewMenu);
}
popup->insertSeparator();
KAction* pasteAction = dolphin.actionCollection()->action(KStdAction::stdName(KStdAction::Paste));
pasteAction->plug(popup);
// setup 'View Mode' menu
KPopupMenu* viewModeMenu = new KPopupMenu();
KAction* iconsMode = dolphin.actionCollection()->action("icons");
iconsMode->plug(viewModeMenu);
KAction* detailsMode = dolphin.actionCollection()->action("details");
detailsMode->plug(viewModeMenu);
KAction* previewsMode = dolphin.actionCollection()->action("previews");
previewsMode->plug(viewModeMenu);
popup->insertItem(i18n("View Mode"), viewModeMenu);
popup->insertSeparator();
popup->insertItem(i18n("Bookmark this folder"), bookmarkID);
popup->insertSeparator();
popup->insertItem(i18n("Properties..."), propertiesID);
int id = popup->exec(m_pos);
if (id == emptyID) {
KonqOperations::emptyTrash();
}
else if (id == propertiesID) {
new KPropertiesDialog(dolphin.activeView()->url());
}
else if (id == bookmarkID) {
const KURL& url = dolphin.activeView()->url();
KBookmark bookmark = EditBookmarkDialog::getBookmark(i18n("Add folder as bookmark"),
url.filename(),
url,
"bookmark");
if (!bookmark.isNull()) {
KBookmarkManager* manager = DolphinSettings::instance().bookmarkManager();
KBookmarkGroup root = manager->root();
root.addBookmark(manager, bookmark);
manager->emitChanged(root);
}
}
popup->deleteLater();
}
void DolphinContextMenu::openItemContextMenu()
{
// Parts of the following code have been taken
// from the class KonqOperations located in
// libqonq/konq_operations.h of Konqueror.
// (Copyright (C) 2000 David Faure <*****@*****.**>)
assert(m_fileInfo != 0);
KPopupMenu* popup = new KPopupMenu(m_dolphinView);
Dolphin& dolphin = Dolphin::mainWin();
const KURL::List urls = m_dolphinView->selectedURLs();
const KURL& url = dolphin.activeView()->url();
if (url.protocol() == "trash")
{
popup->insertItem(i18n("&Restore"), restoreID);
}
// insert 'Cut', 'Copy' and 'Paste'
const KStdAction::StdAction actionNames[] = { KStdAction::Cut, KStdAction::Copy, KStdAction::Paste };
const int count = sizeof(actionNames) / sizeof(KStdAction::StdAction);
for (int i = 0; i < count; ++i) {
KAction* action = dolphin.actionCollection()->action(KStdAction::stdName(actionNames[i]));
if (action != 0) {
action->plug(popup);
}
}
popup->insertSeparator();
// insert 'Rename'
KAction* renameAction = dolphin.actionCollection()->action("rename");
renameAction->plug(popup);
// insert 'Move to Trash' for local URLs, otherwise insert 'Delete'
if (url.isLocalFile()) {
KAction* moveToTrashAction = dolphin.actionCollection()->action("move_to_trash");
moveToTrashAction->plug(popup);
}
else {
KAction* deleteAction = dolphin.actionCollection()->action("delete");
deleteAction->plug(popup);
}
// insert 'Bookmark this folder...' entry
// urls is a list of selected items, so insert boolmark menu if
// urls contains only one item, i.e. no multiple selection made
if (m_fileInfo->isDir() && (urls.count() == 1)) {
popup->insertItem(i18n("Bookmark this folder"), bookmarkID);
}
popup->insertSeparator();
// Insert 'Open With...' sub menu
QValueVector<KService::Ptr> openWithVector;
const int openWithID = insertOpenWithItems(popup, openWithVector);
// Insert 'Actions' sub menu
QValueVector<KDEDesktopMimeType::Service> actionsVector;
insertActionItems(popup, actionsVector);
// insert 'Properties...' entry
popup->insertSeparator();
KAction* propertiesAction = dolphin.actionCollection()->action("properties");
propertiesAction->plug(popup);
int id = popup->exec(m_pos);
if (id == restoreID ) {
KonqOperations::restoreTrashedItems(urls);
}
else if (id == bookmarkID) {
const KURL selectedURL(m_fileInfo->url());
KBookmark bookmark = EditBookmarkDialog::getBookmark(i18n("Add folder as bookmark"),
selectedURL.filename(),
selectedURL,
"bookmark");
if (!bookmark.isNull()) {
KBookmarkManager* manager = DolphinSettings::instance().bookmarkManager();
KBookmarkGroup root = manager->root();
root.addBookmark(manager, bookmark);
manager->emitChanged(root);
}
}
else if (id >= actionsIDStart) {
// one of the 'Actions' items has been selected
KDEDesktopMimeType::executeService(urls, actionsVector[id - actionsIDStart]);
}
else if (id >= openWithIDStart) {
// one of the 'Open With' items has been selected
if (id == openWithID) {
// the item 'Other...' has been selected
KRun::displayOpenWithDialog(urls);
}
else {
KService::Ptr servicePtr = openWithVector[id - openWithIDStart];
KRun::run(*servicePtr, urls);
}
}
openWithVector.clear();
actionsVector.clear();
popup->deleteLater();
}
void BookmarksSidebarPage::slotContextMenuRequested(QListBoxItem* item,
const QPoint& pos)
{
const int insertID = 1;
const int editID = 2;
const int deleteID = 3;
const int addID = 4;
QPopupMenu* popup = new QPopupMenu();
if (item == 0) {
popup->insertItem(SmallIcon("filenew"), i18n("Add Bookmark..."), addID);
}
else {
popup->insertItem(SmallIcon("filenew"), i18n("Insert Bookmark..."), insertID);
popup->insertItem(SmallIcon("edit"), i18n("Edit..."), editID);
popup->insertItem(SmallIcon("editdelete"), i18n("Delete"), deleteID);
}
KBookmarkManager* manager = DolphinSettings::instance().bookmarkManager();
KBookmarkGroup root = manager->root();
const int index = m_bookmarksList->index(m_bookmarksList->selectedItem());
const int result = popup->exec(pos);
switch (result) {
case insertID: {
KBookmark newBookmark = EditBookmarkDialog::getBookmark(i18n("Insert Bookmark"),
i18n("New bookmark"),
KURL(),
"bookmark");
if (!newBookmark.isNull()) {
root.addBookmark(manager, newBookmark);
if (index > 0) {
KBookmark prevBookmark = DolphinSettings::instance().bookmark(index - 1);
root.moveItem(newBookmark, prevBookmark);
}
else {
// insert bookmark at first position (is a little bit tricky as KBookmarkGroup
// only allows to move items after existing items)
KBookmark firstBookmark = root.first();
root.moveItem(newBookmark, firstBookmark);
root.moveItem(firstBookmark, newBookmark);
}
manager->emitChanged(root);
}
break;
}
case editID: {
KBookmark oldBookmark = DolphinSettings::instance().bookmark(index);
KBookmark newBookmark = EditBookmarkDialog::getBookmark(i18n("Edit Bookmark"),
oldBookmark.text(),
oldBookmark.url(),
oldBookmark.icon());
if (!newBookmark.isNull()) {
root.addBookmark(manager, newBookmark);
root.moveItem(newBookmark, oldBookmark);
root.deleteBookmark(oldBookmark);
manager->emitChanged(root);
}
break;
}
case deleteID: {
KBookmark bookmark = DolphinSettings::instance().bookmark(index);
root.deleteBookmark(bookmark);
manager->emitChanged(root);
break;
}
case addID: {
KBookmark bookmark = EditBookmarkDialog::getBookmark(i18n("Add Bookmark"),
"New bookmark",
KURL(),
"bookmark");
if (!bookmark.isNull()) {
root.addBookmark(manager, bookmark);
manager->emitChanged(root);
}
}
default: break;
}
delete popup;
popup = 0;
DolphinView* view = Dolphin::mainWin().activeView();
adjustSelection(view->url());
}
// TODO *** drop improvements ***
// open submenus on drop interactions
bool KBookmarkBar::eventFilter( QObject *, QEvent *e )
{
if (d->m_filteredToolbar)
return false; // todo: make this limit the actions
if ( e->type() == QEvent::DragLeave )
{
removeTempSep();
}
else if ( e->type() == QEvent::Drop )
{
removeTempSep();
QDropEvent *dev = static_cast<QDropEvent*>( e );
QDomDocument doc;
QList<KBookmark> list = KBookmark::List::fromMimeData( dev->mimeData(), doc );
if ( list.isEmpty() )
return false;
if (list.count() > 1)
kWarning(7043) << "Sorry, currently you can only drop one address "
"onto the bookmark bar!";
KBookmark toInsert = list.first();
KBookmarkGroup parentBookmark = getToolbar();
if(d->m_sepIndex == 0)
{
KBookmark newBookmark = parentBookmark.addBookmark(toInsert.fullText(), toInsert.url() );
parentBookmark.moveBookmark( newBookmark, KBookmark() );
m_pManager->emitChanged( parentBookmark );
return true;
}
else
{
KBookmark after = parentBookmark.first();
for(int i=0; i < d->m_sepIndex - 1 ; ++i)
after = parentBookmark.next(after);
KBookmark newBookmark = parentBookmark.addBookmark(toInsert.fullText(), toInsert.url() );
parentBookmark.moveBookmark( newBookmark, after );
m_pManager->emitChanged( parentBookmark );
return true;
}
}
else if ( e->type() == QEvent::DragMove || e->type() == QEvent::DragEnter )
{
QDragMoveEvent *dme = static_cast<QDragMoveEvent*>( e );
if (!KBookmark::List::canDecode( dme->mimeData() ))
return false;
//cache text, save positions (inserting the temporary widget changes the positions)
if(e->type() == QEvent::DragEnter)
{
QDomDocument doc;
const QList<KBookmark> list = KBookmark::List::fromMimeData( dme->mimeData(), doc );
if ( list.isEmpty() )
return false;
d->tempLabel = list.first().url().pathOrUrl();
d->widgetPositions.clear();
for (int i = 0; i < m_toolBar->actions().count(); ++i)
if (QWidget* button = m_toolBar->widgetForAction(m_toolBar->actions()[i])) {
if(m_toolBar->orientation() == Qt::Horizontal) {
if(QApplication::isLeftToRight()) {
d->widgetPositions.push_back(button->geometry().right());
} else {
d->widgetPositions.push_back(button->geometry().left());
}
} else {
d->widgetPositions.push_back(button->geometry().bottom());
}
}
}
bool accept = handleToolbarDragMoveEvent(dme->pos(), d->m_actions, d->tempLabel);
if (accept)
{
dme->accept();
return true; //Really?
}
}
return false;
}