kbookmarkmenu.cc
// -*- c-basic-offset:4; indent-tabs-mode:nil -*-
// vim: set ts=4 sts=4 sw=4 et:
/* This file is part of the KDE project
Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "kbookmarkmenu.h"
#include "kbookmarkmenu_p.h"
#include "kbookmarkimporter.h"
#include "kbookmarkimporter_opera.h"
#include "kbookmarkimporter_ie.h"
#include "kbookmarkdrag.h"
#include <kapplication.h>
#include <kconfig.h>
#include <kdebug.h>
#include <kdialogbase.h>
#include <kiconloader.h>
#include <klineedit.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <kpopupmenu.h>
#include <kstdaccel.h>
#include <kstdaction.h>
#include <kstringhandler.h>
#include <qclipboard.h>
#include <qfile.h>
#include <qheader.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qlineedit.h>
#include <qlistview.h>
#include <qpushbutton.h>
#include <dptrtemplate.h>
template class QPtrList<KBookmarkMenu>;
static QString makeTextNodeMod(KBookmark bk, const QString &m_nodename, const QString &m_newText) {
QDomNode subnode = bk.internalElement().namedItem(m_nodename);
if (subnode.isNull()) {
subnode = bk.internalElement().ownerDocument().createElement(m_nodename);
bk.internalElement().appendChild(subnode);
}
if (subnode.firstChild().isNull()) {
QDomText domtext = subnode.ownerDocument().createTextNode("");
subnode.appendChild(domtext);
}
QDomText domtext = subnode.firstChild().toText();
QString m_oldText = domtext.data();
domtext.setData(m_newText);
return m_oldText;
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
KBookmarkMenu::KBookmarkMenu( KBookmarkManager* mgr,
KBookmarkOwner * _owner, KPopupMenu * _parentMenu,
KActionCollection *collec, bool _isRoot, bool _add,
const QString & parentAddress )
: QObject(),
m_bIsRoot(_isRoot), m_bAddBookmark(_add),
m_bAddShortcuts(true),
m_pManager(mgr), m_pOwner(_owner),
m_parentMenu( _parentMenu ),
m_actionCollection( collec ),
m_parentAddress( parentAddress )
{
m_parentMenu->setKeyboardShortcutsEnabled( true );
m_lstSubMenus.setAutoDelete( true );
m_actions.setAutoDelete( true );
if (m_actionCollection)
{
m_actionCollection->setHighlightingEnabled(true);
disconnect( m_actionCollection, SIGNAL( actionHighlighted( KAction * ) ), 0, 0 );
connect( m_actionCollection, SIGNAL( actionHighlighted( KAction * ) ),
this, SLOT( slotActionHighlighted( KAction * ) ) );
}
m_bNSBookmark = m_parentAddress.isNull();
if ( !m_bNSBookmark ) // not for the netscape bookmark
{
//kdDebug(7043) << "KBookmarkMenu::KBookmarkMenu " << this << " address : " << m_parentAddress << endl;
connect( _parentMenu, SIGNAL( aboutToShow() ),
SLOT( slotAboutToShow() ) );
if ( KBookmarkSettings::self()->m_contextmenu )
{
(void) _parentMenu->contextMenu();
connect( _parentMenu, SIGNAL( aboutToShowContextMenu(KPopupMenu*, int, QPopupMenu*) ),
this, SLOT( slotAboutToShowContextMenu(KPopupMenu*, int, QPopupMenu*) ));
}
if ( m_bIsRoot )
{
connect( m_pManager, SIGNAL( changed(const QString &, const QString &) ),
SLOT( slotBookmarksChanged(const QString &) ) );
}
}
// add entries that possibly have a shortcut, so they are available _before_ first popup
if ( m_bIsRoot )
{
if ( m_bAddBookmark )
{
addAddBookmark();
if ( extOwner() )
addAddBookmarksList(); // FIXME
}
addEditBookmarks();
}
m_bDirty = true;
}
KBookmarkMenu::~KBookmarkMenu()
{
//kdDebug(7043) << "KBookmarkMenu::~KBookmarkMenu() " << this << endl;
QPtrListIterator<KAction> it( m_actions );
for (; it.current(); ++it )
it.current()->unplugAll();
m_lstSubMenus.clear();
m_actions.clear();
}
void KBookmarkMenu::ensureUpToDate()
{
slotAboutToShow();
}
void KBookmarkMenu::slotAboutToShow()
{
// Did the bookmarks change since the last time we showed them ?
if ( m_bDirty )
{
m_bDirty = false;
refill();
}
}
QString KBookmarkMenu::s_highlightedAddress;
QString KBookmarkMenu::s_highlightedImportType;
QString KBookmarkMenu::s_highlightedImportLocation;
void KBookmarkMenu::slotActionHighlighted( KAction* action )
{
if (action->isA("KBookmarkActionMenu") || action->isA("KBookmarkAction"))
{
s_highlightedAddress = action->property("address").toString();
//kdDebug() << "KBookmarkMenu::slotActionHighlighted" << s_highlightedAddress << endl;
}
else if (action->isA("KImportedBookmarksActionMenu"))
{
s_highlightedImportType = action->property("type").toString();
s_highlightedImportLocation = action->property("location").toString();
}
else
{
s_highlightedAddress = QString::null;
s_highlightedImportType = QString::null;
s_highlightedImportLocation = QString::null;
}
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
class KBookmarkMenuRMBAssoc : public dPtrTemplate<KBookmarkMenu, RMB> { };
template<> QPtrDict<RMB>* dPtrTemplate<KBookmarkMenu, RMB>::d_ptr = 0;
static RMB* rmbSelf(KBookmarkMenu *m) { return KBookmarkMenuRMBAssoc::d(m); }
// TODO check via dcop before making any changes to the bookmarks file???
void RMB::begin_rmb_action(KBookmarkMenu *self)
{
RMB *s = rmbSelf(self);
s->recv = self;
s->m_parentAddress = self->m_parentAddress;
s->s_highlightedAddress = KBookmarkMenu::s_highlightedAddress;
s->m_pManager = self->m_pManager;
s->m_pOwner = self->m_pOwner;
s->m_parentMenu = self->m_parentMenu;
}
bool RMB::invalid( int val )
{
bool valid = true;
if (val == 1)
s_highlightedAddress = m_parentAddress;
if (s_highlightedAddress.isNull())
valid = false;
return !valid;
}
KBookmark RMB::atAddress(const QString & address)
{
KBookmark bookmark = m_pManager->findByAddress( address );
Q_ASSERT(!bookmark.isNull());
return bookmark;
}
void KBookmarkMenu::slotAboutToShowContextMenu( KPopupMenu*, int, QPopupMenu* contextMenu )
{
//kdDebug(7043) << "KBookmarkMenu::slotAboutToShowContextMenu" << s_highlightedAddress << endl;
if (s_highlightedAddress.isNull())
{
KPopupMenu::contextMenuFocus()->hideContextMenu();
return;
}
contextMenu->clear();
fillContextMenu( contextMenu, s_highlightedAddress, 0 );
}
void RMB::fillContextMenu( QPopupMenu* contextMenu, const QString & address, int val )
{
KBookmark bookmark = atAddress(address);
int id;
// binner:
// "Add Bookmark Here" when pointing at a bookmark looks strange and if you
// call it you have to close and reopen the menu to see an entry was added?
//
// TODO rename these, but, message freeze... umm...
// if (bookmark.isGroup()) {
id = contextMenu->insertItem( SmallIcon("bookmark_add"), i18n( "Add Bookmark Here" ), recv, SLOT(slotRMBActionInsert(int)) );
contextMenu->setItemParameter( id, val );
/* }
else
{
id = contextMenu->insertItem( SmallIcon("bookmark_add"), i18n( "Add Bookmark Here" ), recv, SLOT(slotRMBActionInsert(int)) );
contextMenu->setItemParameter( id, val );
}*/
}
void RMB::fillContextMenu2( QPopupMenu* contextMenu, const QString & address, int val )
{
KBookmark bookmark = atAddress(address);
int id;
if (bookmark.isGroup()) {
id = contextMenu->insertItem( i18n( "Open Folder in Bookmark Editor" ), recv, SLOT(slotRMBActionEditAt(int)) );
contextMenu->setItemParameter( id, val );
contextMenu->insertSeparator();
id = contextMenu->insertItem( SmallIcon("editdelete"), i18n( "Delete Folder" ), recv, SLOT(slotRMBActionRemove(int)) );
contextMenu->setItemParameter( id, val );
contextMenu->insertSeparator();
id = contextMenu->insertItem( i18n( "Properties" ), recv, SLOT(slotRMBActionProperties(int)) );
contextMenu->setItemParameter( id, val );
}
else
{
id = contextMenu->insertItem( i18n( "Copy Link Address" ), recv, SLOT(slotRMBActionCopyLocation(int)) );
contextMenu->setItemParameter( id, val );
contextMenu->insertSeparator();
id = contextMenu->insertItem( SmallIcon("editdelete"), i18n( "Delete Bookmark" ), recv, SLOT(slotRMBActionRemove(int)) );
contextMenu->setItemParameter( id, val );
contextMenu->insertSeparator();
id = contextMenu->insertItem( i18n( "Properties" ), recv, SLOT(slotRMBActionProperties(int)) );
contextMenu->setItemParameter( id, val );
}
}
void RMB::slotRMBActionEditAt( int val )
{
kdDebug(7043) << "KBookmarkMenu::slotRMBActionEditAt" << s_highlightedAddress << endl;
if (invalid(val)) { hidePopup(); return; }
KBookmark bookmark = atAddress(s_highlightedAddress);
m_pManager->slotEditBookmarksAtAddress( s_highlightedAddress );
}
void RMB::slotRMBActionProperties( int val )
{
kdDebug(7043) << "KBookmarkMenu::slotRMBActionProperties" << s_highlightedAddress << endl;
if (invalid(val)) { hidePopup(); return; }
KBookmark bookmark = atAddress(s_highlightedAddress);
QString folder = bookmark.isGroup() ? QString::null : bookmark.url().pathOrURL();
KBookmarkEditDialog dlg( bookmark.fullText(), folder,
m_pManager, KBookmarkEditDialog::ModifyMode, 0,
0, 0, i18n("Bookmark Properties") );
if ( dlg.exec() != KDialogBase::Accepted )
return;
makeTextNodeMod(bookmark, "title", dlg.finalTitle());
if ( !dlg.finalUrl().isNull() )
{
KURL u = KURL::fromPathOrURL(dlg.finalUrl());
bookmark.internalElement().setAttribute("href", u.url(0, 106));
}
kdDebug(7043) << "Requested move to " << dlg.finalAddress() << "!" << endl;
KBookmarkGroup parentBookmark = atAddress(m_parentAddress).toGroup();
m_pManager->emitChanged( parentBookmark );
}
void RMB::slotRMBActionInsert( int val )
{
kdDebug(7043) << "KBookmarkMenu::slotRMBActionInsert" << s_highlightedAddress << endl;
if (invalid(val)) { hidePopup(); return; }
QString url = m_pOwner->currentURL();
if (url.isEmpty())
{
KMessageBox::error( 0L, i18n("Cannot add bookmark with empty URL."));
return;
}
QString title = m_pOwner->currentTitle();
if (title.isEmpty())
title = url;
KBookmark bookmark = atAddress( s_highlightedAddress );
// TODO use unique title
if (bookmark.isGroup())
{
KBookmarkGroup parentBookmark = bookmark.toGroup();
Q_ASSERT(!parentBookmark.isNull());
parentBookmark.addBookmark( m_pManager, title, KURL( url ) );
m_pManager->emitChanged( parentBookmark );
}
else
{
KBookmarkGroup parentBookmark = bookmark.parentGroup();
Q_ASSERT(!parentBookmark.isNull());
KBookmark newBookmark = parentBookmark.addBookmark( m_pManager, title, KURL( url ) );
parentBookmark.moveItem( newBookmark, parentBookmark.previous(bookmark) );
m_pManager->emitChanged( parentBookmark );
}
}
void RMB::slotRMBActionRemove( int val )
{
//kdDebug(7043) << "KBookmarkMenu::slotRMBActionRemove" << s_highlightedAddress << endl;
if (invalid(val)) { hidePopup(); return; }
KBookmark bookmark = atAddress( s_highlightedAddress );
bool folder = bookmark.isGroup();
if (KMessageBox::warningContinueCancel(
m_parentMenu,
folder ? i18n("Are you sure you wish to remove the bookmark folder\n\"%1\"?").arg(bookmark.text())
: i18n("Are you sure you wish to remove the bookmark\n\"%1\"?").arg(bookmark.text()),
folder ? i18n("Bookmark Folder Deletion")
: i18n("Bookmark Deletion"),
KStdGuiItem::del())
!= KMessageBox::Continue
)
return;
KBookmarkGroup parentBookmark = atAddress( m_parentAddress ).toGroup();
parentBookmark.deleteBookmark( bookmark );
m_pManager->emitChanged( parentBookmark );
if (m_parentMenu)
m_parentMenu->hide();
}
void RMB::slotRMBActionCopyLocation( int val )
{
//kdDebug(7043) << "KBookmarkMenu::slotRMBActionCopyLocation" << s_highlightedAddress << endl;
if (invalid(val)) { hidePopup(); return; }
KBookmark bookmark = atAddress( s_highlightedAddress );
if ( !bookmark.isGroup() )
{
kapp->clipboard()->setData( KBookmarkDrag::newDrag(bookmark, 0),
QClipboard::Selection );
kapp->clipboard()->setData( KBookmarkDrag::newDrag(bookmark, 0),
QClipboard::Clipboard );
}
}
void RMB::hidePopup() {
KPopupMenu::contextMenuFocus()->hideContextMenu();
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
void KBookmarkMenu::fillContextMenu( QPopupMenu* contextMenu, const QString & address, int val )
{
RMB::begin_rmb_action(this);
rmbSelf(this)->fillContextMenu(contextMenu, address, val);
emit aboutToShowContextMenu( rmbSelf(this)->atAddress(address), contextMenu);
rmbSelf(this)->fillContextMenu2(contextMenu, address, val);
}
void KBookmarkMenu::slotRMBActionEditAt( int val )
{ RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionEditAt( val ); }
void KBookmarkMenu::slotRMBActionProperties( int val )
{ RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionProperties( val ); }
void KBookmarkMenu::slotRMBActionInsert( int val )
{ RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionInsert( val ); }
void KBookmarkMenu::slotRMBActionRemove( int val )
{ RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionRemove( val ); }
void KBookmarkMenu::slotRMBActionCopyLocation( int val )
{ RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionCopyLocation( val ); }
void KBookmarkMenu::slotBookmarksChanged( const QString & groupAddress )
{
if (m_bNSBookmark)
return;
if ( groupAddress == m_parentAddress )
{
//kdDebug(7043) << "KBookmarkMenu::slotBookmarksChanged -> setting m_bDirty on " << groupAddress << endl;
m_bDirty = true;
}
else
{
// Iterate recursively into child menus
QPtrListIterator<KBookmarkMenu> it( m_lstSubMenus );
for (; it.current(); ++it )
{
it.current()->slotBookmarksChanged( groupAddress );
}
}
}
void KBookmarkMenu::refill()
{
//kdDebug(7043) << "KBookmarkMenu::refill()" << endl;
m_lstSubMenus.clear();
QPtrListIterator<KAction> it( m_actions );
for (; it.current(); ++it )
it.current()->unplug( m_parentMenu );
m_parentMenu->clear();
m_actions.clear();
fillBookmarkMenu();
m_parentMenu->adjustSize();
}
void KBookmarkMenu::addAddBookmarksList()
{
if (!kapp->authorizeKAction("bookmarks"))
return;
QString title = i18n( "Bookmark Tabs as Folder..." );
KAction * paAddBookmarksList = new KAction( title,
"bookmarks_list_add",
0,
this,
SLOT( slotAddBookmarksList() ),
m_actionCollection, m_bIsRoot ? "add_bookmarks_list" : 0 );
paAddBookmarksList->setToolTip( i18n( "Add a folder of bookmarks for all open tabs." ) );
paAddBookmarksList->plug( m_parentMenu );
m_actions.append( paAddBookmarksList );
}
void KBookmarkMenu::addAddBookmark()
{
if (!kapp->authorizeKAction("bookmarks"))
return;
QString title = i18n( "Add Bookmark" );
KAction * paAddBookmarks = new KAction( title,
"bookmark_add",
m_bIsRoot && m_bAddShortcuts ? KStdAccel::addBookmark() : KShortcut(),
this,
SLOT( slotAddBookmark() ),
m_actionCollection, m_bIsRoot ? "add_bookmark" : 0 );
paAddBookmarks->setToolTip( i18n( "Add a bookmark for the current document" ) );
paAddBookmarks->plug( m_parentMenu );
m_actions.append( paAddBookmarks );
}
void KBookmarkMenu::addEditBookmarks()
{
if (!kapp->authorizeKAction("bookmarks"))
return;
KAction * m_paEditBookmarks = KStdAction::editBookmarks( m_pManager, SLOT( slotEditBookmarks() ),
m_actionCollection, "edit_bookmarks" );
m_paEditBookmarks->plug( m_parentMenu );
m_paEditBookmarks->setToolTip( i18n( "Edit your bookmark collection in a separate window" ) );
m_actions.append( m_paEditBookmarks );
}
void KBookmarkMenu::addNewFolder()
{
if (!kapp->authorizeKAction("bookmarks"))
return;
QString title = i18n( "&New Bookmark Folder..." );
int p;
while ( ( p = title.find( '&' ) ) >= 0 )
title.remove( p, 1 );
KAction * paNewFolder = new KAction( title,
"folder_new", //"folder",
0,
this,
SLOT( slotNewFolder() ),
m_actionCollection );
paNewFolder->setToolTip( i18n( "Create a new bookmark folder in this menu" ) );
paNewFolder->plug( m_parentMenu );
m_actions.append( paNewFolder );
}
void KBookmarkMenu::fillBookmarkMenu()
{
if (!kapp->authorizeKAction("bookmarks"))
return;
if ( m_bIsRoot )
{
if ( m_bAddBookmark )
{
addAddBookmark();
if ( extOwner() )
addAddBookmarksList(); // FIXME
}
addEditBookmarks();
if ( m_bAddBookmark && !KBookmarkSettings::self()->m_advancedaddbookmark )
addNewFolder();
}
if ( m_bIsRoot
&& KBookmarkManager::userBookmarksFile() == m_pManager->path() )
{
bool haveSep = false;
QValueList<QString> keys = KBookmarkMenu::dynamicBookmarksList();
QValueList<QString>::const_iterator it;
for ( it = keys.begin(); it != keys.end(); ++it )
{
DynMenuInfo info;
info = showDynamicBookmarks((*it));
if ( !info.show || !QFile::exists( info.location ) )
continue;
if (!haveSep)
{
m_parentMenu->insertSeparator();
haveSep = true;
}
KActionMenu * actionMenu;
actionMenu = new KImportedBookmarksActionMenu(
info.name, info.type,
m_actionCollection, "kbookmarkmenu" );
actionMenu->setProperty( "type", info.type );
actionMenu->setProperty( "location", info.location );
actionMenu->plug( m_parentMenu );
m_actions.append( actionMenu );
KBookmarkMenu *subMenu =
new KBookmarkMenu( m_pManager, m_pOwner, actionMenu->popupMenu(),
m_actionCollection, false,
m_bAddBookmark, QString::null );
connect( subMenu, SIGNAL( openBookmark( const QString &, Qt::ButtonState ) ),
this, SIGNAL( openBookmark( const QString &, Qt::ButtonState ) ));
m_lstSubMenus.append(subMenu);
connect(actionMenu->popupMenu(), SIGNAL(aboutToShow()), subMenu, SLOT(slotNSLoad()));
}
}
KBookmarkGroup parentBookmark = m_pManager->findByAddress( m_parentAddress ).toGroup();
Q_ASSERT(!parentBookmark.isNull());
bool separatorInserted = false;
for ( KBookmark bm = parentBookmark.first(); !bm.isNull(); bm = parentBookmark.next(bm) )
{
QString text = KStringHandler::csqueeze(bm.fullText(), 60);
text.replace( '&', "&&" );
if ( !separatorInserted && m_bIsRoot) {
// inserted before the first konq bookmark, to avoid the separator if no konq bookmark
m_parentMenu->insertSeparator();
separatorInserted = true;
}
if ( !bm.isGroup() )
{
if ( bm.isSeparator() )
{
m_parentMenu->insertSeparator();
}
else
{
//kdDebug(7043) << "Creating URL bookmark menu item for " << bm.text() << endl;
KAction * action = new KBookmarkAction( text, bm.icon(), 0, m_actionCollection, 0 );
connect(action, SIGNAL( activated ( KAction::ActivationReason, Qt::ButtonState )),
this, SLOT( slotBookmarkSelected( KAction::ActivationReason, Qt::ButtonState ) ));
action->setProperty( "url", bm.url().url() );
action->setProperty( "address", bm.address() );
action->setToolTip( bm.url().pathOrURL() );
action->plug( m_parentMenu );
m_actions.append( action );
}
}
else
{
//kdDebug(7043) << "Creating bookmark submenu named " << bm.text() << endl;
KActionMenu * actionMenu = new KBookmarkActionMenu( text, bm.icon(),
m_actionCollection,
"kbookmarkmenu" );
actionMenu->setProperty( "address", bm.address() );
actionMenu->plug( m_parentMenu );
m_actions.append( actionMenu );
KBookmarkMenu *subMenu = new KBookmarkMenu( m_pManager, m_pOwner, actionMenu->popupMenu(),
m_actionCollection, false,
m_bAddBookmark,
bm.address() );
connect(subMenu, SIGNAL( aboutToShowContextMenu( const KBookmark &, QPopupMenu * ) ),
this, SIGNAL( aboutToShowContextMenu( const KBookmark &, QPopupMenu * ) ));
connect(subMenu, SIGNAL( openBookmark( const QString &, Qt::ButtonState ) ),
this, SIGNAL( openBookmark( const QString &, Qt::ButtonState ) ));
m_lstSubMenus.append( subMenu );
}
}
if ( !m_bIsRoot && m_bAddBookmark )
{
if ( m_parentMenu->count() > 0 )
m_parentMenu->insertSeparator();
if ( KBookmarkSettings::self()->m_quickactions )
{
KActionMenu * actionMenu = new KActionMenu( i18n("Quick Actions"), m_actionCollection, 0L );
fillContextMenu( actionMenu->popupMenu(), m_parentAddress, 1 );
actionMenu->plug( m_parentMenu );
m_actions.append( actionMenu );
}
else
{
addAddBookmark();
if ( extOwner() )
addAddBookmarksList(); // FIXME
addNewFolder();
}
}
}
void KBookmarkMenu::slotAddBookmarksList()
{
KExtendedBookmarkOwner *extOwner = dynamic_cast<KExtendedBookmarkOwner*>(m_pOwner);
if (!extOwner)
{
kdWarning() << "erm, sorry ;-)" << endl;
return;
}
KExtendedBookmarkOwner::QStringPairList list;
extOwner->fillBookmarksList( list );
KBookmarkGroup parentBookmark = m_pManager->findByAddress( m_parentAddress ).toGroup();
Q_ASSERT(!parentBookmark.isNull());
KBookmarkGroup group = parentBookmark.createNewFolder( m_pManager );
if ( group.isNull() )
return; // user canceled i guess
KExtendedBookmarkOwner::QStringPairList::const_iterator it;
for ( it = list.begin(); it != list.end(); ++it )
group.addBookmark( m_pManager, (*it).first, KURL((*it).second) );
m_pManager->emitChanged( parentBookmark );
}
void KBookmarkMenu::slotAddBookmark()
{
KBookmarkGroup parentBookmark;
parentBookmark = m_pManager->addBookmarkDialog(m_pOwner->currentURL(), m_pOwner->currentTitle(), m_parentAddress);
if (!parentBookmark.isNull())
m_pManager->emitChanged( parentBookmark );
}
void KBookmarkMenu::slotNewFolder()
{
if ( !m_pOwner ) return; // this view doesn't handle bookmarks...
KBookmarkGroup parentBookmark = m_pManager->findByAddress( m_parentAddress ).toGroup();
Q_ASSERT(!parentBookmark.isNull());
KBookmarkGroup group = parentBookmark.createNewFolder( m_pManager );
if ( !group.isNull() )
{
KBookmarkGroup parentGroup = group.parentGroup();
m_pManager->emitChanged( parentGroup );
}
}
void KBookmarkMenu::slotBookmarkSelected( KAction::ActivationReason /*reason*/, Qt::ButtonState state )
{
kdDebug(7043) << "KBookmarkMenu::slotBookmarkSelected()" << endl;
if ( !m_pOwner ) return; // this view doesn't handle bookmarks...
const KAction* action = dynamic_cast<const KAction *>(sender());
if(action)
{
const QString& url = sender()->property("url").toString();
m_pOwner->openBookmarkURL( url );
emit openBookmark( url, state );
}
}
void KBookmarkMenu::slotBookmarkSelected()
{
slotBookmarkSelected(KAction::PopupMenuActivation, Qt::NoButton);
}
KExtendedBookmarkOwner* KBookmarkMenu::extOwner()
{
return dynamic_cast<KExtendedBookmarkOwner*>(m_pOwner);
}
void KBookmarkMenu::slotNSLoad()
{
// only fill menu once
m_parentMenu->disconnect(SIGNAL(aboutToShow()));
// not NSImporter, but kept old name for BC reasons
KBookmarkMenuNSImporter importer( m_pManager, this, m_actionCollection );
importer.openBookmarks(s_highlightedImportLocation, s_highlightedImportType);
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
KBookmarkEditFields::KBookmarkEditFields(QWidget *main, QBoxLayout *vbox, FieldsSet fieldsSet)
{
bool isF = (fieldsSet != FolderFieldsSet);
QGridLayout *grid = new QGridLayout( vbox, 2, isF ? 2 : 1 );
m_title = new KLineEdit( main );
grid->addWidget( m_title, 0, 1 );
grid->addWidget( new QLabel( m_title, i18n( "Name:" ), main ), 0, 0 );
m_title->setFocus();
if (isF)
{
m_url = new KLineEdit( main );
grid->addWidget( m_url, 1, 1 );
grid->addWidget( new QLabel( m_url, i18n( "Location:" ), main ), 1, 0 );
}
else
{
m_url = 0;
}
main->setMinimumSize( 300, 0 );
}
void KBookmarkEditFields::setName(const QString &str)
{
m_title->setText(str);
}
void KBookmarkEditFields::setLocation(const QString &str)
{
m_url->setText(str);
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
// TODO - make the dialog use Properties as a title when in Modify mode... (dirk noticed the bug...)
KBookmarkEditDialog::KBookmarkEditDialog(const QString& title, const QString& url, KBookmarkManager * mgr, BookmarkEditType editType, const QString& address,
QWidget * parent, const char * name, const QString& caption )
: KDialogBase(parent, name, true, caption,
(editType == InsertionMode) ? (User1|Ok|Cancel) : (Ok|Cancel),
Ok, false, KGuiItem()),
m_folderTree(0), m_mgr(mgr), m_editType(editType), m_address(address)
{
setButtonOK( (editType == InsertionMode) ? KGuiItem( i18n( "&Add" ), "bookmark_add") : i18n( "&Update" ) );
if (editType == InsertionMode) {
setButtonGuiItem( User1, KGuiItem( i18n( "&New Folder..." ), "folder_new") );
}
bool folder = url.isNull();
m_main = new QWidget( this );
setMainWidget( m_main );
QBoxLayout *vbox = new QVBoxLayout( m_main, 0, spacingHint() );
KBookmarkEditFields::FieldsSet fs =
folder ? KBookmarkEditFields::FolderFieldsSet
: KBookmarkEditFields::BookmarkFieldsSet;
m_fields = new KBookmarkEditFields(m_main, vbox, fs);
m_fields->setName(title);
if ( !folder )
m_fields->setLocation(url);
if ( editType == InsertionMode )
{
m_folderTree = KBookmarkFolderTree::createTree( m_mgr, m_main, name, m_address );
connect( m_folderTree, SIGNAL( doubleClicked(QListViewItem*) ),
this, SLOT( slotDoubleClicked(QListViewItem*) ) );
vbox->addWidget( m_folderTree );
connect( this, SIGNAL( user1Clicked() ), SLOT( slotUser1() ) );
}
}
void KBookmarkEditDialog::slotDoubleClicked( QListViewItem* item )
{
Q_ASSERT( m_folderTree );
m_folderTree->setCurrentItem( item );
accept();
}
void KBookmarkEditDialog::slotOk()
{
accept();
}
void KBookmarkEditDialog::slotCancel()
{
reject();
}
QString KBookmarkEditDialog::finalAddress() const
{
Q_ASSERT( m_folderTree );
return KBookmarkFolderTree::selectedAddress( m_folderTree );
}
QString KBookmarkEditDialog::finalUrl() const
{
return m_fields->m_url ? m_fields->m_url->text() : QString::null;
}
QString KBookmarkEditDialog::finalTitle() const
{
return m_fields->m_title ? m_fields->m_title->text() : QString::null;
}
void KBookmarkEditDialog::slotUser1()
{
// kdDebug(7043) << "KBookmarkEditDialog::slotUser1" << endl;
Q_ASSERT( m_folderTree );
QString address = KBookmarkFolderTree::selectedAddress( m_folderTree );
if ( address.isNull() ) return;
KBookmarkGroup bm = m_mgr->findByAddress( address ).toGroup();
Q_ASSERT(!bm.isNull());
Q_ASSERT(m_editType == InsertionMode);
KBookmarkGroup group = bm.createNewFolder( m_mgr );
if ( !group.isNull() )
{
KBookmarkGroup parentGroup = group.parentGroup();
m_mgr->emitChanged( parentGroup );
}
KBookmarkFolderTree::fillTree( m_folderTree, m_mgr );
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
static void fillGroup( QListView* listview, KBookmarkFolderTreeItem * parentItem, KBookmarkGroup group, bool expandOpenGroups = true, const QString& address = QString::null )
{
bool noSubGroups = true;
KBookmarkFolderTreeItem * lastItem = 0L;
KBookmarkFolderTreeItem * item = 0L;
for ( KBookmark bk = group.first() ; !bk.isNull() ; bk = group.next(bk) )
{
if ( bk.isGroup() )
{
KBookmarkGroup grp = bk.toGroup();
item = new KBookmarkFolderTreeItem( parentItem, lastItem, grp );
fillGroup( listview, item, grp, expandOpenGroups, address );
if ( expandOpenGroups && grp.isOpen() )
item->setOpen( true );
lastItem = item;
noSubGroups = false;
}
if (bk.address() == address) {
listview->setCurrentItem( lastItem );
listview->ensureItemVisible( item );
}
}
if ( noSubGroups ) {
parentItem->setOpen( true );
}
}
QListView* KBookmarkFolderTree::createTree( KBookmarkManager* mgr, QWidget* parent, const char* name, const QString& address )
{
QListView *listview = new QListView( parent, name );
listview->setRootIsDecorated( false );
listview->header()->hide();
listview->addColumn( i18n("Bookmark"), 200 );
listview->setSorting( -1, false );
listview->setSelectionMode( QListView::Single );
listview->setAllColumnsShowFocus( true );
listview->setResizeMode( QListView::AllColumns );
listview->setMinimumSize( 60, 100 );
fillTree( listview, mgr, address );
return listview;
}
void KBookmarkFolderTree::fillTree( QListView *listview, KBookmarkManager* mgr, const QString& address )
{
listview->clear();
KBookmarkGroup root = mgr->root();
KBookmarkFolderTreeItem * rootItem = new KBookmarkFolderTreeItem( listview, root );
listview->setCurrentItem( rootItem );
rootItem->setSelected( true );
fillGroup( listview, rootItem, root, (address == root.groupAddress() || address.isNull()) ? true : false, address );
rootItem->setOpen( true );
}
static KBookmarkFolderTreeItem* ft_cast( QListViewItem *i )
{
return static_cast<KBookmarkFolderTreeItem*>( i );
}
QString KBookmarkFolderTree::selectedAddress( QListView *listview )
{
if ( !listview)
return QString::null;
KBookmarkFolderTreeItem *item = ft_cast( listview->currentItem() );
return item ? item->m_bookmark.address() : QString::null;
}
void KBookmarkFolderTree::setAddress( QListView *listview, const QString & address )
{
KBookmarkFolderTreeItem* it = ft_cast( listview->firstChild() );
while ( true ) {
kdDebug(7043) << it->m_bookmark.address() << endl;
it = ft_cast( it->itemBelow() );
if ( !it )
return;
if ( it->m_bookmark.address() == address )
break;
}
it->setSelected( true );
listview->setCurrentItem( it );
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
// toplevel item
KBookmarkFolderTreeItem::KBookmarkFolderTreeItem( QListView *parent, const KBookmark & gp )
: QListViewItem(parent, i18n("Bookmarks")), m_bookmark(gp)
{
setPixmap(0, SmallIcon("bookmark"));
setExpandable(true);
}
// group
KBookmarkFolderTreeItem::KBookmarkFolderTreeItem( KBookmarkFolderTreeItem *parent, QListViewItem *after, const KBookmarkGroup & gp )
: QListViewItem(parent, after, gp.fullText()), m_bookmark(gp)
{
setPixmap(0, SmallIcon( gp.icon() ) );
setExpandable(true);
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
// NOTE - KBookmarkMenuNSImporter is really === KBookmarkMenuImporter
// i.e, it is _not_ ns specific. and in KDE4 it should be renamed.
void KBookmarkMenuNSImporter::openNSBookmarks()
{
openBookmarks( KNSBookmarkImporter::netscapeBookmarksFile(), "netscape" );
}
void KBookmarkMenuNSImporter::openBookmarks( const QString &location, const QString &type )
{
mstack.push(m_menu);
KBookmarkImporterBase *importer = KBookmarkImporterBase::factory(type);
if (!importer)
return;
importer->setFilename(location);
connectToImporter(*importer);
importer->parse();
delete importer;
}
void KBookmarkMenuNSImporter::connectToImporter(const QObject &importer)
{
connect( &importer, SIGNAL( newBookmark( const QString &, const QCString &, const QString & ) ),
SLOT( newBookmark( const QString &, const QCString &, const QString & ) ) );
connect( &importer, SIGNAL( newFolder( const QString &, bool, const QString & ) ),
SLOT( newFolder( const QString &, bool, const QString & ) ) );
connect( &importer, SIGNAL( newSeparator() ), SLOT( newSeparator() ) );
connect( &importer, SIGNAL( endFolder() ), SLOT( endFolder() ) );
}
void KBookmarkMenuNSImporter::newBookmark( const QString & text, const QCString & url, const QString & )
{
QString _text = KStringHandler::csqueeze(text);
_text.replace( '&', "&&" );
KAction * action = new KBookmarkAction(_text, "html", 0, 0, "", m_actionCollection, 0);
connect(action, SIGNAL( activated ( KAction::ActivationReason, Qt::ButtonState )),
m_menu, SLOT( slotBookmarkSelected( KAction::ActivationReason, Qt::ButtonState ) ));
action->setProperty( "url", url );
action->setToolTip( url );
action->plug( mstack.top()->m_parentMenu );
mstack.top()->m_actions.append( action );
}
void KBookmarkMenuNSImporter::newFolder( const QString & text, bool, const QString & )
{
QString _text = KStringHandler::csqueeze(text);
_text.replace( '&', "&&" );
KActionMenu * actionMenu = new KActionMenu( _text, "folder", m_actionCollection, 0L );
actionMenu->plug( mstack.top()->m_parentMenu );
mstack.top()->m_actions.append( actionMenu );
KBookmarkMenu *subMenu = new KBookmarkMenu( m_pManager, m_menu->m_pOwner, actionMenu->popupMenu(),
m_actionCollection, false,
m_menu->m_bAddBookmark, QString::null );
connect( subMenu, SIGNAL( openBookmark( const QString &, Qt::ButtonState ) ),
m_menu, SIGNAL( openBookmark( const QString &, Qt::ButtonState ) ));
mstack.top()->m_lstSubMenus.append( subMenu );
mstack.push(subMenu);
}
void KBookmarkMenuNSImporter::newSeparator()
{
mstack.top()->m_parentMenu->insertSeparator();
}
void KBookmarkMenuNSImporter::endFolder()
{
mstack.pop();
}
/********************************************************************/
/********************************************************************/
/********************************************************************/
KBookmarkMenu::DynMenuInfo KBookmarkMenu::showDynamicBookmarks( const QString &id )
{
KConfig config("kbookmarkrc", false, false);
config.setGroup("Bookmarks");
DynMenuInfo info;
info.show = false;
if (!config.hasKey("DynamicMenus")) {
// upgrade path
if (id == "netscape") {
KBookmarkManager *manager = KBookmarkManager::userBookmarksManager();
info.show = manager->root().internalElement().attribute("hide_nsbk") != "yes";
info.location = KNSBookmarkImporter::netscapeBookmarksFile();
info.type = "netscape";
info.name = i18n("Netscape Bookmarks");
} // else, no show
} else {
// have new version config
if (config.hasGroup("DynamicMenu-" + id)) {
config.setGroup("DynamicMenu-" + id);
info.show = config.readBoolEntry("Show");
info.location = config.readPathEntry("Location");
info.type = config.readEntry("Type");
info.name = config.readEntry("Name");
} // else, no show
}
return info;
}
QStringList KBookmarkMenu::dynamicBookmarksList()
{
KConfig config("kbookmarkrc", false, false);
config.setGroup("Bookmarks");
QStringList mlist;
if (config.hasKey("DynamicMenus"))
mlist = config.readListEntry("DynamicMenus");
else
mlist << "netscape";
return mlist;
}
void KBookmarkMenu::setDynamicBookmarks(const QString &id, const DynMenuInfo &newMenu)
{
KConfig config("kbookmarkrc", false, false);
// add group unconditionally
config.setGroup("DynamicMenu-" + id);
config.writeEntry("Show", newMenu.show);
config.writePathEntry("Location", newMenu.location);
config.writeEntry("Type", newMenu.type);
config.writeEntry("Name", newMenu.name);
QStringList elist;
config.setGroup("Bookmarks");
if (!config.hasKey("DynamicMenus")) {
if (newMenu.type != "netscape") {
// update from old xbel method to new rc method
// though only if not writing the netscape setting
config.setGroup("DynamicMenu-" "netscape");
DynMenuInfo xbelSetting;
xbelSetting = showDynamicBookmarks("netscape");
config.writeEntry("Show", xbelSetting.show);
config.writePathEntry("Location", xbelSetting.location);
config.writeEntry("Type", xbelSetting.type);
config.writeEntry("Name", xbelSetting.name);
}
} else {
elist = config.readListEntry("DynamicMenus");
}
// make sure list includes type
config.setGroup("Bookmarks");
if (elist.contains(id) < 1) {
elist << id;
config.writeEntry("DynamicMenus", elist);
}
config.sync();
}
#include "kbookmarkmenu.moc"
#include "kbookmarkmenu_p.moc"
KBookmarkGroup::previous
KBookmark previous(const KBookmark &current) const
Return the prevous sibling of a child bookmark of this group.
Definition: kbookmark.cc:78
KBookmarkGroup::createNewFolder
KBookmarkGroup createNewFolder(KBookmarkManager *mgr, const QString &text=QString::null, bool emitSignal=true)
Create a new bookmark folder, as the last child of this group.
Definition: kbookmark.cc:110
KBookmarkGroup::groupAddress
QString groupAddress() const
Much like KBookmark::address, but caches the address into m_address.
Definition: kbookmark.cc:45
KBookmarkOwner::openBookmarkURL
virtual void openBookmarkURL(const QString &_url)
This function is called if the user selects a bookmark.
Definition: kbookmarkmanager.cc:637
KBookmarkGroup::addBookmark
KBookmark addBookmark(KBookmarkManager *mgr, const KBookmark &bm, bool emitSignal=true)
Create a new bookmark, as the last child of this group Don't forget to use KBookmarkManager::self()->...
Definition: kbookmark.cc:178
KBookmarkManager
This class implements the reading/writing of bookmarks in XML.
Definition: kbookmarkmanager.h:53
KBookmarkOwner::currentTitle
virtual QString currentTitle() const
This function is called whenever the user wants to add the current page to the bookmarks list...
Definition: kbookmarkmanager.h:334
KBookmarkOwner::currentURL
virtual QString currentURL() const
This function is called whenever the user wants to add the current page to the bookmarks list...
Definition: kbookmarkmanager.h:344
KExtendedBookmarkOwner
Definition: kbookmarkmanager.h:353
KBookmarkGroup
A group of bookmarks.
Definition: kbookmark.h:199
KBookmarkOwner
The KBookmarkMenu and KBookmarkBar classes gives the user the ability to either edit bookmarks or add...
Definition: kbookmarkmanager.h:317
KBookmarkManager::userBookmarksManager
static KBookmarkManager * userBookmarksManager()
Returns a pointer to the users main bookmark collection.
Definition: kbookmarkmanager.cc:696
KBookmarkManager::root
KBookmarkGroup root() const
This will return the root bookmark.
Definition: kbookmarkmanager.cc:379
KBookmarkManager::userBookmarksFile
static QString userBookmarksFile()
Returns the path to the user's main bookmark collection file.
Definition: kbookmarkmanager.cc:691
KBookmarkGroup::isOpen
bool isOpen() const
Definition: kbookmark.cc:52
KBookmarkImporterBase
A class for importing NS bookmarks KEditBookmarks uses it to insert bookmarks into its DOM tree...
Definition: kbookmarkimporter.h:37
KBookmarkGroup::deleteBookmark
void deleteBookmark(KBookmark bk)
Delete a bookmark - it has to be one of our children ! Don't forget to use KBookmarkManager::self()->...
Definition: kbookmark.cc:213
KBookmarkGroup::moveItem
bool moveItem(const KBookmark &item, const KBookmark &after)
Moves item after after (which should be a child of ours).
Definition: kbookmark.cc:155
KBookmarkGroup::next
KBookmark next(const KBookmark &current) const
Return the next sibling of a child bookmark of this group.
Definition: kbookmark.cc:83
KBookmarkGroup::first
KBookmark first() const
Return the first child bookmark of this group.
Definition: kbookmark.cc:73

KDE Home | KDE Accessibility Home | Description of Access Keys