netwm.h

/*

  Copyright (c) 2000 Troll Tech AS
  Copyright (c) 2003 Lubos Lunak <[email protected]>

  Permission is hereby granted, free of charge, to any person obtaining a
  copy of this software and associated documentation files (the "Software"),
  to deal in the Software without restriction, including without limitation
  the rights to use, copy, modify, merge, publish, distribute, sublicense,
  and/or sell copies of the Software, and to permit persons to whom the
  Software is furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  DEALINGS IN THE SOFTWARE.

*/

#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;

    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