File indexing completed on 2024-05-05 05:38:34

 /*
     SPDX-FileCopyrightText: 2016 Eike Hein <hein@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "taskfilterproxymodel.h"
 #include "abstracttasksmodel.h"
 
 #include "launchertasksmodel_p.h"
 
 #include "config-X11.h"
 #if HAVE_X11
 #include <QGuiApplication>
 #include <QScreen>
 
 #include <KWindowSystem>
 #endif
 
 namespace TaskManager
 {
 class Q_DECL_HIDDEN TaskFilterProxyModel::Private
 {
 public:
     Private(TaskFilterProxyModel *q);
 
     AbstractTasksModelIface *sourceTasksModel = nullptr;
 
     QVariant virtualDesktop;
     QRect screenGeometry;
     QRect regionGeometry;
     QString activity;
 
     bool filterByVirtualDesktop = false;
     bool filterByScreen = false;
     bool filterByActivity = false;
     RegionFilterMode::Mode filterByRegion = RegionFilterMode::Mode::Disabled;
     bool filterMinimized = false;
     bool filterNotMinimized = false;
     bool filterNotMaximized = false;
     bool filterHidden = false;
     bool filterSkipTaskbar = true;
     bool filterSkipPager = false;
 
     bool demandingAttentionSkipsFilters = true;
 };
 
 TaskFilterProxyModel::Private::Private(TaskFilterProxyModel *)
 {
 }
 
 TaskFilterProxyModel::TaskFilterProxyModel(QObject *parent)
     : QSortFilterProxyModel(parent)
     , d(new Private(this))
 {
 }
 
 TaskFilterProxyModel::~TaskFilterProxyModel()
 {
 }
 
 void TaskFilterProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
 {
     d->sourceTasksModel = dynamic_cast<AbstractTasksModelIface *>(sourceModel);
 
     QSortFilterProxyModel::setSourceModel(sourceModel);
 }
 
 QVariant TaskFilterProxyModel::virtualDesktop() const
 {
     return d->virtualDesktop;
 }
 
 void TaskFilterProxyModel::setVirtualDesktop(const QVariant &desktop)
 {
     if (d->virtualDesktop != desktop) {
         d->virtualDesktop = desktop;
 
         if (d->filterByVirtualDesktop) {
             invalidateFilter();
         }
 
         Q_EMIT virtualDesktopChanged();
     }
 }
 
 QRect TaskFilterProxyModel::screenGeometry() const
 {
     return d->screenGeometry;
 }
 
 void TaskFilterProxyModel::setScreenGeometry(const QRect &geometry)
 {
     if (d->screenGeometry != geometry) {
         d->screenGeometry = geometry;
 
         if (d->filterByScreen) {
             invalidateFilter();
         }
 
         Q_EMIT screenGeometryChanged();
     }
 }
 
 QRect TaskFilterProxyModel::regionGeometry() const
 {
     return d->regionGeometry;
 }
 
 void TaskFilterProxyModel::setRegionGeometry(const QRect &geometry)
 {
     if (d->regionGeometry == geometry) {
         return;
     }
     d->regionGeometry = geometry;
 
     if (d->filterByRegion != RegionFilterMode::Mode::Disabled) {
         invalidateFilter();
     }
 
     Q_EMIT regionGeometryChanged();
 }
 
 QString TaskFilterProxyModel::activity() const
 {
     return d->activity;
 }
 
 void TaskFilterProxyModel::setActivity(const QString &activity)
 {
     if (d->activity != activity) {
         d->activity = activity;
 
         if (d->filterByActivity) {
             invalidateFilter();
         }
 
         Q_EMIT activityChanged();
     }
 }
 
 bool TaskFilterProxyModel::filterByVirtualDesktop() const
 {
     return d->filterByVirtualDesktop;
 }
 
 void TaskFilterProxyModel::setFilterByVirtualDesktop(bool filter)
 {
     if (d->filterByVirtualDesktop != filter) {
         d->filterByVirtualDesktop = filter;
 
         invalidateFilter();
 
         Q_EMIT filterByVirtualDesktopChanged();
     }
 }
 
 bool TaskFilterProxyModel::filterByScreen() const
 {
     return d->filterByScreen;
 }
 
 void TaskFilterProxyModel::setFilterByScreen(bool filter)
 {
     if (d->filterByScreen != filter) {
         d->filterByScreen = filter;
 
         invalidateFilter();
 
         Q_EMIT filterByScreenChanged();
     }
 }
 
 bool TaskFilterProxyModel::filterByActivity() const
 {
     return d->filterByActivity;
 }
 
 void TaskFilterProxyModel::setFilterByActivity(bool filter)
 {
     if (d->filterByActivity != filter) {
         d->filterByActivity = filter;
 
         invalidateFilter();
 
         Q_EMIT filterByActivityChanged();
     }
 }
 
 RegionFilterMode::Mode TaskFilterProxyModel::filterByRegion() const
 {
     return d->filterByRegion;
 }
 
 void TaskFilterProxyModel::setFilterByRegion(RegionFilterMode::Mode mode)
 {
     if (d->filterByRegion == mode) {
         return;
     }
 
     d->filterByRegion = mode;
     invalidateFilter();
     Q_EMIT filterByActivityChanged();
 }
 
 bool TaskFilterProxyModel::filterMinimized() const
 {
     return d->filterMinimized;
 }
 
 void TaskFilterProxyModel::setFilterMinimized(bool filter)
 {
     if (d->filterMinimized == filter) {
         return;
     }
 
     d->filterMinimized = filter;
     invalidateFilter();
 
     Q_EMIT filterMinimizedChanged();
 }
 
 bool TaskFilterProxyModel::filterNotMinimized() const
 {
     return d->filterNotMinimized;
 }
 
 void TaskFilterProxyModel::setFilterNotMinimized(bool filter)
 {
     if (d->filterNotMinimized != filter) {
         d->filterNotMinimized = filter;
 
         invalidateFilter();
 
         Q_EMIT filterNotMinimizedChanged();
     }
 }
 
 bool TaskFilterProxyModel::filterNotMaximized() const
 {
     return d->filterNotMaximized;
 }
 
 void TaskFilterProxyModel::setFilterNotMaximized(bool filter)
 {
     if (d->filterNotMaximized != filter) {
         d->filterNotMaximized = filter;
 
         invalidateFilter();
 
         Q_EMIT filterNotMaximizedChanged();
     }
 }
 
 bool TaskFilterProxyModel::filterHidden() const
 {
     return d->filterHidden;
 }
 
 void TaskFilterProxyModel::setFilterHidden(bool filter)
 {
     if (d->filterHidden != filter) {
         d->filterHidden = filter;
 
         invalidateFilter();
 
         Q_EMIT filterHiddenChanged();
     }
 }
 
 bool TaskFilterProxyModel::filterSkipTaskbar() const
 {
     return d->filterSkipTaskbar;
 }
 
 void TaskFilterProxyModel::setFilterSkipTaskbar(bool filter)
 {
     if (d->filterSkipTaskbar != filter) {
         d->filterSkipTaskbar = filter;
 
         invalidateFilter();
 
         Q_EMIT filterSkipTaskbarChanged();
     }
 }
 
 bool TaskFilterProxyModel::filterSkipPager() const
 {
     return d->filterSkipPager;
 }
 
 void TaskFilterProxyModel::setFilterSkipPager(bool filter)
 {
     if (d->filterSkipPager != filter) {
         d->filterSkipPager = filter;
 
         invalidateFilter();
 
         Q_EMIT filterSkipPagerChanged();
     }
 }
 
 bool TaskFilterProxyModel::demandingAttentionSkipsFilters() const
 {
     return d->demandingAttentionSkipsFilters;
 }
 
 void TaskFilterProxyModel::setDemandingAttentionSkipsFilters(bool skip)
 {
     if (d->demandingAttentionSkipsFilters != skip) {
         d->demandingAttentionSkipsFilters = skip;
 
         invalidateFilter();
 
         Q_EMIT demandingAttentionSkipsFiltersChanged();
     }
 }
 
 QModelIndex TaskFilterProxyModel::mapIfaceToSource(const QModelIndex &index) const
 {
     return mapToSource(index);
 }
 
 bool TaskFilterProxyModel::acceptsRow(int sourceRow) const
 {
     const QModelIndex &sourceIdx = sourceModel()->index(sourceRow, 0);
 
     if (!sourceIdx.isValid()) {
         return false;
     }
 
     // Filter tasks that are not to be shown on the task bar.
     if (d->filterSkipTaskbar && sourceIdx.data(AbstractTasksModel::SkipTaskbar).toBool()) {
         return false;
     }
 
     // Filter tasks that are not to be shown on the pager.
     if (d->filterSkipPager && sourceIdx.data(AbstractTasksModel::SkipPager).toBool()) {
         return false;
     }
 
     // Filter by virtual desktop.
     if (d->filterByVirtualDesktop && !d->virtualDesktop.isNull()) {
         if (!sourceIdx.data(AbstractTasksModel::IsOnAllVirtualDesktops).toBool()
             && (!d->demandingAttentionSkipsFilters || !sourceIdx.data(AbstractTasksModel::IsDemandingAttention).toBool())) {
             const QVariantList &virtualDesktops = sourceIdx.data(AbstractTasksModel::VirtualDesktops).toList();
 
             if (!virtualDesktops.isEmpty() && !virtualDesktops.contains(d->virtualDesktop)) {
                 return false;
             }
         }
     }
 
     // Filter by screen.
     if (d->filterByScreen && d->screenGeometry.isValid()) {
         const QRect &screenGeometry = sourceIdx.data(AbstractTasksModel::ScreenGeometry).toRect();
 
         if (screenGeometry.isValid() && screenGeometry != d->screenGeometry) {
             return false;
         }
     }
 
     // Filter by region
     if (d->filterByRegion != RegionFilterMode::Mode::Disabled && d->regionGeometry.isValid()) {
         QRect windowGeometry = sourceIdx.data(AbstractTasksModel::Geometry).toRect();
 
         QRect regionGeometry = d->regionGeometry;
 #if HAVE_X11
         if (static const bool isX11 = KWindowSystem::isPlatformX11(); isX11 && windowGeometry.isValid()) {
             // On X11, in regionGeometry, the original point of the topLeft position belongs to the device coordinate system
             // but the size belongs to the logical coordinate system (which means the reported size is already divided by DPR)
             // Converting regionGeometry to device coordinate system is better than converting windowGeometry to logical
             // coordinate system because the window may span multiple screens, while the region is always on one screen.
             const double devicePixelRatio = qGuiApp->devicePixelRatio();
             const QPoint screenTopLeft = d->screenGeometry.topLeft();
             const QPoint regionTopLeft =
                 screenTopLeft + QPoint(regionGeometry.x() - screenTopLeft.x(), regionGeometry.y() - screenTopLeft.y()) * devicePixelRatio;
             regionGeometry = QRect(regionTopLeft, regionGeometry.size() * devicePixelRatio);
         }
 #endif
         switch (d->filterByRegion) {
         case RegionFilterMode::Mode::Inside: {
             if (!regionGeometry.contains(windowGeometry)) {
                 return false;
             }
             break;
         }
         case RegionFilterMode::Mode::Intersect: {
             if (!regionGeometry.intersects(windowGeometry)) {
                 return false;
             }
             break;
         }
         case RegionFilterMode::Mode::Outside: {
             if (regionGeometry.contains(windowGeometry)) {
                 return false;
             }
             break;
         }
         default:
             break;
         }
     }
 
     // Filter by activity.
     if (d->filterByActivity && !d->activity.isEmpty()) {
         if (!d->demandingAttentionSkipsFilters || !sourceIdx.data(AbstractTasksModel::IsDemandingAttention).toBool()) {
             const QVariant &activities = sourceIdx.data(AbstractTasksModel::Activities);
 
             if (!activities.isNull()) {
                 const QStringList l = activities.toStringList();
 
                 if (!l.isEmpty() && !l.contains(NULL_UUID) && !l.contains(d->activity)) {
                     return false;
                 }
             }
         }
     }
 
     // Filter not minimized.
     if (d->filterNotMinimized) {
         bool isMinimized = sourceIdx.data(AbstractTasksModel::IsMinimized).toBool();
 
         if (!isMinimized) {
             return false;
         }
     }
 
     // Filter out minimized windows
     if (d->filterMinimized) {
         const bool isMinimized = sourceIdx.data(AbstractTasksModel::IsMinimized).toBool();
 
         if (isMinimized) {
             return false;
         }
     }
 
     // Filter not maximized.
     if (d->filterNotMaximized) {
         bool isMaximized = sourceIdx.data(AbstractTasksModel::IsMaximized).toBool();
 
         if (!isMaximized) {
             return false;
         }
     }
 
     // Filter hidden.
     if (d->filterHidden) {
         bool isHidden = sourceIdx.data(AbstractTasksModel::IsHidden).toBool();
 
         if (isHidden) {
             return false;
         }
     }
 
     return true;
 }
 
 bool TaskFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     Q_UNUSED(sourceParent)
 
     return acceptsRow(sourceRow);
 }
 
 }