XCEngine/editor/src/Workspace/UIEditorWorkspaceInputOwner.cpp

#include <XCEditor/Workspace/UIEditorWorkspaceInputOwner.h>

namespace XCEngine::UI::Editor {

namespace {

using ::XCEngine::UI::UIPoint;
using ::XCEngine::UI::UIRect;
using Widgets::HitTestUIEditorDockHost;
using Widgets::UIEditorDockHostHitTargetKind;

bool ContainsPoint(const UIRect& rect, const UIPoint& point) {
    return point.x >= rect.x &&
        point.x <= rect.x + rect.width &&
        point.y >= rect.y &&
        point.y <= rect.y + rect.height;
}

bool HasUsableBounds(const UIRect& rect) {
    return rect.width > 0.0f && rect.height > 0.0f;
}

bool IsMountedContentPanelValid(
    const UIEditorPanelContentHostPanelState& panelState) {
    return panelState.mounted && HasUsableBounds(panelState.bounds);
}

} // namespace

std::string_view GetUIEditorWorkspaceInputOwnerKindName(
    UIEditorWorkspaceInputOwnerKind kind) {
    switch (kind) {
    case UIEditorWorkspaceInputOwnerKind::None:
        return "None";
    case UIEditorWorkspaceInputOwnerKind::DockHost:
        return "DockHost";
    case UIEditorWorkspaceInputOwnerKind::HostedPanel:
        return "HostedPanel";
    case UIEditorWorkspaceInputOwnerKind::Viewport:
        return "Viewport";
    }

    return "Unknown";
}

bool AreUIEditorWorkspaceInputOwnersEquivalent(
    const UIEditorWorkspaceInputOwner& lhs,
    const UIEditorWorkspaceInputOwner& rhs) {
    return lhs.kind == rhs.kind && lhs.panelId == rhs.panelId;
}

bool IsUIEditorWorkspaceDockHostInputOwner(
    const UIEditorWorkspaceInputOwner& owner) {
    return owner.kind == UIEditorWorkspaceInputOwnerKind::DockHost;
}

bool IsUIEditorWorkspaceHostedPanelInputOwner(
    const UIEditorWorkspaceInputOwner& owner,
    std::string_view panelId) {
    return owner.kind == UIEditorWorkspaceInputOwnerKind::HostedPanel &&
        (panelId.empty() || owner.panelId == panelId);
}

bool IsUIEditorWorkspaceViewportInputOwner(
    const UIEditorWorkspaceInputOwner& owner,
    std::string_view panelId) {
    return owner.kind == UIEditorWorkspaceInputOwnerKind::Viewport &&
        (panelId.empty() || owner.panelId == panelId);
}

UIEditorWorkspaceInputOwner ResolveUIEditorWorkspacePointerInputOwner(
    const Widgets::UIEditorDockHostLayout& dockHostLayout,
    const UIEditorPanelContentHostFrame& contentHostFrame,
    const UIPoint& pointerPosition) {
    for (const UIEditorPanelContentHostPanelState& panelState :
         contentHostFrame.panelStates) {
        if (!IsMountedContentPanelValid(panelState) ||
            !ContainsPoint(panelState.bounds, pointerPosition)) {
            continue;
        }

        UIEditorWorkspaceInputOwner owner = {};
        owner.panelId = panelState.panelId;
        owner.kind = panelState.kind == UIEditorPanelPresentationKind::ViewportShell
            ? UIEditorWorkspaceInputOwnerKind::Viewport
            : UIEditorWorkspaceInputOwnerKind::HostedPanel;
        return owner;
    }

    const Widgets::UIEditorDockHostHitTarget hitTarget =
        HitTestUIEditorDockHost(dockHostLayout, pointerPosition);
    switch (hitTarget.kind) {
    case UIEditorDockHostHitTargetKind::SplitterHandle:
    case UIEditorDockHostHitTargetKind::TabStripBackground:
    case UIEditorDockHostHitTargetKind::Tab:
    case UIEditorDockHostHitTargetKind::PanelHeader:
    case UIEditorDockHostHitTargetKind::PanelBody:
    case UIEditorDockHostHitTargetKind::PanelFooter:
        return { UIEditorWorkspaceInputOwnerKind::DockHost, {} };

    case UIEditorDockHostHitTargetKind::None:
    default:
        return {};
    }
}

UIEditorWorkspaceInputOwner NormalizeUIEditorWorkspaceInputOwner(
    UIEditorWorkspaceInputOwner owner,
    const Widgets::UIEditorDockHostLayout& dockHostLayout,
    const UIEditorPanelContentHostFrame& contentHostFrame) {
    switch (owner.kind) {
    case UIEditorWorkspaceInputOwnerKind::None:
        return {};

    case UIEditorWorkspaceInputOwnerKind::DockHost:
        return HasUsableBounds(dockHostLayout.bounds)
            ? owner
            : UIEditorWorkspaceInputOwner {};

    case UIEditorWorkspaceInputOwnerKind::HostedPanel:
    case UIEditorWorkspaceInputOwnerKind::Viewport:
        for (const UIEditorPanelContentHostPanelState& panelState :
             contentHostFrame.panelStates) {
            if (!IsMountedContentPanelValid(panelState) ||
                panelState.panelId != owner.panelId) {
                continue;
            }

            const UIEditorWorkspaceInputOwnerKind expectedKind =
                panelState.kind == UIEditorPanelPresentationKind::ViewportShell
                    ? UIEditorWorkspaceInputOwnerKind::Viewport
                    : UIEditorWorkspaceInputOwnerKind::HostedPanel;
            return owner.kind == expectedKind
                ? owner
                : UIEditorWorkspaceInputOwner {};
        }
        return {};
    }

    return {};
}

} // namespace XCEngine::UI::Editor