Inheritance diagram for KisWaylandKeyboardWatcher::Keyboard:

Public Member Functions
bool	hasKeyboardFocus () const

	Keyboard (::wl_keyboard *keyboard)

Qt::KeyboardModifiers	modifiers () const

QList< Qt::Key >	pressedKeys () const

	~Keyboard ()

Private Member Functions
void	keyboard_enter (uint32_t serial, wl_surface surface, wl_array keys) override

void	keyboard_key (uint32_t serial, uint32_t time, uint32_t key, uint32_t state) override

void	keyboard_keymap (uint32_t format, int32_t fd, uint32_t size) override

void	keyboard_leave (uint32_t serial, wl_surface *surface) override

void	keyboard_modifiers (uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) override

Private Attributes
bool	m_focus = false

uint32_t	mKeymapFormat = WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1

QList< uint32_t >	mNativeKeys

uint32_t	mNativeModifiers = 0

QXkbCommon::ScopedXKBKeymap	mXkbKeymap

QXkbCommon::ScopedXKBState	mXkbState

Detailed Description

Definition at line 53 of file KisWaylandKeyboardWatcher.cpp.

Constructor & Destructor Documentation

◆ Keyboard()

KisWaylandKeyboardWatcher::Keyboard::Keyboard ( ::wl_keyboard * keyboard )

inline

Definition at line 56 of file KisWaylandKeyboardWatcher.cpp.

        : wl_keyboard(keyboard)
    {
    }

◆ ~Keyboard()

KisWaylandKeyboardWatcher::Keyboard::~Keyboard ( )

inline

Definition at line 61 of file KisWaylandKeyboardWatcher.cpp.

    {
        release();
    }

Member Function Documentation

◆ hasKeyboardFocus()

bool KisWaylandKeyboardWatcher::Keyboard::hasKeyboardFocus ( ) const

inline

Definition at line 87 of file KisWaylandKeyboardWatcher.cpp.

    {
        return m_focus;
    }

References m_focus.

◆ keyboard_enter()

void KisWaylandKeyboardWatcher::Keyboard::keyboard_enter	(	uint32_t	serial,
		wl_surface *	surface,
		wl_array *	keys )

inlineoverrideprivate

Definition at line 159 of file KisWaylandKeyboardWatcher.cpp.

    {
        mNativeKeys.clear();
        mNativeKeys.reserve(keys->size / sizeof(uint32_t));
 
        for (const uint32_t *keyPtr = static_cast<const uint32_t *>(keys->data);
             reinterpret_cast<const char *>(keyPtr) < static_cast<const char *>(keys->data) + keys->size;
             keyPtr++) {
            mNativeKeys.append(*keyPtr);
        }
 
        m_focus = true;
    }

References m_focus, and mNativeKeys.

◆ keyboard_key()

void KisWaylandKeyboardWatcher::Keyboard::keyboard_key	(	uint32_t	serial,
		uint32_t	time,
		uint32_t	key,
		uint32_t	state )

inlineoverrideprivate

Definition at line 133 of file KisWaylandKeyboardWatcher.cpp.

    {
        const bool isDown = state != WL_KEYBOARD_KEY_STATE_RELEASED;
        if (isDown) {
            auto it = std::find(mNativeKeys.begin(), mNativeKeys.end(), key);
            if (it != mNativeKeys.end()) {
                qWarning().nospace() << "WARNING: got a key-down for a key (" << Qt::hex << Qt::showbase << key << ") which is reported to be pressed already!";
            } else {
                mNativeKeys.append(key);
            }
        } else {
            auto it = std::find(mNativeKeys.begin(), mNativeKeys.end(), key);
            if (it == mNativeKeys.end()) {
                qWarning().nospace() << "WARNING: got a key-up for a key (" << Qt::hex << Qt::showbase << key << ") which is NOT reported to be pressed!";
            } else {
                mNativeKeys.erase(it);
            }
        }
    }

References mNativeKeys.

◆ keyboard_keymap()

void KisWaylandKeyboardWatcher::Keyboard::keyboard_keymap	(	uint32_t	format,
		int32_t	fd,
		uint32_t	size )

inlineoverrideprivate

Definition at line 102 of file KisWaylandKeyboardWatcher.cpp.

    {
        mKeymapFormat = format;
 
        if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
            qDebug() << "unknown keymap format:" << format;
            close(fd);
            return;
        }
 
        char *map_str = static_cast<char *>(mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0));
        if (map_str == MAP_FAILED) {
            close(fd);
            return;
        }
 
        struct xkb_context *xkbContext = getGlobalXkbContextFromQt();
        if (xkbContext) {
            mXkbKeymap.reset(xkb_keymap_new_from_string(xkbContext, map_str, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS));
            QXkbCommon::verifyHasLatinLayout(mXkbKeymap.get());
        }
 
        munmap(map_str, size);
        close(fd);
 
        if (mXkbKeymap)
            mXkbState.reset(xkb_state_new(mXkbKeymap.get()));
        else
            mXkbState.reset(nullptr);
    }

References getGlobalXkbContextFromQt(), mKeymapFormat, mXkbKeymap, and mXkbState.

◆ keyboard_leave()

void KisWaylandKeyboardWatcher::Keyboard::keyboard_leave	(	uint32_t	serial,
		wl_surface *	surface )

inlineoverrideprivate

Definition at line 172 of file KisWaylandKeyboardWatcher.cpp.

    {
        mNativeKeys.clear();
        m_focus = false;
    }

References m_focus, and mNativeKeys.

◆ keyboard_modifiers()

void KisWaylandKeyboardWatcher::Keyboard::keyboard_modifiers	(	uint32_t	serial,
		uint32_t	mods_depressed,
		uint32_t	mods_latched,
		uint32_t	mods_locked,
		uint32_t	group )

inlineoverrideprivate

Definition at line 152 of file KisWaylandKeyboardWatcher.cpp.

    {
        if (mXkbState)
            xkb_state_update_mask(mXkbState.get(), mods_depressed, mods_latched, mods_locked, 0, 0, group);
        mNativeModifiers = mods_depressed | mods_latched | mods_locked;
    }

References mNativeModifiers, and mXkbState.

◆ modifiers()

Qt::KeyboardModifiers KisWaylandKeyboardWatcher::Keyboard::modifiers ( ) const

inline

Definition at line 92 of file KisWaylandKeyboardWatcher.cpp.

    {
        Qt::KeyboardModifiers ret = Qt::NoModifier;
        if (!mXkbState)
            return ret;
        ret = QXkbCommon::modifiers(mXkbState.get());
        return ret;
    }

References mXkbState.

◆ pressedKeys()

QList< Qt::Key > KisWaylandKeyboardWatcher::Keyboard::pressedKeys ( ) const

inline

Definition at line 66 of file KisWaylandKeyboardWatcher.cpp.

    {
        QList<Qt::Key> keys;
 
        if (mXkbState) {
            for (uint32_t key : std::as_const(mNativeKeys)) {
                auto code = key + 8; // map to wl_keyboard::keymap_format::keymap_format_xkb_v1
 
                xkb_keysym_t sym = xkb_state_key_get_one_sym(mXkbState.get(), code);
                Qt::KeyboardModifiers modifiers = QXkbCommon::modifiers(mXkbState.get(), sym);
 
                Qt::Key qtKey = static_cast<Qt::Key>(QXkbCommon::keysymToQtKey(sym, modifiers, mXkbState.get(), code));
 
                if (qtKey != Qt::Key_unknown)
                    keys.append(qtKey);
            }
        }
 
        return keys;
    }