TriggerParser.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <phosphorcompositor_export.h>
 
#include <QDBusArgument>
#include <QVariant>
#include <QVariantList>
#include <QVariantMap>
#include <QVector>
#include <Qt>
 
namespace PhosphorCompositor {
 
struct ParsedTrigger
{
    int modifier = 0;
    int mouseButton = 0;
 
    bool operator==(const ParsedTrigger& other) const = default;
};
 
namespace TriggerParser {
 
inline bool checkModifier(int modifierSetting, Qt::KeyboardModifiers mods)
{
    const bool shiftHeld = mods.testFlag(Qt::ShiftModifier);
    const bool ctrlHeld = mods.testFlag(Qt::ControlModifier);
    const bool altHeld = mods.testFlag(Qt::AltModifier);
    const bool metaHeld = mods.testFlag(Qt::MetaModifier);
 
    switch (modifierSetting) {
    case 0:
        return false; // Disabled
    case 1:
        return shiftHeld; // Shift
    case 2:
        return ctrlHeld; // Ctrl
    case 3:
        return altHeld; // Alt
    case 4:
        return metaHeld; // Meta
    case 5:
        return ctrlHeld && altHeld; // CtrlAlt
    case 6:
        return ctrlHeld && shiftHeld; // CtrlShift
    case 7:
        return altHeld && shiftHeld; // AltShift
    case 8:
        return true; // AlwaysActive
    case 9:
        return altHeld && metaHeld; // AltMeta
    case 10:
        return ctrlHeld && altHeld && metaHeld; // CtrlAltMeta
    case 11:
        return metaHeld && shiftHeld; // MetaShift
    case 12:
        return ctrlHeld && metaHeld; // CtrlMeta
    default:
        return false;
    }
}
 
inline Qt::KeyboardModifiers modifierMaskFor(int modifierSetting)
{
    switch (modifierSetting) {
    case 1:
        return Qt::ShiftModifier;
    case 2:
        return Qt::ControlModifier;
    case 3:
        return Qt::AltModifier;
    case 4:
        return Qt::MetaModifier;
    case 5:
        return Qt::ControlModifier | Qt::AltModifier;
    case 6:
        return Qt::ControlModifier | Qt::ShiftModifier;
    case 7:
        return Qt::AltModifier | Qt::ShiftModifier;
    case 9:
        return Qt::AltModifier | Qt::MetaModifier;
    case 10:
        return Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier;
    case 11:
        return Qt::MetaModifier | Qt::ShiftModifier;
    case 12:
        return Qt::ControlModifier | Qt::MetaModifier;
    default:
        return Qt::NoModifier;
    }
}
 
inline bool exactModifierMatch(int modifierSetting, Qt::KeyboardModifiers mods)
{
    constexpr Qt::KeyboardModifiers chordMask =
        Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier;
    return (mods & chordMask) == modifierMaskFor(modifierSetting);
}
 
inline bool anyTriggerHeldExact(const QVector<ParsedTrigger>& triggers, Qt::KeyboardModifiers mods,
                                Qt::MouseButtons mouseButtons)
{
    for (const auto& t : triggers) {
        if (t.modifier == 0 && t.mouseButton == 0) {
            continue;
        }
        const bool btnMatch = (t.mouseButton == 0) || (static_cast<int>(mouseButtons) & t.mouseButton) != 0;
        if (exactModifierMatch(t.modifier, mods) && btnMatch) {
            return true;
        }
    }
    return false;
}
 
inline bool anyTriggerHeld(const QVector<ParsedTrigger>& triggers, Qt::KeyboardModifiers mods,
                           Qt::MouseButtons mouseButtons)
{
    for (const auto& t : triggers) {
        const bool modMatch = (t.modifier == 0) || checkModifier(t.modifier, mods);
        const bool btnMatch = (t.mouseButton == 0) || (static_cast<int>(mouseButtons) & t.mouseButton) != 0;
        if (modMatch && btnMatch && (t.modifier != 0 || t.mouseButton != 0))
            return true;
    }
    return false;
}
 
PHOSPHORCOMPOSITOR_EXPORT QVector<ParsedTrigger>
parseTriggers(const QVariant& triggerVariant, const QString& modifierFieldName, const QString& mouseButtonFieldName);
 
} // namespace TriggerParser
} // namespace PhosphorCompositor