Hyprland/src/debug/HyprCtl.cpp

1392 lines
47 KiB
C++
Raw Normal View History

2022-03-20 16:51:14 +01:00
#include "HyprCtl.hpp"
2022-03-21 18:29:41 +01:00
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
2022-03-20 16:51:14 +01:00
#include <sys/stat.h>
2022-03-21 18:29:41 +01:00
#include <sys/types.h>
#include <sys/un.h>
2022-03-20 16:51:14 +01:00
#include <unistd.h>
2022-03-30 16:24:42 +02:00
#include <errno.h>
2022-03-20 16:51:14 +01:00
2023-01-31 01:03:23 +01:00
#include <sstream>
2022-03-20 16:51:14 +01:00
#include <string>
static void trimTrailingComma(std::string& str) {
if (!str.empty() && str.back() == ',')
str.pop_back();
}
static std::string getWorkspaceNameFromSpecialID(const int workspaceID) {
if (workspaceID == 0)
return "";
const auto* workspace = g_pCompositor->getWorkspaceByID(workspaceID);
if (!workspace)
return "";
return workspace->m_szName;
}
std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
2022-03-20 16:51:14 +01:00
std::string result = "";
if (format == HyprCtl::FORMAT_JSON) {
result += "[";
2022-09-25 20:07:48 +02:00
for (auto& m : g_pCompositor->m_vMonitors) {
2023-03-16 01:18:39 +01:00
if (!m->output)
continue;
result += std::format(
2023-09-06 12:51:36 +02:00
R"#({{
"id": {},
"name": "{}",
"description": "{}",
"make": "{}",
"model": "{}",
"serial": "{}",
"width": {},
"height": {},
"refreshRate": {:.5f},
"x": {},
"y": {},
"activeWorkspace": {{
"id": {},
"name": "{}"
}},
"specialWorkspace": {{
"id": {},
"name": "{}"
}},
"reserved": [{}, {}, {}, {}],
"scale": {:.2f},
"transform": {},
"focused": {},
"dpmsStatus": {},
"vrr": {},
"activelyTearing": {}
2023-09-06 12:51:36 +02:00
}},)#",
m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->output->description ? m->output->description : ""), (m->output->make ? m->output->make : ""),
(m->output->model ? m->output->model : ""), (m->output->serial ? m->output->serial : ""), (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate,
(int)m->vecPosition.x, (int)m->vecPosition.y, m->activeWorkspace, escapeJSONStrings(g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName),
m->specialWorkspaceID, escapeJSONStrings(getWorkspaceNameFromSpecialID(m->specialWorkspaceID)), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
(int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "true" : "false"),
(m->dpmsStatus ? "true" : "false"), (m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED ? "true" : "false"),
m->tearingState.activelyTearing ? "true" : "false");
}
trimTrailingComma(result);
result += "]";
} else {
for (auto& m : g_pCompositor->m_vMonitors) {
2023-03-16 01:18:39 +01:00
if (!m->output)
continue;
result +=
std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\tspecial "
"workspace: {} ({})\n\treserved: {} "
"{} {} {}\n\tscale: {:.2f}\n\ttransform: "
"{}\n\tfocused: {}\n\tdpmsStatus: {}\n\tvrr: {}\n\tactivelyTearing: {}\n\n",
m->szName, m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y,
(m->output->description ? m->output->description : ""), (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""),
(m->output->serial ? m->output->serial : ""), m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName, m->specialWorkspaceID,
getWorkspaceNameFromSpecialID(m->specialWorkspaceID), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x,
(int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus,
(int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED), m->tearingState.activelyTearing);
}
2022-03-20 16:51:14 +01:00
}
return result;
}
static std::string getGroupedData(CWindow* w, HyprCtl::eHyprCtlOutputFormat format) {
const bool isJson = format == HyprCtl::FORMAT_JSON;
2023-02-20 10:28:42 +01:00
if (!w->m_sGroupData.pNextWindow)
return isJson ? "" : "0";
2023-02-20 10:28:42 +01:00
std::vector<CWindow*> groupMembers;
CWindow* curr = w;
do {
groupMembers.push_back(curr);
curr = curr->m_sGroupData.pNextWindow;
} while (curr != w);
const auto comma = isJson ? ", " : ",";
std::ostringstream result;
bool first = true;
for (auto& gw : groupMembers) {
if (first)
first = false;
else
result << comma;
if (isJson)
result << std::format("\"0x{:x}\"", (uintptr_t)gw);
else
result << std::format("{:x}", (uintptr_t)gw);
}
return result.str();
}
static std::string getWindowData(CWindow* w, HyprCtl::eHyprCtlOutputFormat format) {
if (format == HyprCtl::FORMAT_JSON) {
return std::format(
2023-09-06 12:51:36 +02:00
R"#({{
"address": "0x{:x}",
"mapped": {},
"hidden": {},
"at": [{}, {}],
"size": [{}, {}],
"workspace": {{
"id": {},
"name": "{}"
}},
"floating": {},
"monitor": {},
"class": "{}",
"title": "{}",
"initialClass": "{}",
"initialTitle": "{}",
"pid": {},
"xwayland": {},
"pinned": {},
"fullscreen": {},
"fullscreenMode": {},
"fakeFullscreen": {},
"grouped": [{}],
"swallowing": "0x{:x}"
}},)#",
(uintptr_t)w, (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
(int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
escapeJSONStrings(w->m_iWorkspaceID == -1 ? "" :
g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName :
2023-09-06 12:51:36 +02:00
std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))),
2023-09-19 01:41:56 +02:00
((int)w->m_bIsFloating == 1 ? "true" : "false"), (int64_t)w->m_iMonitorID, escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)),
2023-09-06 12:51:36 +02:00
escapeJSONStrings(g_pXWaylandManager->getTitle(w)), escapeJSONStrings(w->m_szInitialClass), escapeJSONStrings(w->m_szInitialTitle), w->getPID(),
((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"), (w->m_bIsFullscreen ? "true" : "false"),
2023-09-06 12:51:36 +02:00
(w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? (int)g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
w->m_bFakeFullscreenState ? "true" : "false", getGroupedData(w, format), (uintptr_t)w->m_pSwallowed);
} else {
return std::format(
2023-09-06 12:51:36 +02:00
"Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
"{}\n\tinitialClass: {}\n\tinitialTitle: {}\n\tpid: "
"{}\n\txwayland: {}\n\tpinned: "
"{}\n\tfullscreen: {}\n\tfullscreenmode: {}\n\tfakefullscreen: {}\n\tgrouped: {}\n\tswallowing: {:x}\n\n",
(uintptr_t)w, w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
2023-09-06 12:51:36 +02:00
(int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
(w->m_iWorkspaceID == -1 ? "" :
g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName :
std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))),
(int)w->m_bIsFloating, (int64_t)w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w), g_pXWaylandManager->getTitle(w), w->m_szInitialClass, w->m_szInitialTitle,
w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen,
(w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
(int)w->m_bFakeFullscreenState, getGroupedData(w, format), (uintptr_t)w->m_pSwallowed);
}
}
std::string clientsRequest(HyprCtl::eHyprCtlOutputFormat format) {
std::string result = "";
if (format == HyprCtl::FORMAT_JSON) {
result += "[";
for (auto& w : g_pCompositor->m_vWindows) {
result += getWindowData(w.get(), format);
}
trimTrailingComma(result);
result += "]";
} else {
for (auto& w : g_pCompositor->m_vWindows) {
result += getWindowData(w.get(), format);
2022-06-27 13:17:11 +02:00
}
2022-03-20 16:51:14 +01:00
}
return result;
}
static std::string getWorkspaceData(CWorkspace* w, HyprCtl::eHyprCtlOutputFormat format) {
const auto PLASTW = w->getLastFocusedWindow();
const auto PMONITOR = g_pCompositor->getMonitorFromID(w->m_iMonitorID);
if (format == HyprCtl::FORMAT_JSON) {
return std::format(R"#({{
2023-09-06 12:51:36 +02:00
"id": {},
"name": "{}",
"monitor": "{}",
"windows": {},
"hasfullscreen": {},
"lastwindow": "0x{:x}",
"lastwindowtitle": "{}"
}})#",
w->m_iID, escapeJSONStrings(w->m_szName), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"), g_pCompositor->getWindowsOnWorkspace(w->m_iID),
((int)w->m_bHasFullscreenWindow == 1 ? "true" : "false"), (uintptr_t)PLASTW, PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "");
} else {
return std::format("workspace ID {} ({}) on monitor {}:\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\n", w->m_iID, w->m_szName,
PMONITOR ? PMONITOR->szName : "?", g_pCompositor->getWindowsOnWorkspace(w->m_iID), (int)w->m_bHasFullscreenWindow, (uintptr_t)PLASTW,
PLASTW ? PLASTW->m_szTitle : "");
}
}
std::string activeWorkspaceRequest(HyprCtl::eHyprCtlOutputFormat format) {
if (!g_pCompositor->m_pLastMonitor)
return "unsafe state";
std::string result = "";
auto w = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
if (!w)
return "internal error";
return getWorkspaceData(w, format);
}
std::string workspacesRequest(HyprCtl::eHyprCtlOutputFormat format) {
std::string result = "";
if (format == HyprCtl::FORMAT_JSON) {
result += "[";
for (auto& w : g_pCompositor->m_vWorkspaces) {
result += getWorkspaceData(w.get(), format);
result += ",";
}
trimTrailingComma(result);
result += "]";
} else {
for (auto& w : g_pCompositor->m_vWorkspaces) {
result += getWorkspaceData(w.get(), format);
}
2022-03-20 16:51:14 +01:00
}
2022-03-20 16:51:14 +01:00
return result;
}
std::string activeWindowRequest(HyprCtl::eHyprCtlOutputFormat format) {
2022-04-02 18:57:09 +02:00
const auto PWINDOW = g_pCompositor->m_pLastWindow;
2022-03-22 16:54:45 +01:00
if (!g_pCompositor->windowValidMapped(PWINDOW))
return format == HyprCtl::FORMAT_JSON ? "{}" : "Invalid";
auto result = getWindowData(PWINDOW, format);
if (format == HyprCtl::FORMAT_JSON)
result.pop_back();
return result;
2022-03-22 16:54:45 +01:00
}
std::string layersRequest(HyprCtl::eHyprCtlOutputFormat format) {
2022-03-22 16:54:45 +01:00
std::string result = "";
if (format == HyprCtl::FORMAT_JSON) {
result += "{\n";
for (auto& mon : g_pCompositor->m_vMonitors) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#("{}": {{
"levels": {{
)#",
escapeJSONStrings(mon->szName));
int layerLevel = 0;
for (auto& level : mon->m_aLayerSurfaceLayers) {
result += std::format(
R"#(
2023-09-06 12:51:36 +02:00
"{}": [
)#",
layerLevel);
for (auto& layer : level) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"x": {},
"y": {},
"w": {},
"h": {},
"namespace": "{}"
}},)#",
(uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, escapeJSONStrings(layer->szNamespace));
}
trimTrailingComma(result);
if (level.size() > 0)
result += "\n ";
result += "],";
layerLevel++;
2022-03-22 16:54:45 +01:00
}
trimTrailingComma(result);
result += "\n }\n},";
}
trimTrailingComma(result);
result += "\n}\n";
2022-09-25 20:07:48 +02:00
} else {
for (auto& mon : g_pCompositor->m_vMonitors) {
result += std::format("Monitor {}:\n", mon->szName);
2023-01-09 21:26:07 +01:00
int layerLevel = 0;
static const std::array<std::string, 4> levelNames = {"background", "bottom", "top", "overlay"};
for (auto& level : mon->m_aLayerSurfaceLayers) {
result += std::format("\tLayer level {} ({}):\n", layerLevel, levelNames[layerLevel]);
for (auto& layer : level) {
result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}\n", (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width,
layer->geometry.height, layer->szNamespace);
}
layerLevel++;
}
result += "\n\n";
2022-03-22 16:54:45 +01:00
}
}
return result;
}
std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
2022-06-02 13:59:33 +02:00
std::string result = "";
if (format == HyprCtl::FORMAT_JSON) {
result += "{\n";
result += "\"mice\": [\n";
for (auto& m : g_pInputManager->m_lMice) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"name": "{}",
"defaultSpeed": {:.5f}
}},)#",
(uintptr_t)&m, escapeJSONStrings(m.name),
wlr_input_device_is_libinput(m.mouse) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(m.mouse)) : 0.f);
}
2022-06-02 13:59:33 +02:00
trimTrailingComma(result);
result += "\n],\n";
result += "\"keyboards\": [\n";
for (auto& k : g_pInputManager->m_lKeyboards) {
2022-08-16 16:10:20 +02:00
const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"name": "{}",
"rules": "{}",
"model": "{}",
"layout": "{}",
"variant": "{}",
"options": "{}",
"active_keymap": "{}",
"main": {}
}},)#",
(uintptr_t)&k, escapeJSONStrings(k.name), escapeJSONStrings(k.currentRules.rules), escapeJSONStrings(k.currentRules.model),
escapeJSONStrings(k.currentRules.layout), escapeJSONStrings(k.currentRules.variant), escapeJSONStrings(k.currentRules.options), escapeJSONStrings(KM),
(k.active ? "true" : "false"));
}
2022-06-02 13:59:33 +02:00
trimTrailingComma(result);
result += "\n],\n";
2022-06-02 13:59:33 +02:00
result += "\"tablets\": [\n";
2022-06-02 13:59:33 +02:00
for (auto& d : g_pInputManager->m_lTabletPads) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"type": "tabletPad",
2023-09-06 12:51:36 +02:00
"belongsTo": {{
"address": "0x{:x}",
"name": "{}"
}}
}},)#",
(uintptr_t)&d, (uintptr_t)d.pTabletParent, escapeJSONStrings(d.pTabletParent ? d.pTabletParent->name : ""));
}
2022-06-09 19:25:26 +02:00
for (auto& d : g_pInputManager->m_lTablets) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"name": "{}"
}},)#",
(uintptr_t)&d, escapeJSONStrings(d.name));
}
2022-06-09 19:25:26 +02:00
for (auto& d : g_pInputManager->m_lTabletTools) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"type": "tabletTool",
2023-09-06 12:51:36 +02:00
"belongsTo": "0x{:x}"
}},)#",
(uintptr_t)&d, d.wlrTabletTool ? (uintptr_t)d.wlrTabletTool->data : 0);
}
trimTrailingComma(result);
result += "\n],\n";
result += "\"touch\": [\n";
for (auto& d : g_pInputManager->m_lTouchDevices) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"name": "{}"
}},)#",
(uintptr_t)&d, d.name);
}
trimTrailingComma(result);
2022-10-04 21:07:21 +02:00
result += "\n],\n";
result += "\"switches\": [\n";
for (auto& d : g_pInputManager->m_lSwitches) {
result += std::format(
2023-09-06 12:51:36 +02:00
R"#( {{
"address": "0x{:x}",
"name": "{}"
}},)#",
(uintptr_t)&d, d.pWlrDevice ? d.pWlrDevice->name : "");
2022-10-04 21:07:21 +02:00
}
trimTrailingComma(result);
result += "\n]\n";
2022-06-09 19:25:26 +02:00
result += "}\n";
} else {
result += "mice:\n";
for (auto& m : g_pInputManager->m_lMice) {
result += std::format(
"\tMouse at {:x}:\n\t\t{}\n\t\t\tdefault speed: {:.5f}\n", (uintptr_t)&m, m.name,
(wlr_input_device_is_libinput(m.mouse) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(m.mouse)) : 0.f));
}
result += "\n\nKeyboards:\n";
for (auto& k : g_pInputManager->m_lKeyboards) {
2022-08-16 16:10:20 +02:00
const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
result += std::format("\tKeyboard at {:x}:\n\t\t{}\n\t\t\trules: r \"{}\", m \"{}\", l \"{}\", v \"{}\", o \"{}\"\n\t\t\tactive keymap: {}\n\t\t\tmain: {}\n",
(uintptr_t)&k, k.name, k.currentRules.rules, k.currentRules.model, k.currentRules.layout, k.currentRules.variant, k.currentRules.options, KM,
(k.active ? "yes" : "no"));
}
result += "\n\nTablets:\n";
for (auto& d : g_pInputManager->m_lTabletPads) {
result += std::format("\tTablet Pad at {:x} (belongs to {:x} -> {})\n", (uintptr_t)&d, (uintptr_t)d.pTabletParent, d.pTabletParent ? d.pTabletParent->name : "");
}
for (auto& d : g_pInputManager->m_lTablets) {
result += std::format("\tTablet at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.name);
}
for (auto& d : g_pInputManager->m_lTabletTools) {
result += std::format("\tTablet Tool at {:x} (belongs to {:x})\n", (uintptr_t)&d, d.wlrTabletTool ? (uintptr_t)d.wlrTabletTool->data : 0);
}
result += "\n\nTouch:\n";
for (auto& d : g_pInputManager->m_lTouchDevices) {
result += std::format("\tTouch Device at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.name);
}
2022-10-04 21:07:21 +02:00
result += "\n\nSwitches:\n";
for (auto& d : g_pInputManager->m_lSwitches) {
result += std::format("\tSwitch Device at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.pWlrDevice ? d.pWlrDevice->name : "");
2022-10-04 21:07:21 +02:00
}
2022-06-09 19:25:26 +02:00
}
2022-06-02 13:59:33 +02:00
return result;
}
2023-01-25 16:16:28 +01:00
std::string animationsRequest(HyprCtl::eHyprCtlOutputFormat format) {
std::string ret = "";
if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
ret += "animations:\n";
for (auto& ac : g_pConfigManager->getAnimationConfig()) {
ret += std::format("\n\tname: {}\n\t\toverriden: {}\n\t\tbezier: {}\n\t\tenabled: {}\n\t\tspeed: {:.2f}\n\t\tstyle: {}\n", ac.first, (int)ac.second.overridden,
ac.second.internalBezier, ac.second.internalEnabled, ac.second.internalSpeed, ac.second.internalStyle);
2023-01-25 16:16:28 +01:00
}
ret += "beziers:\n";
for (auto& bz : g_pAnimationManager->getAllBeziers()) {
ret += std::format("\n\tname: {}\n", bz.first);
2023-01-25 16:16:28 +01:00
}
} else {
// json
ret += "[[";
for (auto& ac : g_pConfigManager->getAnimationConfig()) {
ret += std::format(R"#(
2023-09-06 12:51:36 +02:00
{{
"name": "{}",
"overridden": {},
"bezier": "{}",
"enabled": {},
"speed": {:.2f},
"style": "{}"
}},)#",
ac.first, ac.second.overridden ? "true" : "false", ac.second.internalBezier, ac.second.internalEnabled ? "true" : "false", ac.second.internalSpeed,
ac.second.internalStyle);
2023-01-25 16:16:28 +01:00
}
ret[ret.length() - 1] = ']';
ret += ",\n[";
for (auto& bz : g_pAnimationManager->getAllBeziers()) {
ret += std::format(R"#(
2023-09-06 12:51:36 +02:00
{{
"name": "{}"
}},)#",
bz.first);
2023-01-25 16:16:28 +01:00
}
trimTrailingComma(ret);
2023-01-25 16:16:28 +01:00
2023-02-11 21:54:32 +01:00
ret += "]]";
2023-01-25 16:16:28 +01:00
}
return ret;
}
std::string globalShortcutsRequest(HyprCtl::eHyprCtlOutputFormat format) {
std::string ret = "";
const auto SHORTCUTS = g_pProtocolManager->m_pGlobalShortcutsProtocolManager->getAllShortcuts();
if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
for (auto& sh : SHORTCUTS)
ret += std::format("{}:{} -> {}\n", sh.appid, sh.id, sh.description);
} else {
ret += "[";
for (auto& sh : SHORTCUTS) {
ret += std::format(R"#(
2023-09-06 12:51:36 +02:00
{{
"name": "{}",
"description": "{}"
}},)#",
escapeJSONStrings(sh.appid + ":" + sh.id), escapeJSONStrings(sh.description));
}
trimTrailingComma(ret);
ret += "]\n";
}
return ret;
}
2023-01-06 14:32:25 +01:00
std::string bindsRequest(HyprCtl::eHyprCtlOutputFormat format) {
std::string ret = "";
if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
for (auto& kb : g_pKeybindManager->m_lKeybinds) {
ret += "bind";
if (kb.locked)
ret += "l";
if (kb.mouse)
ret += "m";
if (kb.release)
ret += "r";
if (kb.repeat)
ret += "e";
if (kb.nonConsuming)
ret += "n";
2023-01-06 14:32:25 +01:00
ret += std::format("\n\tmodmask: {}\n\tsubmap: {}\n\tkey: {}\n\tkeycode: {}\n\tdispatcher: {}\n\targ: {}\n\n", kb.modmask, kb.submap, kb.key, kb.keycode, kb.handler,
kb.arg);
2023-01-06 14:32:25 +01:00
}
} else {
// json
ret += "[";
for (auto& kb : g_pKeybindManager->m_lKeybinds) {
ret += std::format(
2023-01-06 14:32:25 +01:00
R"#(
2023-09-06 12:51:36 +02:00
{{
"locked": {},
"mouse": {},
"release": {},
"repeat": {},
"non_consuming": {},
"modmask": {},
"submap": "{}",
"key": "{}",
"keycode": {},
"dispatcher": "{}",
"arg": "{}"
}},)#",
kb.locked ? "true" : "false", kb.mouse ? "true" : "false", kb.release ? "true" : "false", kb.repeat ? "true" : "false", kb.nonConsuming ? "true" : "false",
kb.modmask, escapeJSONStrings(kb.submap), escapeJSONStrings(kb.key), kb.keycode, escapeJSONStrings(kb.handler), escapeJSONStrings(kb.arg));
2023-01-06 14:32:25 +01:00
}
trimTrailingComma(ret);
2023-01-06 14:32:25 +01:00
ret += "]";
}
return ret;
}
2022-08-11 21:28:37 +02:00
std::string versionRequest(HyprCtl::eHyprCtlOutputFormat format) {
auto commitMsg = removeBeginEndSpacesTabs(GIT_COMMIT_MESSAGE);
std::replace(commitMsg.begin(), commitMsg.end(), '#', ' ');
2022-08-11 21:28:37 +02:00
if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
std::string result = "Hyprland, built from branch " + std::string(GIT_BRANCH) + " at commit " + GIT_COMMIT_HASH + " " + GIT_DIRTY + " (" + commitMsg +
").\nTag: " + GIT_TAG + "\n\nflags: (if any)\n";
2022-04-22 18:14:25 +02:00
#ifdef LEGACY_RENDERER
2022-08-11 21:28:37 +02:00
result += "legacyrenderer\n";
2022-04-22 18:14:25 +02:00
#endif
#ifndef NDEBUG
2022-08-11 21:28:37 +02:00
result += "debug\n";
2022-04-22 18:14:25 +02:00
#endif
#ifdef HYPRLAND_DEBUG
result += "debug\n";
#endif
2022-04-22 18:14:25 +02:00
#ifdef NO_XWAYLAND
2022-08-11 21:28:37 +02:00
result += "no xwayland\n";
2022-04-22 18:14:25 +02:00
#endif
2022-08-11 21:28:37 +02:00
return result;
} else {
std::string result = std::format(
2023-09-06 12:51:36 +02:00
R"#({{
"branch": "{}",
"commit": "{}",
"dirty": {},
"commit_message": "{}",
"tag": "{}",
"flags": [)#",
GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), escapeJSONStrings(commitMsg), GIT_TAG);
2022-08-11 21:28:37 +02:00
#ifdef LEGACY_RENDERER
result += "\"legacyrenderer\",";
#endif
#ifndef NDEBUG
result += "\"debug\",";
#endif
#ifdef HYPRLAND_DEBUG
result += "\"debug\",";
2022-08-11 21:28:37 +02:00
#endif
#ifdef NO_XWAYLAND
result += "\"no xwayland\",";
#endif
trimTrailingComma(result);
2022-08-11 21:28:37 +02:00
result += "]\n}";
return result;
}
return ""; // make the compiler happy
2022-04-22 18:14:25 +02:00
}
2022-04-21 16:11:29 +02:00
std::string dispatchRequest(std::string in) {
// get rid of the dispatch keyword
in = in.substr(in.find_first_of(' ') + 1);
const auto DISPATCHSTR = in.substr(0, in.find_first_of(' '));
2023-07-21 17:20:23 +02:00
auto DISPATCHARG = std::string();
if ((int)in.find_first_of(' ') != -1)
DISPATCHARG = in.substr(in.find_first_of(' ') + 1);
2022-04-21 16:11:29 +02:00
const auto DISPATCHER = g_pKeybindManager->m_mDispatchers.find(DISPATCHSTR);
if (DISPATCHER == g_pKeybindManager->m_mDispatchers.end())
return "Invalid dispatcher";
DISPATCHER->second(DISPATCHARG);
Debug::log(LOG, "Hyprctl: dispatcher {} : {}", DISPATCHSTR, DISPATCHARG);
2022-04-21 21:48:37 +02:00
2022-04-21 16:11:29 +02:00
return "ok";
}
2022-04-21 16:56:27 +02:00
std::string dispatchKeyword(std::string in) {
// get rid of the keyword keyword
in = in.substr(in.find_first_of(' ') + 1);
const auto COMMAND = in.substr(0, in.find_first_of(' '));
2022-04-21 16:56:27 +02:00
const auto VALUE = in.substr(in.find_first_of(' ') + 1);
2022-04-21 16:56:27 +02:00
std::string retval = g_pConfigManager->parseKeyword(COMMAND, VALUE, true);
if (COMMAND == "monitor")
g_pConfigManager->m_bWantsMonitorReload = true; // for monitor keywords
2022-08-20 18:57:30 +02:00
if (COMMAND.contains("input") || COMMAND.contains("device:")) {
g_pInputManager->setKeyboardLayout(); // update kb layout
g_pInputManager->setPointerConfigs(); // update mouse cfgs
g_pInputManager->setTouchDeviceConfigs(); // update touch device cfgs
2022-12-21 16:11:39 +01:00
g_pInputManager->setTabletConfigs(); // update tablets
2022-08-20 18:57:30 +02:00
}
2022-07-16 22:44:29 +02:00
if (COMMAND.contains("general:layout"))
g_pLayoutManager->switchToLayout(g_pConfigManager->getString("general:layout")); // update layout
if (COMMAND.contains("decoration:screen_shader"))
g_pHyprOpenGL->m_bReloadScreenShader = true;
2022-07-16 22:44:29 +02:00
if (COMMAND.contains("blur")) {
for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) {
rd.blurFBDirty = true;
}
}
2023-01-12 12:14:57 +01:00
// decorations will probably need a repaint
if (COMMAND.contains("decoration:") || COMMAND.contains("border") || COMMAND == "workspace" || COMMAND.contains("cursor_zoom_factor")) {
for (auto& m : g_pCompositor->m_vMonitors) {
2023-01-12 12:14:57 +01:00
g_pHyprRenderer->damageMonitor(m.get());
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
}
2023-01-12 12:14:57 +01:00
}
Debug::log(LOG, "Hyprctl: keyword {} : {}", COMMAND, VALUE);
2022-04-21 21:48:37 +02:00
2022-09-25 20:07:48 +02:00
if (retval == "")
2022-04-21 16:56:27 +02:00
return "ok";
return retval;
}
std::string reloadRequest(const std::string& request) {
2022-09-25 20:07:48 +02:00
2022-08-14 23:26:18 +02:00
const auto REQMODE = request.substr(request.find_last_of(' ') + 1);
2022-05-08 15:28:45 +02:00
g_pConfigManager->m_bForceReload = true;
2022-08-14 23:26:18 +02:00
if (REQMODE == "config-only") {
g_pConfigManager->m_bNoMonitorReload = true;
}
2022-09-13 15:36:49 +02:00
g_pConfigManager->tick();
2022-05-08 15:28:45 +02:00
return "ok";
}
2022-06-27 13:42:20 +02:00
std::string killRequest() {
g_pInputManager->setClickMode(CLICKMODE_KILL);
return "ok";
}
2022-07-10 15:41:26 +02:00
std::string splashRequest() {
return g_pCompositor->m_szCurrentSplash;
}
2022-10-26 14:19:37 +02:00
std::string cursorPosRequest(HyprCtl::eHyprCtlOutputFormat format) {
const auto CURSORPOS = g_pInputManager->getMouseCoordsInternal().floor();
if (format == HyprCtl::FORMAT_NORMAL) {
return std::format("{}, {}", (int)CURSORPOS.x, (int)CURSORPOS.y);
2022-10-26 14:19:37 +02:00
} else {
return std::format(R"#(
2023-09-06 12:51:36 +02:00
{{
"x": {},
"y": {}
}}
)#",
(int)CURSORPOS.x, (int)CURSORPOS.y);
2022-10-26 14:19:37 +02:00
}
return "error";
}
2022-04-29 19:44:09 +02:00
std::string getReply(std::string);
std::string dispatchBatch(std::string request) {
// split by ;
request = request.substr(9);
2022-04-29 19:44:09 +02:00
std::string curitem = "";
std::string reply = "";
2022-04-29 19:44:09 +02:00
auto nextItem = [&]() {
2022-04-29 19:44:09 +02:00
auto idx = request.find_first_of(';');
if (idx != std::string::npos) {
curitem = request.substr(0, idx);
request = request.substr(idx + 1);
} else {
curitem = request;
request = "";
}
curitem = removeBeginEndSpacesTabs(curitem);
};
nextItem();
while (curitem != "") {
reply += getReply(curitem);
nextItem();
}
return reply;
}
2022-08-10 21:22:11 +02:00
std::string dispatchSetCursor(std::string request) {
CVarList vars(request, 0, ' ');
2023-04-21 00:59:31 +02:00
const auto SIZESTR = vars[vars.size() - 1];
std::string theme = "";
2023-04-21 00:59:31 +02:00
for (size_t i = 1; i < vars.size() - 1; ++i)
theme += vars[i] + " ";
if (!theme.empty())
theme.pop_back();
2023-04-21 00:59:31 +02:00
int size = 0;
try {
size = std::stoi(SIZESTR);
} catch (...) { return "size not int"; }
2022-08-10 21:22:11 +02:00
2023-04-21 00:59:31 +02:00
if (size <= 0)
return "size not positive";
2022-08-10 21:22:11 +02:00
wlr_xcursor_manager_destroy(g_pCompositor->m_sWLRXCursorMgr);
2023-04-21 00:59:31 +02:00
g_pCompositor->m_sWLRXCursorMgr = wlr_xcursor_manager_create(theme.c_str(), size);
2022-08-10 21:22:11 +02:00
2023-04-21 00:59:31 +02:00
setenv("XCURSOR_SIZE", SIZESTR.c_str(), true);
setenv("XCURSOR_THEME", theme.c_str(), true);
2022-08-10 21:22:11 +02:00
for (auto& m : g_pCompositor->m_vMonitors) {
wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, m->scale);
}
return "ok";
}
std::string switchXKBLayoutRequest(const std::string& request) {
CVarList vars(request, 0, ' ');
2022-12-03 16:56:07 +01:00
const auto KB = vars[1];
2022-12-03 16:56:07 +01:00
const auto CMD = vars[2];
// get kb
const auto PKEYBOARD = std::find_if(g_pInputManager->m_lKeyboards.begin(), g_pInputManager->m_lKeyboards.end(),
[&](const SKeyboard& other) { return other.name == g_pInputManager->deviceNameToInternalString(KB); });
2022-12-03 16:56:07 +01:00
if (PKEYBOARD == g_pInputManager->m_lKeyboards.end())
return "device not found";
const auto PWLRKEYBOARD = wlr_keyboard_from_input_device(PKEYBOARD->keyboard);
const auto LAYOUTS = xkb_keymap_num_layouts(PWLRKEYBOARD->keymap);
2022-12-03 16:56:07 +01:00
xkb_layout_index_t activeLayout = 0;
while (activeLayout < LAYOUTS) {
if (xkb_state_layout_index_is_active(PWLRKEYBOARD->xkb_state, activeLayout, XKB_STATE_LAYOUT_EFFECTIVE))
break;
activeLayout++;
}
if (CMD == "next") {
wlr_keyboard_notify_modifiers(PWLRKEYBOARD, PWLRKEYBOARD->modifiers.depressed, PWLRKEYBOARD->modifiers.latched, PWLRKEYBOARD->modifiers.locked,
activeLayout > LAYOUTS ? 0 : activeLayout + 1);
2022-12-03 16:56:07 +01:00
} else if (CMD == "prev") {
wlr_keyboard_notify_modifiers(PWLRKEYBOARD, PWLRKEYBOARD->modifiers.depressed, PWLRKEYBOARD->modifiers.latched, PWLRKEYBOARD->modifiers.locked,
activeLayout == 0 ? LAYOUTS - 1 : activeLayout - 1);
2022-12-03 16:56:07 +01:00
} else {
2022-12-03 16:56:07 +01:00
int requestedLayout = 0;
try {
requestedLayout = std::stoi(CMD);
} catch (std::exception& e) { return "invalid arg 2"; }
2022-12-03 16:56:07 +01:00
if (requestedLayout < 0 || (uint64_t)requestedLayout > LAYOUTS - 1) {
return "layout idx out of range of " + std::to_string(LAYOUTS);
}
wlr_keyboard_notify_modifiers(PWLRKEYBOARD, PWLRKEYBOARD->modifiers.depressed, PWLRKEYBOARD->modifiers.latched, PWLRKEYBOARD->modifiers.locked, requestedLayout);
2022-12-03 16:56:07 +01:00
}
return "ok";
}
2023-01-22 16:38:17 +01:00
std::string dispatchSeterror(std::string request) {
CVarList vars(request, 0, ' ');
std::string errorMessage = "";
if (vars.size() < 3) {
g_pHyprError->destroy();
if (vars.size() == 2 && !vars[1].find("dis"))
return "var 1 not color or disable";
2023-01-22 16:38:17 +01:00
return "ok";
}
const CColor COLOR = configStringToInt(vars[1]);
for (size_t i = 2; i < vars.size(); ++i)
errorMessage += vars[i] + ' ';
if (errorMessage.empty()) {
g_pHyprError->destroy();
} else {
errorMessage.pop_back(); // pop last space
g_pHyprError->queueCreate(errorMessage, COLOR);
}
return "ok";
}
2023-01-24 20:05:34 +01:00
std::string dispatchSetProp(std::string request) {
CVarList vars(request, 0, ' ');
if (vars.size() < 4)
return "not enough args";
const auto PWINDOW = g_pCompositor->getWindowByRegex(vars[1]);
if (!PWINDOW)
return "window not found";
const auto PROP = vars[2];
const auto VAL = vars[3];
bool lock = false;
if (vars.size() > 4) {
if (vars[4].find("lock") == 0) {
lock = true;
}
}
try {
if (PROP == "animationstyle") {
PWINDOW->m_sAdditionalConfigData.animationStyle = VAL;
} else if (PROP == "rounding") {
PWINDOW->m_sAdditionalConfigData.rounding.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "forcenoblur") {
PWINDOW->m_sAdditionalConfigData.forceNoBlur.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "forceopaque") {
PWINDOW->m_sAdditionalConfigData.forceOpaque.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "forceopaqueoverriden") {
PWINDOW->m_sAdditionalConfigData.forceOpaqueOverridden.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "forceallowsinput") {
PWINDOW->m_sAdditionalConfigData.forceAllowsInput.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "forcenoanims") {
PWINDOW->m_sAdditionalConfigData.forceNoAnims.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "forcenoborder") {
PWINDOW->m_sAdditionalConfigData.forceNoBorder.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "forcenoshadow") {
PWINDOW->m_sAdditionalConfigData.forceNoShadow.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-05-31 21:11:20 +02:00
} else if (PROP == "forcenodim") {
PWINDOW->m_sAdditionalConfigData.forceNoDim.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "windowdancecompat") {
PWINDOW->m_sAdditionalConfigData.windowDanceCompat.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "nomaxsize") {
PWINDOW->m_sAdditionalConfigData.noMaxSize.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "dimaround") {
PWINDOW->m_sAdditionalConfigData.dimAround.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "alphaoverride") {
PWINDOW->m_sSpecialRenderData.alphaOverride.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "alpha") {
PWINDOW->m_sSpecialRenderData.alpha.forceSetIgnoreLocked(std::stof(VAL), lock);
} else if (PROP == "alphainactiveoverride") {
PWINDOW->m_sSpecialRenderData.alphaInactiveOverride.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "alphainactive") {
PWINDOW->m_sSpecialRenderData.alphaInactive.forceSetIgnoreLocked(std::stof(VAL), lock);
} else if (PROP == "activebordercolor") {
PWINDOW->m_sSpecialRenderData.activeBorderColor.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else if (PROP == "inactivebordercolor") {
PWINDOW->m_sSpecialRenderData.inactiveBorderColor.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-03-26 03:00:24 +02:00
} else if (PROP == "forcergbx") {
PWINDOW->m_sAdditionalConfigData.forceRGBX.forceSetIgnoreLocked(configStringToInt(VAL), lock);
} else if (PROP == "bordersize") {
PWINDOW->m_sSpecialRenderData.borderSize.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-08-08 18:52:20 +02:00
} else if (PROP == "keepaspectratio") {
PWINDOW->m_sAdditionalConfigData.keepAspectRatio.forceSetIgnoreLocked(configStringToInt(VAL), lock);
} else if (PROP == "immediate") {
PWINDOW->m_sAdditionalConfigData.forceTearing.forceSetIgnoreLocked(configStringToInt(VAL), lock);
2023-01-24 20:05:34 +01:00
} else {
return "prop not found";
}
} catch (std::exception& e) { return "error in parsing prop value: " + std::string(e.what()); }
g_pCompositor->updateAllWindowsAnimatedDecorationValues();
2023-06-04 21:35:17 +02:00
for (auto& m : g_pCompositor->m_vMonitors)
g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
2023-01-24 20:05:34 +01:00
return "ok";
}
2022-08-11 21:16:38 +02:00
std::string dispatchGetOption(std::string request, HyprCtl::eHyprCtlOutputFormat format) {
std::string curitem = "";
auto nextItem = [&]() {
2022-08-11 21:16:38 +02:00
auto idx = request.find_first_of(' ');
if (idx != std::string::npos) {
curitem = request.substr(0, idx);
request = request.substr(idx + 1);
} else {
curitem = request;
request = "";
}
curitem = removeBeginEndSpacesTabs(curitem);
};
nextItem();
nextItem();
const auto PCFGOPT = g_pConfigManager->getConfigValuePtrSafe(curitem);
if (!PCFGOPT)
return "no such option";
if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL)
return std::format("option {}\n\tint: {}\n\tfloat: {:.5f}\n\tstr: \"{}\"\n\tdata: {:x}\n\tset: {}", curitem, PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue,
(uintptr_t)PCFGOPT->data.get(), PCFGOPT->set);
2022-08-11 21:16:38 +02:00
else {
return std::format(
R"#(
2023-09-06 12:51:36 +02:00
{{
"option": "{}",
"int": {},
2023-09-06 12:51:36 +02:00
"float": {:.5f},
"str": "{}",
"data": "0x{:x}",
"set": {}
2023-09-06 12:51:36 +02:00
}}
)#",
curitem, PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue, (uintptr_t)PCFGOPT->data.get(), PCFGOPT->set);
2022-08-11 21:16:38 +02:00
}
}
void createOutputIter(wlr_backend* backend, void* data) {
const auto DATA = (std::pair<std::string, bool>*)data;
if (DATA->second)
return;
if (DATA->first.empty() || DATA->first == "auto") {
if (wlr_backend_is_wl(backend)) {
wlr_wl_output_create(backend);
DATA->second = true;
} else if (wlr_backend_is_x11(backend)) {
wlr_x11_output_create(backend);
DATA->second = true;
} else if (wlr_backend_is_headless(backend)) {
wlr_headless_add_output(backend, 1920, 1080);
DATA->second = true;
}
} else {
if (wlr_backend_is_wl(backend) && DATA->first == "wayland") {
wlr_wl_output_create(backend);
DATA->second = true;
} else if (wlr_backend_is_x11(backend) && DATA->first == "x11") {
wlr_x11_output_create(backend);
DATA->second = true;
} else if (wlr_backend_is_headless(backend) && DATA->first == "headless") {
wlr_headless_add_output(backend, 1920, 1080);
DATA->second = true;
}
}
}
std::string dispatchOutput(std::string request) {
std::string curitem = "";
auto nextItem = [&]() {
auto idx = request.find_first_of(' ');
if (idx != std::string::npos) {
curitem = request.substr(0, idx);
request = request.substr(idx + 1);
} else {
curitem = request;
request = "";
}
curitem = removeBeginEndSpacesTabs(curitem);
};
nextItem();
nextItem();
const auto MODE = curitem;
nextItem();
const auto NAME = curitem;
if (MODE == "create" || MODE == "add") {
std::pair<std::string, bool> result = {NAME, false};
wlr_multi_for_each_backend(g_pCompositor->m_sWLRBackend, createOutputIter, &result);
if (!result.second)
return "no backend replied to the request";
} else if (MODE == "destroy" || MODE == "remove") {
const auto PMONITOR = g_pCompositor->getMonitorFromName(NAME);
if (!PMONITOR)
return "output not found";
if (!PMONITOR->createdByUser)
return "cannot remove a real display. Use the monitor keyword.";
wlr_output_destroy(PMONITOR->output);
}
return "ok";
}
std::string dispatchPlugin(std::string request) {
CVarList vars(request, 0, ' ');
if (vars.size() < 2)
return "not enough args";
const auto OPERATION = vars[1];
const auto PATH = vars[2];
if (OPERATION == "load") {
if (vars.size() < 3)
return "not enough args";
const auto PLUGIN = g_pPluginSystem->loadPlugin(PATH);
if (!PLUGIN)
return "error in loading plugin";
} else if (OPERATION == "unload") {
if (vars.size() < 3)
return "not enough args";
const auto PLUGIN = g_pPluginSystem->getPluginByPath(PATH);
if (!PLUGIN)
return "plugin not loaded";
g_pPluginSystem->unloadPlugin(PLUGIN);
} else if (OPERATION == "list") {
const auto PLUGINS = g_pPluginSystem->getAllPlugins();
std::string list = "";
for (auto& p : PLUGINS) {
list += std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->name, p->author, (uintptr_t)p->m_pHandle, p->version, p->description);
}
return list;
} else {
return "unknown opt";
}
return "ok";
}
2023-03-20 17:00:54 +01:00
std::string dispatchNotify(std::string request) {
CVarList vars(request, 0, ' ');
if (vars.size() < 5)
return "not enough args";
const auto ICON = vars[1];
if (!isNumber(ICON))
return "invalid arg 1";
int icon = -1;
try {
icon = std::stoi(ICON);
} catch (std::exception& e) { return "invalid arg 1"; }
2023-04-08 19:53:54 +02:00
if (icon > ICON_NONE || icon < 0) {
2023-03-20 17:00:54 +01:00
icon = ICON_NONE;
}
const auto TIME = vars[2];
int time = 0;
try {
time = std::stoi(TIME);
} catch (std::exception& e) { return "invalid arg 2"; }
CColor color = configStringToInt(vars[3]);
std::string message = "";
for (size_t i = 4; i < vars.size(); ++i) {
message += vars[i] + " ";
}
message.pop_back();
g_pHyprNotificationOverlay->addNotification(message, color, time, (eIcons)icon);
return "ok";
}
2022-04-29 19:44:09 +02:00
std::string getReply(std::string request) {
auto format = HyprCtl::FORMAT_NORMAL;
2022-07-13 00:34:28 +02:00
// process flags for non-batch requests
2022-07-14 11:43:15 +02:00
if (!request.contains("[[BATCH]]") && request.contains("/")) {
2022-07-13 15:48:47 +02:00
long unsigned int sepIndex = 0;
2022-07-13 00:34:28 +02:00
for (const auto& c : request) {
if (c == '/') { // stop at separator
break;
}
sepIndex++;
2022-09-25 20:07:48 +02:00
2022-07-13 00:34:28 +02:00
if (c == 'j')
format = HyprCtl::FORMAT_JSON;
}
2022-07-13 00:34:28 +02:00
if (sepIndex < request.size())
request = request.substr(sepIndex + 1); // remove flags and separator so we can compare the rest of the string
}
2022-04-29 19:44:09 +02:00
if (request == "monitors")
return monitorsRequest(format);
2022-04-29 19:44:09 +02:00
else if (request == "workspaces")
return workspacesRequest(format);
else if (request == "activeworkspace")
return activeWorkspaceRequest(format);
2022-04-29 19:44:09 +02:00
else if (request == "clients")
return clientsRequest(format);
2022-06-27 13:42:20 +02:00
else if (request == "kill")
return killRequest();
2022-04-29 19:44:09 +02:00
else if (request == "activewindow")
return activeWindowRequest(format);
2022-04-29 19:44:09 +02:00
else if (request == "layers")
return layersRequest(format);
2022-04-29 19:44:09 +02:00
else if (request == "version")
2022-08-11 21:28:37 +02:00
return versionRequest(format);
2022-08-14 23:26:18 +02:00
else if (request.find("reload") == 0)
return reloadRequest(request);
2022-06-02 13:59:33 +02:00
else if (request == "devices")
return devicesRequest(format);
2022-07-10 15:41:26 +02:00
else if (request == "splash")
return splashRequest();
2022-10-26 14:19:37 +02:00
else if (request == "cursorpos")
return cursorPosRequest(format);
2023-01-06 14:32:25 +01:00
else if (request == "binds")
return bindsRequest(format);
else if (request == "globalshortcuts")
return globalShortcutsRequest(format);
2023-01-25 16:16:28 +01:00
else if (request == "animations")
return animationsRequest(format);
else if (request.find("plugin") == 0)
return dispatchPlugin(request);
2023-03-20 17:00:54 +01:00
else if (request.find("notify") == 0)
return dispatchNotify(request);
2023-01-24 20:05:34 +01:00
else if (request.find("setprop") == 0)
return dispatchSetProp(request);
2023-01-22 16:38:17 +01:00
else if (request.find("seterror") == 0)
return dispatchSeterror(request);
2022-12-03 16:56:07 +01:00
else if (request.find("switchxkblayout") == 0)
return switchXKBLayoutRequest(request);
else if (request.find("output") == 0)
return dispatchOutput(request);
2022-04-29 19:44:09 +02:00
else if (request.find("dispatch") == 0)
return dispatchRequest(request);
else if (request.find("keyword") == 0)
return dispatchKeyword(request);
2022-08-10 21:22:11 +02:00
else if (request.find("setcursor") == 0)
return dispatchSetCursor(request);
2022-08-11 21:16:38 +02:00
else if (request.find("getoption") == 0)
return dispatchGetOption(request, format);
2022-04-29 19:44:09 +02:00
else if (request.find("[[BATCH]]") == 0)
return dispatchBatch(request);
return "unknown request";
}
std::string HyprCtl::makeDynamicCall(const std::string& input) {
return getReply(input);
}
2022-09-10 21:21:28 +02:00
int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
if (mask & WL_EVENT_ERROR || mask & WL_EVENT_HANGUP)
return 0;
sockaddr_in clientAddress;
socklen_t clientSize = sizeof(clientAddress);
2022-09-10 21:21:28 +02:00
const auto ACCEPTEDCONNECTION = accept4(HyprCtl::iSocketFD, (sockaddr*)&clientAddress, &clientSize, SOCK_CLOEXEC);
2022-09-10 21:21:28 +02:00
char readBuffer[1024];
2022-09-10 21:21:28 +02:00
2023-07-21 17:20:23 +02:00
fd_set fdset;
FD_ZERO(&fdset);
FD_SET(ACCEPTEDCONNECTION, &fdset);
timeval timeout = {.tv_sec = 0, .tv_usec = 5000};
auto success = select(ACCEPTEDCONNECTION + 1, &fdset, nullptr, nullptr, &timeout);
if (success <= 0) {
close(ACCEPTEDCONNECTION);
return 0;
}
auto messageSize = read(ACCEPTEDCONNECTION, readBuffer, 1024);
2022-09-10 21:21:28 +02:00
readBuffer[messageSize == 1024 ? 1023 : messageSize] = '\0';
std::string request(readBuffer);
2022-04-21 22:00:03 +02:00
std::string reply = "";
try {
2022-04-29 19:44:09 +02:00
reply = getReply(request);
2022-04-21 22:00:03 +02:00
} catch (std::exception& e) {
2023-09-06 12:51:36 +02:00
Debug::log(ERR, "Error in request: {}", e.what());
2022-04-21 22:00:03 +02:00
reply = "Err: " + std::string(e.what());
}
2022-09-10 21:21:28 +02:00
write(ACCEPTEDCONNECTION, reply.c_str(), reply.length());
2022-04-21 22:00:03 +02:00
2022-09-10 21:21:28 +02:00
close(ACCEPTEDCONNECTION);
if (g_pConfigManager->m_bWantsMonitorReload) {
g_pConfigManager->ensureMonitorStatus();
}
2022-04-21 22:00:03 +02:00
2022-09-10 21:21:28 +02:00
return 0;
2022-04-21 22:00:03 +02:00
}
2022-03-21 18:29:41 +01:00
void HyprCtl::startHyprCtlSocket() {
2022-03-20 16:51:14 +01:00
iSocketFD = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
2022-03-21 18:29:41 +01:00
2022-09-10 21:21:28 +02:00
if (iSocketFD < 0) {
Debug::log(ERR, "Couldn't start the Hyprland Socket. (1) IPC will not work.");
return;
}
2022-03-21 18:29:41 +01:00
2022-09-10 21:21:28 +02:00
sockaddr_un SERVERADDRESS = {.sun_family = AF_UNIX};
2022-03-21 18:29:41 +01:00
2022-09-10 21:21:28 +02:00
std::string socketPath = "/tmp/hypr/" + g_pCompositor->m_szInstanceSignature + "/.socket.sock";
2022-03-21 18:29:41 +01:00
2022-09-10 21:21:28 +02:00
strcpy(SERVERADDRESS.sun_path, socketPath.c_str());
2022-03-21 18:29:41 +01:00
if (bind(iSocketFD, (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)) < 0) {
Debug::log(ERR, "Couldn't start the Hyprland Socket. (2) IPC will not work.");
return;
}
2022-03-21 18:29:41 +01:00
2022-09-10 21:21:28 +02:00
// 10 max queued.
listen(iSocketFD, 10);
2022-03-22 16:54:45 +01:00
Debug::log(LOG, "Hypr socket started at {}", socketPath);
2022-09-10 21:21:28 +02:00
wl_event_loop_add_fd(g_pCompositor->m_sWLEventLoop, iSocketFD, WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
2022-08-05 01:25:56 +02:00
}