internal: Protocol C++ Wraps + XDGOutput impl (#2733)

move to our own xdgoutput impl instead of wlr's
This commit is contained in:
Vaxry 2023-07-18 15:30:28 +02:00 committed by GitHub
parent 629e61c7a5
commit 8370a7fcc4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 284 additions and 88 deletions

View file

@ -196,8 +196,7 @@ void CCompositor::initServer() {
m_sWLRXDGDecoMgr = wlr_xdg_decoration_manager_v1_create(m_sWLDisplay);
wlr_server_decoration_manager_set_default_mode(m_sWLRServerDecoMgr, WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
m_sWLRXDGOutputMgr = wlr_xdg_output_manager_v1_create(m_sWLDisplay, m_sWLROutputLayout);
m_sWLROutputMgr = wlr_output_manager_v1_create(m_sWLDisplay);
m_sWLROutputMgr = wlr_output_manager_v1_create(m_sWLDisplay);
m_sWLRInhibitMgr = wlr_input_inhibit_manager_create(m_sWLDisplay);
m_sWLRKbShInhibitMgr = wlr_keyboard_shortcuts_inhibit_v1_create(m_sWLDisplay);

View file

@ -61,7 +61,6 @@ class CCompositor {
wlr_xcursor_manager* m_sWLRXCursorMgr;
wlr_virtual_keyboard_manager_v1* m_sWLRVKeyboardMgr;
wlr_output_manager_v1* m_sWLROutputMgr;
wlr_xdg_output_manager_v1* m_sWLRXDGOutputMgr;
wlr_presentation* m_sWLRPresentation;
wlr_scene* m_sWLRScene;
wlr_input_inhibit_manager* m_sWLRInhibitMgr;

View file

@ -1587,9 +1587,6 @@ void CConfigManager::loadConfigLoadVars() {
// update layout
g_pLayoutManager->switchToLayout(configValues["general:layout"].strValue);
// update xwl scale
g_pXWaylandManager->updateXWaylandScale();
// manual crash
if (configValues["debug:manual_crash"].intValue && !m_bManualCrashInitiated) {
m_bManualCrashInitiated = true;
@ -1972,6 +1969,8 @@ void CConfigManager::performMonitorReload() {
g_pCompositor->m_bUnsafeState = false;
m_bWantsMonitorReload = false;
EMIT_HOOK_EVENT("monitorLayoutChanged", nullptr);
}
SConfigValue* CConfigManager::getConfigValuePtr(const std::string& val) {

View file

@ -74,8 +74,6 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
}
xcb_disconnect(XCBCONNECTION);
g_pXWaylandManager->updateXWaylandScale();
#endif
}

View file

@ -219,11 +219,8 @@ void Events::listener_monitorCommit(void* owner, void* data) {
if (E->committed & WLR_OUTPUT_STATE_BUFFER)
g_pProtocolManager->m_pScreencopyProtocolManager->onOutputCommit(PMONITOR, E);
if (E->committed & (WLR_OUTPUT_STATE_SCALE | WLR_OUTPUT_STATE_TRANSFORM | WLR_OUTPUT_STATE_MODE))
g_pXWaylandManager->updateXWaylandScale();
}
void Events::listener_monitorBind(void* owner, void* data) {
g_pXWaylandManager->updateXWaylandScale();
;
}

View file

@ -1,9 +1,13 @@
#include "ProtocolManager.hpp"
#include "xdg-output-unstable-v1-protocol.h"
CProtocolManager::CProtocolManager() {
m_pToplevelExportProtocolManager = std::make_unique<CToplevelExportProtocolManager>();
m_pFractionalScaleProtocolManager = std::make_unique<CFractionalScaleProtocolManager>();
m_pTextInputV1ProtocolManager = std::make_unique<CTextInputV1ProtocolManager>();
m_pGlobalShortcutsProtocolManager = std::make_unique<CGlobalShortcutsProtocolManager>();
m_pScreencopyProtocolManager = std::make_unique<CScreencopyProtocolManager>();
}
m_pXDGOutputProtocol = std::make_unique<CXDGOutputProtocol>(&zxdg_output_manager_v1_interface, 3, "XDGOutput");
}

View file

@ -6,16 +6,21 @@
#include "../protocols/TextInputV1.hpp"
#include "../protocols/GlobalShortcuts.hpp"
#include "../protocols/Screencopy.hpp"
#include "../protocols/XDGOutput.hpp"
class CProtocolManager {
public:
CProtocolManager();
// TODO: rewrite to use the new protocol framework
std::unique_ptr<CToplevelExportProtocolManager> m_pToplevelExportProtocolManager;
std::unique_ptr<CFractionalScaleProtocolManager> m_pFractionalScaleProtocolManager;
std::unique_ptr<CTextInputV1ProtocolManager> m_pTextInputV1ProtocolManager;
std::unique_ptr<CGlobalShortcutsProtocolManager> m_pGlobalShortcutsProtocolManager;
std::unique_ptr<CScreencopyProtocolManager> m_pScreencopyProtocolManager;
// New protocols
std::unique_ptr<CXDGOutputProtocol> m_pXDGOutputProtocol;
};
inline std::unique_ptr<CProtocolManager> g_pProtocolManager;

View file

@ -295,73 +295,4 @@ Vector2D CHyprXWaylandManager::getMaxSizeForWindow(CWindow* pWindow) {
MAXSIZE.y = 99999;
return MAXSIZE;
}
void CHyprXWaylandManager::updateXWaylandScale() {
static auto* const PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue;
setXWaylandScale(*PXWLFORCESCALEZERO ? std::optional<double>{1.0} : std::optional<double>{});
}
void CHyprXWaylandManager::setXWaylandScale(std::optional<double> scale) {
Debug::log(LOG, "Overriding XWayland scale with %.2f", (float)scale.value_or(0.0));
#ifndef NO_XWAYLAND
wl_resource* res = nullptr;
for (auto& m : g_pCompositor->m_vMonitors) {
if (!m->output || !m->m_bEnabled)
continue;
const Vector2D LOGICALSIZE = m->vecTransformedSize / scale.value_or(m->scale);
wl_resource* outputResource = nullptr;
bool needsDone = false;
wl_list_for_each(res, &m->output->resources, link) {
const auto PCLIENT = wl_resource_get_client(res);
if (PCLIENT == m_sWLRXWayland->server->client) {
const auto VERSION = wl_resource_get_version(res);
wl_output_send_mode(res, WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED, (int32_t)LOGICALSIZE.x, (int32_t)LOGICALSIZE.y, m->output->refresh);
if (VERSION >= WL_OUTPUT_SCALE_SINCE_VERSION)
wl_output_send_scale(res, (uint32_t)ceil(scale.value_or(m->scale)));
wl_output_send_name(res, getFormat("HL-X11-%d", m->ID).c_str());
outputResource = res;
needsDone = true;
break;
}
}
wlr_xdg_output_v1* output;
wl_list_for_each(output, &g_pCompositor->m_sWLRXDGOutputMgr->outputs, link) {
if (output->layout_output->output == m->output) {
wl_list_for_each(res, &output->resources, link) {
const auto PCLIENT = wl_resource_get_client(res);
if (PCLIENT == m_sWLRXWayland->server->client) {
zxdg_output_v1_send_logical_size(res, LOGICALSIZE.x, LOGICALSIZE.y);
if (wl_resource_get_version(res) < OUTPUT_DONE_DEPRECATED_SINCE_VERSION)
zxdg_output_v1_send_done(res);
needsDone = true;
break;
}
}
break;
}
}
if (needsDone && outputResource)
wl_output_send_done(outputResource);
}
#endif
}
}

View file

@ -26,10 +26,6 @@ class CHyprXWaylandManager {
void moveXWaylandWindow(CWindow*, const Vector2D&);
void checkBorders(CWindow*);
Vector2D getMaxSizeForWindow(CWindow*);
void updateXWaylandScale();
private:
void setXWaylandScale(std::optional<double> scale);
};
inline std::unique_ptr<CHyprXWaylandManager> g_pXWaylandManager;

View file

@ -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();
}

View file

@ -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;
};

127
src/protocols/XDGOutput.cpp Normal file
View file

@ -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<CWaylandResource>(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<CMonitor*>(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<SXDGOutput>(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<CWaylandResource>(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);
}
}

View file

@ -0,0 +1,31 @@
#pragma once
#include "WaylandProtocol.hpp"
class CMonitor;
struct SXDGOutput {
CMonitor* monitor = nullptr;
std::unique_ptr<CWaylandResource> 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<std::unique_ptr<CWaylandResource>> m_vManagerResources;
std::vector<std::unique_ptr<SXDGOutput>> m_vXDGOutputs;
};

View file

@ -1891,7 +1891,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
(int)pMonitor->vecPixelSize.y, pMonitor->refreshRate, pMonitor->scale, (int)pMonitor->transform, (int)pMonitor->vecPosition.x, (int)pMonitor->vecPosition.y,
(int)pMonitor->enabled10bit);
g_pXWaylandManager->updateXWaylandScale();
EMIT_HOOK_EVENT("monitorLayoutChanged", nullptr);
return true;
}