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

tdeio/bookmarks

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

tdeio/bookmarks

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

tdeio/bookmarks

Skip menu "tdeio/bookmarks"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdeio/bookmarks by doxygen 1.9.1
This website is maintained by Timothy Pearson.