netwm.h

Go to the documentation of this file.

/*

  Copyright (c) 2000 Troll Tech AS
  Copyright (c) 2003 Lubos Lunak <l.lunak@kde.org>

  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 <kdeui_export.h>
#include <QtGui/QWidget>
#ifdef Q_WS_X11
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <fixx11h.h>

#include "netwm_def.h"

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


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

    NETRootInfo(Display *display, Window supportWindow, const char *wmName,
        const unsigned long properties[], int properties_size,
                int screen = -1, bool doActivate = true);


    NETRootInfo(Display *display, const unsigned long properties[], int properties_size,
                int screen = -1, bool doActivate = true);

    NETRootInfo(Display *display, unsigned long properties, int screen = -1,
        bool doActivate = true);

    NETRootInfo(const NETRootInfo &rootinfo);

    virtual ~NETRootInfo();

    Display *x11Display() const;

    Window rootWindow() const;

    Window supportWindow() const;

    const char *wmName() const;

    int screenNumber() const;

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

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

    void setSupported( NET::WindowType 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::WindowType type ) const;
    bool isSupported( NET::State state ) const;

    bool isSupported( NET::Action action ) const;

    const unsigned long* supportedProperties() const;

    const unsigned long* passedProperties() const;

    const Window *clientList() const;

    int clientListCount() const;

    const Window *clientListStacking() const;

    int clientListStackingCount() const;

    NETSize desktopGeometry(int desktop) const;

    NETPoint desktopViewport(int desktop) const;

    NETRect workArea(int desktop) const;

    const char *desktopName(int desktop) const;

    const Window *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;

    Window activeWindow() const;

    void activate();

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

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

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

    void setDesktopGeometry(int desktop, const NETSize &geometry);

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

    void setNumberOfDesktops(int numberOfDesktops);

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

    void setActiveWindow(Window window, NET::RequestSource src,
        Time timestamp, Window active_window);

    void setActiveWindow(Window window);

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

    void setVirtualRoots(const Window *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(Window window);

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

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

    void restackRequest(Window window, RequestSource source, Window above, int detail, Time timestamp);

    void sendPing( Window window, Time timestamp );

    void takeActivity( Window window, Time timestamp, long flags );

    void event( XEvent* event, unsigned long* properties, int properties_size );

    unsigned long event(XEvent *event);


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

    virtual void removeClient(Window 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(Window window) { Q_UNUSED(window); }

    virtual void moveResize(Window 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( Window window, Time timestamp ) { Q_UNUSED(window); Q_UNUSED(timestamp); }
    virtual void changeActiveWindow(Window window,NET::RequestSource src,
        Time timestamp, Window active_window ) { Q_UNUSED(window); Q_UNUSED(src); Q_UNUSED(timestamp); Q_UNUSED(active_window);}

    virtual void moveResizeWindow(Window 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(Window window, RequestSource source,
           Window above, int detail, Time timestamp) { Q_UNUSED(window); Q_UNUSED(source); Q_UNUSED(above); Q_UNUSED(detail); Q_UNUSED(timestamp); }
    virtual void gotTakeActivity(Window window, Time timestamp, long flags ) { Q_UNUSED(window); Q_UNUSED(timestamp); Q_UNUSED(flags); }

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

private:
    void update( const unsigned long[] );
    void setSupported();
    void setDefaultProperties();
    void updateSupportedProperties( Atom atom );

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

class KDEUI_EXPORT NETWinInfo : public NET {
public:
    // update also NETWinInfoPrivate::properties[] size when extending this
    enum { PROTOCOLS, PROTOCOLS2,
        PROPERTIES_SIZE };
    NETWinInfo(Display *display, Window window, Window rootWindow,
               const unsigned long properties[], int properties_size,
           Role role = Client);

    NETWinInfo(Display *display, Window window,
           Window rootWindow, unsigned long properties,
           Role role = Client);

    NETWinInfo(const NETWinInfo & wininfo);

    virtual ~NETWinInfo();

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

    bool hasNETSupport() const;

    const unsigned long* passedProperties() const;

    NETRect iconGeometry() const;

    unsigned long state() const;

    NETExtendedStrut extendedStrut() const;

    NETStrut strut() const;

    WindowType windowType( unsigned long 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 );

    void setStrut(NETStrut strut);

    void setState(unsigned long state, unsigned long 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;

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

    void setUserTime( Time time );

    Time userTime() const;

    void setStartupId( const char* startup_id );

    const char* startupId() const;

    void setOpacity( unsigned long opacity );

    unsigned long opacity() const;

    void setAllowedActions( unsigned long actions );

    unsigned long allowedActions() const;

    Window transientFor() const;

    Window groupLeader() const;

    const char* windowClassClass() const;

    const char* windowClassName() const;

    const char* windowRole() const;

    const char* clientMachine() const;

    const char* activities() const;


    void setBlockingCompositing(bool active);

    bool isBlockingCompositing() const;

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

    void event( XEvent* event, unsigned long* properties, int properties_size );

    unsigned long event(XEvent *event);

    static const int OnAllDesktops;

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

    virtual void changeState(unsigned long state, unsigned long mask) { Q_UNUSED(state); Q_UNUSED(mask); }

private:
    void update( const unsigned long[] );
    void updateWMState();
    void setIconInternal(NETRArray<NETIcon>& icons, int& icon_count, Atom 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)
    friend class NETWinInfo2;
};


class KDEUI_EXPORT NETWinInfo2 : public NETWinInfo {
public:
    NETWinInfo2(Display *display, Window window, Window rootWindow,
                const unsigned long properties[], int properties_size,
                Role role = Client);

    NETWinInfo2(Display *display, Window window,
                Window rootWindow, unsigned long properties,
                Role role = Client);

    void setFullscreenMonitors(NETFullscreenMonitors topology);

    NETFullscreenMonitors fullscreenMonitors() const;

protected:
    friend class NETWinInfo;
    virtual void changeFullscreenMonitors(NETFullscreenMonitors topology) { Q_UNUSED(topology); }
};

//#define KWIN_FOCUS

#endif
#endif // netwm_h