property changes on the window and some client messages
*/
+#include "widget.hh"
+#include "otk/point.hh"
+#include "otk/strut.hh"
+#include "otk/rect.hh"
+#include "otk/eventhandler.hh"
+
extern "C" {
#include <X11/Xlib.h>
}
#include <string>
-
-#include "otk/point.hh"
-#include "otk/strut.hh"
-#include "otk/rect.hh"
-#include "otk/eventhandler.hh"
-#include "widget.hh"
+#include <list>
namespace ob {
structure contains 5. We only use the first 3, so that is all gets defined.
*/
struct MwmHints {
- //! The number of elements in the OBClient::MwmHints struct
- static const unsigned int elements = 3;
unsigned long flags; //!< A bitmask of OBClient::MwmFlags values
unsigned long functions; //!< A bitmask of OBClient::MwmFunctions values
unsigned long decorations;//!< A bitmask of OBClient::MwmDecorations values
+ //! The number of elements in the OBClient::MwmHints struct
+ static const unsigned int elements = 3;
};
-
//! Maintains the state of a client window.
/*!
OBClient maintains the state of a client window. The state consists of the
*/
OBFrame *frame;
+ //! Holds a list of OBClients
+ typedef std::list<OBClient*> List;
+
+ //! The possible stacking layers a client window can be a part of
+ enum StackLayer {
+ Layer_Icon, //!< 0 - iconified windows, in any order at all
+ Layer_Desktop, //!< 1 - desktop windows
+ Layer_Below, //!< 2 - normal windows w/ below
+ Layer_Normal, //!< 3 - normal windows
+ Layer_Above, //!< 4 - normal windows w/ above
+ Layer_Top, //!< 5 - always-on-top-windows (docks?)
+ Layer_Fullscreen, //!< 6 - fullscreeen windows
+ Layer_Internal, //!< 7 - openbox windows/menus
+ NUM_LAYERS
+ };
+
//! Corners of the client window, used for anchor positions
enum Corner { TopLeft,
TopRight,
//! The id of the group the window belongs to
Window _group;
- // XXX: transient_for, transients
+ //! The client which this client is a transient (child) for
+ OBClient *_transient_for;
+
+ //! The clients which are transients (children) of this client
+ OBClient::List _transients;
//! The desktop on which the window resides (0xffffffff for all desktops)
unsigned long _desktop;
std::string _app_name;
//! The class of the window, can used for grouping
std::string _app_class;
+ //! The specified role of the window, used for identification
+ std::string _role;
//! The type of window (what its function is)
WindowType _type;
*/
otk::Rect _area;
+ //! The window's strut
+ /*!
+ The strut defines areas of the screen that are marked off-bounds for window
+ placement. In theory, where this window exists.
+ */
+ otk::Strut _strut;
+
//! The logical size of the window
/*!
The "logical" size of the window is refers to the user's perception of the
*/
otk::Point _base_size;
+ //! Window decoration and functionality hints
+ MwmHints _mwmhints;
+
//! Where to place the decorated window in relation to the undecorated window
int _gravity;
bool _urgent;
//! Notify the window when it receives focus?
bool _focus_notify;
+ //! Does the client window have the input focus?
+ bool _focused;
//! The window uses shape extension to be non-rectangular?
bool _shaped;
bool _max_vert;
//! The window is maximized to fill the screen horizontally
bool _max_horz;
+ //! The window should not be displayed by pagers
+ bool _skip_pager;
+ //! The window should not be displayed by taskbars
+ bool _skip_taskbar;
//! The window is a 'fullscreen' window, and should be on top of all others
bool _fullscreen;
//! The window should be on top of other windows of the same type
- bool _floating;
+ bool _above;
+ //! The window should be underneath other windows of the same type
+ bool _below;
+
+ StackLayer _layer;
//! A bitmask of values in the OBClient::Decoration enum
/*!
//! OBClient::_shaped
void getShaped();
+ //! Set up what decor should be shown on the window and what functions should
+ //! be allowed (OBClient::_decorations and OBClient::_functions).
+ /*!
+ This also updates the NET_WM_ALLOWED_ACTIONS hint.
+ */
+ void setupDecorAndFunctions();
+
//! Sets the wm_state to the specified value
void setWMState(long state);
//! Sends the window to the specified desktop
//! Adjusts the window's net_state
void setState(StateAction action, long data1, long data2);
+ //! Calculates the stacking layer for the client window
+ void calcLayer();
+
//! Update the protocols that the window supports and adjusts things if they
//! change
void updateProtocols();
void updateIconTitle();
//! Updates the window's application name and class
void updateClass();
- // XXX: updateTransientFor();
+ //! Updates the strut for the client
+ void updateStrut();
+ //! Updates the window's transient status, and any parents of it
+ void updateTransientFor();
+ //! Change the client's state hints to match the class' data
+ void changeState();
+
public:
#ifndef SWIG
//! Constructs a new OBClient object around a specified window id
//! Returns the type of the window, one of the OBClient::WindowType values
inline WindowType type() const { return _type; }
+ //! Returns if the window should be treated as a normal window.
+ /*!
+ Some windows (desktops, docks, splash screens) have special rules applied
+ to them in a number of places regarding focus or user interaction.
+ */
+ inline bool normal() const {
+ return ! (_type == Type_Desktop || _type == Type_Dock ||
+ _type == Type_Splash);
+ }
+
//! Returns the desktop on which the window resides
/*!
This value is a 0-based index.<br>
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 the program-specified role of the window
+ inline const std::string &role() const { return _role; }
//! Returns if the window can be focused
/*!
- @return true if the window can receive focusl otherwise, false
+ @return true if the window can receive focus; otherwise, false
*/
inline bool canFocus() const { return _can_focus; }
//! Returns if the window has indicated that it needs urgent attention
//! Returns the functions that the user can perform on the window
inline FunctionFlags funtions() const { return _functions; }
+ //! Return the client this window is transient for
+ inline OBClient *transientFor() const { return _transient_for; }
+
//! Returns if the window is modal
/*!
If the window is modal, then no other windows that it is related to can get
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; }
+ //! Returns the window's stacking layer
+ inline StackLayer layer() const { return _layer; }
//! Removes or reapplies the client's border to its window
/*!
//! Returns the position and size of the client relative to the root window
inline const otk::Rect &area() const { return _area; }
+ //! Returns the client's strut definition
+ inline const otk::Strut &strut() const { return _strut; }
+
//! 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
+ @param anchor The corner to keep in the same position when resizing.
+ @param w The width component of the new size for the client.
+ @param h The height component of the new size for the client.
+ @param x An optional X coordinate to which the window will be moved
+ after resizing.
+ @param y An optional Y coordinate to which the window will be moved
+ after resizing.
+ The x and y coordinates must both be sepcified together, or they will have
+ no effect. When they are specified, the anchor is ignored.
*/
- void resize(Corner anchor, int x, int y);
+ void resize(Corner anchor, int w, int h, int x = INT_MIN, int y = INT_MIN);
//! Request the client to close its window.
void close();
+
+ //! Sets the window's stacking layer
+ /*!
+ @param l An integer specifying the layer.<br>
+ '0' - the normal layer<br>
+ '> 0' - the 'above' layer<br>
+ '< 0' - the 'below' layer
+ */
+ void setStackLayer(int l);
+
+ //! Shades or unshades the client window
+ /*!
+ @param shade true if the window should be shaded; false if it should be
+ unshaded.
+ */
+ void shade(bool shade);
+ //! Attempt to focus the client window
+ bool focus();
+
+ //! Remove focus from the client window
+ void unfocus();
+
+ virtual void focusHandler(const XFocusChangeEvent &e);
+ virtual void unfocusHandler(const XFocusChangeEvent &e);
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);
+ virtual void reparentHandler(const XReparentEvent &e);
+ virtual void mapRequestHandler(const XMapRequestEvent &e);
+#if defined(SHAPE)
+ virtual void shapeHandler(const XShapeEvent &e);
+#endif // SHAPE
};
}