netwm.h

/*
    SPDX-FileCopyrightText: 2000 Troll Tech AS
    SPDX-FileCopyrightText: 2003 Lubos Lunak <[email protected]>

    SPDX-License-Identifier: MIT
*/

#ifndef   netwm_h
#define   netwm_h

#include <kwindowsystem_export.h>
#include <QSize>
#include <config-kwindowsystem.h>
#if KWINDOWSYSTEM_HAVE_X11
#include <xcb/xcb.h>
#include <vector>

#include "netwm_def.h"

#define KDE_ALL_ACTIVITIES_UUID "00000000-0000-0000-0000-000000000000"

// forward declaration
struct NETRootInfoPrivate;
struct NETWinInfoPrivate;
template <class Z> class NETRArray;

class KWINDOWSYSTEM_EXPORT NETRootInfo : public NET
{
public:
    // update also NETRootInfoPrivate::properties[] size when extending this
    enum { PROTOCOLS, WINDOW_TYPES, STATES, PROTOCOLS2, ACTIONS,
           PROPERTIES_SIZE
         };

    NETRootInfo(xcb_connection_t *connection, xcb_window_t supportWindow, const char *wmName,
                NET::Properties properties, NET::WindowTypes windowTypes, NET::States states,
                NET::Properties2 properties2, NET::Actions actions,
                int screen = -1, bool doActivate = true);

    NETRootInfo(xcb_connection_t *connection, NET::Properties properties, NET::Properties2 properties2 = NET::Properties2(),
                int screen = -1, bool doActivate = true);


    NETRootInfo(const NETRootInfo &rootinfo);

    virtual ~NETRootInfo();

    xcb_connection_t *xcbConnection() const;

    xcb_window_t rootWindow() const;

    xcb_window_t supportWindow() const;

    const char *wmName() const;

    void setSupported(NET::Property property, bool on = true);

    void setSupported(NET::Property2 property, bool on = true);

    void setSupported(NET::WindowTypeMask property, bool on = true);

    void setSupported(NET::State property, bool on = true);

    void setSupported(NET::Action property, bool on = true);

    bool isSupported(NET::Property property) const;
    bool isSupported(NET::Property2 property) const;
    bool isSupported(NET::WindowTypeMask type) const;
    bool isSupported(NET::State state) const;

    bool isSupported(NET::Action action) const;

    NET::Properties supportedProperties() const;
    NET::Properties2 supportedProperties2() const;
    NET::States supportedStates() const;
    NET::WindowTypes supportedWindowTypes() const;
    NET::Actions supportedActions() const;

    NET::Properties passedProperties() const;
    NET::Properties2 passedProperties2() const;
    NET::States passedStates() const;
    NET::WindowTypes passedWindowTypes() const;
    NET::Actions passedActions() const;

    const xcb_window_t *clientList() const;

    int clientListCount() const;

    const xcb_window_t *clientListStacking() const;

    int clientListStackingCount() const;

    NETSize desktopGeometry() const;

    NETPoint desktopViewport(int desktop) const;

    NETRect workArea(int desktop) const;

    const char *desktopName(int desktop) const;

    const xcb_window_t *virtualRoots() const;

    int virtualRootsCount() const;

    NET::Orientation desktopLayoutOrientation() const;

    QSize desktopLayoutColumnsRows() const;

    NET::DesktopLayoutCorner desktopLayoutCorner() const;

    int numberOfDesktops(bool ignore_viewport = false) const;

    int currentDesktop(bool ignore_viewport = false) const;

    xcb_window_t activeWindow() const;

    void activate();

    void setClientList(const xcb_window_t *windows, unsigned int count);

    void setClientListStacking(const xcb_window_t *windows, unsigned int count);

    void setCurrentDesktop(int desktop, bool ignore_viewport = false);

    void setDesktopGeometry(const NETSize &geometry);

    void setDesktopViewport(int desktop, const NETPoint &viewport);

    void setNumberOfDesktops(int numberOfDesktops);

    void setDesktopName(int desktop, const char *desktopName);

    void setActiveWindow(xcb_window_t window, NET::RequestSource src,
                         xcb_timestamp_t timestamp, xcb_window_t active_window);

    void setActiveWindow(xcb_window_t window);

    void setWorkArea(int desktop, const NETRect &workArea);

    void setVirtualRoots(const xcb_window_t *windows, unsigned int count);

    void setDesktopLayout(NET::Orientation orientation, int columns, int rows,
                          NET::DesktopLayoutCorner corner);

    void setShowingDesktop(bool showing);
    bool showingDesktop() const;

    const NETRootInfo &operator=(const NETRootInfo &rootinfo);

    void closeWindowRequest(xcb_window_t window);

    void moveResizeRequest(xcb_window_t window, int x_root, int y_root,
                           Direction direction);

    void moveResizeWindowRequest(xcb_window_t window, int flags, int x, int y, int width, int height);

    void restackRequest(xcb_window_t window, RequestSource source, xcb_window_t above, int detail, xcb_timestamp_t timestamp);

    void sendPing(xcb_window_t window, xcb_timestamp_t timestamp);

#if KWINDOWSYSTEM_ENABLE_DEPRECATED_SINCE(5, 0)

    KWINDOWSYSTEM_DEPRECATED_VERSION(5, 0, "Use NETRootInfo::event(xcb_generic_event_t*, NET::Properties*, NET::Properties2*)")
    void event(xcb_generic_event_t *event, unsigned long *properties, int properties_size);
#endif

    void event(xcb_generic_event_t *event, NET::Properties *properties, NET::Properties2 *properties2 = nullptr);

    NET::Properties event(xcb_generic_event_t *event);

protected:
    virtual void addClient(xcb_window_t window)
    {
        Q_UNUSED(window);
    }

    virtual void removeClient(xcb_window_t window)
    {
        Q_UNUSED(window);
    }

    virtual void changeNumberOfDesktops(int numberOfDesktops)
    {
        Q_UNUSED(numberOfDesktops);
    }

    virtual void changeDesktopGeometry(int desktop, const NETSize &geom)
    {
        Q_UNUSED(desktop);
        Q_UNUSED(geom);
    }

    virtual void changeDesktopViewport(int desktop, const NETPoint &viewport)
    {
        Q_UNUSED(desktop);
        Q_UNUSED(viewport);
    }

    virtual void changeCurrentDesktop(int desktop)
    {
        Q_UNUSED(desktop);
    }

    virtual void closeWindow(xcb_window_t window)
    {
        Q_UNUSED(window);
    }

    virtual void moveResize(xcb_window_t window, int x_root, int y_root,
                            unsigned long direction)
    {
        Q_UNUSED(window);
        Q_UNUSED(x_root);
        Q_UNUSED(y_root);
        Q_UNUSED(direction);
    }

    virtual void gotPing(xcb_window_t window, xcb_timestamp_t timestamp)
    {
        Q_UNUSED(window);
        Q_UNUSED(timestamp);
    }
    virtual void changeActiveWindow(xcb_window_t window, NET::RequestSource src,
                                    xcb_timestamp_t timestamp, xcb_window_t active_window)
    {
        Q_UNUSED(window);
        Q_UNUSED(src);
        Q_UNUSED(timestamp);
        Q_UNUSED(active_window);
    }

    virtual void moveResizeWindow(xcb_window_t window, int flags, int x, int y, int width, int height)
    {
        Q_UNUSED(window);
        Q_UNUSED(flags);
        Q_UNUSED(x);
        Q_UNUSED(y);
        Q_UNUSED(width);
        Q_UNUSED(height);
    }

    virtual void restackWindow(xcb_window_t window, RequestSource source,
                               xcb_window_t above, int detail, xcb_timestamp_t timestamp)
    {
        Q_UNUSED(window);
        Q_UNUSED(source);
        Q_UNUSED(above);
        Q_UNUSED(detail);
        Q_UNUSED(timestamp);
    }

    virtual void changeShowingDesktop(bool showing)
    {
        Q_UNUSED(showing);
    }

private:
    void update(NET::Properties properties, NET::Properties2 properties2);
    void setSupported();
    void setDefaultProperties();
    void updateSupportedProperties(xcb_atom_t atom);

protected:
    virtual void virtual_hook(int id, void *data);
private:
    NETRootInfoPrivate *p; // krazy:exclude=dpointer (implicitly shared)
};

class KWINDOWSYSTEM_EXPORT NETWinInfo : public NET
{
public:
    // update also NETWinInfoPrivate::properties[] size when extending this
    enum { PROTOCOLS, PROTOCOLS2,
           PROPERTIES_SIZE
         };
    NETWinInfo(xcb_connection_t *connection, xcb_window_t window, xcb_window_t rootWindow,
               NET::Properties properties, NET::Properties2 properties2,
               Role role = Client);

#if KWINDOWSYSTEM_ENABLE_DEPRECATED_SINCE(5, 0)

    KWINDOWSYSTEM_DEPRECATED_VERSION(5, 0, "Use NETWinInfo(xcb_connection_t *, xcb_window_t, xcb_window_t, NET::Properties, NET::Properties2, Role")
    NETWinInfo(xcb_connection_t *connection, xcb_window_t window,
               xcb_window_t rootWindow, NET::Properties properties,
               Role role = Client);
#endif

    NETWinInfo(const NETWinInfo &wininfo);

    virtual ~NETWinInfo();

    const NETWinInfo &operator=(const NETWinInfo &wintinfo);

    xcb_connection_t *xcbConnection() const;

    bool hasNETSupport() const;

    NET::Properties passedProperties() const;
    NET::Properties2 passedProperties2() const;

    NETRect iconGeometry() const;

    NET::States state() const;

    NETExtendedStrut extendedStrut() const;

    // Still used internally, e.g. by KWindowSystem::strutChanged() logic
    NETStrut strut() const;

    WindowType windowType(WindowTypes supported_types) const;

    bool hasWindowType() const;

    const char *name() const;

    const char *visibleName() const;

    const char *iconName() const;

    const char *visibleIconName() const;

    int desktop(bool ignore_viewport = false) const;

    int pid() const;

    bool handledIcons() const;

    MappingState mappingState() const;

    void setIcon(NETIcon icon, bool replace = true);

    void setIconGeometry(NETRect geometry);

    void setExtendedStrut(const NETExtendedStrut &extended_strut);

    // Still used internally, e.g. by KWindowSystem::strutChanged() logic
    void setStrut(NETStrut strut);

    void setState(NET::States state, NET::States mask);

    void setWindowType(WindowType type);

    void setName(const char *name);

    void setVisibleName(const char *visibleName);

    void setIconName(const char *name);

    void setVisibleIconName(const char *name);

    void setDesktop(int desktop, bool ignore_viewport = false);

    void setPid(int pid);

    void setHandledIcons(bool handled);

    void setFrameExtents(NETStrut strut);

    NETStrut frameExtents() const;

    void setFrameOverlap(NETStrut strut);

    NETStrut frameOverlap() const;

    void setGtkFrameExtents(NETStrut strut);

    NETStrut gtkFrameExtents() const;

    NETIcon icon(int width = -1, int height = -1) const;

    const int *iconSizes() const;

    void setUserTime(xcb_timestamp_t time);

    xcb_timestamp_t userTime() const;

    void setStartupId(const char *startup_id);

    const char *startupId() const;

    void setOpacity(unsigned long opacity);

    unsigned long opacity() const;

    void setAllowedActions(NET::Actions actions);

    NET::Actions allowedActions() const;

    xcb_window_t transientFor() const;

    xcb_window_t groupLeader() const;

    bool urgency() const;

    bool input() const;

    MappingState initialMappingState() const;

    xcb_pixmap_t icccmIconPixmap() const;

    xcb_pixmap_t icccmIconPixmapMask() const;

    const char *windowClassClass() const;

    const char *windowClassName() const;

    const char *windowRole() const;

    const char *clientMachine() const;

    const char *activities() const;

    void setActivities(const char *activities);

    void setBlockingCompositing(bool active);

    bool isBlockingCompositing() const;

    void kdeGeometry(NETRect &frame, NETRect &window);

    void setFullscreenMonitors(NETFullscreenMonitors topology);

    NETFullscreenMonitors fullscreenMonitors() const;

#if KWINDOWSYSTEM_ENABLE_DEPRECATED_SINCE(5, 0)

    KWINDOWSYSTEM_DEPRECATED_VERSION(5, 0, "Use NETWinInfo::event(xcb_generic_event_t*, NET::Properties*, NET::Properties2*)")
    void event(xcb_generic_event_t *event, unsigned long *properties, int properties_size);
#endif

    void event(xcb_generic_event_t *event, NET::Properties *properties, NET::Properties2 *properties2 = nullptr);

    NET::Properties event(xcb_generic_event_t *event);

    NET::Protocols protocols() const;

    bool supportsProtocol(NET::Protocol protocol) const;

    std::vector<NETRect> opaqueRegion() const;

    void setDesktopFileName(const char *name);

    const char *desktopFileName() const;

    void setAppMenuServiceName(const char *name);

    void setAppMenuObjectPath(const char *path);

    const char *appMenuServiceName() const;

    const char *appMenuObjectPath() const;

    static const int OnAllDesktops;

protected:
    virtual void changeDesktop(int desktop)
    {
        Q_UNUSED(desktop);
    }

    virtual void changeState(NET::States state, NET::States mask)
    {
        Q_UNUSED(state);
        Q_UNUSED(mask);
    }

    virtual void changeFullscreenMonitors(NETFullscreenMonitors topology)
    {
        Q_UNUSED(topology);
    }

private:
    void update(NET::Properties dirtyProperties, NET::Properties2 dirtyProperties2 = NET::Properties2());
    void updateWMState();
    void setIconInternal(NETRArray<NETIcon> &icons, int &icon_count, xcb_atom_t property, NETIcon icon, bool replace);
    NETIcon iconInternal(NETRArray<NETIcon> &icons, int icon_count, int width, int height) const;

protected:
    virtual void virtual_hook(int id, void *data);
private:
    NETWinInfoPrivate *p; // krazy:exclude=dpointer (implicitly shared)
};

//#define KWIN_FOCUS

#endif
#endif // netwm_h