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

KIO

  • kio
  • bookmarks
kbookmark.cc
Go to the documentation of this file.
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 libraries
4 Copyright (C) 2000 David Faure <faure@kde.org>
5 Copyright (C) 2003 Alexander Kellett <lypanov@kde.org>
6 Copyright (C) 2008 Norbert Frese <nf2@scheinwelt.at>
7
8 This library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Library General Public
10 License version 2 as published by the Free Software Foundation.
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
23#include "kbookmark.h"
24#include <QStack>
25#include <kdebug.h>
26#include <kmimetype.h>
27#include <kstringhandler.h>
28#include <kglobal.h>
29#include <klocale.h>
30#include <assert.h>
31#include <kbookmarkmanager.h>
32
33#include <qdatetime.h>
34#include <qmimedata.h>
35
36#define METADATA_KDE_OWNER "http://www.kde.org"
37#define METADATA_FREEDESKTOP_OWNER "http://freedesktop.org"
38#define METADATA_MIME_OWNER "http://www.freedesktop.org/standards/shared-mime-info"
39
41
42static QDomNode cd(QDomNode node, const QString &name, bool create)
43{
44 QDomNode subnode = node.namedItem(name);
45 if (create && subnode.isNull())
46 {
47 subnode = node.ownerDocument().createElement(name);
48 node.appendChild(subnode);
49 }
50 return subnode;
51}
52
53static QDomNode cd_or_create(QDomNode node, const QString &name)
54{
55 return cd(node, name, true);
56}
57
58static QDomText get_or_create_text(QDomNode node)
59{
60 QDomNode subnode = node.firstChild();
61 if (subnode.isNull())
62 {
63 subnode = node.ownerDocument().createTextNode("");
64 node.appendChild(subnode);
65 }
66 return subnode.toText();
67}
68
69static QDomNode findMetadata(const QString & forOwner, QDomNode& parent, bool create)
70{
71 bool forOwnerIsKDE = forOwner == METADATA_KDE_OWNER;
72
73 QDomElement metadataElement;
74 for ( QDomNode _node = parent.firstChild(); !_node.isNull(); _node = _node.nextSibling() ) {
75 QDomElement elem = _node.toElement();
76 if ( !elem.isNull() && elem.tagName() == "metadata" ) {
77 const QString owner = elem.attribute( "owner" );
78 if ( owner == forOwner )
79 return elem;
80 if ( owner.isEmpty() && forOwnerIsKDE )
81 metadataElement = elem;
82 }
83 }
84 if ( create && metadataElement.isNull() ) {
85 metadataElement = parent.ownerDocument().createElement( "metadata" );
86 parent.appendChild(metadataElement);
87 metadataElement.setAttribute( "owner", forOwner );
88
89 } else if (!metadataElement.isNull() && forOwnerIsKDE) {
90 // i'm not sure if this is good, we shouln't take over foreign metatdata
91 metadataElement.setAttribute( "owner", METADATA_KDE_OWNER );
92 }
93 return metadataElement;
94}
95
97
98KBookmarkGroup::KBookmarkGroup()
99 : KBookmark( QDomElement() )
100{
101}
102
103KBookmarkGroup::KBookmarkGroup( const QDomElement &elem )
104 : KBookmark(elem)
105{
106}
107
108bool KBookmarkGroup::isOpen() const
109{
110 return element.attribute("folded") == "no"; // default is: folded
111}
112
113KBookmark KBookmarkGroup::first() const
114{
115 return KBookmark( nextKnownTag( element.firstChildElement(), true ) );
116}
117
118KBookmark KBookmarkGroup::previous( const KBookmark & current ) const
119{
120 return KBookmark( nextKnownTag( current.element.previousSiblingElement(), false ) );
121}
122
123KBookmark KBookmarkGroup::next( const KBookmark & current ) const
124{
125 return KBookmark( nextKnownTag( current.element.nextSiblingElement(), true ) );
126}
127
128int KBookmarkGroup::indexOf(const KBookmark& child) const
129{
130 uint counter = 0;
131 for ( KBookmark bk = first(); !bk.isNull(); bk = next(bk), ++counter ) {
132 if ( bk.element == child.element )
133 return counter;
134 }
135 return -1;
136}
137
138QDomElement KBookmarkGroup::nextKnownTag( const QDomElement &start, bool goNext ) const
139{
140 static const QString & bookmark = KGlobal::staticQString("bookmark");
141 static const QString & folder = KGlobal::staticQString("folder");
142 static const QString & separator = KGlobal::staticQString("separator");
143
144 for( QDomElement elem = start; !elem.isNull(); )
145 {
146 QString tag = elem.tagName();
147 if (tag == folder || tag == bookmark || tag == separator)
148 return elem;
149 if (goNext)
150 elem = elem.nextSiblingElement();
151 else
152 elem = elem.previousSiblingElement();
153 }
154 return QDomElement();
155}
156
157KBookmarkGroup KBookmarkGroup::createNewFolder( const QString & text )
158{
159 if (isNull())
160 return KBookmarkGroup();
161 QDomDocument doc = element.ownerDocument();
162 QDomElement groupElem = doc.createElement( "folder" );
163 element.appendChild( groupElem );
164 QDomElement textElem = doc.createElement( "title" );
165 groupElem.appendChild( textElem );
166 textElem.appendChild( doc.createTextNode( text ) );
167 return KBookmarkGroup(groupElem);
168
169}
170
171KBookmark KBookmarkGroup::createNewSeparator()
172{
173 if (isNull())
174 return KBookmark();
175 QDomDocument doc = element.ownerDocument();
176 Q_ASSERT(!doc.isNull());
177 QDomElement sepElem = doc.createElement( "separator" );
178 element.appendChild( sepElem );
179 return KBookmark(sepElem);
180}
181
182#ifndef KDE_NO_DEPRECATED
183bool KBookmarkGroup::moveItem( const KBookmark & bookmark, const KBookmark & after )
184{
185 return moveBookmark(bookmark, after);
186}
187#endif
188
189bool KBookmarkGroup::moveBookmark( const KBookmark & item, const KBookmark & after )
190{
191 QDomNode n;
192 if ( !after.isNull() )
193 n = element.insertAfter( item.element, after.element );
194 else // first child
195 {
196 if ( element.firstChild().isNull() ) // Empty element -> set as real first child
197 n = element.insertBefore( item.element, QDomElement() );
198
199 // we have to skip everything up to the first valid child
200 QDomElement firstChild = nextKnownTag(element.firstChild().toElement(), true);
201 if ( !firstChild.isNull() )
202 n = element.insertBefore( item.element, firstChild );
203 else
204 {
205 // No real first child -> append after the <title> etc.
206 n = element.appendChild( item.element );
207 }
208 }
209 return (!n.isNull());
210}
211
212KBookmark KBookmarkGroup::addBookmark( const KBookmark &bm )
213{
214 element.appendChild( bm.internalElement() );
215 return bm;
216}
217
218KBookmark KBookmarkGroup::addBookmark( const QString & text, const KUrl & url, const QString & icon )
219{
220 if (isNull())
221 return KBookmark();
222 QDomDocument doc = element.ownerDocument();
223 QDomElement elem = doc.createElement( "bookmark" );
224 elem.setAttribute( "href", url.url() ); // gives us utf8
225
226 QDomElement textElem = doc.createElement( "title" );
227 elem.appendChild( textElem );
228 textElem.appendChild( doc.createTextNode( text ) );
229
230 KBookmark newBookmark = addBookmark( KBookmark( elem ) );
231
232 // as icons are moved to metadata, we have to use the KBookmark API for this
233 newBookmark.setIcon(icon.isEmpty() ? KMimeType::iconNameForUrl( url ) : icon );
234 return newBookmark;
235}
236
237void KBookmarkGroup::deleteBookmark( const KBookmark &bk )
238{
239 element.removeChild( bk.element );
240}
241
242bool KBookmarkGroup::isToolbarGroup() const
243{
244 return ( element.attribute("toolbar") == "yes" );
245}
246
247QDomElement KBookmarkGroup::findToolbar() const
248{
249 if ( element.attribute("toolbar") == "yes" )
250 return element;
251 for (QDomElement e = element.firstChildElement("folder"); !e.isNull();
252 e = e.nextSiblingElement("folder") )
253 {
254 QDomElement result = KBookmarkGroup(e).findToolbar();
255 if (!result.isNull())
256 return result;
257 }
258 return QDomElement();
259}
260
261QList<KUrl> KBookmarkGroup::groupUrlList() const
262{
263 QList<KUrl> urlList;
264 for ( KBookmark bm = first(); !bm.isNull(); bm = next(bm) )
265 {
266 if ( bm.isSeparator() || bm.isGroup() )
267 continue;
268 urlList << bm.url();
269 }
270 return urlList;
271}
272
274
275KBookmark::KBookmark()
276{
277}
278
279KBookmark::KBookmark( const QDomElement &elem ) : element(elem)
280{
281}
282
283bool KBookmark::isGroup() const
284{
285 QString tag = element.tagName();
286 return ( tag == "folder"
287 || tag == "xbel" ); // don't forget the toplevel group
288}
289
290bool KBookmark::isSeparator() const
291{
292 return (element.tagName() == "separator");
293}
294
295bool KBookmark::isNull() const
296{
297 return element.isNull();
298}
299
300bool KBookmark::hasParent() const
301{
302 QDomElement parent = element.parentNode().toElement();
303 return !parent.isNull();
304}
305
306QString KBookmark::text() const
307{
308 return KStringHandler::csqueeze( fullText() );
309}
310
311QString KBookmark::fullText() const
312{
313 if (isSeparator())
314 return i18n("--- separator ---");
315
316 QString text = element.namedItem("title").toElement().text();
317 text.replace('\n', ' '); // #140673
318 return text;
319}
320
321void KBookmark::setFullText(const QString &fullText)
322{
323 QDomNode titleNode = element.namedItem("title");
324 if (titleNode.isNull()) {
325 titleNode = element.ownerDocument().createElement("title");
326 element.appendChild(titleNode);
327 }
328
329 if (titleNode.firstChild().isNull()) {
330 QDomText domtext = titleNode.ownerDocument().createTextNode("");
331 titleNode.appendChild(domtext);
332 }
333
334 QDomText domtext = titleNode.firstChild().toText();
335 domtext.setData(fullText);
336}
337
338KUrl KBookmark::url() const
339{
340 return KUrl(element.attribute("href").toLatin1()); // Decodes it from utf8
341}
342
343void KBookmark::setUrl(const KUrl &url)
344{
345 element.setAttribute("href", url.url());
346}
347
348QString KBookmark::icon() const
349{
350 QDomNode metaDataNode = metaData(METADATA_FREEDESKTOP_OWNER, false);
351 QDomElement iconElement = cd(metaDataNode, "bookmark:icon", false).toElement();
352
353 QString icon = iconElement.attribute("name");
354
355 // migration code
356 if (icon.isEmpty())
357 icon = element.attribute("icon");
358 if (icon == "www") // common icon for kde3 bookmarks
359 return "internet-web-browser";
360 // end migration code
361
362 if (icon == "bookmark_folder") {
363 return "folder-bookmarks";
364 }
365 if (icon.isEmpty()) {
366 // Default icon depends on URL for bookmarks, and is default directory
367 // icon for groups.
368 if (isGroup()) {
369 icon = "folder-bookmarks";
370 }
371 else {
372 if (isSeparator()) {
373 icon = "edit-clear"; // whatever
374 } else {
375 // get icon from mimeType
376 QString _mimeType = mimeType();
377 if (!_mimeType.isEmpty()) {
378 KMimeType::Ptr mime = KMimeType::mimeType(_mimeType, KMimeType::ResolveAliases);
379 if (mime) {
380 return mime->iconName();
381 }
382 }
383 // get icon from URL
384 icon = KMimeType::iconNameForUrl(url());
385 }
386 }
387 }
388 return icon;
389}
390
391void KBookmark::setIcon(const QString &icon)
392{
393 QDomNode metaDataNode = metaData(METADATA_FREEDESKTOP_OWNER, true);
394 QDomElement iconElement = cd_or_create(metaDataNode, "bookmark:icon").toElement();
395 iconElement.setAttribute ( "name", icon );
396
397 // migration code
398 if(!element.attribute("icon").isEmpty())
399 element.removeAttribute("icon");
400}
401
402QString KBookmark::description() const
403{
404 if (isSeparator())
405 return QString();
406
407 QString description = element.namedItem("desc").toElement().text();
408 description.replace('\n', ' '); // #140673
409 return description;
410}
411
412void KBookmark::setDescription(const QString &description)
413{
414 QDomNode descNode = element.namedItem("desc");
415 if (descNode.isNull()) {
416 descNode = element.ownerDocument().createElement("desc");
417 element.appendChild(descNode);
418 }
419
420 if (descNode.firstChild().isNull()) {
421 QDomText domtext = descNode.ownerDocument().createTextNode(QString());
422 descNode.appendChild(domtext);
423 }
424
425 QDomText domtext = descNode.firstChild().toText();
426 domtext.setData(description);
427}
428
429QString KBookmark::mimeType() const
430{
431 QDomNode metaDataNode = metaData(METADATA_MIME_OWNER, false);
432 QDomElement mimeTypeElement = cd(metaDataNode, "mime:mime-type", false).toElement();
433 return mimeTypeElement.attribute("type");
434}
435
436void KBookmark::setMimeType(const QString &mimeType)
437{
438 QDomNode metaDataNode = metaData(METADATA_MIME_OWNER, true);
439 QDomElement iconElement = cd_or_create(metaDataNode, "mime:mime-type").toElement();
440 iconElement.setAttribute ( "type", mimeType );
441}
442
443bool KBookmark::showInToolbar() const
444{
445 if(element.hasAttribute("showintoolbar"))
446 {
447 bool show = element.attribute("showintoolbar") == "yes";
448 const_cast<QDomElement *>(&element)->removeAttribute("showintoolbar");
449 const_cast<KBookmark *>(this)->setShowInToolbar(show);
450 }
451 return metaDataItem("showintoolbar") == "yes";
452}
453
454
455void KBookmark::setShowInToolbar(bool show)
456{
457 setMetaDataItem("showintoolbar", show ? "yes" : "no");
458}
459
460KBookmarkGroup KBookmark::parentGroup() const
461{
462 return KBookmarkGroup( element.parentNode().toElement() );
463}
464
465KBookmarkGroup KBookmark::toGroup() const
466{
467 Q_ASSERT( isGroup() );
468 return KBookmarkGroup(element);
469}
470
471QString KBookmark::address() const
472{
473 if ( element.tagName() == "xbel" )
474 return ""; // not QString() !
475 else
476 {
477 // Use keditbookmarks's DEBUG_ADDRESSES flag to debug this code :)
478 if (element.parentNode().isNull())
479 {
480 Q_ASSERT(false);
481 return "ERROR"; // Avoid an infinite loop
482 }
483 KBookmarkGroup group = parentGroup();
484 QString parentAddress = group.address();
485 int pos = group.indexOf(*this);
486 Q_ASSERT(pos != -1);
487 return parentAddress + '/' + QString::number(pos);
488 }
489}
490
491int KBookmark::positionInParent() const
492{
493 return parentGroup().indexOf(*this);
494}
495
496QDomElement KBookmark::internalElement() const
497{
498 return element;
499}
500
501KBookmark KBookmark::standaloneBookmark( const QString & text, const KUrl & url, const QString & icon )
502{
503 QDomDocument doc("xbel");
504 QDomElement elem = doc.createElement("xbel");
505 doc.appendChild( elem );
506 KBookmarkGroup grp( elem );
507 grp.addBookmark( text, url, icon );
508 return grp.first();
509}
510
511
512QString KBookmark::commonParent(const QString &first, const QString &second)
513{
514 QString A = first;
515 QString B = second;
516 QString error("ERROR");
517 if(A == error || B == error)
518 return error;
519
520 A += '/';
521 B += '/';
522
523 uint lastCommonSlash = 0;
524 uint lastPos = A.length() < B.length() ? A.length() : B.length();
525 for(uint i=0; i < lastPos; ++i)
526 {
527 if(A[i] != B[i])
528 return A.left(lastCommonSlash);
529 if(A[i] == '/')
530 lastCommonSlash = i;
531 }
532 return A.left(lastCommonSlash);
533}
534
535void KBookmark::updateAccessMetadata()
536{
537 kDebug(7043) << "KBookmark::updateAccessMetadata " << address() << " " << url().prettyUrl();
538
539 const uint timet = QDateTime::currentDateTime().toTime_t();
540 setMetaDataItem( "time_added", QString::number( timet ), DontOverwriteMetaData );
541 setMetaDataItem( "time_visited", QString::number( timet ) );
542
543 QString countStr = metaDataItem( "visit_count" ); // TODO use spec'ed name
544 bool ok;
545 int currentCount = countStr.toInt(&ok);
546 if (!ok)
547 currentCount = 0;
548 currentCount++;
549 setMetaDataItem( "visit_count", QString::number( currentCount ) );
550
551 // TODO - for 4.0 - time_modified
552}
553
554QString KBookmark::parentAddress( const QString & address )
555{
556 return address.left( address.lastIndexOf(QLatin1Char('/')) );
557}
558
559uint KBookmark::positionInParent( const QString & address )
560{
561 return address.mid( address.lastIndexOf(QLatin1Char('/')) + 1 ).toInt();
562}
563
564QString KBookmark::previousAddress( const QString & address )
565{
566 uint pp = positionInParent(address);
567 return pp>0
568 ? parentAddress(address) + QLatin1Char('/') + QString::number(pp-1)
569 : QString();
570}
571
572QString KBookmark::nextAddress( const QString & address )
573{
574 return parentAddress(address) + QLatin1Char('/') +
575 QString::number(positionInParent(address)+1);
576}
577
578QDomNode KBookmark::metaData(const QString &owner, bool create) const
579{
580 QDomNode infoNode = cd( internalElement(), "info", create);
581 if (infoNode.isNull()) return QDomNode();
582 return findMetadata(owner, infoNode , create);
583}
584
585QString KBookmark::metaDataItem( const QString &key ) const
586{
587 QDomNode metaDataNode = metaData(METADATA_KDE_OWNER, false);
588 for ( QDomElement e = metaDataNode.firstChildElement(); !e.isNull(); e = e.nextSiblingElement() )
589 {
590 if ( e.tagName() == key ) {
591 return e.text();
592 }
593 }
594 return QString();
595}
596
597void KBookmark::setMetaDataItem( const QString &key, const QString &value, MetaDataOverwriteMode mode )
598{
599 QDomNode metaDataNode = metaData(METADATA_KDE_OWNER, true);
600 QDomNode item = cd_or_create( metaDataNode, key );
601 QDomText text = get_or_create_text( item );
602 if ( mode == DontOverwriteMetaData && !text.data().isEmpty() ) {
603 return;
604 }
605
606 text.setData( value );
607}
608
609
610bool KBookmark::operator==(const KBookmark& rhs) const
611{
612 return element == rhs.element;
613}
614
616
617KBookmarkGroupTraverser::~KBookmarkGroupTraverser()
618{
619}
620
621void KBookmarkGroupTraverser::traverse(const KBookmarkGroup &root)
622{
623 QStack<KBookmarkGroup> stack;
624 stack.push(root);
625 KBookmark bk = root.first();
626 for(;;) {
627 if(bk.isNull()) {
628 if(stack.count() == 1) // only root is on the stack
629 return;
630 if(stack.count() > 0) {
631 visitLeave(stack.top());
632 bk = stack.pop();
633 }
634 bk = stack.top().next(bk);
635 } else if(bk.isGroup()) {
636 KBookmarkGroup gp = bk.toGroup();
637 visitEnter(gp);
638 bk = gp.first();
639 stack.push(gp);
640 } else {
641 visit(bk);
642 bk = stack.top().next(bk);
643 }
644 }
645}
646
647void KBookmarkGroupTraverser::visit(const KBookmark &)
648{
649}
650
651void KBookmarkGroupTraverser::visitEnter(const KBookmarkGroup &)
652{
653}
654
655void KBookmarkGroupTraverser::visitLeave(const KBookmarkGroup &)
656{
657}
658
659void KBookmark::populateMimeData( QMimeData* mimeData ) const
660{
661 KBookmark::List bookmarkList;
662 bookmarkList.append( *this );
663 bookmarkList.populateMimeData( mimeData );
664}
665
666KBookmark::List::List() : QList<KBookmark>()
667{
668}
669
670void KBookmark::List::populateMimeData( QMimeData* mimeData ) const
671{
672 KUrl::List urls;
673
674 QDomDocument doc( "xbel" );
675 QDomElement elem = doc.createElement( "xbel" );
676 doc.appendChild( elem );
677
678 for ( const_iterator it = begin(), end = this->end() ; it != end ; ++it ) {
679 urls.append( (*it).url() );
680 elem.appendChild( (*it).internalElement().cloneNode( true /* deep */ ) );
681 }
682
683 // This sets text/uri-list and text/plain into the mimedata
684 urls.populateMimeData( mimeData, KUrl::MetaDataMap() );
685
686 mimeData->setData( "application/x-xbel", doc.toByteArray() );
687}
688
689bool KBookmark::List::canDecode( const QMimeData *mimeData )
690{
691 return mimeData->hasFormat( "application/x-xbel" ) || KUrl::List::canDecode(mimeData);
692}
693
694QStringList KBookmark::List::mimeDataTypes()
695{
696 return QStringList()<<("application/x-xbel")<<KUrl::List::mimeDataTypes();
697}
698
699#ifndef KDE_NO_DEPRECATED
700KBookmark::List KBookmark::List::fromMimeData( const QMimeData *mimeData )
701{
702 QDomDocument doc;
703 kWarning(7043) << "Deprecated method called, with wrong lifetime of QDomDocument, will probably crash";
704 return fromMimeData(mimeData, doc);
705}
706#endif
707
708KBookmark::List KBookmark::List::fromMimeData( const QMimeData *mimeData, QDomDocument& doc )
709{
710 KBookmark::List bookmarks;
711 QByteArray payload = mimeData->data( "application/x-xbel" );
712 if ( !payload.isEmpty() ) {
713 doc.setContent( payload );
714 QDomElement elem = doc.documentElement();
715 const QDomNodeList children = elem.childNodes();
716 for ( int childno = 0; childno < children.count(); childno++)
717 {
718 bookmarks.append( KBookmark( children.item(childno).toElement() ));
719 }
720 return bookmarks;
721 }
722 const KUrl::List urls = KUrl::List::fromMimeData( mimeData );
723 if ( !urls.isEmpty() )
724 {
725 KUrl::List::ConstIterator uit = urls.begin();
726 KUrl::List::ConstIterator uEnd = urls.end();
727 for ( ; uit != uEnd ; ++uit )
728 {
729 //kDebug(7043) << "url=" << (*uit);
730 bookmarks.append( KBookmark::standaloneBookmark(
731 (*uit).prettyUrl(), (*uit) ));
732 }
733 }
734 return bookmarks;
735}
736
KBookmarkGroupTraverser::visitLeave
virtual void visitLeave(const KBookmarkGroup &)
Definition: kbookmark.cc:655
KBookmarkGroupTraverser::visit
virtual void visit(const KBookmark &)
Definition: kbookmark.cc:647
KBookmarkGroupTraverser::visitEnter
virtual void visitEnter(const KBookmarkGroup &)
Definition: kbookmark.cc:651
KBookmarkGroupTraverser::traverse
void traverse(const KBookmarkGroup &)
Definition: kbookmark.cc:621
KBookmarkGroupTraverser::~KBookmarkGroupTraverser
virtual ~KBookmarkGroupTraverser()
Definition: kbookmark.cc:617
KBookmarkGroup
A group of bookmarks.
Definition: kbookmark.h:348
KBookmarkGroup::isToolbarGroup
bool isToolbarGroup() const
Definition: kbookmark.cc:242
KBookmarkGroup::next
KBookmark next(const KBookmark &current) const
Return the next sibling of a child bookmark of this group.
Definition: kbookmark.cc:123
KBookmarkGroup::groupUrlList
QList< KUrl > groupUrlList() const
Definition: kbookmark.cc:261
KBookmarkGroup::first
KBookmark first() const
Return the first child bookmark of this group.
Definition: kbookmark.cc:113
KBookmarkGroup::isOpen
bool isOpen() const
Definition: kbookmark.cc:108
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::KBookmarkGroup
KBookmarkGroup()
Create an invalid group.
Definition: kbookmark.cc:98
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::createNewSeparator
KBookmark createNewSeparator()
Create a new bookmark separator Don't forget to use KBookmarkManager::self()->emitChanged( parentBook...
Definition: kbookmark.cc:171
KBookmarkGroup::moveItem
bool moveItem(const KBookmark &item, const KBookmark &after)
Definition: kbookmark.cc:183
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
KBookmarkGroup::indexOf
int indexOf(const KBookmark &child) const
Return the index of a child bookmark, -1 if not found.
Definition: kbookmark.cc:128
KBookmarkGroup::findToolbar
QDomElement findToolbar() const
Definition: kbookmark.cc:247
KBookmarkGroup::nextKnownTag
QDomElement nextKnownTag(const QDomElement &start, bool goNext) const
Definition: kbookmark.cc:138
KBookmarkGroup::createNewFolder
KBookmarkGroup createNewFolder(const QString &text)
Create a new bookmark folder, as the last child of this group.
Definition: kbookmark.cc:157
KBookmark::List
KUrl::Bookmark is a QList that contains bookmarks with a few convenience methods.
Definition: kbookmark.h:49
KBookmark::List::canDecode
static bool canDecode(const QMimeData *mimeData)
Return true if mimeData contains bookmarks.
Definition: kbookmark.cc:689
KBookmark::List::List
List()
Definition: kbookmark.cc:666
KBookmark::List::fromMimeData
static KBookmark::List fromMimeData(const QMimeData *mimeData)
Extract a list of bookmarks from the contents of mimeData.
Definition: kbookmark.cc:700
KBookmark::List::mimeDataTypes
static QStringList mimeDataTypes()
Return the list of mimeTypes that can be decoded by fromMimeData.
Definition: kbookmark.cc:694
KBookmark::List::populateMimeData
void populateMimeData(QMimeData *mimeData) const
Adds this list of bookmark into the given QMimeData.
Definition: kbookmark.cc:670
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::MetaDataOverwriteMode
MetaDataOverwriteMode
Definition: kbookmark.h:38
KBookmark::DontOverwriteMetaData
@ DontOverwriteMetaData
Definition: kbookmark.h:39
KBookmark::nextAddress
static QString nextAddress(const QString &address)
Definition: kbookmark.cc:572
KBookmark::parentGroup
KBookmarkGroup parentGroup() const
Definition: kbookmark.cc:460
KBookmark::icon
QString icon() const
Definition: kbookmark.cc:348
KBookmark::setMetaDataItem
void setMetaDataItem(const QString &key, const QString &value, MetaDataOverwriteMode mode=OverwriteMetaData)
Change the value of a specific metadata item, or create the given item if it doesn't exist already (o...
Definition: kbookmark.cc:597
KBookmark::updateAccessMetadata
void updateAccessMetadata()
Updates the bookmarks access metadata Call when a user accesses the bookmark.
Definition: kbookmark.cc:535
KBookmark::KBookmark
KBookmark()
Constructs a null bookmark, i.e.
Definition: kbookmark.cc:275
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::showInToolbar
bool showInToolbar() const
Definition: kbookmark.cc:443
KBookmark::metaData
QDomNode metaData(const QString &owner, bool create) const
Definition: kbookmark.cc:578
KBookmark::isGroup
bool isGroup() const
Whether the bookmark is a group or a normal bookmark.
Definition: kbookmark.cc:283
KBookmark::fullText
QString fullText() const
Text shown for the bookmark, not truncated.
Definition: kbookmark.cc:311
KBookmark::hasParent
bool hasParent() const
Definition: kbookmark.cc:300
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::positionInParent
int positionInParent() const
Return the position in the parent, i.e.
Definition: kbookmark.cc:491
KBookmark::commonParent
static QString commonParent(const QString &A, const QString &B)
Definition: kbookmark.cc:512
KBookmark::setDescription
void setDescription(const QString &description)
Set the description of the bookmark.
Definition: kbookmark.cc:412
KBookmark::mimeType
QString mimeType() const
Definition: kbookmark.cc:429
KBookmark::previousAddress
static QString previousAddress(const QString &address)
Definition: kbookmark.cc:564
KBookmark::setMimeType
void setMimeType(const QString &mimeType)
Set the Mime-Type of this item.
Definition: kbookmark.cc:436
KBookmark::setUrl
void setUrl(const KUrl &url)
Set the URL of the bookmark.
Definition: kbookmark.cc:343
KBookmark::parentAddress
static QString parentAddress(const QString &address)
Definition: kbookmark.cc:554
KBookmark::internalElement
QDomElement internalElement() const
Definition: kbookmark.cc:496
KBookmark::element
QDomElement element
Definition: kbookmark.h:332
KBookmark::url
KUrl url() const
URL contained by the bookmark.
Definition: kbookmark.cc:338
KBookmark::setFullText
void setFullText(const QString &fullText)
Set the text shown for the bookmark.
Definition: kbookmark.cc:321
KBookmark::address
QString address() const
Return the "address" of this bookmark in the whole tree.
Definition: kbookmark.cc:471
KBookmark::operator==
bool operator==(const KBookmark &rhs) const
Comparison operator.
Definition: kbookmark.cc:610
KBookmark::setIcon
void setIcon(const QString &icon)
Set the icon name of the bookmark.
Definition: kbookmark.cc:391
KBookmark::setShowInToolbar
void setShowInToolbar(bool show)
Set whether this bookmark is show in a filterd toolbar.
Definition: kbookmark.cc:455
KBookmark::populateMimeData
void populateMimeData(QMimeData *mimeData) const
Adds this bookmark into the given QMimeData.
Definition: kbookmark.cc:659
KBookmark::metaDataItem
QString metaDataItem(const QString &key) const
Get the value of a specific metadata item (owner = "http://www.kde.org").
Definition: kbookmark.cc:585
KMimeType::ResolveAliases
ResolveAliases
KMimeType::iconNameForUrl
static QString iconNameForUrl(const KUrl &url, mode_t mode=0)
KMimeType::mimeType
static Ptr mimeType(const QString &name, FindByNameOption options=ResolveAliases)
KSharedPtr< KMimeType >
KUrl::List
KUrl::List::mimeDataTypes
static QStringList mimeDataTypes()
KUrl::List::canDecode
static bool canDecode(const QMimeData *mimeData)
KUrl::List::populateMimeData
void populateMimeData(const KUrl::List &mostLocalUrls, QMimeData *mimeData, const KUrl::MetaDataMap &metaData=MetaDataMap(), MimeDataFlags flags=DefaultMimeDataFlags) const
KUrl::List::fromMimeData
static KUrl::List fromMimeData(const QMimeData *mimeData, DecodeOptions decodeOptions, KUrl::MetaDataMap *metaData=0)
KUrl
KUrl::prettyUrl
QString prettyUrl(AdjustPathOption trailing=LeaveTrailingSlash) const
KUrl::url
QString url(AdjustPathOption trailing=LeaveTrailingSlash) const
QList
QMap< QString, QString >
kDebug
#define kDebug
kWarning
#define kWarning
METADATA_FREEDESKTOP_OWNER
#define METADATA_FREEDESKTOP_OWNER
Definition: kbookmark.cc:37
get_or_create_text
static QDomText get_or_create_text(QDomNode node)
Definition: kbookmark.cc:58
METADATA_KDE_OWNER
#define METADATA_KDE_OWNER
Definition: kbookmark.cc:36
findMetadata
static QDomNode findMetadata(const QString &forOwner, QDomNode &parent, bool create)
Definition: kbookmark.cc:69
cd
static QDomNode cd(QDomNode node, const QString &name, bool create)
Definition: kbookmark.cc:42
cd_or_create
static QDomNode cd_or_create(QDomNode node, const QString &name)
Definition: kbookmark.cc:53
METADATA_MIME_OWNER
#define METADATA_MIME_OWNER
Definition: kbookmark.cc:38
kbookmark.h
kbookmarkmanager.h
kdebug.h
kglobal.h
klocale.h
i18n
QString i18n(const char *text)
kmimetype.h
kstringhandler.h
fromMimeData
QColor fromMimeData(const QMimeData *mimeData)
KGlobal::staticQString
const QString & staticQString(const char *str)
group
group
name
const char * name(StandardAction id)
create
KAction * create(StandardAction id, const QObject *recvr, const char *slot, QObject *parent)
ok
KGuiItem ok()
begin
const KShortcut & begin()
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