diff --git a/CMakeLists.txt b/CMakeLists.txt
index f2939040..9775098b 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -109,7 +109,7 @@ pkg_check_modules(deps REQUIRED IMPORTED_TARGET
wayland-server wayland-client wayland-cursor wayland-protocols
cairo pango pangocairo pixman-1
libdrm libinput hwdata libseat libdisplay-info libliftoff libudev gbm
- hyprwayland-scanner>=0.3.3 hyprlang>=0.3.2 hyprcursor>=0.1.7
+ hyprwayland-scanner>=0.3.4 hyprlang>=0.3.2 hyprcursor>=0.1.7
)
file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
@@ -264,6 +264,7 @@ protocolNew("protocols/wlr-output-power-management-unstable-v1.xml" "wlr-output-
protocolNew("protocols/virtual-keyboard-unstable-v1.xml" "virtual-keyboard-unstable-v1" true)
protocolNew("protocols/wlr-virtual-pointer-unstable-v1.xml" "wlr-virtual-pointer-unstable-v1" true)
protocolNew("protocols/input-method-unstable-v2.xml" "input-method-unstable-v2" true)
+protocolNew("protocols/wlr-output-management-unstable-v1.xml" "wlr-output-management-unstable-v1" true)
protocolNew("staging/tearing-control/tearing-control-v1.xml" "tearing-control-v1" false)
protocolNew("staging/fractional-scale/fractional-scale-v1.xml" "fractional-scale-v1" false)
protocolNew("unstable/xdg-output/xdg-output-unstable-v1.xml" "xdg-output-unstable-v1" false)
diff --git a/flake.lock b/flake.lock
index 4aa34ac0..2e8ccf87 100644
--- a/flake.lock
+++ b/flake.lock
@@ -82,11 +82,11 @@
]
},
"locked": {
- "lastModified": 1714589749,
- "narHash": "sha256-zzkb5vc4n/YI5KHrMie7oMZlgCKxs7zm/ybVXNL02Z0=",
+ "lastModified": 1714755542,
+ "narHash": "sha256-D0pg+ZRwrt4lavZ97Ca8clsgbPA3duLj8iEM7riaIFY=",
"owner": "hyprwm",
"repo": "hyprwayland-scanner",
- "rev": "c8c2151c607a036ddfc790f5f70237ab984266aa",
+ "rev": "1270ebaa539e56d61b708c24b072b09cbbd3a828",
"type": "github"
},
"original": {
diff --git a/protocols/meson.build b/protocols/meson.build
index 38b973af..ce89e7f1 100644
--- a/protocols/meson.build
+++ b/protocols/meson.build
@@ -41,6 +41,7 @@ new_protocols = [
['input-method-unstable-v2.xml'],
['virtual-keyboard-unstable-v1.xml'],
['wlr-virtual-pointer-unstable-v1.xml'],
+ ['wlr-output-management-unstable-v1.xml'],
[wl_protocol_dir, 'staging/tearing-control/tearing-control-v1.xml'],
[wl_protocol_dir, 'staging/fractional-scale/fractional-scale-v1.xml'],
[wl_protocol_dir, 'unstable/xdg-output/xdg-output-unstable-v1.xml'],
diff --git a/protocols/wlr-output-management-unstable-v1.xml b/protocols/wlr-output-management-unstable-v1.xml
new file mode 100644
index 00000000..411e2f04
--- /dev/null
+++ b/protocols/wlr-output-management-unstable-v1.xml
@@ -0,0 +1,601 @@
+
+
+
+ Copyright © 2019 Purism SPC
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that copyright notice and this permission
+ notice appear in supporting documentation, and that the name of
+ the copyright holders not be used in advertising or publicity
+ pertaining to distribution of the software without specific,
+ written prior permission. The copyright holders make no
+ representations about the suitability of this software for any
+ purpose. It is provided "as is" without express or implied
+ warranty.
+
+ THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ THIS SOFTWARE.
+
+
+
+ This protocol exposes interfaces to obtain and modify output device
+ configuration.
+
+ Warning! The protocol described in this file is experimental and
+ backward incompatible changes may be made. Backward compatible changes
+ may be added together with the corresponding interface version bump.
+ Backward incompatible changes are done by bumping the version number in
+ the protocol and interface names and resetting the interface version.
+ Once the protocol is to be declared stable, the 'z' prefix and the
+ version number in the protocol and interface names are removed and the
+ interface version number is reset.
+
+
+
+
+ This interface is a manager that allows reading and writing the current
+ output device configuration.
+
+ Output devices that display pixels (e.g. a physical monitor or a virtual
+ output in a window) are represented as heads. Heads cannot be created nor
+ destroyed by the client, but they can be enabled or disabled and their
+ properties can be changed. Each head may have one or more available modes.
+
+ Whenever a head appears (e.g. a monitor is plugged in), it will be
+ advertised via the head event. Immediately after the output manager is
+ bound, all current heads are advertised.
+
+ Whenever a head's properties change, the relevant wlr_output_head events
+ will be sent. Not all head properties will be sent: only properties that
+ have changed need to.
+
+ Whenever a head disappears (e.g. a monitor is unplugged), a
+ wlr_output_head.finished event will be sent.
+
+ After one or more heads appear, change or disappear, the done event will
+ be sent. It carries a serial which can be used in a create_configuration
+ request to update heads properties.
+
+ The information obtained from this protocol should only be used for output
+ configuration purposes. This protocol is not designed to be a generic
+ output property advertisement protocol for regular clients. Instead,
+ protocols such as xdg-output should be used.
+
+
+
+
+ This event introduces a new head. This happens whenever a new head
+ appears (e.g. a monitor is plugged in) or after the output manager is
+ bound.
+
+
+
+
+
+
+ This event is sent after all information has been sent after binding to
+ the output manager object and after any subsequent changes. This applies
+ to child head and mode objects as well. In other words, this event is
+ sent whenever a head or mode is created or destroyed and whenever one of
+ their properties has been changed. Not all state is re-sent each time
+ the current configuration changes: only the actual changes are sent.
+
+ This allows changes to the output configuration to be seen as atomic,
+ even if they happen via multiple events.
+
+ A serial is sent to be used in a future create_configuration request.
+
+
+
+
+
+
+ Create a new output configuration object. This allows to update head
+ properties.
+
+
+
+
+
+
+
+ Indicates the client no longer wishes to receive events for output
+ configuration changes. However the compositor may emit further events,
+ until the finished event is emitted.
+
+ The client must not send any more requests after this one.
+
+
+
+
+
+ This event indicates that the compositor is done sending manager events.
+ The compositor will destroy the object immediately after sending this
+ event, so it will become invalid and the client should release any
+ resources associated with it.
+
+
+
+
+
+
+ A head is an output device. The difference between a wl_output object and
+ a head is that heads are advertised even if they are turned off. A head
+ object only advertises properties and cannot be used directly to change
+ them.
+
+ A head has some read-only properties: modes, name, description and
+ physical_size. These cannot be changed by clients.
+
+ Other properties can be updated via a wlr_output_configuration object.
+
+ Properties sent via this interface are applied atomically via the
+ wlr_output_manager.done event. No guarantees are made regarding the order
+ in which properties are sent.
+
+
+
+
+ This event describes the head name.
+
+ The naming convention is compositor defined, but limited to alphanumeric
+ characters and dashes (-). Each name is unique among all wlr_output_head
+ objects, but if a wlr_output_head object is destroyed the same name may
+ be reused later. The names will also remain consistent across sessions
+ with the same hardware and software configuration.
+
+ Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do
+ not assume that the name is a reflection of an underlying DRM
+ connector, X11 connection, etc.
+
+ If the compositor implements the xdg-output protocol and this head is
+ enabled, the xdg_output.name event must report the same name.
+
+ The name event is sent after a wlr_output_head object is created. This
+ event is only sent once per object, and the name does not change over
+ the lifetime of the wlr_output_head object.
+
+
+
+
+
+
+ This event describes a human-readable description of the head.
+
+ The description is a UTF-8 string with no convention defined for its
+ contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11
+ output via :1'. However, do not assume that the name is a reflection of
+ the make, model, serial of the underlying DRM connector or the display
+ name of the underlying X11 connection, etc.
+
+ If the compositor implements xdg-output and this head is enabled,
+ the xdg_output.description must report the same description.
+
+ The description event is sent after a wlr_output_head object is created.
+ This event is only sent once per object, and the description does not
+ change over the lifetime of the wlr_output_head object.
+
+
+
+
+
+
+ This event describes the physical size of the head. This event is only
+ sent if the head has a physical size (e.g. is not a projector or a
+ virtual device).
+
+
+
+
+
+
+
+ This event introduces a mode for this head. It is sent once per
+ supported mode.
+
+
+
+
+
+
+ This event describes whether the head is enabled. A disabled head is not
+ mapped to a region of the global compositor space.
+
+ When a head is disabled, some properties (current_mode, position,
+ transform and scale) are irrelevant.
+
+
+
+
+
+
+ This event describes the mode currently in use for this head. It is only
+ sent if the output is enabled.
+
+
+
+
+
+
+ This events describes the position of the head in the global compositor
+ space. It is only sent if the output is enabled.
+
+
+
+
+
+
+
+ This event describes the transformation currently applied to the head.
+ It is only sent if the output is enabled.
+
+
+
+
+
+
+ This events describes the scale of the head in the global compositor
+ space. It is only sent if the output is enabled.
+
+
+
+
+
+
+ This event indicates that the head is no longer available. The head
+ object becomes inert. Clients should send a destroy request and release
+ any resources associated with it.
+
+
+
+
+
+
+
+ This event describes the manufacturer of the head.
+
+ This must report the same make as the wl_output interface does in its
+ geometry event.
+
+ Together with the model and serial_number events the purpose is to
+ allow clients to recognize heads from previous sessions and for example
+ load head-specific configurations back.
+
+ It is not guaranteed this event will be ever sent. A reason for that
+ can be that the compositor does not have information about the make of
+ the head or the definition of a make is not sensible in the current
+ setup, for example in a virtual session. Clients can still try to
+ identify the head by available information from other events but should
+ be aware that there is an increased risk of false positives.
+
+ It is not recommended to display the make string in UI to users. For
+ that the string provided by the description event should be preferred.
+
+
+
+
+
+
+ This event describes the model of the head.
+
+ This must report the same model as the wl_output interface does in its
+ geometry event.
+
+ Together with the make and serial_number events the purpose is to
+ allow clients to recognize heads from previous sessions and for example
+ load head-specific configurations back.
+
+ It is not guaranteed this event will be ever sent. A reason for that
+ can be that the compositor does not have information about the model of
+ the head or the definition of a model is not sensible in the current
+ setup, for example in a virtual session. Clients can still try to
+ identify the head by available information from other events but should
+ be aware that there is an increased risk of false positives.
+
+ It is not recommended to display the model string in UI to users. For
+ that the string provided by the description event should be preferred.
+
+
+
+
+
+
+ This event describes the serial number of the head.
+
+ Together with the make and model events the purpose is to allow clients
+ to recognize heads from previous sessions and for example load head-
+ specific configurations back.
+
+ It is not guaranteed this event will be ever sent. A reason for that
+ can be that the compositor does not have information about the serial
+ number of the head or the definition of a serial number is not sensible
+ in the current setup. Clients can still try to identify the head by
+ available information from other events but should be aware that there
+ is an increased risk of false positives.
+
+ It is not recommended to display the serial_number string in UI to
+ users. For that the string provided by the description event should be
+ preferred.
+
+
+
+
+
+
+
+
+ This request indicates that the client will no longer use this head
+ object.
+
+
+
+
+
+
+
+
+
+
+
+
+ This event describes whether adaptive sync is currently enabled for
+ the head or not. Adaptive sync is also known as Variable Refresh
+ Rate or VRR.
+
+
+
+
+
+
+
+ This object describes an output mode.
+
+ Some heads don't support output modes, in which case modes won't be
+ advertised.
+
+ Properties sent via this interface are applied atomically via the
+ wlr_output_manager.done event. No guarantees are made regarding the order
+ in which properties are sent.
+
+
+
+
+ This event describes the mode size. The size is given in physical
+ hardware units of the output device. This is not necessarily the same as
+ the output size in the global compositor space. For instance, the output
+ may be scaled or transformed.
+
+
+
+
+
+
+
+ This event describes the mode's fixed vertical refresh rate. It is only
+ sent if the mode has a fixed refresh rate.
+
+
+
+
+
+
+ This event advertises this mode as preferred.
+
+
+
+
+
+ This event indicates that the mode is no longer available. The mode
+ object becomes inert. Clients should send a destroy request and release
+ any resources associated with it.
+
+
+
+
+
+
+
+ This request indicates that the client will no longer use this mode
+ object.
+
+
+
+
+
+
+ This object is used by the client to describe a full output configuration.
+
+ First, the client needs to setup the output configuration. Each head can
+ be either enabled (and configured) or disabled. It is a protocol error to
+ send two enable_head or disable_head requests with the same head. It is a
+ protocol error to omit a head in a configuration.
+
+ Then, the client can apply or test the configuration. The compositor will
+ then reply with a succeeded, failed or cancelled event. Finally the client
+ should destroy the configuration object.
+
+
+
+
+
+
+
+
+
+
+ Enable a head. This request creates a head configuration object that can
+ be used to change the head's properties.
+
+
+
+
+
+
+
+ Disable a head.
+
+
+
+
+
+
+ Apply the new output configuration.
+
+ In case the configuration is successfully applied, there is no guarantee
+ that the new output state matches completely the requested
+ configuration. For instance, a compositor might round the scale if it
+ doesn't support fractional scaling.
+
+ After this request has been sent, the compositor must respond with an
+ succeeded, failed or cancelled event. Sending a request that isn't the
+ destructor is a protocol error.
+
+
+
+
+
+ Test the new output configuration. The configuration won't be applied,
+ but will only be validated.
+
+ Even if the compositor succeeds to test a configuration, applying it may
+ fail.
+
+ After this request has been sent, the compositor must respond with an
+ succeeded, failed or cancelled event. Sending a request that isn't the
+ destructor is a protocol error.
+
+
+
+
+
+ Sent after the compositor has successfully applied the changes or
+ tested them.
+
+ Upon receiving this event, the client should destroy this object.
+
+ If the current configuration has changed, events to describe the changes
+ will be sent followed by a wlr_output_manager.done event.
+
+
+
+
+
+ Sent if the compositor rejects the changes or failed to apply them. The
+ compositor should revert any changes made by the apply request that
+ triggered this event.
+
+ Upon receiving this event, the client should destroy this object.
+
+
+
+
+
+ Sent if the compositor cancels the configuration because the state of an
+ output changed and the client has outdated information (e.g. after an
+ output has been hotplugged).
+
+ The client can create a new configuration with a newer serial and try
+ again.
+
+ Upon receiving this event, the client should destroy this object.
+
+
+
+
+
+ Using this request a client can tell the compositor that it is not going
+ to use the configuration object anymore. Any changes to the outputs
+ that have not been applied will be discarded.
+
+ This request also destroys wlr_output_configuration_head objects created
+ via this object.
+
+
+
+
+
+
+ This object is used by the client to update a single head's configuration.
+
+ It is a protocol error to set the same property twice.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This request sets the head's mode.
+
+
+
+
+
+
+ This request assigns a custom mode to the head. The size is given in
+ physical hardware units of the output device. If set to zero, the
+ refresh rate is unspecified.
+
+ It is a protocol error to set both a mode and a custom mode.
+
+
+
+
+
+
+
+
+ This request sets the head's position in the global compositor space.
+
+
+
+
+
+
+
+ This request sets the head's transform.
+
+
+
+
+
+
+ This request sets the head's scale.
+
+
+
+
+
+
+
+
+ This request enables/disables adaptive sync. Adaptive sync is also
+ known as Variable Refresh Rate or VRR.
+
+
+
+
+
diff --git a/src/Compositor.cpp b/src/Compositor.cpp
index ea88bec1..e28d86c7 100644
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -243,8 +243,6 @@ void CCompositor::initServer() {
m_sWLRServerDecoMgr = wlr_server_decoration_manager_create(m_sWLDisplay);
wlr_server_decoration_manager_set_default_mode(m_sWLRServerDecoMgr, WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
- m_sWLROutputMgr = wlr_output_manager_v1_create(m_sWLDisplay);
-
m_sWRLDRMLeaseMgr = wlr_drm_lease_v1_manager_create(m_sWLDisplay, m_sWLRBackend);
if (!m_sWRLDRMLeaseMgr) {
Debug::log(INFO, "Failed to create wlr_drm_lease_v1_manager");
@@ -300,9 +298,6 @@ void CCompositor::initAllSignals() {
addWLSignal(&m_sSeat.seat->events.request_set_selection, &Events::listen_requestSetSel, &m_sSeat, "Seat");
addWLSignal(&m_sSeat.seat->events.request_set_primary_selection, &Events::listen_requestSetPrimarySel, &m_sSeat, "Seat");
addWLSignal(&m_sWLRLayerShell->events.new_surface, &Events::listen_newLayerSurface, m_sWLRLayerShell, "LayerShell");
- addWLSignal(&m_sWLROutputLayout->events.change, &Events::listen_change, m_sWLROutputLayout, "OutputLayout");
- addWLSignal(&m_sWLROutputMgr->events.apply, &Events::listen_outputMgrApply, m_sWLROutputMgr, "OutputMgr");
- addWLSignal(&m_sWLROutputMgr->events.test, &Events::listen_outputMgrTest, m_sWLROutputMgr, "OutputMgr");
addWLSignal(&m_sWLRRenderer->events.destroy, &Events::listen_RendererDestroy, m_sWLRRenderer, "WLRRenderer");
if (m_sWRLDRMLeaseMgr)
@@ -340,9 +335,6 @@ void CCompositor::removeAllSignals() {
removeWLSignal(&Events::listen_requestSetSel);
removeWLSignal(&Events::listen_requestSetPrimarySel);
removeWLSignal(&Events::listen_newLayerSurface);
- removeWLSignal(&Events::listen_change);
- removeWLSignal(&Events::listen_outputMgrApply);
- removeWLSignal(&Events::listen_outputMgrTest);
removeWLSignal(&Events::listen_RendererDestroy);
if (m_sWRLDRMLeaseMgr)
diff --git a/src/Compositor.hpp b/src/Compositor.hpp
index 33b4a04e..f252d131 100644
--- a/src/Compositor.hpp
+++ b/src/Compositor.hpp
@@ -55,7 +55,6 @@ class CCompositor {
wlr_layer_shell_v1* m_sWLRLayerShell;
wlr_xdg_shell* m_sWLRXDGShell;
wlr_cursor* m_sWLRCursor;
- wlr_output_manager_v1* m_sWLROutputMgr;
wlr_presentation* m_sWLRPresentation;
wlr_egl* m_sWLREGL;
int m_iDRMFD;
diff --git a/src/config/ConfigManager.cpp b/src/config/ConfigManager.cpp
index a2db6040..652a063c 100644
--- a/src/config/ConfigManager.cpp
+++ b/src/config/ConfigManager.cpp
@@ -16,6 +16,7 @@
#include
#include
#include
+#include
extern "C" char** environ;
@@ -954,7 +955,7 @@ std::string CConfigManager::getDeviceString(const std::string& dev, const std::s
}
SMonitorRule CConfigManager::getMonitorRuleFor(const CMonitor& PMONITOR) {
- for (auto& r : m_dMonitorRules) {
+ for (auto& r : m_dMonitorRules | std::views::reverse) {
if (PMONITOR.matchesStaticSelector(r.name)) {
return r;
}
@@ -1236,6 +1237,10 @@ void CConfigManager::dispatchExecOnce() {
g_pCompositor->performUserChecks();
}
+void CConfigManager::appendMonitorRule(const SMonitorRule& r) {
+ m_dMonitorRules.emplace_back(r);
+}
+
void CConfigManager::performMonitorReload() {
bool overAgain = false;
diff --git a/src/config/ConfigManager.hpp b/src/config/ConfigManager.hpp
index 2e723656..7fc132c6 100644
--- a/src/config/ConfigManager.hpp
+++ b/src/config/ConfigManager.hpp
@@ -127,6 +127,7 @@ class CConfigManager {
void dispatchExecOnce();
void performMonitorReload();
+ void appendMonitorRule(const SMonitorRule&);
bool m_bWantsMonitorReload = false;
bool m_bForceReload = false;
bool m_bNoMonitorReload = false;
diff --git a/src/events/Events.hpp b/src/events/Events.hpp
index c7e98e65..5fa93c49 100644
--- a/src/events/Events.hpp
+++ b/src/events/Events.hpp
@@ -65,10 +65,6 @@ namespace Events {
LISTENER(requestSetSel);
LISTENER(requestSetPrimarySel);
- // outputMgr
- LISTENER(outputMgrApply);
- LISTENER(outputMgrTest);
-
// Monitor part 2 the sequel
DYNLISTENFUNC(monitorFrame);
DYNLISTENFUNC(monitorDestroy);
diff --git a/src/events/Misc.cpp b/src/events/Misc.cpp
index 13dc85a3..a67a6753 100644
--- a/src/events/Misc.cpp
+++ b/src/events/Misc.cpp
@@ -16,16 +16,6 @@
// //
// ------------------------------ //
-void Events::listener_outputMgrApply(wl_listener* listener, void* data) {
- const auto CONFIG = (wlr_output_configuration_v1*)data;
- g_pHyprRenderer->outputMgrApplyTest(CONFIG, false);
-}
-
-void Events::listener_outputMgrTest(wl_listener* listener, void* data) {
- const auto CONFIG = (wlr_output_configuration_v1*)data;
- g_pHyprRenderer->outputMgrApplyTest(CONFIG, true);
-}
-
void Events::listener_leaseRequest(wl_listener* listener, void* data) {
const auto REQUEST = (wlr_drm_lease_request_v1*)data;
struct wlr_drm_lease_v1* lease = wlr_drm_lease_request_v1_grant(REQUEST);
diff --git a/src/events/Monitors.cpp b/src/events/Monitors.cpp
index 11b7a25c..69cc912d 100644
--- a/src/events/Monitors.cpp
+++ b/src/events/Monitors.cpp
@@ -16,50 +16,6 @@
// //
// --------------------------------------------------------- //
-void Events::listener_change(wl_listener* listener, void* data) {
- // layout got changed, let's update monitors.
- const auto CONFIG = wlr_output_configuration_v1_create();
-
- if (!CONFIG)
- return;
-
- for (auto& m : g_pCompositor->m_vRealMonitors) {
- if (!m->output)
- continue;
-
- if (g_pCompositor->m_pUnsafeOutput == m.get())
- continue;
-
- const auto CONFIGHEAD = wlr_output_configuration_head_v1_create(CONFIG, m->output);
-
- CBox BOX;
- wlr_output_layout_get_box(g_pCompositor->m_sWLROutputLayout, m->output, BOX.pWlr());
- BOX.applyFromWlr();
-
- //m->vecSize.x = BOX.width;
- // m->vecSize.y = BOX.height;
- m->vecPosition.x = BOX.x;
- m->vecPosition.y = BOX.y;
-
- CONFIGHEAD->state.enabled = m->output->enabled;
- CONFIGHEAD->state.mode = m->output->current_mode;
- if (!m->output->current_mode) {
- CONFIGHEAD->state.custom_mode = {
- m->output->width,
- m->output->height,
- m->output->refresh,
- };
- }
- CONFIGHEAD->state.x = m->vecPosition.x;
- CONFIGHEAD->state.y = m->vecPosition.y;
- CONFIGHEAD->state.transform = m->transform;
- CONFIGHEAD->state.scale = m->scale;
- CONFIGHEAD->state.adaptive_sync_enabled = m->vrrActive;
- }
-
- wlr_output_manager_v1_set_configuration(g_pCompositor->m_sWLROutputMgr, CONFIG);
-}
-
static void checkDefaultCursorWarp(std::shared_ptr* PNEWMONITORWRAP, std::string monitorName) {
const auto PNEWMONITOR = PNEWMONITORWRAP->get();
diff --git a/src/helpers/Monitor.hpp b/src/helpers/Monitor.hpp
index 81997514..a93d23af 100644
--- a/src/helpers/Monitor.hpp
+++ b/src/helpers/Monitor.hpp
@@ -96,6 +96,7 @@ class CMonitor {
float xwaylandScale = 1.f;
std::array projMatrix = {0};
std::optional forceSize;
+ wlr_output_mode* currentMode = nullptr;
bool dpmsStatus = true;
bool vrrActive = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
diff --git a/src/managers/ProtocolManager.cpp b/src/managers/ProtocolManager.cpp
index 8ec2a35f..115e10f4 100644
--- a/src/managers/ProtocolManager.cpp
+++ b/src/managers/ProtocolManager.cpp
@@ -22,6 +22,7 @@
#include "../protocols/InputMethodV2.hpp"
#include "../protocols/VirtualKeyboard.hpp"
#include "../protocols/VirtualPointer.hpp"
+#include "../protocols/OutputManagement.hpp"
CProtocolManager::CProtocolManager() {
@@ -47,6 +48,7 @@ CProtocolManager::CProtocolManager() {
PROTO::ime = std::make_unique(&zwp_input_method_manager_v2_interface, 1, "IMEv2");
PROTO::virtualKeyboard = std::make_unique(&zwp_virtual_keyboard_manager_v1_interface, 1, "VirtualKeyboard");
PROTO::virtualPointer = std::make_unique(&zwlr_virtual_pointer_manager_v1_interface, 2, "VirtualPointer");
+ PROTO::outputManagement = std::make_unique(&zwlr_output_manager_v1_interface, 4, "OutputManagement");
// Old protocol implementations.
// TODO: rewrite them to use hyprwayland-scanner.
diff --git a/src/protocols/OutputManagement.cpp b/src/protocols/OutputManagement.cpp
new file mode 100644
index 00000000..18be636d
--- /dev/null
+++ b/src/protocols/OutputManagement.cpp
@@ -0,0 +1,597 @@
+#include "OutputManagement.hpp"
+#include
+#include "../Compositor.hpp"
+
+#define LOGM PROTO::outputManagement->protoLog
+
+COutputManager::COutputManager(SP resource_) : resource(resource_) {
+ if (!good())
+ return;
+
+ LOGM(LOG, "New OutputManager registered");
+
+ resource->setOnDestroy([this](CZwlrOutputManagerV1* r) { PROTO::outputManagement->destroyResource(this); });
+
+ resource->setStop([this](CZwlrOutputManagerV1* r) { stopped = true; });
+
+ resource->setCreateConfiguration([this](CZwlrOutputManagerV1* r, uint32_t id, uint32_t serial) {
+ LOGM(LOG, "Creating new configuration");
+
+ const auto RESOURCE = PROTO::outputManagement->m_vConfigurations.emplace_back(
+ std::make_shared(std::make_shared(resource->client(), resource->version(), id), self.lock()));
+
+ if (!RESOURCE->good()) {
+ resource->noMemory();
+ PROTO::outputManagement->m_vConfigurations.pop_back();
+ return;
+ }
+ });
+
+ // send all heads at start
+ for (auto& m : g_pCompositor->m_vRealMonitors) {
+ if (m.get() == g_pCompositor->m_pUnsafeOutput)
+ continue;
+
+ LOGM(LOG, " | sending output head for {}", m->szName);
+
+ makeAndSendNewHead(m.get());
+ }
+
+ sendDone();
+}
+
+bool COutputManager::good() {
+ return resource->resource();
+}
+
+void COutputManager::makeAndSendNewHead(CMonitor* pMonitor) {
+ if (stopped)
+ return;
+
+ const auto RESOURCE =
+ PROTO::outputManagement->m_vHeads.emplace_back(std::make_shared(std::make_shared(resource->client(), resource->version(), 0), pMonitor));
+
+ if (!RESOURCE->good()) {
+ resource->noMemory();
+ PROTO::outputManagement->m_vHeads.pop_back();
+ return;
+ }
+
+ heads.push_back(RESOURCE);
+
+ resource->sendHead(RESOURCE->resource.get());
+ RESOURCE->sendAllData();
+}
+
+void COutputManager::ensureMonitorSent(CMonitor* pMonitor) {
+ if (pMonitor == g_pCompositor->m_pUnsafeOutput)
+ return;
+
+ for (auto& hw : heads) {
+ auto h = hw.lock();
+
+ if (!h)
+ continue;
+
+ if (h->pMonitor == pMonitor)
+ return;
+ }
+
+ makeAndSendNewHead(pMonitor);
+
+ sendDone();
+}
+
+void COutputManager::sendDone() {
+ resource->sendDone(wl_display_next_serial(g_pCompositor->m_sWLDisplay));
+}
+
+COutputHead::COutputHead(SP resource_, CMonitor* pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
+ if (!good())
+ return;
+
+ resource->setRelease([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
+ resource->setOnDestroy([this](CZwlrOutputHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
+
+ listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any d) {
+ resource->sendFinished();
+
+ for (auto& mw : modes) {
+ auto m = mw.lock();
+
+ if (!m)
+ continue;
+
+ m->resource->sendFinished();
+ }
+
+ pMonitor = nullptr;
+ });
+
+ listeners.monitorModeChange = pMonitor->events.modeChanged.registerListener([this](std::any d) { updateMode(); });
+}
+
+bool COutputHead::good() {
+ return resource->resource();
+}
+
+void COutputHead::sendAllData() {
+ const auto VERSION = resource->version();
+
+ resource->sendName(pMonitor->szName.c_str());
+ resource->sendDescription(pMonitor->szDescription.c_str());
+ if (pMonitor->output->phys_width > 0 && pMonitor->output->phys_height > 0)
+ resource->sendPhysicalSize(pMonitor->output->phys_width, pMonitor->output->phys_height);
+ resource->sendEnabled(pMonitor->m_bEnabled);
+
+ if (pMonitor->m_bEnabled) {
+ resource->sendPosition(pMonitor->vecPosition.x, pMonitor->vecPosition.y);
+ resource->sendTransform(pMonitor->transform);
+ resource->sendScale(wl_fixed_from_double(pMonitor->scale));
+ }
+
+ if (pMonitor->output->make && VERSION >= 2)
+ resource->sendMake(pMonitor->output->make);
+ if (pMonitor->output->model && VERSION >= 2)
+ resource->sendModel(pMonitor->output->model);
+ if (pMonitor->output->serial && VERSION >= 2)
+ resource->sendSerialNumber(pMonitor->output->serial);
+
+ if (VERSION >= 4)
+ resource->sendAdaptiveSync(pMonitor->vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
+
+ // send all available modes
+
+ if (modes.empty()) {
+ if (!wl_list_empty(&pMonitor->output->modes)) {
+ wlr_output_mode* mode;
+
+ wl_list_for_each(mode, &pMonitor->output->modes, link) {
+ makeAndSendNewMode(mode);
+ }
+ } else
+ makeAndSendNewMode(nullptr);
+ }
+
+ // send current mode
+ if (pMonitor->m_bEnabled) {
+ for (auto& mw : modes) {
+ auto m = mw.lock();
+
+ if (!m)
+ continue;
+
+ if (m->mode == pMonitor->currentMode) {
+ if (m->mode)
+ LOGM(LOG, " | sending current mode for {}: {}x{}@{}", pMonitor->szName, m->mode->width, m->mode->height, m->mode->refresh);
+ else
+ LOGM(LOG, " | sending current mode for {}: null (fake)", pMonitor->szName);
+ resource->sendCurrentMode(m->resource->resource());
+ break;
+ }
+ }
+ }
+}
+
+void COutputHead::updateMode() {
+ resource->sendEnabled(pMonitor->m_bEnabled);
+
+ if (pMonitor->m_bEnabled) {
+ resource->sendPosition(pMonitor->vecPosition.x, pMonitor->vecPosition.y);
+ resource->sendTransform(pMonitor->transform);
+ resource->sendScale(wl_fixed_from_double(pMonitor->scale));
+ }
+
+ if (resource->version() >= 4)
+ resource->sendAdaptiveSync(pMonitor->vrrActive ? ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_ENABLED : ZWLR_OUTPUT_HEAD_V1_ADAPTIVE_SYNC_STATE_DISABLED);
+
+ if (pMonitor->m_bEnabled) {
+ for (auto& mw : modes) {
+ auto m = mw.lock();
+
+ if (!m)
+ continue;
+
+ if (m->mode == pMonitor->currentMode) {
+ if (m->mode)
+ LOGM(LOG, " | sending current mode for {}: {}x{}@{}", pMonitor->szName, m->mode->width, m->mode->height, m->mode->refresh);
+ else
+ LOGM(LOG, " | sending current mode for {}: null (fake)", pMonitor->szName);
+ resource->sendCurrentMode(m->resource->resource());
+ break;
+ }
+ }
+ }
+}
+
+void COutputHead::makeAndSendNewMode(wlr_output_mode* mode) {
+ const auto RESOURCE =
+ PROTO::outputManagement->m_vModes.emplace_back(std::make_shared(std::make_shared(resource->client(), resource->version(), 0), mode));
+
+ if (!RESOURCE->good()) {
+ resource->noMemory();
+ PROTO::outputManagement->m_vModes.pop_back();
+ return;
+ }
+
+ modes.push_back(RESOURCE);
+ resource->sendMode(RESOURCE->resource.get());
+ RESOURCE->sendAllData();
+}
+
+CMonitor* COutputHead::monitor() {
+ return pMonitor;
+}
+
+COutputMode::COutputMode(SP resource_, wlr_output_mode* mode_) : resource(resource_), mode(mode_) {
+ if (!good())
+ return;
+
+ resource->setRelease([this](CZwlrOutputModeV1* r) { PROTO::outputManagement->destroyResource(this); });
+ resource->setOnDestroy([this](CZwlrOutputModeV1* r) { PROTO::outputManagement->destroyResource(this); });
+}
+
+void COutputMode::sendAllData() {
+ if (!mode)
+ return;
+
+ LOGM(LOG, " | sending mode {}x{}@{}mHz, pref: {}", mode->width, mode->height, mode->refresh, mode->preferred);
+
+ resource->sendSize(mode->width, mode->height);
+ if (mode->refresh > 0)
+ resource->sendRefresh(mode->refresh);
+ if (mode->preferred)
+ resource->sendPreferred();
+}
+
+bool COutputMode::good() {
+ return resource->resource();
+}
+
+wlr_output_mode* COutputMode::getMode() {
+ return mode;
+}
+
+COutputConfiguration::COutputConfiguration(SP resource_, SP owner_) : resource(resource_), owner(owner_) {
+ if (!good())
+ return;
+
+ resource->setDestroy([this](CZwlrOutputConfigurationV1* r) { PROTO::outputManagement->destroyResource(this); });
+ resource->setOnDestroy([this](CZwlrOutputConfigurationV1* r) { PROTO::outputManagement->destroyResource(this); });
+
+ resource->setEnableHead([this](CZwlrOutputConfigurationV1* r, uint32_t id, wl_resource* outputHead) {
+ const auto HEAD = PROTO::outputManagement->headFromResource(outputHead);
+
+ if (!HEAD) {
+ LOGM(ERR, "No head in setEnableHead??");
+ return;
+ }
+
+ const auto PMONITOR = HEAD->monitor();
+
+ if (!PMONITOR) {
+ LOGM(ERR, "No monitor in setEnableHead??");
+ return;
+ }
+
+ const auto RESOURCE = PROTO::outputManagement->m_vConfigurationHeads.emplace_back(
+ std::make_shared(std::make_shared(resource->client(), resource->version(), id), PMONITOR));
+
+ if (!RESOURCE->good()) {
+ resource->noMemory();
+ PROTO::outputManagement->m_vConfigurationHeads.pop_back();
+ return;
+ }
+
+ heads.push_back(RESOURCE);
+
+ LOGM(LOG, "enableHead on {}. For now, doing nothing. Waiting for apply().", PMONITOR->szName);
+ });
+
+ resource->setDisableHead([this](CZwlrOutputConfigurationV1* r, wl_resource* outputHead) {
+ const auto HEAD = PROTO::outputManagement->headFromResource(outputHead);
+
+ if (!HEAD) {
+ LOGM(ERR, "No head in setDisableHead??");
+ return;
+ }
+
+ const auto PMONITOR = HEAD->monitor();
+
+ if (!PMONITOR) {
+ LOGM(ERR, "No monitor in setDisableHead??");
+ return;
+ }
+
+ LOGM(LOG, "disableHead on {}", PMONITOR->szName);
+
+ PMONITOR->activeMonitorRule.disabled = true;
+ g_pHyprRenderer->applyMonitorRule(PMONITOR, &PMONITOR->activeMonitorRule, false);
+ });
+
+ resource->setTest([this](CZwlrOutputConfigurationV1* r) {
+ const auto SUCCESS = applyTestConfiguration(true);
+
+ if (SUCCESS)
+ resource->sendSucceeded();
+ else
+ resource->sendFailed();
+ });
+
+ resource->setApply([this](CZwlrOutputConfigurationV1* r) {
+ const auto SUCCESS = applyTestConfiguration(false);
+
+ if (SUCCESS)
+ resource->sendSucceeded();
+ else
+ resource->sendFailed();
+
+ owner.lock()->sendDone();
+ });
+}
+
+bool COutputConfiguration::good() {
+ return resource->resource();
+}
+
+bool COutputConfiguration::applyTestConfiguration(bool test) {
+ if (test) {
+ LOGM(WARN, "TODO: STUB: applyTestConfiguration for test not implemented, returning true.");
+ return true;
+ }
+
+ LOGM(LOG, "Applying configuration");
+
+ for (auto& headw : heads) {
+ auto head = headw.lock();
+
+ if (!head)
+ continue;
+
+ const auto PMONITOR = head->pMonitor;
+
+ if (!PMONITOR)
+ continue;
+
+ LOGM(LOG, "Applying config for monitor {}", PMONITOR->szName);
+
+ SMonitorRule newRule = PMONITOR->activeMonitorRule;
+ newRule.name = PMONITOR->szName;
+
+ if (head->committedProperties & COutputConfigurationHead::eCommittedProperties::OUTPUT_HEAD_COMMITTED_MODE) {
+ newRule.resolution = {head->state.mode.lock()->getMode()->width, head->state.mode.lock()->getMode()->height};
+ newRule.refreshRate = head->state.mode.lock()->getMode()->refresh / 1000.F;
+ } else if (head->committedProperties & COutputConfigurationHead::eCommittedProperties::OUTPUT_HEAD_COMMITTED_CUSTOM_MODE) {
+ newRule.resolution = head->state.customMode.size;
+ newRule.refreshRate = head->state.customMode.refresh / 1000.F;
+ }
+
+ if (head->committedProperties & COutputConfigurationHead::eCommittedProperties::OUTPUT_HEAD_COMMITTED_POSITION)
+ newRule.offset = head->state.position;
+
+ if (head->committedProperties & COutputConfigurationHead::eCommittedProperties::OUTPUT_HEAD_COMMITTED_ADAPTIVE_SYNC)
+ newRule.vrr = head->state.adaptiveSync;
+
+ if (head->committedProperties & COutputConfigurationHead::eCommittedProperties::OUTPUT_HEAD_COMMITTED_SCALE)
+ newRule.scale = head->state.scale;
+
+ if (head->committedProperties & COutputConfigurationHead::eCommittedProperties::OUTPUT_HEAD_COMMITTED_TRANSFORM)
+ newRule.transform = head->state.transform;
+
+ // reset properties for next set.
+ head->committedProperties = 0;
+
+ g_pConfigManager->appendMonitorRule(newRule);
+ g_pConfigManager->m_bWantsMonitorReload = true;
+ }
+
+ LOGM(LOG, "Applied configuration");
+
+ return true;
+}
+
+COutputConfigurationHead::COutputConfigurationHead(SP resource_, CMonitor* pMonitor_) : resource(resource_), pMonitor(pMonitor_) {
+ if (!good())
+ return;
+
+ resource->setOnDestroy([this](CZwlrOutputConfigurationHeadV1* r) { PROTO::outputManagement->destroyResource(this); });
+
+ listeners.monitorDestroy = pMonitor->events.destroy.registerListener([this](std::any d) { pMonitor = nullptr; });
+
+ resource->setSetMode([this](CZwlrOutputConfigurationHeadV1* r, wl_resource* outputMode) {
+ const auto MODE = PROTO::outputManagement->modeFromResource(outputMode);
+
+ if (!MODE || !MODE->getMode()) {
+ LOGM(ERR, "No mode in setMode??");
+ return;
+ }
+
+ if (!pMonitor) {
+ LOGM(ERR, "setMode on inert resource");
+ return;
+ }
+
+ if (committedProperties & OUTPUT_HEAD_COMMITTED_MODE) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_ALREADY_SET, "Property already set");
+ return;
+ }
+
+ committedProperties |= OUTPUT_HEAD_COMMITTED_MODE;
+ state.mode = MODE;
+
+ LOGM(LOG, " | configHead for {}: set mode to {}x{}@{}", pMonitor->szName, MODE->getMode()->width, MODE->getMode()->height, MODE->getMode()->refresh);
+ });
+
+ resource->setSetCustomMode([this](CZwlrOutputConfigurationHeadV1* r, int32_t w, int32_t h, int32_t refresh) {
+ if (!pMonitor) {
+ LOGM(ERR, "setCustomMode on inert resource");
+ return;
+ }
+
+ if (committedProperties & OUTPUT_HEAD_COMMITTED_CUSTOM_MODE) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_ALREADY_SET, "Property already set");
+ return;
+ }
+
+ if (w <= 0 || h <= 0 || refresh <= 100) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_INVALID_CUSTOM_MODE, "Invalid mode");
+ return;
+ }
+
+ committedProperties |= OUTPUT_HEAD_COMMITTED_CUSTOM_MODE;
+ state.customMode = {{w, h}, (uint32_t)refresh};
+
+ LOGM(LOG, " | configHead for {}: set custom mode to {}x{}@{}", pMonitor->szName, w, h, refresh);
+ });
+
+ resource->setSetPosition([this](CZwlrOutputConfigurationHeadV1* r, int32_t x, int32_t y) {
+ if (!pMonitor) {
+ LOGM(ERR, "setMode on inert resource");
+ return;
+ }
+
+ if (committedProperties & OUTPUT_HEAD_COMMITTED_POSITION) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_ALREADY_SET, "Property already set");
+ return;
+ }
+
+ committedProperties |= OUTPUT_HEAD_COMMITTED_POSITION;
+ state.position = {x, y};
+
+ LOGM(LOG, " | configHead for {}: set pos to {}, {}", pMonitor->szName, x, y);
+ });
+
+ resource->setSetTransform([this](CZwlrOutputConfigurationHeadV1* r, int32_t transform) {
+ if (!pMonitor) {
+ LOGM(ERR, "setMode on inert resource");
+ return;
+ }
+
+ if (committedProperties & OUTPUT_HEAD_COMMITTED_TRANSFORM) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_ALREADY_SET, "Property already set");
+ return;
+ }
+
+ if (transform < 0 || transform > 7) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_INVALID_TRANSFORM, "Invalid transform");
+ return;
+ }
+
+ committedProperties |= OUTPUT_HEAD_COMMITTED_TRANSFORM;
+ state.transform = (wl_output_transform)transform;
+
+ LOGM(LOG, " | configHead for {}: set transform to {}", pMonitor->szName, transform);
+ });
+
+ resource->setSetScale([this](CZwlrOutputConfigurationHeadV1* r, wl_fixed_t scale_) {
+ if (!pMonitor) {
+ LOGM(ERR, "setMode on inert resource");
+ return;
+ }
+
+ if (committedProperties & OUTPUT_HEAD_COMMITTED_SCALE) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_ALREADY_SET, "Property already set");
+ return;
+ }
+
+ double scale = wl_fixed_to_double(scale_);
+
+ if (scale < 0.1 || scale > 10.0) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_INVALID_SCALE, "Invalid scale");
+ return;
+ }
+
+ committedProperties |= OUTPUT_HEAD_COMMITTED_SCALE;
+ state.scale = scale;
+
+ LOGM(LOG, " | configHead for {}: set scale to {:.2f}", pMonitor->szName, scale);
+ });
+
+ resource->setSetAdaptiveSync([this](CZwlrOutputConfigurationHeadV1* r, uint32_t as) {
+ if (!pMonitor) {
+ LOGM(ERR, "setMode on inert resource");
+ return;
+ }
+
+ if (committedProperties & OUTPUT_HEAD_COMMITTED_ADAPTIVE_SYNC) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_ALREADY_SET, "Property already set");
+ return;
+ }
+
+ if (as > 1) {
+ resource->error(ZWLR_OUTPUT_CONFIGURATION_HEAD_V1_ERROR_INVALID_ADAPTIVE_SYNC_STATE, "Invalid adaptive sync state");
+ return;
+ }
+
+ committedProperties |= OUTPUT_HEAD_COMMITTED_ADAPTIVE_SYNC;
+ state.adaptiveSync = as;
+
+ LOGM(LOG, " | configHead for {}: set adaptiveSync to {}", pMonitor->szName, as);
+ });
+}
+
+bool COutputConfigurationHead::good() {
+ return resource->resource();
+}
+
+COutputManagementProtocol::COutputManagementProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
+ static auto P = g_pHookSystem->hookDynamic("monitorLayoutChanged", [this](void* self, SCallbackInfo& info, std::any param) { this->updateAllOutputs(); });
+}
+
+void COutputManagementProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
+ const auto RESOURCE = m_vManagers.emplace_back(std::make_shared(std::make_shared(client, ver, id)));
+
+ if (!RESOURCE->good()) {
+ wl_client_post_no_memory(client);
+ m_vManagers.pop_back();
+ return;
+ }
+
+ RESOURCE->self = RESOURCE;
+}
+
+void COutputManagementProtocol::destroyResource(COutputManager* resource) {
+ std::erase_if(m_vManagers, [&](const auto& other) { return other.get() == resource; });
+}
+
+void COutputManagementProtocol::destroyResource(COutputHead* resource) {
+ std::erase_if(m_vHeads, [&](const auto& other) { return other.get() == resource; });
+}
+
+void COutputManagementProtocol::destroyResource(COutputMode* resource) {
+ std::erase_if(m_vModes, [&](const auto& other) { return other.get() == resource; });
+}
+
+void COutputManagementProtocol::destroyResource(COutputConfiguration* resource) {
+ std::erase_if(m_vConfigurations, [&](const auto& other) { return other.get() == resource; });
+}
+
+void COutputManagementProtocol::destroyResource(COutputConfigurationHead* resource) {
+ std::erase_if(m_vConfigurationHeads, [&](const auto& other) { return other.get() == resource; });
+}
+
+void COutputManagementProtocol::updateAllOutputs() {
+ for (auto& m : g_pCompositor->m_vRealMonitors) {
+ for (auto& mgr : m_vManagers) {
+ mgr->ensureMonitorSent(m.get());
+ }
+ }
+}
+
+SP COutputManagementProtocol::headFromResource(wl_resource* r) {
+ for (auto& h : m_vHeads) {
+ if (h->resource->resource() == r)
+ return h;
+ }
+
+ return nullptr;
+}
+
+SP COutputManagementProtocol::modeFromResource(wl_resource* r) {
+ for (auto& h : m_vModes) {
+ if (h->resource->resource() == r)
+ return h;
+ }
+
+ return nullptr;
+}
diff --git a/src/protocols/OutputManagement.hpp b/src/protocols/OutputManagement.hpp
new file mode 100644
index 00000000..12e324b7
--- /dev/null
+++ b/src/protocols/OutputManagement.hpp
@@ -0,0 +1,166 @@
+#pragma once
+
+#include
+#include
+#include
+#include "WaylandProtocol.hpp"
+#include "wlr-output-management-unstable-v1.hpp"
+#include "../helpers/signal/Listener.hpp"
+
+class CMonitor;
+
+class COutputHead;
+class COutputMode;
+
+class COutputManager {
+ public:
+ COutputManager(SP resource_);
+
+ bool good();
+ void ensureMonitorSent(CMonitor* pMonitor);
+ void sendDone();
+
+ private:
+ SP resource;
+ bool stopped = false;
+
+ WP self;
+
+ std::vector> heads;
+
+ void makeAndSendNewHead(CMonitor* pMonitor);
+ friend class COutputManagementProtocol;
+};
+
+class COutputMode {
+ public:
+ COutputMode(SP resource_, wlr_output_mode* mode_);
+
+ bool good();
+ wlr_output_mode* getMode();
+ void sendAllData();
+
+ private:
+ SP resource;
+ wlr_output_mode* mode = nullptr;
+
+ friend class COutputHead;
+ friend class COutputManagementProtocol;
+};
+
+class COutputHead {
+ public:
+ COutputHead(SP resource_, CMonitor* pMonitor_);
+
+ bool good();
+ void sendAllData(); // this has to be separate as we need to send the head first, then set the data
+ void updateMode();
+ CMonitor* monitor();
+
+ private:
+ SP resource;
+ CMonitor* pMonitor = nullptr;
+
+ void makeAndSendNewMode(wlr_output_mode* mode);
+ void sendCurrentMode();
+
+ std::vector> modes;
+
+ struct {
+ CHyprSignalListener monitorDestroy;
+ CHyprSignalListener monitorModeChange;
+ } listeners;
+
+ friend class COutputManager;
+ friend class COutputManagementProtocol;
+};
+
+class COutputConfigurationHead {
+ public:
+ COutputConfigurationHead(SP resource_, CMonitor* pMonitor_);
+
+ bool good();
+
+ enum eCommittedProperties : uint32_t {
+ OUTPUT_HEAD_COMMITTED_MODE = (1 << 0),
+ OUTPUT_HEAD_COMMITTED_CUSTOM_MODE = (1 << 1),
+ OUTPUT_HEAD_COMMITTED_POSITION = (1 << 2),
+ OUTPUT_HEAD_COMMITTED_TRANSFORM = (1 << 3),
+ OUTPUT_HEAD_COMMITTED_SCALE = (1 << 4),
+ OUTPUT_HEAD_COMMITTED_ADAPTIVE_SYNC = (1 << 5),
+ };
+
+ uint32_t committedProperties = 0;
+
+ struct {
+ WP mode;
+ struct {
+ Vector2D size;
+ uint32_t refresh = 0;
+ } customMode;
+ Vector2D position;
+ wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
+ float scale = 1.F;
+ bool adaptiveSync = false;
+ } state;
+
+ private:
+ SP resource;
+ CMonitor* pMonitor = nullptr;
+
+ struct {
+ CHyprSignalListener monitorDestroy;
+ } listeners;
+
+ friend class COutputConfiguration;
+};
+
+class COutputConfiguration {
+ public:
+ COutputConfiguration(SP resource_, SP owner_);
+
+ bool good();
+
+ private:
+ SP resource;
+ std::vector> heads;
+ WP owner;
+
+ bool applyTestConfiguration(bool test);
+};
+
+class COutputManagementProtocol : public IWaylandProtocol {
+ public:
+ COutputManagementProtocol(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);
+
+ private:
+ void destroyResource(COutputManager* resource);
+ void destroyResource(COutputHead* resource);
+ void destroyResource(COutputMode* resource);
+ void destroyResource(COutputConfiguration* resource);
+ void destroyResource(COutputConfigurationHead* resource);
+
+ void updateAllOutputs();
+
+ //
+ std::vector> m_vManagers;
+ std::vector> m_vHeads;
+ std::vector> m_vModes;
+ std::vector> m_vConfigurations;
+ std::vector> m_vConfigurationHeads;
+
+ SP headFromResource(wl_resource* r);
+ SP modeFromResource(wl_resource* r);
+
+ friend class COutputManager;
+ friend class COutputHead;
+ friend class COutputMode;
+ friend class COutputConfiguration;
+ friend class COutputConfigurationHead;
+};
+
+namespace PROTO {
+ inline UP outputManagement;
+};
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index 6c4c6a7b..7053adf7 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -1474,70 +1474,6 @@ void CHyprRenderer::setWindowScanoutMode(PHLWINDOW pWindow) {
Debug::log(LOG, "Scanout mode ON set for {}", pWindow);
}
-void CHyprRenderer::outputMgrApplyTest(wlr_output_configuration_v1* config, bool test) {
- wlr_output_configuration_head_v1* head;
- bool ok = true;
-
- wl_list_for_each(head, &config->heads, link) {
-
- std::string commandForCfg = "";
- const auto OUTPUT = head->state.output;
-
- commandForCfg += std::string(OUTPUT->name) + ",";
-
- if (!head->state.enabled) {
- commandForCfg += "disabled";
- if (!test)
- g_pConfigManager->parseKeyword("monitor", commandForCfg);
- continue;
- }
-
- const auto PMONITOR = g_pCompositor->getRealMonitorFromOutput(OUTPUT);
- RASSERT(PMONITOR, "nullptr monitor in outputMgrApplyTest");
- wlr_output_state_set_enabled(PMONITOR->state.wlr(), head->state.enabled);
-
- if (head->state.mode)
- commandForCfg +=
- std::to_string(head->state.mode->width) + "x" + std::to_string(head->state.mode->height) + "@" + std::to_string(head->state.mode->refresh / 1000.f) + ",";
- else
- commandForCfg += std::to_string(head->state.custom_mode.width) + "x" + std::to_string(head->state.custom_mode.height) + "@" +
- std::to_string(head->state.custom_mode.refresh / 1000.f) + ",";
-
- commandForCfg += std::to_string(head->state.x) + "x" + std::to_string(head->state.y) + "," + std::to_string(head->state.scale) + ",transform," +
- std::to_string((int)head->state.transform);
-
- if (!test) {
- g_pConfigManager->parseKeyword("monitor", commandForCfg);
- wlr_output_state_set_adaptive_sync_enabled(PMONITOR->state.wlr(), head->state.adaptive_sync_enabled);
- }
-
- ok = wlr_output_test_state(OUTPUT, PMONITOR->state.wlr());
-
- if (!ok)
- break;
- }
-
- if (!test) {
- g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
- // if everything is disabled, performMonitorReload won't be called from renderMonitor
- bool allDisabled = std::all_of(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(),
- [](const auto m) { return !m->m_bEnabled || g_pCompositor->m_pUnsafeOutput == m.get(); });
- if (allDisabled) {
- Debug::log(LOG, "OutputMgr apply: All monitors disabled; performing monitor reload.");
- g_pConfigManager->performMonitorReload();
- }
- }
-
- if (ok)
- wlr_output_configuration_v1_send_succeeded(config);
- else
- wlr_output_configuration_v1_send_failed(config);
-
- wlr_output_configuration_v1_destroy(config);
-
- Debug::log(LOG, "OutputMgr Applied/Tested.");
-}
-
// taken from Sway.
// this is just too much of a spaghetti for me to understand
static void applyExclusive(wlr_box& usableArea, uint32_t anchor, int32_t exclusive, int32_t marginTop, int32_t marginRight, int32_t marginBottom, int32_t marginLeft) {
@@ -1939,6 +1875,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
// Needed in case we are switching from a custom modeline to a standard mode
pMonitor->customDrmMode = {};
+ pMonitor->currentMode = nullptr;
bool autoScale = false;
if (RULE->scale > 0.1) {
@@ -1981,6 +1918,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
pMonitor->refreshRate = mode->refresh / 1000.f;
pMonitor->vecSize = Vector2D(mode->width, mode->height);
+ pMonitor->currentMode = mode;
break;
}
@@ -2010,6 +1948,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
+ pMonitor->currentMode = PREFERREDMODE;
} else {
Debug::log(LOG, "Set a custom mode {:X0}@{:2f} (mode not found in monitor modes)", RULE->resolution, (float)RULE->refreshRate);
}
@@ -2118,6 +2057,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
+ pMonitor->currentMode = PREFERREDMODE;
} else {
Debug::log(LOG, "Monitor {}: Applying highest mode {}x{}@{:2f}.", pMonitor->output->name, (int)currentWidth, (int)currentHeight, (int)currentRefresh / 1000.f);
@@ -2148,6 +2088,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
pMonitor->refreshRate = mode->refresh / 1000.f;
pMonitor->vecSize = Vector2D(mode->width, mode->height);
+ pMonitor->currentMode = mode;
break;
}
@@ -2158,6 +2099,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
pMonitor->vecSize = Vector2D(PREFERREDMODE->width, PREFERREDMODE->height);
pMonitor->refreshRate = PREFERREDMODE->refresh / 1000.f;
+ pMonitor->currentMode = PREFERREDMODE;
Debug::log(LOG, "Setting preferred mode for {}", pMonitor->output->name);
}
@@ -2307,8 +2249,6 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
pMonitor->events.modeChanged.emit();
- Events::listener_change(nullptr, nullptr);
-
return true;
}
diff --git a/src/render/Renderer.hpp b/src/render/Renderer.hpp
index fcf3f20b..b93af0b0 100644
--- a/src/render/Renderer.hpp
+++ b/src/render/Renderer.hpp
@@ -43,7 +43,6 @@ class CHyprRenderer {
CHyprRenderer();
void renderMonitor(CMonitor* pMonitor);
- void outputMgrApplyTest(wlr_output_configuration_v1*, bool);
void arrangeLayersForMonitor(const int&);
void damageSurface(wlr_surface*, double, double, double scale = 1.0);
void damageWindow(PHLWINDOW, bool forceFull = false);