property changes on the window and some client messages
*/
+#include "widgetbase.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 {
class OBFrame;
+//! The MWM Hints as retrieved from the window property
+/*!
+ This structure only contains 3 elements, even though the Motif 2.0
+ structure contains 5. We only use the first 3, so that is all gets defined.
+*/
+struct MwmHints {
+ 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,
//! Holds a bitmask of OBClient::Decoration values
typedef unsigned char DecorationFlags;
- //! The MWM Hints as retrieved from the window property
- /*!
- This structure only contains 3 elements, even though the Motif 2.0
- structure contains 5. We only use the first 3, so that is all gets defined.
- */
- typedef 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
- };
-
//! Possible actions that can be made with the _NET_WM_STATE client message
enum StateAction { State_Remove = 0, //!< _NET_WM_STATE_REMOVE
State_Add, //!< _NET_WM_STATE_ADD
static const long event_mask = PropertyChangeMask | FocusChangeMask |
StructureNotifyMask;
+ //! The mask of events to not let propogate past the client
+ /*!
+ This makes things like xprop work on the client window, but means we have
+ to explicitly grab clicks that we want.
+ */
+ static const long no_propagate_mask = ButtonPressMask | ButtonReleaseMask |
+ ButtonMotionMask;
+
//! The number of unmap events to ignore on the window
int ignore_unmaps;
//! 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;
+ long _desktop;
//! Normal window title
std::string _title; // XXX: Have to keep track if this string is Utf8 or not
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
- void setDesktop(long desktop);
//! Adjusts the window's net_state
void setState(StateAction action, long data1, long data2);
+ //! Sends the window to the specified desktop
+ void setDesktop(long desktop);
+
+ //! 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();
- //! Move the client window
- void move(int x, int y);
-
- //! Resizes the client window, anchoring it in a given corner
+ //! Change the client's state hints to match the class' data
+ void changeState();
+
+ //! Request the client to close its window.
+ void close();
+
+ //! Shades or unshades the client window
/*!
- 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 shade true if the window should be shaded; false if it should be
+ unshaded.
*/
- void resize(Corner anchor, int x, int y);
+ void shade(bool shade);
public:
+#ifndef SWIG
//! Constructs a new OBClient object around a specified window id
/*!
- @param window The window id that the OBClient class should handle
+BB @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();
+#endif
//! Returns the screen on which the clien resides
inline int screen() const { return _screen; }
//! 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>
A value of 0xffffffff indicates that the window exists on all desktops.
*/
- inline unsigned long desktop() const { return _desktop; }
+ inline 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 &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 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
+ When the window is shaded, only its titlebar is visible.
*/
inline bool shaded() const { return _shaded; }
//! Returns if the window is iconified
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 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 w, int h, int x = INT_MIN, int y = INT_MIN);
+
+ //! Attempt to focus the client window
+ bool focus() const;
+
+ //! Remove focus from the client window
+ void unfocus() const;
+
+ 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);
+#if defined(SHAPE)
+ virtual void shapeHandler(const XShapeEvent &e);
+#endif // SHAPE
};
}
projects / chaz / openbox / blobdiff