diff options
Diffstat (limited to 'src/protocols')
| -rw-r--r-- | src/protocols/InputMethodV2.cpp | 383 | ||||
| -rw-r--r-- | src/protocols/InputMethodV2.hpp | 160 |
2 files changed, 543 insertions, 0 deletions
diff --git a/src/protocols/InputMethodV2.cpp b/src/protocols/InputMethodV2.cpp new file mode 100644 index 00000000..91dac671 --- /dev/null +++ b/src/protocols/InputMethodV2.cpp @@ -0,0 +1,383 @@ +#include "InputMethodV2.hpp" +#include "../Compositor.hpp" +#include <sys/mman.h> + +#define LOGM PROTO::ime->protoLog + +CInputMethodKeyboardGrabV2::CInputMethodKeyboardGrabV2(SP<CZwpInputMethodKeyboardGrabV2> resource_, SP<CInputMethodV2> owner_) : resource(resource_), owner(owner_) { + if (!resource->resource()) + return; + + resource->setRelease([this](CZwpInputMethodKeyboardGrabV2* r) { PROTO::ime->destroyResource(this); }); + resource->setOnDestroy([this](CZwpInputMethodKeyboardGrabV2* r) { PROTO::ime->destroyResource(this); }); + + const auto PKEYBOARD = wlr_seat_get_keyboard(g_pCompositor->m_sSeat.seat); + + if (!PKEYBOARD) { + LOGM(ERR, "IME called but no active keyboard???"); + return; + } + + sendKeyboardData(PKEYBOARD); +} + +CInputMethodKeyboardGrabV2::~CInputMethodKeyboardGrabV2() { + if (!owner.expired()) + std::erase_if(owner.lock()->grabs, [](const auto& g) { return g.expired(); }); +} + +void CInputMethodKeyboardGrabV2::sendKeyboardData(wlr_keyboard* keyboard) { + + if (keyboard == pLastKeyboard) + return; + + pLastKeyboard = keyboard; + + int keymapFD = allocateSHMFile(keyboard->keymap_size); + if (keymapFD < 0) { + LOGM(ERR, "Failed to create a keymap file for keyboard grab"); + return; + } + + void* data = mmap(nullptr, keyboard->keymap_size, PROT_READ | PROT_WRITE, MAP_SHARED, keymapFD, 0); + if (data == MAP_FAILED) { + LOGM(ERR, "Failed to mmap a keymap file for keyboard grab"); + close(keymapFD); + return; + } + + memcpy(data, keyboard->keymap_string, keyboard->keymap_size); + munmap(data, keyboard->keymap_size); + + resource->sendKeymap(WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1, keymapFD, keyboard->keymap_size); + + close(keymapFD); + + sendMods(0, 0, 0, 0); + + resource->sendRepeatInfo(keyboard->repeat_info.rate, keyboard->repeat_info.delay); +} + +void CInputMethodKeyboardGrabV2::sendKey(uint32_t time, uint32_t key, wl_keyboard_key_state state) { + const auto SERIAL = wlr_seat_client_next_serial(wlr_seat_client_for_wl_client(g_pCompositor->m_sSeat.seat, wl_resource_get_client(resource->resource()))); + + resource->sendKey(SERIAL, time, key, (uint32_t)state); +} + +void CInputMethodKeyboardGrabV2::sendMods(uint32_t depressed, uint32_t latched, uint32_t locked, uint32_t group) { + const auto SERIAL = wlr_seat_client_next_serial(wlr_seat_client_for_wl_client(g_pCompositor->m_sSeat.seat, wl_resource_get_client(resource->resource()))); + + resource->sendModifiers(SERIAL, depressed, latched, locked, group); +} + +bool CInputMethodKeyboardGrabV2::good() { + return resource->resource(); +} + +SP<CInputMethodV2> CInputMethodKeyboardGrabV2::getOwner() { + return owner.lock(); +} + +wl_client* CInputMethodKeyboardGrabV2::client() { + return wl_resource_get_client(resource->resource()); +} + +CInputMethodPopupV2::CInputMethodPopupV2(SP<CZwpInputPopupSurfaceV2> resource_, SP<CInputMethodV2> owner_, wlr_surface* wlrSurface) : resource(resource_), owner(owner_) { + if (!resource->resource()) + return; + + resource->setDestroy([this](CZwpInputPopupSurfaceV2* r) { PROTO::ime->destroyResource(this); }); + resource->setOnDestroy([this](CZwpInputPopupSurfaceV2* r) { PROTO::ime->destroyResource(this); }); + + pSurface = wlrSurface; + + hyprListener_destroySurface.initCallback( + &wlrSurface->events.destroy, + [this](void* owner, void* data) { + if (mapped) + events.unmap.emit(); + + hyprListener_commitSurface.removeCallback(); + hyprListener_destroySurface.removeCallback(); + + if (g_pCompositor->m_pLastFocus == pSurface) + g_pCompositor->m_pLastFocus = nullptr; + + pSurface = nullptr; + }, + this, "IMEPopup"); + + hyprListener_commitSurface.initCallback( + &wlrSurface->events.commit, + [this](void* owner, void* data) { + if (pSurface->pending.buffer_width > 0 && pSurface->pending.buffer_height > 0 && !mapped) { + mapped = true; + wlr_surface_map(pSurface); + events.map.emit(); + return; + } + + if (pSurface->pending.buffer_width <= 0 && pSurface->pending.buffer_height <= 0 && mapped) { + mapped = false; + wlr_surface_unmap(pSurface); + events.unmap.emit(); + return; + } + + events.commit.emit(); + }, + this, "IMEPopup"); +} + +CInputMethodPopupV2::~CInputMethodPopupV2() { + if (!owner.expired()) + std::erase_if(owner.lock()->popups, [](const auto& p) { return p.expired(); }); + + events.destroy.emit(); +} + +bool CInputMethodPopupV2::good() { + return resource->resource(); +} + +void CInputMethodPopupV2::sendInputRectangle(const CBox& box) { + resource->sendTextInputRectangle(box.x, box.y, box.w, box.h); +} + +wlr_surface* CInputMethodPopupV2::surface() { + return pSurface; +} + +void CInputMethodV2::SState::reset() { + committedString.committed = false; + deleteSurrounding.committed = false; + preeditString.committed = false; +} + +CInputMethodV2::CInputMethodV2(SP<CZwpInputMethodV2> resource_) : resource(resource_) { + if (!resource->resource()) + return; + + resource->setDestroy([this](CZwpInputMethodV2* r) { + events.destroy.emit(); + PROTO::ime->destroyResource(this); + }); + resource->setOnDestroy([this](CZwpInputMethodV2* r) { + events.destroy.emit(); + PROTO::ime->destroyResource(this); + }); + + resource->setCommitString([this](CZwpInputMethodV2* r, const char* str) { + pending.committedString.string = str; + pending.committedString.committed = true; + }); + + resource->setDeleteSurroundingText([this](CZwpInputMethodV2* r, uint32_t before, uint32_t after) { + pending.deleteSurrounding.before = before; + pending.deleteSurrounding.after = after; + pending.deleteSurrounding.committed = true; + }); + + resource->setSetPreeditString([this](CZwpInputMethodV2* r, const char* str, int32_t begin, int32_t end) { + pending.preeditString.string = str; + pending.preeditString.begin = begin; + pending.preeditString.end = end; + pending.preeditString.committed = true; + }); + + resource->setCommit([this](CZwpInputMethodV2* r, uint32_t serial) { + current = pending; + pending.reset(); + events.onCommit.emit(); + }); + + resource->setGetInputPopupSurface([this](CZwpInputMethodV2* r, uint32_t id, wl_resource* surface) { + const auto CLIENT = wl_resource_get_client(r->resource()); + const auto RESOURCE = PROTO::ime->m_vPopups.emplace_back(std::make_shared<CInputMethodPopupV2>( + std::make_shared<CZwpInputPopupSurfaceV2>(CLIENT, wl_resource_get_version(r->resource()), id), self.lock(), wlr_surface_from_resource(surface))); + + if (!RESOURCE->good()) { + wl_resource_post_no_memory(r->resource()); + PROTO::ime->m_vPopups.pop_back(); + return; + } + + LOGM(LOG, "New IME Popup with resource id {}", id); + + popups.emplace_back(RESOURCE); + + events.newPopup.emit(RESOURCE); + }); + + resource->setGrabKeyboard([this](CZwpInputMethodV2* r, uint32_t id) { + const auto CLIENT = wl_resource_get_client(r->resource()); + const auto RESOURCE = PROTO::ime->m_vGrabs.emplace_back( + std::make_shared<CInputMethodKeyboardGrabV2>(std::make_shared<CZwpInputMethodKeyboardGrabV2>(CLIENT, wl_resource_get_version(r->resource()), id), self.lock())); + + if (!RESOURCE->good()) { + wl_resource_post_no_memory(r->resource()); + PROTO::ime->m_vGrabs.pop_back(); + return; + } + + LOGM(LOG, "New IME Grab with resource id {}", id); + + grabs.emplace_back(RESOURCE); + }); +} + +CInputMethodV2::~CInputMethodV2() { + events.destroy.emit(); +} + +bool CInputMethodV2::good() { + return resource->resource(); +} + +void CInputMethodV2::activate() { + if (active) + return; + resource->sendActivate(); + active = true; +} + +void CInputMethodV2::deactivate() { + if (!active) + return; + resource->sendDeactivate(); + active = false; +} + +void CInputMethodV2::surroundingText(const std::string& text, uint32_t cursor, uint32_t anchor) { + resource->sendSurroundingText(text.c_str(), cursor, anchor); +} + +void CInputMethodV2::textChangeCause(zwpTextInputV3ChangeCause changeCause) { + resource->sendTextChangeCause((uint32_t)changeCause); +} + +void CInputMethodV2::textContentType(zwpTextInputV3ContentHint hint, zwpTextInputV3ContentPurpose purpose) { + resource->sendContentType((uint32_t)hint, (uint32_t)purpose); +} + +void CInputMethodV2::done() { + resource->sendDone(); +} + +void CInputMethodV2::unavailable() { + resource->sendUnavailable(); +} + +bool CInputMethodV2::hasGrab() { + return !grabs.empty(); +} + +wl_client* CInputMethodV2::grabClient() { + if (grabs.empty()) + return nullptr; + + for (auto& gw : grabs) { + auto g = gw.lock(); + + if (!g) + continue; + + return g->client(); + } + + return nullptr; +} + +void CInputMethodV2::sendInputRectangle(const CBox& box) { + inputRectangle = box; + for (auto& wp : popups) { + auto p = wp.lock(); + + if (!p) + continue; + + p->sendInputRectangle(inputRectangle); + } +} + +void CInputMethodV2::sendKey(uint32_t time, uint32_t key, wl_keyboard_key_state state) { + for (auto& gw : grabs) { + auto g = gw.lock(); + + if (!g) + continue; + + g->sendKey(time, key, state); + } +} + +void CInputMethodV2::sendMods(uint32_t depressed, uint32_t latched, uint32_t locked, uint32_t group) { + for (auto& gw : grabs) { + auto g = gw.lock(); + + if (!g) + continue; + + g->sendMods(depressed, latched, locked, group); + } +} + +void CInputMethodV2::setKeyboard(wlr_keyboard* keyboard) { + for (auto& gw : grabs) { + auto g = gw.lock(); + + if (!g) + continue; + + g->sendKeyboardData(keyboard); + } +} + +wl_client* CInputMethodV2::client() { + return wl_resource_get_client(resource->resource()); +} + +CInputMethodV2Protocol::CInputMethodV2Protocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) { + ; +} + +void CInputMethodV2Protocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) { + const auto RESOURCE = m_vManagers.emplace_back(std::make_unique<CZwpInputMethodManagerV2>(client, ver, id)).get(); + RESOURCE->setOnDestroy([this](CZwpInputMethodManagerV2* p) { this->onManagerResourceDestroy(p->resource()); }); + + RESOURCE->setDestroy([this](CZwpInputMethodManagerV2* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); }); + RESOURCE->setGetInputMethod([this](CZwpInputMethodManagerV2* pMgr, wl_resource* seat, uint32_t id) { this->onGetIME(pMgr, seat, id); }); +} + +void CInputMethodV2Protocol::onManagerResourceDestroy(wl_resource* res) { + std::erase_if(m_vManagers, [&](const auto& other) { return other->resource() == res; }); +} + +void CInputMethodV2Protocol::destroyResource(CInputMethodPopupV2* popup) { + std::erase_if(m_vPopups, [&](const auto& other) { return other.get() == popup; }); +} + +void CInputMethodV2Protocol::destroyResource(CInputMethodKeyboardGrabV2* grab) { + std::erase_if(m_vGrabs, [&](const auto& other) { return other.get() == grab; }); +} + +void CInputMethodV2Protocol::destroyResource(CInputMethodV2* ime) { + std::erase_if(m_vIMEs, [&](const auto& other) { return other.get() == ime; }); +} + +void CInputMethodV2Protocol::onGetIME(CZwpInputMethodManagerV2* mgr, wl_resource* seat, uint32_t id) { + const auto CLIENT = wl_resource_get_client(mgr->resource()); + const auto RESOURCE = m_vIMEs.emplace_back(std::make_shared<CInputMethodV2>(std::make_shared<CZwpInputMethodV2>(CLIENT, wl_resource_get_version(mgr->resource()), id))); + + if (!RESOURCE->good()) { + wl_resource_post_no_memory(mgr->resource()); + m_vIMEs.pop_back(); + return; + } + + RESOURCE->self = RESOURCE; + + LOGM(LOG, "New IME with resource id {}", id); + + events.newIME.emit(RESOURCE); +}
\ No newline at end of file diff --git a/src/protocols/InputMethodV2.hpp b/src/protocols/InputMethodV2.hpp new file mode 100644 index 00000000..1f5d2598 --- /dev/null +++ b/src/protocols/InputMethodV2.hpp @@ -0,0 +1,160 @@ +#pragma once + +#include <memory> +#include <vector> +#include <cstdint> +#include "WaylandProtocol.hpp" +#include "input-method-unstable-v2.hpp" +#include "text-input-unstable-v3.hpp" +#include "../helpers/signal/Signal.hpp" +#include "../desktop/WLSurface.hpp" + +class CInputMethodKeyboardGrabV2; +class CInputMethodPopupV2; + +class CInputMethodV2 { + public: + CInputMethodV2(SP<CZwpInputMethodV2> resource_); + ~CInputMethodV2(); + + struct { + CSignal onCommit; + CSignal destroy; + CSignal newPopup; + } events; + + struct SState { + void reset(); + + struct { + std::string string; + bool committed = false; + } committedString; + + struct { + std::string string; + int32_t begin = 0, end = 0; + bool committed = false; + } preeditString; + + struct { + uint32_t before = 0, after = 0; + bool committed = false; + } deleteSurrounding; + }; + + SState pending, current; + + bool good(); + void activate(); + void deactivate(); + void surroundingText(const std::string& text, uint32_t cursor, uint32_t anchor); + void textChangeCause(zwpTextInputV3ChangeCause changeCause); + void textContentType(zwpTextInputV3ContentHint hint, zwpTextInputV3ContentPurpose purpose); + void done(); + void unavailable(); + + void sendInputRectangle(const CBox& box); + bool hasGrab(); + void sendKey(uint32_t time, uint32_t key, wl_keyboard_key_state state); + void sendMods(uint32_t depressed, uint32_t latched, uint32_t locked, uint32_t group); + void setKeyboard(wlr_keyboard* keyboard); + + wl_client* client(); + wl_client* grabClient(); + + private: + SP<CZwpInputMethodV2> resource; + std::vector<WP<CInputMethodKeyboardGrabV2>> grabs; + std::vector<WP<CInputMethodPopupV2>> popups; + + WP<CInputMethodV2> self; + + bool active = false; + + CBox inputRectangle; + + friend class CInputMethodPopupV2; + friend class CInputMethodKeyboardGrabV2; + friend class CInputMethodV2Protocol; +}; + +class CInputMethodKeyboardGrabV2 { + public: + CInputMethodKeyboardGrabV2(SP<CZwpInputMethodKeyboardGrabV2> resource_, SP<CInputMethodV2> owner_); + ~CInputMethodKeyboardGrabV2(); + + bool good(); + SP<CInputMethodV2> getOwner(); + wl_client* client(); + + void sendKey(uint32_t time, uint32_t key, wl_keyboard_key_state state); + void sendMods(uint32_t depressed, uint32_t latched, uint32_t locked, uint32_t group); + void sendKeyboardData(wlr_keyboard* keyboard); + + private: + SP<CZwpInputMethodKeyboardGrabV2> resource; + WP<CInputMethodV2> owner; + + wlr_keyboard* pLastKeyboard = nullptr; // READ-ONLY +}; + +class CInputMethodPopupV2 { + public: + CInputMethodPopupV2(SP<CZwpInputPopupSurfaceV2> resource_, SP<CInputMethodV2> owner_, wlr_surface* surface); + ~CInputMethodPopupV2(); + + bool good(); + void sendInputRectangle(const CBox& box); + wlr_surface* surface(); + + struct { + CSignal map; + CSignal unmap; + CSignal commit; + CSignal destroy; + } events; + + bool mapped = false; + + private: + SP<CZwpInputPopupSurfaceV2> resource; + WP<CInputMethodV2> owner; + wlr_surface* pSurface = nullptr; + + DYNLISTENER(commitSurface); + DYNLISTENER(destroySurface); +}; + +class CInputMethodV2Protocol : public IWaylandProtocol { + public: + CInputMethodV2Protocol(const wl_interface* iface, const int& ver, const std::string& name); + + virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id); + + struct { + CSignal newIME; // SP<CInputMethodV2> + } events; + + private: + void onManagerResourceDestroy(wl_resource* res); + void destroyResource(CInputMethodPopupV2* popup); + void destroyResource(CInputMethodKeyboardGrabV2* grab); + void destroyResource(CInputMethodV2* ime); + + void onGetIME(CZwpInputMethodManagerV2* mgr, wl_resource* seat, uint32_t id); + + // + std::vector<UP<CZwpInputMethodManagerV2>> m_vManagers; + std::vector<SP<CInputMethodV2>> m_vIMEs; + std::vector<SP<CInputMethodKeyboardGrabV2>> m_vGrabs; + std::vector<SP<CInputMethodPopupV2>> m_vPopups; + + friend class CInputMethodPopupV2; + friend class CInputMethodKeyboardGrabV2; + friend class CInputMethodV2; +}; + +namespace PROTO { + inline UP<CInputMethodV2Protocol> ime; +};
\ No newline at end of file |