diff --git a/libtaskmanager/CMakeLists.txt b/libtaskmanager/CMakeLists.txt index 7a7e6ccbd..9c3e15e9a 100644 --- a/libtaskmanager/CMakeLists.txt +++ b/libtaskmanager/CMakeLists.txt @@ -1,105 +1,107 @@ add_subdirectory(declarative) add_subdirectory(autotests) set(taskmanager_LIB_SRCS abstracttasksmodel.cpp activityinfo.cpp concatenatetasksproxymodel.cpp + flattentaskgroupsproxymodel.cpp launchertasksmodel.cpp startuptasksmodel.cpp taskfilterproxymodel.cpp taskgroupingproxymodel.cpp tasksmodel.cpp tasktools.cpp virtualdesktopinfo.cpp waylandtasksmodel.cpp ) if (X11_FOUND) set(taskmanager_LIB_SRCS ${taskmanager_LIB_SRCS} xwindowtasksmodel.cpp ) endif() add_library(taskmanager ${taskmanager_LIB_SRCS}) add_library(PW::LibTaskManager ALIAS taskmanager) generate_export_header(taskmanager) target_include_directories(taskmanager PUBLIC "$" "$") target_link_libraries(taskmanager PUBLIC Qt5::Core Qt5::Gui Qt5::Quick + KF5::ItemModels KF5::WaylandClient PRIVATE KF5::Activities - KF5::ItemModels KF5::ConfigCore KF5::KIOCore KF5::KIOWidgets KF5::ProcessCore KF5::WindowSystem ) if (X11_FOUND) target_link_libraries(taskmanager PRIVATE Qt5::X11Extras KF5::IconThemes) endif() set_target_properties(taskmanager PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION 6 EXPORT_NAME LibTaskManager) install(TARGETS taskmanager EXPORT libtaskmanagerLibraryTargets ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} ) install(FILES abstracttasksmodel.h abstracttasksmodeliface.h activityinfo.h concatenatetasksproxymodel.h + flattentaskgroupsproxymodel.h launchertasksmodel.h startuptasksmodel.h taskfilterproxymodel.h taskgroupingproxymodel.h tasksmodel.h tasktools.h virtualdesktopinfo.h waylandtasksmodel.h ${CMAKE_CURRENT_BINARY_DIR}/taskmanager_export.h DESTINATION ${KDE_INSTALL_INCLUDEDIR}/taskmanager COMPONENT Devel ) if (X11_FOUND) install(FILES xwindowtasksmodel.h ${CMAKE_CURRENT_BINARY_DIR}/taskmanager_export.h DESTINATION ${KDE_INSTALL_INCLUDEDIR}/taskmanager COMPONENT Devel ) endif() write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/LibTaskManagerConfigVersion.cmake VERSION "${PROJECT_VERSION}" COMPATIBILITY AnyNewerVersion) set(CMAKECONFIG_INSTALL_DIR ${KDE_INSTALL_LIBDIR}/cmake/LibTaskManager) ecm_configure_package_config_file(LibTaskManagerConfig.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/LibTaskManagerConfig.cmake" INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/LibTaskManagerConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/LibTaskManagerConfigVersion.cmake DESTINATION ${CMAKECONFIG_INSTALL_DIR}) install(EXPORT libtaskmanagerLibraryTargets NAMESPACE PW:: DESTINATION ${CMAKECONFIG_INSTALL_DIR} FILE LibTaskManagerLibraryTargets.cmake ) install(FILES taskmanagerrulesrc DESTINATION ${KDE_INSTALL_CONFDIR}) diff --git a/libtaskmanager/flattentaskgroupsproxymodel.cpp b/libtaskmanager/flattentaskgroupsproxymodel.cpp new file mode 100644 index 000000000..e21dc524b --- /dev/null +++ b/libtaskmanager/flattentaskgroupsproxymodel.cpp @@ -0,0 +1,150 @@ +/******************************************************************** +Copyright 2016 Eike Hein + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) version 3, or any +later version accepted by the membership of KDE e.V. (or its +successor approved by the membership of KDE e.V.), which shall +act as a proxy defined in Section 6 of version 3 of the license. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library. If not, see . +*********************************************************************/ + +#include "flattentaskgroupsproxymodel.h" + +namespace TaskManager +{ + +class FlattenTaskGroupsProxyModel::Private +{ +public: + Private(FlattenTaskGroupsProxyModel *q); + + AbstractTasksModelIface *sourceTasksModel = nullptr; + +private: + FlattenTaskGroupsProxyModel *q; +}; + +FlattenTaskGroupsProxyModel::Private::Private(FlattenTaskGroupsProxyModel *q) + : q(q) +{ +} + +FlattenTaskGroupsProxyModel::FlattenTaskGroupsProxyModel(QObject *parent) + : KDescendantsProxyModel(parent) + , d(new Private(this)) +{ +} + +FlattenTaskGroupsProxyModel::~FlattenTaskGroupsProxyModel() +{ +} + +void FlattenTaskGroupsProxyModel::setSourceModel(QAbstractItemModel *sourceModel) +{ + d->sourceTasksModel = dynamic_cast(sourceModel); + + KDescendantsProxyModel::setSourceModel(sourceModel); +} + +void FlattenTaskGroupsProxyModel::requestActivate(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestActivate(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestNewInstance(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestNewInstance(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestClose(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestClose(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestMove(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestMove(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestResize(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestResize(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestToggleMinimized(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestToggleMinimized(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestToggleMaximized(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestToggleMaximized(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestToggleKeepAbove(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestToggleKeepAbove(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestToggleKeepBelow(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestToggleKeepBelow(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestToggleFullScreen(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestToggleFullScreen(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestToggleShaded(const QModelIndex &index) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestToggleShaded(mapToSource(index)); + } +} + +void FlattenTaskGroupsProxyModel::requestVirtualDesktop(const QModelIndex &index, qint32 desktop) +{ + if (d->sourceTasksModel && index.isValid() && index.model() == this) { + d->sourceTasksModel->requestVirtualDesktop(mapToSource(index), desktop); + } +} + +void FlattenTaskGroupsProxyModel::requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, QObject *delegate) +{ + if (index.isValid() && index.model() == this) { + d->sourceTasksModel->requestPublishDelegateGeometry(mapToSource(index), geometry, delegate); + } +} + +} diff --git a/libtaskmanager/flattentaskgroupsproxymodel.h b/libtaskmanager/flattentaskgroupsproxymodel.h new file mode 100644 index 000000000..bd7a7b9c6 --- /dev/null +++ b/libtaskmanager/flattentaskgroupsproxymodel.h @@ -0,0 +1,191 @@ +/******************************************************************** +Copyright 2016 Eike Hein + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) version 3, or any +later version accepted by the membership of KDE e.V. (or its +successor approved by the membership of KDE e.V.), which shall +act as a proxy defined in Section 6 of version 3 of the license. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library. If not, see . +*********************************************************************/ + +#ifndef FLATTENTASKGROUPSPROXYMODEL_H +#define FLATTENTASKGROUPSPROXYMODEL_H + +#include "abstracttasksmodeliface.h" + +#include + +#include "taskmanager_export.h" + +namespace TaskManager +{ + +/** + * @short A proxy tasks model for flattening a tree-structured tasks model + * into a list-structured tasks model. + * + * This proxy model is a subclass of KDescendantsProxyModel implementing + * AbstractTasksModelIface. + * + * @author Eike Hein + **/ + +class TASKMANAGER_EXPORT FlattenTaskGroupsProxyModel : public KDescendantsProxyModel, + public AbstractTasksModelIface +{ + Q_OBJECT + +public: + explicit FlattenTaskGroupsProxyModel(QObject *parent = 0); + virtual ~FlattenTaskGroupsProxyModel(); + + void setSourceModel(QAbstractItemModel *sourceModel) override; + + /** + * Request activation of the task at the given index. Derived classes are + * free to interpret the meaning of "activate" themselves depending on + * the nature and state of the task, e.g. launch or raise a window task. + * + * @param index An index in this tasks model. + **/ + void requestActivate(const QModelIndex &index); + + /** + * Request an additional instance of the application backing the task + * at the given index. + * + * @param index An index in this tasks model. + **/ + void requestNewInstance(const QModelIndex &index); + + /** + * Request the task at the given index be closed. + * + * @param index An index in this tasks model. + **/ + void requestClose(const QModelIndex &index); + + /** + * Request starting an interactive move for the task at the given index. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestMove(const QModelIndex &index); + + /** + * Request starting an interactive resize for the task at the given index. + * + * This is meant for tasks that have an associated window, and may be a + * no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestResize(const QModelIndex &index); + + /** + * Request toggling the minimized state of the task at the given index. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestToggleMinimized(const QModelIndex &index); + + /** + * Request toggling the maximized state of the task at the given index. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestToggleMaximized(const QModelIndex &index); + + /** + * Request toggling the keep-above state of the task at the given index. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestToggleKeepAbove(const QModelIndex &index); + + /** + * Request toggling the keep-below state of the task at the given index. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestToggleKeepBelow(const QModelIndex &index); + + /** + * Request toggling the fullscreen state of the task at the given index. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestToggleFullScreen(const QModelIndex &index); + + /** + * Request toggling the shaded state of the task at the given index. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + **/ + void requestToggleShaded(const QModelIndex &index); + + /** + * Request moving the task at the given index to the specified virtual + * desktop. + * + * This is meant for tasks that have an associated window, and may be + * a no-op when there is no window. + * + * @param index An index in this tasks model. + * @param desktop A virtual desktop number. + **/ + void requestVirtualDesktop(const QModelIndex &index, qint32 desktop); + + /** + * Request informing the window manager of new geometry for a visual + * delegate for the task at the given index. The geometry should be in + * screen coordinates. + * + * @param index An index in this tasks model. + * @param geometry Visual delegate geometry in screen coordinates. + * @param delegate The delegate. Implementations are on their own with + * regard to extracting information from this, and should take care to + * reject invalid objects. + **/ + void requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, + QObject *delegate = nullptr); + +private: + class Private; + QScopedPointer d; +}; + +} + +#endif diff --git a/libtaskmanager/launchertasksmodel.cpp b/libtaskmanager/launchertasksmodel.cpp index a3a029da6..6f4d177c1 100644 --- a/libtaskmanager/launchertasksmodel.cpp +++ b/libtaskmanager/launchertasksmodel.cpp @@ -1,286 +1,299 @@ /******************************************************************** Copyright 2016 Eike Hein This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . *********************************************************************/ #include "launchertasksmodel.h" #include "tasktools.h" #include #include #include #include #include #include #include #if HAVE_X11 #include #endif namespace TaskManager { class LauncherTasksModel::Private { public: Private(LauncherTasksModel *q); QList launchers; QHash appDataCache; QTimer sycocaChangeTimer; void init(); AppData appData(const QUrl &url); private: LauncherTasksModel *q; }; LauncherTasksModel::Private::Private(LauncherTasksModel *q) : q(q) { } void LauncherTasksModel::Private::init() { sycocaChangeTimer.setSingleShot(true); sycocaChangeTimer.setInterval(100); QObject::connect(&sycocaChangeTimer, &QTimer::timeout, q, [this]() { if (!launchers.count()) { return; } appDataCache.clear(); // Emit changes of all roles satisfied from app data cache. q->dataChanged(q->index(0, 0), q->index(launchers.count() - 1, 0), QVector{Qt::DisplayRole, Qt::DecorationRole, AbstractTasksModel::AppId, AbstractTasksModel::AppName, AbstractTasksModel::GenericName, AbstractTasksModel::LauncherUrl}); } ); void (KSycoca::*myDatabaseChangeSignal)(const QStringList &) = &KSycoca::databaseChanged; QObject::connect(KSycoca::self(), myDatabaseChangeSignal, q, [this](const QStringList &changedResources) { if (changedResources.contains(QLatin1String("services")) || changedResources.contains(QLatin1String("apps")) || changedResources.contains(QLatin1String("xdgdata-apps"))) { sycocaChangeTimer.start(); } } ); } AppData LauncherTasksModel::Private::appData(const QUrl &url) { if (!appDataCache.contains(url)) { const AppData &data = appDataFromUrl(url, QIcon::fromTheme(QLatin1String("unknown"))); appDataCache.insert(url, data); return data; } return appDataCache.value(url); } LauncherTasksModel::LauncherTasksModel(QObject *parent) : AbstractTasksModel(parent) , d(new Private(this)) { d->init(); } LauncherTasksModel::~LauncherTasksModel() { } QVariant LauncherTasksModel::data(const QModelIndex &index, int role) const { if (!index.isValid() || index.row() >= d->launchers.count()) { return QVariant(); } const QUrl &url = d->launchers.at(index.row()); const AppData &data = d->appData(url); if (role == Qt::DisplayRole) { return data.name; } else if (role == Qt::DecorationRole) { return data.icon; } else if (role == AppId) { return data.id; } else if (role == AppName) { return data.name; } else if (role == GenericName) { return data.genericName; } else if (role == LauncherUrl) { // Take resolved URL from cache. return data.url; } else if (role == IsLauncher) { return true; } else if (role == IsOnAllVirtualDesktops) { return true; } return QVariant(); } int LauncherTasksModel::rowCount(const QModelIndex &parent) const { return parent.isValid() ? 0 : d->launchers.count(); } QStringList LauncherTasksModel::launcherList() const { return QUrl::toStringList(d->launchers); } void LauncherTasksModel::setLauncherList(const QStringList &launchers) { const QList &_urls = QUrl::fromStringList(launchers, QUrl::StrictMode); QList urls; // Reject invalid urls and duplicates. foreach(const QUrl &url, _urls) { if (url.isValid()) { bool dupe = false; foreach(const QUrl &addedUrl, urls) { dupe = launcherUrlsMatch(url, addedUrl, IgnoreQueryItems); } if (!dupe) { urls.append(url); } } } if (d->launchers != urls) { - beginResetModel(); + // Common case optimization: If the list changed but its size + // did not (e.g. due to reordering by a user of this model), + // just clear the caches and announce new data instead of + // resetting. + if (d->launchers.count() == urls.count()) { + d->launchers.clear(); + d->appDataCache.clear(); - d->launchers.clear(); - d->appDataCache.clear(); + d->launchers = urls; - d->launchers = urls; + emit dataChanged(index(0, 0), index(d->launchers.count() - 1, 0)); + } else { + beginResetModel(); - endResetModel(); + d->launchers.clear(); + d->appDataCache.clear(); + + d->launchers = urls; + + endResetModel(); + } emit launcherListChanged(); } } bool LauncherTasksModel::requestAddLauncher(const QUrl &_url) { // isValid() for the passed-in URL might return true if it was // constructed in TolerantMode, but we want to reject invalid URLs. QUrl url(_url.toString(), QUrl::StrictMode); if (url.isEmpty() || !url.isValid()) { return false; } // Reject duplicates. foreach(const QUrl &launcher, d->launchers) { if (launcherUrlsMatch(url, launcher, IgnoreQueryItems)) { return false; } } const int count = d->launchers.count(); beginInsertRows(QModelIndex(), count, count); d->launchers.append(url); endInsertRows(); emit launcherListChanged(); return true; } bool LauncherTasksModel::requestRemoveLauncher(const QUrl &url) { for (int i = 0; i < d->launchers.count(); ++i) { const QUrl &launcher = d->launchers.at(i); if (launcherUrlsMatch(url, launcher, IgnoreQueryItems) || launcherUrlsMatch(url, d->appData(launcher).url, IgnoreQueryItems)) { beginRemoveRows(QModelIndex(), i, i); d->launchers.removeAt(i); d->appDataCache.remove(launcher); endRemoveRows(); emit launcherListChanged(); return true; } } return false; } int LauncherTasksModel::launcherPosition(const QUrl &url) const { for (int i = 0; i < d->launchers.count(); ++i) { if (launcherUrlsMatch(url, d->launchers.at(i), IgnoreQueryItems)) { return i; } } return -1; } void LauncherTasksModel::requestActivate(const QModelIndex &index) { requestNewInstance(index); } void LauncherTasksModel::requestNewInstance(const QModelIndex &index) { if (!index.isValid() || index.model() != this || index.row() < 0 || index.row() >= d->launchers.count()) { return; } const QUrl &url = d->launchers.at(index.row()); quint32 timeStamp = 0; #if HAVE_X11 if (QX11Info::isPlatformX11()) { timeStamp = QX11Info::appUserTime(); } #endif if (url.scheme() == QLatin1String("preferred")) { KService::Ptr service = KService::serviceByStorageId(defaultApplication(url)); if (!service) { return; } new KRun(QUrl::fromLocalFile(service->entryPath()), 0, false, KStartupInfo::createNewStartupIdForTimestamp(timeStamp)); } else { new KRun(url, 0, false, KStartupInfo::createNewStartupIdForTimestamp(timeStamp)); } } } diff --git a/libtaskmanager/tasksmodel.cpp b/libtaskmanager/tasksmodel.cpp index eee94b37c..e84cf4b06 100644 --- a/libtaskmanager/tasksmodel.cpp +++ b/libtaskmanager/tasksmodel.cpp @@ -1,1348 +1,1486 @@ /******************************************************************** Copyright 2016 Eike Hein This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . *********************************************************************/ #include "tasksmodel.h" #include "activityinfo.h" #include "concatenatetasksproxymodel.h" +#include "flattentaskgroupsproxymodel.h" #include "taskfilterproxymodel.h" #include "taskgroupingproxymodel.h" #include "tasktools.h" #include #include "launchertasksmodel.h" #include "waylandtasksmodel.h" #include "startuptasksmodel.h" #if HAVE_X11 #include "xwindowtasksmodel.h" #endif #include #include #include #include #if HAVE_X11 #include #endif #include namespace TaskManager { class TasksModel::Private { public: Private(TasksModel *q); ~Private(); static int instanceCount; static AbstractTasksModel* windowTasksModel; static StartupTasksModel* startupTasksModel; LauncherTasksModel* launcherTasksModel = nullptr; ConcatenateTasksProxyModel* concatProxyModel = nullptr; TaskFilterProxyModel* filterProxyModel = nullptr; TaskGroupingProxyModel* groupingProxyModel = nullptr; + FlattenTaskGroupsProxyModel* flattenGroupsProxyModel = nullptr; + AbstractTasksModelIface *abstractTasksSourceModel = nullptr; bool anyTaskDemandsAttention = false; int launcherCount = 0; int virtualDesktop = -1; int screen = -1; QString activity; SortMode sortMode = SortAlpha; bool separateLaunchers = true; bool launchInPlace = false; bool launcherSortingDirty = false; QList sortedPreFilterRows; QVector sortRowInsertQueue; QHash activityTaskCounts; static ActivityInfo* activityInfo; static int activityInfoUsers; + bool groupInline = false; + int groupingWindowTasksThreshold = -1; + void initModels(); void updateAnyTaskDemandsAttention(); void updateManualSortMap(); - void syncManualSortMapForGroup(const QModelIndex &parent); + void consolidateManualSortMapForGroup(const QModelIndex &groupingProxyIndex); + void updateGroupInline(); QModelIndex preFilterIndex(const QModelIndex &sourceIndex) const; void updateActivityTaskCounts(); void forceResort(); bool lessThan(const QModelIndex &left, const QModelIndex &right, bool sortOnlyLaunchers = false) const; private: TasksModel *q; }; class TasksModel::TasksModelLessThan { public: inline TasksModelLessThan(const QAbstractItemModel *s, TasksModel *p, bool sortOnlyLaunchers) : sourceModel(s), tasksModel(p), sortOnlyLaunchers(sortOnlyLaunchers) {} inline bool operator()(int r1, int r2) const { QModelIndex i1 = sourceModel->index(r1, 0); QModelIndex i2 = sourceModel->index(r2, 0); return tasksModel->d->lessThan(i1, i2, sortOnlyLaunchers); } private: const QAbstractItemModel *sourceModel; const TasksModel *tasksModel; bool sortOnlyLaunchers; }; int TasksModel::Private::instanceCount = 0; AbstractTasksModel* TasksModel::Private::windowTasksModel = nullptr; StartupTasksModel* TasksModel::Private::startupTasksModel = nullptr; ActivityInfo* TasksModel::Private::activityInfo = nullptr; int TasksModel::Private::activityInfoUsers = 0; TasksModel::Private::Private(TasksModel *q) : q(q) { ++instanceCount; } TasksModel::Private::~Private() { --instanceCount; if (sortMode == SortActivity) { --activityInfoUsers; } if (!instanceCount) { delete windowTasksModel; windowTasksModel = nullptr; delete startupTasksModel; startupTasksModel = nullptr; delete activityInfo; activityInfo = nullptr; } } void TasksModel::Private::initModels() { // NOTE: Overview over the entire model chain assembled here: // {X11,Wayland}WindowTasksModel, StartupTasksModel, LauncherTasksModel - // -> ConcatenateTasksProxyModel concatenates them into a single list. - // -> TaskFilterProxyModel filters by state (e.g. virtual desktop). - // -> TaskGroupingProxyModel groups by application (we go from flat list to tree). - // -> TasksModel collapses top-level items into task lifecycle abstraction, sorts. + // -> concatProxyModel concatenates them into a single list. + // -> filterProxyModel filters by state (e.g. virtual desktop). + // -> groupingProxyModel groups by application (we go from flat list to tree). + // -> flattenGroupsProxyModel (optionally, if groupInline == true) flattens groups out. + // -> TasksModel collapses (top-level) items into task lifecycle abstraction; sorts. if (!windowTasksModel && QGuiApplication::platformName().startsWith(QLatin1String("wayland"))) { windowTasksModel = new WaylandTasksModel(); } #if HAVE_X11 if (!windowTasksModel && QX11Info::isPlatformX11()) { windowTasksModel = new XWindowTasksModel(); } #endif QObject::connect(windowTasksModel, &QAbstractItemModel::rowsInserted, q, [this]() { if (sortMode == SortActivity) { updateActivityTaskCounts(); } } ); QObject::connect(windowTasksModel, &QAbstractItemModel::rowsRemoved, q, [this]() { if (sortMode == SortActivity) { updateActivityTaskCounts(); forceResort(); } } ); QObject::connect(windowTasksModel, &QAbstractItemModel::dataChanged, q, [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector &roles) { Q_UNUSED(topLeft) Q_UNUSED(bottomRight) if (sortMode == SortActivity && roles.contains(AbstractTasksModel::Activities)) { updateActivityTaskCounts(); } } ); if (!startupTasksModel) { startupTasksModel = new StartupTasksModel(); } launcherTasksModel = new LauncherTasksModel(q); QObject::connect(launcherTasksModel, &LauncherTasksModel::launcherListChanged, q, &TasksModel::launcherListChanged); QObject::connect(launcherTasksModel, &QAbstractItemModel::rowsInserted, q, &TasksModel::updateLauncherCount); QObject::connect(launcherTasksModel, &QAbstractItemModel::rowsRemoved, q, &TasksModel::updateLauncherCount); QObject::connect(launcherTasksModel, &QAbstractItemModel::modelReset, q, &TasksModel::updateLauncherCount); concatProxyModel = new ConcatenateTasksProxyModel(q); concatProxyModel->addSourceModel(windowTasksModel); concatProxyModel->addSourceModel(startupTasksModel); concatProxyModel->addSourceModel(launcherTasksModel); // If we're in manual sort mode, we need to seed the sort map on pending row // insertions. QObject::connect(concatProxyModel, &QAbstractItemModel::rowsAboutToBeInserted, q, [this](const QModelIndex &parent, int start, int end) { Q_UNUSED(parent) if (sortMode != SortManual) { return; } const int delta = (end - start) + 1; QMutableListIterator it(sortedPreFilterRows); while (it.hasNext()) { it.next(); if (it.value() >= start) { it.setValue(it.value() + delta); } } for (int i = start; i <= end; ++i) { sortedPreFilterRows.append(i); if (0 && !separateLaunchers) { // FIXME TODO: Disable until done. sortRowInsertQueue.append(sortedPreFilterRows.count() - 1); } } } ); // If we're in manual sort mode, we need to update the sort map on row insertions. QObject::connect(concatProxyModel, &QAbstractItemModel::rowsInserted, q, [this](const QModelIndex &parent, int start, int end) { Q_UNUSED(parent) Q_UNUSED(start) Q_UNUSED(end) if (sortMode == SortManual) { updateManualSortMap(); } } ); // If we're in manual sort mode, we need to update the sort map on row removals. QObject::connect(concatProxyModel, &QAbstractItemModel::rowsAboutToBeRemoved, q, [this](const QModelIndex &parent, int first, int last) { Q_UNUSED(parent) if (sortMode != SortManual) { return; } for (int i = first; i <= last; ++i) { sortedPreFilterRows.removeOne(i); } const int delta = (last - first) + 1; QMutableListIterator it(sortedPreFilterRows); while (it.hasNext()) { it.next(); if (it.value() > last) { it.setValue(it.value() - delta); } } } ); filterProxyModel = new TaskFilterProxyModel(q); filterProxyModel->setSourceModel(concatProxyModel); QObject::connect(filterProxyModel, &TaskFilterProxyModel::virtualDesktopChanged, q, &TasksModel::virtualDesktopChanged); QObject::connect(filterProxyModel, &TaskFilterProxyModel::screenChanged, q, &TasksModel::screenChanged); QObject::connect(filterProxyModel, &TaskFilterProxyModel::activityChanged, q, &TasksModel::activityChanged); QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterByVirtualDesktopChanged, q, &TasksModel::filterByVirtualDesktopChanged); QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterByScreenChanged, q, &TasksModel::filterByScreenChanged); QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterByActivityChanged, q, &TasksModel::filterByActivityChanged); QObject::connect(filterProxyModel, &TaskFilterProxyModel::filterNotMinimizedChanged, q, &TasksModel::filterNotMinimizedChanged); groupingProxyModel = new TaskGroupingProxyModel(q); groupingProxyModel->setSourceModel(filterProxyModel); QObject::connect(groupingProxyModel, &TaskGroupingProxyModel::groupModeChanged, q, &TasksModel::groupModeChanged); - QObject::connect(groupingProxyModel, &TaskGroupingProxyModel::windowTasksThresholdChanged, - q, &TasksModel::groupingWindowTasksThresholdChanged); QObject::connect(groupingProxyModel, &TaskGroupingProxyModel::blacklistedAppIdsChanged, q, &TasksModel::groupingAppIdBlacklistChanged); QObject::connect(groupingProxyModel, &TaskGroupingProxyModel::blacklistedLauncherUrlsChanged, q, &TasksModel::groupingLauncherUrlBlacklistChanged); QObject::connect(groupingProxyModel, &QAbstractItemModel::rowsInserted, q, [this](const QModelIndex &parent, int first, int last) { - // We can ignore group members. if (parent.isValid()) { + consolidateManualSortMapForGroup(parent); + + // Existence of a group means everything below this has already been done. return; } for (int i = first; i <= last; ++i) { const QModelIndex &sourceIndex = groupingProxyModel->index(i, 0); const QString &appId = sourceIndex.data(AbstractTasksModel::AppId).toString(); if (sourceIndex.data(AbstractTasksModel::IsDemandingAttention).toBool()) { updateAnyTaskDemandsAttention(); } // When we get a window we have a startup for, cause the startup to be re-filtered. if (sourceIndex.data(AbstractTasksModel::IsWindow).toBool()) { const QString &appName = sourceIndex.data(AbstractTasksModel::AppName).toString(); for (int i = 0; i < startupTasksModel->rowCount(); ++i) { QModelIndex startupIndex = startupTasksModel->index(i, 0); if (appId == startupIndex.data(AbstractTasksModel::AppId).toString() || appName == startupIndex.data(AbstractTasksModel::AppName).toString()) { startupTasksModel->dataChanged(startupIndex, startupIndex); } } } // When we get a window or startup we have a launcher for, cause the launcher to be re-filtered. if (sourceIndex.data(AbstractTasksModel::IsWindow).toBool() || sourceIndex.data(AbstractTasksModel::IsStartup).toBool()) { const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrl).toUrl(); for (int i = 0; i < launcherTasksModel->rowCount(); ++i) { QModelIndex launcherIndex = launcherTasksModel->index(i, 0); const QString &launcherAppId = launcherIndex.data(AbstractTasksModel::AppId).toString(); if ((!appId.isEmpty() && appId == launcherAppId) || (launcherUrl.isValid() && launcherUrlsMatch(launcherUrl, launcherIndex.data(AbstractTasksModel::LauncherUrl).toUrl(), IgnoreQueryItems))) { launcherTasksModel->dataChanged(launcherIndex, launcherIndex); } } } } } ); // When a window is removed, we have to trigger a re-filter of matching launchers. QObject::connect(groupingProxyModel, &QAbstractItemModel::rowsAboutToBeRemoved, q, [this](const QModelIndex &parent, int first, int last) { // We can ignore group members. if (parent.isValid()) { return; } for (int i = first; i <= last; ++i) { const QModelIndex &sourceIndex = groupingProxyModel->index(i, 0); if (sourceIndex.data(AbstractTasksModel::IsDemandingAttention).toBool()) { updateAnyTaskDemandsAttention(); } if (!sourceIndex.data(AbstractTasksModel::IsWindow).toBool()) { continue; } const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrl).toUrl(); if (!launcherUrl.isEmpty() && launcherUrl.isValid()) { const int pos = launcherTasksModel->launcherPosition(launcherUrl); if (pos != -1) { QModelIndex launcherIndex = launcherTasksModel->index(pos, 0); QMetaObject::invokeMethod(launcherTasksModel, "dataChanged", Qt::QueuedConnection, Q_ARG(QModelIndex, launcherIndex), Q_ARG(QModelIndex, launcherIndex)); QMetaObject::invokeMethod(q, "updateLauncherCount", Qt::QueuedConnection); } } } } ); // Update anyTaskDemandsAttention on source data changes. QObject::connect(groupingProxyModel, &QAbstractItemModel::dataChanged, q, [this](const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector &roles) { Q_UNUSED(bottomRight) // We can ignore group members. - if (topLeft.isValid()) { + if (topLeft.parent().isValid()) { return; } if (roles.isEmpty() || roles.contains(AbstractTasksModel::IsDemandingAttention)) { updateAnyTaskDemandsAttention(); } } ); // Update anyTaskDemandsAttention on source model resets. QObject::connect(groupingProxyModel, &QAbstractItemModel::modelReset, q, [this]() { updateAnyTaskDemandsAttention(); } ); + abstractTasksSourceModel = groupingProxyModel; q->setSourceModel(groupingProxyModel); - QObject::connect(q, &QAbstractItemModel::rowsInserted, q, - [this](const QModelIndex &parent, int first, int last) { - Q_UNUSED(first) - Q_UNUSED(last) - - q->countChanged(); - - // If we're in manual sort mode, we need to consolidate new children - // of a group in the manual sort map to prepare for when a group - // gets dissolved. - // This is done after we've already had a chance to sort the new child - // in alphabetically in this proxy. - if (sortMode == SortManual && parent.isValid()) { - syncManualSortMapForGroup(parent); - } - } - ); - - + QObject::connect(q, &QAbstractItemModel::rowsInserted, q, &TasksModel::countChanged); QObject::connect(q, &QAbstractItemModel::rowsRemoved, q, &TasksModel::countChanged); QObject::connect(q, &QAbstractItemModel::modelReset, q, &TasksModel::countChanged); } void TasksModel::Private::updateAnyTaskDemandsAttention() { bool taskFound = false; for (int i = 0; i < groupingProxyModel->rowCount(); ++i) { if (groupingProxyModel->index(i, 0).data(AbstractTasksModel::IsDemandingAttention).toBool()) { taskFound = true; break; } } if (taskFound != anyTaskDemandsAttention) { anyTaskDemandsAttention = taskFound; q->anyTaskDemandsAttentionChanged(); } } void TasksModel::Private::updateManualSortMap() { // Empty map; full sort. if (sortedPreFilterRows.isEmpty()) { sortedPreFilterRows.reserve(concatProxyModel->rowCount()); for (int i = 0; i < concatProxyModel->rowCount(); ++i) { sortedPreFilterRows.append(i); } // Full sort. TasksModelLessThan lt(concatProxyModel, q, false); std::stable_sort(sortedPreFilterRows.begin(), sortedPreFilterRows.end(), lt); + // Consolidate sort map entries for groups. + if (q->groupMode() != GroupDisabled) { + for (int i = 0; i < groupingProxyModel->rowCount(); ++i) { + const QModelIndex &groupingIndex = groupingProxyModel->index(i, 0); + + if (groupingIndex.data(AbstractTasksModel::IsGroupParent).toBool()) { + consolidateManualSortMapForGroup(groupingIndex); + } + } + } + return; } // Existing map; check whether launchers need sorting by launcher list position. if (separateLaunchers) { // Sort only launchers. TasksModelLessThan lt(concatProxyModel, q, true); std::stable_sort(sortedPreFilterRows.begin(), sortedPreFilterRows.end(), lt); // Otherwise process any entries in the insert queue and move them intelligently // in the sort map. } else if (0) { // FIXME TODO: Disable until done. while (sortRowInsertQueue.count()) { const int row = sortRowInsertQueue.takeFirst(); const QModelIndex &idx = concatProxyModel->index(sortedPreFilterRows.at(row), 0); // New launcher tasks go after the last launcher in the proxy, or to the start of // the map if there are none. if (idx.data(AbstractTasksModel::IsLauncher).toBool()) { int insertPos = 0; for (int i = 0; i < row; ++i) { const QModelIndex &proxyIdx = q->index(i, 0); if (proxyIdx.data(AbstractTasksModel::IsLauncher).toBool()) { insertPos = i + 1; } else { break; } } sortedPreFilterRows.move(row, insertPos); // Anything else goes after its right-most app sibling, if any. If there are // none it just stays put. } else { for (int i = (row - 1); i >= 0; --i) { const QModelIndex &concatProxyIndex = concatProxyModel->index(sortedPreFilterRows.at(i), 0); if (appsMatch(concatProxyIndex, idx)) { sortedPreFilterRows.move(row, i + 1); break; } } } } } } -void TasksModel::Private::syncManualSortMapForGroup(const QModelIndex &parent) +void TasksModel::Private::consolidateManualSortMapForGroup(const QModelIndex &groupingProxyIndex) +{ + // Consolidates sort map entries for a group's items to be contiguous + // after the group's first item and the same order as in groupingProxyModel. + + const int childCount = groupingProxyModel->rowCount(groupingProxyIndex); + + if (!childCount) { + return; + } + + const QModelIndex &leader = groupingProxyIndex.child(0, 0); + const QModelIndex &preFilterLeader = filterProxyModel->mapToSource(groupingProxyModel->mapToSource(leader)); + + // We're moving the trailing children to the sort map position of + // the first child, so we're skipping the first child. + for (int i = 1; i < childCount; ++i) { + const QModelIndex &child = groupingProxyIndex.child(i, 0); + const QModelIndex &preFilterChild = filterProxyModel->mapToSource(groupingProxyModel->mapToSource(child)); + const int leaderPos = sortedPreFilterRows.indexOf(preFilterLeader.row()); + const int childPos = sortedPreFilterRows.indexOf(preFilterChild.row()); + const int insertPos = (leaderPos + i) + ((leaderPos + i) > childPos ? -1 : 0); + sortedPreFilterRows.move(childPos, insertPos); + } +} + +void TasksModel::Private::updateGroupInline() { - const int childCount = q->rowCount(parent); + if (q->groupMode() != GroupDisabled && groupInline) { + if (flattenGroupsProxyModel) { + return; + } - if (childCount != -1) { - const QModelIndex &preFilterParent = preFilterIndex(q->mapToSource(parent)); + // Exempting tasks which demand attention from grouping is not + // necessary when all group children are shown inline anyway + // and would interfere with our sort-tasks-together goals. + groupingProxyModel->setGroupDemandingAttention(true); - // We're moving the trailing children to the sort map position of - // the first child, so we're skipping the first child. - for (int i = 1; i < childCount; ++i) { - const QModelIndex &preFilterChildIndex = preFilterIndex(q->mapToSource(parent.child(i, 0))); - const int childSortIndex = sortedPreFilterRows.indexOf(preFilterChildIndex.row()); - const int parentSortIndex = sortedPreFilterRows.indexOf(preFilterParent.row()); - const int insertPos = (parentSortIndex + i) + ((parentSortIndex + i) > childSortIndex ? -1 : 0); - sortedPreFilterRows.move(childSortIndex, insertPos); + // Likewise, ignore the window tasks threshold when making + // grouping decisions. + groupingProxyModel->setWindowTasksThreshold(-1); + + flattenGroupsProxyModel = new FlattenTaskGroupsProxyModel(q); + flattenGroupsProxyModel->setSourceModel(groupingProxyModel); + + abstractTasksSourceModel = flattenGroupsProxyModel; + q->setSourceModel(flattenGroupsProxyModel); + + if (sortMode == SortManual) { + forceResort(); + } + } else { + if (!flattenGroupsProxyModel) { + return; + } + + groupingProxyModel->setGroupDemandingAttention(false); + groupingProxyModel->setWindowTasksThreshold(groupingWindowTasksThreshold); + + abstractTasksSourceModel = groupingProxyModel; + q->setSourceModel(groupingProxyModel); + + delete flattenGroupsProxyModel; + flattenGroupsProxyModel = nullptr; + + if (sortMode == SortManual) { + forceResort(); } } } QModelIndex TasksModel::Private::preFilterIndex(const QModelIndex &sourceIndex) const { - return filterProxyModel->mapToSource(groupingProxyModel->mapToSource(sourceIndex)); + // Only in inline grouping mode, we have an additional proxy layer. + if (flattenGroupsProxyModel) { + return filterProxyModel->mapToSource(groupingProxyModel->mapToSource(flattenGroupsProxyModel->mapToSource(sourceIndex))); + } else { + return filterProxyModel->mapToSource(groupingProxyModel->mapToSource(sourceIndex)); + } } void TasksModel::Private::updateActivityTaskCounts() { // Collects the number of window tasks on each activity. activityTaskCounts.clear(); if (!windowTasksModel || !activityInfo) { return; } foreach(const QString &activity, activityInfo->runningActivities()) { activityTaskCounts.insert(activity, 0); } for (int i = 0; i < windowTasksModel->rowCount(); ++i) { const QModelIndex &windowIndex = windowTasksModel->index(i, 0); const QStringList &activities = windowIndex.data(AbstractTasksModel::Activities).toStringList(); if (activities.isEmpty()) { QMutableHashIterator i(activityTaskCounts); while (i.hasNext()) { i.next(); i.setValue(i.value() + 1); } } else { foreach(const QString &activity, activities) { ++activityTaskCounts[activity]; } } } } void TasksModel::Private::forceResort() { // HACK: This causes QSortFilterProxyModel to run all rows through // our lessThan() implementation again. q->setDynamicSortFilter(false); q->setDynamicSortFilter(true); } bool TasksModel::Private::lessThan(const QModelIndex &left, const QModelIndex &right, bool sortOnlyLaunchers) const { // Launcher tasks go first. // When launchInPlace is enabled, startup and window tasks are sorted // as the launchers they replace (see also move()). if (left.data(AbstractTasksModel::IsLauncher).toBool() && right.data(AbstractTasksModel::IsLauncher).toBool()) { return (left.row() < right.row()); } else if (left.data(AbstractTasksModel::IsLauncher).toBool() && !right.data(AbstractTasksModel::IsLauncher).toBool()) { if (launchInPlace) { const int rightPos = q->launcherPosition(right.data(AbstractTasksModel::LauncherUrl).toUrl()); if (rightPos != -1) { return (left.row() < rightPos); } } return true; } else if (!left.data(AbstractTasksModel::IsLauncher).toBool() && right.data(AbstractTasksModel::IsLauncher).toBool()) { if (launchInPlace) { const int leftPos = q->launcherPosition(left.data(AbstractTasksModel::LauncherUrl).toUrl()); if (leftPos != -1) { return (leftPos < right.row()); } } return false; } else if (launchInPlace) { const int leftPos = q->launcherPosition(left.data(AbstractTasksModel::LauncherUrl).toUrl()); const int rightPos = q->launcherPosition(right.data(AbstractTasksModel::LauncherUrl).toUrl()); if (leftPos != -1 && rightPos != -1) { return (leftPos < rightPos); } else if (leftPos != -1 && rightPos == -1) { return true; } else if (leftPos == -1 && rightPos != -1) { return false; } } // If told to stop after launchers we fall through to the existing map if it exists. if (sortOnlyLaunchers && !sortedPreFilterRows.isEmpty()) { return (sortedPreFilterRows.indexOf(left.row()) < sortedPreFilterRows.indexOf(right.row())); } // Sort other cases by sort mode. switch (sortMode) { case SortVirtualDesktop: { const QVariant &leftDesktopVariant = left.data(AbstractTasksModel::VirtualDesktop); bool leftOk = false; const int leftDesktop = leftDesktopVariant.toInt(&leftOk); const QVariant &rightDesktopVariant = right.data(AbstractTasksModel::VirtualDesktop); bool rightOk = false; const int rightDesktop = rightDesktopVariant.toInt(&rightOk); if (leftOk && rightOk && (leftDesktop != rightDesktop)) { return (leftDesktop < rightDesktop); } else if (leftOk && !rightOk) { return false; } else if (!leftOk && rightOk) { return true; } } case SortActivity: { // updateActivityTaskCounts() counts the number of window tasks on each // activity. This will sort tasks by comparing a cumulative score made // up of the task counts for each acvtivity a task is assigned to, and // otherwise fall through to alphabetical sorting. int leftScore = -1; int rightScore = -1; const QStringList &leftActivities = left.data(AbstractTasksModel::Activities).toStringList(); if (!leftActivities.isEmpty()) { foreach(const QString& activity, leftActivities) { leftScore += activityTaskCounts[activity]; } } const QStringList &rightActivities = right.data(AbstractTasksModel::Activities).toStringList(); if (!rightActivities.isEmpty()) { foreach(const QString& activity, rightActivities) { rightScore += activityTaskCounts[activity]; } } if (leftScore == -1 || rightScore == -1) { const QList &counts = activityTaskCounts.values(); const int sumScore = std::accumulate(counts.begin(), counts.end(), 0); if (leftScore == -1) { leftScore = sumScore; } if (rightScore == -1) { rightScore = sumScore; } } if (leftScore != rightScore) { return (leftScore > rightScore); } } // Fall through to source order if sorting is disabled or manual, or alphabetical by app name otherwise. default: { if (sortMode == SortDisabled) { return (left.row() < right.row()); } else { const QString &leftSortString = left.data(AbstractTasksModel::AppName).toString() + left.data(Qt::DisplayRole).toString(); const QString &rightSortString = right.data(AbstractTasksModel::AppName).toString() + right.data(Qt::DisplayRole).toString(); return (leftSortString.localeAwareCompare(rightSortString) < 0); } } } } TasksModel::TasksModel(QObject *parent) : QSortFilterProxyModel(parent) , d(new Private(this)) { d->initModels(); // Start sorting. sort(0); } TasksModel::~TasksModel() { } QHash TasksModel::roleNames() const { if (d->windowTasksModel) { return d->windowTasksModel->roleNames(); } return QHash(); } int TasksModel::rowCount(const QModelIndex &parent) const { return QSortFilterProxyModel::rowCount(parent); } void TasksModel::updateLauncherCount() { QList launchers = QUrl::fromStringList(d->launcherTasksModel->launcherList()); - for(int i = 0; i < d->filterProxyModel->rowCount(); ++i) { + for (int i = 0; i < d->filterProxyModel->rowCount(); ++i) { const QModelIndex &filterIndex = d->filterProxyModel->index(i, 0); if (!filterIndex.data(AbstractTasksModel::IsLauncher).toBool()) { - // TODO: It would be much faster if we didn't ask for a URL with serialized PNG data in it, just to discard it a few lines below + // TODO: It would be much faster if we didn't ask for a URL with serialized PNG + // data in it, just to discard it a few lines below. const QUrl &launcherUrl = filterIndex.data(AbstractTasksModel::LauncherUrl).toUrl(); QMutableListIterator it(launchers); while(it.hasNext()) { it.next(); if (launcherUrlsMatch(launcherUrl, it.value(), IgnoreQueryItems)) { it.remove(); } } } } if (d->launcherCount != launchers.count()) { d->launcherCount = launchers.count(); emit launcherCountChanged(); } } int TasksModel::launcherCount() const { return d->launcherCount; } bool TasksModel::anyTaskDemandsAttention() const { return d->anyTaskDemandsAttention; } int TasksModel::virtualDesktop() const { return d->filterProxyModel->virtualDesktop(); } void TasksModel::setVirtualDesktop(int virtualDesktop) { d->filterProxyModel->setVirtualDesktop(virtualDesktop); } int TasksModel::screen() const { return d->filterProxyModel->screen(); } void TasksModel::setScreen(int screen) { d->filterProxyModel->setScreen(screen); } QString TasksModel::activity() const { return d->filterProxyModel->activity(); } void TasksModel::setActivity(const QString &activity) { d->filterProxyModel->setActivity(activity); } bool TasksModel::filterByVirtualDesktop() const { return d->filterProxyModel->filterByVirtualDesktop(); } void TasksModel::setFilterByVirtualDesktop(bool filter) { d->filterProxyModel->setFilterByVirtualDesktop(filter); } bool TasksModel::filterByScreen() const { return d->filterProxyModel->filterByScreen(); } void TasksModel::setFilterByScreen(bool filter) { d->filterProxyModel->setFilterByScreen(filter); } bool TasksModel::filterByActivity() const { return d->filterProxyModel->filterByActivity(); } void TasksModel::setFilterByActivity(bool filter) { d->filterProxyModel->setFilterByActivity(filter); } bool TasksModel::filterNotMinimized() const { return d->filterProxyModel->filterNotMinimized(); } void TasksModel::setFilterNotMinimized(bool filter) { d->filterProxyModel->setFilterNotMinimized(filter); } TasksModel::SortMode TasksModel::sortMode() const { return d->sortMode; } void TasksModel::setSortMode(SortMode mode) { if (d->sortMode != mode) { if (mode == SortManual) { d->updateManualSortMap(); } else if (d->sortMode == SortManual) { d->sortedPreFilterRows.clear(); } if (mode == SortActivity) { if (!d->activityInfo) { d->activityInfo = new ActivityInfo(); } ++d->activityInfoUsers; d->updateActivityTaskCounts(); setSortRole(AbstractTasksModel::Activities); } else if (d->sortMode == SortActivity) { --d->activityInfoUsers; if (!d->activityInfoUsers) { delete d->activityInfo; d->activityInfo = nullptr; } d->activityTaskCounts.clear(); setSortRole(Qt::DisplayRole); } d->sortMode = mode; d->forceResort(); emit sortModeChanged(); } } bool TasksModel::separateLaunchers() const { return d->separateLaunchers; } void TasksModel::setSeparateLaunchers(bool separate) { return; // FIXME TODO: Disable until done. if (d->separateLaunchers != separate) { d->separateLaunchers = separate; + d->updateManualSortMap(); d->forceResort(); emit separateLaunchersChanged(); } } bool TasksModel::launchInPlace() const { return d->launchInPlace; } void TasksModel::setLaunchInPlace(bool launchInPlace) { if (d->launchInPlace != launchInPlace) { d->launchInPlace = launchInPlace; d->forceResort(); emit launchInPlaceChanged(); } } TasksModel::GroupMode TasksModel::groupMode() const { if (!d->groupingProxyModel) { return GroupDisabled; } return d->groupingProxyModel->groupMode(); } void TasksModel::setGroupMode(GroupMode mode) { if (d->groupingProxyModel) { + if (mode == GroupDisabled && d->flattenGroupsProxyModel) { + d->flattenGroupsProxyModel->setSourceModel(nullptr); + } + d->groupingProxyModel->setGroupMode(mode); + d->updateGroupInline(); } } -int TasksModel::groupingWindowTasksThreshold() const +bool TasksModel::groupInline() const { - if (!d->groupingProxyModel) { - return -1; + return d->groupInline; +} + +void TasksModel::setGroupInline(bool groupInline) +{ + if (d->groupInline != groupInline) { + d->groupInline = groupInline; + + d->updateGroupInline(); + + emit groupInlineChanged(); } +} - return d->groupingProxyModel->windowTasksThreshold(); +int TasksModel::groupingWindowTasksThreshold() const +{ + return d->groupingWindowTasksThreshold; } void TasksModel::setGroupingWindowTasksThreshold(int threshold) { - if (d->groupingProxyModel) { - d->groupingProxyModel->setWindowTasksThreshold(threshold); + if (d->groupingWindowTasksThreshold != threshold) { + d->groupingWindowTasksThreshold = threshold; + + if (!d->groupInline && d->groupingProxyModel) { + d->groupingProxyModel->setWindowTasksThreshold(threshold); + } + + emit groupingWindowTasksThresholdChanged(); } } QStringList TasksModel::groupingAppIdBlacklist() const { if (!d->groupingProxyModel) { return QStringList(); } return d->groupingProxyModel->blacklistedAppIds(); } void TasksModel::setGroupingAppIdBlacklist(const QStringList &list) { if (d->groupingProxyModel) { d->groupingProxyModel->setBlacklistedAppIds(list); } } QStringList TasksModel::groupingLauncherUrlBlacklist() const { if (!d->groupingProxyModel) { return QStringList(); } return d->groupingProxyModel->blacklistedLauncherUrls(); } void TasksModel::setGroupingLauncherUrlBlacklist(const QStringList &list) { if (d->groupingProxyModel) { d->groupingProxyModel->setBlacklistedLauncherUrls(list); } } QStringList TasksModel::launcherList() const { if (d->launcherTasksModel) { return d->launcherTasksModel->launcherList(); } return QStringList(); } void TasksModel::setLauncherList(const QStringList &launchers) { if (d->launcherTasksModel) { d->launcherTasksModel->setLauncherList(launchers); } } bool TasksModel::requestAddLauncher(const QUrl &url) { if (d->launcherTasksModel) { bool added = d->launcherTasksModel->requestAddLauncher(url); // If using manual sorting and launch-in-place sorting, we need // to trigger a sort map update to move any window tasks to their // launcher position now. if (added && d->sortMode == SortManual && (d->launchInPlace || !d->separateLaunchers)) { d->updateManualSortMap(); d->forceResort(); } return added; } return false; } bool TasksModel::requestRemoveLauncher(const QUrl &url) { if (d->launcherTasksModel) { return d->launcherTasksModel->requestRemoveLauncher(url); } return false; } int TasksModel::launcherPosition(const QUrl &url) const { if (d->launcherTasksModel) { return d->launcherTasksModel->launcherPosition(url); } return -1; } void TasksModel::requestActivate(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestActivate(mapToSource(index)); + d->abstractTasksSourceModel->requestActivate(mapToSource(index)); } } void TasksModel::requestNewInstance(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestNewInstance(mapToSource(index)); + d->abstractTasksSourceModel->requestNewInstance(mapToSource(index)); } } void TasksModel::requestClose(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestClose(mapToSource(index)); + d->abstractTasksSourceModel->requestClose(mapToSource(index)); } } void TasksModel::requestMove(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestMove(mapToSource(index)); + d->abstractTasksSourceModel->requestMove(mapToSource(index)); } } void TasksModel::requestResize(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestResize(mapToSource(index)); + d->abstractTasksSourceModel->requestResize(mapToSource(index)); } } void TasksModel::requestToggleMinimized(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestToggleMinimized(mapToSource(index)); + d->abstractTasksSourceModel->requestToggleMinimized(mapToSource(index)); } } void TasksModel::requestToggleMaximized(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestToggleMaximized(mapToSource(index)); + d->abstractTasksSourceModel->requestToggleMaximized(mapToSource(index)); } } void TasksModel::requestToggleKeepAbove(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestToggleKeepAbove(mapToSource(index)); + d->abstractTasksSourceModel->requestToggleKeepAbove(mapToSource(index)); } } void TasksModel::requestToggleKeepBelow(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestToggleKeepBelow(mapToSource(index)); + d->abstractTasksSourceModel->requestToggleKeepBelow(mapToSource(index)); } } void TasksModel::requestToggleFullScreen(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestToggleFullScreen(mapToSource(index)); + d->abstractTasksSourceModel->requestToggleFullScreen(mapToSource(index)); } } void TasksModel::requestToggleShaded(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestToggleShaded(mapToSource(index)); + d->abstractTasksSourceModel->requestToggleShaded(mapToSource(index)); } } void TasksModel::requestVirtualDesktop(const QModelIndex &index, qint32 desktop) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestVirtualDesktop(mapToSource(index), desktop); + d->abstractTasksSourceModel->requestVirtualDesktop(mapToSource(index), desktop); } } void TasksModel::requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, QObject *delegate) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestPublishDelegateGeometry(mapToSource(index), geometry, delegate); + d->abstractTasksSourceModel->requestPublishDelegateGeometry(mapToSource(index), geometry, delegate); } } void TasksModel::requestToggleGrouping(const QModelIndex &index) { if (index.isValid() && index.model() == this) { - d->groupingProxyModel->requestToggleGrouping(mapToSource(index)); + const QModelIndex &target = (d->flattenGroupsProxyModel + ? d->flattenGroupsProxyModel->mapToSource(mapToSource(index)) : mapToSource(index)); + d->groupingProxyModel->requestToggleGrouping(target); } } bool TasksModel::move(int row, int newPos) { if (d->sortMode != SortManual || row == newPos || newPos < 0 || newPos >= rowCount()) { return false; } const QModelIndex &idx = index(row, 0); bool isLauncherMove = false; // Figure out if we're moving a launcher so we can run barrier checks. if (idx.isValid()) { if (idx.data(AbstractTasksModel::IsLauncher).toBool()) { isLauncherMove = true; // When using launch-in-place sorting, launcher-backed window tasks act as launchers. } else if ((d->launchInPlace || !d->separateLaunchers) && idx.data(AbstractTasksModel::IsWindow).toBool()) { const QUrl &launcherUrl = idx.data(AbstractTasksModel::LauncherUrl).toUrl(); const int launcherPos = launcherPosition(launcherUrl); if (launcherPos != -1) { isLauncherMove = true; } } } else { return false; } if (d->separateLaunchers) { const int firstTask = (d->launchInPlace ? d->launcherTasksModel->rowCount() : launcherCount()); // Don't allow launchers to be moved past the last launcher. if (isLauncherMove && newPos >= firstTask) { return false; } // Don't allow tasks to be moved into the launchers. if (!isLauncherMove && newPos < firstTask) { return false; } } - beginMoveRows(QModelIndex(), row, row, QModelIndex(), (newPos >row) ? newPos + 1 : newPos); + // Treat flattened-out groups as single items. + if (d->flattenGroupsProxyModel) { + QModelIndex groupingRowIndex = d->flattenGroupsProxyModel->mapToSource(mapToSource(index(row, 0))); + const QModelIndex &groupingRowIndexParent = groupingRowIndex.parent(); + QModelIndex groupingNewPosIndex = d->flattenGroupsProxyModel->mapToSource(mapToSource(index(newPos, 0))); + const QModelIndex &groupingNewPosIndexParent = groupingNewPosIndex.parent(); + + // Disallow moves within a flattened-out group (TODO: for now, anyway). + if (groupingRowIndexParent.isValid() + && (groupingRowIndexParent == groupingNewPosIndex + || groupingRowIndexParent == groupingNewPosIndexParent)) { + return false; + } + + int offset = 0; + int extraChildCount = 0; + + if (groupingRowIndexParent.isValid()) { + offset = groupingRowIndex.row(); + extraChildCount = d->groupingProxyModel->rowCount(groupingRowIndexParent) - 1; + groupingRowIndex = groupingRowIndexParent; + } + + if (groupingNewPosIndexParent.isValid()) { + groupingNewPosIndex = groupingNewPosIndexParent; + } + + beginMoveRows(QModelIndex(), (row - offset), (row - offset) + extraChildCount, + QModelIndex(), (newPos > row) ? newPos + 1 : newPos); + + row = d->sortedPreFilterRows.indexOf(d->filterProxyModel->mapToSource(d->groupingProxyModel->mapToSource(groupingRowIndex)).row()); + newPos = d->sortedPreFilterRows.indexOf(d->filterProxyModel->mapToSource(d->groupingProxyModel->mapToSource(groupingNewPosIndex)).row()); + + // Update sort mappings. + d->sortedPreFilterRows.move(row, newPos); - // Translate to sort map indices. - const QModelIndex &rowIndex = index(row, 0); - const QModelIndex &preFilterRowIndex = d->preFilterIndex(mapToSource(rowIndex)); - row = d->sortedPreFilterRows.indexOf(preFilterRowIndex.row()); - newPos = d->sortedPreFilterRows.indexOf(d->preFilterIndex(mapToSource(index(newPos, 0))).row()); + if (groupingRowIndexParent.isValid()) { + d->consolidateManualSortMapForGroup(groupingRowIndexParent); + } + + if (groupingNewPosIndexParent.isValid()) { + d->consolidateManualSortMapForGroup(groupingNewPosIndexParent); + } + + endMoveRows(); + } else { + beginMoveRows(QModelIndex(), row, row, QModelIndex(), (newPos >row) ? newPos + 1 : newPos); - // Update sort mapping. - d->sortedPreFilterRows.move(row, newPos); + // Translate to sort map indices. + const QModelIndex &groupingRowIndex = mapToSource(index(row, 0)); + const QModelIndex &preFilterRowIndex = d->preFilterIndex(groupingRowIndex); + row = d->sortedPreFilterRows.indexOf(preFilterRowIndex.row()); + newPos = d->sortedPreFilterRows.indexOf(d->preFilterIndex(mapToSource(index(newPos, 0))).row()); - endMoveRows(); + // Update sort mapping. + d->sortedPreFilterRows.move(row, newPos); - // Move children along with the group. - // This can be safely done after the row move transaction as the sort - // map isn't consulted for rows below the top level. - if (groupMode() != GroupDisabled && rowCount(rowIndex)) { - d->syncManualSortMapForGroup(rowIndex); + // If we moved a group parent, consolidate sort map for children. + if (groupMode() != GroupDisabled && d->groupingProxyModel->rowCount(groupingRowIndex)) { + d->consolidateManualSortMapForGroup(groupingRowIndex); + } + + endMoveRows(); } // Resort. d->forceResort(); // Setup for syncLaunchers(). d->launcherSortingDirty = isLauncherMove; return true; } void TasksModel::syncLaunchers() { // Writes the launcher order exposed through the model back to the launcher // tasks model, committing any move() operations to persistent state. if (!d->launcherTasksModel || !d->launcherSortingDirty) { return; } QMap sortedLaunchers; foreach(const QUrl &launcherUrl, launcherList()) { int row = -1; for (int i = 0; i < rowCount(); ++i) { const QUrl &rowLauncherUrl = index(i, 0).data(AbstractTasksModel::LauncherUrl).toUrl(); if (launcherUrlsMatch(launcherUrl, rowLauncherUrl, IgnoreQueryItems)) { row = i; break; } } if (row != -1) { sortedLaunchers.insert(row, launcherUrl); } } setLauncherList(QUrl::toStringList(sortedLaunchers.values())); d->launcherSortingDirty = false; + + d->updateManualSortMap(); + d->forceResort(); } QModelIndex TasksModel::activeTask() const { for (int i = 0; i < rowCount(); ++i) { const QModelIndex &idx = index(i, 0); if (idx.data(AbstractTasksModel::IsActive).toBool()) { if (groupMode() != GroupDisabled && rowCount(idx)) { for (int j = 0; j < rowCount(idx); ++j) { const QModelIndex &child = idx.child(j, 0); if (child.data(AbstractTasksModel::IsActive).toBool()) { return child; } } } else { return idx; } } } return QModelIndex(); } QModelIndex TasksModel::makeModelIndex(int row, int childRow) const { if (row < 0 || row >= rowCount()) { return QModelIndex(); } const QModelIndex &parent = index(row, 0); if (childRow == -1) { return index(row, 0); } else { const QModelIndex &parent = index(row, 0); if (childRow < rowCount(parent)) { return parent.child(childRow, 0); } } return QModelIndex(); } bool TasksModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const { - // All our filtering occurs at the top-level; group children always go through. + // All our filtering occurs at the top-level; anything below always + // goes through. if (sourceParent.isValid()) { return true; } const QModelIndex &sourceIndex = sourceModel()->index(sourceRow, 0); + + // In inline grouping mode, filter out group parents. + if (d->flattenGroupsProxyModel && sourceIndex.data(AbstractTasksModel::IsGroupParent).toBool()) { + return false; + } + const QString &appId = sourceIndex.data(AbstractTasksModel::AppId).toString(); const QString &appName = sourceIndex.data(AbstractTasksModel::AppName).toString(); // Filter startup tasks we already have a window task for. if (sourceIndex.data(AbstractTasksModel::IsStartup).toBool()) { for (int i = 0; i < d->windowTasksModel->rowCount(); ++i) { const QModelIndex &windowIndex = d->windowTasksModel->index(i, 0); if (appId == windowIndex.data(AbstractTasksModel::AppId).toString() || appName == windowIndex.data(AbstractTasksModel::AppName).toString()) { return false; } } } // Filter launcher tasks we already have a startup or window task for (that // got through filtering). if (sourceIndex.data(AbstractTasksModel::IsLauncher).toBool()) { const QUrl &launcherUrl = sourceIndex.data(AbstractTasksModel::LauncherUrl).toUrl(); for (int i = 0; i < d->filterProxyModel->rowCount(); ++i) { const QModelIndex &filteredIndex = d->filterProxyModel->index(i, 0); if (!filteredIndex.data(AbstractTasksModel::IsWindow).toBool() && !filteredIndex.data(AbstractTasksModel::IsStartup).toBool()) { continue; } const QString &filteredAppId = filteredIndex.data(AbstractTasksModel::AppId).toString(); if ((!appId.isEmpty() && appId == filteredAppId) || (launcherUrl.isValid() && launcherUrlsMatch(launcherUrl, filteredIndex.data(AbstractTasksModel::LauncherUrl).toUrl(), IgnoreQueryItems))) { - // TODO: Do this outside of filterAcceptsRow, based on notification that something changed + // TODO: Do this outside of filterAcceptsRow, based on notification that something changed. QMetaObject::invokeMethod(const_cast(this), "updateLauncherCount", Qt::QueuedConnection); - return false; } } } return true; } bool TasksModel::lessThan(const QModelIndex &left, const QModelIndex &right) const { - // In manual sort mode we sort top-level items by referring to a map we keep. - // Insertions into the map are placed using a combination of Private::lessThan - // and simple append behavior. Child items are sorted alphabetically. - if (d->sortMode == SortManual && !left.parent().isValid() && !right.parent().isValid()) { + // In manual sort mode, sort by map. + if (d->sortMode == SortManual) { return (d->sortedPreFilterRows.indexOf(d->preFilterIndex(left).row()) < d->sortedPreFilterRows.indexOf(d->preFilterIndex(right).row())); } return d->lessThan(left, right); } } diff --git a/libtaskmanager/tasksmodel.h b/libtaskmanager/tasksmodel.h index df3ded0dc..dfddf81b3 100644 --- a/libtaskmanager/tasksmodel.h +++ b/libtaskmanager/tasksmodel.h @@ -1,704 +1,744 @@ /******************************************************************** Copyright 2016 Eike Hein This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . *********************************************************************/ #ifndef TASKSMODEL_H #define TASKSMODEL_H #include #include "abstracttasksmodeliface.h" #include "taskmanager_export.h" namespace TaskManager { /** * @short A unified tasks model. * * This model presents tasks sourced from supplied launcher URLs, startup * notification data and window data retrieved from the windowing server * the host process is connected to. The underlying windowing system is * abstracted away. * * The source data is abstracted into a unified lifecycle for tasks * suitable for presentation in a user interface. * * Matching startup and window tasks replace launcher tasks. Startup * tasks are omitted when matching window tasks exist. Tasks that desire * not to be shown in a user interface are omitted. * * Tasks may be filtered, sorted or grouped by setting properties on the * model. * * Tasks may be interacted with by calling methods on the model. * * @author Eike Hein **/ class TASKMANAGER_EXPORT TasksModel : public QSortFilterProxyModel, public AbstractTasksModelIface { Q_OBJECT Q_ENUMS(SortMode) Q_ENUMS(GroupMode) Q_PROPERTY(int count READ rowCount NOTIFY countChanged) Q_PROPERTY(int launcherCount READ launcherCount NOTIFY launcherCountChanged) Q_PROPERTY(QStringList launcherList READ launcherList WRITE setLauncherList NOTIFY launcherListChanged) Q_PROPERTY(bool anyTaskDemandsAttention READ anyTaskDemandsAttention NOTIFY anyTaskDemandsAttentionChanged) Q_PROPERTY(int virtualDesktop READ virtualDesktop WRITE setVirtualDesktop NOTIFY virtualDesktopChanged) Q_PROPERTY(int screen READ screen WRITE setScreen NOTIFY screenChanged) Q_PROPERTY(QString activity READ activity WRITE setActivity NOTIFY activityChanged) Q_PROPERTY(bool filterByVirtualDesktop READ filterByVirtualDesktop WRITE setFilterByVirtualDesktop NOTIFY filterByVirtualDesktopChanged) Q_PROPERTY(bool filterByScreen READ filterByScreen WRITE setFilterByScreen NOTIFY filterByScreenChanged) Q_PROPERTY(bool filterByActivity READ filterByActivity WRITE setFilterByActivity NOTIFY filterByActivityChanged) Q_PROPERTY(bool filterNotMinimized READ filterNotMinimized WRITE setFilterNotMinimized NOTIFY filterNotMinimizedChanged) Q_PROPERTY(SortMode sortMode READ sortMode WRITE setSortMode NOTIFY sortModeChanged) Q_PROPERTY(bool separateLaunchers READ separateLaunchers WRITE setSeparateLaunchers NOTIFY separateLaunchersChanged) Q_PROPERTY(bool launchInPlace READ launchInPlace WRITE setLaunchInPlace NOTIFY launchInPlaceChanged) Q_PROPERTY(GroupMode groupMode READ groupMode WRITE setGroupMode NOTIFY groupModeChanged) + Q_PROPERTY(bool groupInline READ groupInline WRITE setGroupInline NOTIFY groupInlineChanged) Q_PROPERTY(int groupingWindowTasksThreshold READ groupingWindowTasksThreshold WRITE setGroupingWindowTasksThreshold NOTIFY groupingWindowTasksThresholdChanged) Q_PROPERTY(QStringList groupingAppIdBlacklist READ groupingAppIdBlacklist WRITE setGroupingAppIdBlacklist NOTIFY groupingAppIdBlacklistChanged) Q_PROPERTY(QStringList groupingLauncherUrlBlacklist READ groupingLauncherUrlBlacklist WRITE setGroupingLauncherUrlBlacklist NOTIFY groupingLauncherUrlBlacklistChanged) public: enum SortMode { SortDisabled = 0, /**< No sorting is done. */ SortManual, /**< Tasks can be moved with move() and syncLaunchers(). */ SortAlpha, /**< Tasks are sorted alphabetically, by AbstractTasksModel::AppName and Qt::DisplayRole. */ SortVirtualDesktop, /**< Tasks are sorted by the virtual desktop they are on. */ SortActivity /**< Tasks are sorted by the number of tasks on the activities they're on. */ }; enum GroupMode { GroupDisabled = 0, /**< No grouping is done. */ GroupApplications /**< Tasks are grouped by the application backing them. */ }; explicit TasksModel(QObject *parent = 0); virtual ~TasksModel(); QHash roleNames() const override; Q_INVOKABLE int rowCount(const QModelIndex &parent = QModelIndex()) const; // Invokable. /** * The number of launcher tasks in the tast list. * * @returns the number of launcher tasks in the task list. **/ int launcherCount() const; /** * The list of launcher URLs serialized to strings. * * @see setLauncherList * @returns the list of launcher URLs serialized to strings. **/ QStringList launcherList() const; /** * Replace the list of launcher URL strings. * * Invalid or empty URLs will be rejected. Duplicate URLs will be * collapsed. * * @see launcherList * @param launchers A list of launcher URL strings. **/ void setLauncherList(const QStringList &launchers); /** * Returns whether any task in the model currently demands attention * (AbstractTasksModel::IsDemandingAttention). * * @returns whether any task in the model currently demands attention. **/ bool anyTaskDemandsAttention() const; /** * The number of the virtual desktop used in filtering by virtual * desktop. Usually set to the number of the current virtual desktop. * Defaults to @c -1. * * @see setVirtualDesktop * @returns the number of the virtual desktop used in filtering. **/ int virtualDesktop() const; /** * Set the number of the virtual desktop to use in filtering by virtual * desktop. * * If set to @c -1, filtering by virtual desktop is disabled. * * @see virtualDesktop * @param virtualDesktop A virtual desktop number. **/ void setVirtualDesktop(int virtualDesktop); /** * The number of the screen used in filtering by screen. Usually * set to the number of the current screen. Defaults to @c -1. * * @see setScreen * @returns the number of the screen used in filtering. **/ int screen() const; /** * Set the number of the screen to use in filtering by screen. * * If set to @c -1, filtering by screen is disabled. * * @see screen * @param screen A screen number. **/ void setScreen(int screen); /** * The id of the activity used in filtering by activity. Usually * set to the id of the current activity. Defaults to an empty id. * - * FIXME: Implement. - * * @see setActivity * @returns the id of the activity used in filtering. **/ QString activity() const; /** * Set the id of the activity to use in filtering by activity. * - * FIXME: Implement. - * * @see activity * @param activity An activity id. **/ void setActivity(const QString &activity); /** * Whether tasks should be filtered by virtual desktop. Defaults to * @c false. * * Filtering by virtual desktop only happens if a virtual desktop * number is set, even if this returns @c true. * * @see setFilterByVirtualDesktop * @see setVirtualDesktop * @returns @c true if tasks should be filtered by virtual desktop. **/ bool filterByVirtualDesktop() const; /** * Set whether tasks should be filtered by virtual desktop. * * Filtering by virtual desktop only happens if a virtual desktop * number is set, even if this is set to @c true. * * @see filterByVirtualDesktop * @see setVirtualDesktop * @param filter Whether tasks should be filtered by virtual desktop. **/ void setFilterByVirtualDesktop(bool filter); /** * Whether tasks should be filtered by screen. Defaults to @c false. * * Filtering by screen only happens if a screen number is set, even * if this returns @c true. * * @see setFilterByScreen * @see setScreen * @returns @c true if tasks should be filtered by screen. **/ bool filterByScreen() const; /** * Set whether tasks should be filtered by screen. * * Filtering by screen only happens if a screen number is set, even * if this is set to @c true. * * @see filterByScreen * @see setScreen * @param filter Whether tasks should be filtered by screen. **/ void setFilterByScreen(bool filter); /** * Whether tasks should be filtered by activity. Defaults to @c false. * * Filtering by activity only happens if an activity id is set, even * if this returns @c true. * * @see setFilterByActivity * @see setActivity * @returns @ctrue if tasks should be filtered by activity. **/ bool filterByActivity() const; /** * Set whether tasks should be filtered by activity. Defaults to * @c false. * * Filtering by virtual desktop only happens if an activity id is set, * even if this is set to @c true. * * @see filterByActivity * @see setActivity * @param filter Whether tasks should be filtered by activity. **/ void setFilterByActivity(bool filter); /** * Whether non-minimized tasks should be filtered. Defaults to * @c false. * * @see setFilterNotMinimized * @returns @c true if non-minimized tasks should be filtered. **/ bool filterNotMinimized() const; /** * Set whether non-minimized tasks should be filtered. * * @see filterNotMinimized * @param filter Whether non-minimized tasks should be filtered. **/ void setFilterNotMinimized(bool filter); /** * The sort mode used in sorting tasks. Defaults to SortAlpha. * * @see setSortMode * @returns the curent sort mode. **/ SortMode sortMode() const; /** * Sets the sort mode used in sorting tasks. * * @see sortMode * @param mode A sort mode. **/ void setSortMode(SortMode mode); // FIXME TODO: Add docs once fully implemented. bool separateLaunchers() const; void setSeparateLaunchers(bool separate); /** * Whether window tasks should be sorted as their associated launcher * tasks or separately. Defaults to @c false. * * @see setLaunchInPlace * @returns whether window tasks should be sorted as their associated * launcher tasks. **/ bool launchInPlace() const; /** * Sets whether window tasks should be sorted as their associated launcher * tasks or separately. * * @see launchInPlace * @param launchInPlace Whether window tasks should be sorted as their * associated launcher tasks. **/ void setLaunchInPlace(bool launchInPlace); /** * Returns the current group mode, i.e. the criteria by which tasks should * be grouped. * * Defaults to TasksModel::GroupApplication, which groups tasks backed by * the same application. * * If the group mode is TasksModel::GroupDisabled, no grouping is done. * * @see setGroupMode * @returns the current group mode. **/ TasksModel::GroupMode groupMode() const; /** * Sets the group mode, i.e. the criteria by which tasks should be grouped. * * The group mode can be set to TasksModel::GroupDisabled to disable grouping * entirely, breaking apart any existing groups. * * @see groupMode * @param mode A group mode. **/ void setGroupMode(TasksModel::GroupMode mode); + /** + * Returns whether grouping is done "inline" or not, i.e. whether groups + * are maintained inside the flat, top-level list, or by forming a tree. + * In inline grouping mode, move() on a group member will move all siblings + * as well, and sorting is first done among groups, then group members. + * + * Further, in inline grouping mode, the groupingWindowTasksThreshold + * setting is ignored: Grouping is always done. + * + * @see setGroupInline + * @see move + * @see groupingWindowTasksThreshold + * @returns whether grouping is done inline or not. + **/ + bool groupInline() const; + + /** + * Sets whether grouping is done "inline" or not, i.e. whether groups + * are maintained inside the flat, top-level list, or by forming a tree. + * In inline grouping mode, move() on a group member will move all siblings + * as well, and sorting is first done among groups, then group members. + * + * @see groupInline + * @see move + * @see groupingWindowTasksThreshold + * @param inline Whether to do grouping inline or not. + **/ + void setGroupInline(bool groupInline); + /** * As window tasks (AbstractTasksModel::IsWindow) come and go, groups will * be formed when this threshold value is exceeded, and broken apart when * it matches or falls below. * * Defaults to @c -1, which means grouping is done regardless of the number * of window tasks. * + * When the groupInline property is set to @c true, the threshold is ignored: + * Grouping is always done. + * * @see setGroupingWindowTasksThreshold + * @see groupInline * @return the threshold number of window tasks used in grouping decisions. **/ int groupingWindowTasksThreshold() const; /** * Sets the number of window tasks (AbstractTasksModel::IsWindow) above which * groups will be formed, and at or below which groups will be broken apart. * * If set to -1, grouping will be done regardless of the number of window tasks * in the source model. * + * When the groupInline property is set to @c true, the threshold is ignored: + * Grouping is always done. + * * @see groupingWindowTasksThreshold + * @see groupInline * @param threshold A threshold number of window tasks used in grouping * decisions. **/ void setGroupingWindowTasksThreshold(int threshold); /** * A blacklist of app ids (AbstractTasksModel::AppId) that is consulted before * grouping a task. If a task's app id is found on the blacklist, it is not * grouped. * * The default app id blacklist is empty. * * @see setGroupingAppIdBlacklist * @returns the blacklist of app ids consulted before grouping a task. **/ QStringList groupingAppIdBlacklist() const; /** * Sets the blacklist of app ids (AbstractTasksModel::AppId) that is consulted * before grouping a task. If a task's app id is found on the blacklist, it is * not grouped. * * When set, groups will be formed and broken apart as necessary. * * @see groupingAppIdBlacklist * @param list a blacklist of app ids to be consulted before grouping a task. **/ void setGroupingAppIdBlacklist(const QStringList &list); /** * A blacklist of launcher URLs (AbstractTasksModel::LauncherUrl) that is * consulted before grouping a task. If a task's launcher URL is found on the * blacklist, it is not grouped. * * The default launcher URL blacklist is empty. * * @see setGroupingLauncherUrlBlacklist * @returns the blacklist of launcher URLs consulted before grouping a task. **/ QStringList groupingLauncherUrlBlacklist() const; /** * Sets the blacklist of launcher URLs (AbstractTasksModel::LauncherUrl) that * is consulted before grouping a task. If a task's launcher URL is found on * the blacklist, it is not grouped. * * When set, groups will be formed and broken apart as necessary. * * @see groupingLauncherUrlBlacklist * @param list a blacklist of launcher URLs to be consulted before grouping a task. **/ void setGroupingLauncherUrlBlacklist(const QStringList &list); /** * Request adding a launcher with the given URL. * * If this URL is already in the list, the request will fail. URLs are * compared for equality after removing the query string used to hold * metadata. * * @see launcherUrlsMatch * @param url A launcher URL. * @returns @c true if a launcher was added. */ Q_INVOKABLE bool requestAddLauncher(const QUrl &url); /** * Request removing the launcher with the given URL. * * If this URL is already in the list, the request will fail. URLs are * compared for equality after removing the query string used to hold * metadata. * * @see launcherUrlsMatch * @param url A launcher URL. * @returns @c true if the launcher was removed. */ Q_INVOKABLE bool requestRemoveLauncher(const QUrl &url); /** * Return the position of the launcher with the given URL. * * URLs are compared for equality after removing the query string used * to hold metadata. * * @see launcherUrlsMatch * @param url A launcher URL. * @returns @c -1 if no launcher exists for the given URL. */ Q_INVOKABLE int launcherPosition(const QUrl &url) const; /** * Request activation of the task at the given index. Derived classes are * free to interpret the meaning of "activate" themselves depending on * the nature and state of the task, e.g. launch or raise a window task. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestActivate(const QModelIndex &index); /** * Request an additional instance of the application backing the task * at the given index. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestNewInstance(const QModelIndex &index); /** * Request the task at the given index be closed. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestClose(const QModelIndex &index); /** * Request starting an interactive move for the task at the given index. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestMove(const QModelIndex &index); /** * Request starting an interactive resize for the task at the given index. * * This is meant for tasks that have an associated window, and may be a * no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestResize(const QModelIndex &index); /** * Request toggling the minimized state of the task at the given index. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestToggleMinimized(const QModelIndex &index); /** * Request toggling the maximized state of the task at the given index. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestToggleMaximized(const QModelIndex &index); /** * Request toggling the keep-above state of the task at the given index. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestToggleKeepAbove(const QModelIndex &index); /** * Request toggling the keep-below state of the task at the given index. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestToggleKeepBelow(const QModelIndex &index); /** * Request toggling the fullscreen state of the task at the given index. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestToggleFullScreen(const QModelIndex &index); /** * Request toggling the shaded state of the task at the given index. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestToggleShaded(const QModelIndex &index); /** * Request moving the task at the given index to the specified virtual * desktop. * * This is meant for tasks that have an associated window, and may be * a no-op when there is no window. * * @param index An index in this tasks model. * @param desktop A virtual desktop number. **/ Q_INVOKABLE void requestVirtualDesktop(const QModelIndex &index, qint32 desktop); /** * Request informing the window manager of new geometry for a visual * delegate for the task at the given index. The geometry should be in * screen coordinates. * * If the task at the given index is a group parent, the geometry is * set for all of its children. If the task at the given index is a * group member, the geometry is set for all of its siblings. * * @param index An index in this tasks model. * @param geometry Visual delegate geometry in screen coordinates. * @param delegate The delegate. Implementations are on their own with * regard to extracting information from this, and should take care to * reject invalid objects. **/ Q_INVOKABLE void requestPublishDelegateGeometry(const QModelIndex &index, const QRect &geometry, QObject *delegate = nullptr); /** * Request toggling whether the task at the given index, along with any * tasks matching its kind, should be grouped or not. Task groups will be * formed or broken apart as needed, along with affecting future grouping * decisions as new tasks appear. * * As grouping is toggled for a task, updates are made to the * grouping*Blacklist properties of the model instance. * * @see groupingAppIdBlacklist * @see groupingLauncherUrlBlacklist * * @param index An index in this tasks model. **/ Q_INVOKABLE void requestToggleGrouping(const QModelIndex &index); /** * Moves a (top-level) task to a new position in the list. The insert * position is bounded to the list start and end. + * * syncLaunchers() should be called after a set of move operations to - * update the launcher list to reflect the new order. + * update the launcherList property to reflect the new order. + * + * When the groupInline property is set to @c true, a move request + * for a group member will bring all siblings along. * * @see syncLaunchers * @see launcherList + * @see setGroupInline * @param index An index in this tasks model. * @param newPos The new list position to move the task to. */ Q_INVOKABLE bool move(int row, int newPos); /** * Updates the launcher list to reflect the new order after calls to * move(), if needed. * * @see move * @see launcherList */ Q_INVOKABLE void syncLaunchers(); /** * Finds the first active (AbstractTasksModel::IsActive) task in the model * and returns its QModelIndex, or a null QModelIndex if no active task is * found. * * @returns the model index for the first active task, if any. */ Q_INVOKABLE QModelIndex activeTask() const; /** * Given a row in the model, returns a QModelIndex for it. To get an index * for a child in a task group, an optional child row may be passed as well. * * This easier to use from Qt Quick views than QAbstractItemModel::index is. * * @param row A row index in the model. * @param childRow A row index for a child of the task group at the given row. * @returns a model index for the task at the given row, or for one of its * child tasks. */ Q_INVOKABLE QModelIndex makeModelIndex(int row, int childRow = -1) const; Q_SIGNALS: void countChanged() const; void launcherCountChanged() const; void launcherListChanged() const; void anyTaskDemandsAttentionChanged() const; void virtualDesktopChanged() const; void screenChanged() const; void activityChanged() const; void filterByVirtualDesktopChanged() const; void filterByScreenChanged() const; void filterByActivityChanged() const; void filterNotMinimizedChanged() const; void sortModeChanged() const; void separateLaunchersChanged() const; void launchInPlaceChanged() const; void groupModeChanged() const; + void groupInlineChanged() const; void groupingWindowTasksThresholdChanged() const; void groupingAppIdBlacklistChanged() const; void groupingLauncherUrlBlacklistChanged() const; protected: bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const; bool lessThan(const QModelIndex &left, const QModelIndex &right) const; private: Q_INVOKABLE void updateLauncherCount(); class Private; class TasksModelLessThan; friend class TasksModelLessThan; QScopedPointer d; }; } #endif