From 8370a7fcc4627e6f21395cc8b81298369be5cdaf Mon Sep 17 00:00:00 2001 From: Vaxry <43317083+vaxerski@users.noreply.github.com> Date: Tue, 18 Jul 2023 15:30:28 +0200 Subject: internal: Protocol C++ Wraps + XDGOutput impl (#2733) move to our own xdgoutput impl instead of wlr's --- src/protocols/WaylandProtocol.cpp | 75 ++++++++++++++++++++++ src/protocols/WaylandProtocol.hpp | 35 +++++++++++ src/protocols/XDGOutput.cpp | 127 ++++++++++++++++++++++++++++++++++++++ src/protocols/XDGOutput.hpp | 31 ++++++++++ 4 files changed, 268 insertions(+) create mode 100644 src/protocols/WaylandProtocol.cpp create mode 100644 src/protocols/WaylandProtocol.hpp create mode 100644 src/protocols/XDGOutput.cpp create mode 100644 src/protocols/XDGOutput.hpp (limited to 'src/protocols') diff --git a/src/protocols/WaylandProtocol.cpp b/src/protocols/WaylandProtocol.cpp new file mode 100644 index 00000000..b5acffea --- /dev/null +++ b/src/protocols/WaylandProtocol.cpp @@ -0,0 +1,75 @@ +#include "WaylandProtocol.hpp" +#include "../Compositor.hpp" + +CWaylandResource::CWaylandResource(wl_client* client, const wl_interface* wlInterface, uint32_t version, uint32_t id, bool destroyInDestructor) { + m_pWLResource = wl_resource_create(client, wlInterface, version, id); + + if (!m_pWLResource) { + wl_client_post_no_memory(client); + return; + } + + m_pWLClient = client; + m_bDestroyInDestructor = destroyInDestructor; + + Debug::log(LOG, "[wl res %lx] created", m_pWLResource); +} + +CWaylandResource::~CWaylandResource() { + if (m_pWLResource && m_bDestroyInDestructor) + wl_resource_destroy(m_pWLResource); + + Debug::log(LOG, "[wl res %lx] destroyed (wl_resource_destroy %s)", m_pWLResource, (m_pWLResource && m_bDestroyInDestructor ? "sent" : "not sent")); +} + +bool CWaylandResource::good() { + return resource(); +} + +wl_resource* CWaylandResource::resource() { + return m_pWLResource; +} + +uint32_t CWaylandResource::version() { + return wl_resource_get_version(m_pWLResource); +} + +void CWaylandResource::setImplementation(const void* impl, void* data, wl_resource_destroy_func_t df) { + RASSERT(!m_bImplementationSet, "Wayland Resource %lx already has an implementation, cannot re-set!", m_pWLResource); + + wl_resource_set_implementation(m_pWLResource, impl, data, df); + + Debug::log(LOG, "[wl res %lx] set impl to %lx", m_pWLResource, impl); + + m_bImplementationSet = true; +} + +static void bindManagerInternal(wl_client* client, void* data, uint32_t ver, uint32_t id) { + ((IWaylandProtocol*)data)->bindManager(client, data, ver, id); +} + +static void displayDestroyInternal(struct wl_listener* listener, void* data) { + ((IWaylandProtocol*)data)->onDisplayDestroy(); +} + +void IWaylandProtocol::onDisplayDestroy() { + wl_global_destroy(m_pGlobal); +} + +IWaylandProtocol::IWaylandProtocol(const wl_interface* iface, const int& ver, const std::string& name) { + m_pGlobal = wl_global_create(g_pCompositor->m_sWLDisplay, iface, ver, this, &bindManagerInternal); + + if (!m_pGlobal) { + Debug::log(ERR, "[proto %s] could not create a global", name.c_str()); + return; + } + + m_liDisplayDestroy.notify = displayDestroyInternal; + wl_display_add_destroy_listener(g_pCompositor->m_sWLDisplay, &m_liDisplayDestroy); + + Debug::log(LOG, "[proto %s] started", name.c_str()); +} + +IWaylandProtocol::~IWaylandProtocol() { + onDisplayDestroy(); +} diff --git a/src/protocols/WaylandProtocol.hpp b/src/protocols/WaylandProtocol.hpp new file mode 100644 index 00000000..04a58387 --- /dev/null +++ b/src/protocols/WaylandProtocol.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include "../defines.hpp" + +class CWaylandResource { + public: + CWaylandResource(wl_client* client, const wl_interface* wlInterface, uint32_t version, uint32_t id, bool destroyInDestructor = false); + ~CWaylandResource(); + + bool good(); + wl_resource* resource(); + uint32_t version(); + + void setImplementation(const void* impl, void* data, wl_resource_destroy_func_t df); + + private: + bool m_bDestroyInDestructor = false; + bool m_bImplementationSet = false; + wl_client* m_pWLClient = nullptr; + wl_resource* m_pWLResource = nullptr; +}; + +interface IWaylandProtocol { + public: + IWaylandProtocol(const wl_interface* iface, const int& ver, const std::string& name); + ~IWaylandProtocol(); + + virtual void onDisplayDestroy(); + + virtual void bindManager(wl_client * client, void* data, uint32_t ver, uint32_t id) = 0; + + private: + wl_global* m_pGlobal = nullptr; + wl_listener m_liDisplayDestroy; +}; \ No newline at end of file diff --git a/src/protocols/XDGOutput.cpp b/src/protocols/XDGOutput.cpp new file mode 100644 index 00000000..ab0820e0 --- /dev/null +++ b/src/protocols/XDGOutput.cpp @@ -0,0 +1,127 @@ +#include "XDGOutput.hpp" +#include "../Compositor.hpp" + +#include "xdg-output-unstable-v1-protocol.h" + +#define OUTPUT_MANAGER_VERSION 3 +#define OUTPUT_DONE_DEPRECATED_SINCE_VERSION 3 +#define OUTPUT_DESCRIPTION_MUTABLE_SINCE_VERSION 3 + +static void destroyManagerResource(wl_client* client, wl_resource* resource) { + ((CXDGOutputProtocol*)wl_resource_get_user_data(resource))->onManagerResourceDestroy(resource); + // will be destroyed by the destruction of the unique_ptr +} + +static void destroyOutputResource(wl_client* client, wl_resource* resource) { + ((CXDGOutputProtocol*)wl_resource_get_user_data(resource))->onOutputResourceDestroy(resource); + wl_resource_destroy(resource); +} + +static void destroyOutputResourceOnly(wl_resource* resource) { + ((CXDGOutputProtocol*)wl_resource_get_user_data(resource))->onOutputResourceDestroy(resource); +} + +static void getXDGOutput(wl_client* client, wl_resource* resource, uint32_t id, wl_resource* outputResource) { + ((CXDGOutputProtocol*)wl_resource_get_user_data(resource))->onManagerGetXDGOutput(client, resource, id, outputResource); +} + +// + +static const struct zxdg_output_manager_v1_interface MANAGER_IMPL = { + .destroy = destroyManagerResource, + .get_xdg_output = getXDGOutput, +}; + +static const struct zxdg_output_v1_interface OUTPUT_IMPL = { + .destroy = destroyOutputResource, +}; + +void CXDGOutputProtocol::onManagerResourceDestroy(wl_resource* res) { + std::erase_if(m_vManagerResources, [&](const auto& other) { return other->resource() == res; }); +} + +void CXDGOutputProtocol::onOutputResourceDestroy(wl_resource* res) { + std::erase_if(m_vXDGOutputs, [&](const auto& other) { return !other->resource || other->resource->resource() == res; }); +} + +void CXDGOutputProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { + const auto RESOURCE = m_vManagerResources.emplace_back(std::make_unique(client, &zxdg_output_manager_v1_interface, ver, id, true)).get(); + + if (!RESOURCE->good()) { + Debug::log(LOG, "Couldn't bind XDGOutputMgr"); + return; + } + + RESOURCE->setImplementation(&MANAGER_IMPL, this, nullptr); +} + +CXDGOutputProtocol::CXDGOutputProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) { + g_pHookSystem->hookDynamic("monitorLayoutChanged", [&](void* self, std::any param) { this->updateAllOutputs(); }); + g_pHookSystem->hookDynamic("configReloaded", [&](void* self, std::any param) { this->updateAllOutputs(); }); + g_pHookSystem->hookDynamic("monitorRemoved", [&](void* self, std::any param) { + const auto PMONITOR = std::any_cast(param); + std::erase_if(m_vXDGOutputs, [&](const auto& other) { return other->monitor == PMONITOR; }); + }); +} + +void CXDGOutputProtocol::onManagerGetXDGOutput(wl_client* client, wl_resource* resource, uint32_t id, wl_resource* outputResource) { + const auto OUTPUT = wlr_output_from_resource(outputResource); + + if (!OUTPUT) + return; + + const auto PMONITOR = g_pCompositor->getMonitorFromOutput(OUTPUT); + + if (!PMONITOR) + return; + + SXDGOutput* pXDGOutput = m_vXDGOutputs.emplace_back(std::make_unique(PMONITOR)).get(); +#ifndef NO_XWAYLAND + if (g_pXWaylandManager->m_sWLRXWayland->server->client == client) + pXDGOutput->isXWayland = true; +#endif + pXDGOutput->client = client; + + pXDGOutput->resource = std::make_unique(client, &zxdg_output_v1_interface, wl_resource_get_version(resource), id); + + if (!pXDGOutput->resource->good()) { + pXDGOutput->resource.release(); + return; + } + + pXDGOutput->resource->setImplementation(&OUTPUT_IMPL, this, destroyOutputResourceOnly); + const auto XDGVER = pXDGOutput->resource->version(); + + if (XDGVER >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION) + zxdg_output_v1_send_name(pXDGOutput->resource->resource(), PMONITOR->szName.c_str()); + if (XDGVER >= ZXDG_OUTPUT_V1_DESCRIPTION_SINCE_VERSION && PMONITOR->output->description) + zxdg_output_v1_send_description(pXDGOutput->resource->resource(), PMONITOR->output->description); + + updateOutputDetails(pXDGOutput); + + const auto OUTPUTVER = wl_resource_get_version(outputResource); + if (OUTPUTVER >= WL_OUTPUT_DONE_SINCE_VERSION && XDGVER >= OUTPUT_DONE_DEPRECATED_SINCE_VERSION) + wl_output_send_done(outputResource); +} + +void CXDGOutputProtocol::updateOutputDetails(SXDGOutput* pOutput) { + static auto* const PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue; + + zxdg_output_v1_send_logical_position(pOutput->resource->resource(), pOutput->monitor->vecPosition.x, pOutput->monitor->vecPosition.y); + + if (*PXWLFORCESCALEZERO && pOutput->isXWayland) + zxdg_output_v1_send_logical_size(pOutput->resource->resource(), pOutput->monitor->vecPixelSize.x, pOutput->monitor->vecPixelSize.y); + else + zxdg_output_v1_send_logical_size(pOutput->resource->resource(), pOutput->monitor->vecSize.x, pOutput->monitor->vecSize.y); + + if (wl_resource_get_version(pOutput->resource->resource()) < OUTPUT_DONE_DEPRECATED_SINCE_VERSION) + zxdg_output_v1_send_done(pOutput->resource->resource()); +} + +void CXDGOutputProtocol::updateAllOutputs() { + for (auto& o : m_vXDGOutputs) { + updateOutputDetails(o.get()); + + wlr_output_schedule_done(o->monitor->output); + } +} \ No newline at end of file diff --git a/src/protocols/XDGOutput.hpp b/src/protocols/XDGOutput.hpp new file mode 100644 index 00000000..13b7029c --- /dev/null +++ b/src/protocols/XDGOutput.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include "WaylandProtocol.hpp" + +class CMonitor; + +struct SXDGOutput { + CMonitor* monitor = nullptr; + std::unique_ptr resource; + + wl_client* client = nullptr; + bool isXWayland = false; +}; + +class CXDGOutputProtocol : public IWaylandProtocol { + public: + CXDGOutputProtocol(const wl_interface* iface, const int& ver, const std::string& name); + + virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); + + void onManagerResourceDestroy(wl_resource* res); + void onOutputResourceDestroy(wl_resource* res); + void onManagerGetXDGOutput(wl_client* client, wl_resource* resource, uint32_t id, wl_resource* outputResource); + + private: + void updateOutputDetails(SXDGOutput* pOutput); + void updateAllOutputs(); + + std::vector> m_vManagerResources; + std::vector> m_vXDGOutputs; +}; \ No newline at end of file -- cgit v1.2.3