summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/Compositor.cpp2
-rw-r--r--src/desktop/Window.cpp62
-rw-r--r--src/events/Windows.cpp18
-rw-r--r--src/layout/IHyprLayout.cpp4
-rw-r--r--src/managers/ANRManager.cpp2
-rw-r--r--src/managers/XWaylandManager.cpp14
-rw-r--r--src/protocols/XDGOutput.cpp2
-rw-r--r--src/protocols/core/DataDevice.cpp8
-rw-r--r--src/xwayland/Dnd.cpp108
-rw-r--r--src/xwayland/Dnd.hpp35
-rw-r--r--src/xwayland/Server.cpp86
-rw-r--r--src/xwayland/Server.hpp28
-rw-r--r--src/xwayland/XDataSource.cpp44
-rw-r--r--src/xwayland/XDataSource.hpp6
-rw-r--r--src/xwayland/XSurface.cpp166
-rw-r--r--src/xwayland/XSurface.hpp59
-rw-r--r--src/xwayland/XWM.cpp603
-rw-r--r--src/xwayland/XWM.hpp72
-rw-r--r--src/xwayland/XWayland.cpp8
-rw-r--r--src/xwayland/XWayland.hpp8
20 files changed, 661 insertions, 674 deletions
diff --git a/src/Compositor.cpp b/src/Compositor.cpp
index dd098df2..ece6691a 100644
--- a/src/Compositor.cpp
+++ b/src/Compositor.cpp
@@ -2394,7 +2394,7 @@ PHLWINDOW CCompositor::getX11Parent(PHLWINDOW pWindow) {
if (!w->m_isX11)
continue;
- if (w->m_xwaylandSurface == pWindow->m_xwaylandSurface->parent)
+ if (w->m_xwaylandSurface == pWindow->m_xwaylandSurface->m_parent)
return w;
}
diff --git a/src/desktop/Window.cpp b/src/desktop/Window.cpp
index 6e6e51a1..c712e5eb 100644
--- a/src/desktop/Window.cpp
+++ b/src/desktop/Window.cpp
@@ -100,18 +100,18 @@ CWindow::CWindow(SP<CXDGSurfaceResource> resource) : m_xdgSurface(resource) {
CWindow::CWindow(SP<CXWaylandSurface> surface) : m_xwaylandSurface(surface) {
m_wlSurface = CWLSurface::create();
- m_listeners.map = m_xwaylandSurface->events.map.registerListener([this](std::any d) { Events::listener_mapWindow(this, nullptr); });
- m_listeners.unmap = m_xwaylandSurface->events.unmap.registerListener([this](std::any d) { Events::listener_unmapWindow(this, nullptr); });
- m_listeners.destroy = m_xwaylandSurface->events.destroy.registerListener([this](std::any d) { Events::listener_destroyWindow(this, nullptr); });
- m_listeners.commit = m_xwaylandSurface->events.commit.registerListener([this](std::any d) { Events::listener_commitWindow(this, nullptr); });
- m_listeners.configureRequest = m_xwaylandSurface->events.configureRequest.registerListener([this](std::any d) { onX11ConfigureRequest(std::any_cast<CBox>(d)); });
- m_listeners.updateState = m_xwaylandSurface->events.stateChanged.registerListener([this](std::any d) { onUpdateState(); });
- m_listeners.updateMetadata = m_xwaylandSurface->events.metadataChanged.registerListener([this](std::any d) { onUpdateMeta(); });
- m_listeners.resourceChange = m_xwaylandSurface->events.resourceChange.registerListener([this](std::any d) { onResourceChangeX11(); });
- m_listeners.activate = m_xwaylandSurface->events.activate.registerListener([this](std::any d) { Events::listener_activateX11(this, nullptr); });
+ m_listeners.map = m_xwaylandSurface->m_events.map.registerListener([this](std::any d) { Events::listener_mapWindow(this, nullptr); });
+ m_listeners.unmap = m_xwaylandSurface->m_events.unmap.registerListener([this](std::any d) { Events::listener_unmapWindow(this, nullptr); });
+ m_listeners.destroy = m_xwaylandSurface->m_events.destroy.registerListener([this](std::any d) { Events::listener_destroyWindow(this, nullptr); });
+ m_listeners.commit = m_xwaylandSurface->m_events.commit.registerListener([this](std::any d) { Events::listener_commitWindow(this, nullptr); });
+ m_listeners.configureRequest = m_xwaylandSurface->m_events.configureRequest.registerListener([this](std::any d) { onX11ConfigureRequest(std::any_cast<CBox>(d)); });
+ m_listeners.updateState = m_xwaylandSurface->m_events.stateChanged.registerListener([this](std::any d) { onUpdateState(); });
+ m_listeners.updateMetadata = m_xwaylandSurface->m_events.metadataChanged.registerListener([this](std::any d) { onUpdateMeta(); });
+ m_listeners.resourceChange = m_xwaylandSurface->m_events.resourceChange.registerListener([this](std::any d) { onResourceChangeX11(); });
+ m_listeners.activate = m_xwaylandSurface->m_events.activate.registerListener([this](std::any d) { Events::listener_activateX11(this, nullptr); });
- if (m_xwaylandSurface->overrideRedirect)
- m_listeners.setGeometry = m_xwaylandSurface->events.setGeometry.registerListener([this](std::any d) { Events::listener_unmanagedSetGeometry(this, nullptr); });
+ if (m_xwaylandSurface->m_overrideRedirect)
+ m_listeners.setGeometry = m_xwaylandSurface->m_events.setGeometry.registerListener([this](std::any d) { Events::listener_unmanagedSetGeometry(this, nullptr); });
}
CWindow::~CWindow() {
@@ -352,7 +352,7 @@ pid_t CWindow::getPID() {
if (!m_xwaylandSurface)
return -1;
- PID = m_xwaylandSurface->pid;
+ PID = m_xwaylandSurface->m_pid;
}
return PID;
@@ -471,10 +471,10 @@ void CWindow::moveToWorkspace(PHLWORKSPACE pWorkspace) {
}
PHLWINDOW CWindow::x11TransientFor() {
- if (!m_xwaylandSurface || !m_xwaylandSurface->parent)
+ if (!m_xwaylandSurface || !m_xwaylandSurface->m_parent)
return nullptr;
- auto s = m_xwaylandSurface->parent;
+ auto s = m_xwaylandSurface->m_parent;
std::vector<SP<CXWaylandSurface>> visited;
while (s) {
// break loops. Some X apps make them, and it seems like it's valid behavior?!?!?!
@@ -483,7 +483,7 @@ PHLWINDOW CWindow::x11TransientFor() {
break;
visited.emplace_back(s.lock());
- s = s->parent;
+ s = s->m_parent;
}
if (s == m_xwaylandSurface)
@@ -1159,8 +1159,8 @@ bool CWindow::opaque() {
if (PWORKSPACE->m_alpha->value() != 1.f)
return false;
- if (m_isX11 && m_xwaylandSurface && m_xwaylandSurface->surface && m_xwaylandSurface->surface->m_current.texture)
- return m_xwaylandSurface->surface->m_current.texture->m_opaque;
+ if (m_isX11 && m_xwaylandSurface && m_xwaylandSurface->m_surface && m_xwaylandSurface->m_surface->m_current.texture)
+ return m_xwaylandSurface->m_surface->m_current.texture->m_opaque;
if (!m_wlSurface->resource() || !m_wlSurface->resource()->m_current.texture)
return false;
@@ -1418,9 +1418,9 @@ void CWindow::activate(bool force) {
}
void CWindow::onUpdateState() {
- std::optional<bool> requestsFS = m_xdgSurface ? m_xdgSurface->m_toplevel->m_state.requestsFullscreen : m_xwaylandSurface->state.requestsFullscreen;
+ std::optional<bool> requestsFS = m_xdgSurface ? m_xdgSurface->m_toplevel->m_state.requestsFullscreen : m_xwaylandSurface->m_state.requestsFullscreen;
std::optional<MONITORID> requestsID = m_xdgSurface ? m_xdgSurface->m_toplevel->m_state.requestsFullscreenMonitor : MONITOR_INVALID;
- std::optional<bool> requestsMX = m_xdgSurface ? m_xdgSurface->m_toplevel->m_state.requestsMaximize : m_xwaylandSurface->state.requestsMaximize;
+ std::optional<bool> requestsMX = m_xdgSurface ? m_xdgSurface->m_toplevel->m_state.requestsMaximize : m_xwaylandSurface->m_state.requestsMaximize;
if (requestsFS.has_value() && !(m_suppressedEvents & SUPPRESS_FULLSCREEN)) {
if (requestsID.has_value() && (requestsID.value() != MONITOR_INVALID) && !(m_suppressedEvents & SUPPRESS_FULLSCREEN_OUTPUT)) {
@@ -1495,7 +1495,7 @@ std::string CWindow::fetchTitle() {
return m_xdgSurface->m_toplevel->m_state.title;
} else {
if (m_xwaylandSurface)
- return m_xwaylandSurface->state.title;
+ return m_xwaylandSurface->m_state.title;
}
return "";
@@ -1507,7 +1507,7 @@ std::string CWindow::fetchClass() {
return m_xdgSurface->m_toplevel->m_state.appid;
} else {
if (m_xwaylandSurface)
- return m_xwaylandSurface->state.appid;
+ return m_xwaylandSurface->m_state.appid;
}
return "";
@@ -1524,9 +1524,9 @@ void CWindow::onAck(uint32_t serial) {
}
void CWindow::onResourceChangeX11() {
- if (m_xwaylandSurface->surface && !m_wlSurface->resource())
- m_wlSurface->assign(m_xwaylandSurface->surface.lock(), m_self.lock());
- else if (!m_xwaylandSurface->surface && m_wlSurface->resource())
+ if (m_xwaylandSurface->m_surface && !m_wlSurface->resource())
+ m_wlSurface->assign(m_xwaylandSurface->m_surface.lock(), m_self.lock());
+ else if (!m_xwaylandSurface->m_surface && m_wlSurface->resource())
m_wlSurface->unassign();
// update metadata as well,
@@ -1538,7 +1538,7 @@ void CWindow::onResourceChangeX11() {
void CWindow::onX11ConfigureRequest(CBox box) {
- if (!m_xwaylandSurface->surface || !m_xwaylandSurface->mapped || !m_isMapped) {
+ if (!m_xwaylandSurface->m_surface || !m_xwaylandSurface->m_mapped || !m_isMapped) {
m_xwaylandSurface->configure(box);
m_pendingReportedSize = box.size();
m_reportedSize = box.size();
@@ -1668,18 +1668,18 @@ void CWindow::unsetWindowData(eOverridePriority priority) {
}
bool CWindow::isX11OverrideRedirect() {
- return m_xwaylandSurface && m_xwaylandSurface->overrideRedirect;
+ return m_xwaylandSurface && m_xwaylandSurface->m_overrideRedirect;
}
bool CWindow::isModal() {
- return (m_xwaylandSurface && m_xwaylandSurface->modal);
+ return (m_xwaylandSurface && m_xwaylandSurface->m_modal);
}
Vector2D CWindow::requestedMinSize() {
- if ((m_isX11 && !m_xwaylandSurface->sizeHints) || (!m_isX11 && !m_xdgSurface->m_toplevel))
+ if ((m_isX11 && !m_xwaylandSurface->m_sizeHints) || (!m_isX11 && !m_xdgSurface->m_toplevel))
return Vector2D(1, 1);
- Vector2D minSize = m_isX11 ? Vector2D(m_xwaylandSurface->sizeHints->min_width, m_xwaylandSurface->sizeHints->min_height) : m_xdgSurface->m_toplevel->layoutMinSize();
+ Vector2D minSize = m_isX11 ? Vector2D(m_xwaylandSurface->m_sizeHints->min_width, m_xwaylandSurface->m_sizeHints->min_height) : m_xdgSurface->m_toplevel->layoutMinSize();
minSize = minSize.clamp({1, 1});
@@ -1688,10 +1688,10 @@ Vector2D CWindow::requestedMinSize() {
Vector2D CWindow::requestedMaxSize() {
constexpr int NO_MAX_SIZE_LIMIT = 99999;
- if (((m_isX11 && !m_xwaylandSurface->sizeHints) || (!m_isX11 && (!m_xdgSurface || !m_xdgSurface->m_toplevel)) || m_windowData.noMaxSize.valueOrDefault()))
+ if (((m_isX11 && !m_xwaylandSurface->m_sizeHints) || (!m_isX11 && (!m_xdgSurface || !m_xdgSurface->m_toplevel)) || m_windowData.noMaxSize.valueOrDefault()))
return Vector2D(NO_MAX_SIZE_LIMIT, NO_MAX_SIZE_LIMIT);
- Vector2D maxSize = m_isX11 ? Vector2D(m_xwaylandSurface->sizeHints->max_width, m_xwaylandSurface->sizeHints->max_height) : m_xdgSurface->m_toplevel->layoutMaxSize();
+ Vector2D maxSize = m_isX11 ? Vector2D(m_xwaylandSurface->m_sizeHints->max_width, m_xwaylandSurface->m_sizeHints->max_height) : m_xdgSurface->m_toplevel->layoutMaxSize();
if (maxSize.x < 5)
maxSize.x = NO_MAX_SIZE_LIMIT;
diff --git a/src/events/Windows.cpp b/src/events/Windows.cpp
index d365e376..240070a3 100644
--- a/src/events/Windows.cpp
+++ b/src/events/Windows.cpp
@@ -136,7 +136,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
PWINDOW->m_matchedRules = g_pConfigManager->getMatchingRules(PWINDOW, false);
std::optional<eFullscreenMode> requestedInternalFSMode, requestedClientFSMode;
std::optional<SFullscreenState> requestedFSState;
- if (PWINDOW->m_wantsInitialFullscreen || (PWINDOW->m_isX11 && PWINDOW->m_xwaylandSurface->fullscreen))
+ if (PWINDOW->m_wantsInitialFullscreen || (PWINDOW->m_isX11 && PWINDOW->m_xwaylandSurface->m_fullscreen))
requestedClientFSMode = FSMODE_FULLSCREEN;
MONITORID requestedFSMonitor = PWINDOW->m_wantsInitialFullscreenMonitor;
@@ -975,13 +975,13 @@ void Events::listener_activateX11(void* owner, void* data) {
void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
PHLWINDOW PWINDOW = ((CWindow*)owner)->m_self.lock();
- if (!PWINDOW->m_isMapped || !PWINDOW->m_xwaylandSurface || !PWINDOW->m_xwaylandSurface->overrideRedirect)
+ if (!PWINDOW->m_isMapped || !PWINDOW->m_xwaylandSurface || !PWINDOW->m_xwaylandSurface->m_overrideRedirect)
return;
const auto POS = PWINDOW->m_realPosition->goal();
const auto SIZ = PWINDOW->m_realSize->goal();
- if (PWINDOW->m_xwaylandSurface->geometry.size() > Vector2D{1, 1})
+ if (PWINDOW->m_xwaylandSurface->m_geometry.size() > Vector2D{1, 1})
PWINDOW->setHidden(false);
else
PWINDOW->setHidden(true);
@@ -994,17 +994,17 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
- const auto LOGICALPOS = g_pXWaylandManager->xwaylandToWaylandCoords(PWINDOW->m_xwaylandSurface->geometry.pos());
+ const auto LOGICALPOS = g_pXWaylandManager->xwaylandToWaylandCoords(PWINDOW->m_xwaylandSurface->m_geometry.pos());
- if (abs(std::floor(POS.x) - LOGICALPOS.x) > 2 || abs(std::floor(POS.y) - LOGICALPOS.y) > 2 || abs(std::floor(SIZ.x) - PWINDOW->m_xwaylandSurface->geometry.width) > 2 ||
- abs(std::floor(SIZ.y) - PWINDOW->m_xwaylandSurface->geometry.height) > 2) {
- Debug::log(LOG, "Unmanaged window {} requests geometry update to {:j} {:j}", PWINDOW, LOGICALPOS, PWINDOW->m_xwaylandSurface->geometry.size());
+ if (abs(std::floor(POS.x) - LOGICALPOS.x) > 2 || abs(std::floor(POS.y) - LOGICALPOS.y) > 2 || abs(std::floor(SIZ.x) - PWINDOW->m_xwaylandSurface->m_geometry.width) > 2 ||
+ abs(std::floor(SIZ.y) - PWINDOW->m_xwaylandSurface->m_geometry.height) > 2) {
+ Debug::log(LOG, "Unmanaged window {} requests geometry update to {:j} {:j}", PWINDOW, LOGICALPOS, PWINDOW->m_xwaylandSurface->m_geometry.size());
g_pHyprRenderer->damageWindow(PWINDOW);
PWINDOW->m_realPosition->setValueAndWarp(Vector2D(LOGICALPOS.x, LOGICALPOS.y));
- if (abs(std::floor(SIZ.x) - PWINDOW->m_xwaylandSurface->geometry.w) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_xwaylandSurface->geometry.h) > 2)
- PWINDOW->m_realSize->setValueAndWarp(PWINDOW->m_xwaylandSurface->geometry.size());
+ if (abs(std::floor(SIZ.x) - PWINDOW->m_xwaylandSurface->m_geometry.w) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_xwaylandSurface->m_geometry.h) > 2)
+ PWINDOW->m_realSize->setValueAndWarp(PWINDOW->m_xwaylandSurface->m_geometry.size());
if (*PXWLFORCESCALEZERO) {
if (const auto PMONITOR = PWINDOW->m_monitor.lock(); PMONITOR) {
diff --git a/src/layout/IHyprLayout.cpp b/src/layout/IHyprLayout.cpp
index 96dea105..9919404a 100644
--- a/src/layout/IHyprLayout.cpp
+++ b/src/layout/IHyprLayout.cpp
@@ -131,8 +131,8 @@ void IHyprLayout::onWindowCreatedFloating(PHLWINDOW pWindow) {
if (pWindow->m_isX11 && pWindow->isX11OverrideRedirect()) {
- if (pWindow->m_xwaylandSurface->geometry.x != 0 && pWindow->m_xwaylandSurface->geometry.y != 0)
- *pWindow->m_realPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_xwaylandSurface->geometry.pos());
+ if (pWindow->m_xwaylandSurface->m_geometry.x != 0 && pWindow->m_xwaylandSurface->m_geometry.y != 0)
+ *pWindow->m_realPosition = g_pXWaylandManager->xwaylandToWaylandCoords(pWindow->m_xwaylandSurface->m_geometry.pos());
else
*pWindow->m_realPosition = Vector2D(PMONITOR->m_position.x + (PMONITOR->m_size.x - pWindow->m_realSize->goal().x) / 2.f,
PMONITOR->m_position.y + (PMONITOR->m_size.y - pWindow->m_realSize->goal().y) / 2.f);
diff --git a/src/managers/ANRManager.cpp b/src/managers/ANRManager.cpp
index eff5046b..e4e62ea8 100644
--- a/src/managers/ANRManager.cpp
+++ b/src/managers/ANRManager.cpp
@@ -218,7 +218,7 @@ pid_t CANRManager::SANRData::getPid() const {
}
if (xwaylandSurface)
- return xwaylandSurface->pid;
+ return xwaylandSurface->m_pid;
return 0;
}
diff --git a/src/managers/XWaylandManager.cpp b/src/managers/XWaylandManager.cpp
index ec9e078c..460e9ecd 100644
--- a/src/managers/XWaylandManager.cpp
+++ b/src/managers/XWaylandManager.cpp
@@ -84,7 +84,7 @@ CBox CHyprXWaylandManager::getGeometryForWindow(PHLWINDOW pWindow) {
CBox box;
if (pWindow->m_isX11)
- box = pWindow->m_xwaylandSurface->geometry;
+ box = pWindow->m_xwaylandSurface->m_geometry;
else if (pWindow->m_xdgSurface)
box = pWindow->m_xdgSurface->m_current.geometry;
@@ -100,7 +100,7 @@ void CHyprXWaylandManager::sendCloseWindow(PHLWINDOW pWindow) {
bool CHyprXWaylandManager::shouldBeFloated(PHLWINDOW pWindow, bool pending) {
if (pWindow->m_isX11) {
- for (const auto& a : pWindow->m_xwaylandSurface->atoms)
+ for (const auto& a : pWindow->m_xwaylandSurface->m_atoms)
if (a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DIALOG"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_SPLASH"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLBAR"] ||
a == HYPRATOMS["_NET_WM_WINDOW_TYPE_UTILITY"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLTIP"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_POPUP_MENU"] ||
a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DOCK"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"] ||
@@ -115,12 +115,12 @@ bool CHyprXWaylandManager::shouldBeFloated(PHLWINDOW pWindow, bool pending) {
return true;
}
- if (pWindow->isModal() || pWindow->m_xwaylandSurface->transient ||
- (pWindow->m_xwaylandSurface->role.contains("task_dialog") || pWindow->m_xwaylandSurface->role.contains("pop-up")) || pWindow->m_xwaylandSurface->overrideRedirect)
+ if (pWindow->isModal() || pWindow->m_xwaylandSurface->m_transient ||
+ (pWindow->m_xwaylandSurface->m_role.contains("task_dialog") || pWindow->m_xwaylandSurface->m_role.contains("pop-up")) || pWindow->m_xwaylandSurface->m_overrideRedirect)
return true;
- const auto SIZEHINTS = pWindow->m_xwaylandSurface->sizeHints.get();
- if (pWindow->m_xwaylandSurface->transient || pWindow->m_xwaylandSurface->parent ||
+ const auto SIZEHINTS = pWindow->m_xwaylandSurface->m_sizeHints.get();
+ if (pWindow->m_xwaylandSurface->m_transient || pWindow->m_xwaylandSurface->m_parent ||
(SIZEHINTS && (SIZEHINTS->min_width == SIZEHINTS->max_width) && (SIZEHINTS->min_height == SIZEHINTS->max_height)))
return true;
} else {
@@ -140,7 +140,7 @@ void CHyprXWaylandManager::checkBorders(PHLWINDOW pWindow) {
if (!pWindow->m_isX11)
return;
- for (auto const& a : pWindow->m_xwaylandSurface->atoms) {
+ for (auto const& a : pWindow->m_xwaylandSurface->m_atoms) {
if (a == HYPRATOMS["_NET_WM_WINDOW_TYPE_POPUP_MENU"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_NOTIFICATION"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"] ||
a == HYPRATOMS["_NET_WM_WINDOW_TYPE_COMBO"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_MENU"] || a == HYPRATOMS["_NET_WM_WINDOW_TYPE_SPLASH"] ||
a == HYPRATOMS["_NET_WM_WINDOW_TYPE_TOOLTIP"]) {
diff --git a/src/protocols/XDGOutput.cpp b/src/protocols/XDGOutput.cpp
index 93ac1c37..ccb78e98 100644
--- a/src/protocols/XDGOutput.cpp
+++ b/src/protocols/XDGOutput.cpp
@@ -47,7 +47,7 @@ void CXDGOutputProtocol::onManagerGetXDGOutput(CZxdgOutputManagerV1* mgr, uint32
CXDGOutput* pXDGOutput = m_xdgOutputs.emplace_back(makeUnique<CXDGOutput>(makeShared<CZxdgOutputV1>(CLIENT, mgr->version(), id), PMONITOR)).get();
#ifndef NO_XWAYLAND
- if (g_pXWayland && g_pXWayland->pServer && g_pXWayland->pServer->xwaylandClient == CLIENT)
+ if (g_pXWayland && g_pXWayland->m_server && g_pXWayland->m_server->m_xwaylandClient == CLIENT)
pXDGOutput->m_isXWayland = true;
#endif
pXDGOutput->m_client = CLIENT;
diff --git a/src/protocols/core/DataDevice.cpp b/src/protocols/core/DataDevice.cpp
index 67c16e43..ad580ed1 100644
--- a/src/protocols/core/DataDevice.cpp
+++ b/src/protocols/core/DataDevice.cpp
@@ -420,8 +420,8 @@ void CWLDataDeviceProtocol::destroyResource(CWLDataOfferResource* resource) {
SP<IDataDevice> CWLDataDeviceProtocol::dataDeviceForClient(wl_client* c) {
#ifndef NO_XWAYLAND
- if (g_pXWayland && g_pXWayland->pServer && c == g_pXWayland->pServer->xwaylandClient)
- return g_pXWayland->pWM->getDataDevice();
+ if (g_pXWayland && g_pXWayland->m_server && c == g_pXWayland->m_server->m_xwaylandClient)
+ return g_pXWayland->m_wm->getDataDevice();
#endif
auto it = std::find_if(m_devices.begin(), m_devices.end(), [c](const auto& e) { return e->client() == c; });
@@ -451,7 +451,7 @@ void CWLDataDeviceProtocol::sendSelectionToDevice(SP<IDataDevice> dev, SP<IDataS
}
#ifndef NO_XWAYLAND
else if (const auto X11 = dev->getX11(); X11)
- offer = g_pXWayland->pWM->createX11DataOffer(g_pSeatManager->m_state.keyboardFocus.lock(), sel);
+ offer = g_pXWayland->m_wm->createX11DataOffer(g_pSeatManager->m_state.keyboardFocus.lock(), sel);
#endif
if UNLIKELY (!offer) {
@@ -669,7 +669,7 @@ void CWLDataDeviceProtocol::updateDrag() {
}
#ifndef NO_XWAYLAND
else if (const auto X11 = m_dnd.focusedDevice->getX11(); X11)
- offer = g_pXWayland->pWM->createX11DataOffer(g_pSeatManager->m_state.keyboardFocus.lock(), m_dnd.currentSource.lock());
+ offer = g_pXWayland->m_wm->createX11DataOffer(g_pSeatManager->m_state.keyboardFocus.lock(), m_dnd.currentSource.lock());
#endif
if (!offer) {
diff --git a/src/xwayland/Dnd.cpp b/src/xwayland/Dnd.cpp
index 2cb8be57..e4c60920 100644
--- a/src/xwayland/Dnd.cpp
+++ b/src/xwayland/Dnd.cpp
@@ -36,15 +36,15 @@ void CX11DataDevice::sendDndEvent(xcb_window_t targetWindow, xcb_atom_t type, xc
.data = data,
};
- xcb_send_event(g_pXWayland->pWM->connection, 0, targetWindow, XCB_EVENT_MASK_NO_EVENT, (const char*)&event);
- xcb_flush(g_pXWayland->pWM->connection);
+ xcb_send_event(g_pXWayland->m_wm->m_connection, 0, targetWindow, XCB_EVENT_MASK_NO_EVENT, (const char*)&event);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
}
xcb_window_t CX11DataDevice::getProxyWindow(xcb_window_t window) {
xcb_window_t targetWindow = window;
xcb_get_property_cookie_t proxyCookie =
- xcb_get_property(g_pXWayland->pWM->connection, PROPERTY_OFFSET, window, HYPRATOMS["XdndProxy"], XCB_ATOM_WINDOW, PROPERTY_OFFSET, PROPERTY_LENGTH);
- xcb_get_property_reply_t* proxyReply = xcb_get_property_reply(g_pXWayland->pWM->connection, proxyCookie, nullptr);
+ xcb_get_property(g_pXWayland->m_wm->m_connection, PROPERTY_OFFSET, window, HYPRATOMS["XdndProxy"], XCB_ATOM_WINDOW, PROPERTY_OFFSET, PROPERTY_LENGTH);
+ xcb_get_property_reply_t* proxyReply = xcb_get_property_reply(g_pXWayland->m_wm->m_connection, proxyCookie, nullptr);
const auto isValidPropertyReply = [](xcb_get_property_reply_t* reply) {
return reply && reply->type == XCB_ATOM_WINDOW && reply->format == PROPERTY_FORMAT_32BIT && xcb_get_property_value_length(reply) == sizeof(xcb_window_t);
@@ -54,8 +54,8 @@ xcb_window_t CX11DataDevice::getProxyWindow(xcb_window_t window) {
xcb_window_t proxyWindow = *(xcb_window_t*)xcb_get_property_value(proxyReply);
xcb_get_property_cookie_t proxyVerifyCookie =
- xcb_get_property(g_pXWayland->pWM->connection, PROPERTY_OFFSET, proxyWindow, HYPRATOMS["XdndProxy"], XCB_ATOM_WINDOW, PROPERTY_OFFSET, PROPERTY_LENGTH);
- xcb_get_property_reply_t* proxyVerifyReply = xcb_get_property_reply(g_pXWayland->pWM->connection, proxyVerifyCookie, nullptr);
+ xcb_get_property(g_pXWayland->m_wm->m_connection, PROPERTY_OFFSET, proxyWindow, HYPRATOMS["XdndProxy"], XCB_ATOM_WINDOW, PROPERTY_OFFSET, PROPERTY_LENGTH);
+ xcb_get_property_reply_t* proxyVerifyReply = xcb_get_property_reply(g_pXWayland->m_wm->m_connection, proxyVerifyCookie, nullptr);
if (isValidPropertyReply(proxyVerifyReply)) {
xcb_window_t verifyWindow = *(xcb_window_t*)xcb_get_property_value(proxyVerifyReply);
@@ -81,16 +81,16 @@ SP<CWLDataOfferResource> CX11DataOffer::getWayland() {
}
SP<CX11DataOffer> CX11DataOffer::getX11() {
- return self.lock();
+ return m_self.lock();
}
SP<IDataSource> CX11DataOffer::getSource() {
- return source.lock();
+ return m_source.lock();
}
void CX11DataOffer::markDead() {
#ifndef NO_XWAYLAND
- std::erase(g_pXWayland->pWM->dndDataOffers, self);
+ std::erase(g_pXWayland->m_wm->m_dndDataOffers, m_self);
#endif
}
@@ -100,7 +100,7 @@ void CX11DataDevice::sendDataOffer(SP<IDataOffer> offer) {
void CX11DataDevice::sendEnter(uint32_t serial, SP<CWLSurfaceResource> surf, const Vector2D& local, SP<IDataOffer> offer) {
#ifndef NO_XWAYLAND
- auto XSURF = g_pXWayland->pWM->windowForWayland(surf);
+ auto XSURF = g_pXWayland->m_wm->windowForWayland(surf);
if (!XSURF) {
Debug::log(ERR, "CX11DataDevice::sendEnter: No xwayland surface for destination");
@@ -118,54 +118,54 @@ void CX11DataDevice::sendEnter(uint32_t serial, SP<CWLSurfaceResource> surf, con
// reserve to avoid reallocations
targets.reserve(SOURCE->mimes().size());
for (auto const& m : SOURCE->mimes()) {
- targets.push_back(g_pXWayland->pWM->mimeToAtom(m));
+ targets.push_back(g_pXWayland->m_wm->mimeToAtom(m));
}
- xcb_change_property(g_pXWayland->pWM->connection, XCB_PROP_MODE_REPLACE, g_pXWayland->pWM->dndSelection.window, HYPRATOMS["XdndTypeList"], XCB_ATOM_ATOM, 32, targets.size(),
- targets.data());
+ xcb_change_property(g_pXWayland->m_wm->m_connection, XCB_PROP_MODE_REPLACE, g_pXWayland->m_wm->m_dndSelection.window, HYPRATOMS["XdndTypeList"], XCB_ATOM_ATOM, 32,
+ targets.size(), targets.data());
- xcb_set_selection_owner(g_pXWayland->pWM->connection, g_pXWayland->pWM->dndSelection.window, HYPRATOMS["XdndSelection"], XCB_TIME_CURRENT_TIME);
- xcb_flush(g_pXWayland->pWM->connection);
+ xcb_set_selection_owner(g_pXWayland->m_wm->m_connection, g_pXWayland->m_wm->m_dndSelection.window, HYPRATOMS["XdndSelection"], XCB_TIME_CURRENT_TIME);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
- xcb_window_t targetWindow = getProxyWindow(XSURF->xID);
+ xcb_window_t targetWindow = getProxyWindow(XSURF->m_xID);
xcb_client_message_data_t data = {{0}};
- data.data32[0] = g_pXWayland->pWM->dndSelection.window;
+ data.data32[0] = g_pXWayland->m_wm->m_dndSelection.window;
data.data32[1] = XDND_VERSION << 24;
data.data32[1] |= 1;
sendDndEvent(targetWindow, HYPRATOMS["XdndEnter"], data);
- lastSurface = XSURF;
- lastOffer = offer;
+ m_lastSurface = XSURF;
+ m_lastOffer = offer;
- auto hlSurface = XSURF->surface.lock();
+ auto hlSurface = XSURF->m_surface.lock();
if (!hlSurface) {
Debug::log(ERR, "CX11DataDevice::sendEnter: Non desktop x surface?!");
- lastSurfaceCoords = {};
+ m_lastSurfaceCoords = {};
return;
}
- lastSurfaceCoords = g_pXWaylandManager->xwaylandToWaylandCoords(XSURF->geometry.pos());
+ m_lastSurfaceCoords = g_pXWaylandManager->xwaylandToWaylandCoords(XSURF->m_geometry.pos());
#endif
}
void CX11DataDevice::cleanupState() {
- lastSurface.reset();
- lastOffer.reset();
- lastSurfaceCoords = {};
- lastTime = 0;
+ m_lastSurface.reset();
+ m_lastOffer.reset();
+ m_lastSurfaceCoords = {};
+ m_lastTime = 0;
}
void CX11DataDevice::sendLeave() {
#ifndef NO_XWAYLAND
- if (!lastSurface)
+ if (!m_lastSurface)
return;
- xcb_window_t targetWindow = getProxyWindow(lastSurface->xID);
+ xcb_window_t targetWindow = getProxyWindow(m_lastSurface->m_xID);
xcb_client_message_data_t data = {{0}};
- data.data32[0] = g_pXWayland->pWM->dndSelection.window;
+ data.data32[0] = g_pXWayland->m_wm->m_dndSelection.window;
sendDndEvent(targetWindow, HYPRATOMS["XdndLeave"], data);
@@ -175,38 +175,38 @@ void CX11DataDevice::sendLeave() {
void CX11DataDevice::sendMotion(uint32_t timeMs, const Vector2D& local) {
#ifndef NO_XWAYLAND
- if (!lastSurface || !lastOffer || !lastOffer->getSource())
+ if (!m_lastSurface || !m_lastOffer || !m_lastOffer->getSource())
return;
- xcb_window_t targetWindow = getProxyWindow(lastSurface->xID);
+ xcb_window_t targetWindow = getProxyWindow(m_lastSurface->m_xID);
- const auto XCOORDS = g_pXWaylandManager->waylandToXWaylandCoords(lastSurfaceCoords + local);
+ const auto XCOORDS = g_pXWaylandManager->waylandToXWaylandCoords(m_lastSurfaceCoords + local);
const uint32_t coords = ((uint32_t)XCOORDS.x << 16) | (uint32_t)XCOORDS.y;
xcb_client_message_data_t data = {{0}};
- data.data32[0] = g_pXWayland->pWM->dndSelection.window;
+ data.data32[0] = g_pXWayland->m_wm->m_dndSelection.window;
data.data32[2] = coords;
data.data32[3] = timeMs;
- data.data32[4] = dndActionToAtom(lastOffer->getSource()->actions());
+ data.data32[4] = dndActionToAtom(m_lastOffer->getSource()->actions());
sendDndEvent(targetWindow, HYPRATOMS["XdndPosition"], data);
- lastTime = timeMs;
+ m_lastTime = timeMs;
#endif
}
void CX11DataDevice::sendDrop() {
#ifndef NO_XWAYLAND
- if (!lastSurface || !lastOffer) {
+ if (!m_lastSurface || !m_lastOffer) {
Debug::log(ERR, "CX11DataDevice::sendDrop: No surface or offer");
return;
}
- xcb_window_t targetWindow = getProxyWindow(lastSurface->xID);
+ xcb_window_t targetWindow = getProxyWindow(m_lastSurface->m_xID);
xcb_client_message_data_t data = {{0}};
- data.data32[0] = g_pXWayland->pWM->dndSelection.window;
- data.data32[2] = lastTime;
+ data.data32[0] = g_pXWayland->m_wm->m_dndSelection.window;
+ data.data32[2] = m_lastTime;
sendDndEvent(targetWindow, HYPRATOMS["XdndDrop"], data);
@@ -227,11 +227,11 @@ SP<CWLDataDeviceResource> CX11DataDevice::getWayland() {
}
SP<CX11DataDevice> CX11DataDevice::getX11() {
- return self.lock();
+ return m_self.lock();
}
std::vector<std::string> CX11DataSource::mimes() {
- return mimeTypes;
+ return m_mimeTypes;
}
void CX11DataSource::send(const std::string& mime, CFileDescriptor fd) {
@@ -243,30 +243,30 @@ void CX11DataSource::accepted(const std::string& mime) {
}
void CX11DataSource::cancelled() {
- dndSuccess = false;
- dropped = false;
+ m_dndSuccess = false;
+ m_dropped = false;
}
bool CX11DataSource::hasDnd() {
- return dnd;
+ return m_dnd;
}
bool CX11DataSource::dndDone() {
- return dropped;
+ return m_dropped;
}
void CX11DataSource::error(uint32_t code, const std::string& msg) {
Debug::log(ERR, "CX11DataSource error: code {} msg {}", code, msg);
- dndSuccess = false;
- dropped = false;
+ m_dndSuccess = false;
+ m_dropped = false;
}
void CX11DataSource::sendDndFinished() {
- dndSuccess = true;
+ m_dndSuccess = true;
}
uint32_t CX11DataSource::actions() {
- return supportedActions;
+ return m_supportedActions;
}
eDataSourceType CX11DataSource::type() {
@@ -274,7 +274,7 @@ eDataSourceType CX11DataSource::type() {
}
void CX11DataSource::sendDndDropPerformed() {
- dropped = true;
+ m_dropped = true;
}
void CX11DataSource::sendDndAction(wl_data_device_manager_dnd_action a) {
@@ -283,16 +283,16 @@ void CX11DataSource::sendDndAction(wl_data_device_manager_dnd_action a) {
void CX11DataDevice::forceCleanupDnd() {
#ifndef NO_XWAYLAND
- if (lastOffer) {
- auto source = lastOffer->getSource();
+ if (m_lastOffer) {
+ auto source = m_lastOffer->getSource();
if (source) {
source->cancelled();
source->sendDndFinished();
}
}
- xcb_set_selection_owner(g_pXWayland->pWM->connection, XCB_ATOM_NONE, HYPRATOMS["XdndSelection"], XCB_TIME_CURRENT_TIME);
- xcb_flush(g_pXWayland->pWM->connection);
+ xcb_set_selection_owner(g_pXWayland->m_wm->m_connection, XCB_ATOM_NONE, HYPRATOMS["XdndSelection"], XCB_TIME_CURRENT_TIME);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
cleanupState();
diff --git a/src/xwayland/Dnd.hpp b/src/xwayland/Dnd.hpp
index 1b97f5cc..58129741 100644
--- a/src/xwayland/Dnd.hpp
+++ b/src/xwayland/Dnd.hpp
@@ -22,15 +22,9 @@ class CX11DataOffer : public IDataOffer {
virtual SP<IDataSource> getSource();
virtual void markDead();
- WP<IDataSource> source;
- WP<CX11DataOffer> self;
- WP<CXWaylandSurface> xwaylandSurface;
-
- bool dead = false;
- bool accepted = false;
- bool recvd = false;
-
- uint32_t actions = 0;
+ WP<IDataSource> m_source;
+ WP<CX11DataOffer> m_self;
+ WP<CXWaylandSurface> m_xwaylandSurface;
};
class CX11DataSource : public IDataSource {
@@ -51,15 +45,12 @@ class CX11DataSource : public IDataSource {
virtual void sendDndDropPerformed();
virtual void sendDndAction(wl_data_device_manager_dnd_action a);
- bool used = false;
- bool dnd = true;
- bool dndSuccess = false;
- bool dropped = false;
-
- WP<CX11DataSource> self;
+ bool m_dnd = true;
+ bool m_dndSuccess = false;
+ bool m_dropped = false;
- std::vector<std::string> mimeTypes;
- uint32_t supportedActions = 0;
+ std::vector<std::string> m_mimeTypes;
+ uint32_t m_supportedActions = 0;
};
class CX11DataDevice : public IDataDevice {
@@ -77,7 +68,7 @@ class CX11DataDevice : public IDataDevice {
virtual eDataSourceType type();
void forceCleanupDnd();
- WP<CX11DataDevice> self;
+ WP<CX11DataDevice> m_self;
private:
void cleanupState();
@@ -85,8 +76,8 @@ class CX11DataDevice : public IDataDevice {
xcb_window_t getProxyWindow(xcb_window_t window);
void sendDndEvent(xcb_window_t targetWindow, xcb_atom_t type, xcb_client_message_data_t& data);
#endif
- WP<CXWaylandSurface> lastSurface;
- WP<IDataOffer> lastOffer;
- Vector2D lastSurfaceCoords;
- uint32_t lastTime = 0;
+ WP<CXWaylandSurface> m_lastSurface;
+ WP<IDataOffer> m_lastOffer;
+ Vector2D m_lastSurfaceCoords;
+ uint32_t m_lastTime = 0;
};
diff --git a/src/xwayland/Server.cpp b/src/xwayland/Server.cpp
index a2e0e9fa..814bd20c 100644
--- a/src/xwayland/Server.cpp
+++ b/src/xwayland/Server.cpp
@@ -172,12 +172,12 @@ static bool openSockets(std::array<CFileDescriptor, 2>& sockets, int display) {
}
static void startServer(void* data) {
- if (!g_pXWayland->pServer->start())
+ if (!g_pXWayland->m_server->start())
Debug::log(ERR, "The XWayland server could not start! XWayland will not work...");
}
static int xwaylandReady(int fd, uint32_t mask, void* data) {
- return g_pXWayland->pServer->ready(fd, mask);
+ return g_pXWayland->m_server->ready(fd, mask);
}
static bool safeRemove(const std::string& path) {
@@ -194,7 +194,7 @@ bool CXWaylandServer::tryOpenSockets() {
CFileDescriptor fd{open(lockPath.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, LOCK_FILE_MODE)};
if (fd.isValid()) {
// we managed to open the lock
- if (!openSockets(xFDs, i)) {
+ if (!openSockets(m_xFDs, i)) {
safeRemove(lockPath);
continue;
}
@@ -205,8 +205,8 @@ bool CXWaylandServer::tryOpenSockets() {
continue;
}
- display = i;
- displayName = std::format(":{}", display);
+ m_display = i;
+ m_displayName = std::format(":{}", m_display);
break;
}
@@ -230,12 +230,12 @@ bool CXWaylandServer::tryOpenSockets() {
}
}
- if (display < 0) {
+ if (m_display < 0) {
Debug::log(ERR, "Failed to find a suitable socket for XWayland");
return false;
}
- Debug::log(LOG, "XWayland found a suitable display socket at DISPLAY: {}", displayName);
+ Debug::log(LOG, "XWayland found a suitable display socket at DISPLAY: {}", m_displayName);
return true;
}
@@ -245,63 +245,63 @@ CXWaylandServer::CXWaylandServer() {
CXWaylandServer::~CXWaylandServer() {
die();
- if (display < 0)
+ if (m_display < 0)
return;
- std::string lockPath = std::format("/tmp/.X{}-lock", display);
+ std::string lockPath = std::format("/tmp/.X{}-lock", m_display);
safeRemove(lockPath);
std::string path;
for (bool isLinux : {true, false}) {
- path = getSocketPath(display, isLinux);
+ path = getSocketPath(m_display, isLinux);
safeRemove(path);
}
}
void CXWaylandServer::die() {
- if (display < 0)
+ if (m_display < 0)
return;
- if (xFDReadEvents[0]) {
- wl_event_source_remove(xFDReadEvents[0]);
- wl_event_source_remove(xFDReadEvents[1]);
- xFDReadEvents = {nullptr, nullptr};
+ if (m_xFDReadEvents[0]) {
+ wl_event_source_remove(m_xFDReadEvents[0]);
+ wl_event_source_remove(m_xFDReadEvents[1]);
+ m_xFDReadEvents = {nullptr, nullptr};
}
- if (pipeSource)
- wl_event_source_remove(pipeSource);
+ if (m_pipeSource)
+ wl_event_source_remove(m_pipeSource);
// possible crash. Better to leak a bit.
//if (xwaylandClient)
// wl_client_destroy(xwaylandClient);
- xwaylandClient = nullptr;
+ m_xwaylandClient = nullptr;
}
bool CXWaylandServer::create() {
if (!tryOpenSockets())
return false;
- setenv("DISPLAY", displayName.c_str(), true);
+ setenv("DISPLAY", m_displayName.c_str(), true);
// TODO: lazy mode
- idleSource = wl_event_loop_add_idle(g_pCompositor->m_wlEventLoop, ::startServer, nullptr);
+ m_idleSource = wl_event_loop_add_idle(g_pCompositor->m_wlEventLoop, ::startServer, nullptr);
return true;
}
void CXWaylandServer::runXWayland(CFileDescriptor& notifyFD) {
- if (!xFDs[0].setFlags(xFDs[0].getFlags() & ~FD_CLOEXEC) || !xFDs[1].setFlags(xFDs[1].getFlags() & ~FD_CLOEXEC) ||
- !waylandFDs[1].setFlags(waylandFDs[1].getFlags() & ~FD_CLOEXEC) || !xwmFDs[1].setFlags(xwmFDs[1].getFlags() & ~FD_CLOEXEC)) {
+ if (!m_xFDs[0].setFlags(m_xFDs[0].getFlags() & ~FD_CLOEXEC) || !m_xFDs[1].setFlags(m_xFDs[1].getFlags() & ~FD_CLOEXEC) ||
+ !m_waylandFDs[1].setFlags(m_waylandFDs[1].getFlags() & ~FD_CLOEXEC) || !m_xwmFDs[1].setFlags(m_xwmFDs[1].getFlags() & ~FD_CLOEXEC)) {
Debug::log(ERR, "Failed to unset cloexec on fds");
_exit(EXIT_FAILURE);
}
- auto cmd =
- std::format("Xwayland {} -rootless -core -listenfd {} -listenfd {} -displayfd {} -wm {}", displayName, xFDs[0].get(), xFDs[1].get(), notifyFD.get(), xwmFDs[1].get());
+ auto cmd = std::format("Xwayland {} -rootless -core -listenfd {} -listenfd {} -displayfd {} -wm {}", m_displayName, m_xFDs[0].get(), m_xFDs[1].get(), notifyFD.get(),
+ m_xwmFDs[1].get());
- auto waylandSocket = std::format("{}", waylandFDs[1].get());
+ auto waylandSocket = std::format("{}", m_waylandFDs[1].get());
setenv("WAYLAND_SOCKET", waylandSocket.c_str(), true);
Debug::log(LOG, "Starting XWayland with \"{}\", bon voyage!", cmd);
@@ -313,17 +313,17 @@ void CXWaylandServer::runXWayland(CFileDescriptor& notifyFD) {
}
bool CXWaylandServer::start() {
- idleSource = nullptr;
+ m_idleSource = nullptr;
int wlPair[2] = {-1, -1};
if (socketpair(AF_UNIX, SOCK_STREAM, 0, wlPair) != 0) {
Debug::log(ERR, "socketpair failed (1)");
die();
return false;
}
- waylandFDs[0] = CFileDescriptor{wlPair[0]};
- waylandFDs[1] = CFileDescriptor{wlPair[1]};
+ m_waylandFDs[0] = CFileDescriptor{wlPair[0]};
+ m_waylandFDs[1] = CFileDescriptor{wlPair[1]};
- if (!waylandFDs[0].setFlags(waylandFDs[0].getFlags() | FD_CLOEXEC) || !waylandFDs[1].setFlags(waylandFDs[1].getFlags() | FD_CLOEXEC)) {
+ if (!m_waylandFDs[0].setFlags(m_waylandFDs[0].getFlags() | FD_CLOEXEC) || !m_waylandFDs[1].setFlags(m_waylandFDs[1].getFlags() | FD_CLOEXEC)) {
Debug::log(ERR, "set_cloexec failed (1)");
die();
return false;
@@ -336,23 +336,23 @@ bool CXWaylandServer::start() {
return false;
}
- xwmFDs[0] = CFileDescriptor{xwmPair[0]};
- xwmFDs[1] = CFileDescriptor{xwmPair[1]};
+ m_xwmFDs[0] = CFileDescriptor{xwmPair[0]};
+ m_xwmFDs[1] = CFileDescriptor{xwmPair[1]};
- if (!xwmFDs[0].setFlags(xwmFDs[0].getFlags() | FD_CLOEXEC) || !xwmFDs[1].setFlags(xwmFDs[1].getFlags() | FD_CLOEXEC)) {
+ if (!m_xwmFDs[0].setFlags(m_xwmFDs[0].getFlags() | FD_CLOEXEC) || !m_xwmFDs[1].setFlags(m_xwmFDs[1].getFlags() | FD_CLOEXEC)) {
Debug::log(ERR, "set_cloexec failed (2)");
die();
return false;
}
- xwaylandClient = wl_client_create(g_pCompositor->m_wlDisplay, waylandFDs[0].get());
- if (!xwaylandClient) {
+ m_xwaylandClient = wl_client_create(g_pCompositor->m_wlDisplay, m_waylandFDs[0].get());
+ if (!m_xwaylandClient) {
Debug::log(ERR, "wl_client_create failed");
die();
return false;
}
- waylandFDs[0].take(); // wl_client owns this fd now
+ m_waylandFDs[0].take(); // wl_client owns this fd now
int notify[2] = {-1, -1};
if (pipe(notify) < 0) {
@@ -369,8 +369,8 @@ bool CXWaylandServer::start() {
return false;
}
- pipeSource = wl_event_loop_add_fd(g_pCompositor->m_wlEventLoop, notifyFds[0].get(), WL_EVENT_READABLE, ::xwaylandReady, nullptr);
- pipeFd = std::move(notifyFds[0]);
+ m_pipeSource = wl_event_loop_add_fd(g_pCompositor->m_wlEventLoop, notifyFds[0].get(), WL_EVENT_READABLE, ::xwaylandReady, nullptr);
+ m_pipeFd = std::move(notifyFds[0]);
auto serverPID = fork();
if (serverPID < 0) {
@@ -400,19 +400,19 @@ int CXWaylandServer::ready(int fd, uint32_t mask) {
// if we don't have readable here, it failed
if (!(mask & WL_EVENT_READABLE)) {
Debug::log(ERR, "Xwayland: startup failed, not setting up xwm");
- g_pXWayland->pServer.reset();
+ g_pXWayland->m_server.reset();
return 1;
}
Debug::log(LOG, "XWayland is ready");
- wl_event_source_remove(pipeSource);
- pipeFd.reset();
- pipeSource = nullptr;
+ wl_event_source_remove(m_pipeSource);
+ m_pipeFd.reset();
+ m_pipeSource = nullptr;
// start the wm
- if (!g_pXWayland->pWM)
- g_pXWayland->pWM = makeUnique<CXWM>();
+ if (!g_pXWayland->m_wm)
+ g_pXWayland->m_wm = makeUnique<CXWM>();
g_pCursorManager->setXWaylandCursor();
diff --git a/src/xwayland/Server.hpp b/src/xwayland/Server.hpp
index 553d99ad..7266a9b0 100644
--- a/src/xwayland/Server.hpp
+++ b/src/xwayland/Server.hpp
@@ -20,29 +20,25 @@ class CXWaylandServer {
bool start();
// called on ready
- int ready(int fd, uint32_t mask);
+ int ready(int fd, uint32_t mask);
- void die();
+ void die();
- struct {
- CSignal ready;
- } events;
-
- wl_client* xwaylandClient = nullptr;
+ wl_client* m_xwaylandClient = nullptr;
private:
bool tryOpenSockets();
void runXWayland(Hyprutils::OS::CFileDescriptor& notifyFD);
- std::string displayName;
- int display = -1;
- std::array<Hyprutils::OS::CFileDescriptor, 2> xFDs;
- std::array<wl_event_source*, 2> xFDReadEvents = {nullptr, nullptr};
- wl_event_source* idleSource = nullptr;
- wl_event_source* pipeSource = nullptr;
- Hyprutils::OS::CFileDescriptor pipeFd;
- std::array<Hyprutils::OS::CFileDescriptor, 2> xwmFDs;
- std::array<Hyprutils::OS::CFileDescriptor, 2> waylandFDs;
+ std::string m_displayName;
+ int m_display = -1;
+ std::array<Hyprutils::OS::CFileDescriptor, 2> m_xFDs;
+ std::array<wl_event_source*, 2> m_xFDReadEvents = {nullptr, nullptr};
+ wl_event_source* m_idleSource = nullptr;
+ wl_event_source* m_pipeSource = nullptr;
+ Hyprutils::OS::CFileDescriptor m_pipeFd;
+ std::array<Hyprutils::OS::CFileDescriptor, 2> m_xwmFDs;
+ std::array<Hyprutils::OS::CFileDescriptor, 2> m_waylandFDs;
friend class CXWM;
};
diff --git a/src/xwayland/XDataSource.cpp b/src/xwayland/XDataSource.cpp
index 14656d8b..ec06c9bc 100644
--- a/src/xwayland/XDataSource.cpp
+++ b/src/xwayland/XDataSource.cpp
@@ -7,12 +7,12 @@
#include <fcntl.h>
using namespace Hyprutils::OS;
-CXDataSource::CXDataSource(SXSelection& sel_) : selection(sel_) {
- xcb_get_property_cookie_t cookie = xcb_get_property(g_pXWayland->pWM->connection,
+CXDataSource::CXDataSource(SXSelection& sel_) : m_selection(sel_) {
+ xcb_get_property_cookie_t cookie = xcb_get_property(g_pXWayland->m_wm->m_connection,
1, // delete
- selection.window, HYPRATOMS["_WL_SELECTION"], XCB_GET_PROPERTY_TYPE_ANY, 0, 4096);
+ m_selection.window, HYPRATOMS["_WL_SELECTION"], XCB_GET_PROPERTY_TYPE_ANY, 0, 4096);
- xcb_get_property_reply_t* reply = xcb_get_property_reply(g_pXWayland->pWM->connection, cookie, nullptr);
+ xcb_get_property_reply_t* reply = xcb_get_property_reply(g_pXWayland->m_wm->m_connection, cookie, nullptr);
if (!reply)
return;
@@ -24,28 +24,28 @@ CXDataSource::CXDataSource(SXSelection& sel_) : selection(sel_) {
auto value = (xcb_atom_t*)xcb_get_property_value(reply);
for (uint32_t i = 0; i < reply->value_len; i++) {
if (value[i] == HYPRATOMS["UTF8_STRING"])
- mimeTypes.emplace_back("text/plain;charset=utf-8");
+ m_mimeTypes.emplace_back("text/plain;charset=utf-8");
else if (value[i] == HYPRATOMS["TEXT"])
- mimeTypes.emplace_back("text/plain");
+ m_mimeTypes.emplace_back("text/plain");
else if (value[i] != HYPRATOMS["TARGETS"] && value[i] != HYPRATOMS["TIMESTAMP"]) {
- auto type = g_pXWayland->pWM->mimeFromAtom(value[i]);
+ auto type = g_pXWayland->m_wm->mimeFromAtom(value[i]);
if (type == "INVALID")
continue;
- mimeTypes.push_back(type);
+ m_mimeTypes.push_back(type);
} else
continue;
- mimeAtoms.push_back(value[i]);
+ m_mimeAtoms.push_back(value[i]);
}
free(reply);
}
std::vector<std::string> CXDataSource::mimes() {
- return mimeTypes;
+ return m_mimeTypes;
}
void CXDataSource::send(const std::string& mime, CFileDescriptor fd) {
@@ -56,9 +56,9 @@ void CXDataSource::send(const std::string& mime, CFileDescriptor fd) {
else if (mime == "text/plain;charset=utf-8")
mimeAtom = HYPRATOMS["UTF8_STRING"];
else {
- for (size_t i = 0; i < mimeTypes.size(); ++i) {
- if (mimeTypes[i] == mime) {
- mimeAtom = mimeAtoms[i];
+ for (size_t i = 0; i < m_mimeTypes.size(); ++i) {
+ if (m_mimeTypes[i] == mime) {
+ mimeAtom = m_mimeAtoms[i];
break;
}
}
@@ -71,26 +71,26 @@ void CXDataSource::send(const std::string& mime, CFileDescriptor fd) {
Debug::log(LOG, "[XDataSource] send with mime {} to fd {}", mime, fd.get());
- auto transfer = makeUnique<SXTransfer>(selection);
- transfer->incomingWindow = xcb_generate_id(g_pXWayland->pWM->connection);
+ auto transfer = makeUnique<SXTransfer>(m_selection);
+ transfer->incomingWindow = xcb_generate_id(g_pXWayland->m_wm->m_connection);
const uint32_t MASK = XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE;
- xcb_create_window(g_pXWayland->pWM->connection, XCB_COPY_FROM_PARENT, transfer->incomingWindow, g_pXWayland->pWM->screen->root, 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
- g_pXWayland->pWM->screen->root_visual, XCB_CW_EVENT_MASK, &MASK);
+ xcb_create_window(g_pXWayland->m_wm->m_connection, XCB_COPY_FROM_PARENT, transfer->incomingWindow, g_pXWayland->m_wm->m_screen->root, 0, 0, 10, 10, 0,
+ XCB_WINDOW_CLASS_INPUT_OUTPUT, g_pXWayland->m_wm->m_screen->root_visual, XCB_CW_EVENT_MASK, &MASK);
xcb_atom_t selection_atom = HYPRATOMS["CLIPBOARD"];
- if (&selection == &g_pXWayland->pWM->primarySelection)
+ if (&m_selection == &g_pXWayland->m_wm->m_primarySelection)
selection_atom = HYPRATOMS["PRIMARY"];
- else if (&selection == &g_pXWayland->pWM->dndSelection)
+ else if (&m_selection == &g_pXWayland->m_wm->m_dndSelection)
selection_atom = HYPRATOMS["XdndSelection"];
- xcb_convert_selection(g_pXWayland->pWM->connection, transfer->incomingWindow, selection_atom, mimeAtom, HYPRATOMS["_WL_SELECTION"], XCB_TIME_CURRENT_TIME);
+ xcb_convert_selection(g_pXWayland->m_wm->m_connection, transfer->incomingWindow, selection_atom, mimeAtom, HYPRATOMS["_WL_SELECTION"], XCB_TIME_CURRENT_TIME);
- xcb_flush(g_pXWayland->pWM->connection);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
//TODO: make CFileDescriptor setflags take SETFL aswell
fcntl(fd.get(), F_SETFL, O_WRONLY | O_NONBLOCK);
transfer->wlFD = std::move(fd);
- selection.transfers.emplace_back(std::move(transfer));
+ m_selection.transfers.emplace_back(std::move(transfer));
}
void CXDataSource::accepted(const std::string& mime) {
diff --git a/src/xwayland/XDataSource.hpp b/src/xwayland/XDataSource.hpp
index a61ffcc9..686991d5 100644
--- a/src/xwayland/XDataSource.hpp
+++ b/src/xwayland/XDataSource.hpp
@@ -17,7 +17,7 @@ class CXDataSource : public IDataSource {
virtual eDataSourceType type();
private:
- SXSelection& selection;
- std::vector<std::string> mimeTypes; // these two have shared idx
- std::vector<uint32_t> mimeAtoms; //
+ SXSelection& m_selection;
+ std::vector<std::string> m_mimeTypes; // these two have shared idx
+ std::vector<uint32_t> m_mimeAtoms; //
};
diff --git a/src/xwayland/XSurface.cpp b/src/xwayland/XSurface.cpp
index 89c65473..949649ae 100644
--- a/src/xwayland/XSurface.cpp
+++ b/src/xwayland/XSurface.cpp
@@ -9,19 +9,19 @@
#include <ranges>
-CXWaylandSurface::CXWaylandSurface(uint32_t xID_, CBox geometry_, bool OR) : xID(xID_), geometry(geometry_), overrideRedirect(OR) {
+CXWaylandSurface::CXWaylandSurface(uint32_t xID_, CBox geometry_, bool OR) : m_xID(xID_), m_geometry(geometry_), m_overrideRedirect(OR) {
xcb_res_query_client_ids_cookie_t client_id_cookie = {0};
- if (g_pXWayland->pWM->xres) {
- xcb_res_client_id_spec_t spec = {.client = xID, .mask = XCB_RES_CLIENT_ID_MASK_LOCAL_CLIENT_PID};
- client_id_cookie = xcb_res_query_client_ids(g_pXWayland->pWM->connection, 1, &spec);
+ if (g_pXWayland->m_wm->m_xres) {
+ xcb_res_client_id_spec_t spec = {.client = m_xID, .mask = XCB_RES_CLIENT_ID_MASK_LOCAL_CLIENT_PID};
+ client_id_cookie = xcb_res_query_client_ids(g_pXWayland->m_wm->m_connection, 1, &spec);
}
uint32_t values[1];
values[0] = XCB_EVENT_MASK_FOCUS_CHANGE | XCB_EVENT_MASK_PROPERTY_CHANGE;
- xcb_change_window_attributes(g_pXWayland->pWM->connection, xID, XCB_CW_EVENT_MASK, values);
+ xcb_change_window_attributes(g_pXWayland->m_wm->m_connection, m_xID, XCB_CW_EVENT_MASK, values);
- if (g_pXWayland->pWM->xres) {
- xcb_res_query_client_ids_reply_t* reply = xcb_res_query_client_ids_reply(g_pXWayland->pWM->connection, client_id_cookie, nullptr);
+ if (g_pXWayland->m_wm->m_xres) {
+ xcb_res_query_client_ids_reply_t* reply = xcb_res_query_client_ids_reply(g_pXWayland->m_wm->m_connection, client_id_cookie, nullptr);
if (!reply)
return;
@@ -38,101 +38,101 @@ CXWaylandSurface::CXWaylandSurface(uint32_t xID_, CBox geometry_, bool OR) : xID
free(reply);
return;
}
- pid = *ppid;
+ m_pid = *ppid;
free(reply);
}
- events.resourceChange.registerStaticListener([this](void* data, std::any d) { ensureListeners(); }, nullptr);
+ m_events.resourceChange.registerStaticListener([this](void* data, std::any d) { ensureListeners(); }, nullptr);
}
void CXWaylandSurface::ensureListeners() {
- bool connected = listeners.destroySurface;
-
- if (connected && !surface) {
- listeners.destroySurface.reset();
- listeners.commitSurface.reset();
- } else if (!connected && surface) {
- listeners.destroySurface = surface->m_events.destroy.registerListener([this](std::any d) {
- if (mapped)
+ bool connected = m_listeners.destroySurface;
+
+ if (connected && !m_surface) {
+ m_listeners.destroySurface.reset();
+ m_listeners.commitSurface.reset();
+ } else if (!connected && m_surface) {
+ m_listeners.destroySurface = m_surface->m_events.destroy.registerListener([this](std::any d) {
+ if (m_mapped)
unmap();
- surface.reset();
- listeners.destroySurface.reset();
- listeners.commitSurface.reset();
- events.resourceChange.emit();
+ m_surface.reset();
+ m_listeners.destroySurface.reset();
+ m_listeners.commitSurface.reset();
+ m_events.resourceChange.emit();
});
- listeners.commitSurface = surface->m_events.commit.registerListener([this](std::any d) {
- if (surface->m_current.texture && !mapped) {
+ m_listeners.commitSurface = m_surface->m_events.commit.registerListener([this](std::any d) {
+ if (m_surface->m_current.texture && !m_mapped) {
map();
return;
}
- if (!surface->m_current.texture && mapped) {
+ if (!m_surface->m_current.texture && m_mapped) {
unmap();
return;
}
- events.commit.emit();
+ m_events.commit.emit();
});
}
- if (resource) {
- listeners.destroyResource = resource->events.destroy.registerListener([this](std::any d) {
+ if (m_resource) {
+ m_listeners.destroyResource = m_resource->events.destroy.registerListener([this](std::any d) {
unmap();
- surface.reset();
- events.resourceChange.emit();
+ m_surface.reset();
+ m_events.resourceChange.emit();
});
}
}
void CXWaylandSurface::map() {
- if (mapped)
+ if (m_mapped)
return;
- ASSERT(surface);
+ ASSERT(m_surface);
- g_pXWayland->pWM->mappedSurfaces.emplace_back(self);
- g_pXWayland->pWM->mappedSurfacesStacking.emplace_back(self);
+ g_pXWayland->m_wm->m_mappedSurfaces.emplace_back(m_self);
+ g_pXWayland->m_wm->m_mappedSurfacesStacking.emplace_back(m_self);
- mapped = true;
- surface->map();
+ m_mapped = true;
+ m_surface->map();
Debug::log(LOG, "XWayland surface {:x} mapping", (uintptr_t)this);
- events.map.emit();
+ m_events.map.emit();
- g_pXWayland->pWM->updateClientList();
+ g_pXWayland->m_wm->updateClientList();
}
void CXWaylandSurface::unmap() {
- if (!mapped)
+ if (!m_mapped)
return;
- ASSERT(surface);
+ ASSERT(m_surface);
- std::erase(g_pXWayland->pWM->mappedSurfaces, self);
- std::erase(g_pXWayland->pWM->mappedSurfacesStacking, self);
+ std::erase(g_pXWayland->m_wm->m_mappedSurfaces, m_self);
+ std::erase(g_pXWayland->m_wm->m_mappedSurfacesStacking, m_self);
- mapped = false;
- events.unmap.emit();
- surface->unmap();
+ m_mapped = false;
+ m_events.unmap.emit();
+ m_surface->unmap();
Debug::log(LOG, "XWayland surface {:x} unmapping", (uintptr_t)this);
- g_pXWayland->pWM->updateClientList();
+ g_pXWayland->m_wm->updateClientList();
}
void CXWaylandSurface::considerMap() {
- if (mapped)
+ if (m_mapped)
return;
- if (!surface) {
+ if (!m_surface) {
Debug::log(LOG, "XWayland surface: considerMap, nope, no surface");
return;
}
- if (surface->m_current.texture) {
+ if (m_surface->m_current.texture) {
Debug::log(LOG, "XWayland surface: considerMap, sure, we have a buffer");
map();
return;
@@ -142,7 +142,7 @@ void CXWaylandSurface::considerMap() {
}
bool CXWaylandSurface::wantsFocus() {
- if (atoms.empty())
+ if (m_atoms.empty())
return true;
const std::array<uint32_t, 10> search = {
@@ -153,7 +153,7 @@ bool CXWaylandSurface::wantsFocus() {
};
for (auto const& searched : search) {
- for (auto const& a : atoms) {
+ for (auto const& a : m_atoms) {
if (a == searched)
return false;
}
@@ -163,110 +163,110 @@ bool CXWaylandSurface::wantsFocus() {
}
void CXWaylandSurface::configure(const CBox& box) {
- Vector2D oldSize = geometry.size();
+ Vector2D oldSize = m_geometry.size();
- geometry = box;
+ m_geometry = box;
uint32_t mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_BORDER_WIDTH;
uint32_t values[] = {box.x, box.y, box.width, box.height, 0};
- xcb_configure_window(g_pXWayland->pWM->connection, xID, mask, values);
+ xcb_configure_window(g_pXWayland->m_wm->m_connection, m_xID, mask, values);
- if (geometry.width == box.width && geometry.height == box.height) {
+ if (m_geometry.width == box.width && m_geometry.height == box.height) {
// ICCCM requires a synthetic event when window size is not changed
xcb_configure_notify_event_t e;
e.response_type = XCB_CONFIGURE_NOTIFY;
- e.event = xID;
- e.window = xID;
+ e.event = m_xID;
+ e.window = m_xID;
e.x = box.x;
e.y = box.y;
e.width = box.width;
e.height = box.height;
e.border_width = 0;
e.above_sibling = XCB_NONE;
- e.override_redirect = overrideRedirect;
- xcb_send_event(g_pXWayland->pWM->connection, false, xID, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (const char*)&e);
+ e.override_redirect = m_overrideRedirect;
+ xcb_send_event(g_pXWayland->m_wm->m_connection, false, m_xID, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (const char*)&e);
}
- g_pXWayland->pWM->updateClientList();
+ g_pXWayland->m_wm->updateClientList();
- xcb_flush(g_pXWayland->pWM->connection);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
}
void CXWaylandSurface::activate(bool activate) {
- if (overrideRedirect && !activate)
+ if (m_overrideRedirect && !activate)
return;
- g_pXWayland->pWM->activateSurface(self.lock(), activate);
+ g_pXWayland->m_wm->activateSurface(m_self.lock(), activate);
}
void CXWaylandSurface::setFullscreen(bool fs) {
- fullscreen = fs;
- g_pXWayland->pWM->sendState(self.lock());
+ m_fullscreen = fs;
+ g_pXWayland->m_wm->sendState(m_self.lock());
}
void CXWaylandSurface::setMinimized(bool mz) {
- minimized = mz;
- g_pXWayland->pWM->sendState(self.lock());
+ m_minimized = mz;
+ g_pXWayland->m_wm->sendState(m_self.lock());
}
void CXWaylandSurface::restackToTop() {
uint32_t values[1] = {XCB_STACK_MODE_ABOVE};
- xcb_configure_window(g_pXWayland->pWM->connection, xID, XCB_CONFIG_WINDOW_STACK_MODE, values);
+ xcb_configure_window(g_pXWayland->m_wm->m_connection, m_xID, XCB_CONFIG_WINDOW_STACK_MODE, values);
- auto& stack = g_pXWayland->pWM->mappedSurfacesStacking;
- auto it = std::find(stack.begin(), stack.end(), self);
+ auto& stack = g_pXWayland->m_wm->m_mappedSurfacesStacking;
+ auto it = std::find(stack.begin(), stack.end(), m_self);
if (it != stack.end())
std::rotate(it, it + 1, stack.end());
- g_pXWayland->pWM->updateClientList();
+ g_pXWayland->m_wm->updateClientList();
- xcb_flush(g_pXWayland->pWM->connection);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
}
void CXWaylandSurface::close() {
xcb_client_message_data_t msg = {};
msg.data32[0] = HYPRATOMS["WM_DELETE_WINDOW"];
msg.data32[1] = XCB_CURRENT_TIME;
- g_pXWayland->pWM->sendWMMessage(self.lock(), &msg, XCB_EVENT_MASK_NO_EVENT);
+ g_pXWayland->m_wm->sendWMMessage(m_self.lock(), &msg, XCB_EVENT_MASK_NO_EVENT);
}
void CXWaylandSurface::setWithdrawn(bool withdrawn_) {
- withdrawn = withdrawn_;
+ m_withdrawn = withdrawn_;
std::vector<uint32_t> props = {XCB_ICCCM_WM_STATE_NORMAL, XCB_WINDOW_NONE};
- if (withdrawn)
+ if (m_withdrawn)
props[0] = XCB_ICCCM_WM_STATE_WITHDRAWN;
- else if (minimized)
+ else if (m_minimized)
props[0] = XCB_ICCCM_WM_STATE_ICONIC;
else
props[0] = XCB_ICCCM_WM_STATE_NORMAL;
- xcb_change_property(g_pXWayland->pWM->connection, XCB_PROP_MODE_REPLACE, xID, HYPRATOMS["WM_STATE"], HYPRATOMS["WM_STATE"], 32, props.size(), props.data());
+ xcb_change_property(g_pXWayland->m_wm->m_connection, XCB_PROP_MODE_REPLACE, m_xID, HYPRATOMS["WM_STATE"], HYPRATOMS["WM_STATE"], 32, props.size(), props.data());
}
void CXWaylandSurface::ping() {
- bool supportsPing = std::ranges::find(protocols, HYPRATOMS["_NET_WM_PING"]) != protocols.end();
+ bool supportsPing = std::ranges::find(m_protocols, HYPRATOMS["_NET_WM_PING"]) != m_protocols.end();
if (!supportsPing) {
- Debug::log(TRACE, "CXWaylandSurface: XID {} does not support ping, just sending an instant reply", xID);
- g_pANRManager->onResponse(self.lock());
+ Debug::log(TRACE, "CXWaylandSurface: XID {} does not support ping, just sending an instant reply", m_xID);
+ g_pANRManager->onResponse(m_self.lock());
return;
}
xcb_client_message_data_t msg = {};
msg.data32[0] = HYPRATOMS["_NET_WM_PING"];
msg.data32[1] = Time::millis(Time::steadyNow());
- msg.data32[2] = xID;
+ msg.data32[2] = m_xID;
- lastPingSeq = msg.data32[1];
+ m_lastPingSeq = msg.data32[1];
- g_pXWayland->pWM->sendWMMessage(self.lock(), &msg, XCB_EVENT_MASK_PROPERTY_CHANGE);
+ g_pXWayland->m_wm->sendWMMessage(m_self.lock(), &msg, XCB_EVENT_MASK_PROPERTY_CHANGE);
}
#else
-CXWaylandSurface::CXWaylandSurface(uint32_t xID_, CBox geometry_, bool OR) : xID(xID_), geometry(geometry_), overrideRedirect(OR) {
+CXWaylandSurface::CXWaylandSurface(uint32_t xID_, CBox geometry_, bool OR) : m_xID(xID_), m_geometry(geometry_), m_overrideRedirect(OR) {
;
}
diff --git a/src/xwayland/XSurface.hpp b/src/xwayland/XSurface.hpp
index 53777c33..dc43acbb 100644
--- a/src/xwayland/XSurface.hpp
+++ b/src/xwayland/XSurface.hpp
@@ -39,8 +39,8 @@ typedef struct {
class CXWaylandSurface {
public:
- WP<CWLSurfaceResource> surface;
- WP<CXWaylandSurfaceResource> resource;
+ WP<CWLSurfaceResource> m_surface;
+ WP<CXWaylandSurfaceResource> m_resource;
struct {
CSignal stateChanged; // maximized, fs, minimized, etc.
@@ -57,7 +57,7 @@ class CXWaylandSurface {
CSignal commit;
CSignal activate;
- } events;
+ } m_events;
struct {
std::string title;
@@ -67,31 +67,32 @@ class CXWaylandSurface {
std::optional<bool> requestsMaximize;
std::optional<bool> requestsFullscreen;
std::optional<bool> requestsMinimize;
- } state;
-
- uint32_t xID = 0;
- uint64_t wlID = 0;
- uint64_t wlSerial = 0;
- uint32_t lastPingSeq = 0;
- pid_t pid = 0;
- CBox geometry;
- bool overrideRedirect = false;
- bool withdrawn = false;
- bool fullscreen = false;
- bool maximized = false;
- bool minimized = false;
- bool mapped = false;
- bool modal = false;
-
- WP<CXWaylandSurface> parent;
- WP<CXWaylandSurface> self;
- std::vector<WP<CXWaylandSurface>> children;
-
- UP<xcb_icccm_wm_hints_t> hints;
- UP<xcb_size_hints_t> sizeHints;
- std::vector<uint32_t> atoms, protocols;
- std::string role = "";
- bool transient = false;
+ } m_state;
+
+ uint32_t m_xID = 0;
+ uint64_t m_wlID = 0;
+ uint64_t m_wlSerial = 0;
+ uint32_t m_lastPingSeq = 0;
+ pid_t m_pid = 0;
+ CBox m_geometry;
+ bool m_overrideRedirect = false;
+ bool m_withdrawn = false;
+ bool m_fullscreen = false;
+ bool m_maximized = false;
+ bool m_minimized = false;
+ bool m_mapped = false;
+ bool m_modal = false;
+
+ WP<CXWaylandSurface> m_parent;
+ WP<CXWaylandSurface> m_self;
+ std::vector<WP<CXWaylandSurface>> m_children;
+
+ UP<xcb_icccm_wm_hints_t> m_hints;
+ UP<xcb_size_hints_t> m_sizeHints;
+ std::vector<uint32_t> m_atoms;
+ std::vector<uint32_t> m_protocols;
+ std::string m_role = "";
+ bool m_transient = false;
bool wantsFocus();
void configure(const CBox& box);
@@ -115,7 +116,7 @@ class CXWaylandSurface {
CHyprSignalListener destroyResource;
CHyprSignalListener destroySurface;
CHyprSignalListener commitSurface;
- } listeners;
+ } m_listeners;
friend class CXWM;
};
diff --git a/src/xwayland/XWM.cpp b/src/xwayland/XWM.cpp
index c62758c5..8e4f9a87 100644
--- a/src/xwayland/XWM.cpp
+++ b/src/xwayland/XWM.cpp
@@ -24,12 +24,12 @@ using namespace Hyprutils::OS;
#define INCR_CHUNK_SIZE (64 * 1024)
static int onX11Event(int fd, uint32_t mask, void* data) {
- return g_pXWayland->pWM->onEvent(fd, mask);
+ return g_pXWayland->m_wm->onEvent(fd, mask);
}
SP<CXWaylandSurface> CXWM::windowForXID(xcb_window_t wid) {
- for (auto const& s : surfaces) {
- if (s->xID == wid)
+ for (auto const& s : m_surfaces) {
+ if (s->m_xID == wid)
return s;
}
@@ -40,8 +40,8 @@ void CXWM::handleCreate(xcb_create_notify_event_t* e) {
if (isWMWindow(e->window))
return;
- const auto XSURF = surfaces.emplace_back(SP<CXWaylandSurface>(new CXWaylandSurface(e->window, CBox{e->x, e->y, e->width, e->height}, e->override_redirect)));
- XSURF->self = XSURF;
+ const auto XSURF = m_surfaces.emplace_back(SP<CXWaylandSurface>(new CXWaylandSurface(e->window, CBox{e->x, e->y, e->width, e->height}, e->override_redirect)));
+ XSURF->m_self = XSURF;
Debug::log(LOG, "[xwm] New XSurface at {:x} with xid of {}", (uintptr_t)XSURF.get(), e->window);
const auto WINDOW = CWindow::create(XSURF);
@@ -56,8 +56,8 @@ void CXWM::handleDestroy(xcb_destroy_notify_event_t* e) {
if (!XSURF)
return;
- XSURF->events.destroy.emit();
- std::erase_if(surfaces, [XSURF](const auto& other) { return XSURF == other; });
+ XSURF->m_events.destroy.emit();
+ std::erase_if(m_surfaces, [XSURF](const auto& other) { return XSURF == other; });
}
void CXWM::handleConfigureRequest(xcb_configure_request_event_t* e) {
@@ -71,9 +71,9 @@ void CXWM::handleConfigureRequest(xcb_configure_request_event_t* e) {
if (!(MASK & GEOMETRY))
return;
- XSURF->events.configureRequest.emit(CBox{MASK & XCB_CONFIG_WINDOW_X ? e->x : XSURF->geometry.x, MASK & XCB_CONFIG_WINDOW_Y ? e->y : XSURF->geometry.y,
- MASK & XCB_CONFIG_WINDOW_WIDTH ? e->width : XSURF->geometry.width,
- MASK & XCB_CONFIG_WINDOW_HEIGHT ? e->height : XSURF->geometry.height});
+ XSURF->m_events.configureRequest.emit(CBox{MASK & XCB_CONFIG_WINDOW_X ? e->x : XSURF->m_geometry.x, MASK & XCB_CONFIG_WINDOW_Y ? e->y : XSURF->m_geometry.y,
+ MASK & XCB_CONFIG_WINDOW_WIDTH ? e->width : XSURF->m_geometry.width,
+ MASK & XCB_CONFIG_WINDOW_HEIGHT ? e->height : XSURF->m_geometry.height});
}
void CXWM::handleConfigureNotify(xcb_configure_notify_event_t* e) {
@@ -82,12 +82,12 @@ void CXWM::handleConfigureNotify(xcb_configure_notify_event_t* e) {
if (!XSURF)
return;
- if (XSURF->geometry == CBox{e->x, e->y, e->width, e->height})
+ if (XSURF->m_geometry == CBox{e->x, e->y, e->width, e->height})
return;
- XSURF->geometry = {e->x, e->y, e->width, e->height};
+ XSURF->m_geometry = {e->x, e->y, e->width, e->height};
updateOverrideRedirect(XSURF, e->override_redirect);
- XSURF->events.setGeometry.emit();
+ XSURF->m_events.setGeometry.emit();
}
void CXWM::handleMapRequest(xcb_map_request_event_t* e) {
@@ -96,20 +96,21 @@ void CXWM::handleMapRequest(xcb_map_request_event_t* e) {
if (!XSURF)
return;
- xcb_map_window(connection, e->window);
+ xcb_map_window(m_connection, e->window);
XSURF->restackToTop();
const bool SMALL =
- XSURF->geometry.size() < Vector2D{2, 2} || (XSURF->sizeHints && XSURF->geometry.size() < Vector2D{XSURF->sizeHints->min_width, XSURF->sizeHints->min_height});
- const bool HAS_HINTS = XSURF->sizeHints && Vector2D{XSURF->sizeHints->base_width, XSURF->sizeHints->base_height} > Vector2D{5, 5};
- const auto DESIREDSIZE = HAS_HINTS ? Vector2D{XSURF->sizeHints->base_width, XSURF->sizeHints->base_height} : Vector2D{800, 800};
+ XSURF->m_geometry.size() < Vector2D{2, 2} || (XSURF->m_sizeHints && XSURF->m_geometry.size() < Vector2D{XSURF->m_sizeHints->min_width, XSURF->m_sizeHints->min_height});
+ const bool HAS_HINTS = XSURF->m_sizeHints && Vector2D{XSURF->m_sizeHints->base_width, XSURF->m_sizeHints->base_height} > Vector2D{5, 5};
+ const auto DESIREDSIZE = HAS_HINTS ? Vector2D{XSURF->m_sizeHints->base_width, XSURF->m_sizeHints->base_height} : Vector2D{800, 800};
// if it's too small, configure it.
- if (SMALL && !XSURF->overrideRedirect) // default to 800 x 800
- XSURF->configure({XSURF->geometry.pos(), DESIREDSIZE});
+ if (SMALL && !XSURF->m_overrideRedirect) // default to 800 x 800
+ XSURF->configure({XSURF->m_geometry.pos(), DESIREDSIZE});
- Debug::log(LOG, "[xwm] Mapping window {} in X (geometry {}x{} at {}x{}))", e->window, XSURF->geometry.width, XSURF->geometry.height, XSURF->geometry.x, XSURF->geometry.y);
+ Debug::log(LOG, "[xwm] Mapping window {} in X (geometry {}x{} at {}x{}))", e->window, XSURF->m_geometry.width, XSURF->m_geometry.height, XSURF->m_geometry.x,
+ XSURF->m_geometry.y);
// read data again. Some apps for some reason fail to send WINDOW_TYPE
// this shouldn't happen but does, I prolly fucked up somewhere, this is a band-aid
@@ -126,12 +127,12 @@ void CXWM::handleMapNotify(xcb_map_notify_event_t* e) {
updateOverrideRedirect(XSURF, e->override_redirect);
- if (XSURF->overrideRedirect)
+ if (XSURF->m_overrideRedirect)
return;
XSURF->setWithdrawn(false);
sendState(XSURF);
- xcb_flush(connection);
+ xcb_flush(m_connection);
XSURF->considerMap();
}
@@ -145,23 +146,23 @@ void CXWM::handleUnmapNotify(xcb_unmap_notify_event_t* e) {
XSURF->unmap();
dissociate(XSURF);
- if (XSURF->overrideRedirect)
+ if (XSURF->m_overrideRedirect)
return;
XSURF->setWithdrawn(true);
sendState(XSURF);
- xcb_flush(connection);
+ xcb_flush(m_connection);
}
static bool lookupParentExists(SP<CXWaylandSurface> XSURF, SP<CXWaylandSurface> prospectiveChild) {
std::vector<SP<CXWaylandSurface>> visited;
- while (XSURF->parent) {
- if (XSURF->parent == prospectiveChild)
+ while (XSURF->m_parent) {
+ if (XSURF->m_parent == prospectiveChild)
return true;
visited.emplace_back(XSURF);
- XSURF = XSURF->parent.lock();
+ XSURF = XSURF->m_parent.lock();
if (std::find(visited.begin(), visited.end(), XSURF) != visited.end())
return false;
@@ -179,8 +180,8 @@ std::string CXWM::getAtomName(uint32_t atom) {
}
// Get the name of the atom
- auto const atom_name_cookie = xcb_get_atom_name(connection, atom);
- auto* atom_name_reply = xcb_get_atom_name_reply(connection, atom_name_cookie, nullptr);
+ auto const atom_name_cookie = xcb_get_atom_name(m_connection, atom);
+ auto* atom_name_reply = xcb_get_atom_name_reply(m_connection, atom_name_cookie, nullptr);
if (!atom_name_reply)
return "Unknown";
@@ -198,90 +199,90 @@ void CXWM::readProp(SP<CXWaylandSurface> XSURF, uint32_t atom, xcb_get_property_
propName = getAtomName(atom);
if (atom == XCB_ATOM_WM_CLASS) {
- size_t len = xcb_get_property_value_length(reply);
- char* string = (char*)xcb_get_property_value(reply);
- XSURF->state.appid = std::string{string, len};
- if (std::count(XSURF->state.appid.begin(), XSURF->state.appid.end(), '\000') == 2)
- XSURF->state.appid = XSURF->state.appid.substr(XSURF->state.appid.find_first_of('\000') + 1); // fuck you X
- if (!XSURF->state.appid.empty())
- XSURF->state.appid.pop_back();
- XSURF->events.metadataChanged.emit();
+ size_t len = xcb_get_property_value_length(reply);
+ char* string = (char*)xcb_get_property_value(reply);
+ XSURF->m_state.appid = std::string{string, len};
+ if (std::count(XSURF->m_state.appid.begin(), XSURF->m_state.appid.end(), '\000') == 2)
+ XSURF->m_state.appid = XSURF->m_state.appid.substr(XSURF->m_state.appid.find_first_of('\000') + 1); // fuck you X
+ if (!XSURF->m_state.appid.empty())
+ XSURF->m_state.appid.pop_back();
+ XSURF->m_events.metadataChanged.emit();
} else if (atom == XCB_ATOM_WM_NAME || atom == HYPRATOMS["_NET_WM_NAME"]) {
size_t len = xcb_get_property_value_length(reply);
char* string = (char*)xcb_get_property_value(reply);
if (reply->type != HYPRATOMS["UTF8_STRING"] && reply->type != HYPRATOMS["TEXT"] && reply->type != XCB_ATOM_STRING)
return;
- XSURF->state.title = std::string{string, len};
- XSURF->events.metadataChanged.emit();
+ XSURF->m_state.title = std::string{string, len};
+ XSURF->m_events.metadataChanged.emit();
} else if (atom == HYPRATOMS["_NET_WM_WINDOW_TYPE"]) {
xcb_atom_t* atomsArr = (xcb_atom_t*)xcb_get_property_value(reply);
size_t atomsNo = reply->value_len;
- XSURF->atoms.clear();
+ XSURF->m_atoms.clear();
for (size_t i = 0; i < atomsNo; ++i) {
- XSURF->atoms.push_back(atomsArr[i]);
+ XSURF->m_atoms.push_back(atomsArr[i]);
}
} else if (atom == HYPRATOMS["_NET_WM_STATE"]) {
xcb_atom_t* atoms = (xcb_atom_t*)xcb_get_property_value(reply);
for (uint32_t i = 0; i < reply->value_len; i++) {
if (atoms[i] == HYPRATOMS["_NET_WM_STATE_MODAL"])
- XSURF->modal = true;
+ XSURF->m_modal = true;
}
} else if (atom == HYPRATOMS["WM_HINTS"]) {
if (reply->value_len != 0) {
- XSURF->hints = makeUnique<xcb_icccm_wm_hints_t>();
- xcb_icccm_get_wm_hints_from_reply(XSURF->hints.get(), reply);
+ XSURF->m_hints = makeUnique<xcb_icccm_wm_hints_t>();
+ xcb_icccm_get_wm_hints_from_reply(XSURF->m_hints.get(), reply);
- if (!(XSURF->hints->flags & XCB_ICCCM_WM_HINT_INPUT))
- XSURF->hints->input = true;
+ if (!(XSURF->m_hints->flags & XCB_ICCCM_WM_HINT_INPUT))
+ XSURF->m_hints->input = true;
}
} else if (atom == HYPRATOMS["WM_WINDOW_ROLE"]) {
size_t len = xcb_get_property_value_length(reply);
if (len <= 0)
- XSURF->role = "";
+ XSURF->m_role = "";
else {
- XSURF->role = std::string{(char*)xcb_get_property_value(reply), len};
- XSURF->role = XSURF->role.substr(0, XSURF->role.find_first_of('\000'));
+ XSURF->m_role = std::string{(char*)xcb_get_property_value(reply), len};
+ XSURF->m_role = XSURF->m_role.substr(0, XSURF->m_role.find_first_of('\000'));
}
} else if (atom == XCB_ATOM_WM_TRANSIENT_FOR) {
if (reply->type == XCB_ATOM_WINDOW) {
- const auto XID = (xcb_window_t*)xcb_get_property_value(reply);
- XSURF->transient = XID;
+ const auto XID = (xcb_window_t*)xcb_get_property_value(reply);
+ XSURF->m_transient = XID;
if (XID) {
if (const auto NEWXSURF = windowForXID(*XID); NEWXSURF && !lookupParentExists(XSURF, NEWXSURF)) {
- XSURF->parent = NEWXSURF;
- NEWXSURF->children.emplace_back(XSURF);
+ XSURF->m_parent = NEWXSURF;
+ NEWXSURF->m_children.emplace_back(XSURF);
} else
Debug::log(LOG, "[xwm] Denying transient because it would create a loop");
}
}
} else if (atom == HYPRATOMS["WM_NORMAL_HINTS"]) {
if (reply->type == HYPRATOMS["WM_SIZE_HINTS"] && reply->value_len > 0) {
- XSURF->sizeHints = makeUnique<xcb_size_hints_t>();
- std::memset(XSURF->sizeHints.get(), 0, sizeof(xcb_size_hints_t));
+ XSURF->m_sizeHints = makeUnique<xcb_size_hints_t>();
+ std::memset(XSURF->m_sizeHints.get(), 0, sizeof(xcb_size_hints_t));
- xcb_icccm_get_wm_size_hints_from_reply(XSURF->sizeHints.get(), reply);
+ xcb_icccm_get_wm_size_hints_from_reply(XSURF->m_sizeHints.get(), reply);
- const int32_t FLAGS = XSURF->sizeHints->flags;
+ const int32_t FLAGS = XSURF->m_sizeHints->flags;
const bool HASMIN = (FLAGS & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE);
const bool HASBASE = (FLAGS & XCB_ICCCM_SIZE_HINT_BASE_SIZE);
if (!HASMIN && !HASBASE) {
- XSURF->sizeHints->min_width = -1;
- XSURF->sizeHints->min_height = -1;
- XSURF->sizeHints->base_width = -1;
- XSURF->sizeHints->base_height = -1;
+ XSURF->m_sizeHints->min_width = -1;
+ XSURF->m_sizeHints->min_height = -1;
+ XSURF->m_sizeHints->base_width = -1;
+ XSURF->m_sizeHints->base_height = -1;
} else if (!HASBASE) {
- XSURF->sizeHints->base_width = XSURF->sizeHints->min_width;
- XSURF->sizeHints->base_height = XSURF->sizeHints->min_height;
+ XSURF->m_sizeHints->base_width = XSURF->m_sizeHints->min_width;
+ XSURF->m_sizeHints->base_height = XSURF->m_sizeHints->min_height;
} else if (!HASMIN) {
- XSURF->sizeHints->min_width = XSURF->sizeHints->base_width;
- XSURF->sizeHints->min_height = XSURF->sizeHints->base_height;
+ XSURF->m_sizeHints->min_width = XSURF->m_sizeHints->base_width;
+ XSURF->m_sizeHints->min_height = XSURF->m_sizeHints->base_height;
}
if (!(FLAGS & XCB_ICCCM_SIZE_HINT_P_MAX_SIZE)) {
- XSURF->sizeHints->max_width = -1;
- XSURF->sizeHints->max_height = -1;
+ XSURF->m_sizeHints->max_width = -1;
+ XSURF->m_sizeHints->max_height = -1;
}
}
} else if (atom == HYPRATOMS["WM_PROTOCOLS"]) {
@@ -292,7 +293,7 @@ void CXWM::readProp(SP<CXWaylandSurface> XSURF, uint32_t atom, xcb_get_property_
for (size_t i = 0; i < reply->value_len; ++i) {
vec.emplace_back(atoms[i]);
}
- XSURF->protocols = vec;
+ XSURF->m_protocols = vec;
}
} else {
Debug::log(TRACE, "[xwm] Unhandled prop {} -> {}", atom, propName);
@@ -308,8 +309,8 @@ void CXWM::handlePropertyNotify(xcb_property_notify_event_t* e) {
if (!XSURF)
return;
- xcb_get_property_cookie_t cookie = xcb_get_property(connection, 0, XSURF->xID, e->atom, XCB_ATOM_ANY, 0, 2048);
- xcb_get_property_reply_t* reply = xcb_get_property_reply(connection, cookie, nullptr);
+ xcb_get_property_cookie_t cookie = xcb_get_property(m_connection, 0, XSURF->m_xID, e->atom, XCB_ATOM_ANY, 0, 2048);
+ xcb_get_property_reply_t* reply = xcb_get_property_reply(m_connection, cookie, nullptr);
if (!reply) {
Debug::log(ERR, "[xwm] Failed to read property notify cookie");
return;
@@ -329,39 +330,39 @@ void CXWM::handleClientMessage(xcb_client_message_event_t* e) {
std::string propName = getAtomName(e->type);
if (e->type == HYPRATOMS["WM_PROTOCOLS"]) {
- if (e->data.data32[1] == XSURF->lastPingSeq && e->data.data32[0] == HYPRATOMS["_NET_WM_PING"]) {
+ if (e->data.data32[1] == XSURF->m_lastPingSeq && e->data.data32[0] == HYPRATOMS["_NET_WM_PING"]) {
g_pANRManager->onResponse(XSURF);
return;
}
} else if (e->type == HYPRATOMS["WL_SURFACE_ID"]) {
- if (XSURF->surface) {
+ if (XSURF->m_surface) {
Debug::log(WARN, "[xwm] Re-assignment of WL_SURFACE_ID");
dissociate(XSURF);
}
auto id = e->data.data32[0];
- auto resource = wl_client_get_object(g_pXWayland->pServer->xwaylandClient, id);
+ auto resource = wl_client_get_object(g_pXWayland->m_server->m_xwaylandClient, id);
if (resource) {
auto surf = CWLSurfaceResource::fromResource(resource);
associate(XSURF, surf);
}
} else if (e->type == HYPRATOMS["WL_SURFACE_SERIAL"]) {
- if (XSURF->wlSerial) {
+ if (XSURF->m_wlSerial) {
Debug::log(WARN, "[xwm] Re-assignment of WL_SURFACE_SERIAL");
dissociate(XSURF);
}
uint32_t serialLow = e->data.data32[0];
uint32_t serialHigh = e->data.data32[1];
- XSURF->wlSerial = ((uint64_t)serialHigh << 32) | serialLow;
+ XSURF->m_wlSerial = ((uint64_t)serialHigh << 32) | serialLow;
- Debug::log(LOG, "[xwm] surface {:x} requests serial {:x}", (uintptr_t)XSURF.get(), XSURF->wlSerial);
+ Debug::log(LOG, "[xwm] surface {:x} requests serial {:x}", (uintptr_t)XSURF.get(), XSURF->m_wlSerial);
- for (auto const& res : shellResources) {
+ for (auto const& res : m_shellResources) {
if (!res)
continue;
- if (res->m_serial != XSURF->wlSerial || !XSURF->wlSerial)
+ if (res->m_serial != XSURF->m_wlSerial || !XSURF->m_wlSerial)
continue;
associate(XSURF, res->m_surface.lock());
@@ -391,15 +392,15 @@ void CXWM::handleClientMessage(xcb_client_message_event_t* e) {
};
if (prop == HYPRATOMS["_NET_WM_STATE_FULLSCREEN"])
- XSURF->state.requestsFullscreen = updateState(action, XSURF->fullscreen);
+ XSURF->m_state.requestsFullscreen = updateState(action, XSURF->m_fullscreen);
}
- XSURF->events.stateChanged.emit();
+ XSURF->m_events.stateChanged.emit();
}
} else if (e->type == HYPRATOMS["_NET_ACTIVE_WINDOW"]) {
- XSURF->events.activate.emit();
+ XSURF->m_events.activate.emit();
} else if (e->type == HYPRATOMS["XdndStatus"]) {
- if (dndDataOffers.empty() || !dndDataOffers.at(0)->getSource()) {
+ if (m_dndDataOffers.empty() || !m_dndDataOffers.at(0)->getSource()) {
Debug::log(TRACE, "[xwm] Rejecting XdndStatus message: nothing to get");
return;
}
@@ -408,16 +409,16 @@ void CXWM::handleClientMessage(xcb_client_message_event_t* e) {
const bool ACCEPTED = data->data32[1] & 1;
if (ACCEPTED)
- dndDataOffers.at(0)->getSource()->accepted("");
+ m_dndDataOffers.at(0)->getSource()->accepted("");
Debug::log(LOG, "[xwm] XdndStatus: accepted: {}");
} else if (e->type == HYPRATOMS["XdndFinished"]) {
- if (dndDataOffers.empty() || !dndDataOffers.at(0)->getSource()) {
+ if (m_dndDataOffers.empty() || !m_dndDataOffers.at(0)->getSource()) {
Debug::log(TRACE, "[xwm] Rejecting XdndFinished message: nothing to get");
return;
}
- dndDataOffers.at(0)->getSource()->sendDndFinished();
+ m_dndDataOffers.at(0)->getSource()->sendDndFinished();
Debug::log(LOG, "[xwm] XdndFinished");
} else {
@@ -437,10 +438,10 @@ void CXWM::handleFocusIn(xcb_focus_in_event_t* e) {
if (!XSURF)
return;
- if (focusedSurface && focusedSurface->pid == XSURF->pid && e->sequence - lastFocusSeq <= 255)
+ if (m_focusedSurface && m_focusedSurface->m_pid == XSURF->m_pid && e->sequence - m_lastFocusSeq <= 255)
focusWindow(XSURF);
else
- focusWindow(focusedSurface.lock());
+ focusWindow(m_focusedSurface.lock());
}
void CXWM::handleFocusOut(xcb_focus_out_event_t* e) {
@@ -451,8 +452,8 @@ void CXWM::handleFocusOut(xcb_focus_out_event_t* e) {
if (!XSURF)
return;
- Debug::log(TRACE, "[xwm] focusOut for {} {} {} surface {}", XSURF->mapped ? "mapped" : "unmapped", XSURF->fullscreen ? "fullscreen" : "windowed",
- XSURF == focusedSurface ? "focused" : "unfocused", XSURF->state.title);
+ Debug::log(TRACE, "[xwm] focusOut for {} {} {} surface {}", XSURF->m_mapped ? "mapped" : "unmapped", XSURF->m_fullscreen ? "fullscreen" : "windowed",
+ XSURF == m_focusedSurface ? "focused" : "unfocused", XSURF->m_state.title);
// do something?
}
@@ -462,63 +463,63 @@ void CXWM::sendWMMessage(SP<CXWaylandSurface> surf, xcb_client_message_data_t* d
.response_type = XCB_CLIENT_MESSAGE,
.format = 32,
.sequence = 0,
- .window = surf->xID,
+ .window = surf->m_xID,
.type = HYPRATOMS["WM_PROTOCOLS"],
.data = *data,
};
- xcb_send_event(connection, 0, surf->xID, mask, (const char*)&event);
- xcb_flush(connection);
+ xcb_send_event(m_connection, 0, surf->m_xID, mask, (const char*)&event);
+ xcb_flush(m_connection);
}
void CXWM::focusWindow(SP<CXWaylandSurface> surf) {
- if (surf == focusedSurface)
+ if (surf == m_focusedSurface)
return;
- focusedSurface = surf;
+ m_focusedSurface = surf;
// send state to all toplevel surfaces, sometimes we might lose some
// that could still stick with the focused atom
- for (auto const& s : mappedSurfaces) {
- if (!s || s->overrideRedirect)
+ for (auto const& s : m_mappedSurfaces) {
+ if (!s || s->m_overrideRedirect)
continue;
sendState(s.lock());
}
if (!surf) {
- xcb_set_input_focus_checked(connection, XCB_INPUT_FOCUS_POINTER_ROOT, XCB_NONE, XCB_CURRENT_TIME);
+ xcb_set_input_focus_checked(m_connection, XCB_INPUT_FOCUS_POINTER_ROOT, XCB_NONE, XCB_CURRENT_TIME);
return;
}
- if (surf->overrideRedirect)
+ if (surf->m_overrideRedirect)
return;
xcb_client_message_data_t msg = {{0}};
msg.data32[0] = HYPRATOMS["WM_TAKE_FOCUS"];
msg.data32[1] = XCB_TIME_CURRENT_TIME;
- if (surf->hints && !surf->hints->input)
+ if (surf->m_hints && !surf->m_hints->input)
sendWMMessage(surf, &msg, XCB_EVENT_MASK_NO_EVENT);
else {
sendWMMessage(surf, &msg, XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT);
- xcb_void_cookie_t cookie = xcb_set_input_focus(connection, XCB_INPUT_FOCUS_POINTER_ROOT, surf->xID, XCB_CURRENT_TIME);
- lastFocusSeq = cookie.sequence;
+ xcb_void_cookie_t cookie = xcb_set_input_focus(m_connection, XCB_INPUT_FOCUS_POINTER_ROOT, surf->m_xID, XCB_CURRENT_TIME);
+ m_lastFocusSeq = cookie.sequence;
}
}
void CXWM::handleError(xcb_value_error_t* e) {
- const char* major_name = xcb_errors_get_name_for_major_code(errors, e->major_opcode);
+ const char* major_name = xcb_errors_get_name_for_major_code(m_errors, e->major_opcode);
if (!major_name) {
Debug::log(ERR, "xcb error happened, but could not get major name");
return;
}
- const char* minor_name = xcb_errors_get_name_for_minor_code(errors, e->major_opcode, e->minor_opcode);
+ const char* minor_name = xcb_errors_get_name_for_minor_code(m_errors, e->major_opcode, e->minor_opcode);
const char* extension;
- const char* error_name = xcb_errors_get_name_for_error(errors, e->error_code, &extension);
+ const char* error_name = xcb_errors_get_name_for_error(m_errors, e->error_code, &extension);
if (!error_name) {
Debug::log(ERR, "xcb error happened, but could not get error name");
return;
@@ -539,8 +540,8 @@ void CXWM::selectionSendNotify(xcb_selection_request_event_t* e, bool success) {
.property = success ? e->property : (uint32_t)XCB_ATOM_NONE,
};
- xcb_send_event(connection, 0, e->requestor, XCB_EVENT_MASK_NO_EVENT, (const char*)&selection_notify);
- xcb_flush(connection);
+ xcb_send_event(m_connection, 0, e->requestor, XCB_EVENT_MASK_NO_EVENT, (const char*)&selection_notify);
+ xcb_flush(m_connection);
}
xcb_atom_t CXWM::mimeToAtom(const std::string& mime) {
@@ -549,8 +550,8 @@ xcb_atom_t CXWM::mimeToAtom(const std::string& mime) {
if (mime == "text/plain")
return HYPRATOMS["TEXT"];
- xcb_intern_atom_cookie_t cookie = xcb_intern_atom(connection, 0, mime.length(), mime.c_str());
- xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(connection, cookie, nullptr);
+ xcb_intern_atom_cookie_t cookie = xcb_intern_atom(m_connection, 0, mime.length(), mime.c_str());
+ xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(m_connection, cookie, nullptr);
if (!reply)
return XCB_ATOM_NONE;
xcb_atom_t atom = reply->atom;
@@ -564,8 +565,8 @@ std::string CXWM::mimeFromAtom(xcb_atom_t atom) {
if (atom == HYPRATOMS["TEXT"])
return "text/plain";
- xcb_get_atom_name_cookie_t cookie = xcb_get_atom_name(connection, atom);
- xcb_get_atom_name_reply_t* reply = xcb_get_atom_name_reply(connection, cookie, nullptr);
+ xcb_get_atom_name_cookie_t cookie = xcb_get_atom_name(m_connection, atom);
+ xcb_get_atom_name_reply_t* reply = xcb_get_atom_name_reply(m_connection, cookie, nullptr);
if (!reply)
return "INVALID";
size_t len = xcb_get_atom_name_name_length(reply);
@@ -587,7 +588,7 @@ void CXWM::handleSelectionNotify(xcb_selection_notify_event_t* e) {
sel->transfers.erase(it);
}
} else if (e->target == HYPRATOMS["TARGETS"]) {
- if (!focusedSurface) {
+ if (!m_focusedSurface) {
Debug::log(TRACE, "[xwm] denying access to write to clipboard because no X client is in focus");
return;
}
@@ -601,7 +602,7 @@ bool CXWM::handleSelectionPropertyNotify(xcb_property_notify_event_t* e) {
if (e->state != XCB_PROPERTY_DELETE)
return false;
- for (auto* sel : {&clipboard, &primarySelection}) {
+ for (auto* sel : {&m_clipboard, &m_primarySelection}) {
auto it = std::ranges::find_if(sel->transfers, [e](const auto& t) { return t->incomingWindow == e->window; });
if (it != sel->transfers.end()) {
if (!(*it)->getIncomingSelectionProp(true)) {
@@ -618,11 +619,11 @@ bool CXWM::handleSelectionPropertyNotify(xcb_property_notify_event_t* e) {
SXSelection* CXWM::getSelection(xcb_atom_t atom) {
if (atom == HYPRATOMS["CLIPBOARD"])
- return &clipboard;
+ return &m_clipboard;
else if (atom == HYPRATOMS["PRIMARY"])
- return &primarySelection;
+ return &m_primarySelection;
else if (atom == HYPRATOMS["XdndSelection"])
- return &dndSelection;
+ return &m_dndSelection;
return nullptr;
}
@@ -650,7 +651,7 @@ void CXWM::handleSelectionRequest(xcb_selection_request_event_t* e) {
return;
}
- if (!g_pSeatManager->m_state.keyboardFocusResource || g_pSeatManager->m_state.keyboardFocusResource->client() != g_pXWayland->pServer->xwaylandClient) {
+ if (!g_pSeatManager->m_state.keyboardFocusResource || g_pSeatManager->m_state.keyboardFocusResource->client() != g_pXWayland->m_server->m_xwaylandClient) {
Debug::log(TRACE, "[xwm] Ignoring clipboard access: xwayland not in focus");
selectionSendNotify(e, false);
return;
@@ -659,10 +660,10 @@ void CXWM::handleSelectionRequest(xcb_selection_request_event_t* e) {
if (e->target == HYPRATOMS["TARGETS"]) {
// send mime types
std::vector<std::string> mimes;
- if (sel == &clipboard && g_pSeatManager->m_selection.currentSelection)
+ if (sel == &m_clipboard && g_pSeatManager->m_selection.currentSelection)
mimes = g_pSeatManager->m_selection.currentSelection->mimes();
- else if (sel == &dndSelection && !dndDataOffers.empty() && dndDataOffers.at(0)->source)
- mimes = dndDataOffers.at(0)->source->mimes();
+ else if (sel == &m_dndSelection && !m_dndDataOffers.empty() && m_dndDataOffers.at(0)->m_source)
+ mimes = m_dndDataOffers.at(0)->m_source->mimes();
if (mimes.empty())
Debug::log(WARN, "[xwm] WARNING: No mimes in TARGETS?");
@@ -677,10 +678,10 @@ void CXWM::handleSelectionRequest(xcb_selection_request_event_t* e) {
atoms.push_back(mimeToAtom(m));
}
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, e->requestor, e->property, XCB_ATOM_ATOM, 32, atoms.size(), atoms.data());
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, e->requestor, e->property, XCB_ATOM_ATOM, 32, atoms.size(), atoms.data());
selectionSendNotify(e, true);
} else if (e->target == HYPRATOMS["TIMESTAMP"]) {
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, e->requestor, e->property, XCB_ATOM_INTEGER, 32, 1, &sel->timestamp);
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, e->requestor, e->property, XCB_ATOM_INTEGER, 32, 1, &sel->timestamp);
selectionSendNotify(e, true);
} else if (e->target == HYPRATOMS["DELETE"]) {
selectionSendNotify(e, true);
@@ -707,14 +708,14 @@ bool CXWM::handleSelectionXFixesNotify(xcb_xfixes_selection_notify_event_t* e) {
// IMPORTANT: mind the g_pSeatManager below
SXSelection* sel = getSelection(e->selection);
- if (sel == &dndSelection)
+ if (sel == &m_dndSelection)
return true;
if (e->owner == XCB_WINDOW_NONE) {
if (sel->owner != sel->window) {
- if (sel == &clipboard)
+ if (sel == &m_clipboard)
g_pSeatManager->setCurrentSelection(nullptr);
- else if (sel == &primarySelection)
+ else if (sel == &m_primarySelection)
g_pSeatManager->setCurrentPrimarySelection(nullptr);
}
@@ -729,11 +730,11 @@ bool CXWM::handleSelectionXFixesNotify(xcb_xfixes_selection_notify_event_t* e) {
return true;
}
- if (sel == &clipboard)
- xcb_convert_selection(connection, sel->window, HYPRATOMS["CLIPBOARD"], HYPRATOMS["TARGETS"], HYPRATOMS["_WL_SELECTION"], e->timestamp);
- else if (sel == &primarySelection)
- xcb_convert_selection(connection, sel->window, HYPRATOMS["PRIMARY"], HYPRATOMS["TARGETS"], HYPRATOMS["_WL_SELECTION"], e->timestamp);
- xcb_flush(connection);
+ if (sel == &m_clipboard)
+ xcb_convert_selection(m_connection, sel->window, HYPRATOMS["CLIPBOARD"], HYPRATOMS["TARGETS"], HYPRATOMS["_WL_SELECTION"], e->timestamp);
+ else if (sel == &m_primarySelection)
+ xcb_convert_selection(m_connection, sel->window, HYPRATOMS["PRIMARY"], HYPRATOMS["TARGETS"], HYPRATOMS["_WL_SELECTION"], e->timestamp);
+ xcb_flush(m_connection);
return true;
}
@@ -753,7 +754,7 @@ bool CXWM::handleSelectionEvent(xcb_generic_event_t* e) {
}
}
- if (e->response_type - xfixes->first_event == XCB_XFIXES_SELECTION_NOTIFY)
+ if (e->response_type - m_xfixes->first_event == XCB_XFIXES_SELECTION_NOTIFY)
return handleSelectionXFixesNotify((xcb_xfixes_selection_notify_event_t*)e);
return 0;
@@ -764,8 +765,8 @@ int CXWM::onEvent(int fd, uint32_t mask) {
if ((mask & WL_EVENT_HANGUP) || (mask & WL_EVENT_ERROR)) {
Debug::log(ERR, "XWayland has yeeten the xwm off?!");
Debug::log(CRIT, "XWayland has yeeten the xwm off?!");
- g_pXWayland->pWM.reset();
- g_pXWayland->pServer.reset();
+ g_pXWayland->m_wm.reset();
+ g_pXWayland->m_server.reset();
// Attempt to create fresh instance
g_pEventLoopManager->doLater([]() { g_pXWayland = makeUnique<CXWayland>(true); });
return 0;
@@ -774,7 +775,7 @@ int CXWM::onEvent(int fd, uint32_t mask) {
int count = 0;
while (42069) {
- xcb_generic_event_t* event = xcb_poll_for_event(connection);
+ xcb_generic_event_t* event = xcb_poll_for_event(m_connection);
if (!event)
break;
@@ -806,19 +807,19 @@ int CXWM::onEvent(int fd, uint32_t mask) {
}
if (count)
- xcb_flush(connection);
+ xcb_flush(m_connection);
return count;
}
void CXWM::gatherResources() {
- xcb_prefetch_extension_data(connection, &xcb_xfixes_id);
- xcb_prefetch_extension_data(connection, &xcb_composite_id);
- xcb_prefetch_extension_data(connection, &xcb_res_id);
+ xcb_prefetch_extension_data(m_connection, &xcb_xfixes_id);
+ xcb_prefetch_extension_data(m_connection, &xcb_composite_id);
+ xcb_prefetch_extension_data(m_connection, &xcb_res_id);
for (auto& ATOM : HYPRATOMS) {
- xcb_intern_atom_cookie_t cookie = xcb_intern_atom(connection, 0, ATOM.first.length(), ATOM.first.c_str());
- xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(connection, cookie, nullptr);
+ xcb_intern_atom_cookie_t cookie = xcb_intern_atom(m_connection, 0, ATOM.first.length(), ATOM.first.c_str());
+ xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(m_connection, cookie, nullptr);
if (!reply) {
Debug::log(ERR, "[xwm] Atom failed: {}", ATOM.first);
@@ -829,33 +830,33 @@ void CXWM::gatherResources() {
free(reply);
}
- xfixes = xcb_get_extension_data(connection, &xcb_xfixes_id);
+ m_xfixes = xcb_get_extension_data(m_connection, &xcb_xfixes_id);
- if (!xfixes || !xfixes->present)
+ if (!m_xfixes || !m_xfixes->present)
Debug::log(WARN, "XFixes not available");
xcb_xfixes_query_version_cookie_t xfixes_cookie;
xcb_xfixes_query_version_reply_t* xfixes_reply;
- xfixes_cookie = xcb_xfixes_query_version(connection, XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION);
- xfixes_reply = xcb_xfixes_query_version_reply(connection, xfixes_cookie, nullptr);
+ xfixes_cookie = xcb_xfixes_query_version(m_connection, XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION);
+ xfixes_reply = xcb_xfixes_query_version_reply(m_connection, xfixes_cookie, nullptr);
Debug::log(LOG, "xfixes version: {}.{}", xfixes_reply->major_version, xfixes_reply->minor_version);
- xfixesMajor = xfixes_reply->major_version;
+ m_xfixesMajor = xfixes_reply->major_version;
free(xfixes_reply);
- const xcb_query_extension_reply_t* xresReply1 = xcb_get_extension_data(connection, &xcb_res_id);
+ const xcb_query_extension_reply_t* xresReply1 = xcb_get_extension_data(m_connection, &xcb_res_id);
if (!xresReply1 || !xresReply1->present)
return;
- xcb_res_query_version_cookie_t xres_cookie = xcb_res_query_version(connection, XCB_RES_MAJOR_VERSION, XCB_RES_MINOR_VERSION);
- xcb_res_query_version_reply_t* xres_reply = xcb_res_query_version_reply(connection, xres_cookie, nullptr);
+ xcb_res_query_version_cookie_t xres_cookie = xcb_res_query_version(m_connection, XCB_RES_MAJOR_VERSION, XCB_RES_MINOR_VERSION);
+ xcb_res_query_version_reply_t* xres_reply = xcb_res_query_version_reply(m_connection, xres_cookie, nullptr);
if (xres_reply == nullptr)
return;
Debug::log(LOG, "xres version: {}.{}", xres_reply->server_major, xres_reply->server_minor);
if (xres_reply->server_major > 1 || (xres_reply->server_major == 1 && xres_reply->server_minor >= 2)) {
- xres = xresReply1;
+ m_xres = xresReply1;
}
free(xres_reply);
}
@@ -865,7 +866,7 @@ void CXWM::getVisual() {
xcb_visualtype_iterator_t vt_iter;
xcb_visualtype_t* visualtype;
- d_iter = xcb_screen_allowed_depths_iterator(screen);
+ d_iter = xcb_screen_allowed_depths_iterator(m_screen);
visualtype = nullptr;
while (d_iter.rem > 0) {
if (d_iter.data->depth == 32) {
@@ -882,14 +883,14 @@ void CXWM::getVisual() {
return;
}
- visual_id = visualtype->visual_id;
- colormap = xcb_generate_id(connection);
- xcb_create_colormap(connection, XCB_COLORMAP_ALLOC_NONE, colormap, screen->root, visual_id);
+ m_visualID = visualtype->visual_id;
+ m_colormap = xcb_generate_id(m_connection);
+ xcb_create_colormap(m_connection, XCB_COLORMAP_ALLOC_NONE, m_colormap, m_screen->root, m_visualID);
}
void CXWM::getRenderFormat() {
- xcb_render_query_pict_formats_cookie_t cookie = xcb_render_query_pict_formats(connection);
- xcb_render_query_pict_formats_reply_t* reply = xcb_render_query_pict_formats_reply(connection, cookie, nullptr);
+ xcb_render_query_pict_formats_cookie_t cookie = xcb_render_query_pict_formats(m_connection);
+ xcb_render_query_pict_formats_reply_t* reply = xcb_render_query_pict_formats_reply(m_connection, cookie, nullptr);
if (!reply) {
Debug::log(LOG, "xwm: No xcb_render_query_pict_formats_reply_t reply");
return;
@@ -911,30 +912,30 @@ void CXWM::getRenderFormat() {
return;
}
- render_format_id = format->id;
+ m_renderFormatID = format->id;
free(reply);
}
-CXWM::CXWM() : connection(g_pXWayland->pServer->xwmFDs[0].get()) {
+CXWM::CXWM() : m_connection(g_pXWayland->m_server->m_xwmFDs[0].get()) {
- if (connection.hasError()) {
- Debug::log(ERR, "[xwm] Couldn't start, error {}", connection.hasError());
+ if (m_connection.hasError()) {
+ Debug::log(ERR, "[xwm] Couldn't start, error {}", m_connection.hasError());
return;
}
- CXCBErrorContext xcbErrCtx(connection);
+ CXCBErrorContext xcbErrCtx(m_connection);
if (!xcbErrCtx.isValid()) {
Debug::log(ERR, "[xwm] Couldn't allocate errors context");
return;
}
- dndDataDevice->self = dndDataDevice;
+ m_dndDataDevice->m_self = m_dndDataDevice;
- xcb_screen_iterator_t screen_iterator = xcb_setup_roots_iterator(xcb_get_setup(connection));
- screen = screen_iterator.data;
+ xcb_screen_iterator_t screen_iterator = xcb_setup_roots_iterator(xcb_get_setup(m_connection));
+ m_screen = screen_iterator.data;
- eventSource = wl_event_loop_add_fd(g_pCompositor->m_wlEventLoop, g_pXWayland->pServer->xwmFDs[0].get(), WL_EVENT_READABLE, ::onX11Event, nullptr);
- wl_event_source_check(eventSource);
+ m_eventSource = wl_event_loop_add_fd(g_pCompositor->m_wlEventLoop, g_pXWayland->m_server->m_xwmFDs[0].get(), WL_EVENT_READABLE, ::onX11Event, nullptr);
+ wl_event_source_check(m_eventSource);
gatherResources();
getVisual();
@@ -943,114 +944,115 @@ CXWM::CXWM() : connection(g_pXWayland->pServer->xwmFDs[0].get()) {
uint32_t values[] = {
XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_PROPERTY_CHANGE,
};
- xcb_change_window_attributes(connection, screen->root, XCB_CW_EVENT_MASK, values);
+ xcb_change_window_attributes(m_connection, m_screen->root, XCB_CW_EVENT_MASK, values);
- xcb_composite_redirect_subwindows(connection, screen->root, XCB_COMPOSITE_REDIRECT_MANUAL);
+ xcb_composite_redirect_subwindows(m_connection, m_screen->root, XCB_COMPOSITE_REDIRECT_MANUAL);
xcb_atom_t supported[] = {
HYPRATOMS["_NET_WM_STATE"], HYPRATOMS["_NET_ACTIVE_WINDOW"], HYPRATOMS["_NET_WM_MOVERESIZE"], HYPRATOMS["_NET_WM_STATE_FOCUSED"],
HYPRATOMS["_NET_WM_STATE_MODAL"], HYPRATOMS["_NET_WM_STATE_FULLSCREEN"], HYPRATOMS["_NET_WM_STATE_MAXIMIZED_VERT"], HYPRATOMS["_NET_WM_STATE_MAXIMIZED_HORZ"],
HYPRATOMS["_NET_WM_STATE_HIDDEN"], HYPRATOMS["_NET_CLIENT_LIST"], HYPRATOMS["_NET_CLIENT_LIST_STACKING"],
};
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, screen->root, HYPRATOMS["_NET_SUPPORTED"], XCB_ATOM_ATOM, 32, sizeof(supported) / sizeof(*supported), supported);
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_screen->root, HYPRATOMS["_NET_SUPPORTED"], XCB_ATOM_ATOM, 32, sizeof(supported) / sizeof(*supported), supported);
setActiveWindow(XCB_WINDOW_NONE);
initSelection();
- listeners.newWLSurface = PROTO::compositor->m_events.newSurface.registerListener([this](std::any d) { onNewSurface(std::any_cast<SP<CWLSurfaceResource>>(d)); });
- listeners.newXShellSurface = PROTO::xwaylandShell->m_events.newSurface.registerListener([this](std::any d) { onNewResource(std::any_cast<SP<CXWaylandSurfaceResource>>(d)); });
+ m_listeners.newWLSurface = PROTO::compositor->m_events.newSurface.registerListener([this](std::any d) { onNewSurface(std::any_cast<SP<CWLSurfaceResource>>(d)); });
+ m_listeners.newXShellSurface =
+ PROTO::xwaylandShell->m_events.newSurface.registerListener([this](std::any d) { onNewResource(std::any_cast<SP<CXWaylandSurfaceResource>>(d)); });
createWMWindow();
- xcb_flush(connection);
+ xcb_flush(m_connection);
}
CXWM::~CXWM() {
- if (eventSource)
- wl_event_source_remove(eventSource);
+ if (m_eventSource)
+ wl_event_source_remove(m_eventSource);
- for (auto const& sr : surfaces) {
- sr->events.destroy.emit();
+ for (auto const& sr : m_surfaces) {
+ sr->m_events.destroy.emit();
}
}
void CXWM::setActiveWindow(xcb_window_t window) {
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, screen->root, HYPRATOMS["_NET_ACTIVE_WINDOW"], HYPRATOMS["WINDOW"], 32, 1, &window);
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_screen->root, HYPRATOMS["_NET_ACTIVE_WINDOW"], HYPRATOMS["WINDOW"], 32, 1, &window);
}
void CXWM::createWMWindow() {
constexpr const char* wmName = "Hyprland :D";
- wmWindow = xcb_generate_id(connection);
- xcb_create_window(connection, XCB_COPY_FROM_PARENT, wmWindow, screen->root, 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, 0, nullptr);
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, wmWindow, HYPRATOMS["_NET_WM_NAME"], HYPRATOMS["UTF8_STRING"],
+ m_wmWindow = xcb_generate_id(m_connection);
+ xcb_create_window(m_connection, XCB_COPY_FROM_PARENT, m_wmWindow, m_screen->root, 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, m_screen->root_visual, 0, nullptr);
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_wmWindow, HYPRATOMS["_NET_WM_NAME"], HYPRATOMS["UTF8_STRING"],
8, // format
strlen(wmName), wmName);
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, screen->root, HYPRATOMS["_NET_SUPPORTING_WM_CHECK"], XCB_ATOM_WINDOW,
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_screen->root, HYPRATOMS["_NET_SUPPORTING_WM_CHECK"], XCB_ATOM_WINDOW,
32, // format
- 1, &wmWindow);
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, wmWindow, HYPRATOMS["_NET_SUPPORTING_WM_CHECK"], XCB_ATOM_WINDOW,
+ 1, &m_wmWindow);
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_wmWindow, HYPRATOMS["_NET_SUPPORTING_WM_CHECK"], XCB_ATOM_WINDOW,
32, // format
- 1, &wmWindow);
- xcb_set_selection_owner(connection, wmWindow, HYPRATOMS["WM_S0"], XCB_CURRENT_TIME);
- xcb_set_selection_owner(connection, wmWindow, HYPRATOMS["_NET_WM_CM_S0"], XCB_CURRENT_TIME);
+ 1, &m_wmWindow);
+ xcb_set_selection_owner(m_connection, m_wmWindow, HYPRATOMS["WM_S0"], XCB_CURRENT_TIME);
+ xcb_set_selection_owner(m_connection, m_wmWindow, HYPRATOMS["_NET_WM_CM_S0"], XCB_CURRENT_TIME);
}
void CXWM::activateSurface(SP<CXWaylandSurface> surf, bool activate) {
- if ((surf == focusedSurface && activate) || (surf && surf->overrideRedirect))
+ if ((surf == m_focusedSurface && activate) || (surf && surf->m_overrideRedirect))
return;
if (!surf || (!activate && g_pCompositor->m_lastWindow && !g_pCompositor->m_lastWindow->m_isX11)) {
setActiveWindow((uint32_t)XCB_WINDOW_NONE);
focusWindow(nullptr);
} else {
- setActiveWindow(surf ? surf->xID : (uint32_t)XCB_WINDOW_NONE);
+ setActiveWindow(surf ? surf->m_xID : (uint32_t)XCB_WINDOW_NONE);
focusWindow(surf);
}
- xcb_flush(connection);
+ xcb_flush(m_connection);
}
void CXWM::sendState(SP<CXWaylandSurface> surf) {
- Debug::log(TRACE, "[xwm] sendState for {} {} {} surface {}", surf->mapped ? "mapped" : "unmapped", surf->fullscreen ? "fullscreen" : "windowed",
- surf == focusedSurface ? "focused" : "unfocused", surf->state.title);
- if (surf->fullscreen && surf->mapped && surf == focusedSurface)
+ Debug::log(TRACE, "[xwm] sendState for {} {} {} surface {}", surf->m_mapped ? "mapped" : "unmapped", surf->m_fullscreen ? "fullscreen" : "windowed",
+ surf == m_focusedSurface ? "focused" : "unfocused", surf->m_state.title);
+ if (surf->m_fullscreen && surf->m_mapped && surf == m_focusedSurface)
surf->setWithdrawn(false); // resend normal state
- if (surf->withdrawn) {
- xcb_delete_property(connection, surf->xID, HYPRATOMS["_NET_WM_STATE"]);
+ if (surf->m_withdrawn) {
+ xcb_delete_property(m_connection, surf->m_xID, HYPRATOMS["_NET_WM_STATE"]);
return;
}
std::vector<uint32_t> props;
// reserve to avoid reallocations
props.reserve(6); // props below
- if (surf->modal)
+ if (surf->m_modal)
props.push_back(HYPRATOMS["_NET_WM_STATE_MODAL"]);
- if (surf->fullscreen)
+ if (surf->m_fullscreen)
props.push_back(HYPRATOMS["_NET_WM_STATE_FULLSCREEN"]);
- if (surf->maximized) {
+ if (surf->m_maximized) {
props.push_back(HYPRATOMS["NET_WM_STATE_MAXIMIZED_VERT"]);
props.push_back(HYPRATOMS["NET_WM_STATE_MAXIMIZED_HORZ"]);
}
- if (surf->minimized)
+ if (surf->m_minimized)
props.push_back(HYPRATOMS["_NET_WM_STATE_HIDDEN"]);
- if (surf == focusedSurface)
+ if (surf == m_focusedSurface)
props.push_back(HYPRATOMS["_NET_WM_STATE_FOCUSED"]);
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, surf->xID, HYPRATOMS["_NET_WM_STATE"], XCB_ATOM_ATOM, 32, props.size(), props.data());
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, surf->m_xID, HYPRATOMS["_NET_WM_STATE"], XCB_ATOM_ATOM, 32, props.size(), props.data());
}
void CXWM::onNewSurface(SP<CWLSurfaceResource> surf) {
- if (surf->client() != g_pXWayland->pServer->xwaylandClient)
+ if (surf->client() != g_pXWayland->m_server->m_xwaylandClient)
return;
Debug::log(LOG, "[xwm] New XWayland surface at {:x}", (uintptr_t)surf.get());
const auto WLID = surf->id();
- for (auto const& sr : surfaces) {
- if (sr->surface || sr->wlID != WLID)
+ for (auto const& sr : m_surfaces) {
+ if (sr->m_surface || sr->m_wlID != WLID)
continue;
associate(sr, surf);
@@ -1063,11 +1065,11 @@ void CXWM::onNewSurface(SP<CWLSurfaceResource> surf) {
void CXWM::onNewResource(SP<CXWaylandSurfaceResource> resource) {
Debug::log(LOG, "[xwm] New XWayland resource at {:x}", (uintptr_t)resource.get());
- std::erase_if(shellResources, [](const auto& e) { return e.expired(); });
- shellResources.emplace_back(resource);
+ std::erase_if(m_shellResources, [](const auto& e) { return e.expired(); });
+ m_shellResources.emplace_back(resource);
- for (auto const& surf : surfaces) {
- if (surf->resource || surf->wlSerial != resource->m_serial)
+ for (auto const& surf : m_surfaces) {
+ if (surf->m_resource || surf->m_wlSerial != resource->m_serial)
continue;
associate(surf, resource->m_surface.lock());
@@ -1083,8 +1085,8 @@ void CXWM::readWindowData(SP<CXWaylandSurface> surf) {
};
for (size_t i = 0; i < interestingProps.size(); i++) {
- xcb_get_property_cookie_t cookie = xcb_get_property(connection, 0, surf->xID, interestingProps[i], XCB_ATOM_ANY, 0, 2048);
- xcb_get_property_reply_t* reply = xcb_get_property_reply(connection, cookie, nullptr);
+ xcb_get_property_cookie_t cookie = xcb_get_property(m_connection, 0, surf->m_xID, interestingProps[i], XCB_ATOM_ANY, 0, 2048);
+ xcb_get_property_reply_t* reply = xcb_get_property_reply(m_connection, cookie, nullptr);
if (!reply) {
Debug::log(ERR, "[xwm] Failed to get window property");
continue;
@@ -1095,8 +1097,8 @@ void CXWM::readWindowData(SP<CXWaylandSurface> surf) {
}
SP<CXWaylandSurface> CXWM::windowForWayland(SP<CWLSurfaceResource> surf) {
- for (auto& s : surfaces) {
- if (s->surface == surf)
+ for (auto& s : m_surfaces) {
+ if (s->m_surface == surf)
return s;
}
@@ -1104,100 +1106,100 @@ SP<CXWaylandSurface> CXWM::windowForWayland(SP<CWLSurfaceResource> surf) {
}
void CXWM::associate(SP<CXWaylandSurface> surf, SP<CWLSurfaceResource> wlSurf) {
- if (surf->surface)
+ if (surf->m_surface)
return;
- auto existing = std::find_if(surfaces.begin(), surfaces.end(), [wlSurf](const auto& e) { return e->surface == wlSurf; });
+ auto existing = std::find_if(m_surfaces.begin(), m_surfaces.end(), [wlSurf](const auto& e) { return e->m_surface == wlSurf; });
- if (existing != surfaces.end()) {
+ if (existing != m_surfaces.end()) {
Debug::log(WARN, "[xwm] associate() called but surface is already associated to {:x}, ignoring...", (uintptr_t)surf.get());
return;
}
- surf->surface = wlSurf;
+ surf->m_surface = wlSurf;
surf->ensureListeners();
readWindowData(surf);
- surf->events.resourceChange.emit();
+ surf->m_events.resourceChange.emit();
}
void CXWM::dissociate(SP<CXWaylandSurface> surf) {
- if (!surf->surface)
+ if (!surf->m_surface)
return;
- if (surf->mapped)
+ if (surf->m_mapped)
surf->unmap();
- surf->surface.reset();
- surf->events.resourceChange.emit();
+ surf->m_surface.reset();
+ surf->m_events.resourceChange.emit();
Debug::log(LOG, "Dissociate for {:x}", (uintptr_t)surf.get());
}
void CXWM::updateClientList() {
std::vector<xcb_window_t> windows;
- windows.reserve(mappedSurfaces.size());
+ windows.reserve(m_mappedSurfaces.size());
- for (auto const& s : mappedSurfaces) {
+ for (auto const& s : m_mappedSurfaces) {
if (auto surf = s.lock(); surf)
- windows.push_back(surf->xID);
+ windows.push_back(surf->m_xID);
}
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, screen->root, HYPRATOMS["_NET_CLIENT_LIST"], XCB_ATOM_WINDOW, 32, windows.size(), windows.data());
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_screen->root, HYPRATOMS["_NET_CLIENT_LIST"], XCB_ATOM_WINDOW, 32, windows.size(), windows.data());
windows.clear();
- windows.reserve(mappedSurfacesStacking.size());
+ windows.reserve(m_mappedSurfacesStacking.size());
- for (auto const& s : mappedSurfacesStacking) {
+ for (auto const& s : m_mappedSurfacesStacking) {
if (auto surf = s.lock(); surf)
- windows.push_back(surf->xID);
+ windows.push_back(surf->m_xID);
}
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, screen->root, HYPRATOMS["_NET_CLIENT_LIST_STACKING"], XCB_ATOM_WINDOW, 32, windows.size(), windows.data());
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_screen->root, HYPRATOMS["_NET_CLIENT_LIST_STACKING"], XCB_ATOM_WINDOW, 32, windows.size(), windows.data());
}
bool CXWM::isWMWindow(xcb_window_t w) {
- return w == wmWindow || w == clipboard.window || w == dndSelection.window;
+ return w == m_wmWindow || w == m_clipboard.window || w == m_dndSelection.window;
}
void CXWM::updateOverrideRedirect(SP<CXWaylandSurface> surf, bool overrideRedirect) {
- if (!surf || surf->overrideRedirect == overrideRedirect)
+ if (!surf || surf->m_overrideRedirect == overrideRedirect)
return;
- surf->overrideRedirect = overrideRedirect;
+ surf->m_overrideRedirect = overrideRedirect;
}
void CXWM::initSelection() {
- clipboard.window = xcb_generate_id(connection);
- uint32_t mask[1] = {XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE};
- xcb_create_window(connection, XCB_COPY_FROM_PARENT, clipboard.window, screen->root, 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, XCB_CW_EVENT_MASK,
- mask);
- xcb_set_selection_owner(connection, clipboard.window, HYPRATOMS["CLIPBOARD_MANAGER"], XCB_TIME_CURRENT_TIME);
+ m_clipboard.window = xcb_generate_id(m_connection);
+ uint32_t mask[1] = {XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE};
+ xcb_create_window(m_connection, XCB_COPY_FROM_PARENT, m_clipboard.window, m_screen->root, 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, m_screen->root_visual,
+ XCB_CW_EVENT_MASK, mask);
+ xcb_set_selection_owner(m_connection, m_clipboard.window, HYPRATOMS["CLIPBOARD_MANAGER"], XCB_TIME_CURRENT_TIME);
uint32_t mask2 =
XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER | XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY | XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE;
- xcb_xfixes_select_selection_input(connection, clipboard.window, HYPRATOMS["CLIPBOARD"], mask2);
+ xcb_xfixes_select_selection_input(m_connection, m_clipboard.window, HYPRATOMS["CLIPBOARD"], mask2);
- clipboard.listeners.setSelection = g_pSeatManager->m_events.setSelection.registerListener([this](std::any d) { clipboard.onSelection(); });
- clipboard.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any d) { clipboard.onKeyboardFocus(); });
+ m_clipboard.listeners.setSelection = g_pSeatManager->m_events.setSelection.registerListener([this](std::any d) { m_clipboard.onSelection(); });
+ m_clipboard.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any d) { m_clipboard.onKeyboardFocus(); });
- primarySelection.window = xcb_generate_id(connection);
- xcb_create_window(connection, XCB_COPY_FROM_PARENT, primarySelection.window, screen->root, 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual,
+ m_primarySelection.window = xcb_generate_id(m_connection);
+ xcb_create_window(m_connection, XCB_COPY_FROM_PARENT, m_primarySelection.window, m_screen->root, 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, m_screen->root_visual,
XCB_CW_EVENT_MASK, mask);
- xcb_set_selection_owner(connection, primarySelection.window, HYPRATOMS["PRIMARY"], XCB_TIME_CURRENT_TIME);
+ xcb_set_selection_owner(m_connection, m_primarySelection.window, HYPRATOMS["PRIMARY"], XCB_TIME_CURRENT_TIME);
- xcb_xfixes_select_selection_input(connection, primarySelection.window, HYPRATOMS["PRIMARY"], mask2);
+ xcb_xfixes_select_selection_input(m_connection, m_primarySelection.window, HYPRATOMS["PRIMARY"], mask2);
- primarySelection.listeners.setSelection = g_pSeatManager->m_events.setPrimarySelection.registerListener([this](std::any d) { primarySelection.onSelection(); });
- primarySelection.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any d) { primarySelection.onKeyboardFocus(); });
+ m_primarySelection.listeners.setSelection = g_pSeatManager->m_events.setPrimarySelection.registerListener([this](std::any d) { m_primarySelection.onSelection(); });
+ m_primarySelection.listeners.keyboardFocusChange = g_pSeatManager->m_events.keyboardFocusChange.registerListener([this](std::any d) { m_primarySelection.onKeyboardFocus(); });
- dndSelection.window = xcb_generate_id(connection);
- xcb_create_window(connection, XCB_COPY_FROM_PARENT, dndSelection.window, screen->root, 0, 0, 8192, 8192, 0, XCB_WINDOW_CLASS_INPUT_ONLY, screen->root_visual, XCB_CW_EVENT_MASK,
- mask);
+ m_dndSelection.window = xcb_generate_id(m_connection);
+ xcb_create_window(m_connection, XCB_COPY_FROM_PARENT, m_dndSelection.window, m_screen->root, 0, 0, 8192, 8192, 0, XCB_WINDOW_CLASS_INPUT_ONLY, m_screen->root_visual,
+ XCB_CW_EVENT_MASK, mask);
uint32_t val1 = XDND_VERSION;
- xcb_change_property(connection, XCB_PROP_MODE_REPLACE, dndSelection.window, HYPRATOMS["XdndAware"], XCB_ATOM_ATOM, 32, 1, &val1);
+ xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_dndSelection.window, HYPRATOMS["XdndAware"], XCB_ATOM_ATOM, 32, 1, &val1);
}
void CXWM::setClipboardToWayland(SXSelection& sel) {
@@ -1209,11 +1211,11 @@ void CXWM::setClipboardToWayland(SXSelection& sel) {
sel.dataSource = source;
- Debug::log(LOG, "[xwm] X selection at {:x} takes {}", (uintptr_t)sel.dataSource.get(), (&sel == &clipboard) ? "clipboard" : "primary selection");
+ Debug::log(LOG, "[xwm] X selection at {:x} takes {}", (uintptr_t)sel.dataSource.get(), (&sel == &m_clipboard) ? "clipboard" : "primary selection");
- if (&sel == &clipboard)
+ if (&sel == &m_clipboard)
g_pSeatManager->setCurrentSelection(sel.dataSource);
- else if (&sel == &primarySelection)
+ else if (&sel == &m_primarySelection)
g_pSeatManager->setCurrentPrimarySelection(sel.dataSource);
}
@@ -1274,40 +1276,40 @@ void CXWM::getTransferData(SXSelection& sel) {
}
void CXWM::setCursor(unsigned char* pixData, uint32_t stride, const Vector2D& size, const Vector2D& hotspot) {
- if (!render_format_id) {
+ if (!m_renderFormatID) {
Debug::log(ERR, "[xwm] can't set cursor: no render format");
return;
}
- if (cursorXID)
- xcb_free_cursor(connection, cursorXID);
+ if (m_cursorXID)
+ xcb_free_cursor(m_connection, m_cursorXID);
constexpr int CURSOR_DEPTH = 32;
- xcb_pixmap_t pix = xcb_generate_id(connection);
- xcb_create_pixmap(connection, CURSOR_DEPTH, pix, screen->root, size.x, size.y);
+ xcb_pixmap_t pix = xcb_generate_id(m_connection);
+ xcb_create_pixmap(m_connection, CURSOR_DEPTH, pix, m_screen->root, size.x, size.y);
- xcb_render_picture_t pic = xcb_generate_id(connection);
- xcb_render_create_picture(connection, pic, pix, render_format_id, 0, 0);
+ xcb_render_picture_t pic = xcb_generate_id(m_connection);
+ xcb_render_create_picture(m_connection, pic, pix, m_renderFormatID, 0, 0);
- xcb_gcontext_t gc = xcb_generate_id(connection);
- xcb_create_gc(connection, gc, pix, 0, nullptr);
+ xcb_gcontext_t gc = xcb_generate_id(m_connection);
+ xcb_create_gc(m_connection, gc, pix, 0, nullptr);
- xcb_put_image(connection, XCB_IMAGE_FORMAT_Z_PIXMAP, pix, gc, size.x, size.y, 0, 0, 0, CURSOR_DEPTH, stride * size.y * sizeof(uint8_t), pixData);
- xcb_free_gc(connection, gc);
+ xcb_put_image(m_connection, XCB_IMAGE_FORMAT_Z_PIXMAP, pix, gc, size.x, size.y, 0, 0, 0, CURSOR_DEPTH, stride * size.y * sizeof(uint8_t), pixData);
+ xcb_free_gc(m_connection, gc);
- cursorXID = xcb_generate_id(connection);
- xcb_render_create_cursor(connection, cursorXID, pic, hotspot.x, hotspot.y);
- xcb_free_pixmap(connection, pix);
- xcb_render_free_picture(connection, pic);
+ m_cursorXID = xcb_generate_id(m_connection);
+ xcb_render_create_cursor(m_connection, m_cursorXID, pic, hotspot.x, hotspot.y);
+ xcb_free_pixmap(m_connection, pix);
+ xcb_render_free_picture(m_connection, pic);
- uint32_t values[] = {cursorXID};
- xcb_change_window_attributes(connection, screen->root, XCB_CW_CURSOR, values);
- xcb_flush(connection);
+ uint32_t values[] = {m_cursorXID};
+ xcb_change_window_attributes(m_connection, m_screen->root, XCB_CW_CURSOR, values);
+ xcb_flush(m_connection);
}
SP<CX11DataDevice> CXWM::getDataDevice() {
- return dndDataDevice;
+ return m_dndDataDevice;
}
SP<IDataOffer> CXWM::createX11DataOffer(SP<CWLSurfaceResource> surf, SP<IDataSource> source) {
@@ -1319,43 +1321,43 @@ SP<IDataOffer> CXWM::createX11DataOffer(SP<CWLSurfaceResource> surf, SP<IDataSou
}
// invalidate old
- g_pXWayland->pWM->dndDataOffers.clear();
+ g_pXWayland->m_wm->m_dndDataOffers.clear();
- auto offer = dndDataOffers.emplace_back(makeShared<CX11DataOffer>());
- offer->self = offer;
- offer->xwaylandSurface = XSURF;
- offer->source = source;
+ auto offer = m_dndDataOffers.emplace_back(makeShared<CX11DataOffer>());
+ offer->m_self = offer;
+ offer->m_xwaylandSurface = XSURF;
+ offer->m_source = source;
return offer;
}
void SXSelection::onSelection() {
- if ((this == &g_pXWayland->pWM->clipboard && g_pSeatManager->m_selection.currentSelection && g_pSeatManager->m_selection.currentSelection->type() == DATA_SOURCE_TYPE_X11) ||
- (this == &g_pXWayland->pWM->primarySelection && g_pSeatManager->m_selection.currentPrimarySelection &&
+ if ((this == &g_pXWayland->m_wm->m_clipboard && g_pSeatManager->m_selection.currentSelection && g_pSeatManager->m_selection.currentSelection->type() == DATA_SOURCE_TYPE_X11) ||
+ (this == &g_pXWayland->m_wm->m_primarySelection && g_pSeatManager->m_selection.currentPrimarySelection &&
g_pSeatManager->m_selection.currentPrimarySelection->type() == DATA_SOURCE_TYPE_X11))
return;
- if (this == &g_pXWayland->pWM->clipboard && g_pSeatManager->m_selection.currentSelection) {
- xcb_set_selection_owner(g_pXWayland->pWM->connection, g_pXWayland->pWM->clipboard.window, HYPRATOMS["CLIPBOARD"], XCB_TIME_CURRENT_TIME);
- xcb_flush(g_pXWayland->pWM->connection);
- g_pXWayland->pWM->clipboard.notifyOnFocus = true;
- } else if (this == &g_pXWayland->pWM->primarySelection && g_pSeatManager->m_selection.currentPrimarySelection) {
- xcb_set_selection_owner(g_pXWayland->pWM->connection, g_pXWayland->pWM->primarySelection.window, HYPRATOMS["PRIMARY"], XCB_TIME_CURRENT_TIME);
- xcb_flush(g_pXWayland->pWM->connection);
- g_pXWayland->pWM->primarySelection.notifyOnFocus = true;
+ if (this == &g_pXWayland->m_wm->m_clipboard && g_pSeatManager->m_selection.currentSelection) {
+ xcb_set_selection_owner(g_pXWayland->m_wm->m_connection, g_pXWayland->m_wm->m_clipboard.window, HYPRATOMS["CLIPBOARD"], XCB_TIME_CURRENT_TIME);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
+ g_pXWayland->m_wm->m_clipboard.notifyOnFocus = true;
+ } else if (this == &g_pXWayland->m_wm->m_primarySelection && g_pSeatManager->m_selection.currentPrimarySelection) {
+ xcb_set_selection_owner(g_pXWayland->m_wm->m_connection, g_pXWayland->m_wm->m_primarySelection.window, HYPRATOMS["PRIMARY"], XCB_TIME_CURRENT_TIME);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
+ g_pXWayland->m_wm->m_primarySelection.notifyOnFocus = true;
}
}
void SXSelection::onKeyboardFocus() {
- if (!g_pSeatManager->m_state.keyboardFocusResource || g_pSeatManager->m_state.keyboardFocusResource->client() != g_pXWayland->pServer->xwaylandClient)
+ if (!g_pSeatManager->m_state.keyboardFocusResource || g_pSeatManager->m_state.keyboardFocusResource->client() != g_pXWayland->m_server->m_xwaylandClient)
return;
- if (this == &g_pXWayland->pWM->clipboard && g_pXWayland->pWM->clipboard.notifyOnFocus) {
+ if (this == &g_pXWayland->m_wm->m_clipboard && g_pXWayland->m_wm->m_clipboard.notifyOnFocus) {
onSelection();
- g_pXWayland->pWM->clipboard.notifyOnFocus = false;
- } else if (this == &g_pXWayland->pWM->primarySelection && g_pXWayland->pWM->primarySelection.notifyOnFocus) {
+ g_pXWayland->m_wm->m_clipboard.notifyOnFocus = false;
+ } else if (this == &g_pXWayland->m_wm->m_primarySelection && g_pXWayland->m_wm->m_primarySelection.notifyOnFocus) {
onSelection();
- g_pXWayland->pWM->primarySelection.notifyOnFocus = false;
+ g_pXWayland->m_wm->m_primarySelection.notifyOnFocus = false;
}
}
@@ -1373,7 +1375,7 @@ int SXSelection::onRead(int fd, uint32_t mask) {
auto len = read(fd, transfer->data.data() + pre, INCR_CHUNK_SIZE - 1);
if (len < 0) {
Debug::log(ERR, "[xwm] readDataSource died");
- g_pXWayland->pWM->selectionSendNotify(&transfer->request, false);
+ g_pXWayland->m_wm->selectionSendNotify(&transfer->request, false);
transfers.erase(it);
return 0;
}
@@ -1382,10 +1384,10 @@ int SXSelection::onRead(int fd, uint32_t mask) {
if (len == 0) {
Debug::log(LOG, "[xwm] Received all the bytes, final length {}", transfer->data.size());
- xcb_change_property(g_pXWayland->pWM->connection, XCB_PROP_MODE_REPLACE, transfer->request.requestor, transfer->request.property, transfer->request.target, 8,
+ xcb_change_property(g_pXWayland->m_wm->m_connection, XCB_PROP_MODE_REPLACE, transfer->request.requestor, transfer->request.property, transfer->request.target, 8,
transfer->data.size(), transfer->data.data());
- xcb_flush(g_pXWayland->pWM->connection);
- g_pXWayland->pWM->selectionSendNotify(&transfer->request, true);
+ xcb_flush(g_pXWayland->m_wm->m_connection);
+ g_pXWayland->m_wm->selectionSendNotify(&transfer->request, true);
transfers.erase(it);
} else
Debug::log(LOG, "[xwm] Received {} bytes, waiting...", len);
@@ -1403,12 +1405,12 @@ static int readDataSource(int fd, uint32_t mask, void* data) {
bool SXSelection::sendData(xcb_selection_request_event_t* e, std::string mime) {
WP<IDataSource> selection;
- if (this == &g_pXWayland->pWM->clipboard)
+ if (this == &g_pXWayland->m_wm->m_clipboard)
selection = g_pSeatManager->m_selection.currentSelection;
- else if (this == &g_pXWayland->pWM->primarySelection)
+ else if (this == &g_pXWayland->m_wm->m_primarySelection)
selection = g_pSeatManager->m_selection.currentPrimarySelection;
- else if (!g_pXWayland->pWM->dndDataOffers.empty())
- selection = g_pXWayland->pWM->dndDataOffers.at(0)->getSource();
+ else if (!g_pXWayland->m_wm->m_dndDataOffers.empty())
+ selection = g_pXWayland->m_wm->m_dndDataOffers.at(0)->getSource();
if (!selection)
return false;
@@ -1491,16 +1493,17 @@ SXTransfer::~SXTransfer() {
if (eventSource)
wl_event_source_remove(eventSource);
if (incomingWindow)
- xcb_destroy_window(g_pXWayland->pWM->connection, incomingWindow);
+ xcb_destroy_window(g_pXWayland->m_wm->m_connection, incomingWindow);
if (propertyReply)
free(propertyReply);
}
bool SXTransfer::getIncomingSelectionProp(bool erase) {
- xcb_get_property_cookie_t cookie = xcb_get_property(g_pXWayland->pWM->connection, erase, incomingWindow, HYPRATOMS["_WL_SELECTION"], XCB_GET_PROPERTY_TYPE_ANY, 0, 0x1fffffff);
+ xcb_get_property_cookie_t cookie =
+ xcb_get_property(g_pXWayland->m_wm->m_connection, erase, incomingWindow, HYPRATOMS["_WL_SELECTION"], XCB_GET_PROPERTY_TYPE_ANY, 0, 0x1fffffff);
propertyStart = 0;
- propertyReply = xcb_get_property_reply(g_pXWayland->pWM->connection, cookie, nullptr);
+ propertyReply = xcb_get_property_reply(g_pXWayland->m_wm->m_connection, cookie, nullptr);
if (!propertyReply) {
Debug::log(ERR, "[SXTransfer] couldn't get a prop reply");
diff --git a/src/xwayland/XWM.hpp b/src/xwayland/XWM.hpp
index 25010b0b..d6383bf4 100644
--- a/src/xwayland/XWM.hpp
+++ b/src/xwayland/XWM.hpp
@@ -63,45 +63,45 @@ struct SXSelection {
class CXCBConnection {
public:
- CXCBConnection(int fd) : connection{xcb_connect_to_fd(fd, nullptr)} {
+ CXCBConnection(int fd) : m_connection{xcb_connect_to_fd(fd, nullptr)} {
;
}
~CXCBConnection() {
- if (connection)
- xcb_disconnect(connection);
+ if (m_connection)
+ xcb_disconnect(m_connection);
}
bool hasError() const {
- return xcb_connection_has_error(connection);
+ return xcb_connection_has_error(m_connection);
}
operator xcb_connection_t*() const {
- return connection;
+ return m_connection;
}
private:
- xcb_connection_t* connection = nullptr;
+ xcb_connection_t* m_connection = nullptr;
};
class CXCBErrorContext {
public:
explicit CXCBErrorContext(xcb_connection_t* connection) {
- if (xcb_errors_context_new(connection, &errors) != 0)
- errors = nullptr;
+ if (xcb_errors_context_new(connection, &m_errors) != 0)
+ m_errors = nullptr;
}
~CXCBErrorContext() {
- if (errors)
- xcb_errors_context_free(errors);
+ if (m_errors)
+ xcb_errors_context_free(m_errors);
}
bool isValid() const {
- return errors != nullptr;
+ return m_errors != nullptr;
}
private:
- xcb_errors_context_t* errors = nullptr;
+ xcb_errors_context_t* m_errors = nullptr;
};
class CXWM {
@@ -174,42 +174,42 @@ class CXWM {
SXSelection* getSelection(xcb_atom_t atom);
//
- CXCBConnection connection;
- xcb_errors_context_t* errors = nullptr;
- xcb_screen_t* screen = nullptr;
+ CXCBConnection m_connection;
+ xcb_errors_context_t* m_errors = nullptr;
+ xcb_screen_t* m_screen = nullptr;
- xcb_window_t wmWindow;
+ xcb_window_t m_wmWindow;
- wl_event_source* eventSource = nullptr;
+ wl_event_source* m_eventSource = nullptr;
- const xcb_query_extension_reply_t* xfixes = nullptr;
- const xcb_query_extension_reply_t* xres = nullptr;
- int xfixesMajor = 0;
+ const xcb_query_extension_reply_t* m_xfixes = nullptr;
+ const xcb_query_extension_reply_t* m_xres = nullptr;
+ int m_xfixesMajor = 0;
- xcb_visualid_t visual_id;
- xcb_colormap_t colormap;
- uint32_t cursorXID = 0;
+ xcb_visualid_t m_visualID;
+ xcb_colormap_t m_colormap;
+ uint32_t m_cursorXID = 0;
- xcb_render_pictformat_t render_format_id;
+ xcb_render_pictformat_t m_renderFormatID;
- std::vector<WP<CXWaylandSurfaceResource>> shellResources;
- std::vector<SP<CXWaylandSurface>> surfaces;
- std::vector<WP<CXWaylandSurface>> mappedSurfaces; // ordered by map time
- std::vector<WP<CXWaylandSurface>> mappedSurfacesStacking; // ordered by stacking
+ std::vector<WP<CXWaylandSurfaceResource>> m_shellResources;
+ std::vector<SP<CXWaylandSurface>> m_surfaces;
+ std::vector<WP<CXWaylandSurface>> m_mappedSurfaces; // ordered by map time
+ std::vector<WP<CXWaylandSurface>> m_mappedSurfacesStacking; // ordered by stacking
- WP<CXWaylandSurface> focusedSurface;
- uint64_t lastFocusSeq = 0;
+ WP<CXWaylandSurface> m_focusedSurface;
+ uint64_t m_lastFocusSeq = 0;
- SXSelection clipboard;
- SXSelection primarySelection;
- SXSelection dndSelection;
- SP<CX11DataDevice> dndDataDevice = makeShared<CX11DataDevice>();
- std::vector<SP<CX11DataOffer>> dndDataOffers;
+ SXSelection m_clipboard;
+ SXSelection m_primarySelection;
+ SXSelection m_dndSelection;
+ SP<CX11DataDevice> m_dndDataDevice = makeShared<CX11DataDevice>();
+ std::vector<SP<CX11DataOffer>> m_dndDataOffers;
struct {
CHyprSignalListener newWLSurface;
CHyprSignalListener newXShellSurface;
- } listeners;
+ } m_listeners;
friend class CXWaylandSurface;
friend class CXWayland;
diff --git a/src/xwayland/XWayland.cpp b/src/xwayland/XWayland.cpp
index 1f78231f..f7bdf1e6 100644
--- a/src/xwayland/XWayland.cpp
+++ b/src/xwayland/XWayland.cpp
@@ -26,9 +26,9 @@ CXWayland::CXWayland(const bool wantsEnabled) {
Debug::log(LOG, "Starting up the XWayland server");
- pServer = makeUnique<CXWaylandServer>();
+ m_server = makeUnique<CXWaylandServer>();
- if (!pServer->create()) {
+ if (!m_server->create()) {
Debug::log(ERR, "XWayland failed to start: it will not work.");
return;
}
@@ -41,12 +41,12 @@ CXWayland::CXWayland(const bool wantsEnabled) {
void CXWayland::setCursor(unsigned char* pixData, uint32_t stride, const Vector2D& size, const Vector2D& hotspot) {
#ifndef NO_XWAYLAND
- if (!pWM) {
+ if (!m_wm) {
Debug::log(ERR, "Couldn't set XCursor: no XWM yet");
return;
}
- pWM->setCursor(pixData, stride, size, hotspot);
+ m_wm->setCursor(pixData, stride, size, hotspot);
#endif
}
diff --git a/src/xwayland/XWayland.hpp b/src/xwayland/XWayland.hpp
index 9202f19e..7fd6e354 100644
--- a/src/xwayland/XWayland.hpp
+++ b/src/xwayland/XWayland.hpp
@@ -19,17 +19,13 @@ class CXWayland {
CXWayland(const bool wantsEnabled);
#ifndef NO_XWAYLAND
- UP<CXWaylandServer> pServer;
- UP<CXWM> pWM;
+ UP<CXWaylandServer> m_server;
+ UP<CXWM> m_wm;
#endif
bool enabled();
void setCursor(unsigned char* pixData, uint32_t stride, const Vector2D& size, const Vector2D& hotspot);
- struct {
- CSignal newSurface;
- } events;
-
private:
bool m_enabled = false;
};
generated by cgit v1.2.3 (git 2.25.1) at 2026-11-01 15:57:26 +0000