#define __client_hh
/*! @file client.hh
- @brief The OBClient class maintains the state of a client window by handling
+ @brief The Client class maintains the state of a client window by handling
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"
+#include "otk/ustring.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;
+class Frame;
+
+//! 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 Client::MwmFlags values
+ unsigned long functions; //!< A bitmask of Client::MwmFunctions values
+ unsigned long decorations;//!< A bitmask of Client::MwmDecorations values
+ //! The number of elements in the Client::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
+ Client maintains the state of a client window. The state consists of the
hints that the application sets on the window, such as the title, or window
gravity.
<p>
- OBClient also manages client messages for the client window. When the
+ Client also manages client messages for the client window. When the
application (or any application) requests something to be changed for the
client, it will call the ActionHandler (for client messages) or update 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 : public otk::OtkEventHandler, public OBWidget {
+class Client : public otk::EventHandler, public WidgetBase {
public:
//! The frame window which decorates around the client window
/*!
NOTE: This should NEVER be used inside the client class's constructor!
*/
- OBFrame *frame;
+ Frame *frame;
+
+ //! Holds a list of Clients
+ typedef std::list<Client*> 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,
Func_Maximize = 1 << 3, //!< Allow to be maximized
Func_Close = 1 << 4 //!< Allow to be closed
};
- //! Holds a bitmask of OBClient::Function values
+ //! Holds a bitmask of Client::Function values
typedef unsigned char FunctionFlags;
//! The decorations the client window wants to be displayed on it
Decor_Sticky = 1 << 5, //!< Display a sticky button
Decor_Close = 1 << 6 //!< Display a close button
};
- //! Holds a bitmask of OBClient::Decoration values
+ //! Holds a bitmask of Client::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
+ Client *_transient_for;
+
+ //! The clients which are transients (children) of this client
+ Client::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
+ otk::ustring _title;
//! Window title when iconifiged
- std::string _icon_title;
+ otk::ustring _icon_title;
//! The application that created the window
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
+ //! A bitmask of values in the Client::Decoration enum
/*!
The values in the variable are the decorations that the client wants to be
displayed around it.
*/
DecorationFlags _decorations;
- //! A bitmask of values in the OBClient::Function enum
+ //! A bitmask of values in the Client::Function enum
/*!
The values in the variable specify the ways in which the user is allowed to
modify this window.
*/
FunctionFlags _functions;
- //! Retrieves the desktop hint's value and sets OBClient::_desktop
+ //! Retrieves the window's initial gravity
+ void getGravity();
+ //! Retrieves the desktop hint's value and sets Client::_desktop
void getDesktop();
- //! Retrieves the window's type and sets OBClient::_type
+ //! Retrieves the window's type and sets Client::_type
void getType();
- //! Gets the MWM Hints and adjusts OBClient::_functions and
- //! OBClient::_decorations
+ //! Gets the MWM Hints and adjusts Client::_functions and
+ //! Client::_decorations
void getMwmHints();
- //! Gets the position and size of the window and sets OBClient::_area
+ //! Gets the position and size of the window and sets Client::_area
void getArea();
//! Gets the net_state hint and sets the boolean flags for any states set in
//! the hint
void getState();
//! Determines if the window uses the Shape extension and sets
- //! OBClient::_shaped
+ //! Client::_shaped
void getShaped();
+ //! Set up what decor should be shown on the window and what functions should
+ //! be allowed (Client::_decorations and Client::_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:
- //! Constructs a new OBClient object around a specified window id
+#ifndef SWIG
+ //! Constructs a new Client 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 Client class should handle
@param screen The screen on which the window resides
*/
- OBClient(int screen, Window window);
- //! Destroys the OBClient object
- virtual ~OBClient();
+ Client(int screen, Window window);
+ //! Destroys the Client object
+ virtual ~Client();
+#endif
//! Returns the screen on which the clien resides
inline int screen() const { return _screen; }
- //! Returns the window id that the OBClient object is handling
+ //! Returns the window id that the Client object is handling
inline Window window() const { return _window; }
- //! Returns the type of the window, one of the OBClient::WindowType values
+ //! Returns the type of the window, one of the Client::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; }
+ inline const otk::ustring &title() const { return _title; }
//! Returns the window's title when it is iconified
- inline const std::string &iconTitle() const { return _title; }
+ inline const otk::ustring &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 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 Client *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
+ /*!
+ @param x The X coordinate to move to.
+ @param y The Y coordinate to move to.
+ */
+ 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