* Copyright (C) 2012 Aurélien Gâteau <agateau@kde.org> *
* Copyright (C) 2013-2014 by Eike Hein <hein@kde.org> *
* *
* 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 2 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, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
***************************************************************************/
#include "appsmodel.h"
#include "actionlist.h"
#include "containmentinterface.h"
#include <QTimer>
#include <KLocalizedString>
#include <KRun>
#include <KSycoca>
AppGroupEntry::AppGroupEntry(KServiceGroup::Ptr group, QAbstractListModel *parentModel,
bool flat, int appNameFormat)
{
m_name = group->caption();
m_icon = QIcon::fromTheme(group->icon());
m_model = new AppsModel(group->entryPath(), flat, parentModel);
static_cast<AppsModel *>(m_model.data())->setAppNameFormat(appNameFormat);
QObject::connect(parentModel, SIGNAL(refreshing()), m_model, SLOT(deleteLater()));
QObject::connect(m_model, SIGNAL(appLaunched(QString)), parentModel, SIGNAL(appLaunched(QString)));
}
AppEntry::AppEntry(KService::Ptr service, NameFormat nameFormat)
: m_service(service)
{
const QString &name = service->name();
QString genericName = service->genericName();
if (genericName.isEmpty()) {
genericName = service->comment();
}
if (nameFormat == NameOnly || genericName.isEmpty() || name == genericName) {
m_name = name;
} else if (nameFormat == GenericNameOnly) {
m_name = genericName;
} else if (nameFormat == NameAndGenericName) {
m_name = i18nc("App name (Generic name)", "%1 (%2)", name, genericName);
} else {
m_name = i18nc("Generic name (App name)", "%1 (%2)", genericName, name);
}
m_icon = QIcon::fromTheme(service->icon());
m_service = service;
}
ContainmentInterface *AppsModel::m_containmentInterface = 0;
AppsModel::AppsModel(const QString &entryPath, bool flat, QObject *parent)
: AbstractModel(parent)
, m_entryPath(entryPath)
, m_changeTimer(0)
, m_flat(flat)
, m_appNameFormat(AppEntry::NameOnly)
, m_sortNeeded(false)
{
refresh();
}
AppsModel::~AppsModel()
{
qDeleteAll(m_entryList);
}
QVariant AppsModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || index.row() >= m_entryList.count()) {
return QVariant();
}
if (role == Qt::DisplayRole) {
return m_entryList.at(index.row())->name();
} else if (role == Qt::DecorationRole) {
return m_entryList.at(index.row())->icon();
} else if (role == Kicker::HasChildrenRole) {
AbstractEntry *entry = m_entryList.at(index.row());
if (entry->type() == AbstractEntry::GroupType) {
AbstractGroupEntry *groupEntry = static_cast<AbstractGroupEntry *>(entry);
if (groupEntry->model() && groupEntry->model()->count()) {
return true;
}
}
} else if (role == Kicker::FavoriteIdRole) {
if (m_entryList.at(index.row())->type() == AbstractEntry::RunnableType) {
return QVariant("app:" + static_cast<AppEntry *>(m_entryList.at(index.row()))->service()->storageId());
}
} else if (role == Kicker::HasActionListRole) {
return (m_entryList.at(index.row())->type() == AbstractEntry::RunnableType);
} else if (role == Kicker::ActionListRole) {
if (m_containmentInterface) {
QVariantList actionList;
if (m_containmentInterface->mayAddLauncher(ContainmentInterface::Desktop)) {
actionList << Kicker::createActionItem(i18n("Add to Desktop"), "addToDesktop");
}
if (m_containmentInterface->mayAddLauncher(ContainmentInterface::Panel)) {
actionList << Kicker::createActionItem(i18n("Add to Panel"), "addToPanel");
}
if (m_containmentInterface->mayAddLauncher(ContainmentInterface::TaskManager,
static_cast<AppEntry *>(m_entryList.at(index.row()))->service()->entryPath())) {
actionList << Kicker::createActionItem(i18n("Add as Launcher"), "addToTaskManager");
}
return actionList;
}
} else if (role == Kicker::UrlRole) {
if (m_entryList.at(index.row())->type() == AbstractEntry::RunnableType) {
return QUrl::fromLocalFile(static_cast<AppEntry *>(m_entryList.at(index.row()))->service()->entryPath());
}
}
return QVariant();
}
int AppsModel::rowCount(const QModelIndex &parent) const
{
return parent.isValid() ? 0 : m_entryList.count();
}
bool AppsModel::trigger(int row, const QString &actionId, const QVariant &argument)
{
Q_UNUSED(argument)
if (row < 0 || row >= m_entryList.count() || m_entryList.at(row)->type() != AbstractEntry::RunnableType) {
return false;
}
if (actionId == "addToDesktop" && m_containmentInterface
&& m_containmentInterface->mayAddLauncher(ContainmentInterface::Desktop)) {
m_containmentInterface->addLauncher(ContainmentInterface::Desktop,
static_cast<AppEntry *>(m_entryList.at(row))->service()->entryPath());
} else if (actionId == "addToPanel" && m_containmentInterface
&& m_containmentInterface->mayAddLauncher(ContainmentInterface::Panel)) {
m_containmentInterface->addLauncher(ContainmentInterface::Panel,
static_cast<AppEntry *>(m_entryList.at(row))->service()->entryPath());
} else if (actionId == "addToTaskManager" && m_containmentInterface
&& m_containmentInterface->mayAddLauncher(ContainmentInterface::TaskManager,
static_cast<AppEntry *>(m_entryList.at(row))->service()->entryPath())) {
m_containmentInterface->addLauncher(ContainmentInterface::TaskManager,
static_cast<AppEntry *>(m_entryList.at(row))->service()->entryPath());
} else if (actionId.isEmpty()) {
KService::Ptr service = static_cast<AppEntry *>(m_entryList.at(row))->service();
bool ran = KRun::run(*service, QList<QUrl>(), 0);
if (ran) {
emit appLaunched(service->storageId());
}
return ran;
}
return false;
}
AbstractModel *AppsModel::modelForRow(int row)
{
if (row < 0 || row >= m_entryList.count() || m_entryList.at(row)->type() != AbstractEntry::GroupType) {
return 0;
}
return static_cast<AbstractGroupEntry *>(m_entryList.at(row))->model();
}
bool AppsModel::flat() const
{
return m_flat;
}
void AppsModel::setFlat(bool flat)
{
if (m_flat != flat) {
m_flat = flat;
refresh();
emit flatChanged();
}
}
int AppsModel::appNameFormat() const
{
return m_appNameFormat;
}
void AppsModel::setAppNameFormat(int format)
{
if (m_appNameFormat != (AppEntry::NameFormat)format) {
m_appNameFormat = (AppEntry::NameFormat)format;
refresh();
emit appNameFormatChanged();
}
}
QObject* AppsModel::appletInterface() const
{
if (m_containmentInterface) {
return m_containmentInterface;
}
return 0;
}
void AppsModel::setAppletInterface(QObject* appletInterface)
{
if (!m_containmentInterface) {
m_containmentInterface = new ContainmentInterface(this);
}
m_containmentInterface->setApplet(appletInterface);
}
void AppsModel::refresh()
{
beginResetModel();
emit refreshing();
qDeleteAll(m_entryList);
m_entryList.clear();
if (m_entryPath.isEmpty()) {
KServiceGroup::Ptr group = KServiceGroup::root();
KServiceGroup::List list = group->entries(true);
for (KServiceGroup::List::ConstIterator it = list.constBegin(); it != list.constEnd(); it++) {
const KSycocaEntry::Ptr p = (*it);
if (p->isType(KST_KServiceGroup)) {
KServiceGroup::Ptr subGroup = static_cast<KServiceGroup::Ptr >(p);
if (!subGroup->noDisplay() && subGroup->childCount() > 0) {
m_entryList << new AppGroupEntry(subGroup, this, m_flat, m_appNameFormat);
}
}
}
m_changeTimer = new QTimer(this);
m_changeTimer->setSingleShot(true);
m_changeTimer->setInterval(100);
connect(m_changeTimer, SIGNAL(timeout()), this, SLOT(refresh()));
connect(KSycoca::self(), SIGNAL(databaseChanged(QStringList)), SLOT(checkSycocaChanges(QStringList)));
} else {
KServiceGroup::Ptr group = KServiceGroup::group(m_entryPath);
processServiceGroup(group);
if (m_sortNeeded) {
qSort(m_entryList.begin(), m_entryList.end(), AbstractEntry::lessThan);
m_sortNeeded = false;
}
}
endResetModel();
emit countChanged();
}
void AppsModel::processServiceGroup(KServiceGroup::Ptr group)
{
if (!group || !group->isValid()) {
return;
}
KServiceGroup::List list = group->entries(true);
for (KServiceGroup::List::ConstIterator it = list.constBegin();
it != list.constEnd(); it++) {
const KSycocaEntry::Ptr p = (*it);
if (p->isType(KST_KService)) {
const KService::Ptr service = static_cast<KService::Ptr>(p);
if (!service->noDisplay()) {
bool found = false;
foreach (const AbstractEntry *entry, m_entryList) {
if (entry->type() == AbstractEntry::RunnableType
&& static_cast<const AppEntry *>(entry)->service()->storageId() == service->storageId()) {
found = true;
}
}
if (!found) {
m_entryList << new AppEntry(service, m_appNameFormat);
}
}
} else if (p->isType(KST_KServiceGroup)) {
if (m_flat) {
processServiceGroup(static_cast<KServiceGroup::Ptr>(p));
m_sortNeeded = true;
} else {
const KServiceGroup::Ptr subGroup = static_cast<KServiceGroup::Ptr>(p);
if (!subGroup->noDisplay() && subGroup->childCount() > 0) {
m_entryList << new AppGroupEntry(subGroup, this, m_flat, m_appNameFormat);
}
}
}
}
}
void AppsModel::checkSycocaChanges(const QStringList &changes)
{
if (changes.contains("services") || changes.contains("apps") || changes.contains("xdgdata-apps")) {
m_changeTimer->start();
}
}
