KBookmarks

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

KDE's Doxygen guidelines are available online.