#ifndef __client_hh
#define __client_hh
+/*! @file client.hh
+ @brief The OBClient class maintains the state of a client window by handling
+ property changes on the window and some client messages
+*/
+
extern "C" {
#include <X11/Xlib.h>
+
+#ifdef SHAPE
+#include <X11/extensions/shape.h>
+#endif // SHAPE
}
#include <string>
+#include "otk/point.hh"
#include "otk/strut.hh"
#include "otk/rect.hh"
+#include "otk/eventhandler.hh"
namespace ob {
+class OBFrame;
+
//! Maintains the state of a client window.
/*!
OBClient maintains the state of a client window. The state consists of the
class' member variables and call whatever is nessary to complete the
change (such as causing a redraw of the titlebar after the title is changed).
*/
-class OBClient {
+class OBClient : public otk::OtkEventHandler {
public:
+
+ //! The frame window which decorates around the client window
+ /*!
+ NOTE: This should NEVER be used inside the client class's constructor!
+ */
+ OBFrame *frame;
+
+ //! Corners of the client window, used for anchor positions
+ enum Corner { TopLeft,
+ TopRight,
+ BottomLeft,
+ BottomRight };
+
//! Possible window types
enum WindowType { Type_Desktop, //!< A desktop (bottom-most window)
Type_Dock, //!< A dock bar/panel window
Decor_Border = 1 << 2, //!< Display a border
Decor_Iconify = 1 << 3, //!< Display an iconify button
Decor_Maximize = 1 << 4, //!< Display a maximize button
- Decor_Close = 1 << 5 //!< Display a close button
+ Decor_Sticky = 1 << 5, //!< Display a sticky button
+ Decor_Close = 1 << 6 //!< Display a close button
};
//! Holds a bitmask of OBClient::Decoration values
typedef unsigned char DecorationFlags;
State_Toggle //!< _NET_WM_STATE_TOGGLE
};
+ //! The event mask to grab on client windows
+ static const long event_mask = PropertyChangeMask | FocusChangeMask |
+ StructureNotifyMask;
+
+ //! The number of unmap events to ignore on the window
+ int ignore_unmaps;
+
private:
+ //! The screen number on which the client resides
+ int _screen;
+
//! The actual window that this class is wrapping up
Window _window;
//! The type of window (what its function is)
WindowType _type;
- //! Position and size of the window (relative to the root window)
+ //! Position and size of the window
+ /*!
+ This will not always be the actual position of the window on screen, it is
+ rather, the position requested by the client, to which the window's gravity
+ is applied.
+ */
otk::Rect _area;
+ //! The logical size of the window
+ /*!
+ The "logical" size of the window is refers to the user's perception of the
+ size of the window, and is the value that should be displayed to the user.
+ For example, with xterms, this value it the number of characters being
+ displayed in the terminal, instead of the number of pixels.
+ */
+ otk::Point _logical_size;
+
//! Width of the border on the window.
/*!
The window manager will set this to 0 while the window is being managed,
*/
int _border_width;
- //! The minimum width of the client window
+ //! The minimum size of the client window
/*!
If the min is > the max, then the window is not resizable
*/
- int _min_x;
- //! The minimum height of the client window
+ otk::Point _min_size;
+ //! The maximum size of the client window
/*!
If the min is > the max, then the window is not resizable
*/
- int _min_y;
- //! The maximum width of the client window
+ otk::Point _max_size;
+ //! The size of increments to resize the client window by
+ otk::Point _size_inc;
+ //! The base size of the client window
/*!
- If the min is > the max, then the window is not resizable
- */
- int _max_x;
- //! The maximum height of the client window
- /*!
- If the min is > the max, then the window is not resizable
+ This value should be subtracted from the window's actual size when
+ displaying its size to the user, or working with its min/max size
*/
- int _max_y;
- //! The size of increments to resize the client window by (for the width)
- int _inc_x;
- //! The size of increments to resize the client window by (for the height)
- int _inc_y;
- //! The base width of the client window
- /*!
- This value should be subtracted from the window's actual width when
- displaying its size to the user, or working with its min/max width
- */
- int _base_x;
- //! The base height of the client window
- /*!
- This value should be subtracted from the window's actual height when
- displaying its size to the user, or working with its min/max height
- */
- int _base_y;
+ otk::Point _base_size;
//! Where to place the decorated window in relation to the undecorated window
int _gravity;
void updateClass();
// XXX: updateTransientFor();
+ //! Move the client window
+ void move(int x, int y);
+
+ //! Resizes the client window, anchoring it in a given corner
+ /*!
+ This also maintains things like the client's minsize, and size increments.
+ @param anchor The corner to keep in the same position when resizing
+ @param x The X component of the new size for the client
+ @param y The Y component of the new size for the client
+ */
+ void resize(Corner anchor, int x, int y);
+
public:
- OBClient(Window window);
+ //! Constructs a new OBClient object around a specified window id
+ /*!
+ @param window The window id that the OBClient class should handle
+ @param screen The screen on which the window resides
+ */
+ OBClient(int screen, Window window);
+ //! Destroys the OBClient object
virtual ~OBClient();
+ //! Returns the screen on which the clien resides
+ inline int screen() const { return _screen; }
+
+ //! Returns the window id that the OBClient object is handling
inline Window window() const { return _window; }
+ //! Returns the type of the window, one of the OBClient::WindowType values
inline WindowType type() const { return _type; }
+ //! Returns the desktop on which the window resides
+ /*!
+ This value is a 0-based index.<br>
+ A value of 0xffffffff indicates that the window exists on all desktops.
+ */
inline unsigned long desktop() const { return _desktop; }
+ //! Returns the window's title
inline const std::string &title() const { return _title; }
+ //! Returns the window's title when it is iconified
inline const std::string &iconTitle() const { return _title; }
+ //! Returns the application's name to whom the window belongs
inline const std::string &appName() const { return _app_name; }
+ //! Returns the class of the window
inline const std::string &appClass() const { return _app_class; }
+ //! Returns if the window can be focused
+ /*!
+ @return true if the window can receive focusl otherwise, false
+ */
inline bool canFocus() const { return _can_focus; }
+ //! Returns if the window has indicated that it needs urgent attention
inline bool urgent() const { return _urgent; }
+ //! Returns if the window wants to be notified when it receives focus
inline bool focusNotify() const { return _focus_notify; }
+ //! Returns if the window uses the Shape extension
inline bool shaped() const { return _shaped; }
+ //! Returns the window's gravity
+ /*!
+ This value determines where to place the decorated window in relation to
+ its position without decorations.<br>
+ One of: NorthWestGravity, SouthWestGravity, EastGravity, ...,
+ SouthGravity, StaticGravity, ForgetGravity
+ */
inline int gravity() const { return _gravity; }
+ //! Returns if the application requested the initial position for the window
+ /*!
+ If the application did not request a position (this function returns false)
+ then the window should be placed intelligently by the window manager
+ initially
+ */
inline bool positionRequested() const { return _positioned; }
+ //! Returns the decorations that the client window wishes to be displayed on
+ //! it
inline DecorationFlags decorations() const { return _decorations; }
+ //! Returns the functions that the user can perform on the window
inline FunctionFlags funtions() const { return _functions; }
- // states
+ //! Returns if the window is modal
+ /*!
+ If the window is modal, then no other windows that it is related to can get
+ focus while it exists/remains modal.
+ */
inline bool modal() const { return _modal; }
+ //! Returns if the window is shaded
+ /*!
+ When the window is shaded, only its titlebar is visible, the client itself
+ is not mapped
+ */
inline bool shaded() const { return _shaded; }
+ //! Returns if the window is iconified
+ /*!
+ When the window is iconified, it is not visible at all (except in iconbars/
+ panels/etc that want to show lists of iconified windows
+ */
inline bool iconic() const { return _iconic; }
+ //! Returns if the window is maximized vertically
inline bool maxVert() const { return _max_vert; }
+ //! Returns if the window is maximized horizontally
inline bool maxHorz() const { return _max_horz; }
+ //! Returns if the window is fullscreen
+ /*!
+ When the window is fullscreen, it is kept above all others
+ */
inline bool fullscreen() const { return _fullscreen; }
+ //! Returns if the window is floating
+ /*!
+ When the window is floating, it is kept above all others in the same
+ stacking layer as it
+ */
inline bool floating() const { return _floating; }
- inline int borderWidth() const { return _border_width; }
- inline int minX() const { return _min_x; }
- inline int minY() const { return _min_y; }
- inline int maxX() const { return _max_x; }
- inline int maxY() const { return _max_y; }
- inline int incrementX() const { return _inc_x; }
- inline int incrementY() const { return _inc_y; }
- inline int baseX() const { return _base_x; }
- inline int baseY() const { return _base_y; }
+ //! Removes or reapplies the client's border to its window
+ /*!
+ Used when managing and unmanaging a window.
+ @param addborder true if adding the border to the client; false if removing
+ from the client
+ */
+ void toggleClientBorder(bool addborder);
+ //! Returns the position and size of the client relative to the root window
inline const otk::Rect &area() const { return _area; }
- void update(const XPropertyEvent &e);
- void update(const XClientMessageEvent &e);
-
- void setArea(const otk::Rect &area);
+ virtual void propertyHandler(const XPropertyEvent &e);
+ virtual void clientMessageHandler(const XClientMessageEvent &e);
+ virtual void shapeHandler(const XShapeEvent &e);
+ virtual void configureRequestHandler(const XConfigureRequestEvent &e);
+ virtual void unmapHandler(const XUnmapEvent &e);
+ virtual void destroyHandler(const XDestroyWindowEvent &e);
};
}