• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • kio/bookmarks
 

kio/bookmarks

  • kio
  • bookmarks
kbookmarkbar.cc
1 // -*- c-basic-offset:4; indent-tabs-mode:nil -*-
2 // vim: set ts=4 sts=4 sw=4 et:
3 /* This file is part of the KDE project
4  Copyright (C) 1999 Kurt Granroth <granroth@kde.org>
5  Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
6 
7  This library is free software; you can redistribute it and/or
8  modify it under the terms of the GNU Library General Public
9  License as published by the Free Software Foundation; either
10  version 2 of the License, or (at your option) any later version.
11 
12  This library is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  Library General Public License for more details.
16 
17  You should have received a copy of the GNU Library General Public License
18  along with this library; see the file COPYING.LIB. If not, write to
19  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  Boston, MA 02110-1301, USA.
21 */
22 #include <tqregexp.h>
23 #include <tqfile.h>
24 
25 #include <kbookmarkbar.h>
26 #include <kbookmarkdrag.h>
27 
28 #include <kbookmarkmenu.h>
29 #include <kdebug.h>
30 
31 #include <ktoolbar.h>
32 #include <ktoolbarbutton.h>
33 
34 #include <kconfig.h>
35 #include <kpopupmenu.h>
36 
37 #include "kbookmarkdrag.h"
38 #include "kbookmarkmenu_p.h"
39 #include "kbookmarkdombuilder.h"
40 
41 #include "dptrtemplate.h"
42 
43 #include <tqapplication.h>
44 
45 class KBookmarkBarPrivate : public dPtrTemplate<KBookmarkBar, KBookmarkBarPrivate>
46 {
47 public:
48  TQPtrList<KAction> m_actions;
49  bool m_readOnly;
50  KBookmarkManager* m_filteredMgr;
51  KToolBar* m_sepToolBar;
52  int m_sepIndex;
53  bool m_atFirst;
54  TQString m_dropAddress;
55  TQString m_highlightedAddress;
56 public:
57  KBookmarkBarPrivate() {
58  m_readOnly = false;
59  m_filteredMgr = 0;
60  m_sepToolBar = 0;
61  m_sepIndex = -1;
62  m_atFirst = false;
63  }
64 };
65 template<> TQPtrDict<KBookmarkBarPrivate>* dPtrTemplate<KBookmarkBar, KBookmarkBarPrivate>::d_ptr = 0;
66 
67 KBookmarkBarPrivate* KBookmarkBar::dptr() const
68 {
69  return KBookmarkBarPrivate::d( this );
70 }
71 
72 // usage of KXBELBookmarkImporterImpl is just plain evil, but it reduces code dup. so...
73 class ToolbarFilter : public KXBELBookmarkImporterImpl
74 {
75 public:
76  ToolbarFilter() : m_visible(false) { ; }
77  void filter( const KBookmarkGroup &grp ) { traverse(grp); }
78 private:
79  virtual void visit( const KBookmark & );
80  virtual void visitEnter( const KBookmarkGroup & );
81  virtual void visitLeave( const KBookmarkGroup & );
82 private:
83  bool m_visible;
84  KBookmarkGroup m_visibleStart;
85 };
86 
87 KBookmarkBar::KBookmarkBar( KBookmarkManager* mgr,
88  KBookmarkOwner *_owner, KToolBar *_toolBar,
89  KActionCollection *coll,
90  TQObject *parent, const char *name )
91  : TQObject( parent, name ), m_pOwner(_owner), m_toolBar(_toolBar),
92  m_actionCollection( coll ), m_pManager(mgr)
93 {
94  m_lstSubMenus.setAutoDelete( true );
95 
96  m_toolBar->setAcceptDrops( true );
97  m_toolBar->installEventFilter( this ); // for drops
98 
99  dptr()->m_actions.setAutoDelete( true );
100 
101  connect( mgr, TQT_SIGNAL( changed(const TQString &, const TQString &) ),
102  TQT_SLOT( slotBookmarksChanged(const TQString &) ) );
103 
104  KBookmarkGroup toolbar = getToolbar();
105  fillBookmarkBar( toolbar );
106 }
107 
108 TQString KBookmarkBar::parentAddress()
109 {
110  return dptr()->m_filteredMgr ? TQString::null : m_pManager->toolbar().address();
111 }
112 
113 #define CURRENT_TOOLBAR() ( \
114  dptr()->m_filteredMgr ? dptr()->m_filteredMgr->root() \
115  : m_pManager->toolbar() )
116 
117 #define CURRENT_MANAGER() ( \
118  dptr()->m_filteredMgr ? dptr()->m_filteredMgr \
119  : m_pManager )
120 
121 KBookmarkGroup KBookmarkBar::getToolbar()
122 {
123  if ( KBookmarkSettings::self()->m_filteredtoolbar )
124  {
125  if ( !dptr()->m_filteredMgr ) {
126  dptr()->m_filteredMgr = KBookmarkManager::createTempManager();
127  } else {
128  KBookmarkGroup bkRoot = dptr()->m_filteredMgr->root();
129  TQValueList<KBookmark> bks;
130  for (KBookmark bm = bkRoot.first(); !bm.isNull(); bm = bkRoot.next(bm))
131  bks << bm;
132  for ( TQValueListConstIterator<KBookmark> it = bks.begin(); it != bks.end(); ++it )
133  bkRoot.deleteBookmark( (*it) );
134  }
135  ToolbarFilter filter;
136  KBookmarkDomBuilder builder( dptr()->m_filteredMgr->root(),
137  dptr()->m_filteredMgr );
138  builder.connectImporter( &filter );
139  filter.filter( m_pManager->root() );
140  }
141 
142  return CURRENT_TOOLBAR();
143 }
144 
145 KBookmarkBar::~KBookmarkBar()
146 {
147  //clear();
148  KBookmarkBarPrivate::delete_d(this);
149 }
150 
151 void KBookmarkBar::clear()
152 {
153  TQPtrListIterator<KAction> it( dptr()->m_actions );
154  m_toolBar->clear();
155  for (; it.current(); ++it ) {
156  (*it)->unplugAll();
157  }
158  dptr()->m_actions.clear();
159  m_lstSubMenus.clear();
160 }
161 
162 void KBookmarkBar::slotBookmarksChanged( const TQString & group )
163 {
164  KBookmarkGroup tb = getToolbar(); // heavy for non cached toolbar version
165  kdDebug(7043) << "slotBookmarksChanged( " << group << " )" << endl;
166 
167  if ( tb.isNull() )
168  return;
169 
170  if ( KBookmark::commonParent(group, tb.address()) == group // Is group a parent of tb.address?
171  || KBookmarkSettings::self()->m_filteredtoolbar )
172  {
173  clear();
174  fillBookmarkBar( tb );
175  }
176  else
177  {
178  // Iterate recursively into child menus
179  TQPtrListIterator<KBookmarkMenu> it( m_lstSubMenus );
180  for (; it.current(); ++it )
181  {
182  it.current()->slotBookmarksChanged( group );
183  }
184  }
185 }
186 
187 void KBookmarkBar::fillBookmarkBar(KBookmarkGroup & parent)
188 {
189  if (parent.isNull())
190  return;
191 
192  for (KBookmark bm = parent.first(); !bm.isNull(); bm = parent.next(bm))
193  {
194  TQString text = bm.text();
195  text.replace( '&', "&&" );
196  if (!bm.isGroup())
197  {
198  if ( bm.isSeparator() )
199  m_toolBar->insertLineSeparator();
200  else
201  {
202  KAction *action = new KBookmarkAction( text, bm.icon(), 0, m_actionCollection, 0 );
203  connect(action, TQT_SIGNAL( activated ( KAction::ActivationReason, TQt::ButtonState )),
204  this, TQT_SLOT( slotBookmarkSelected( KAction::ActivationReason, TQt::ButtonState ) ));
205 
206  action->setProperty( "url", bm.url().url() );
207  action->setProperty( "address", bm.address() );
208 
209  action->setToolTip( bm.url().pathOrURL() );
210 
211  action->plug(m_toolBar);
212 
213  dptr()->m_actions.append( action );
214  }
215  }
216  else
217  {
218  KActionMenu *action = new KBookmarkActionMenu( text, bm.icon(),
219  m_actionCollection,
220  "bookmarkbar-actionmenu");
221  action->setProperty( "address", bm.address() );
222  action->setProperty( "readOnly", dptr()->m_readOnly );
223  action->setDelayed( false );
224 
225  // this flag doesn't have any UI yet
226  KGlobal::config()->setGroup( "Settings" );
227  bool addEntriesBookmarkBar = KGlobal::config()->readBoolEntry("AddEntriesBookmarkBar",true);
228 
229  KBookmarkMenu *menu = new KBookmarkMenu(CURRENT_MANAGER(), m_pOwner, action->popupMenu(),
230  m_actionCollection, false, addEntriesBookmarkBar,
231  bm.address());
232  connect(menu, TQT_SIGNAL( aboutToShowContextMenu(const KBookmark &, TQPopupMenu * ) ),
233  this, TQT_SIGNAL( aboutToShowContextMenu(const KBookmark &, TQPopupMenu * ) ));
234  connect(menu, TQT_SIGNAL( openBookmark( const TQString &, TQt::ButtonState) ),
235  this, TQT_SIGNAL( openBookmark( const TQString &, TQt::ButtonState) ));
236  menu->fillBookmarkMenu();
237  action->plug(m_toolBar);
238  m_lstSubMenus.append( menu );
239 
240  dptr()->m_actions.append( action );
241  }
242  }
243 }
244 
245 void KBookmarkBar::setReadOnly(bool readOnly)
246 {
247  dptr()->m_readOnly = readOnly;
248 }
249 
250 bool KBookmarkBar::isReadOnly() const
251 {
252  return dptr()->m_readOnly;
253 }
254 
255 void KBookmarkBar::slotBookmarkSelected( KAction::ActivationReason /*reason*/, TQt::ButtonState state )
256 {
257  if (!m_pOwner) return; // this view doesn't handle bookmarks...
258 
259  const KAction* action = dynamic_cast<const KAction *>(sender());
260  if(action)
261  {
262  const TQString & url = sender()->property("url").toString();
263  m_pOwner->openBookmarkURL(url);
264  emit openBookmark( url, state );
265  }
266 }
267 
268 void KBookmarkBar::slotBookmarkSelected()
269 {
270  slotBookmarkSelected(KAction::ToolBarActivation, Qt::NoButton);
271 }
272 
273 static const int const_sepId = -9999; // FIXME this is ugly,
274  // surely there is another
275  // way of doing this...
276 
277 static void removeTempSep(KBookmarkBarPrivate* p)
278 {
279  if (p->m_sepToolBar) {
280  p->m_sepToolBar->removeItem(const_sepId);
281  p->m_sepToolBar = 0; // needed?
282  }
283 }
284 
285 static KAction* findPluggedAction(TQPtrList<KAction> actions, KToolBar *tb, int id)
286 {
287  TQPtrListIterator<KAction> it( actions );
288  for (; (*it); ++it )
289  if ((*it)->isPlugged(tb, id))
290  return (*it);
291  return 0;
292 }
293 
304 static TQString handleToolbarDragMoveEvent(
305  KBookmarkBarPrivate *p, KToolBar *tb, TQPoint pos, TQPtrList<KAction> actions,
306  bool &atFirst, KBookmarkManager *mgr
307 ) {
308  Q_UNUSED( mgr );
309  Q_ASSERT( actions.isEmpty() || (tb == dynamic_cast<KToolBar*>(actions.first()->container(0))) );
310  p->m_sepToolBar = tb;
311  p->m_sepToolBar->removeItemDelayed(const_sepId);
312 
313  int index = 0;
314  KToolBarButton* b;
315 
316  b = dynamic_cast<KToolBarButton*>(tb->childAt(pos));
317  KAction *a = 0;
318  TQString address;
319  atFirst = false;
320 
321  if (b)
322  {
323  index = tb->itemIndex(b->id());
324  TQRect r = b->geometry();
325  if (pos.x() < ((r.left() + r.right())/2))
326  {
327  // if in first half of button then
328  // we jump to previous index
329  if ( index == 0 )
330  atFirst = true;
331  else {
332  index--;
333  b = tb->getButton(tb->idAt(index));
334  }
335  }
336  }
337  else if (actions.isEmpty())
338  {
339  atFirst = true;
340  index = 0;
341  // we skip the action related stuff
342  // and do what it should have...
343  // FIXME - here we want to get the
344  // parent address of the bookmark
345  // bar itself and return that + "/0"
346  p->m_sepIndex = 0;
347  goto skipact;
348  }
349  else // (!b)
350  {
351  index = actions.count() - 1;
352  b = tb->getButton(tb->idAt(index));
353  // if !b and not past last button, we didn't find button
354  if (pos.x() <= b->geometry().left())
355  goto skipact; // TODO - rename
356  }
357 
358  if ( !b )
359  return TQString::null; // TODO Make it works for that case
360 
361  a = findPluggedAction(actions, tb, b->id());
362  Q_ASSERT(a);
363  address = a->property("address").toString();
364  p->m_sepIndex = index + (atFirst ? 0 : 1);
365 
366 #if 0
367  { // ugly workaround to fix the goto scoping problems...
368  KBookmark bk = mgr->findByAddress( address );
369  if (bk.isGroup()) // TODO - fix this ****!!!, manhatten distance should be used!!!
370  {
371  kdDebug() << "kbookmarkbar:: popping up " << bk.text() << endl;
372  KBookmarkActionMenu *menu = dynamic_cast<KBookmarkActionMenu*>(a);
373  Q_ASSERT(menu);
374  menu->popup(tb->mapToGlobal(b->geometry().center()));
375  }
376  }
377 #endif
378 
379 skipact:
380  tb->insertLineSeparator(p->m_sepIndex, const_sepId);
381  return address;
382 }
383 
384 // TODO - document!!!!
385 static KAction* handleToolbarMouseButton(TQPoint pos, TQPtrList<KAction> actions,
386  KBookmarkManager * /*mgr*/, TQPoint & pt)
387 {
388  KAction *act = actions.first();
389  if (!act) {
390  return 0;
391  }
392 
393  KToolBar *tb = dynamic_cast<KToolBar*>(act->container(0));
394  Q_ASSERT(tb);
395 
396  KToolBarButton *b;
397  b = dynamic_cast<KToolBarButton*>(tb->childAt(pos));
398  if (!b)
399  return 0;
400 
401  KAction *a = 0;
402  a = findPluggedAction(actions, tb, b->id());
403  Q_ASSERT(a);
404  pt = tb->mapToGlobal(pos);
405 
406  return a;
407 }
408 
409 // TODO *** drop improvements ***
410 // open submenus on drop interactions
411 
412 // TODO *** generic rmb improvements ***
413 // don't *ever* show the rmb on press, always relase, possible???
414 
415 class KBookmarkBarRMBAssoc : public dPtrTemplate<KBookmarkBar, RMB> { };
416 template<> TQPtrDict<RMB>* dPtrTemplate<KBookmarkBar, RMB>::d_ptr = 0;
417 
418 static RMB* rmbSelf(KBookmarkBar *m) { return KBookmarkBarRMBAssoc::d(m); }
419 
420 void RMB::begin_rmb_action(KBookmarkBar *self)
421 {
422  RMB *s = rmbSelf(self);
423  s->recv = self;
424  s->m_parentAddress = self->parentAddress();
425  s->s_highlightedAddress = self->dptr()->m_highlightedAddress; // rename in RMB
426  s->m_pManager = self->m_pManager;
427  s->m_pOwner = self->m_pOwner;
428  s->m_parentMenu = 0;
429 }
430 
431 void KBookmarkBar::slotRMBActionEditAt( int val )
432 { RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionEditAt( val ); }
433 
434 void KBookmarkBar::slotRMBActionProperties( int val )
435 { RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionProperties( val ); }
436 
437 void KBookmarkBar::slotRMBActionInsert( int val )
438 { RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionInsert( val ); }
439 
440 void KBookmarkBar::slotRMBActionRemove( int val )
441 { RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionRemove( val ); }
442 
443 void KBookmarkBar::slotRMBActionCopyLocation( int val )
444 { RMB::begin_rmb_action(this); rmbSelf(this)->slotRMBActionCopyLocation( val ); }
445 
446 bool KBookmarkBar::eventFilter( TQObject *o, TQEvent *e )
447 {
448  if (dptr()->m_readOnly || dptr()->m_filteredMgr) // note, we assume m_pManager in various places,
449  // this shouldn't really be the case
450  return false; // todo: make this limit the actions
451 
452  if ( (e->type() == TQEvent::MouseButtonRelease) || (e->type() == TQEvent::MouseButtonPress) ) // FIXME, which one?
453  {
454  TQMouseEvent *mev = (TQMouseEvent*)e;
455 
456  TQPoint pt;
457  KAction *_a;
458 
459  // FIXME, see how this holds up on an empty toolbar
460  _a = handleToolbarMouseButton( mev->pos(), dptr()->m_actions, m_pManager, pt );
461  if (_a && mev->button() == Qt::RightButton)
462  {
463  dptr()->m_highlightedAddress = _a->property("address").toString();
464  KBookmark bookmark = m_pManager->findByAddress( dptr()->m_highlightedAddress );
465  RMB::begin_rmb_action(this);
466  KPopupMenu *pm = new KPopupMenu;
467  rmbSelf(this)->fillContextMenu( pm, dptr()->m_highlightedAddress, 0 );
468  emit aboutToShowContextMenu( rmbSelf(this)->atAddress( dptr()->m_highlightedAddress ), pm );
469  rmbSelf(this)->fillContextMenu2( pm, dptr()->m_highlightedAddress, 0 );
470  pm->popup( pt );
471  mev->accept();
472  }
473 
474  return !!_a; // ignore the event if we didn't find the button
475  }
476  else if ( e->type() == TQEvent::DragLeave )
477  {
478  removeTempSep(dptr());
479  dptr()->m_dropAddress = TQString::null;
480  }
481  else if ( e->type() == TQEvent::Drop )
482  {
483  removeTempSep(dptr());
484  TQDropEvent *dev = (TQDropEvent*)e;
485  if ( !KBookmarkDrag::canDecode( dev ) )
486  return false;
487  TQValueList<KBookmark> list = KBookmarkDrag::decode( dev );
488  if (list.count() > 1)
489  kdWarning(7043) << "Sorry, currently you can only drop one address "
490  "onto the bookmark bar!" << endl;
491  KBookmark toInsert = list.first();
492  KBookmark bookmark = m_pManager->findByAddress( dptr()->m_dropAddress );
493  Q_ASSERT(!bookmark.isNull());
494  kdDebug(7043) << "inserting "
495  << TQString(dptr()->m_atFirst ? "before" : "after")
496  << " dptr()->m_dropAddress == " << dptr()->m_dropAddress << endl;
497  KBookmarkGroup parentBookmark = bookmark.parentGroup();
498  Q_ASSERT(!parentBookmark.isNull());
499  KBookmark newBookmark = parentBookmark.addBookmark(
500  m_pManager, toInsert.fullText(),
501  toInsert.url() );
502  parentBookmark.moveItem( newBookmark, dptr()->m_atFirst ? KBookmark() : bookmark );
503  m_pManager->emitChanged( parentBookmark );
504  return true;
505  }
506  else if ( e->type() == TQEvent::DragMove )
507  {
508  TQDragMoveEvent *dme = (TQDragMoveEvent*)e;
509  if (!KBookmarkDrag::canDecode( dme ))
510  return false;
511  bool _atFirst;
512  TQString dropAddress;
513  KToolBar *tb = (KToolBar*)o;
514  dropAddress = handleToolbarDragMoveEvent(dptr(), tb, dme->pos(), dptr()->m_actions, _atFirst, m_pManager);
515  if (!dropAddress.isNull())
516  {
517  dptr()->m_dropAddress = dropAddress;
518  dptr()->m_atFirst = _atFirst;
519  dme->accept();
520  }
521  }
522  return false;
523 }
524 
525 static bool showInToolbar( const KBookmark &bk ) {
526  return (bk.internalElement().attributes().namedItem("showintoolbar").toAttr().value() == "yes");
527 }
528 
529 void ToolbarFilter::visit( const KBookmark &bk ) {
530  //kdDebug() << "visit(" << bk.text() << ")" << endl;
531  if ( m_visible || showInToolbar(bk) )
532  KXBELBookmarkImporterImpl::visit(bk);
533 }
534 
535 void ToolbarFilter::visitEnter( const KBookmarkGroup &grp ) {
536  //kdDebug() << "visitEnter(" << grp.text() << ")" << endl;
537  if ( !m_visible && showInToolbar(grp) )
538  {
539  m_visibleStart = grp;
540  m_visible = true;
541  }
542  if ( m_visible )
543  KXBELBookmarkImporterImpl::visitEnter(grp);
544 }
545 
546 void ToolbarFilter::visitLeave( const KBookmarkGroup &grp ) {
547  //kdDebug() << "visitLeave()" << endl;
548  if ( m_visible )
549  KXBELBookmarkImporterImpl::visitLeave(grp);
550  if ( m_visible && grp.address() == m_visibleStart.address() )
551  m_visible = false;
552 }
553 
554 #include "kbookmarkbar.moc"
KBookmarkBar
This class provides a bookmark toolbar.
Definition: kbookmarkbar.h:43
KBookmarkBar::parentAddress
TQString parentAddress()
Definition: kbookmarkbar.cc:108
KBookmarkBar::setReadOnly
void setReadOnly(bool)
Definition: kbookmarkbar.cc:245
KBookmarkBar::slotRMBActionProperties
void slotRMBActionProperties(int)
Definition: kbookmarkbar.cc:434
KBookmarkBar::aboutToShowContextMenu
void aboutToShowContextMenu(const KBookmark &, TQPopupMenu *)
KBookmarkBar::KBookmarkBar
KBookmarkBar(KBookmarkManager *manager, KBookmarkOwner *owner, KToolBar *toolBar, KActionCollection *, TQObject *parent=0L, const char *name=0L)
Fills a bookmark toolbar.
Definition: kbookmarkbar.cc:87
KBookmarkBar::openBookmark
void openBookmark(const TQString &url, TQt::ButtonState state)
KBookmarkBar::slotRMBActionInsert
void slotRMBActionInsert(int)
Definition: kbookmarkbar.cc:437
KBookmarkBar::isReadOnly
bool isReadOnly() const
Definition: kbookmarkbar.cc:250
KBookmarkBar::slotRMBActionEditAt
void slotRMBActionEditAt(int)
Definition: kbookmarkbar.cc:431
KBookmarkBar::slotRMBActionRemove
void slotRMBActionRemove(int)
Definition: kbookmarkbar.cc:440
KBookmarkBar::slotRMBActionCopyLocation
void slotRMBActionCopyLocation(int)
Definition: kbookmarkbar.cc:443
KBookmarkDomBuilder
Definition: kbookmarkdombuilder.h:30
KBookmarkGroup
A group of bookmarks.
Definition: kbookmark.h:200
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
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
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
KBookmarkManager
This class implements the reading/writing of bookmarks in XML.
Definition: kbookmarkmanager.h:54
KBookmarkManager::emitChanged
void emitChanged(KBookmarkGroup &group)
Saves the bookmark file and notifies everyone.
Definition: kbookmarkmanager.cc:541
KBookmarkManager::findByAddress
KBookmark findByAddress(const TQString &address, bool tolerate=false)
Definition: kbookmarkmanager.cc:431
KBookmarkManager::toolbar
KBookmarkGroup toolbar()
This returns the root of the toolbar menu.
Definition: kbookmarkmanager.cc:390
KBookmarkManager::root
KBookmarkGroup root() const
This will return the root bookmark.
Definition: kbookmarkmanager.cc:385
KBookmarkMenu
This class provides a bookmark menu.
Definition: kbookmarkmenu.h:80
KBookmarkMenu::fillBookmarkMenu
void fillBookmarkMenu()
Even if you think you need to use this, you are probably wrong.
Definition: kbookmarkmenu.cc:556
KBookmarkOwner
The KBookmarkMenu and KBookmarkBar classes gives the user the ability to either edit bookmarks or add...
Definition: kbookmarkmanager.h:318
KBookmarkOwner::openBookmarkURL
virtual void openBookmarkURL(const TQString &_url)
This function is called if the user selects a bookmark.
Definition: kbookmarkmanager.cc:643
KXBELBookmarkImporterImpl
A class for importing XBEL files.
Definition: kbookmarkimporter.h:88

kio/bookmarks

Skip menu "kio/bookmarks"
  • Main Page
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Class Members
  • Related Pages

kio/bookmarks

Skip menu "kio/bookmarks"
  • arts
  • dcop
  • dnssd
  • interfaces
  •     interface
  •     library
  •   kspeech
  •   ktexteditor
  • kabc
  • kate
  • kcmshell
  • kdecore
  • kded
  • kdefx
  • kdeprint
  • kdesu
  • kdeui
  • kdoctools
  • khtml
  • kimgio
  • kinit
  • kio
  •   bookmarks
  •   httpfilter
  •   kfile
  •   kio
  •   kioexec
  •   kpasswdserver
  •   kssl
  • kioslave
  •   http
  • kjs
  • kmdi
  •   kmdi
  • knewstuff
  • kparts
  • krandr
  • kresources
  • kspell2
  • kunittest
  • kutils
  • kwallet
  • libkmid
  • libkscreensaver
Generated for kio/bookmarks by doxygen 1.9.1
This website is maintained by Timothy Pearson.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. |