• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KIO

  • kio
  • bookmarks
kbookmarkmenu.cc
Go to the documentation of this file.
1/* This file is part of the KDE project
2 Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
3 Copyright (C) 2006 Daniel Teske <teske@squorn.de>
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public License
16 along with this library; see the file COPYING.LIB. If not, write to
17 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
19*/
20
21#include "kbookmarkmenu.h"
22#include "kbookmarkmenu_p.h"
23
24#include "kbookmarkdialog.h"
25
26#include <kauthorized.h>
27#include <kdebug.h>
28#include <kiconloader.h>
29#include <klocale.h>
30#include <kmessagebox.h>
31#include <kmenu.h>
32#include <kstandardshortcut.h>
33#include <kstandardaction.h>
34#include <kstringhandler.h>
35#include <krun.h>
36#include <kactioncollection.h>
37
38#include <qclipboard.h>
39#include <qmimedata.h>
40
41
42#include <QtCore/QStack>
43#include <QtGui/QHeaderView>
44#include <QtGui/QApplication>
45
46/********************************************************************/
47/********************************************************************/
48/********************************************************************/
49class KBookmarkMenuPrivate
50{
51public:
52 KBookmarkMenuPrivate()
53 : newBookmarkFolder(0),
54 addAddBookmark(0),
55 bookmarksToFolder(0)
56 {
57 }
58
59 KAction *newBookmarkFolder;
60 KAction *addAddBookmark;
61 KAction *bookmarksToFolder;
62};
63
64
65KBookmarkMenu::KBookmarkMenu( KBookmarkManager* mgr,
66 KBookmarkOwner * _owner, KMenu * _parentMenu,
67 KActionCollection * actionCollection)
68 : QObject(),
69 m_actionCollection( actionCollection ),
70 d (new KBookmarkMenuPrivate()),
71 m_bIsRoot(true),
72 m_pManager(mgr), m_pOwner(_owner),
73 m_parentMenu( _parentMenu ),
74 m_parentAddress( QString("") ) //TODO KBookmarkAdress::root
75{
76 m_parentMenu->setKeyboardShortcutsEnabled( true );
77
78 //kDebug(7043) << "KBookmarkMenu::KBookmarkMenu " << this << " address : " << m_parentAddress;
79
80 connect( _parentMenu, SIGNAL( aboutToShow() ),
81 SLOT( slotAboutToShow() ) );
82
83 if ( KBookmarkSettings::self()->m_contextmenu )
84 {
85 m_parentMenu->setContextMenuPolicy(Qt::CustomContextMenu);
86 connect(m_parentMenu, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(slotCustomContextMenu(const QPoint &)));
87 }
88
89 connect( m_pManager, SIGNAL( changed(const QString &, const QString &) ),
90 SLOT( slotBookmarksChanged(const QString &) ) );
91
92 m_bDirty = true;
93 addActions();
94}
95
96void KBookmarkMenu::addActions()
97{
98 if ( m_bIsRoot )
99 {
100 addAddBookmark();
101 addAddBookmarksList();
102 addNewFolder();
103 addEditBookmarks();
104 }
105 else
106 {
107 if ( m_parentMenu->actions().count() > 0 )
108 m_parentMenu->addSeparator();
109
110 addOpenInTabs();
111 addAddBookmark();
112 addAddBookmarksList();
113 addNewFolder();
114 }
115}
116
117KBookmarkMenu::KBookmarkMenu( KBookmarkManager* mgr,
118 KBookmarkOwner * _owner, KMenu * _parentMenu,
119 const QString & parentAddress)
120 : QObject(),
121 m_actionCollection( new KActionCollection(this) ),
122 d (new KBookmarkMenuPrivate()),
123 m_bIsRoot(false),
124 m_pManager(mgr), m_pOwner(_owner),
125 m_parentMenu( _parentMenu ),
126 m_parentAddress( parentAddress )
127{
128 m_parentMenu->setKeyboardShortcutsEnabled( true );
129 connect( _parentMenu, SIGNAL( aboutToShow() ), SLOT( slotAboutToShow() ) );
130 if ( KBookmarkSettings::self()->m_contextmenu )
131 {
132 m_parentMenu->setContextMenuPolicy(Qt::CustomContextMenu);
133 connect(m_parentMenu, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(slotCustomContextMenu(const QPoint &)));
134 }
135 m_bDirty = true;
136}
137
138KBookmarkMenu::~KBookmarkMenu()
139{
140 qDeleteAll( m_lstSubMenus );
141 qDeleteAll( m_actions );
142 delete d;
143}
144
145void KBookmarkMenu::ensureUpToDate()
146{
147 slotAboutToShow();
148}
149
150void KBookmarkMenu::slotAboutToShow()
151{
152 // Did the bookmarks change since the last time we showed them ?
153 if ( m_bDirty )
154 {
155 m_bDirty = false;
156 clear();
157 refill();
158 m_parentMenu->adjustSize();
159 }
160}
161
162void KBookmarkMenu::slotCustomContextMenu( const QPoint & pos)
163{
164 QAction * action = m_parentMenu->actionAt(pos);
165 KMenu * menu = contextMenu(action);
166 if(!menu)
167 return;
168 menu->setAttribute(Qt::WA_DeleteOnClose);
169 menu->popup(m_parentMenu->mapToGlobal(pos));
170}
171
172KMenu * KBookmarkMenu::contextMenu( QAction * action )
173{
174 KBookmarkActionInterface* act = dynamic_cast<KBookmarkActionInterface *>(action);
175 if (!act)
176 return 0;
177 return new KBookmarkContextMenu(act->bookmark(), m_pManager, m_pOwner);
178}
179
180bool KBookmarkMenu::isRoot() const
181{
182 return m_bIsRoot;
183}
184
185bool KBookmarkMenu::isDirty() const
186{
187 return m_bDirty;
188}
189
190QString KBookmarkMenu::parentAddress() const
191{
192 return m_parentAddress;
193}
194
195KBookmarkManager * KBookmarkMenu::manager() const
196{
197 return m_pManager;
198}
199
200KBookmarkOwner * KBookmarkMenu::owner() const
201{
202 return m_pOwner;
203}
204
205KMenu * KBookmarkMenu::parentMenu() const
206{
207 return m_parentMenu;
208}
209
210/********************************************************************/
211/********************************************************************/
212/********************************************************************/
213
214KBookmarkActionInterface::KBookmarkActionInterface(const KBookmark &bk)
215: bm(bk)
216{}
217
218KBookmarkActionInterface::~KBookmarkActionInterface()
219{
220}
221
222const KBookmark KBookmarkActionInterface::bookmark() const
223{
224 return bm;
225}
226
227/********************************************************************/
228/********************************************************************/
229/********************************************************************/
230
231
232KBookmarkContextMenu::KBookmarkContextMenu(const KBookmark & bk, KBookmarkManager * manager, KBookmarkOwner *owner, QWidget * parent)
233 : KMenu(parent), bm(bk), m_pManager(manager), m_pOwner(owner)
234{
235 connect(this, SIGNAL(aboutToShow()), SLOT(slotAboutToShow()));
236}
237
238void KBookmarkContextMenu::slotAboutToShow()
239{
240 addActions();
241}
242
243void KBookmarkContextMenu::addActions()
244{
245 if (bm.isGroup())
246 {
247 addOpenFolderInTabs();
248 addBookmark();
249 addFolderActions();
250 }
251 else
252 {
253 addBookmark();
254 addBookmarkActions();
255 }
256}
257
258KBookmarkContextMenu::~KBookmarkContextMenu()
259{
260
261}
262
263
264void KBookmarkContextMenu::addBookmark()
265{
266 if( m_pOwner && m_pOwner->enableOption(KBookmarkOwner::ShowAddBookmark) )
267 addAction( KIcon("bookmark-new"), i18n( "Add Bookmark Here" ), this, SLOT(slotInsert()) );
268}
269
270void KBookmarkContextMenu::addFolderActions()
271{
272 addAction( i18n( "Open Folder in Bookmark Editor" ), this, SLOT(slotEditAt()) );
273 addProperties();
274 addSeparator();
275 addAction( KIcon("edit-delete"), i18n( "Delete Folder" ), this, SLOT(slotRemove()) );
276}
277
278
279void KBookmarkContextMenu::addProperties()
280{
281 addAction( i18n( "Properties" ), this, SLOT(slotProperties()) );
282}
283
284void KBookmarkContextMenu::addBookmarkActions()
285{
286 addAction( i18n( "Copy Link Address" ), this, SLOT(slotCopyLocation()) );
287 addProperties();
288 addSeparator();
289 addAction( KIcon("edit-delete"), i18n( "Delete Bookmark" ), this, SLOT(slotRemove()) );
290}
291
292void KBookmarkContextMenu::addOpenFolderInTabs()
293{
294 if(m_pOwner->supportsTabs())
295 addAction(KIcon("tab-new"), i18n( "Open Folder in Tabs" ), this, SLOT( slotOpenFolderInTabs() ) );
296}
297
298void KBookmarkContextMenu::slotEditAt()
299{
300 //kDebug(7043) << "KBookmarkMenu::slotEditAt" << m_highlightedAddress;
301 m_pManager->slotEditBookmarksAtAddress( bm.address() );
302}
303
304void KBookmarkContextMenu::slotProperties()
305{
306 //kDebug(7043) << "KBookmarkMenu::slotProperties" << m_highlightedAddress;
307
308 KBookmarkDialog * dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow());
309 dlg->editBookmark(bm);
310 delete dlg;
311}
312
313void KBookmarkContextMenu::slotInsert()
314{
315 //kDebug(7043) << "KBookmarkMenu::slotInsert" << m_highlightedAddress;
316
317 QString url = m_pOwner->currentUrl();
318 if (url.isEmpty())
319 {
320 KMessageBox::error( QApplication::activeWindow(), i18n("Cannot add bookmark with empty URL."));
321 return;
322 }
323 QString title = m_pOwner->currentTitle();
324 if (title.isEmpty())
325 title = url;
326
327 if (bm.isGroup())
328 {
329 KBookmarkGroup parentBookmark = bm.toGroup();
330 Q_ASSERT(!parentBookmark.isNull());
331 parentBookmark.addBookmark( title, KUrl(url) );
332 m_pManager->emitChanged( parentBookmark );
333 }
334 else
335 {
336 KBookmarkGroup parentBookmark = bm.parentGroup();
337 Q_ASSERT(!parentBookmark.isNull());
338 KBookmark newBookmark = parentBookmark.addBookmark( title, KUrl(m_pOwner->currentUrl()) );
339 parentBookmark.moveBookmark( newBookmark, parentBookmark.previous(bm) );
340 m_pManager->emitChanged( parentBookmark );
341 }
342}
343
344void KBookmarkContextMenu::slotRemove()
345{
346 //kDebug(7043) << "KBookmarkMenu::slotRemove" << m_highlightedAddress;
347
348 bool folder = bm.isGroup();
349
350 if (KMessageBox::warningContinueCancel(
351 QApplication::activeWindow(),
352 folder ? i18n("Are you sure you wish to remove the bookmark folder\n\"%1\"?", bm.text())
353 : i18n("Are you sure you wish to remove the bookmark\n\"%1\"?", bm.text()),
354 folder ? i18n("Bookmark Folder Deletion")
355 : i18n("Bookmark Deletion"),
356 KStandardGuiItem::del())
357 != KMessageBox::Continue
358 )
359 return;
360
361 KBookmarkGroup parentBookmark = bm.parentGroup();
362 parentBookmark.deleteBookmark( bm );
363 m_pManager->emitChanged( parentBookmark );
364}
365
366void KBookmarkContextMenu::slotCopyLocation()
367{
368 //kDebug(7043) << "KBookmarkMenu::slotCopyLocation" << m_highlightedAddress;
369
370 if ( !bm.isGroup() )
371 {
372 QMimeData* mimeData = new QMimeData;
373 bm.populateMimeData( mimeData );
374 QApplication::clipboard()->setMimeData( mimeData, QClipboard::Selection );
375 mimeData = new QMimeData;
376 bm.populateMimeData( mimeData );
377 QApplication::clipboard()->setMimeData( mimeData, QClipboard::Clipboard );
378 }
379}
380
381void KBookmarkContextMenu::slotOpenFolderInTabs()
382{
383 owner()->openFolderinTabs(bookmark().toGroup());
384}
385
386KBookmarkManager * KBookmarkContextMenu::manager() const
387{
388 return m_pManager;
389}
390
391KBookmarkOwner * KBookmarkContextMenu::owner() const
392{
393 return m_pOwner;
394}
395
396KBookmark KBookmarkContextMenu::bookmark() const
397{
398 return bm;
399}
400
401/********************************************************************/
402/********************************************************************/
403/********************************************************************/
404
405void KBookmarkMenu::slotBookmarksChanged( const QString & groupAddress )
406{
407 kDebug(7043)<<"KBookmarkMenu::slotBookmarksChanged( "<<groupAddress;
408 if ( groupAddress == m_parentAddress )
409 {
410 //kDebug(7043) << "KBookmarkMenu::slotBookmarksChanged -> setting m_bDirty on " << groupAddress;
411 m_bDirty = true;
412 }
413 else
414 {
415 // Iterate recursively into child menus
416 for ( QList<KBookmarkMenu *>::iterator it = m_lstSubMenus.begin(), end = m_lstSubMenus.end() ;
417 it != end ; ++it ) {
418 (*it)->slotBookmarksChanged( groupAddress );
419 }
420 }
421}
422
423void KBookmarkMenu::clear()
424{
425 qDeleteAll( m_lstSubMenus );
426 m_lstSubMenus.clear();
427
428 for ( QList<QAction *>::iterator it = m_actions.begin(), end = m_actions.end() ;
429 it != end ; ++it )
430 {
431 m_parentMenu->removeAction(*it);
432 delete *it;
433 }
434
435 m_parentMenu->clear();
436 m_actions.clear();
437}
438
439void KBookmarkMenu::refill()
440{
441 //kDebug(7043) << "KBookmarkMenu::refill()";
442 if(m_bIsRoot)
443 addActions();
444 fillBookmarks();
445 if(!m_bIsRoot)
446 addActions();
447}
448
449void KBookmarkMenu::addOpenInTabs()
450{
451 if( !m_pOwner || !m_pOwner->supportsTabs() || !KAuthorized::authorizeKAction("bookmarks") )
452 return;
453
454 QString title = i18n( "Open Folder in Tabs" );
455
456 KAction * paOpenFolderInTabs = new KAction( title, this );
457 paOpenFolderInTabs->setIcon( KIcon("tab-new") );
458 paOpenFolderInTabs->setHelpText( i18n( "Open all bookmarks in this folder as a new tab." ) );
459 connect( paOpenFolderInTabs, SIGNAL( triggered( bool ) ), this, SLOT( slotOpenFolderInTabs() ) );
460
461 m_parentMenu->addAction(paOpenFolderInTabs);
462 m_actions.append( paOpenFolderInTabs );
463}
464
465void KBookmarkMenu::addAddBookmarksList()
466{
467 if( !m_pOwner || !m_pOwner->enableOption(KBookmarkOwner::ShowAddBookmark) || !m_pOwner->supportsTabs() || !KAuthorized::authorizeKAction("bookmarks") )
468 return;
469
470 if (d->bookmarksToFolder == 0) {
471 QString title = i18n( "Bookmark Tabs as Folder..." );
472 d->bookmarksToFolder = new KAction( title, this );
473 m_actionCollection->addAction( m_bIsRoot ? "add_bookmarks_list" : 0, d->bookmarksToFolder);
474 d->bookmarksToFolder->setIcon( KIcon( "bookmark-new-list" ) );
475 d->bookmarksToFolder->setHelpText( i18n( "Add a folder of bookmarks for all open tabs." ) );
476 connect( d->bookmarksToFolder, SIGNAL( triggered( bool ) ), this, SLOT( slotAddBookmarksList() ) );
477 }
478
479 m_parentMenu->addAction(d->bookmarksToFolder);
480}
481
482void KBookmarkMenu::addAddBookmark()
483{
484 if( !m_pOwner || !m_pOwner->enableOption(KBookmarkOwner::ShowAddBookmark) || !KAuthorized::authorizeKAction("bookmarks") )
485 return;
486
487 if (d->addAddBookmark == 0) {
488 d->addAddBookmark = m_actionCollection->addAction(
489 KStandardAction::AddBookmark,
490 m_bIsRoot ? "add_bookmark" : 0,
491 this,
492 SLOT(slotAddBookmark()));
493 if (!m_bIsRoot)
494 d->addAddBookmark->setShortcut( QKeySequence() );
495 }
496
497 m_parentMenu->addAction(d->addAddBookmark);
498}
499
500void KBookmarkMenu::addEditBookmarks()
501{
502 if( ( m_pOwner && !m_pOwner->enableOption(KBookmarkOwner::ShowEditBookmark) ) || !KAuthorized::authorizeKAction("bookmarks") )
503 return;
504
505 KAction * m_paEditBookmarks = m_actionCollection->addAction(KStandardAction::EditBookmarks, "edit_bookmarks",
506 m_pManager, SLOT(slotEditBookmarks()));
507 m_parentMenu->addAction(m_paEditBookmarks);
508 m_paEditBookmarks->setHelpText( i18n( "Edit your bookmark collection in a separate window" ) );
509}
510
511void KBookmarkMenu::addNewFolder()
512{
513 if( !m_pOwner || !m_pOwner->enableOption(KBookmarkOwner::ShowAddBookmark) || !KAuthorized::authorizeKAction("bookmarks"))
514 return;
515
516 if (d->newBookmarkFolder == 0) {
517 d->newBookmarkFolder = new KAction( i18n( "New Bookmark Folder..." ), this );
518 d->newBookmarkFolder->setIcon( KIcon( "folder-new" ) );
519 d->newBookmarkFolder->setHelpText( i18n( "Create a new bookmark folder in this menu" ) );
520 connect( d->newBookmarkFolder, SIGNAL( triggered( bool ) ), this, SLOT( slotNewFolder() ) );
521 }
522
523 m_parentMenu->addAction(d->newBookmarkFolder);
524
525}
526
527void KBookmarkMenu::fillBookmarks()
528{
529 KBookmarkGroup parentBookmark = m_pManager->findByAddress( m_parentAddress ).toGroup();
530 Q_ASSERT(!parentBookmark.isNull());
531
532 if ( m_bIsRoot && !parentBookmark.first().isNull() ) // at least one bookmark
533 {
534 m_parentMenu->addSeparator();
535 }
536
537 for ( KBookmark bm = parentBookmark.first(); !bm.isNull(); bm = parentBookmark.next(bm) )
538 {
539 m_parentMenu->addAction(actionForBookmark(bm));
540 }
541}
542
543QAction* KBookmarkMenu::actionForBookmark(const KBookmark &bm)
544{
545 if ( bm.isGroup() )
546 {
547 //kDebug(7043) << "Creating bookmark submenu named " << bm.text();
548 KActionMenu * actionMenu = new KBookmarkActionMenu( bm, this );
549 m_actions.append( actionMenu );
550 KBookmarkMenu *subMenu = new KBookmarkMenu( m_pManager, m_pOwner, actionMenu->menu(), bm.address() );
551 m_lstSubMenus.append( subMenu );
552 return actionMenu;
553 }
554 else if ( bm.isSeparator() )
555 {
556 QAction *sa = new QAction(this);
557 sa->setSeparator(true);
558 m_actions.append(sa);
559 return sa;
560 }
561 else
562 {
563 //kDebug(7043) << "Creating bookmark menu item for " << bm.text();
564 KAction * action = new KBookmarkAction( bm, m_pOwner, this );
565 m_actions.append( action );
566 return action;
567 }
568}
569
570void KBookmarkMenu::slotAddBookmarksList()
571{
572 if( !m_pOwner || !m_pOwner->supportsTabs())
573 return;
574
575 KBookmarkGroup parentBookmark = m_pManager->findByAddress( m_parentAddress ).toGroup();
576
577 KBookmarkDialog * dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow());
578 dlg->addBookmarks(m_pOwner->currentBookmarkList(), "", parentBookmark);
579 delete dlg;
580}
581
582
583void KBookmarkMenu::slotAddBookmark()
584{
585 if( !m_pOwner ) return;
586 KBookmarkGroup parentBookmark = m_pManager->findByAddress( m_parentAddress ).toGroup();
587
588 if(KBookmarkSettings::self()->m_advancedaddbookmark)
589 {
590 KBookmarkDialog * dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow() );
591 dlg->addBookmark(m_pOwner->currentTitle(), KUrl(m_pOwner->currentUrl()), parentBookmark );
592 delete dlg;
593 }
594 else
595 {
596 parentBookmark.addBookmark(m_pOwner->currentTitle(), KUrl(m_pOwner->currentUrl()));
597 m_pManager->emitChanged( parentBookmark );
598 }
599
600}
601
602void KBookmarkMenu::slotOpenFolderInTabs()
603{
604 m_pOwner->openFolderinTabs(m_pManager->findByAddress( m_parentAddress ).toGroup());
605}
606
607void KBookmarkMenu::slotNewFolder()
608{
609 if ( !m_pOwner ) return; // this view doesn't handle bookmarks...
610 KBookmarkGroup parentBookmark = m_pManager->findByAddress( m_parentAddress ).toGroup();
611 Q_ASSERT(!parentBookmark.isNull());
612 KBookmarkDialog * dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow());
613 dlg->createNewFolder("", parentBookmark);
614 delete dlg;
615}
616
617void KImportedBookmarkMenu::slotNSLoad()
618{
619 kDebug(7043)<<"**** slotNSLoad ****"<<m_type<<" "<<m_location;
620 // only fill menu once
621 parentMenu()->disconnect(SIGNAL(aboutToShow()));
622
623 // not NSImporter, but kept old name for BC reasons
624 KBookmarkMenuImporter importer( manager(), this );
625 importer.openBookmarks(m_location, m_type);
626}
627
628KImportedBookmarkMenu::KImportedBookmarkMenu( KBookmarkManager* mgr,
629 KBookmarkOwner * owner, KMenu * parentMenu,
630 const QString & type, const QString & location )
631 :KBookmarkMenu(mgr, owner, parentMenu, QString()), m_type(type), m_location(location)
632{
633 connect(parentMenu, SIGNAL(aboutToShow()), this, SLOT(slotNSLoad()));
634}
635
636KImportedBookmarkMenu::KImportedBookmarkMenu( KBookmarkManager* mgr,
637 KBookmarkOwner * owner, KMenu * parentMenu)
638 :KBookmarkMenu(mgr, owner, parentMenu, QString()), m_type(QString()), m_location(QString())
639{
640
641}
642
643KImportedBookmarkMenu::~KImportedBookmarkMenu()
644{
645
646}
647
648void KImportedBookmarkMenu::refill()
649{
650
651}
652
653void KImportedBookmarkMenu::clear()
654{
655
656}
657
658
659/********************************************************************/
660/********************************************************************/
661/********************************************************************/
662
663void KBookmarkMenuImporter::openBookmarks( const QString &location, const QString &type )
664{
665 mstack.push(m_menu);
666
667 KBookmarkImporterBase *importer = KBookmarkImporterBase::factory(type);
668 if (!importer)
669 return;
670 importer->setFilename(location);
671 connectToImporter(*importer);
672 importer->parse();
673
674 delete importer;
675}
676
677void KBookmarkMenuImporter::connectToImporter(const QObject &importer)
678{
679 connect( &importer, SIGNAL( newBookmark( const QString &, const QString &, const QString & ) ),
680 SLOT( newBookmark( const QString &, const QString &, const QString & ) ) );
681 connect( &importer, SIGNAL( newFolder( const QString &, bool, const QString & ) ),
682 SLOT( newFolder( const QString &, bool, const QString & ) ) );
683 connect( &importer, SIGNAL( newSeparator() ), SLOT( newSeparator() ) );
684 connect( &importer, SIGNAL( endFolder() ), SLOT( endFolder() ) );
685}
686
687void KBookmarkMenuImporter::newBookmark( const QString & text, const QString & url, const QString & )
688{
689 KBookmark bm = KBookmark::standaloneBookmark(text, url, QString("html"));
690 KAction * action = new KBookmarkAction(bm, mstack.top()->owner(), this);
691 mstack.top()->parentMenu()->addAction(action);
692 mstack.top()->m_actions.append( action );
693}
694
695void KBookmarkMenuImporter::newFolder( const QString & text, bool, const QString & )
696{
697 QString _text = KStringHandler::csqueeze(text).replace( '&', "&&" );
698 KActionMenu * actionMenu = new KImportedBookmarkActionMenu( KIcon("folder"), _text, this );
699 mstack.top()->parentMenu()->addAction(actionMenu);
700 mstack.top()->m_actions.append( actionMenu );
701 KImportedBookmarkMenu *subMenu = new KImportedBookmarkMenu( m_pManager, m_menu->owner(), actionMenu->menu());
702 mstack.top()->m_lstSubMenus.append( subMenu );
703
704 mstack.push(subMenu);
705}
706
707void KBookmarkMenuImporter::newSeparator()
708{
709 mstack.top()->parentMenu()->addSeparator();
710}
711
712void KBookmarkMenuImporter::endFolder()
713{
714 mstack.pop();
715}
716
717/********************************************************************/
718/********************************************************************/
719/********************************************************************/
720
721
722KBookmarkAction::KBookmarkAction(const KBookmark &bk, KBookmarkOwner* owner, QObject *parent )
723 : KAction( bk.text().replace('&', "&&"), parent),
724 KBookmarkActionInterface(bk),
725 m_pOwner(owner)
726{
727 setIcon(KIcon(bookmark().icon()));
728 setIconText(text());
729 setHelpText( bookmark().url().pathOrUrl() );
730 const QString description = bk.description();
731 if (!description.isEmpty())
732 setToolTip( description );
733 connect(this, SIGNAL( triggered(Qt::MouseButtons, Qt::KeyboardModifiers) ),
734 SLOT( slotSelected(Qt::MouseButtons, Qt::KeyboardModifiers) ));
735}
736
737KBookmarkAction::~KBookmarkAction()
738{
739}
740
741void KBookmarkAction::slotSelected(Qt::MouseButtons mb, Qt::KeyboardModifiers km)
742{
743 if( !m_pOwner )
744 new KRun( bookmark().url() ,(QWidget*)0);
745 else
746 m_pOwner->openBookmark( bookmark(), mb, km );
747}
748
749KBookmarkActionMenu::KBookmarkActionMenu(const KBookmark &bm, QObject *parent)
750 : KActionMenu(KIcon(bm.icon()), bm.text().replace('&', "&&"), parent),
751 KBookmarkActionInterface(bm)
752{
753 setToolTip( bm.description() );
754 setIconText(text());
755}
756
757KBookmarkActionMenu::KBookmarkActionMenu(const KBookmark &bm, const QString & text, QObject *parent)
758 : KActionMenu(text, parent),
759 KBookmarkActionInterface(bm)
760{
761}
762
763KBookmarkActionMenu::~KBookmarkActionMenu()
764{
765}
766
767#include "kbookmarkmenu.moc"
768#include "kbookmarkmenu_p.moc"
KActionCollection
KActionCollection::addAction
KAction * addAction(const QString &name, const QObject *receiver=0, const char *member=0)
KActionMenu
KActionMenu::menu
KMenu * menu()
KAction
KAction::triggered
void triggered(Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
KAction::setHelpText
void setHelpText(const QString &text)
KBookmarkActionInterface
Definition: kbookmarkmenu.h:226
KBookmarkActionInterface::KBookmarkActionInterface
KBookmarkActionInterface(const KBookmark &bk)
Definition: kbookmarkmenu.cc:214
KBookmarkActionInterface::bookmark
const KBookmark bookmark() const
Definition: kbookmarkmenu.cc:222
KBookmarkActionInterface::~KBookmarkActionInterface
virtual ~KBookmarkActionInterface()
Definition: kbookmarkmenu.cc:218
KBookmarkActionMenu
Definition: kbookmarkmenu.h:241
KBookmarkActionMenu::~KBookmarkActionMenu
virtual ~KBookmarkActionMenu()
Definition: kbookmarkmenu.cc:763
KBookmarkActionMenu::KBookmarkActionMenu
KBookmarkActionMenu(const KBookmark &bm, QObject *parent)
Definition: kbookmarkmenu.cc:749
KBookmarkAction
Definition: kbookmarkmenu.h:256
KBookmarkAction::slotSelected
void slotSelected(Qt::MouseButtons mb, Qt::KeyboardModifiers km)
Definition: kbookmarkmenu.cc:741
KBookmarkAction::KBookmarkAction
KBookmarkAction(const KBookmark &bk, KBookmarkOwner *owner, QObject *parent)
Definition: kbookmarkmenu.cc:722
KBookmarkAction::~KBookmarkAction
virtual ~KBookmarkAction()
Definition: kbookmarkmenu.cc:737
KBookmarkContextMenu
Definition: kbookmarkmenu.h:189
KBookmarkContextMenu::slotProperties
void slotProperties()
Definition: kbookmarkmenu.cc:304
KBookmarkContextMenu::~KBookmarkContextMenu
virtual ~KBookmarkContextMenu()
Definition: kbookmarkmenu.cc:258
KBookmarkContextMenu::addBookmarkActions
void addBookmarkActions()
Definition: kbookmarkmenu.cc:284
KBookmarkContextMenu::addProperties
void addProperties()
Definition: kbookmarkmenu.cc:279
KBookmarkContextMenu::slotOpenFolderInTabs
void slotOpenFolderInTabs()
Definition: kbookmarkmenu.cc:381
KBookmarkContextMenu::addActions
virtual void addActions()
Definition: kbookmarkmenu.cc:243
KBookmarkContextMenu::slotCopyLocation
void slotCopyLocation()
Definition: kbookmarkmenu.cc:366
KBookmarkContextMenu::bookmark
KBookmark bookmark() const
Definition: kbookmarkmenu.cc:396
KBookmarkContextMenu::addBookmark
void addBookmark()
Definition: kbookmarkmenu.cc:264
KBookmarkContextMenu::addFolderActions
void addFolderActions()
Definition: kbookmarkmenu.cc:270
KBookmarkContextMenu::slotEditAt
void slotEditAt()
Definition: kbookmarkmenu.cc:298
KBookmarkContextMenu::slotRemove
void slotRemove()
Definition: kbookmarkmenu.cc:344
KBookmarkContextMenu::KBookmarkContextMenu
KBookmarkContextMenu(const KBookmark &bm, KBookmarkManager *manager, KBookmarkOwner *owner, QWidget *parent=0)
Definition: kbookmarkmenu.cc:232
KBookmarkContextMenu::owner
KBookmarkOwner * owner() const
Definition: kbookmarkmenu.cc:391
KBookmarkContextMenu::manager
KBookmarkManager * manager() const
Definition: kbookmarkmenu.cc:386
KBookmarkContextMenu::slotInsert
void slotInsert()
Definition: kbookmarkmenu.cc:313
KBookmarkContextMenu::addOpenFolderInTabs
void addOpenFolderInTabs()
Definition: kbookmarkmenu.cc:292
KBookmarkDialog
This class provides a Dialog for editing properties, adding Bookmarks and creating new folders.
Definition: kbookmarkdialog.h:45
KBookmarkDialog::editBookmark
KBookmark editBookmark(const KBookmark &bm)
shows a propeties dialog Note: That this updates the bookmark and calls KBookmarkManager::emitChanged
Definition: kbookmarkdialog.cc:36
KBookmarkDialog::addBookmark
KBookmark addBookmark(const QString &title, const KUrl &url, KBookmark parent=KBookmark())
shows a add Bookmark dialog Note: That this updates the bookmark and calls KBookmarkManager::emitChan...
Definition: kbookmarkdialog.cc:63
KBookmarkDialog::addBookmarks
KBookmarkGroup addBookmarks(const QList< QPair< QString, QString > > &list, const QString &name=QString(), KBookmarkGroup parent=KBookmarkGroup())
Creates a folder from a list of bookmarks Note: That this updates the bookmark and calls KBookmarkMan...
Definition: kbookmarkdialog.cc:92
KBookmarkDialog::createNewFolder
KBookmarkGroup createNewFolder(const QString &name, KBookmark parent=KBookmark())
A dialog to create a new folder.
Definition: kbookmarkdialog.cc:151
KBookmarkGroup
A group of bookmarks.
Definition: kbookmark.h:348
KBookmarkGroup::next
KBookmark next(const KBookmark &current) const
Return the next sibling of a child bookmark of this group.
Definition: kbookmark.cc:123
KBookmarkGroup::first
KBookmark first() const
Return the first child bookmark of this group.
Definition: kbookmark.cc:113
KBookmarkGroup::deleteBookmark
void deleteBookmark(const KBookmark &bk)
Delete a bookmark - it has to be one of our children ! Don't forget to use KBookmarkManager::self()->...
Definition: kbookmark.cc:237
KBookmarkGroup::previous
KBookmark previous(const KBookmark &current) const
Return the prevous sibling of a child bookmark of this group.
Definition: kbookmark.cc:118
KBookmarkGroup::moveBookmark
bool moveBookmark(const KBookmark &bookmark, const KBookmark &after)
Moves bookmark after after (which should be a child of ours).
Definition: kbookmark.cc:189
KBookmarkGroup::addBookmark
KBookmark addBookmark(const KBookmark &bm)
Create a new bookmark, as the last child of this group Don't forget to use KBookmarkManager::self()->...
Definition: kbookmark.cc:212
KBookmarkImporterBase
A class for importing NS bookmarks KEditBookmarks uses it to insert bookmarks into its DOM tree,...
Definition: kbookmarkimporter.h:35
KBookmarkImporterBase::setFilename
void setFilename(const QString &filename)
Definition: kbookmarkimporter.h:41
KBookmarkImporterBase::parse
virtual void parse()=0
KBookmarkImporterBase::factory
static KBookmarkImporterBase * factory(const QString &type)
Definition: kbookmarkimporter.cc:85
KBookmarkManager
This class implements the reading/writing of bookmarks in XML.
Definition: kbookmarkmanager.h:66
KBookmarkManager::findByAddress
KBookmark findByAddress(const QString &address)
Definition: kbookmarkmanager.cc:519
KBookmarkManager::slotEditBookmarksAtAddress
void slotEditBookmarksAtAddress(const QString &address)
Definition: kbookmarkmanager.cc:631
KBookmarkManager::emitChanged
void emitChanged()
Saves the bookmark file and notifies everyone.
Definition: kbookmarkmanager.cc:549
KBookmarkMenuImporter
A class connected to KNSBookmarkImporter, to fill KActionMenus.
Definition: kbookmarkmenu_p.h:98
KBookmarkMenuImporter::m_menu
KImportedBookmarkMenu * m_menu
Definition: kbookmarkmenu_p.h:115
KBookmarkMenuImporter::connectToImporter
void connectToImporter(const QObject &importer)
Definition: kbookmarkmenu.cc:677
KBookmarkMenuImporter::newSeparator
void newSeparator()
Definition: kbookmarkmenu.cc:707
KBookmarkMenuImporter::newBookmark
void newBookmark(const QString &text, const QString &url, const QString &)
Definition: kbookmarkmenu.cc:687
KBookmarkMenuImporter::mstack
QStack< KImportedBookmarkMenu * > mstack
Definition: kbookmarkmenu_p.h:114
KBookmarkMenuImporter::endFolder
void endFolder()
Definition: kbookmarkmenu.cc:712
KBookmarkMenuImporter::m_pManager
KBookmarkManager * m_pManager
Definition: kbookmarkmenu_p.h:116
KBookmarkMenuImporter::openBookmarks
void openBookmarks(const QString &location, const QString &type)
Definition: kbookmarkmenu.cc:663
KBookmarkMenuImporter::newFolder
void newFolder(const QString &text, bool, const QString &)
Definition: kbookmarkmenu.cc:695
KBookmarkMenu
This class provides a bookmark menu.
Definition: kbookmarkmenu.h:77
KBookmarkMenu::m_actionCollection
KActionCollection * m_actionCollection
Definition: kbookmarkmenu.h:164
KBookmarkMenu::addEditBookmarks
void addEditBookmarks()
Definition: kbookmarkmenu.cc:500
KBookmarkMenu::addNewFolder
void addNewFolder()
Definition: kbookmarkmenu.cc:511
KBookmarkMenu::refill
virtual void refill()
Definition: kbookmarkmenu.cc:439
KBookmarkMenu::parentMenu
KMenu * parentMenu() const
The menu in which we insert our actions Supplied in the constructor.
Definition: kbookmarkmenu.cc:205
KBookmarkMenu::slotAddBookmarksList
void slotAddBookmarksList()
Definition: kbookmarkmenu.cc:570
KBookmarkMenu::m_actions
QList< QAction * > m_actions
List of our actions.
Definition: kbookmarkmenu.h:168
KBookmarkMenu::slotAboutToShow
void slotAboutToShow()
Definition: kbookmarkmenu.cc:150
KBookmarkMenu::KBookmarkMenu
KBookmarkMenu(KBookmarkManager *mgr, KBookmarkOwner *owner, KMenu *parentMenu, KActionCollection *collec)
Fills a bookmark menu (one instance of KBookmarkMenu is created for the toplevel menu,...
Definition: kbookmarkmenu.cc:65
KBookmarkMenu::ensureUpToDate
void ensureUpToDate()
Call ensureUpToDate() if you need KBookmarkMenu to adjust to its final size before it is executed.
Definition: kbookmarkmenu.cc:145
KBookmarkMenu::contextMenu
virtual KMenu * contextMenu(QAction *action)
Definition: kbookmarkmenu.cc:172
KBookmarkMenu::actionForBookmark
virtual QAction * actionForBookmark(const KBookmark &bm)
Definition: kbookmarkmenu.cc:543
KBookmarkMenu::slotBookmarksChanged
void slotBookmarksChanged(const QString &)
Definition: kbookmarkmenu.cc:405
KBookmarkMenu::~KBookmarkMenu
~KBookmarkMenu()
Definition: kbookmarkmenu.cc:138
KBookmarkMenu::isRoot
bool isRoot() const
Definition: kbookmarkmenu.cc:180
KBookmarkMenu::slotOpenFolderInTabs
void slotOpenFolderInTabs()
Definition: kbookmarkmenu.cc:602
KBookmarkMenu::clear
virtual void clear()
Definition: kbookmarkmenu.cc:423
KBookmarkMenu::parentAddress
QString parentAddress() const
Parent bookmark for this menu.
Definition: kbookmarkmenu.cc:190
KBookmarkMenu::manager
KBookmarkManager * manager() const
Definition: kbookmarkmenu.cc:195
KBookmarkMenu::addActions
void addActions()
Definition: kbookmarkmenu.cc:96
KBookmarkMenu::addOpenInTabs
void addOpenInTabs()
Definition: kbookmarkmenu.cc:449
KBookmarkMenu::slotNewFolder
void slotNewFolder()
Definition: kbookmarkmenu.cc:607
KBookmarkMenu::fillBookmarks
void fillBookmarks()
Definition: kbookmarkmenu.cc:527
KBookmarkMenu::addAddBookmark
void addAddBookmark()
Definition: kbookmarkmenu.cc:482
KBookmarkMenu::slotAddBookmark
void slotAddBookmark()
Definition: kbookmarkmenu.cc:583
KBookmarkMenu::addAddBookmarksList
void addAddBookmarksList()
Definition: kbookmarkmenu.cc:465
KBookmarkMenu::owner
KBookmarkOwner * owner() const
Definition: kbookmarkmenu.cc:200
KBookmarkMenu::isDirty
bool isDirty() const
Definition: kbookmarkmenu.cc:185
KBookmarkMenu::m_lstSubMenus
QList< KBookmarkMenu * > m_lstSubMenus
List of our sub menus.
Definition: kbookmarkmenu.h:159
KBookmarkOwner
The KBookmarkMenu and KBookmarkBar classes gives the user the ability to either edit bookmarks or add...
Definition: kbookmarkmanager.h:383
KBookmarkOwner::enableOption
virtual bool enableOption(BookmarkOption option) const
Returns true if action should be shown in the menu The default is to show both a add and editBookmark...
Definition: kbookmarkmanager.cc:707
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:407
KBookmarkOwner::currentBookmarkList
virtual QList< QPair< QString, QString > > currentBookmarkList() const
Returns a list of title, URL pairs of the open tabs.
Definition: kbookmarkmanager.h:420
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:396
KBookmarkOwner::bookmarkDialog
virtual KBookmarkDialog * bookmarkDialog(KBookmarkManager *mgr, QWidget *parent)
Definition: kbookmarkmanager.cc:716
KBookmarkOwner::ShowAddBookmark
@ ShowAddBookmark
Definition: kbookmarkmanager.h:422
KBookmarkOwner::ShowEditBookmark
@ ShowEditBookmark
Definition: kbookmarkmanager.h:422
KBookmarkOwner::supportsTabs
virtual bool supportsTabs() const
This function returns whether the owner supports tabs.
Definition: kbookmarkmanager.h:414
KBookmarkOwner::openBookmark
virtual void openBookmark(const KBookmark &bm, Qt::MouseButtons mb, Qt::KeyboardModifiers km)=0
Called if a bookmark is selected.
KBookmarkOwner::openFolderinTabs
virtual void openFolderinTabs(const KBookmarkGroup &bm)
Called if the user wants to open every bookmark in this folder in a new tab.
Definition: kbookmarkmanager.cc:721
KBookmarkSettings::self
static KBookmarkSettings * self()
Definition: kbookmarkmanager.cc:695
KBookmark
Definition: kbookmark.h:35
KBookmark::text
QString text() const
Text shown for the bookmark If bigger than 40, the text is shortened by replacing middle characters w...
Definition: kbookmark.cc:306
KBookmark::parentGroup
KBookmarkGroup parentGroup() const
Definition: kbookmark.cc:460
KBookmark::standaloneBookmark
static KBookmark standaloneBookmark(const QString &text, const KUrl &url, const QString &icon=QString())
Creates a stand alone bookmark.
Definition: kbookmark.cc:501
KBookmark::description
QString description() const
Definition: kbookmark.cc:402
KBookmark::isNull
bool isNull() const
Definition: kbookmark.cc:295
KBookmark::isGroup
bool isGroup() const
Whether the bookmark is a group or a normal bookmark.
Definition: kbookmark.cc:283
KBookmark::toGroup
KBookmarkGroup toGroup() const
Convert this to a group - do this only if isGroup() returns true.
Definition: kbookmark.cc:465
KBookmark::isSeparator
bool isSeparator() const
Whether the bookmark is a separator.
Definition: kbookmark.cc:290
KBookmark::address
QString address() const
Return the "address" of this bookmark in the whole tree.
Definition: kbookmark.cc:471
KBookmark::populateMimeData
void populateMimeData(QMimeData *mimeData) const
Adds this bookmark into the given QMimeData.
Definition: kbookmark.cc:659
KIcon
KImportedBookmarkActionMenu
Definition: kbookmarkmenu_p.h:120
KImportedBookmarkMenu
Definition: kbookmarkmenu_p.h:52
KImportedBookmarkMenu::KImportedBookmarkMenu
KImportedBookmarkMenu(KBookmarkManager *mgr, KBookmarkOwner *owner, KMenu *parentMenu, const QString &type, const QString &location)
Definition: kbookmarkmenu.cc:628
KImportedBookmarkMenu::slotNSLoad
void slotNSLoad()
Definition: kbookmarkmenu.cc:617
KImportedBookmarkMenu::~KImportedBookmarkMenu
~KImportedBookmarkMenu()
Definition: kbookmarkmenu.cc:643
KImportedBookmarkMenu::refill
virtual void refill()
Definition: kbookmarkmenu.cc:648
KImportedBookmarkMenu::clear
virtual void clear()
Definition: kbookmarkmenu.cc:653
KMenu
KMenu::setKeyboardShortcutsEnabled
void setKeyboardShortcutsEnabled(bool enable)
KMessageBox::error
static void error(QWidget *parent, const QString &text, const QString &caption=QString(), Options options=Notify)
KMessageBox::warningContinueCancel
static int warningContinueCancel(QWidget *parent, const QString &text, const QString &caption=QString(), const KGuiItem &buttonContinue=KStandardGuiItem::cont(), const KGuiItem &buttonCancel=KStandardGuiItem::cancel(), const QString &dontAskAgainName=QString(), Options options=Notify)
KMessageBox::Continue
Continue
KRun
To open files with their associated applications in KDE, use KRun.
Definition: krun.h:60
KUrl
QAction
QList
QObject
QWidget
kDebug
#define kDebug
kactioncollection.h
kauthorized.h
kbookmarkdialog.h
kbookmarkmenu.h
kbookmarkmenu_p.h
kdebug.h
kiconloader.h
klocale.h
i18n
QString i18n(const char *text)
kmenu.h
kmessagebox.h
krun.h
kstandardaction.h
kstandardshortcut.h
kstringhandler.h
KAuthorized::authorizeKAction
bool authorizeKAction(const QString &action)
replace
KAction * replace(const QObject *recvr, const char *slot, QObject *parent)
KStandardAction::EditBookmarks
EditBookmarks
KStandardAction::AddBookmark
AddBookmark
KStandardGuiItem::del
KGuiItem del()
end
const KShortcut & end()
KStringHandler::csqueeze
QString csqueeze(const QString &str, int maxlen=40)
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KIO

Skip menu "KIO"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal