2011-03-03 18:29:20 +01:00
|
|
|
/* ============================================================
|
|
|
|
* QupZilla - WebKit based browser
|
2014-01-11 16:11:42 +01:00
|
|
|
* Copyright (C) 2010-2014 David Rosca <nowrep@gmail.com>
|
2011-03-03 18:29:20 +01:00
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
* ============================================================ */
|
2014-02-05 15:26:51 +01:00
|
|
|
#include "bookmarks.h"
|
2014-02-06 17:07:19 +01:00
|
|
|
#include "bookmarkitem.h"
|
2014-02-07 22:48:30 +01:00
|
|
|
#include "bookmarksmodel.h"
|
2012-01-21 20:27:45 +01:00
|
|
|
#include "tabbedwebview.h"
|
2011-07-30 17:57:14 +02:00
|
|
|
#include "iconprovider.h"
|
2012-02-29 18:33:50 +01:00
|
|
|
#include "mainapplication.h"
|
|
|
|
#include "settings.h"
|
2014-02-06 17:07:19 +01:00
|
|
|
#include "json.h"
|
2012-02-29 18:33:50 +01:00
|
|
|
|
2014-02-06 17:07:19 +01:00
|
|
|
#include <QSqlQuery>
|
2013-12-30 00:35:01 +01:00
|
|
|
#include <QTextStream>
|
2012-02-29 18:33:50 +01:00
|
|
|
#include <QBuffer>
|
2013-12-30 00:35:01 +01:00
|
|
|
#include <QDebug>
|
|
|
|
#include <QFile>
|
2011-03-02 16:57:41 +01:00
|
|
|
|
|
|
|
// SQLite DB -> table bookmarks + folders
|
|
|
|
// Unique in bookmarks table is id
|
|
|
|
// However from bookmark icon, it is not possible to add more than one bookmark
|
|
|
|
// Only from Ctrl+D dialog it is possible
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
Bookmarks::Bookmarks(QObject* parent)
|
2011-04-15 20:45:22 +02:00
|
|
|
: QObject(parent)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2014-02-06 17:07:19 +01:00
|
|
|
loadBookmarks();
|
2011-03-02 16:57:41 +01:00
|
|
|
loadSettings();
|
|
|
|
}
|
|
|
|
|
2014-02-06 17:07:19 +01:00
|
|
|
void Bookmarks::loadBookmarks()
|
|
|
|
{
|
|
|
|
m_root = new BookmarkItem(BookmarkItem::Root);
|
|
|
|
|
|
|
|
m_folderToolbar = new BookmarkItem(BookmarkItem::Folder, m_root);
|
2014-02-07 22:48:30 +01:00
|
|
|
m_folderToolbar->setTitle(tr("Bookmarks Toolbar"));
|
2014-02-06 17:07:19 +01:00
|
|
|
m_folderToolbar->setDescription(tr("Bookmarks located in Bookmarks Toolbar"));
|
|
|
|
|
|
|
|
m_folderMenu = new BookmarkItem(BookmarkItem::Folder, m_root);
|
2014-02-07 22:48:30 +01:00
|
|
|
m_folderMenu->setTitle(tr("Bookmarks Menu"));
|
2014-02-06 17:07:19 +01:00
|
|
|
m_folderMenu->setDescription(tr("Bookmarks located in Bookmarks Menu"));
|
|
|
|
|
|
|
|
m_folderUnsorted = new BookmarkItem(BookmarkItem::Folder, m_root);
|
|
|
|
m_folderUnsorted->setTitle(tr("Unsorted Bookmarks"));
|
|
|
|
m_folderUnsorted->setDescription(tr("All other bookmarks"));
|
|
|
|
|
|
|
|
// TODO: Make sure bookmarks are loaded correctly even on error
|
|
|
|
|
|
|
|
QFile bFile(mApp->currentProfilePath() + QLatin1String("/bookmarks.json"));
|
|
|
|
bFile.open(QFile::ReadOnly);
|
|
|
|
QByteArray data = bFile.readAll();
|
|
|
|
bFile.close();
|
|
|
|
|
|
|
|
bool ok;
|
|
|
|
const QVariant res = Json::parse(data, &ok);
|
|
|
|
|
|
|
|
if (!ok || res.type() != QVariant::Map) {
|
|
|
|
qWarning() << "Bookmarks::loadBookmarks() Error parsing bookmarks!";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QVariantMap map = res.toMap();
|
|
|
|
const QVariantMap bookmarksMap = map.value("roots").toMap();
|
|
|
|
|
|
|
|
readBookmarks(bookmarksMap.value("bookmark_bar").toMap().value("children").toList(), m_folderToolbar);
|
|
|
|
readBookmarks(bookmarksMap.value("bookmark_menu").toMap().value("children").toList(), m_folderMenu);
|
|
|
|
readBookmarks(bookmarksMap.value("other").toMap().value("children").toList(), m_folderUnsorted);
|
2014-02-07 22:48:30 +01:00
|
|
|
|
|
|
|
m_model = new BookmarksModel(this, this);
|
2014-02-06 17:07:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Bookmarks::saveBookmarks()
|
|
|
|
{
|
|
|
|
QVariantMap toolbarMap;
|
|
|
|
toolbarMap.insert("children", writeBookmarks(m_folderToolbar));
|
|
|
|
|
|
|
|
QVariantMap menuMap;
|
|
|
|
menuMap.insert("children", writeBookmarks(m_folderMenu));
|
|
|
|
|
|
|
|
QVariantMap unsortedMap;
|
|
|
|
unsortedMap.insert("children", writeBookmarks(m_folderUnsorted));
|
|
|
|
|
|
|
|
QVariantMap bookmarksMap;
|
|
|
|
bookmarksMap.insert("bookmark_bar", toolbarMap);
|
|
|
|
bookmarksMap.insert("bookmark_menu", menuMap);
|
|
|
|
bookmarksMap.insert("other", unsortedMap);
|
|
|
|
|
|
|
|
QVariantMap map;
|
|
|
|
map.insert("version", Qz::bookmarksVersion);
|
|
|
|
map.insert("roots", bookmarksMap);
|
|
|
|
|
|
|
|
bool ok;
|
|
|
|
const QByteArray data = Json::serialize(map, &ok);
|
|
|
|
|
|
|
|
if (!ok || data.isEmpty()) {
|
|
|
|
qWarning() << "Bookmarks::saveBookmarks() Error serializing bookmarks!";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
QFile bFile(mApp->currentProfilePath() + QLatin1String("/bookmarks.json"));
|
|
|
|
|
|
|
|
if (!bFile.open(QFile::WriteOnly)) {
|
|
|
|
qWarning() << "Bookmarks::saveBookmarks() Error opening bookmarks file for writing!";
|
|
|
|
}
|
|
|
|
|
|
|
|
bFile.write(data);
|
|
|
|
bFile.close();
|
|
|
|
}
|
|
|
|
|
2014-02-07 22:48:30 +01:00
|
|
|
void Bookmarks::readBookmarks(const QVariantList &list, BookmarkItem* parent)
|
2014-02-06 17:07:19 +01:00
|
|
|
{
|
|
|
|
if (!parent) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (const QVariant &entry, list) {
|
|
|
|
const QVariantMap map = entry.toMap();
|
|
|
|
BookmarkItem::Type type = BookmarkItem::typeFromString(map.value("type").toString());
|
|
|
|
|
|
|
|
if (type == BookmarkItem::Invalid) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
BookmarkItem* item = new BookmarkItem(type, parent);
|
|
|
|
item->setUrl(map.value("url").toUrl());
|
|
|
|
item->setTitle(map.value("name").toString());
|
|
|
|
item->setDescription(map.value("description").toString());
|
|
|
|
item->setKeyword(map.value("keyword").toString());
|
|
|
|
item->setExpanded(map.value("expanded").toBool());
|
|
|
|
|
|
|
|
if (map.contains("children")) {
|
|
|
|
readBookmarks(map.value("children").toList(), item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-07 22:48:30 +01:00
|
|
|
QVariantList Bookmarks::writeBookmarks(BookmarkItem* parent)
|
2014-02-06 17:07:19 +01:00
|
|
|
{
|
|
|
|
QVariantList list;
|
|
|
|
|
|
|
|
if (!parent) {
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (BookmarkItem* child, parent->children()) {
|
|
|
|
QVariantMap map;
|
|
|
|
map.insert("type", BookmarkItem::typeToString(child->type()));
|
|
|
|
map.insert("url", child->url());
|
|
|
|
map.insert("name", child->title());
|
|
|
|
map.insert("description", child->description());
|
|
|
|
map.insert("keyword", child->keyword());
|
|
|
|
map.insert("expanded", child->isExpanded());
|
|
|
|
|
|
|
|
if (!child->children().isEmpty()) {
|
|
|
|
map.insert("children", writeBookmarks(child));
|
|
|
|
}
|
|
|
|
|
|
|
|
list.append(map);
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2014-02-07 22:48:30 +01:00
|
|
|
void Bookmarks::writeChildren(BookmarkItem* parent)
|
2014-02-06 17:07:19 +01:00
|
|
|
{
|
|
|
|
if (!parent) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (BookmarkItem* child, parent->children()) {
|
2014-02-08 18:28:01 +01:00
|
|
|
if (child->isUrl()) {
|
2014-02-06 17:07:19 +01:00
|
|
|
qDebug() << child->title() << child->url();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
qDebug() << "folder" << child->title();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::loadSettings()
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2012-01-11 21:58:25 +01:00
|
|
|
Settings settings;
|
2012-02-04 22:47:55 +01:00
|
|
|
settings.beginGroup("Bookmarks");
|
2011-11-06 17:01:23 +01:00
|
|
|
m_showMostVisited = settings.value("showMostVisited", true).toBool();
|
2012-02-17 19:54:58 +01:00
|
|
|
m_showOnlyIconsInToolbar = settings.value("showOnlyIconsInToolbar", false).toBool();
|
2012-02-04 22:47:55 +01:00
|
|
|
m_lastFolder = settings.value("LastFolder", "unsorted").toString();
|
2011-03-02 16:57:41 +01:00
|
|
|
settings.endGroup();
|
|
|
|
}
|
|
|
|
|
2014-02-05 16:44:19 +01:00
|
|
|
bool Bookmarks::isShowingMostVisited() const
|
|
|
|
{
|
|
|
|
return m_showMostVisited;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::setShowingMostVisited(bool state)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2012-01-11 21:58:25 +01:00
|
|
|
Settings settings;
|
2012-02-04 22:47:55 +01:00
|
|
|
settings.beginGroup("Bookmarks");
|
2011-11-06 17:01:23 +01:00
|
|
|
settings.setValue("showMostVisited", state);
|
2011-03-02 16:57:41 +01:00
|
|
|
settings.endGroup();
|
|
|
|
m_showMostVisited = state;
|
|
|
|
}
|
|
|
|
|
2014-02-05 16:44:19 +01:00
|
|
|
bool Bookmarks::isShowingOnlyIconsInToolbar() const
|
|
|
|
{
|
|
|
|
return m_showOnlyIconsInToolbar;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::setShowingOnlyIconsInToolbar(bool state)
|
2012-02-17 19:54:58 +01:00
|
|
|
{
|
|
|
|
Settings settings;
|
|
|
|
settings.beginGroup("Bookmarks");
|
|
|
|
settings.setValue("showOnlyIconsInToolbar", state);
|
|
|
|
settings.endGroup();
|
|
|
|
m_showOnlyIconsInToolbar = state;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::isFolder(const QString &name)
|
2012-03-06 15:28:52 +01:00
|
|
|
{
|
2012-09-04 12:42:45 +02:00
|
|
|
if (name == QLatin1String("bookmarksToolbar") || name == QLatin1String("bookmarksMenu")
|
2013-01-09 15:30:30 +01:00
|
|
|
|| name == QLatin1String("unsorted") || name == _bookmarksToolbar
|
|
|
|
|| name == _bookmarksMenu || name == _bookmarksUnsorted) {
|
2012-06-06 10:16:11 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-03-06 15:28:52 +01:00
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT name FROM folders WHERE name = ?");
|
|
|
|
query.bindValue(0, name);
|
|
|
|
query.exec();
|
|
|
|
|
|
|
|
return query.next();
|
|
|
|
}
|
|
|
|
|
2014-02-05 16:44:19 +01:00
|
|
|
QString Bookmarks::lastFolder() const
|
|
|
|
{
|
|
|
|
return m_lastFolder;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::setLastFolder(const QString &folder)
|
2012-02-04 22:47:55 +01:00
|
|
|
{
|
|
|
|
Settings settings;
|
|
|
|
settings.beginGroup("Bookmarks");
|
|
|
|
settings.setValue("lastFolder", folder);
|
|
|
|
settings.endGroup();
|
|
|
|
m_lastFolder = folder;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::isBookmarked(const QUrl &url)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT count(id) FROM bookmarks WHERE url=?");
|
|
|
|
query.bindValue(0, url.toString());
|
2014-02-01 19:21:49 +01:00
|
|
|
|
2014-02-03 00:10:14 +01:00
|
|
|
if (!query.exec() || !query.next()) {
|
2014-02-01 19:21:49 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-11-06 17:01:23 +01:00
|
|
|
return query.value(0).toInt() > 0;
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Bookmark search priority:
|
|
|
|
// Bookmarks in menu > bookmarks in toolbar -> user folders and unsorted
|
2014-02-05 16:44:19 +01:00
|
|
|
Bookmarks::Bookmark Bookmarks::getBookmark(const QUrl &url)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT id FROM bookmarks WHERE url=? AND folder='bookmarksMenu' ");
|
|
|
|
query.bindValue(0, url.toString());
|
|
|
|
query.exec();
|
2014-02-05 16:44:19 +01:00
|
|
|
|
2011-11-06 17:01:23 +01:00
|
|
|
if (query.next()) {
|
2014-02-05 16:44:19 +01:00
|
|
|
return getBookmark(query.value(0).toInt());
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-03-02 16:57:41 +01:00
|
|
|
|
|
|
|
query.prepare("SELECT id FROM bookmarks WHERE url=? AND folder='bookmarksToolbar' ");
|
|
|
|
query.bindValue(0, url.toString());
|
|
|
|
query.exec();
|
2014-02-05 16:44:19 +01:00
|
|
|
|
2011-11-06 17:01:23 +01:00
|
|
|
if (query.next()) {
|
2014-02-05 16:44:19 +01:00
|
|
|
return getBookmark(query.value(0).toInt());
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-03-02 16:57:41 +01:00
|
|
|
|
|
|
|
query.prepare("SELECT id FROM bookmarks WHERE url=? ");
|
|
|
|
query.bindValue(0, url.toString());
|
|
|
|
query.exec();
|
|
|
|
|
2011-11-06 17:01:23 +01:00
|
|
|
if (query.next()) {
|
2014-02-05 16:44:19 +01:00
|
|
|
return getBookmark(query.value(0).toInt());
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2014-02-05 16:44:19 +01:00
|
|
|
|
|
|
|
return Bookmark();
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
Bookmarks::Bookmark Bookmarks::getBookmark(int id)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2011-04-15 20:45:22 +02:00
|
|
|
Bookmark bookmark;
|
2011-03-02 16:57:41 +01:00
|
|
|
QSqlQuery query;
|
2011-07-30 17:57:14 +02:00
|
|
|
query.prepare("SELECT url, title, folder, icon FROM bookmarks WHERE id=?");
|
2011-03-02 16:57:41 +01:00
|
|
|
query.bindValue(0, id);
|
|
|
|
query.exec();
|
2011-04-15 20:45:22 +02:00
|
|
|
if (query.next()) {
|
|
|
|
bookmark.id = id;
|
|
|
|
bookmark.url = query.value(0).toUrl();
|
|
|
|
bookmark.title = query.value(1).toString();
|
|
|
|
bookmark.folder = query.value(2).toString();
|
2012-01-17 19:27:24 +01:00
|
|
|
bookmark.image = QImage::fromData(query.value(3).toByteArray());
|
2011-10-28 17:52:42 +02:00
|
|
|
bookmark.inSubfolder = isSubfolder(bookmark.folder);
|
2011-04-15 20:45:22 +02:00
|
|
|
}
|
|
|
|
return bookmark;
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::saveBookmark(const QUrl &url, const QString &title, const QIcon &icon, const QString &folder)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2011-11-06 17:01:23 +01:00
|
|
|
if (url.isEmpty() || title.isEmpty() || folder.isEmpty()) {
|
2011-03-02 16:57:41 +01:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-03-02 16:57:41 +01:00
|
|
|
|
2012-01-17 19:27:24 +01:00
|
|
|
QImage image = icon.pixmap(16, 16).toImage();
|
2012-01-28 12:02:37 +01:00
|
|
|
if (image.isNull()) {
|
2012-04-22 20:51:28 +02:00
|
|
|
image = qIconProvider->emptyWebImage();
|
2012-01-28 12:02:37 +01:00
|
|
|
}
|
2012-01-17 19:27:24 +01:00
|
|
|
|
2013-04-16 23:10:05 +02:00
|
|
|
// createFolder() calls isFolder()
|
|
|
|
createFolder(folder);
|
2012-03-06 15:28:52 +01:00
|
|
|
|
2011-03-02 16:57:41 +01:00
|
|
|
QSqlQuery query;
|
2011-07-30 17:57:14 +02:00
|
|
|
query.prepare("INSERT INTO bookmarks (url, title, folder, icon) VALUES (?,?,?,?)");
|
2011-03-02 16:57:41 +01:00
|
|
|
query.bindValue(0, url.toString());
|
|
|
|
query.bindValue(1, title);
|
|
|
|
query.bindValue(2, folder);
|
2012-01-17 19:27:24 +01:00
|
|
|
QByteArray ba;
|
|
|
|
QBuffer buffer(&ba);
|
|
|
|
buffer.open(QIODevice::WriteOnly);
|
|
|
|
image.save(&buffer, "PNG");
|
|
|
|
query.bindValue(3, buffer.data());
|
2011-12-17 14:30:54 +01:00
|
|
|
query.exec();
|
2011-04-15 20:45:22 +02:00
|
|
|
|
|
|
|
Bookmark bookmark;
|
|
|
|
bookmark.id = query.lastInsertId().toInt();
|
|
|
|
bookmark.url = url;
|
|
|
|
bookmark.title = title;
|
|
|
|
bookmark.folder = folder;
|
2012-01-17 19:27:24 +01:00
|
|
|
bookmark.image = image;
|
2011-10-28 17:52:42 +02:00
|
|
|
bookmark.inSubfolder = isSubfolder(bookmark.folder);
|
|
|
|
|
2012-02-04 22:47:55 +01:00
|
|
|
setLastFolder(folder);
|
|
|
|
|
2011-04-15 20:45:22 +02:00
|
|
|
emit bookmarkAdded(bookmark);
|
2012-01-21 23:19:38 +01:00
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
2011-04-15 20:45:22 +02:00
|
|
|
return true;
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::saveBookmark(WebView* view, QString folder)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2012-02-04 22:47:55 +01:00
|
|
|
if (folder.isEmpty()) {
|
|
|
|
folder = m_lastFolder;
|
|
|
|
}
|
|
|
|
|
2012-01-21 20:27:45 +01:00
|
|
|
return saveBookmark(view->url(), view->title(), view->icon(), folder);
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::removeBookmark(int id)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2012-04-05 10:27:35 +02:00
|
|
|
QList<int> list;
|
|
|
|
list.append(id);
|
2011-04-15 20:45:22 +02:00
|
|
|
|
2012-04-05 10:27:35 +02:00
|
|
|
return removeBookmark(list);
|
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::removeBookmark(const QList<int> list)
|
2012-04-05 10:27:35 +02:00
|
|
|
{
|
|
|
|
QSqlDatabase db = QSqlDatabase::database();
|
|
|
|
db.transaction();
|
|
|
|
|
2013-03-06 09:05:41 +01:00
|
|
|
foreach (int id, list) {
|
2012-04-05 10:27:35 +02:00
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT url, title, folder FROM bookmarks WHERE id = ?");
|
|
|
|
query.bindValue(0, id);
|
|
|
|
query.exec();
|
|
|
|
if (!query.next()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bookmark bookmark;
|
|
|
|
bookmark.id = id;
|
|
|
|
bookmark.url = query.value(0).toUrl();
|
|
|
|
bookmark.title = query.value(1).toString();
|
|
|
|
bookmark.folder = query.value(2).toString();
|
|
|
|
bookmark.image = QImage::fromData(query.value(3).toByteArray());
|
|
|
|
bookmark.inSubfolder = isSubfolder(bookmark.folder);
|
|
|
|
|
2012-08-23 15:37:43 +02:00
|
|
|
query.prepare("DELETE FROM bookmarks WHERE id=?");
|
|
|
|
query.addBindValue(id);
|
|
|
|
query.exec();
|
|
|
|
|
|
|
|
if (!query.exec()) {
|
2012-04-05 10:27:35 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
emit bookmarkDeleted(bookmark);
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
|
2012-04-05 10:27:35 +02:00
|
|
|
db.commit();
|
2012-01-21 23:19:38 +01:00
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::editBookmark(int id, const QString &title, const QUrl &url, const QString &folder)
|
2011-04-15 20:45:22 +02:00
|
|
|
{
|
2011-11-06 17:01:23 +01:00
|
|
|
if (title.isEmpty() && url.isEmpty() && folder.isEmpty()) {
|
2011-04-15 20:45:22 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2012-05-22 11:46:22 +02:00
|
|
|
|
2011-04-15 20:45:22 +02:00
|
|
|
QSqlQuery query;
|
2012-08-23 15:37:43 +02:00
|
|
|
query.prepare("SELECT title, url, folder, icon FROM bookmarks WHERE id=?");
|
|
|
|
query.addBindValue(id);
|
|
|
|
query.exec();
|
|
|
|
|
2012-05-22 11:46:22 +02:00
|
|
|
if (!query.next()) {
|
2011-04-15 20:45:22 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
|
|
|
|
Bookmark before;
|
|
|
|
before.id = id;
|
|
|
|
before.title = query.value(0).toString();
|
|
|
|
before.url = query.value(1).toUrl();
|
|
|
|
before.folder = query.value(2).toString();
|
2012-01-17 19:27:24 +01:00
|
|
|
before.image = QImage::fromData(query.value(3).toByteArray());
|
2011-10-28 17:52:42 +02:00
|
|
|
before.inSubfolder = isSubfolder(before.folder);
|
2011-04-15 20:45:22 +02:00
|
|
|
|
|
|
|
Bookmark after;
|
|
|
|
after.id = id;
|
|
|
|
after.title = title.isEmpty() ? before.title : title;
|
|
|
|
after.url = url.isEmpty() ? before.url : url;
|
|
|
|
after.folder = folder.isEmpty() ? before.folder : folder;
|
2012-01-17 19:27:24 +01:00
|
|
|
after.image = before.image;
|
2011-10-28 17:52:42 +02:00
|
|
|
after.inSubfolder = isSubfolder(after.folder);
|
2011-04-15 20:45:22 +02:00
|
|
|
|
|
|
|
query.prepare("UPDATE bookmarks SET title=?, url=?, folder=? WHERE id = ?");
|
|
|
|
query.bindValue(0, after.title);
|
|
|
|
query.bindValue(1, after.url.toString());
|
|
|
|
query.bindValue(2, after.folder);
|
|
|
|
query.bindValue(3, id);
|
|
|
|
|
2011-11-06 17:01:23 +01:00
|
|
|
if (!query.exec()) {
|
2011-04-15 20:45:22 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
|
|
|
|
emit bookmarkEdited(before, after);
|
2012-01-21 23:19:38 +01:00
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
2011-04-15 20:45:22 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::changeIcon(int id, const QIcon &icon)
|
2012-05-22 11:46:22 +02:00
|
|
|
{
|
|
|
|
QSqlQuery query;
|
2012-09-05 23:52:40 +02:00
|
|
|
query.prepare("SELECT title, url, folder, icon FROM bookmarks WHERE id=?");
|
2012-08-23 15:37:43 +02:00
|
|
|
query.addBindValue(id);
|
|
|
|
query.exec();
|
|
|
|
|
2012-05-22 11:46:22 +02:00
|
|
|
if (!query.next()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bookmark before;
|
|
|
|
before.id = id;
|
|
|
|
before.title = query.value(0).toString();
|
|
|
|
before.url = query.value(1).toUrl();
|
|
|
|
before.folder = query.value(2).toString();
|
|
|
|
before.image = QImage::fromData(query.value(3).toByteArray());
|
|
|
|
before.inSubfolder = isSubfolder(before.folder);
|
|
|
|
|
|
|
|
Bookmark after = before;
|
|
|
|
after.image = icon.pixmap(16).toImage();
|
|
|
|
|
|
|
|
query.prepare("UPDATE bookmarks SET icon = ? WHERE id = ?");
|
|
|
|
QByteArray ba;
|
|
|
|
QBuffer buffer(&ba);
|
|
|
|
buffer.open(QIODevice::WriteOnly);
|
|
|
|
after.image.save(&buffer, "PNG");
|
|
|
|
query.bindValue(0, buffer.data());
|
|
|
|
query.bindValue(1, id);
|
|
|
|
|
|
|
|
if (!query.exec()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
emit bookmarkEdited(before, after);
|
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::createFolder(const QString &name)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2012-03-06 15:28:52 +01:00
|
|
|
if (isFolder(name)) {
|
2011-10-22 22:29:33 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-10-22 22:29:33 +02:00
|
|
|
|
2012-03-06 15:28:52 +01:00
|
|
|
QSqlQuery query;
|
2011-10-28 23:17:38 +02:00
|
|
|
query.prepare("INSERT INTO folders (name, subfolder) VALUES (?, 'no')");
|
2011-04-15 20:45:22 +02:00
|
|
|
query.bindValue(0, name);
|
2011-11-06 17:01:23 +01:00
|
|
|
if (!query.exec()) {
|
2011-04-15 20:45:22 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
|
|
|
|
emit folderAdded(name);
|
2012-01-21 23:19:38 +01:00
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
2011-04-15 20:45:22 +02:00
|
|
|
return true;
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::removeFolder(const QString &name)
|
2011-03-02 16:57:41 +01:00
|
|
|
{
|
2011-12-17 14:30:54 +01:00
|
|
|
if (name == _bookmarksMenu || name == _bookmarksToolbar) {
|
2012-04-05 10:27:35 +02:00
|
|
|
return;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
|
2011-03-02 16:57:41 +01:00
|
|
|
QSqlQuery query;
|
2011-04-15 20:45:22 +02:00
|
|
|
query.prepare("SELECT id FROM bookmarks WHERE folder = ? ");
|
|
|
|
query.bindValue(0, name);
|
2011-11-06 17:01:23 +01:00
|
|
|
if (!query.exec()) {
|
2012-04-05 10:27:35 +02:00
|
|
|
return;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2012-04-05 10:27:35 +02:00
|
|
|
|
|
|
|
QList<int> list;
|
2011-11-06 17:01:23 +01:00
|
|
|
while (query.next()) {
|
2012-04-05 10:27:35 +02:00
|
|
|
list.append(query.value(0).toInt());
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2012-04-05 10:27:35 +02:00
|
|
|
removeBookmark(list);
|
2011-04-15 20:45:22 +02:00
|
|
|
|
|
|
|
query.prepare("DELETE FROM folders WHERE name=?");
|
|
|
|
query.bindValue(0, name);
|
2012-04-05 10:27:35 +02:00
|
|
|
query.exec();
|
2011-04-15 20:45:22 +02:00
|
|
|
|
2013-01-10 18:05:02 +01:00
|
|
|
if (name == m_lastFolder) {
|
|
|
|
setLastFolder("unsorted");
|
|
|
|
}
|
|
|
|
|
2011-04-15 20:45:22 +02:00
|
|
|
emit folderDeleted(name);
|
2012-04-05 10:27:35 +02:00
|
|
|
|
2012-01-21 23:19:38 +01:00
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
2011-04-15 20:45:22 +02:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::renameFolder(const QString &before, const QString &after)
|
2011-10-28 17:52:42 +02:00
|
|
|
{
|
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT name FROM folders WHERE name = ?");
|
|
|
|
query.bindValue(0, after);
|
|
|
|
query.exec();
|
2011-11-06 17:01:23 +01:00
|
|
|
if (query.next()) {
|
2011-10-28 17:52:42 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-10-28 17:52:42 +02:00
|
|
|
|
|
|
|
query.prepare("UPDATE folders SET name=? WHERE name=?");
|
|
|
|
query.bindValue(0, after);
|
|
|
|
query.bindValue(1, before);
|
2011-11-06 17:01:23 +01:00
|
|
|
if (!query.exec()) {
|
|
|
|
return false;
|
|
|
|
}
|
2011-10-28 17:52:42 +02:00
|
|
|
|
|
|
|
query.prepare("UPDATE bookmarks SET folder=? WHERE folder=?");
|
|
|
|
query.bindValue(0, after);
|
|
|
|
query.bindValue(1, before);
|
2011-11-06 17:01:23 +01:00
|
|
|
if (!query.exec()) {
|
|
|
|
return false;
|
|
|
|
}
|
2011-10-28 17:52:42 +02:00
|
|
|
|
|
|
|
emit folderRenamed(before, after);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::exportToHtml(const QString &fileName)
|
2013-12-30 00:35:01 +01:00
|
|
|
{
|
|
|
|
QFile file(fileName);
|
|
|
|
|
|
|
|
if (!file.open(QFile::WriteOnly | QFile::Truncate)) {
|
2014-02-05 15:26:51 +01:00
|
|
|
qWarning() << "Bookmarks::exportHtml Cannot open file for writing!" << file.errorString();
|
2013-12-30 00:35:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QTextStream out(&file);
|
|
|
|
|
|
|
|
out << "<!DOCTYPE NETSCAPE-Bookmark-file-1>" << endl;
|
|
|
|
out << "<!-- This is an automatically generated file." << endl;
|
|
|
|
out << " It will be read and overwritten." << endl;
|
|
|
|
out << " DO NOT EDIT! -->" << endl;
|
|
|
|
out << "<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=UTF-8\">" << endl;
|
|
|
|
out << "<TITLE>Bookmarks</TITLE>" << endl;
|
|
|
|
out << "<H1>Bookmarks</H1>" << endl;
|
|
|
|
|
|
|
|
out << "<DL><p>" << endl;
|
|
|
|
|
|
|
|
QString indent = " ";
|
|
|
|
QList<QPair<QString, bool> > allFolders;
|
|
|
|
|
|
|
|
QPair<QString, bool> menu;
|
|
|
|
menu.first = "bookmarksMenu";
|
|
|
|
menu.second = false;
|
|
|
|
|
|
|
|
QPair<QString, bool> toolbar;
|
|
|
|
toolbar.first = "bookmarksToolbar";
|
|
|
|
toolbar.second = false;
|
|
|
|
|
|
|
|
allFolders.append(menu);
|
|
|
|
allFolders.append(toolbar);
|
|
|
|
|
|
|
|
QSqlQuery query;
|
|
|
|
query.exec("SELECT name, subfolder FROM folders");
|
|
|
|
|
|
|
|
while (query.next()) {
|
|
|
|
QPair<QString, bool> pair;
|
|
|
|
pair.first = query.value(0).toString();
|
|
|
|
pair.second = query.value(1).toString() == QLatin1String("yes");
|
|
|
|
|
|
|
|
allFolders.append(pair);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < allFolders.size(); ++i) {
|
|
|
|
QPair<QString, bool> pair = allFolders.at(i);
|
|
|
|
|
|
|
|
out << indent << "<DT><H3 TOOLBAR_SUBFOLDER=\"" << (pair.second ? "yes" : "no") << "\">" << pair.first << "</H3>" << endl;
|
|
|
|
out << indent << "<DL><p>" << endl;
|
|
|
|
|
|
|
|
QSqlQuery q;
|
|
|
|
q.prepare("SELECT title, url FROM bookmarks WHERE folder = ?");
|
|
|
|
q.addBindValue(pair.first);
|
|
|
|
q.exec();
|
|
|
|
|
|
|
|
while (q.next()) {
|
|
|
|
QString title = q.value(0).toString();
|
|
|
|
QString url = q.value(1).toString();
|
|
|
|
|
|
|
|
out << indent << indent << "<DT><A HREF=\"" << url << "\">" << title << "</A>" << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
out << indent << "</DL><p>" << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
query.exec("SELECT title, url FROM bookmarks WHERE folder='' OR folder='unsorted'");
|
|
|
|
|
|
|
|
while (query.next()) {
|
|
|
|
QString title = query.value(0).toString();
|
|
|
|
QString url = query.value(1).toString();
|
|
|
|
|
|
|
|
out << indent << "<DT><A HREF=\"" << url << "\">" << title << "</A>" << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
out << "</DL><p>" << endl;
|
|
|
|
}
|
|
|
|
|
2014-02-05 16:44:19 +01:00
|
|
|
QVector<Bookmark> Bookmarks::getFolderBookmarks(const QString &name)
|
2011-12-19 21:30:26 +01:00
|
|
|
{
|
2013-02-26 12:56:11 +01:00
|
|
|
QVector<Bookmark> list;
|
2011-12-19 21:30:26 +01:00
|
|
|
|
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT id, url, title, folder, icon FROM bookmarks WHERE folder=?");
|
|
|
|
query.addBindValue(name);
|
|
|
|
query.exec();
|
|
|
|
while (query.next()) {
|
|
|
|
Bookmark bookmark;
|
|
|
|
bookmark.id = query.value(0).toInt();
|
|
|
|
bookmark.url = query.value(1).toUrl();
|
|
|
|
bookmark.title = query.value(2).toString();
|
|
|
|
bookmark.folder = query.value(3).toString();
|
2012-01-17 19:27:24 +01:00
|
|
|
bookmark.image = QImage::fromData(query.value(4).toByteArray());
|
2011-12-19 21:30:26 +01:00
|
|
|
bookmark.inSubfolder = isSubfolder(bookmark.folder);
|
|
|
|
|
|
|
|
list.append(bookmark);
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::createSubfolder(const QString &name)
|
2011-10-28 17:52:42 +02:00
|
|
|
{
|
2012-03-06 15:28:52 +01:00
|
|
|
if (isFolder(name)) {
|
2011-10-28 17:52:42 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-10-28 17:52:42 +02:00
|
|
|
|
2012-03-06 15:28:52 +01:00
|
|
|
QSqlQuery query;
|
2011-10-28 17:52:42 +02:00
|
|
|
query.prepare("INSERT INTO folders (name, subfolder) VALUES (?, 'yes')");
|
|
|
|
query.bindValue(0, name);
|
2011-11-06 17:01:23 +01:00
|
|
|
if (!query.exec()) {
|
2011-10-28 17:52:42 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-10-28 17:52:42 +02:00
|
|
|
|
|
|
|
emit subfolderAdded(name);
|
2012-01-21 23:19:38 +01:00
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
2011-10-28 17:52:42 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
bool Bookmarks::isSubfolder(const QString &name)
|
2011-10-28 17:52:42 +02:00
|
|
|
{
|
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT subfolder FROM folders WHERE name = ?");
|
|
|
|
query.bindValue(0, name);
|
|
|
|
query.exec();
|
2011-11-06 17:01:23 +01:00
|
|
|
if (!query.next()) {
|
2011-10-28 17:52:42 +02:00
|
|
|
return false;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-10-28 17:52:42 +02:00
|
|
|
|
2012-09-04 12:42:45 +02:00
|
|
|
return query.value(0).toString() == QLatin1String("yes");
|
2011-10-28 17:52:42 +02:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
QString Bookmarks::toTranslatedFolder(const QString &name)
|
2011-04-15 20:45:22 +02:00
|
|
|
{
|
|
|
|
QString trFolder;
|
2012-09-04 12:42:45 +02:00
|
|
|
if (name == QLatin1String("bookmarksMenu")) {
|
2011-04-15 20:45:22 +02:00
|
|
|
trFolder = tr("Bookmarks In Menu");
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2012-09-04 12:42:45 +02:00
|
|
|
else if (name == QLatin1String("bookmarksToolbar")) {
|
2011-04-15 20:45:22 +02:00
|
|
|
trFolder = tr("Bookmarks In ToolBar");
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2012-09-04 12:42:45 +02:00
|
|
|
else if (name == QLatin1String("unsorted")) {
|
2011-04-15 20:45:22 +02:00
|
|
|
trFolder = tr("Unsorted Bookmarks");
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
|
|
|
else {
|
2011-04-15 20:45:22 +02:00
|
|
|
trFolder = name;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
return trFolder;
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
QString Bookmarks::fromTranslatedFolder(const QString &name)
|
2011-04-15 20:45:22 +02:00
|
|
|
{
|
|
|
|
QString folder;
|
2011-11-06 17:01:23 +01:00
|
|
|
if (name == tr("Bookmarks In Menu")) {
|
2011-04-15 20:45:22 +02:00
|
|
|
folder = "bookmarksMenu";
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
|
|
|
else if (name == tr("Bookmarks In ToolBar")) {
|
2011-04-15 20:45:22 +02:00
|
|
|
folder = "bookmarksToolbar";
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
|
|
|
else if (name == tr("Unsorted Bookmarks")) {
|
2011-04-15 20:45:22 +02:00
|
|
|
folder = "unsorted";
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
|
|
|
else {
|
2011-04-15 20:45:22 +02:00
|
|
|
folder = name;
|
2011-11-06 17:01:23 +01:00
|
|
|
}
|
2011-04-15 20:45:22 +02:00
|
|
|
return folder;
|
2011-03-02 16:57:41 +01:00
|
|
|
}
|
2012-09-05 23:52:40 +02:00
|
|
|
|
2014-02-08 18:14:38 +01:00
|
|
|
BookmarksModel* Bookmarks::model() const
|
|
|
|
{
|
|
|
|
return m_model;
|
|
|
|
}
|
|
|
|
|
2014-02-07 22:48:30 +01:00
|
|
|
BookmarkItem* Bookmarks::rootItem() const
|
|
|
|
{
|
|
|
|
return m_root;
|
|
|
|
}
|
|
|
|
|
2014-02-08 20:01:07 +01:00
|
|
|
BookmarkItem* Bookmarks::toolbarFolder() const
|
|
|
|
{
|
|
|
|
return m_folderToolbar;
|
|
|
|
}
|
|
|
|
|
|
|
|
BookmarkItem* Bookmarks::menuFolder() const
|
|
|
|
{
|
|
|
|
return m_folderMenu;
|
|
|
|
}
|
|
|
|
|
|
|
|
BookmarkItem* Bookmarks::unsortedFolder() const
|
|
|
|
{
|
|
|
|
return m_folderUnsorted;
|
|
|
|
}
|
|
|
|
|
2014-02-07 22:48:30 +01:00
|
|
|
bool Bookmarks::removeBookmark(BookmarkItem* item)
|
|
|
|
{
|
|
|
|
if (!canBeModified(item)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_model->removeBookmark(item);
|
|
|
|
emit bookmarkRemoved(item);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-08 18:14:38 +01:00
|
|
|
void Bookmarks::notifyBookmarkChanged(BookmarkItem* item)
|
|
|
|
{
|
|
|
|
emit bookmarkChanged(item);
|
|
|
|
}
|
|
|
|
|
2014-02-07 22:48:30 +01:00
|
|
|
bool Bookmarks::canBeModified(BookmarkItem* item) const
|
|
|
|
{
|
2014-02-08 20:01:07 +01:00
|
|
|
return item &&
|
|
|
|
item != m_root &&
|
|
|
|
item != m_folderToolbar &&
|
|
|
|
item != m_folderMenu &&
|
|
|
|
item != m_folderUnsorted;
|
2014-02-07 22:48:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Bookmarks::addBookmark(BookmarkItem* parent, BookmarkItem* item)
|
|
|
|
{
|
|
|
|
Q_ASSERT(parent);
|
2014-02-08 18:28:01 +01:00
|
|
|
Q_ASSERT(parent->isFolder());
|
2014-02-07 22:48:30 +01:00
|
|
|
Q_ASSERT(item);
|
|
|
|
|
|
|
|
insertBookmark(parent, 0, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Bookmarks::insertBookmark(BookmarkItem* parent, int row, BookmarkItem* item)
|
|
|
|
{
|
|
|
|
Q_ASSERT(parent);
|
2014-02-08 18:28:01 +01:00
|
|
|
Q_ASSERT(parent->isFolder());
|
2014-02-07 22:48:30 +01:00
|
|
|
Q_ASSERT(item);
|
|
|
|
|
|
|
|
m_model->addBookmark(parent, row, item);
|
|
|
|
emit bookmarkAdded(item);
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::changeBookmarkParent(int id, const QString &newParent, const QString &oldParent, bool* ok)
|
2012-09-05 23:52:40 +02:00
|
|
|
{
|
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("SELECT title, url, icon FROM bookmarks WHERE id=?");
|
|
|
|
query.addBindValue(id);
|
|
|
|
query.exec();
|
|
|
|
|
|
|
|
if (!query.next()) {
|
|
|
|
if (ok) {
|
|
|
|
*ok = false;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString title = query.value(0).toString();
|
|
|
|
QUrl url = query.value(1).toUrl();
|
|
|
|
QByteArray imageData = query.value(2).toByteArray();
|
|
|
|
|
|
|
|
query.prepare("UPDATE bookmarks SET folder = ? WHERE id = ?");
|
2014-02-05 15:26:51 +01:00
|
|
|
query.bindValue(0, Bookmarks::fromTranslatedFolder(newParent));
|
2012-09-05 23:52:40 +02:00
|
|
|
query.bindValue(1, id);
|
|
|
|
|
|
|
|
if (!query.exec()) {
|
|
|
|
if (ok) {
|
|
|
|
*ok = false;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
emit bookmarkParentChanged(title, imageData, id, url, oldParent, newParent);
|
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
|
|
|
|
|
|
|
if (ok) {
|
|
|
|
*ok = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::changeFolderParent(const QString &name, bool isSubfolder, bool* ok)
|
2012-09-05 23:52:40 +02:00
|
|
|
{
|
2013-12-05 21:13:58 +01:00
|
|
|
if (name.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-09-05 23:52:40 +02:00
|
|
|
QSqlQuery query;
|
|
|
|
query.prepare("UPDATE folders SET subfolder=? WHERE name=?");
|
|
|
|
query.bindValue(0, isSubfolder ? "yes" : "no");
|
2014-02-05 15:26:51 +01:00
|
|
|
query.bindValue(1, Bookmarks::fromTranslatedFolder(name));
|
2012-09-05 23:52:40 +02:00
|
|
|
if (!query.exec()) {
|
|
|
|
if (ok) {
|
|
|
|
*ok = false;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
emit folderParentChanged(name, isSubfolder);
|
|
|
|
mApp->sendMessages(Qz::AM_BookmarksChanged, true);
|
|
|
|
|
|
|
|
if (ok) {
|
|
|
|
*ok = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-05 15:26:51 +01:00
|
|
|
void Bookmarks::bookmarkDropedLink(const QUrl &url, const QString &title, const QVariant &imageVariant, const QString &folder, bool* ok)
|
2012-09-05 23:52:40 +02:00
|
|
|
{
|
|
|
|
QIcon icon = qIconProvider->iconFromImage(qvariant_cast<QImage>(imageVariant));
|
2014-02-05 15:26:51 +01:00
|
|
|
bool result = saveBookmark(url, title, icon, Bookmarks::fromTranslatedFolder(folder));
|
2012-09-05 23:52:40 +02:00
|
|
|
|
|
|
|
if (ok) {
|
|
|
|
*ok = result;
|
|
|
|
}
|
|
|
|
}
|