property changes on the window and some client messages
*/
-#include "widgetbase.hh"
-#include "otk/point.hh"
+#include "screen.hh"
#include "otk/strut.hh"
#include "otk/rect.hh"
#include "otk/eventhandler.hh"
+#include "otk/ustring.hh"
extern "C" {
#include <X11/Xlib.h>
namespace ob {
class Frame;
+class Screen;
+
+struct Icon {
+ unsigned long w, h;
+ unsigned long *data;
+};
//! The MWM Hints as retrieved from the window property
/*!
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 Client : public otk::EventHandler, public WidgetBase {
+class Client : public otk::EventHandler {
public:
//! The frame window which decorates around the client window
enum WindowType { Type_Desktop, //!< A desktop (bottom-most window)
Type_Dock, //!< A dock bar/panel window
Type_Toolbar, //!< A toolbar window, pulled off an app
- Type_Menu, //!< A sticky menu from an app
+ Type_Menu, //!< An unpinned menu from an app
Type_Utility, //!< A small utility window such as a palette
Type_Splash, //!< A splash screen window
Type_Dialog, //!< A dialog window
};
//! The things the user can do to the client window
- enum Function { Func_Resize = 1 << 0, //!< Allow resizing
- Func_Move = 1 << 1, //!< Allow moving
- Func_Iconify = 1 << 2, //!< Allow to be iconified
- Func_Maximize = 1 << 3, //!< Allow to be maximized
- Func_Close = 1 << 4 //!< Allow to be closed
+ enum Function { Func_Resize = 1 << 0, //!< Allow resizing
+ Func_Move = 1 << 1, //!< Allow moving
+ Func_Iconify = 1 << 2, //!< Allow to be iconified
+ Func_Maximize = 1 << 3, //!< Allow to be maximized
+ Func_Shade = 1 << 4, //!< Allow to be shaded
+ Func_Fullscreen = 1 << 5, //!< Allow to be made fullscreen
+ Func_Close = 1 << 6 //!< Allow to be closed
};
//! Holds a bitmask of Client::Function values
typedef unsigned char FunctionFlags;
//! The decorations the client window wants to be displayed on it
- enum Decoration { Decor_Titlebar = 1 << 0, //!< Display a titlebar
- Decor_Handle = 1 << 1, //!< Display a handle (bottom)
- Decor_Border = 1 << 2, //!< Display a border
- Decor_Iconify = 1 << 3, //!< Display an iconify button
- Decor_Maximize = 1 << 4, //!< Display a maximize button
- Decor_Sticky = 1 << 5, //!< Display a sticky button
- Decor_Close = 1 << 6 //!< Display a close button
+ enum Decoration { Decor_Titlebar = 1 << 0, //!< Display a titlebar
+ Decor_Handle = 1 << 1, //!< Display a handle (bottom)
+ Decor_Border = 1 << 2, //!< Display a border
+ Decor_Icon = 1 << 3, //!< Display the window's icon
+ Decor_Iconify = 1 << 4, //!< Display an iconify button
+ Decor_Maximize = 1 << 5, //!< Display a maximize button
+ //! Display a button to toggle the window's placement on
+ //! all desktops
+ Decor_AllDesktops = 1 << 6,
+ Decor_Close = 1 << 7 //!< Display a close button
};
//! Holds a bitmask of Client::Decoration values
typedef unsigned char DecorationFlags;
- //! 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
- State_Toggle //!< _NET_WM_STATE_TOGGLE
- };
-
//! The event mask to grab on client windows
static const long event_mask = PropertyChangeMask | FocusChangeMask |
StructureNotifyMask;
Client::List _transients;
//! The desktop on which the window resides (0xffffffff for all desktops)
- long _desktop;
+ unsigned int _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;
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;
+ otk::Size _logical_size;
//! Width of the border on the window.
/*!
*/
int _border_width;
+ //! The minimum aspect ratio the client window can be sized to.
+ /*!
+ A value of 0 means this is ignored.
+ */
+ float _min_ratio;
+ //! The maximum aspect ratio the client window can be sized to.
+ /*!
+ A value of 0 means this is ignored.
+ */
+ float _max_ratio;
+
//! The minimum size of the client window
/*!
If the min is > the max, then the window is not resizable
*/
- otk::Point _min_size;
+ otk::Size _min_size;
//! The maximum size of the client window
/*!
If the min is > the max, then the window is not resizable
*/
- otk::Point _max_size;
+ otk::Size _max_size;
//! The size of increments to resize the client window by
- otk::Point _size_inc;
+ otk::Size _size_inc;
//! The base size of the client window
/*!
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
*/
- otk::Point _base_size;
+ otk::Size _base_size;
//! Window decoration and functionality hints
MwmHints _mwmhints;
//! NormalState
long _wmstate;
+ //! True if the client supports the delete_window protocol
+ bool _delete_window;
+
//! Was the window's position requested by the application? if not, we should
//! place the window ourselves when it first appears
bool _positioned;
//! The window should be underneath other windows of the same type
bool _below;
+ //! The layer in which the window will be stacked, windows in lower layers
+ //! are always below windows in higher layers.
StackLayer _layer;
//! A bitmask of values in the Client::Decoration enum
*/
DecorationFlags _decorations;
+ //! A bitmask of values in the Client::Decoration enum.
+ /*!
+ Specifies the decorations that should NOT be displayed on the client.
+ */
+ DecorationFlags _disabled_decorations;
+
//! A bitmask of values in the Client::Function enum
/*!
The values in the variable specify the ways in which the user is allowed to
*/
FunctionFlags _functions;
+ //! Icons for the client as specified on the client window
+ Icon *_icons;
+ //! The number of icons in _icons
+ int _nicons;
+
+ Pixmap _pixmap_icon;
+ Pixmap _pixmap_icon_mask;
+
+ //! 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 Client::_type
//! Sets the wm_state to the specified value
void setWMState(long state);
//! Adjusts the window's net_state
- void setState(StateAction action, long data1, long data2);
+ /*!
+ This should not be called as part of the window mapping process! It is for
+ use when updating the state post-mapping.<br>
+ Client::applyStartupState is used to do the same things during the mapping
+ process.
+ */
+ void setState(Atom action, long data1, long data2);
//! Sends the window to the specified desktop
- void setDesktop(long desktop);
+ void setDesktop(unsigned int desktop);
//! Calculates the stacking layer for the client window
void calcLayer();
//! Updates the WMNormalHints and adjusts things if they change
void updateNormalHints();
//! Updates the WMHints and adjusts things if they change
- void updateWMHints();
+ /*!
+ @param initstate Whether to read the initial_state property from the
+ WMHints. This should only be used during the mapping
+ process.
+ */
+ void updateWMHints(bool initstate = false);
//! Updates the window's title
void updateTitle();
//! Updates the window's icon title
void updateStrut();
//! Updates the window's transient status, and any parents of it
void updateTransientFor();
+ //! Updates the window's icons
+ void updateIcons();
+ //! Updates the window's kwm icon
+ void updateKwmIcon();
//! Change the client's state hints to match the class' data
void changeState();
+ //! Change the allowed actions set on the client
+ void changeAllowedActions();
//! Request the client to close its window.
void close();
unshaded.
*/
void shade(bool shade);
+
+ //! Recursively searches the client 'tree' for a modal client, always skips
+ //! the topmost node (the window you're starting with).
+ Client *Client::searchModalTree(Client *node, Client *skip);
+
+ //! Recursively searches the client 'tree' for a focused client, always skips
+ //! the topmost node (the window you're starting with).
+ Client *Client::searchFocusTree(Client *node, Client *skip);
+
+ //! Fires the urgent callbacks which lets the user do what they want with
+ //! urgent windows
+ void fireUrgent();
+
+ //! Fullscreen's or unfullscreen's the client window
+ /*!
+ @param fs true if the window should be made fullscreen; false if it should
+ be returned to normal state.
+ @param savearea true to have the client's current size and position saved;
+ otherwise, they are not. You should not save when mapping a
+ new window that is set to fullscreen. This has no effect
+ when restoring a window from fullscreen.
+ */
+ void fullscreen(bool fs, bool savearea = true);
+
+ //! Iconifies or uniconifies the client window
+ /*!
+ @param iconic true if the window should be iconified; false if it should be
+ restored.
+ @param curdesk If iconic is false, then this determines if the window will
+ be uniconified to the current viewable desktop (true) or to
+ its previous desktop (false)
+ */
+ void iconify(bool iconic, bool curdesk = true);
+
+ //! Maximize or unmaximize the client window
+ /*!
+ @param max true if the window should be maximized; false if it should be
+ returned to normal size.
+ @param dir 0 to set both horz and vert, 1 to set horz, 2 to set vert.
+ @param savearea true to have the client's current size and position saved;
+ otherwise, they are not. You should not save when mapping a
+ new window that is set to fullscreen. This has no effect
+ when unmaximizing a window.
+ */
+ void maximize(bool max, int dir, bool savearea = true);
+
+ //! Internal version of the Client::move function
+ /*!
+ @param x The X coordinate to move to.
+ @param y The Y coordinate to move to.
+ @param final true if this is the final move, false if there are more move
+ events coming. The client is not notified of the move when
+ final is false.
+ */
+ void internal_move(int x, int y, bool final = true);
+ //! Internal version of the Client::resize function
+ /*!
+ 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 user Specifies whether this is a user-requested change or a
+ program requested change.
+ @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 internal_resize(Corner anchor, int w, int h,
+ bool user = true, int x = INT_MIN, int y = INT_MIN);
+
+ //! 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);
+
+ //! Applies the states requested when the window mapped
+ /*!
+ This should be called only once, during the window mapping process. It
+ applies things like maximized, and fullscreen.
+ */
+ void applyStartupState();
public:
-#ifndef SWIG
//! Constructs a new Client object around a specified window id
/*!
-BB @param window The window id that the Client class should handle
+ @param window The window id that the Client class should handle
@param screen The screen on which the window resides
*/
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; }
This value is a 0-based index.<br>
A value of 0xffffffff indicates that the window exists on all desktops.
*/
- inline long desktop() const { return _desktop; }
+ inline unsigned int 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 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 is the focused window
+ inline bool focused() const { return _focused; }
//! Returns if the window uses the Shape extension
inline bool shaped() const { return _shaped; }
//! Returns the window's gravity
//! Returns the decorations that the client window wishes to be displayed on
//! it
inline DecorationFlags decorations() const { return _decorations; }
+ //! Returns the decorations that the user has requested to be disabled on the
+ //! client
+ inline DecorationFlags disabledDecorations() const
+ { return _disabled_decorations; }
//! Returns the functions that the user can perform on the window
- inline FunctionFlags funtions() const { return _functions; }
+ inline FunctionFlags functions() const { return _functions; }
//! Return the client this window is transient for
inline Client *transientFor() const { return _transient_for; }
focus while it exists/remains modal.
*/
inline bool modal() const { return _modal; }
+ //! The window should not be displayed by pagers
+ inline bool skipPager() const { return _skip_pager; }
+ //! The window should not be displayed by taskbars
+ inline bool skipTaskbar() const { return _skip_taskbar; }
//! Returns if the window is shaded
/*!
When the window is shaded, only its titlebar is visible.
*/
inline bool shaded() const { return _shaded; }
+ //! Returns if the window is in fullscreen mode
+ inline bool fullscreen() const { return _fullscreen; }
//! Returns if the window is iconified
/*!
When the window is iconified, it is not visible at all (except in iconbars/
//! Returns the window's stacking layer
inline StackLayer layer() const { return _layer; }
- //! Removes or reapplies the client's border to its window
+ //! Returns the logical size of the window
/*!
- Used when managing and unmanaging a window.
- @param addborder true if adding the border to the client; false if removing
- from the client
+ 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.
*/
- void toggleClientBorder(bool addborder);
+ const otk::Size &logicalSize() const { return _logical_size; }
//! Returns the position and size of the client relative to the root window
+ /*!
+ Note that this value is *not* the size and position of the window's
+ frame, though the position will often line up.<br>
+ If you want the frame's area, use Frame::area() instead.
+ */
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
+ //! Returns an icon for the window
+ /*!
+ The icon chosen will be the smallest icon available that is still bigger or
+ equal to the specified Size.<br>
+ If none that meet the requirements is found, the largest icon that is
+ smaller than the specified size will be returned.
+ */
+ const Icon *icon(const otk::Size &s) const;
+
+ //! Returns the pixmap for the pixmap icon specified on the window (or None)
+ /*!
+ The icon given by Client::icon should take precedence over this icon/mask.
+ */
+ Pixmap pixmapIcon() const { return _pixmap_icon; }
+ //! Returns the mask for the pixmap icon specified on the window (or None)
+ /*!
+ The icon given by Client::icon should take precedence over this icon/mask.
+ */
+ Pixmap pixmapIconMask() const { return _pixmap_icon_mask; }
+
+ //! Move the window (actually, its frame) to a position.
/*!
+ This moves the window so that the top-left corner of its frame will be at
+ the position specified.
@param x The X coordinate to move to.
@param y The Y coordinate to move to.
+ @param final true if this is the final move, false if there are more move
+ events coming. The client is not notified of the move when
+ final is false.
*/
- void move(int x, int y);
+ void move(int x, int y, bool final = true);
//! Resizes the client window, anchoring it in a given corner
/*!
@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);
+ void resize(Corner anchor, int w, int h);
+
+ //! Reapplies the maximized state to the window
+ /*!
+ Use this to make the window readjust its maximized size to new
+ surroundings (struts, etc).
+ */
+ void remaximize();
+
+ //! Shows the window if it should be shown, or hides it
+ /*!
+ Used when changing desktops, the window's state, etc.
+ */
+ void showhide();
+
+ //! Choose a mask of decorations to not display on the client
+ /*!
+ Pass a value of 0 to the function to turn all decorations back on. Note
+ that you cannot add decorations to a window with this, you can only remove
+ decorations that would otherwise have been displayed.
+ @param flags The mask of values from Client::Decoration to specify which
+ decorations should not be displayed.
+ */
+ void disableDecorations(DecorationFlags flags);
+
+ //! Return a modal child of the client window
+ /*!
+ @return A modal child of the client window, or 0 if none was found.
+ */
+ Client *findModalChild();
//! Attempt to focus the client window
- bool focus() const;
+ bool focus();
//! Remove focus from the client window
void unfocus() const;
+ //! Validate client, by making sure no Destroy or Unmap events exist in
+ //! the event queue for the window.
+ /*!
+ @return true if the client is valid; false if the client has already
+ been unmapped/destroyed, and so is invalid.
+ */
+ bool validate() const;
+
+ void installColormap(bool install) const;
+
virtual void focusHandler(const XFocusChangeEvent &e);
virtual void unfocusHandler(const XFocusChangeEvent &e);
virtual void propertyHandler(const XPropertyEvent &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
+#endif // SHAPE
+
+ friend void Screen::manageWindow(Window);
+ friend void Screen::unmanageWindow(Client *);
};
}
projects / chaz / openbox / blobdiff