Differential D3805 Diff 19301 applets/kicker/plugin/kastatsfavoritesmodel.cpp

Changeset View

Standalone View

applets/kicker/plugin/kastatsfavoritesmodel.cpp

This file was added.

		1		/***************************************************************************
		2		* Copyright (C) 2014-2015 by Eike Hein <hein@kde.org> *
		3		* Copyright (C) 2016-2017 by Ivan Cukic <ivan.cukic@kde.org> *
		4		* *
		5		* This program is free software; you can redistribute it and/or modify *
		6		* it under the terms of the GNU General Public License as published by *
		7		* the Free Software Foundation; either version 2 of the License, or *
		8		* (at your option) any later version. *
		9		* *
		10		* This program is distributed in the hope that it will be useful, *
		11		* but WITHOUT ANY WARRANTY; without even the implied warranty of *
		12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
		13		* GNU General Public License for more details. *
		14		* *
		15		* You should have received a copy of the GNU General Public License *
		16		* along with this program; if not, write to the *
		17		* Free Software Foundation, Inc., *
		18		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
		19		***************************************************************************/
		20
		21		#include "kastatsfavoritesmodel.h"
		22		#include "appentry.h"
		23		#include "contactentry.h"
		24		#include "fileentry.h"
		25		#include "actionlist.h"
		26
		27		#include <QDebug>
		28		#include <QFileInfo>
		29		#include <QTimer>
		30		#include <QSortFilterProxyModel>
		31
		32		#include <KLocalizedString>
		33		#include <KSharedConfig>
		34		#include <KConfigGroup>
		35
		36		#include <KActivities/Consumer>
		37		#include <KActivities/Stats/Terms>
		38		#include <KActivities/Stats/Query>
		39		#include <KActivities/Stats/ResultSet>
		40		#include <KActivities/Stats/ResultWatcher>
		41
		42		namespace KAStats = KActivities::Stats;
		43
		44		using namespace KAStats;
		45		using namespace KAStats::Terms;
		46
		47		#define AGENT_APPLICATIONS "org.kde.plasma.favorites.applications"
		48		#define AGENT_CONTACTS "org.kde.plasma.favorites.contacts"
		49		#define AGENT_DOCUMENTS "org.kde.plasma.favorites.documents"
		50
		51		#define DEBUG_PREFIX "\033[0;31m[KASTATSFAVS]\033[0;34m "
		52		#define DEBUG qDebug() << DEBUG_PREFIX << (void)q << ((void)this) << m_clientId << "\033[0;0m "
		53
		54		QString agentForUrl(const QString &url)
		55		{
		56		return url.startsWith("ktp:")
		57		? AGENT_CONTACTS
		58		: url.startsWith("preferred:")
		59		? AGENT_APPLICATIONS
		60		: url.startsWith("applications:")
		61		? AGENT_APPLICATIONS
		62		: (url.startsWith("/") && !url.endsWith(".desktop"))
		63		? AGENT_DOCUMENTS
		64		: (url.startsWith("file:/") && !url.endsWith(".desktop"))
		65		? AGENT_DOCUMENTS
		66		// use applications as the default
		67		: AGENT_APPLICATIONS;
		68		}
		69
		70		class KAStatsFavoritesModel::Private: public QAbstractListModel {
		71		public:
		72		class NormalizedId {
		73		public:
		74		NormalizedId()
		75		{
		76		}
		77
		78		NormalizedId(const Private *parent, const QString &id)
		79		{
		80		if (id.isEmpty()) return;
		81
		82		AbstractEntry *entry = nullptr;
		83		QScopedPointer<AbstractEntry> deleter;
		84
		85		if (parent->m_itemEntries.contains(id)) {
		86		entry = parent->m_itemEntries[id];
		87		} else {
		88		// This entry is not cached - it is temporary,
		89		// so let's clean up when we exit this function
		90		entry = parent->entryForResource(id);
		91		deleter.reset(entry);
		92		}
		93
		94		if (!entry \|\| !entry->isValid()) {
		95		qWarning() << "Entry is not valid" << id << entry;
		96		m_id = id;
		97		return;
		98		}
		99
		100		const auto url = entry->url();
		101
		102		qDebug() << "Original id is: " << id << ", and the url is" << url;
		103
		104		// Preferred applications need special handling
		105		if (entry->id().startsWith("preferred:")) {
		106		m_id = entry->id();
		107		return;
		108		}
		109
		110		// If this is an application, use the applications:-format url
		111		auto appEntry = dynamic_cast<AppEntry*>(entry);
		112		if (appEntry && !appEntry->menuId().isEmpty()) {
		113		m_id = "applications:" + appEntry->menuId();
		114		return;
		115		}
		116
		117		// We want to resolve symbolic links not to have two paths
		118		// refer to the same .desktop file
		119		if (url.isLocalFile()) {
		120		QFileInfo file(url.toLocalFile());
		121
		122		if (file.exists()) {
		123		m_id = QUrl::fromLocalFile(file.canonicalFilePath()).toString();
		124		return;
		125		}
		126		}
		127
		128		// If this is a file, we should have already covered it
		129		if (url.scheme() == "file") {
		130		return;
		131		}
		132
		133		m_id = url.toString();
		134		}
		135
		136		const QString& value() const
		137		{
		138		return m_id;
		139		}
		140
		141		bool operator==(const NormalizedId &other) const
		142		{
		143		return m_id == other.m_id;
		144		}
		145
		146		private:
		147		QString m_id;
		148		};
		149
		150		NormalizedId normalizedId(const QString &id) const
		151		{
		152		return NormalizedId(this, id);
		153		}
		154
		155		AbstractEntry *entryForResource(const QString &resource) const
		156		{
		157		const auto agent =
		158		agentForUrl(resource);
		159
		160		if (agent == AGENT_CONTACTS) {
		161		return new ContactEntry(q, resource);
		162
		163		} else if (agent == AGENT_DOCUMENTS) {
		164		if (resource.startsWith("/")) {
		165		return new FileEntry(q, QUrl::fromLocalFile(resource));
		166		} else {
		167		return new FileEntry(q, QUrl(resource));
		168		}
		169
		170		} else if (agent == AGENT_APPLICATIONS) {
		171		if (resource.startsWith("applications:")) {
		172		return new AppEntry(q, resource.mid(13));
		173		} else {
		174		return new AppEntry(q, resource);
		175		}
		176
		177		} else {
		178		return nullptr;
		179		}
		180		}
		181
		182		Private(KAStatsFavoritesModel *parent, QString clientId)
		183		: q(parent)
		184		, m_query(
		185		LinkedResources
		186		\| Agent {
		187		AGENT_APPLICATIONS,
		188		AGENT_CONTACTS,
		189		AGENT_DOCUMENTS
		190		}
		191		\| Type::any()
		192		\| Activity::current()
		193		\| Activity::global()
		194		)
		195		, m_watcher(m_query)
		196		, m_clientId(clientId)
		197		{
		198		// Connecting the watcher
		199		connect(&m_watcher, &ResultWatcher::resultLinked,
		200		[this] (const QString &resource) {
		201		addResult(resource, -1);
		202		});
		203
		204		connect(&m_watcher, &ResultWatcher::resultUnlinked,
		205		[this] (const QString &resource) {
		206		removeResult(resource);
		207		});
		208
		209		// Loading the items order
		210		const auto cfg = KSharedConfig::openConfig("kactivitymanagerd-statsrc");
		211
		212		// We want first to check whether we have an ordering for this activity.
		213		// If not, we will try to get a global one for this applet
		214
		215		const QString thisGroupName =
		216		"Favorites-" + clientId + "-" + m_activities.currentActivity();
		217		const QString globalGroupName =
		218		"Favorites-" + clientId + "-global";
		219
		220		KConfigGroup thisCfgGroup(cfg, thisGroupName);
		221		KConfigGroup globalCfgGroup(cfg, globalGroupName);
		222
		223		QStringList ordering =
		224		thisCfgGroup.readEntry("ordering", QStringList()) +
		225		globalCfgGroup.readEntry("ordering", QStringList());
		226
		227		DEBUG << "Loading the ordering " << ordering;
		228
		229		// Loading the results without emitting any model signals
		230		ResultSet results(m_query);
		231
		232		for (const auto& result: results) {
		233		addResult(result.resource(), -1, false);
		234		}
		235
		236		// Normalizing all the ids
		237		std::transform(ordering.begin(), ordering.end(), ordering.begin(),
		238		[&] (const QString &item) {
		239		return normalizedId(item).value();
		240		});
		241
		242		// Sorting the items in the cache
		243		std::sort(m_items.begin(), m_items.end(),
		244		[&] (const NormalizedId &left, const NormalizedId &right) {
		245		auto leftIndex = ordering.indexOf(left.value());
		246		auto rightIndex = ordering.indexOf(right.value());
		247
		248		return (leftIndex == -1 && rightIndex == -1) ?
		249		left.value() < right.value() :
		250
		251		(leftIndex == -1) ?
		252		false :
		253
		254		(rightIndex == -1) ?
		255		true :
		256
		257		// otherwise
		258		leftIndex < rightIndex;
		259		});
		260
		261		// Debugging:
		262		QVector<QString> itemStrings(m_items.size());
		263		std::transform(m_items.cbegin(), m_items.cend(), itemStrings.begin(),
		264		[] (const NormalizedId &item) {
		265		return item.value();
		266		});
		267		DEBUG << "After ordering: " << itemStrings;
		268		}
		269
		270		void addResult(const QString &_resource, int index, bool notifyModel = true)
		271		{
		272		// We want even files to have a proper URL
		273		const auto resource =
		274		_resource.startsWith("/") ? QUrl::fromLocalFile(_resource).toString() : _resource;
		275
		276		DEBUG << "Adding result" << resource << "already present?" << m_itemEntries.contains(resource);
		277
		278		if (m_itemEntries.contains(resource)) return;
		279
		280		auto entry = entryForResource(resource);
		281
		282		if (!entry \|\| !entry->isValid()) {
		283		DEBUG << "Entry is not valid!";
		284		return;
		285		}
		286
		287		if (index == -1) {
		288		index = m_items.count();
		289		}
		290
		291		if (notifyModel) {
		292		beginInsertRows(QModelIndex(), index, index);
		293		}
		294
		295		auto url = entry->url();
		296
		297		m_itemEntries[resource]
		298		= m_itemEntries[entry->id()]
		299		= m_itemEntries[url.toString()]
		300		= m_itemEntries[url.toLocalFile()]
		301		= entry;
		302
		303		auto normalized = normalizedId(resource);
		304		m_items.insert(index, normalized);
		305		m_itemEntries[normalized.value()] = entry;
		306
		307		if (notifyModel) {
		308		endInsertRows();
		309		saveOrdering();
		310		}
		311		}
		312
		313		void removeResult(const QString &resource)
		314		{
		315		auto normalized = normalizedId(resource);
		316
		317		// If we know this item will not really be removed,
		318		// but only that activities it is on have changed,
		319		// lets leave it
		320		if (m_ignoredItems.contains(normalized.value())) {
		321		m_ignoredItems.removeAll(normalized.value());
		322		return;
		323		}
		324
		325		DEBUG << "Removing result" << resource;
		326
		327		auto index = m_items.indexOf(normalizedId(resource));
		328
		329		if (index == -1) return;
		330
		331		beginRemoveRows(QModelIndex(), index, index);
		332		auto entry = m_itemEntries[resource];
		333		m_items.removeAt(index);
		334
		335		// Removing the entry from the cache
		336		QMutableHashIterator<QString, AbstractEntry*> i(m_itemEntries);
		337		while (i.hasNext()) {
		338		if (i.value() == entry) {
		339		i.remove();
		340		}
		341		i.next();
		342		}
		343		delete entry;
		344
		345		endRemoveRows();
		346		}
		347
		348
		349		int rowCount(const QModelIndex &parent = QModelIndex()) const override
		350		{
		351		if (parent.isValid()) return 0;
		352
		353		return m_items.count();
		354		}
		355
		356		QVariant data(const QModelIndex &item,
		357		int role = Qt::DisplayRole) const override
		358		{
		359		if (item.parent().isValid()) return QVariant();
		360
		361		const auto index = item.row();
		362
		363		const auto entry = m_itemEntries[m_items[index].value()];
		364
		365		return entry == nullptr ? QVariant()
		366		: role == Qt::DisplayRole ? entry->name()
		367		: role == Qt::DecorationRole ? entry->icon()
		368		: role == Kicker::DescriptionRole ? entry->description()
		369		: role == Kicker::FavoriteIdRole ? entry->id()
		370		: role == Kicker::UrlRole ? entry->url()
		371		: role == Kicker::HasActionListRole ? entry->hasActions()
		372		: role == Kicker::ActionListRole ? entry->actions()
		373		: QVariant();
		374		}
		375
		376		bool trigger(int row, const QString &actionId, const QVariant &argument)
		377		{
		378		if (row < 0 \|\| row >= rowCount()) {
		379		return false;
		380		}
		381
		382		const QString id = data(index(row, 0), Kicker::UrlRole).toString();
		383
		384		return m_itemEntries.contains(id)
		385		? m_itemEntries[id]->run(actionId, argument)
		386		: false;
		387		}
		388
		389		void move(int from, int to)
		390		{
		391		if (from < 0) return;
		392		if (from >= m_items.count()) return;
		393		if (to < 0) return;
		394		if (to >= m_items.count()) return;
		395
		396		if (from == to) return;
		397
		398		const int modelTo = to + (to > from ? 1 : 0);
		399
		400		if (q->beginMoveRows(QModelIndex(), from, from,
		401		QModelIndex(), modelTo)) {
		402		m_items.move(from, to);
		403		q->endMoveRows();
		404
		405		DEBUG << "Save ordering (from Private::move) -->";
		406		saveOrdering();
		407		}
		408		}
		409
		410		void saveOrdering()
		411		{
		412		QStringList ids;
		413
		414		for (const auto& item: m_items) {
		415		ids << item.value();
		416		}
		417
		418		DEBUG << "Save ordering (from Private::saveOrdering) -->";
		419		saveOrdering(ids, m_clientId, m_activities.currentActivity());
		420		}
		421
		422		static void saveOrdering(const QStringList &ids, const QString &clientId, const QString &currentActivity)
		423		{
		424		const auto cfg = KSharedConfig::openConfig("kactivitymanagerd-statsrc");
		425
		426		QStringList activities {
		427		currentActivity,
		428		"global"
		429		};
		430
		431		qDebug() << "Saving ordering for" << currentActivity << "and global" << ids;
		432
		433		for (const auto& activity: activities) {
		434		const QString groupName =
		435		"Favorites-" + clientId + "-" + activity;
		436
		437		KConfigGroup cfgGroup(cfg, groupName);
		438
		439		cfgGroup.writeEntry("ordering", ids);
		440		}
		441
		442		cfg->sync();
		443		}
		444
		445		KAStatsFavoritesModel *const q;
		446		KActivities::Consumer m_activities;
		447		Query m_query;
		448		ResultWatcher m_watcher;
		449		QString m_clientId;
		450
		451		QVector<NormalizedId> m_items;
		452		QHash<QString, AbstractEntry*> m_itemEntries;
		453		QStringList m_ignoredItems;
		454		};
		455
		456		#undef DEBUG
		457		#define DEBUG qDebug() << DEBUG_PREFIX << ((void)this) << ((void)d) << (d ? d->m_clientId : QString("no client ID yet")) << "\033[0;0m "
		458
		459		KAStatsFavoritesModel::KAStatsFavoritesModel(QObject *parent)
		460		: PlaceholderModel(parent)
		461		, d(nullptr) // we have no client id yet
		462		, m_enabled(true)
		463		, m_maxFavorites(-1)
		464		, m_activities(new KActivities::Consumer(this))
		465		{
		466		connect(m_activities, &KActivities::Consumer::currentActivityChanged,
		467		this, [&] (const QString &currentActivity) {
		468		DEBUG << "Activity just got changed";
		469		Q_UNUSED(currentActivity);
		470		auto clientId = d->m_clientId;
		471		initForClient(clientId);
		472		});
		473		}
		474
		475		KAStatsFavoritesModel::~KAStatsFavoritesModel()
		476		{
		477		delete d;
		478		}
		479
		480		void KAStatsFavoritesModel::initForClient(const QString &clientId)
		481		{
		482		DEBUG << "initForClient" << clientId;
		483
		484		setSourceModel(nullptr);
		485		delete d;
		486		d = new Private(
		487		this,
		488		clientId
		489		);
		490
		491		setSourceModel(d);
		492		}
		493
		494		QString KAStatsFavoritesModel::description() const
		495		{
		496		return i18n("Favorites");
		497		}
		498
		499		bool KAStatsFavoritesModel::trigger(int row, const QString &actionId, const QVariant &argument)
		500		{
		501		return d->trigger(row, actionId, argument);
		502		}
		503
		504		bool KAStatsFavoritesModel::enabled() const
		505		{
		506		return m_enabled;
		507		}
		508
		509		int KAStatsFavoritesModel::maxFavorites() const
		510		{
		511		return m_maxFavorites;
		512		}
		513
		514		void KAStatsFavoritesModel::setMaxFavorites(int max)
		515		{
		516		Q_UNUSED(max);
		517		}
		518
		519		void KAStatsFavoritesModel::setEnabled(bool enable)
		520		{
		521		if (m_enabled != enable) {
		522		m_enabled = enable;
		523
		524		emit enabledChanged();
		525		}
		526		}
		527
		528		QStringList KAStatsFavoritesModel::favorites() const
		529		{
		530		qWarning() << "KAStatsFavoritesModel::favorites returns nothing, it is here just to keep the API backwards-compatible";
		531		return QStringList();
		532		}
		533
		534		void KAStatsFavoritesModel::setFavorites(const QStringList& favorites)
		535		{
		536		Q_UNUSED(favorites);
		537		qWarning() << "KAStatsFavoritesModel::setFavorites is ignored";
		538		}
		539
		540		bool KAStatsFavoritesModel::isFavorite(const QString &id) const
		541		{
		542		return d && d->m_itemEntries.contains(id);
		543		}
		544
		545		void KAStatsFavoritesModel::portOldFavorites(const QStringList &ids)
		546		{
		547		DEBUG << "portOldFavorites" << ids;
		548
		549		const auto activityId = ":global";
		550		std::for_each(ids.begin(), ids.end(), [&] (const QString &id) {
		551		addFavoriteTo(id, activityId);
		552		});
		553
		554		// Resetting the model
		555		auto clientId = d->m_clientId;
		556		setSourceModel(nullptr);
		557		delete d;
		558		d = nullptr;
		559
		560		DEBUG << "Save ordering (from portOldFavorites) -->";
		561		Private::saveOrdering(ids, clientId, m_activities->currentActivity());
		562
		563		QTimer::singleShot(500,
		564		std::bind(&KAStatsFavoritesModel::initForClient, this, clientId));
		565		}
		566
		567		void KAStatsFavoritesModel::addFavorite(const QString &id, int index)
		568		{
		569		DEBUG << "addFavorite" << id << index << " -->";
		570		addFavoriteTo(id, Activity::current(), index);
		571		}
		572
		573		void KAStatsFavoritesModel::removeFavorite(const QString &id)
		574		{
		575		DEBUG << "removeFavorite" << id << " -->";
		576		removeFavoriteFrom(id, Activity::current());
		577		}
		578
		579		void KAStatsFavoritesModel::addFavoriteTo(const QString &id, const QString &activityId, int index)
		580		{
		581		DEBUG << "addFavoriteTo" << id << activityId << index << " -->";
		582		addFavoriteTo(id, Activity(activityId), index);
		583		}
		584
		585		void KAStatsFavoritesModel::removeFavoriteFrom(const QString &id, const QString &activityId)
		586		{
		587		DEBUG << "removeFavoriteFrom" << id << activityId << " -->";
		588		removeFavoriteFrom(id, Activity(activityId));
		589		}
		590
		591		void KAStatsFavoritesModel::addFavoriteTo(const QString &id, const Activity &activity, int index)
		592		{
		593		if (!d \|\| id.isEmpty()) return;
		594
		595		Q_ASSERT(!activity.values.isEmpty());
		596
		597		setDropPlaceholderIndex(-1);
		598
		599		QStringList matchers { d->m_activities.currentActivity(), ":global", ":current" };
		600		if (std::find_first_of(activity.values.cbegin(), activity.values.cend(),
		601		matchers.cbegin(), matchers.cend()) != activity.values.cend()) {
		602		d->addResult(id, index);
		603		}
		604
		605		const auto url = d->normalizedId(id).value();
		606
		607		DEBUG << "addFavoriteTo" << id << activity << index << url << " (actual)";
		608
		609		if (url.isEmpty()) return;
		610
		611		d->m_watcher.linkToActivity(QUrl(url), activity,
		612		Agent(agentForUrl(url)));
		613		}
		614
		615		void KAStatsFavoritesModel::removeFavoriteFrom(const QString &id, const Activity &activity)
		616		{
		617		const auto url = d->normalizedId(id).value();
		618
		619		Q_ASSERT(!activity.values.isEmpty());
		620
		621		DEBUG << "addFavoriteTo" << id << activity << url << " (actual)";
		622
		623		if (url.isEmpty()) return;
		624
		625		d->m_watcher.unlinkFromActivity(QUrl(url), activity,
		626		Agent(agentForUrl(url)));
		627		}
		628
		629		void KAStatsFavoritesModel::setFavoriteOn(const QString &id, const QString &activityId)
		630		{
		631		const auto url = d->normalizedId(id).value();
		632
		633		DEBUG << "setFavoriteOn" << id << activityId << url << " (actual)";
		634
		635		DEBUG << "%%%%%%%%%%% Activity is" << activityId;
		636		if (activityId.isEmpty() \|\| activityId == ":any" \|\|
		637		activityId == ":global" \|\|
		638		activityId == m_activities->currentActivity()) {
		639		d->m_ignoredItems << url;
		640		}
		641
		642		d->m_watcher.unlinkFromActivity(QUrl(url), Activity::any(),
		643		Agent(agentForUrl(url)));
		644		d->m_watcher.linkToActivity(QUrl(url), activityId,
		645		Agent(agentForUrl(url)));
		646		}
		647
		648		void KAStatsFavoritesModel::moveRow(int from, int to)
		649		{
		650		d->move(from, to);
		651		}
		652
		653		AbstractModel *KAStatsFavoritesModel::favoritesModel()
		654		{
		655		return this;
		656		}
		657
		658		void KAStatsFavoritesModel::refresh()
		659		{
		660		}
		661
		662		QObject *KAStatsFavoritesModel::activities() const
		663		{
		664		return m_activities;
		665		}
		666
		667		QString KAStatsFavoritesModel::activityNameForId(const QString &activityId) const
		668		{
		669		// It is safe to use a short-lived object here,
		670		// we are always synced with KAMD in plasma
		671		KActivities::Info info(activityId);
		672		return info.name();
		673		}
		674
		675		QStringList KAStatsFavoritesModel::linkedActivitiesFor(const QString &id) const
		676		{
		677		if (!d) {
		678		DEBUG << "Linked for" << id << "is empty, no Private instance";
		679		return {};
		680		}
		681
		682		auto url = d->normalizedId(id).value();
		683
		684		if (url.startsWith("file:")) {
		685		url = QUrl(url).toLocalFile();
		686		}
		687
		688		if (url.isEmpty()) {
		689		DEBUG << "The url for" << id << "is empty";
		690		return {};
		691		}
		692
		693		auto query = LinkedResources
		694		\| Agent {
		695		AGENT_APPLICATIONS,
		696		AGENT_CONTACTS,
		697		AGENT_DOCUMENTS
		698		}
		699		\| Type::any()
		700		\| Activity::any()
		701		\| Url(url);
		702
		703		ResultSet results(query);
		704
		705		for (const auto &result: results) {
		706		DEBUG << "Returning" << result.linkedActivities() << "for" << id << url;
		707		return result.linkedActivities();
		708		}
		709
		710		DEBUG << "Returning empty list of activities for" << id << url;
		711		return {};
		712		}
		713