RedBear-OS/local/recipes/kde/kf6-kidletime/source/src/kwindowbasedidletimepoller.cpp

/* This file is part of the KDE libraries
 * SPDX-FileCopyrightText: 2009 Dario Freddi <drf at kde.org>
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include "kwindowbasedidletimepoller_p.h"

#include <QEvent>
#include <QTimer>
#include <QWindow>

KWindowBasedIdleTimePoller::KWindowBasedIdleTimePoller(QObject *parent)
    : KAbstractIdleTimePoller(parent)
{
}

KWindowBasedIdleTimePoller::~KWindowBasedIdleTimePoller()
{
}

bool KWindowBasedIdleTimePoller::isAvailable()
{
    return true;
}

bool KWindowBasedIdleTimePoller::setUpPoller()
{
    m_pollTimer = new QTimer(this);

    // setup idle timer, with some smart polling
    connect(m_pollTimer, &QTimer::timeout, this, &KWindowBasedIdleTimePoller::poll);

    m_grabber = new QWindow();
    m_grabber->setFlag(Qt::X11BypassWindowManagerHint);
    m_grabber->setPosition(-1000, -1000);
    m_grabber->installEventFilter(this);
    m_grabber->setObjectName(QStringLiteral("KIdleGrabberWidget"));

    return additionalSetUp();
}

void KWindowBasedIdleTimePoller::unloadPoller()
{
    m_pollTimer->deleteLater();
    m_grabber->deleteLater();
}

QList<int> KWindowBasedIdleTimePoller::timeouts() const
{
    return m_timeouts;
}

void KWindowBasedIdleTimePoller::addTimeout(int nextTimeout)
{
    m_timeouts.append(nextTimeout);
    poll();
}

bool KWindowBasedIdleTimePoller::eventFilter(QObject *object, QEvent *event)
{
    if (object == m_grabber && (event->type() == QEvent::MouseMove || event->type() == QEvent::KeyPress)) {
        detectedActivity();
        return true;
    } else if (object != m_grabber) {
        // If it's not the grabber, fallback to default event filter
        return false;
    }

    // Otherwise, simply ignore it
    return false;
}

void KWindowBasedIdleTimePoller::waitForActivity()
{
    m_grabber->show();
    m_grabber->setMouseGrabEnabled(true);
    m_grabber->setKeyboardGrabEnabled(true);
}

void KWindowBasedIdleTimePoller::detectedActivity()
{
    stopCatchingIdleEvents();
    Q_EMIT resumingFromIdle();
}

void KWindowBasedIdleTimePoller::releaseInputLock()
{
    m_grabber->setMouseGrabEnabled(false);
    m_grabber->setKeyboardGrabEnabled(false);
    m_grabber->hide();
}

int KWindowBasedIdleTimePoller::poll()
{
    int idle = getIdleTime();

    // Check if we reached a timeout..
    for (int timeOut : std::as_const(m_timeouts)) {
        if ((timeOut - idle < 300 && timeOut >= idle) || (idle - timeOut < 300 && idle > timeOut)) {
            // Bingo!
            Q_EMIT timeoutReached(timeOut);
        }
    }

    // Let's check the timer now!
    int mintime = 0;

    for (int i : std::as_const(m_timeouts)) {
        if (i > idle && (i < mintime || mintime == 0)) {
            mintime = i;
        }
    }

    // qDebug() << "mintime " << mintime << "idle " << idle;

    if (mintime != 0) {
        m_pollTimer->start(mintime - idle);
    } else {
        m_pollTimer->stop();
    }

    return idle;
}

int KWindowBasedIdleTimePoller::forcePollRequest()
{
    return poll();
}

void KWindowBasedIdleTimePoller::removeTimeout(int timeout)
{
    m_timeouts.removeOne(timeout);
    poll();
}

void KWindowBasedIdleTimePoller::catchIdleEvent()
{
    waitForActivity();
}

void KWindowBasedIdleTimePoller::stopCatchingIdleEvents()
{
    releaseInputLock();
}

#include "moc_kwindowbasedidletimepoller_p.cpp"