void ActionsImpl::slotRecursiveSort() {
KEBApp::self()->bkInfo()->commitChanges();
KBookmark bk = KEBApp::self()->firstSelected();
Q_ASSERT(bk.isGroup());
KEBMacroCommand *mcmd = new KEBMacroCommand(i18nc("(qtundo-format)", "Recursive Sort"));
KBookmarkGroupList lister(GlobalBookmarkManager::self()->mgr());
QList<KBookmark> bookmarks = lister.getList(bk.toGroup());
bookmarks << bk.toGroup();
for (QList<KBookmark>::ConstIterator it = bookmarks.constBegin(); it != bookmarks.constEnd(); ++it) {
new SortCommand(m_model, "", (*it).address(), mcmd);
}
commandHistory()->addCommand(mcmd);
}
void KonqSidebarBookmarkModule::slotOpenTab()
{
KonqSidebarBookmarkItem *bi = dynamic_cast<KonqSidebarBookmarkItem*>( tree()->selectedItem() );
KBookmark bookmark;
if (bi)
{
bookmark = bi->bookmark();
}
else if(tree()->selectedItem() == m_topLevelItem)
bookmark = KonqBookmarkManager::self()->root();
else
return;
DCOPRef ref(kapp->dcopClient()->appId(), tree()->topLevelWidget()->name());
if (bookmark.isGroup()) {
KBookmarkGroup group = bookmark.toGroup();
bookmark = group.first();
while (!bookmark.isNull()) {
if (!bookmark.isGroup() && !bookmark.isSeparator())
ref.call( "newTab(QString)", bookmark.url().url() );
bookmark = group.next(bookmark);
}
} else {
ref.call( "newTab(QString)", bookmark.url().url() );
}
}
void KonqSidebarBookmarkModule::slotOpenTab()
{
KonqSidebarBookmarkItem *bi = dynamic_cast<KonqSidebarBookmarkItem*>( tree()->selectedItem() );
KBookmark bookmark;
if (bi)
{
bookmark = bi->bookmark();
}
else if(tree()->selectedItem() == m_topLevelItem)
bookmark = s_bookmarkManager->root();
else
return;
KParts::OpenUrlArguments args;
args.setActionRequestedByUser(true);
KParts::BrowserArguments browserArguments;
browserArguments.setNewTab(true);
if (bookmark.isGroup()) {
KBookmarkGroup group = bookmark.toGroup();
bookmark = group.first();
while (!bookmark.isNull()) {
if (!bookmark.isGroup() && !bookmark.isSeparator()) {
emit tree()->createNewWindow(bookmark.url(),
args,
browserArguments);
}
bookmark = group.next(bookmark);
}
} else {
emit tree()->createNewWindow(bookmark.url(),
args,
browserArguments);
}
}
QList< BookmarkMatch > KDEBrowser::match(const QString& term, bool addEverything)
{
KBookmarkGroup bookmarkGroup = m_bookmarkManager->root();
QList< BookmarkMatch > matches;
QStack<KBookmarkGroup> groups;
KBookmark bookmark = bookmarkGroup.first();
while (!bookmark.isNull()) {
// if (!context.isValid()) {
// return;
// } TODO: restore?
if (bookmark.isSeparator()) {
bookmark = bookmarkGroup.next(bookmark);
continue;
}
if (bookmark.isGroup()) { // descend
//kDebug (kdbg_code) << "descending into" << bookmark.text();
groups.push(bookmarkGroup);
bookmarkGroup = bookmark.toGroup();
bookmark = bookmarkGroup.first();
while (bookmark.isNull() && !groups.isEmpty()) {
// if (!context.isValid()) {
// return;
// } TODO: restore?
bookmark = bookmarkGroup;
bookmarkGroup = groups.pop();
bookmark = bookmarkGroup.next(bookmark);
}
continue;
}
BookmarkMatch bookmarkMatch(m_favicon, term, bookmark.text(), bookmark.url().url() );
bookmarkMatch.addTo(matches, addEverything);
bookmark = bookmarkGroup.next(bookmark);
while (bookmark.isNull() && !groups.isEmpty()) {
// if (!context.isValid()) {
// return;
// } // TODO: restore?
bookmark = bookmarkGroup;
bookmarkGroup = groups.pop();
//kDebug(kdbg_code) << "ascending from" << bookmark.text() << "to" << bookmarkGroup.text();
bookmark = bookmarkGroup.next(bookmark);
}
}
return matches;
}
void BookmarksProtocol::echoIndex()
{
parseTree();
echoHead();
KBookmark bm = tree.first();
if(bm.isNull()) {
echo("<p class=\"message\">" + i18n("There are no bookmarks to display yet.") + "</p>");
}
else {
for (int i = 1; i <= columns; i++)
{
int size = 0;
echo("<div class=\"column\">");
indent++;
while(!bm.isNull() && (size + sizeOfGroup(bm.toGroup())*2/3 < (totalsize / columns) || size == 0))
{
echoFolder(bm.toGroup());
size += sizeOfGroup(bm.toGroup());
bm = tree.next(bm);
}
if (i == columns)
{
while(!bm.isNull())
{
echoFolder(bm.toGroup());
bm = tree.next(bm);
}
}
indent--;
echo("</div>");
}
}
indent--;
echo("</body>");
echo("</html>");
}
void KBookmarkDialogPrivate::fillGroup(QTreeWidgetItem *parentItem, const KBookmarkGroup &group, const KBookmarkGroup &selectGroup)
{
for (KBookmark bk = group.first(); !bk.isNull(); bk = group.next(bk)) {
if (bk.isGroup()) {
const KBookmarkGroup bkGroup = bk.toGroup();
QTreeWidgetItem* item = new KBookmarkTreeItem(parentItem, folderTree, bkGroup);
if (selectGroup == bkGroup) {
folderTree->setCurrentItem(item);
}
fillGroup(item, bkGroup, selectGroup);
}
}
}
void CmdHistory::slotCommandExecuted(KCommand *k) {
KEBApp::self()->notifyCommandExecuted();
IKEBCommand * cmd = dynamic_cast<IKEBCommand *>(k);
Q_ASSERT(cmd);
KBookmark bk = CurrentMgr::bookmarkAt(cmd->affectedBookmarks());
Q_ASSERT(bk.isGroup());
CurrentMgr::self()->notifyManagers(bk.toGroup());
// sets currentItem to something sensible
// if the currentItem was invalidated by executing
// CreateCommand or DeleteManyCommand
// otherwise does nothing
// sensible is either a already selected item or cmd->currentAddress()
ListView::self()->fixUpCurrent( cmd->currentAddress() );
}
void KonqSidebarBookmarkModule::slotDropped(KListView *, QDropEvent *e, QListViewItem *parent, QListViewItem *after)
{
if (!KBookmarkDrag::canDecode(e))
return;
KBookmark afterBookmark;
KonqSidebarBookmarkItem *afterItem = dynamic_cast<KonqSidebarBookmarkItem*>(after);
if (afterItem)
afterBookmark = afterItem->bookmark();
KBookmarkGroup parentGroup;
// try to get the parent group...
if (after) {
parentGroup = afterBookmark.parentGroup();
} else if (parent) {
if(KonqSidebarBookmarkItem *p = dynamic_cast<KonqSidebarBookmarkItem*>(parent))
{
if (!p)
return;
KBookmark bm = p->bookmark();
if (bm.isGroup())
parentGroup = bm.toGroup();
else
return;
}
else if(parent == m_topLevelItem)
{
parentGroup = KonqBookmarkManager::self()->root();
}
} else {
// it's most probably the root...
parentGroup = KonqBookmarkManager::self()->root();
}
QValueList<KBookmark> bookmarks = KBookmarkDrag::decode(e);
// copy
QValueList<KBookmark>::iterator it = bookmarks.begin();
for (;it != bookmarks.end(); ++it) {
// insert new item.
parentGroup.moveItem(*it, afterBookmark);
}
KonqBookmarkManager::self()->emitChanged( parentGroup );
}
void KonqSidebarBookmarkModule::slotDropped(K3ListView *, QDropEvent *e, Q3ListViewItem *parent, Q3ListViewItem *after)
{
if (!KBookmark::List::canDecode(e->mimeData()))
return;
KBookmark afterBookmark;
KonqSidebarBookmarkItem *afterItem = dynamic_cast<KonqSidebarBookmarkItem*>(after);
if (afterItem)
afterBookmark = afterItem->bookmark();
KBookmarkGroup parentGroup;
// try to get the parent group...
if (after) {
parentGroup = afterBookmark.parentGroup();
} else if (parent) {
if(KonqSidebarBookmarkItem *p = dynamic_cast<KonqSidebarBookmarkItem*>(parent))
{
if (!p)
return;
KBookmark bm = p->bookmark();
if (bm.isGroup())
parentGroup = bm.toGroup();
else
return;
} else if(parent == m_topLevelItem) {
parentGroup = s_bookmarkManager->root();
}
} else {
// it's most probably the root...
parentGroup = s_bookmarkManager->root();
}
QDomDocument parentDocument;
const KBookmark::List bookmarks = KBookmark::List::fromMimeData(e->mimeData(), parentDocument);
// copy
KBookmark::List::const_iterator it = bookmarks.constBegin();
for (;it != bookmarks.constEnd(); ++it) {
// insert new item.
parentGroup.moveBookmark(*it, afterBookmark);
}
s_bookmarkManager->emitChanged( parentGroup );
}
void DeleteCommand::redo()
{
KBookmark bk = m_model->bookmarkManager()->findByAddress(m_from);
Q_ASSERT(!bk.isNull());
if (m_contentOnly) {
QDomElement groupRoot = bk.internalElement();
QDomNode n = groupRoot.firstChild();
while (!n.isNull()) {
QDomElement e = n.toElement();
if (!e.isNull()) {
// kDebug() << e.tagName();
}
QDomNode next = n.nextSibling();
groupRoot.removeChild(n);
n = next;
}
return;
}
// TODO - bug - unparsed xml is lost after undo,
// we must store it all therefore
//FIXME this removes the comments, that's bad!
if (!m_cmd) {
if (bk.isGroup()) {
m_cmd = new CreateCommand(m_model,
m_from, bk.fullText(), bk.icon(),
bk.internalElement().attribute("folded") == "no");
m_subCmd = deleteAll(m_model, bk.toGroup());
m_subCmd->redo();
} else {
m_cmd = (bk.isSeparator())
? new CreateCommand(m_model, m_from)
: new CreateCommand(m_model, m_from, bk.fullText(),
bk.icon(), bk.url());
}
}
m_cmd->undo();
}
void KBookmarkBar::fillBookmarkBar(const KBookmarkGroup & parent)
{
if (parent.isNull())
return;
for (KBookmark bm = parent.first(); !bm.isNull(); bm = parent.next(bm))
{
// Filtered special cases
if(d->m_filteredToolbar)
{
if(bm.isGroup() && !bm.showInToolbar() )
fillBookmarkBar(bm.toGroup());
if(!bm.showInToolbar())
continue;
}
if (!bm.isGroup())
{
if ( bm.isSeparator() )
m_toolBar->addSeparator();
else
{
KAction *action = new KBookmarkAction( bm, m_pOwner, 0 );
m_toolBar->addAction(action);
d->m_actions.append( action );
}
}
else
{
KBookmarkActionMenu *action = new KBookmarkActionMenu(bm, 0);
action->setDelayed( false );
m_toolBar->addAction(action);
d->m_actions.append( action );
KBookmarkMenu *menu = new KonqBookmarkMenu(m_pManager, m_pOwner, action, bm.address());
m_lstSubMenus.append( menu );
}
}
}
void BookmarksProtocol::echoFolder( const KBookmarkGroup &folder )
{
if (sizeOfGroup(folder.toGroup(), true) > 1)
{
QString descriptionAsTitle = folder.description();
if (!descriptionAsTitle.isEmpty())
descriptionAsTitle.prepend(QLatin1String("\" title=\""));
if (folder.parentGroup() == tree)
{
if (config.readEntry("ShowBackgrounds", true))
echo("<ul style=\"background-image: url(/background/" + folder.icon() + ")\">");
else
echo("<ul>");
echo ("<li class=\"title" + descriptionAsTitle + "\">" + folder.fullText() + "</li>");
}
else
{
echo("<ul>");
echo ("<li class=\"title" + descriptionAsTitle + "\"><img src=\"/icon/" + folder.icon() + "\"/>" + folder.text() + "</li>");
}
indent++;
for (KBookmark bm = folder.first(); !bm.isNull(); bm = folder.next(bm))
{
if (bm.isGroup())
echoFolder(bm.toGroup());
else if (bm.isSeparator())
echoSeparator();
else
echoBookmark(bm);
}
indent--;
echo("</ul>");
}
}
void KonqSidebarBookmarkModule::fillGroup( KonqSidebarTreeItem * parentItem, KBookmarkGroup group )
{
int n = 0;
for ( KBookmark bk = group.first() ; !bk.isNull() ; bk = group.next(bk), ++n )
{
KonqSidebarBookmarkItem * item = new KonqSidebarBookmarkItem( parentItem, m_topLevelItem, bk, n );
if ( bk.isGroup() )
{
KBookmarkGroup grp = bk.toGroup();
fillGroup( item, grp );
QString address(grp.address());
if (m_folderOpenState.contains(address))
item->setOpen(m_folderOpenState[address]);
else
item->setOpen(false);
}
else if ( bk.isSeparator() )
item->setVisible( false );
else
item->setExpandable( false );
}
}
void BookmarksPanel::loadFoldedState(const QModelIndex &root)
{
QAbstractItemModel *model = panelTreeView()->model();
if (!model)
return;
int count = model->rowCount(root);
QModelIndex index;
for (int i = 0; i < count; ++i)
{
index = model->index(i, 0, root);
if (index.isValid())
{
KBookmark bm = bookmarkForIndex(index);
if (bm.isGroup())
{
panelTreeView()->setExpanded(index, bm.toGroup().isOpen());
loadFoldedState(index);
}
}
}
}
void WebBrowser::fillGroup(BookmarkItem *parentItem, const KBookmarkGroup &group)
{
KBookmark it = group.first();
while (!it.isNull()) {
BookmarkItem *bookmarkItem = new BookmarkItem(it);
bookmarkItem->setEditable(false);
if (it.isGroup()) {
KBookmarkGroup grp = it.toGroup();
fillGroup( bookmarkItem, grp );
}
if (parentItem) {
parentItem->appendRow(bookmarkItem);
} else {
m_bookmarkModel->appendRow(bookmarkItem);
}
it = m_bookmarkManager->root().next(it);
}
}
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);
}