snapnavigationtargets.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <phosphorsnapengine_export.h>
#include <PhosphorEngine/IWindowTrackingService.h>
#include <PhosphorProtocol/NavigationTypes.h>
 
#include <QRect>
#include <QString>
#include <QStringList>
 
#include <functional>
 
namespace PhosphorZones {
class LayoutRegistry;
}
 
namespace PhosphorScreens {
class ScreenManager;
}
 
namespace PhosphorEngine {
class ICrossSurfaceResolver;
}
 
namespace PhosphorSnapEngine {
 
class ISettings;
class IZoneAdjacencyResolver;
 
struct SpanTargetResult
{
    bool success = false;
    QString reason;
    QStringList zoneIds;
    QRect geometry;
    QString sourceZoneId;
    QString screenName;
    bool grew = false;
};
 
PHOSPHORSNAPENGINE_EXPORT bool isStoredScreenValid(PhosphorScreens::ScreenManager* mgr, const QString& storedScreen);
 
inline QString oppositeCrossingDirection(const QString& direction)
{
    if (direction == QLatin1String("left")) {
        return QStringLiteral("right");
    }
    if (direction == QLatin1String("right")) {
        return QStringLiteral("left");
    }
    if (direction == QLatin1String("up")) {
        return QStringLiteral("down");
    }
    if (direction == QLatin1String("down")) {
        return QStringLiteral("up");
    }
    return {};
}
 
class PHOSPHORSNAPENGINE_EXPORT SnapNavigationTargetResolver
{
public:
    using FeedbackFn =
        std::function<void(bool success, const QString& action, const QString& reason, const QString& sourceZoneId,
                           const QString& targetZoneId, const QString& screenId)>;
 
    SnapNavigationTargetResolver(PhosphorEngine::IWindowTrackingService* service,
                                 PhosphorZones::LayoutRegistry* layoutManager, IZoneAdjacencyResolver* zoneAdjacency,
                                 FeedbackFn feedback);
 
    void setZoneAdjacencyResolver(IZoneAdjacencyResolver* resolver);
 
    void setCrossSurfaceResolver(PhosphorEngine::ICrossSurfaceResolver* resolver);
 
    using NeighbourTilingFn = std::function<bool(const QString& screenId)>;
    void setNeighbourTilingProvider(NeighbourTilingFn fn);
 
    PhosphorProtocol::MoveTargetResult getMoveTargetForWindow(const QString& windowId, const QString& direction,
                                                              const QString& screenId);
 
    SpanTargetResult getSpanTargetForWindow(const QString& windowId, const QString& direction, const QString& screenId);
 
    PhosphorProtocol::FocusTargetResult getFocusTargetForWindow(const QString& windowId, const QString& direction,
                                                                const QString& screenId);
 
    PhosphorProtocol::RestoreTargetResult getRestoreForWindow(const QString& windowId, const QString& screenId);
 
    PhosphorProtocol::CycleTargetResult getCycleTargetForWindow(const QString& windowId, bool forward,
                                                                const QString& screenId);
 
    PhosphorProtocol::SwapTargetResult getSwapTargetForWindow(const QString& windowId, const QString& direction,
                                                              const QString& screenId);
 
    PhosphorProtocol::MoveTargetResult getPushTargetForWindow(const QString& windowId, const QString& screenId);
 
    PhosphorProtocol::MoveTargetResult getSnapToZoneByNumberTarget(const QString& windowId, int zoneNumber,
                                                                   const QString& screenId);
 
private:
    bool hasDependencies() const
    {
        return m_service != nullptr && m_layoutManager != nullptr;
    }
 
    void emitFeedback(bool success, const QString& action, const QString& reason, const QString& sourceZoneId,
                      const QString& targetZoneId, const QString& screenId) const
    {
        if (m_feedback) {
            m_feedback(success, action, reason, sourceZoneId, targetZoneId, screenId);
        }
    }
 
    PhosphorProtocol::MoveTargetResult crossOutputEntryTarget(const QString& currentZoneId, const QString& direction,
                                                              const QString& sourceScreenId,
                                                              bool requireSnapNeighbour) const;
 
    PhosphorProtocol::SwapTargetResult crossOutputSwapTarget(const QString& windowId, const QString& currentZoneId,
                                                             const QString& direction,
                                                             const QString& sourceScreenId) const;
 
    QStringList windowsInZoneOnScreen(const QString& zoneId, const QString& screenName) const;
 
    QString firstWindowInZoneOnScreen(const QString& zoneId, const QString& screenName) const;
 
    PhosphorEngine::IWindowTrackingService* m_service = nullptr;
    PhosphorZones::LayoutRegistry* m_layoutManager = nullptr;
    IZoneAdjacencyResolver* m_zoneAdjacency = nullptr;
    PhosphorEngine::ICrossSurfaceResolver* m_crossSurface = nullptr;
    FeedbackFn m_feedback;
    NeighbourTilingFn m_neighbourIsTiling;
};
 
} // namespace PhosphorSnapEngine