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 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);
}
}
void CreateCommand::undo()
{
KBookmark bk = m_model->bookmarkManager()->findByAddress(m_to);
Q_ASSERT(!bk.isNull() && !bk.parentGroup().isNull());
m_model->removeBookmark(bk);
}
QList<KBookmark> BookmarkManager::find(const QString &text)
{
QList<KBookmark> list;
KBookmarkGroup root = rootGroup();
if (!root.isNull())
for (KBookmark bookmark = root.first(); !bookmark.isNull(); bookmark = root.next(bookmark))
find(&list, bookmark, text);
return list;
}
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 KBookmarkMenu::fillBookmarks()
{
KBookmarkGroup parentBookmark = m_pManager->findByAddress(m_parentAddress).toGroup();
Q_ASSERT(!parentBookmark.isNull());
if (m_bIsRoot && !parentBookmark.first().isNull()) { // at least one bookmark
m_parentMenu->addSeparator();
}
for (KBookmark bm = parentBookmark.first(); !bm.isNull(); bm = parentBookmark.next(bm)) {
m_parentMenu->addAction(actionForBookmark(bm));
}
}
KEBMacroCommand* DeleteCommand::deleteAll(KBookmarkModel* model, const KBookmarkGroup & parentGroup)
{
KEBMacroCommand *cmd = new KEBMacroCommand(QString());
QStringList lstToDelete;
// we need to delete from the end, to avoid index shifting
for (KBookmark bk = parentGroup.first();
!bk.isNull(); bk = parentGroup.next(bk))
lstToDelete.prepend(bk.address());
for (QStringList::const_iterator it = lstToDelete.constBegin();
it != lstToDelete.constEnd(); ++it) {
new DeleteCommand(model, (*it), false, cmd);
}
return cmd;
}
void BookmarksSettingsPage::slotEditButtonClicked()
{
QListViewItem* item = m_listView->selectedItem();
assert(item != 0); // 'edit' may not get invoked when having no items
KBookmark bookmark = EditBookmarkDialog::getBookmark(i18n("Edit Bookmark"),
item->text(NameIdx),
KURL(item->text(URLIdx)),
item->text(IconIdx));
if (!bookmark.isNull()) {
item->setPixmap(PixmapIdx, SmallIcon(bookmark.icon()));
item->setText(NameIdx, bookmark.text());
item->setText(URLIdx, bookmark.url().prettyURL());
item->setText(IconIdx, bookmark.icon());
}
}
void BookmarksSidebarPage::updateBookmarks()
{
m_bookmarksList->clear();
KIconLoader iconLoader;
KBookmarkGroup root = DolphinSettings::instance().bookmarkManager()->root();
KBookmark bookmark = root.first();
while (!bookmark.isNull()) {
m_bookmarksList->insertItem( BookmarkItem::fromKbookmark(bookmark, iconLoader) );
bookmark = root.next(bookmark);
}
connectToActiveView();
}
bool ClearFaviconsAction::action()
{
QDir favIconDir(KGlobal::dirs()->saveLocation( "cache", QLatin1String( "favicons/" ) ));
QStringList saveTheseFavicons;
KBookmarkManager* konqiBookmarkMgr;
konqiBookmarkMgr =
KBookmarkManager::managerForFile(KStandardDirs::locateLocal("data",
QLatin1String("konqueror/bookmarks.xml")), QLatin1String( "konqueror" ));
kDebug() << "saving the favicons that are in konqueror bookmarks" ;
kDebug() << "opened konqueror bookmarks at " << konqiBookmarkMgr->path() ;
// get the entire slew of bookmarks
KBookmarkGroup konqiBookmarks = konqiBookmarkMgr->root();
// walk through the bookmarks, if they have a favicon we should keep it
KBookmark bookmark = konqiBookmarks.first();
while (!bookmark.isNull()) {
if ((bookmark.icon()).startsWith(QLatin1String("favicons/"))) {
// pick out the name, throw .png on the end, and store the filename
QRegExp regex(QLatin1String( "favicons/(.*)" ));
regex.indexIn(bookmark.icon(), 0);
kDebug() << "will save " << (regex.cap(1) + QLatin1String( ".png" )) ;
saveTheseFavicons << (regex.cap(1) + QLatin1String( ".png" ));
}
bookmark = konqiBookmarks.next(bookmark);
}
favIconDir.setFilter( QDir::Files );
const QStringList entries = favIconDir.entryList();
// erase all files in favicon directory...
for( QStringList::const_iterator it = entries.begin() ; it != entries.end() ; ++it) {
// ...if we're not supposed to save them, of course
if (!saveTheseFavicons.contains(*it)) {
kDebug() << "removing " << *it ;
if(!favIconDir.remove(*it)) {
errMsg = i18n("A favicon could not be removed.");
return false;
}
}
}
return true;
}
void BookmarkMenu::addOpenFolderInTabs()
{
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())
{
parentMenu()->addAction(rApp->bookmarkManager()->owner()->createAction(group, BookmarkOwner::OPEN_FOLDER));
}
}
}
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 BookmarksSidebarPage::adjustSelection(const KURL& url)
{
// TODO (remarked in dolphin/TODO): the following code is quite equal
// to BookmarkSelector::updateSelection().
KBookmarkGroup root = DolphinSettings::instance().bookmarkManager()->root();
KBookmark bookmark = root.first();
int maxLength = 0;
int selectedIndex = -1;
// Search the bookmark which is equal to the URL or at least is a parent URL.
// If there are more than one possible parent URL candidates, choose the bookmark
// which covers the bigger range of the URL.
int i = 0;
while (!bookmark.isNull()) {
const KURL bookmarkURL = bookmark.url();
if (bookmarkURL.isParentOf(url)) {
const int length = bookmarkURL.prettyURL().length();
if (length > maxLength) {
selectedIndex = i;
maxLength = length;
}
}
bookmark = root.next(bookmark);
++i;
}
const bool block = m_bookmarksList->signalsBlocked();
m_bookmarksList->blockSignals(true);
if (selectedIndex < 0) {
// no bookmark matches, hence deactivate any selection
const int currentIndex = m_bookmarksList->index(m_bookmarksList->selectedItem());
m_bookmarksList->setSelected(currentIndex, false);
}
else {
// select the bookmark which is part of the current URL
m_bookmarksList->setSelected(selectedIndex, true);
}
m_bookmarksList->blockSignals(block);
}
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 BookmarksContextMenu::addFolderActions()
{
KBookmarkGroup group = bookmark().toGroup();
if (bookmark().internalElement().attributeNode("toolbar").value() == "yes")
{
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::UNSET_TOOLBAR_FOLDER));
}
else
{
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::SET_TOOLBAR_FOLDER));
}
if (!group.first().isNull())
{
KBookmark child = group.first();
while (child.isGroup() || child.isSeparator())
{
child = group.next(child);
}
if (!child.isNull())
{
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::OPEN_FOLDER));
addSeparator();
}
}
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::BOOKMARK_PAGE));
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::NEW_FOLDER));
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::NEW_SEPARATOR));
addSeparator();
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::EDIT));
addAction(m_bmOwner->createAction(bookmark(), BookmarkOwner::DELETE));
}
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);
}
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);
}
}
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 BookmarksSettingsPage::slotAddButtonClicked()
{
KBookmark bookmark = EditBookmarkDialog::getBookmark(i18n("Add Bookmark"),
i18n("New bookmark"),
KURL(),
"bookmark");
if (!bookmark.isNull()) {
// insert bookmark into listview
QListViewItem* item = new QListViewItem(m_listView);
item->setPixmap(PixmapIdx, SmallIcon(bookmark.icon()));
item->setText(NameIdx, bookmark.text());
item->setText(URLIdx, bookmark.url().prettyURL());
item->setText(IconIdx, bookmark.icon());
m_listView->insertItem(item);
QListViewItem* lastItem = m_listView->lastChild();
if (lastItem != 0) {
item->moveItem(lastItem);
}
m_listView->setSelected(item, true);
updateButtons();
}
}
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());
}
BookmarksSettingsPage::BookmarksSettingsPage(QWidget*parent) :
SettingsPageBase(parent),
m_addButton(0),
m_removeButton(0),
m_moveUpButton(0),
m_moveDownButton(0)
{
QVBoxLayout* topLayout = new QVBoxLayout(parent, 2, KDialog::spacingHint());
const int spacing = KDialog::spacingHint();
QHBox* hBox = new QHBox(parent);
hBox->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
hBox->setSpacing(spacing);
hBox->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored);
m_listView = new KListView(hBox);
m_listView->addColumn(i18n("Icon"));
m_listView->addColumn(i18n("Name"));
m_listView->addColumn(i18n("Location"));
m_listView->setResizeMode(QListView::LastColumn);
m_listView->setColumnAlignment(0, Qt::AlignHCenter);
m_listView->setAllColumnsShowFocus(true);
m_listView->setSorting(-1);
connect(m_listView, SIGNAL(selectionChanged()),
this, SLOT(updateButtons()));
connect(m_listView, SIGNAL(pressed(QListViewItem*)),
this, SLOT(slotBookmarkPressed(QListViewItem*)));
connect(m_listView, SIGNAL(doubleClicked(QListViewItem*, const QPoint&, int)),
this, SLOT(slotBookmarkDoubleClicked(QListViewItem*, const QPoint&, int)));
QVBox* buttonBox = new QVBox(hBox);
buttonBox->setSpacing(spacing);
const QSizePolicy buttonSizePolicy(QSizePolicy::Preferred, QSizePolicy::Maximum);
m_addButton = new KPushButton(i18n("Add..."), buttonBox);
connect(m_addButton, SIGNAL(clicked()),
this, SLOT(slotAddButtonClicked()));
m_addButton->setSizePolicy(buttonSizePolicy);
m_editButton = new KPushButton(i18n("Edit..."), buttonBox);
connect(m_editButton, SIGNAL(clicked()),
this, SLOT(slotEditButtonClicked()));
m_editButton->setSizePolicy(buttonSizePolicy);
m_removeButton = new KPushButton(i18n("Remove"), buttonBox);
connect(m_removeButton, SIGNAL(clicked()),
this, SLOT(slotRemoveButtonClicked()));
m_removeButton->setSizePolicy(buttonSizePolicy);
m_moveUpButton = new KPushButton(i18n("Move Up"), buttonBox);
connect(m_moveUpButton, SIGNAL(clicked()),
this, SLOT(slotMoveUpButtonClicked()));
m_moveUpButton->setSizePolicy(buttonSizePolicy);
m_moveDownButton = new KPushButton(i18n("Move Down"), buttonBox);
connect(m_moveDownButton, SIGNAL(clicked()),
this, SLOT(slotMoveDownButtonClicked()));
m_moveDownButton->setSizePolicy(buttonSizePolicy);
// Add a dummy widget with no restriction regarding a vertical resizing.
// This assures that the spacing between the buttons is not increased.
new QWidget(buttonBox);
topLayout->addWidget(hBox);
// insert all editable bookmarks.
KBookmarkGroup root = DolphinSettings::instance().bookmarkManager()->root();
KBookmark bookmark = root.first();
QListViewItem* prev = 0;
while (!bookmark.isNull()) {
QListViewItem* item = new QListViewItem(m_listView);
item->setPixmap(PixmapIdx, SmallIcon(bookmark.icon()));
item->setText(NameIdx, bookmark.text());
item->setText(URLIdx, bookmark.url().prettyURL());
// add hidden column to be able to retrieve the icon name again
item->setText(IconIdx, bookmark.icon());
m_listView->insertItem(item);
if (prev != 0) {
item->moveItem(prev);
}
prev = item;
bookmark = root.next(bookmark);
}
m_listView->setSelected(m_listView->firstChild(), true);
updateButtons();
}
void URLNavigator::updateContent()
{
const QObjectList* list = children();
if (list == 0) {
return;
}
// set the iterator to the first URL navigator button
QObjectListIterator it(*list);
QObject* object = 0;
while ((object = it.current()) != 0) {
if (object->inherits("URLNavigatorButton")) {
break;
}
++it;
}
// delete all existing URL navigator buttons
QPtrList<QWidget> deleteList;
while ((object = it.current()) != 0) {
if (object->inherits("URLNavigatorButton")) {
// Don't close and delete the navigator button immediatly, otherwise
// the iterator won't work anymore and an object would get deleted more
// than once (-> crash).
deleteList.append(static_cast<QWidget*>(object));
}
++it;
}
// now close and delete all unused navigator buttons
QPtrListIterator<QWidget> deleteIter(deleteList);
QWidget* widget = 0;
while ((widget = deleteIter.current()) != 0) {
widget->close();
widget->deleteLater();
++deleteIter;
}
m_bookmarkSelector->updateSelection(url());
QToolTip::remove(m_toggleButton);
QString path(url().prettyURL());
if (m_toggleButton->state() == QButton::On) {
// TODO: don't hardcode the shortcut as part of the text
QToolTip::add(m_toggleButton, i18n("Browse (Ctrl+B, Escape)"));
setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
m_pathBox->show();
m_pathBox->setURL(url());
}
else {
// TODO: don't hardcode the shortcut as part of the text
QToolTip::add(m_toggleButton, i18n("Edit location (Ctrl+L)"));
setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
m_pathBox->hide();
QString dir_name;
// get the data from the currently selected bookmark
KBookmark bookmark = m_bookmarkSelector->selectedBookmark();
//int bookmarkIndex = m_bookmarkSelector->selectedIndex();
QString bookmarkPath;
if (bookmark.isNull()) {
// No bookmark is a part of the current URL.
// The following code tries to guess the bookmark
// path. E. g. "fish://[email protected]/var/lib" writes
// "fish://[email protected]" to 'bookmarkPath', which leads to the
// navigation indication 'Custom Path > var > lib".
int idx = path.find(QString("//"));
idx = path.find("/", (idx < 0) ? 0 : idx + 2);
bookmarkPath = (idx < 0) ? path : path.left(idx);
}
else {
bookmarkPath = bookmark.url().prettyURL();
}
const uint len = bookmarkPath.length();
// calculate the start point for the URL navigator buttons by counting
// the slashs inside the bookmark URL
int slashCount = 0;
for (uint i = 0; i < len; ++i) {
if (bookmarkPath.at(i) == QChar('/')) {
++slashCount;
}
}
if ((len > 0) && bookmarkPath.at(len - 1) == QChar('/')) {
assert(slashCount > 0);
--slashCount;
}
// create URL navigator buttons
int idx = slashCount;
bool hasNext = true;
do {
dir_name = path.section('/', idx, idx);
const bool isFirstButton = (idx == slashCount);
hasNext = isFirstButton || !dir_name.isEmpty();
if (hasNext) {
URLNavigatorButton* button = new URLNavigatorButton(idx, this);
if (isFirstButton) {
// the first URL navigator button should get the name of the bookmark
// instead of the directory name
QString text = bookmark.text();
if (text.isEmpty()) {
text = bookmarkPath;
}
button->setText(text);
}
button->show();
++idx;
}
} while (hasNext);
}
}
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();
}
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);
}
int main(int argc, char **argv)
{
const bool kdeRunning = kdeIsRunning();
KAboutData aboutData("kbookmarkmerger", I18N_NOOP("KBookmarkMerger"), "1.0",
I18N_NOOP("Merges bookmarks installed by 3rd parties into the user's bookmarks"), KAboutData::License_BSD,
I18N_NOOP("Copyright © 2005 Frerich Raabe"));
aboutData.addAuthor("Frerich Raabe", I18N_NOOP("Original author"), "*****@*****.**");
KCmdLineArgs::init(argc, argv, &aboutData);
KCmdLineArgs::addCmdLineOptions(cmdLineOptions);
if(!kdeRunning)
{
KApplication::disableAutoDcopRegistration();
}
KApplication app(false, false);
app.disableSessionManagement();
KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
if(args->count() != 1)
{
kdError() << "No directory to scan for bookmarks specified." << endl;
return 1;
}
KBookmarkManager *konqBookmarks = KBookmarkManager::userBookmarksManager();
QStringList mergedFiles;
{
KBookmarkGroup root = konqBookmarks->root();
for(KBookmark bm = root.first(); !bm.isNull(); bm = root.next(bm))
{
if(bm.isGroup())
{
continue;
}
QString mergedFrom = bm.metaDataItem("merged_from");
if(!mergedFrom.isNull())
{
mergedFiles << mergedFrom;
}
}
}
bool didMergeBookmark = false;
QString extraBookmarksDirName = QFile::decodeName(args->arg(0));
QDir extraBookmarksDir(extraBookmarksDirName, "*.xml");
if(!extraBookmarksDir.isReadable())
{
kdError() << "Failed to read files in directory " << extraBookmarksDirName << endl;
return 1;
}
for(unsigned int i = 0; i < extraBookmarksDir.count(); ++i)
{
const QString fileName = extraBookmarksDir[i];
if(mergedFiles.find(fileName) != mergedFiles.end())
{
continue;
}
const QString absPath = extraBookmarksDir.filePath(fileName);
KBookmarkManager *mgr = KBookmarkManager::managerForFile(absPath, false);
KBookmarkGroup root = mgr->root();
for(KBookmark bm = root.first(); !bm.isNull(); bm = root.next(bm))
{
if(bm.isGroup())
{
continue;
}
bm.setMetaDataItem("merged_from", fileName);
konqBookmarks->root().addBookmark(konqBookmarks, bm, false);
didMergeBookmark = true;
}
}
if(didMergeBookmark)
{
if(!konqBookmarks->save())
{
kdError() << "Failed to write merged bookmarks." << endl;
return 1;
}
if(kdeRunning)
{
konqBookmarks->notifyChanged("");
}
}
}
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();
}