mirror of
https://github.com/hyprwm/Hyprland
synced 2024-11-02 16:45:59 +01:00
internal: Protocol C++ Wraps + XDGOutput impl (#2733)
move to our own xdgoutput impl instead of wlr's
This commit is contained in:
parent
629e61c7a5
commit
8370a7fcc4
14 changed files with 284 additions and 88 deletions
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -74,8 +74,6 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
|
|||
}
|
||||
|
||||
xcb_disconnect(XCBCONNECTION);
|
||||
|
||||
g_pXWaylandManager->updateXWaylandScale();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
@ -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();
|
||||
;
|
||||
}
|
||||
|
|
|
@ -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");
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
|
||||
}
|
||||
}
|
|
@ -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;
|
75
src/protocols/WaylandProtocol.cpp
Normal file
75
src/protocols/WaylandProtocol.cpp
Normal 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();
|
||||
}
|
35
src/protocols/WaylandProtocol.hpp
Normal file
35
src/protocols/WaylandProtocol.hpp
Normal 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
127
src/protocols/XDGOutput.cpp
Normal 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);
|
||||
}
|
||||
}
|
31
src/protocols/XDGOutput.hpp
Normal file
31
src/protocols/XDGOutput.hpp
Normal 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;
|
||||
};
|
|
@ -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;
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue