---

ob::Client Class Reference

#include <client.hh>

Inheritance diagram for ob::Client:

[legend]Collaboration diagram for ob::Client:

[legend]List of all members.

---

Detailed Description

Maintains the state of a client window.

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.

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).

Definition at line 59 of file client.hh.

Public Types
typedef std::list< Client * >	List
	Holds a list of Clients.
typedef unsigned char	FunctionFlags
	Holds a bitmask of Client::Function values.
typedef unsigned char	DecorationFlags
	Holds a bitmask of Client::Decoration values.
enum	StackLayer {   Layer_Icon, Layer_Desktop, Layer_Below, Layer_Normal,   Layer_Above, Layer_Top, Layer_Fullscreen, Layer_Internal,   NUM_LAYERS }
	The possible stacking layers a client window can be a part of. More...
enum	Corner { TopLeft, TopRight, BottomLeft, BottomRight }
	Corners of the client window, used for anchor positions. More...
enum	WindowType {   Type_Desktop, Type_Dock, Type_Toolbar, Type_Menu,   Type_Utility, Type_Splash, Type_Dialog, Type_Normal }
	Possible window types. More...
enum	MwmFlags { MwmFlag_Functions = 1 << 0, MwmFlag_Decorations = 1 << 1 }
	Possible flags for MWM Hints (defined by Motif 2.0). More...
enum	MwmFunctions {   MwmFunc_All = 1 << 0, MwmFunc_Resize = 1 << 1, MwmFunc_Move = 1 << 2, MwmFunc_Iconify = 1 << 3,   MwmFunc_Maximize = 1 << 4 }
	Possible functions for MWM Hints (defined by Motif 2.0). More...
enum	MemDecorations {   MwmDecor_All = 1 << 0, MwmDecor_Border = 1 << 1, MwmDecor_Handle = 1 << 2, MwmDecor_Title = 1 << 3,   MwmDecor_Iconify = 1 << 5, MwmDecor_Maximize = 1 << 6 }
	Possible decorations for MWM Hints (defined by Motif 2.0). More...
enum	Function {   Func_Resize = 1 << 0, Func_Move = 1 << 1, Func_Iconify = 1 << 2, Func_Maximize = 1 << 3,   Func_Shade = 1 << 4, Func_Fullscreen = 1 << 5, Func_Close = 1 << 6 }
	The things the user can do to the client window. More...
enum	Decoration {   Decor_Titlebar = 1 << 0, Decor_Handle = 1 << 1, Decor_Border = 1 << 2, Decor_Iconify = 1 << 3,   Decor_Maximize = 1 << 4, Decor_AllDesktops = 1 << 5, Decor_Close = 1 << 6 }
	The decorations the client window wants to be displayed on it. More...
enum	StateAction { State_Remove = 0, State_Add, State_Toggle }
	Possible actions that can be made with the _NET_WM_STATE client message. More...
Public Methods
	Client (int screen, Window window)
	Constructs a new Client object around a specified window id.
virtual	~Client ()
	Destroys the Client object.
int	screen () const
	Returns the screen on which the clien resides.
Window	window () const
	Returns the window id that the Client object is handling.
WindowType	type () const
	Returns the type of the window, one of the Client::WindowType values.
bool	normal () const
	Returns if the window should be treated as a normal window.
long	desktop () const
	Returns the desktop on which the window resides.
const otk::ustring &	title () const
	Returns the window's title.
const otk::ustring &	iconTitle () const
	Returns the window's title when it is iconified.
const std::string &	appName () const
	Returns the application's name to whom the window belongs.
const std::string &	appClass () const
	Returns the class of the window.
const std::string &	role () const
	Returns the program-specified role of the window.
bool	canFocus () const
	Returns if the window can be focused.
bool	urgent () const
	Returns if the window has indicated that it needs urgent attention.
bool	focusNotify () const
	Returns if the window wants to be notified when it receives focus.
bool	focused () const
	Returns if the window is the focused window.
bool	shaped () const
	Returns if the window uses the Shape extension.
int	gravity () const
	Returns the window's gravity.
bool	positionRequested () const
	Returns if the application requested the initial position for the window.
DecorationFlags	decorations () const
	Returns the decorations that the client window wishes to be displayed on it.
DecorationFlags	disabledDecorations () const
	Returns the decorations that the user has requested to be disabled on the client.
FunctionFlags	funtions () const
	Returns the functions that the user can perform on the window.
Client *	transientFor () const
	Return the client this window is transient for.
Client *	modalChild () const
	Returns the window which is a modal child of this window.
bool	modal () const
	Returns if the window is modal.
bool	skipPager () const
	The window should not be displayed by pagers.
bool	skipTaskbar () const
	The window should not be displayed by taskbars.
bool	shaded () const
	Returns if the window is shaded.
bool	fullscreen () const
	Returns if the window is in fullscreen mode.
bool	iconic () const
	Returns if the window is iconified.
bool	maxVert () const
	Returns if the window is maximized vertically.
bool	maxHorz () const
	Returns if the window is maximized horizontally.
StackLayer	layer () const
	Returns the window's stacking layer.
const otk::Point &	logicalSize () const
	Returns the logical size of the window.
const otk::Rect &	area () const
	Returns the position and size of the client relative to the root window.
const otk::Strut &	strut () const
	Returns the client's strut definition.
void	move (int x, int y)
	Move the window (actually, its frame) to a position.
void	resize (Corner anchor, int w, int h)
	Resizes the client window, anchoring it in a given corner.
void	remaximize ()
	Reapplies the maximized state to the window.
void	disableDecorations (DecorationFlags flags)
	Choose a mask of decorations to not display on the client.
bool	focus ()
	Attempt to focus the client window.
void	unfocus () const
	Remove focus from the client window.
bool	validate () const
	Validate client, by making sure no Destroy or Unmap events exist in the event queue for the window.
void	installColormap (bool install) const
virtual void	focusHandler (const XFocusChangeEvent &e)
	Called when a window gains focus.
virtual void	unfocusHandler (const XFocusChangeEvent &e)
	Called when a window looses focus.
virtual void	propertyHandler (const XPropertyEvent &e)
	Called when a property of a window changes.
virtual void	clientMessageHandler (const XClientMessageEvent &e)
	Called when a client calls XSendEvent.
virtual void	configureRequestHandler (const XConfigureRequestEvent &e)
	Called when a different client initiates a configure window request.
virtual void	unmapHandler (const XUnmapEvent &e)
	Called when a window is unmapped.
virtual void	destroyHandler (const XDestroyWindowEvent &e)
	Called when a window is destroyed.
virtual void	reparentHandler (const XReparentEvent &e)
	Called when a window is reparented.
virtual void	mapRequestHandler (const XMapRequestEvent &e)
	Called when a different client tries to map a window.
Public Attributes
Frame *	frame
	The frame window which decorates around the client window.
int	ignore_unmaps
	The number of unmap events to ignore on the window.
Static Public Attributes
const long	event_mask
	The event mask to grab on client windows.
const long	no_propagate_mask
	The mask of events to not let propogate past the client.
const long	ICONIC_DESKTOP = 0xfffffffe
	The desktop value which indicated the window is iconified and not on any desktop.
Private Methods
void	getGravity ()
	Retrieves the window's initial gravity.
void	getDesktop ()
	Retrieves the desktop hint's value and sets Client::_desktop.
void	getType ()
	Retrieves the window's type and sets Client::_type.
void	getMwmHints ()
	Gets the MWM Hints and adjusts Client::_functions and Client::_decorations.
void	getArea ()
	Gets the position and size of the window and sets Client::_area.
void	getState ()
	Gets the net_state hint and sets the boolean flags for any states set in the hint.
void	getShaped ()
	Determines if the window uses the Shape extension and sets Client::_shaped.
void	setupDecorAndFunctions ()
	Set up what decor should be shown on the window and what functions should be allowed (Client::_decorations and Client::_functions).
void	setWMState (long state)
	Sets the wm_state to the specified value.
void	setState (StateAction action, long data1, long data2)
	Adjusts the window's net_state.
void	setDesktop (long desktop)
	Sends the window to the specified desktop.
void	setModal (bool modal)
	Set whether the window is modal or not.
void	calcLayer ()
	Calculates the stacking layer for the client window.
void	updateProtocols ()
	Update the protocols that the window supports and adjusts things if they change.
void	updateNormalHints ()
	Updates the WMNormalHints and adjusts things if they change.
void	updateWMHints (bool initstate=false)
	Updates the WMHints and adjusts things if they change.
void	updateTitle ()
	Updates the window's title.
void	updateIconTitle ()
	Updates the window's icon title.
void	updateClass ()
	Updates the window's application name and class.
void	updateStrut ()
	Updates the strut for the client.
void	updateTransientFor ()
	Updates the window's transient status, and any parents of it.
void	changeState ()
	Change the client's state hints to match the class' data.
void	changeAllowedActions ()
	Change the allowed actions set on the client.
void	close ()
	Request the client to close its window.
void	shade (bool shade)
	Shades or unshades the client window.
void	fireUrgent ()
	Fires the urgent callbacks which lets the user do what they want with urgent windows.
void	fullscreen (bool fs, bool savearea)
	Fullscreen's or unfullscreen's the client window.
void	maximize (bool max, int dir, bool savearea)
	Maximize or unmaximize the client window.
void	internal_move (int x, int y)
	Internal version of the Client::move function.
void	internal_resize (Corner anchor, int w, int h, bool user=true, int x=INT_MIN, int y=INT_MIN)
	Internal version of the Client::resize function.
Client *	findModalChild (Client *skip=0) const
	Attempts to find and return a modal child of this window, recursively.
void	toggleClientBorder (bool addborder)
	Removes or reapplies the client's border to its window.
void	applyStartupState ()
	Applies the states requested when the window mapped.
Private Attributes
int	_screen
	The screen number on which the client resides.
Window	_window
	The actual window that this class is wrapping up.
Window	_group
	The id of the group the window belongs to.
Client *	_transient_for
	The client which this client is a transient (child) for.
Client::List	_transients
	The clients which are transients (children) of this client.
long	_desktop
	The desktop on which the window resides (0xffffffff for all desktops).
otk::ustring	_title
	Normal window title.
otk::ustring	_icon_title
	Window title when iconifiged.
std::string	_app_name
	The application that created the window.
std::string	_app_class
	The class of the window, can used for grouping.
std::string	_role
	The specified role of the window, used for identification.
WindowType	_type
	The type of window (what its function is).
otk::Rect	_area
	Position and size of the window.
otk::Strut	_strut
	The window's strut.
otk::Point	_logical_size
	The logical size of the window.
int	_border_width
	Width of the border on the window.
float	_min_ratio
	The minimum aspect ratio the client window can be sized to.
float	_max_ratio
	The maximum aspect ratio the client window can be sized to.
otk::Point	_min_size
	The minimum size of the client window.
otk::Point	_max_size
	The maximum size of the client window.
otk::Point	_size_inc
	The size of increments to resize the client window by.
otk::Point	_base_size
	The base size of the client window.
MwmHints	_mwmhints
	Window decoration and functionality hints.
int	_gravity
	Where to place the decorated window in relation to the undecorated window.
long	_wmstate
	The state of the window, one of WithdrawnState, IconicState, or NormalState.
bool	_delete_window
	True if the client supports the delete_window protocol.
bool	_positioned
	Was the window's position requested by the application? if not, we should place the window ourselves when it first appears.
bool	_can_focus
	Can the window receive input focus?
bool	_urgent
	Urgency flag.
bool	_focus_notify
	Notify the window when it receives focus?
bool	_focused
	Does the client window have the input focus?
bool	_shaped
	The window uses shape extension to be non-rectangular?
Client *	_modal_child
	If the window has a modal child window, then this will point to it.
bool	_modal
	The window is modal, so it must be processed before any windows it is related to can be focused.
bool	_shaded
	Only the window's titlebar is displayed.
bool	_iconic
	The window is iconified.
bool	_max_vert
	The window is maximized to fill the screen vertically.
bool	_max_horz
	The window is maximized to fill the screen horizontally.
bool	_skip_pager
	The window should not be displayed by pagers.
bool	_skip_taskbar
	The window should not be displayed by taskbars.
bool	_fullscreen
	The window is a 'fullscreen' window, and should be on top of all others.
bool	_above
	The window should be on top of other windows of the same type.
bool	_below
	The window should be underneath other windows of the same type.
StackLayer	_layer
DecorationFlags	_decorations
	A bitmask of values in the Client::Decoration enum.
DecorationFlags	_disabled_decorations
	A bitmask of values in the Client::Decoration enum.
FunctionFlags	_functions
	A bitmask of values in the Client::Function enum.
Friends
void	Screen::manageWindow (Window)
void	Screen::unmanageWindow (Client *)

---

Member Typedef Documentation

typedef unsigned char ob::Client::DecorationFlags

Holds a bitmask of Client::Decoration values. Definition at line 149 of file client.hh. Referenced by fullscreen().

typedef unsigned char ob::Client::FunctionFlags

Holds a bitmask of Client::Function values. Definition at line 135 of file client.hh. Referenced by fullscreen().

typedef std::list<Client*> ob::Client::List

Holds a list of Clients. Definition at line 69 of file client.hh.

---

Member Enumeration Documentation

enum ob::Client::Corner

Corners of the client window, used for anchor positions. Enumeration values: TopLeft  TopRight  BottomLeft  BottomRight  Definition at line 85 of file client.hh. Referenced by configureRequestHandler(). { TopLeft, TopRight, BottomLeft, BottomRight };

enum ob::Client::Decoration

The decorations the client window wants to be displayed on it. Enumeration values: Decor_Titlebar  Display a titlebar. Decor_Handle  Display a handle (bottom). Decor_Border  Display a border. Decor_Iconify  Display an iconify button. Decor_Maximize  Display a maximize button. Decor_AllDesktops  Display a button to toggle the window's placement on all desktops. Decor_Close  Display a close button. Definition at line 138 of file client.hh. { 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 //! Display a button to toggle the window's placement on //! all desktops Decor_AllDesktops = 1 << 5, Decor_Close = 1 << 6 //!< Display a close button };

enum ob::Client::Function

The things the user can do to the client window. Enumeration values: Func_Resize  Allow resizing. Func_Move  Allow moving. Func_Iconify  Allow to be iconified. Func_Maximize  Allow to be maximized. Func_Shade  Allow to be shaded. Func_Fullscreen  Allow to be made fullscreen. Func_Close  Allow to be closed. Definition at line 126 of file client.hh. { 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 };

enum ob::Client::MemDecorations

Possible decorations for MWM Hints (defined by Motif 2.0). Enumeration values: MwmDecor_All  All decorations. MwmDecor_Border  Show a border. MwmDecor_Handle  Show a handle (bottom). MwmDecor_Title  Show a titlebar. MwmDecor_Iconify  Show an iconify button. MwmDecor_Maximize  Show a maximize button. Definition at line 116 of file client.hh. { MwmDecor_All = 1 << 0, //!< All decorations MwmDecor_Border = 1 << 1, //!< Show a border MwmDecor_Handle = 1 << 2, //!< Show a handle (bottom) MwmDecor_Title = 1 << 3, //!< Show a titlebar //MwmDecor_Menu = 1 << 4, //!< Show a menu MwmDecor_Iconify = 1 << 5, //!< Show an iconify button MwmDecor_Maximize = 1 << 6 //!< Show a maximize button };

enum ob::Client::MwmFlags

Possible flags for MWM Hints (defined by Motif 2.0). Enumeration values: MwmFlag_Functions  The MMW Hints define funcs. MwmFlag_Decorations  The MWM Hints define decor. Definition at line 102 of file client.hh. { MwmFlag_Functions = 1 << 0, //!< The MMW Hints define funcs MwmFlag_Decorations = 1 << 1 //!< The MWM Hints define decor };

enum ob::Client::MwmFunctions

Possible functions for MWM Hints (defined by Motif 2.0). Enumeration values: MwmFunc_All  All functions. MwmFunc_Resize  Allow resizing. MwmFunc_Move  Allow moving. MwmFunc_Iconify  Allow to be iconfied. MwmFunc_Maximize  Allow to be maximized. Definition at line 107 of file client.hh. { MwmFunc_All = 1 << 0, //!< All functions MwmFunc_Resize = 1 << 1, //!< Allow resizing MwmFunc_Move = 1 << 2, //!< Allow moving MwmFunc_Iconify = 1 << 3, //!< Allow to be iconfied MwmFunc_Maximize = 1 << 4 //!< Allow to be maximized //MwmFunc_Close = 1 << 5 //!< Allow to be closed };

enum ob::Client::StackLayer

The possible stacking layers a client window can be a part of. Enumeration values: 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  Definition at line 72 of file client.hh. Referenced by calcLayer(), and layer(). { 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 };

enum ob::Client::StateAction

Possible actions that can be made with the _NET_WM_STATE client message. Enumeration values: State_Remove  _NET_WM_STATE_REMOVE State_Add  _NET_WM_STATE_ADD State_Toggle  _NET_WM_STATE_TOGGLE Definition at line 152 of file client.hh. { State_Remove = 0, //!< _NET_WM_STATE_REMOVE State_Add, //!< _NET_WM_STATE_ADD State_Toggle //!< _NET_WM_STATE_TOGGLE };

enum ob::Client::WindowType

Possible window types. Enumeration values: 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  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. Type_Normal  A normal application window. Definition at line 91 of file client.hh. Referenced by type(). { 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, //!< 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 Type_Normal //!< A normal application window };

---

Constructor & Destructor Documentation

ob::Client::Client (  int    screen, Window    window )

Constructs a new Client object around a specified window id. BB Parameters: window  The window id that the Client class should handle screen  The screen on which the window resides Definition at line 30 of file client.cc. References _desktop, _disabled_decorations, _focused, _group, _layer, _modal_child, _positioned, _transient_for, _type, _urgent, _wmstate, changeState(), getArea(), getDesktop(), getGravity(), getMwmHints(), getShaped(), getState(), getType(), ignore_unmaps, Layer_Normal, ob::openbox, otk::Property::set(), setupDecorAndFunctions(), ob::Openbox::state(), Type_Desktop, updateClass(), updateIconTitle(), updateNormalHints(), updateProtocols(), updateStrut(), updateTitle(), updateTransientFor(), and updateWMHints(). : otk::EventHandler(), WidgetBase(WidgetBase::Type_Client), frame(0), _screen(screen), _window(window) { assert(screen >= 0); assert(window); ignore_unmaps = 0; // update EVERYTHING the first time!! // defaults _wmstate = NormalState; _focused = false; _transient_for = 0; _layer = Layer_Normal; _urgent = false; _positioned = false; _disabled_decorations = 0; _modal_child = 0; _group = None; _desktop = 0; getArea(); getDesktop(); getState(); // do this before updateTransientFor! (for _modal) getShaped(); updateTransientFor(); getMwmHints(); getType(); // this can change the mwmhints for special cases updateProtocols(); getGravity(); // get the attribute gravity updateNormalHints(); // this may override the attribute gravity // got the type, the mwmhints, the protocols, and the normal hints (min/max // sizes), so we're ready to set up // the decorations/functions setupDecorAndFunctions(); // also get the initial_state and set _iconic if we aren't "starting" // when we're "starting" that means we should use whatever state was already // on the window over the initial map state, because it was already mapped updateWMHints(openbox->state() != Openbox::State_Starting); updateTitle(); updateIconTitle(); updateClass(); updateStrut(); // this makes sure that these windows appear on all desktops if (/*_type == Type_Dock ||*/ _type == Type_Desktop) _desktop = 0xffffffff; // set the desktop hint, to make sure that it always exists, and to reflect // any changes we've made here otk::Property::set(_window, otk::Property::atoms.net_wm_desktop, otk::Property::atoms.cardinal, (unsigned)_desktop); changeState(); }

ob::Client::~Client (    )  [virtual]

Destroys the Client object. Definition at line 95 of file client.cc. References _transient_for, _transients, otk::Property::erase(), ob::openbox, and ob::Openbox::state(). { // clean up childrens' references while (!_transients.empty()) { _transients.front()->_transient_for = 0; _transients.pop_front(); } // clean up parents reference to this if (_transient_for) _transient_for->_transients.remove(this); // remove from old parent if (openbox->state() != Openbox::State_Exiting) { // these values should not be persisted across a window unmapping/mapping otk::Property::erase(_window, otk::Property::atoms.net_wm_desktop); otk::Property::erase(_window, otk::Property::atoms.net_wm_state); } else { // if we're left in an iconic state, the client wont be mapped. this is // bad, since we will no longer be managing the window on restart if (_iconic) XMapWindow(**otk::display, _window); } }

---

Member Function Documentation

const std::string& ob::Client::appClass (    )  const [inline]

Returns the class of the window. Definition at line 546 of file client.hh. { return _app_class; }

void ob::Client::applyStartupState (    )  [private]

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. Definition at line 1366 of file client.cc. References _fullscreen, _iconic, _max_horz, _max_vert, _modal, _shaded, fireUrgent(), fullscreen(), maximize(), setDesktop(), setModal(), and shade(). Referenced by ob::Screen::manageWindow(). { // these are in a carefully crafted order.. if (_modal) { _modal = false; setModal(true); } if (_iconic) { _iconic = false; setDesktop(ICONIC_DESKTOP); } if (_fullscreen) { _fullscreen = false; fullscreen(true, false); } if (_shaded) { _shaded = false; shade(true); } if (_urgent) fireUrgent(); if (_max_vert && _max_horz) { _max_vert = _max_horz = false; maximize(true, 0, false); } else if (_max_vert) { _max_vert = false; maximize(true, 2, false); } else if (_max_horz) { _max_horz = false; maximize(true, 1, false); } if (_skip_taskbar); // nothing to do for this if (_skip_pager); // nothing to do for this if (_modal); // nothing to do for this if (_above); // nothing to do for this if (_below); // nothing to do for this }

const std::string& ob::Client::appName (    )  const [inline]

Returns the application's name to whom the window belongs. Definition at line 544 of file client.hh. { return _app_name; }

const otk::Rect& ob::Client::area (    )  const [inline]

Returns the position and size of the client relative to the root window. Definition at line 633 of file client.hh. Referenced by ob::Frame::adjustPosition(), ob::Frame::adjustSize(), ob::Actions::insertPress(), and ob::Frame::releaseClient(). { return _area; }

void ob::Client::calcLayer (    )  [private]

Calculates the stacking layer for the client window. Definition at line 423 of file client.cc. References _below, _layer, _type, Layer_Above, Layer_Below, Layer_Desktop, Layer_Fullscreen, Layer_Icon, Layer_Normal, Layer_Top, ob::openbox, ob::Screen::raiseWindow(), ob::Openbox::screen(), StackLayer, Type_Desktop, and Type_Dock. Referenced by changeState(), propertyHandler(), and setState(). { StackLayer l; if (_iconic) l = Layer_Icon; else if (_fullscreen) l = Layer_Fullscreen; else if (_type == Type_Desktop) l = Layer_Desktop; else if (_type == Type_Dock) { if (!_below) l = Layer_Top; else l = Layer_Normal; } else if (_above) l = Layer_Above; else if (_below) l = Layer_Below; else l = Layer_Normal; if (l != _layer) { _layer = l; if (frame) { /* if we don't have a frame, then we aren't mapped yet (and this would SIGSEGV :) */ openbox->screen(_screen)->raiseWindow(this); } } }

bool ob::Client::canFocus (    )  const [inline]

Returns if the window can be focused. Returns: true if the window can receive focus; otherwise, false Definition at line 553 of file client.hh. { return _can_focus; }

void ob::Client::changeAllowedActions (    )  [private]

Change the allowed actions set on the client. Definition at line 1321 of file client.cc. References _functions, otk::Property::atoms, Func_Close, Func_Fullscreen, Func_Iconify, Func_Maximize, Func_Move, Func_Resize, Func_Shade, and otk::Property::set(). Referenced by fullscreen(), and setupDecorAndFunctions(). { Atom actions[9]; int num = 0; actions[num++] = otk::Property::atoms.net_wm_action_change_desktop; if (_functions & Func_Shade) actions[num++] = otk::Property::atoms.net_wm_action_shade; if (_functions & Func_Close) actions[num++] = otk::Property::atoms.net_wm_action_close; if (_functions & Func_Move) actions[num++] = otk::Property::atoms.net_wm_action_move; if (_functions & Func_Iconify) actions[num++] = otk::Property::atoms.net_wm_action_minimize; if (_functions & Func_Resize) actions[num++] = otk::Property::atoms.net_wm_action_resize; if (_functions & Func_Fullscreen) actions[num++] = otk::Property::atoms.net_wm_action_fullscreen; if (_functions & Func_Maximize) { actions[num++] = otk::Property::atoms.net_wm_action_maximize_horz; actions[num++] = otk::Property::atoms.net_wm_action_maximize_vert; } otk::Property::set(_window, otk::Property::atoms.net_wm_allowed_actions, otk::Property::atoms.atom, actions, num); }

void ob::Client::changeState (    )  [private]

Change the client's state hints to match the class' data. Definition at line 1281 of file client.cc. References _wmstate, ob::Frame::adjustState(), otk::Property::atoms, calcLayer(), frame, and otk::Property::set(). Referenced by Client(), fullscreen(), maximize(), setDesktop(), setState(), and shade(). { unsigned long state[2]; state[0] = _wmstate; state[1] = None; otk::Property::set(_window, otk::Property::atoms.wm_state, otk::Property::atoms.wm_state, state, 2); Atom netstate[10]; int num = 0; if (_modal) netstate[num++] = otk::Property::atoms.net_wm_state_modal; if (_shaded) netstate[num++] = otk::Property::atoms.net_wm_state_shaded; if (_iconic) netstate[num++] = otk::Property::atoms.net_wm_state_hidden; if (_skip_taskbar) netstate[num++] = otk::Property::atoms.net_wm_state_skip_taskbar; if (_skip_pager) netstate[num++] = otk::Property::atoms.net_wm_state_skip_pager; if (_fullscreen) netstate[num++] = otk::Property::atoms.net_wm_state_fullscreen; if (_max_vert) netstate[num++] = otk::Property::atoms.net_wm_state_maximized_vert; if (_max_horz) netstate[num++] = otk::Property::atoms.net_wm_state_maximized_horz; if (_above) netstate[num++] = otk::Property::atoms.net_wm_state_above; if (_below) netstate[num++] = otk::Property::atoms.net_wm_state_below; otk::Property::set(_window, otk::Property::atoms.net_wm_state, otk::Property::atoms.atom, netstate, num); calcLayer(); if (frame) frame->adjustState(); }

void ob::Client::clientMessageHandler (  const XClientMessageEvent &    e )  [virtual]

Called when a client calls XSendEvent. Some types of client messages are filtered out and sent to more specific event handler functions. Reimplemented from otk::EventHandler. Definition at line 1030 of file client.cc. References _shaded, otk::Property::atoms, otk::EventHandler::clientMessageHandler(), close(), ob::Screen::desktop(), focus(), ob::openbox, ob::Screen::raiseWindow(), ob::Openbox::screen(), setDesktop(), setState(), setWMState(), shade(), and validate(). { otk::EventHandler::clientMessageHandler(e); // validate cuz we query stuff off the client here if (!validate()) return; if (e.format != 32) return; if (e.message_type == otk::Property::atoms.wm_change_state) { // compress changes into a single change bool compress = false; XEvent ce; while (XCheckTypedEvent(**otk::display, e.type, &ce)) { // XXX: it would be nice to compress ALL messages of a type, not just // messages in a row without other message types between. if (ce.xclient.message_type != e.message_type) { XPutBackEvent(**otk::display, &ce); break; } compress = true; } if (compress) setWMState(ce.xclient.data.l[0]); // use the found event else setWMState(e.data.l[0]); // use the original event } else if (e.message_type == otk::Property::atoms.net_wm_desktop) { // compress changes into a single change bool compress = false; XEvent ce; while (XCheckTypedEvent(**otk::display, e.type, &ce)) { // XXX: it would be nice to compress ALL messages of a type, not just // messages in a row without other message types between. if (ce.xclient.message_type != e.message_type) { XPutBackEvent(**otk::display, &ce); break; } compress = true; } if (compress) setDesktop(e.data.l[0]); // use the found event else setDesktop(e.data.l[0]); // use the original event } else if (e.message_type == otk::Property::atoms.net_wm_state) { // can't compress these #ifdef DEBUG printf("net_wm_state %s %ld %ld for 0x%lx\n", (e.data.l[0] == 0 ? "Remove" : e.data.l[0] == 1 ? "Add" : e.data.l[0] == 2 ? "Toggle" : "INVALID"), e.data.l[1], e.data.l[2], _window); #endif setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]); } else if (e.message_type == otk::Property::atoms.net_close_window) { #ifdef DEBUG printf("net_close_window for 0x%lx\n", _window); #endif close(); } else if (e.message_type == otk::Property::atoms.net_active_window) { #ifdef DEBUG printf("net_active_window for 0x%lx\n", _window); #endif if (_iconic) setDesktop(openbox->screen(_screen)->desktop()); if (_shaded) shade(false); focus(); openbox->screen(_screen)->raiseWindow(this); } else if (e.message_type == otk::Property::atoms.openbox_active_window) { if (_iconic) setDesktop(openbox->screen(_screen)->desktop()); if (e.data.l[0] && _shaded) shade(false); focus(); if (e.data.l[1]) openbox->screen(_screen)->raiseWindow(this); } }

void ob::Client::close (    )  [private]

Request the client to close its window. Definition at line 1255 of file client.cc. References _functions, _window, otk::Property::atoms, and Func_Close. Referenced by clientMessageHandler(). { XEvent ce; if (!(_functions & Func_Close)) return; // XXX: itd be cool to do timeouts and shit here for killing the client's // process off // like... if the window is around after 5 seconds, then the close button // turns a nice red, and if this function is called again, the client is // explicitly killed. ce.xclient.type = ClientMessage; ce.xclient.message_type = otk::Property::atoms.wm_protocols; ce.xclient.display = **otk::display; ce.xclient.window = _window; ce.xclient.format = 32; ce.xclient.data.l[0] = otk::Property::atoms.wm_delete_window; ce.xclient.data.l[1] = CurrentTime; ce.xclient.data.l[2] = 0l; ce.xclient.data.l[3] = 0l; ce.xclient.data.l[4] = 0l; XSendEvent(**otk::display, _window, false, NoEventMask, &ce); }

void ob::Client::configureRequestHandler (  const XConfigureRequestEvent &    e )  [virtual]

Called when a different client initiates a configure window request. Reimplemented from otk::EventHandler. Definition at line 1725 of file client.cc. References _area, _border_width, _iconic, _shaded, BottomLeft, BottomRight, otk::EventHandler::configureRequestHandler(), Corner, otk::Rect::height(), internal_move(), internal_resize(), ob::Screen::lowerWindow(), ob::openbox, ob::Screen::raiseWindow(), ob::Openbox::screen(), TopLeft, TopRight, otk::Rect::width(), otk::Rect::x(), and otk::Rect::y(). { #ifdef DEBUG printf("ConfigureRequest for 0x%lx\n", e.window); #endif // DEBUG otk::EventHandler::configureRequestHandler(e); // if we are iconic (or shaded (fvwm does this)) ignore the event if (_iconic || _shaded) return; if (e.value_mask & CWBorderWidth) _border_width = e.border_width; // resize, then move, as specified in the EWMH section 7.7 if (e.value_mask & (CWWidth | CWHeight)) { int w = (e.value_mask & CWWidth) ? e.width : _area.width(); int h = (e.value_mask & CWHeight) ? e.height : _area.height(); Corner corner; switch (_gravity) { case NorthEastGravity: case EastGravity: corner = TopRight; break; case SouthWestGravity: case SouthGravity: corner = BottomLeft; break; case SouthEastGravity: corner = BottomRight; break; default: // NorthWest, Static, etc corner = TopLeft; } // if moving AND resizing ... if (e.value_mask & (CWX | CWY)) { int x = (e.value_mask & CWX) ? e.x : _area.x(); int y = (e.value_mask & CWY) ? e.y : _area.y(); internal_resize(corner, w, h, false, x, y); } else // if JUST resizing... internal_resize(corner, w, h, false); } else if (e.value_mask & (CWX | CWY)) { // if JUST moving... int x = (e.value_mask & CWX) ? e.x : _area.x(); int y = (e.value_mask & CWY) ? e.y : _area.y(); internal_move(x, y); } if (e.value_mask & CWStackMode) { switch (e.detail) { case Below: case BottomIf: openbox->screen(_screen)->lowerWindow(this); break; case Above: case TopIf: default: openbox->screen(_screen)->raiseWindow(this); break; } } }

DecorationFlags ob::Client::decorations (    )  const [inline]

Returns the decorations that the client window wishes to be displayed on it. Definition at line 579 of file client.hh. Referenced by ob::Frame::adjustSize(). { return _decorations; }

long ob::Client::desktop (    )  const [inline]

Returns the desktop on which the window resides. This value is a 0-based index. A value of 0xffffffff indicates that the window exists on all desktops. Definition at line 538 of file client.hh. Referenced by ob::Screen::manageWindow(), ob::ButtonWidget::setTextures(), and ob::ButtonWidget::update(). { return _desktop; }

void ob::Client::destroyHandler (  const XDestroyWindowEvent &    e )  [virtual]

Called when a window is destroyed. Reimplemented from otk::EventHandler. Definition at line 1812 of file client.cc. References otk::EventHandler::destroyHandler(), ob::openbox, ob::Openbox::screen(), and ob::Screen::unmanageWindow(). { #ifdef DEBUG printf("DestroyNotify for 0x%lx\n", e.window); #endif // DEBUG otk::EventHandler::destroyHandler(e); // this deletes us etc openbox->screen(_screen)->unmanageWindow(this); }

DecorationFlags ob::Client::disabledDecorations (    )  const [inline]

Returns the decorations that the user has requested to be disabled on the client. Definition at line 582 of file client.hh. { return _disabled_decorations; }

void ob::Client::disableDecorations (  DecorationFlags    flags )

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. Parameters: flags  The mask of values from Client::Decoration to specify which decorations should not be displayed. Definition at line 1613 of file client.cc. References _disabled_decorations, and setupDecorAndFunctions(). { _disabled_decorations = flags; setupDecorAndFunctions(); }

Client * ob::Client::findModalChild (  Client *    skip = 0 )  const [private]

Attempts to find and return a modal child of this window, recursively. Definition at line 801 of file client.cc. References _transients. Referenced by setModal(). { Client *ret = 0; // find a modal child recursively and try focus it List::const_iterator it, end = _transients.end(); for (it = _transients.begin(); it != end; ++it) if ((*it)->_modal && *it != skip) return *it; // got one // none of our direct children are modal, let them try check for (it = _transients.begin(); it != end; ++it) if ((ret = (*it)->findModalChild())) return ret; // got one return ret; }

void ob::Client::fireUrgent (    )  [private]

Fires the urgent callbacks which lets the user do what they want with urgent windows. Definition at line 1409 of file client.cc. References ob::Openbox::bindings(), ob::Bindings::fireEvent(), and ob::openbox. Referenced by applyStartupState(), and updateWMHints(). { // call the python UrgentWindow callbacks EventData data(_screen, this, EventAction::UrgentWindow, 0); openbox->bindings()->fireEvent(&data); }

bool ob::Client::focus (    )

Attempt to focus the client window. Definition at line 1632 of file client.cc. References _can_focus, _focus_notify, _modal_child, _window, otk::Property::atoms, frame, otk::Widget::isVisible(), otk::EventDispatcher::lastTime(), ob::openbox, and unmapHandler(). Referenced by clientMessageHandler(), and fullscreen(). { // if we have a modal child, then focus it, not us if (_modal_child) return _modal_child->focus(); // won't try focus if the client doesn't want it, or if the window isn't // visible on the screen if (!(frame->isVisible() && (_can_focus || _focus_notify))) return false; if (_focused) return true; // do a check to see if the window has already been unmapped or destroyed // do this intelligently while watching out for unmaps we've generated // (ignore_unmaps > 0) XEvent ev; if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &ev)) { XPutBackEvent(**otk::display, &ev); return false; } while (XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &ev)) { if (ignore_unmaps) { unmapHandler(ev.xunmap); } else { XPutBackEvent(**otk::display, &ev); return false; } } if (_can_focus) XSetInputFocus(**otk::display, _window, RevertToNone, CurrentTime); if (_focus_notify) { XEvent ce; ce.xclient.type = ClientMessage; ce.xclient.message_type = otk::Property::atoms.wm_protocols; ce.xclient.display = **otk::display; ce.xclient.window = _window; ce.xclient.format = 32; ce.xclient.data.l[0] = otk::Property::atoms.wm_take_focus; ce.xclient.data.l[1] = openbox->lastTime(); ce.xclient.data.l[2] = 0l; ce.xclient.data.l[3] = 0l; ce.xclient.data.l[4] = 0l; XSendEvent(**otk::display, _window, False, NoEventMask, &ce); } XSync(**otk::display, False); return true; }

bool ob::Client::focused (    )  const [inline]

Returns if the window is the focused window. Definition at line 559 of file client.hh. { return _focused; }

void ob::Client::focusHandler (  const XFocusChangeEvent &    e )  [virtual]

Called when a window gains focus. Reimplemented from otk::EventHandler. Definition at line 1694 of file client.cc. References _focused, ob::Frame::focus(), otk::EventHandler::focusHandler(), frame, ob::openbox, and ob::Openbox::setFocusedClient(). { #ifdef DEBUG // printf("FocusIn for 0x%lx\n", e.window); #endif // DEBUG otk::EventHandler::focusHandler(e); frame->focus(); _focused = true; openbox->setFocusedClient(this); }

bool ob::Client::focusNotify (    )  const [inline]

Returns if the window wants to be notified when it receives focus. Definition at line 557 of file client.hh. { return _focus_notify; }

bool ob::Client::fullscreen (    )  const [inline]

Returns if the window is in fullscreen mode. Definition at line 609 of file client.hh. Referenced by applyStartupState(), and setState(). { return _fullscreen; }

void ob::Client::fullscreen (  bool    fs, bool    savearea )  [private]

Fullscreen's or unfullscreen's the client window. Parameters: fs  true if the window should be made fullscreen; false if it should be returned to normal state. 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. Definition at line 1538 of file client.cc. References _area, _decorations, _fullscreen, _functions, ob::Screen::area(), changeAllowedActions(), changeState(), DecorationFlags, focus(), Func_Close, Func_Fullscreen, Func_Iconify, FunctionFlags, otk::Property::get(), otk::ScreenInfo::height(), otk::Rect::height(), internal_resize(), ob::openbox, ob::Screen::raiseWindow(), ob::Openbox::screen(), otk::Property::set(), otk::ScreenInfo::width(), otk::Rect::width(), otk::Rect::x(), and otk::Rect::y(). { static FunctionFlags saved_func; static DecorationFlags saved_decor; if (!(_functions & Func_Fullscreen) || // can't _fullscreen == fs) return; // already done _fullscreen = fs; changeState(); // change the state hints on the client int x = _area.x(), y = _area.y(), w = _area.width(), h = _area.height(); if (fs) { // save the functions and remove them saved_func = _functions; _functions = _functions & (Func_Close | Func_Fullscreen | Func_Iconify); // save the decorations and remove them saved_decor = _decorations; _decorations = 0; if (savearea) { long dimensions[4]; dimensions[0] = _area.x(); dimensions[1] = _area.y(); dimensions[2] = _area.width(); dimensions[3] = _area.height(); otk::Property::set(_window, otk::Property::atoms.openbox_premax, otk::Property::atoms.cardinal, (long unsigned*)dimensions, 4); } const otk::ScreenInfo *info = otk::display->screenInfo(_screen); x = 0; y = 0; w = info->width(); h = info->height(); } else { _functions = saved_func; _decorations = saved_decor; long *dimensions; long unsigned n = 4; if (otk::Property::get(_window, otk::Property::atoms.openbox_premax, otk::Property::atoms.cardinal, &n, (long unsigned**) &dimensions)) { if (n >= 4) { x = dimensions[0]; y = dimensions[1]; w = dimensions[2]; h = dimensions[3]; } delete dimensions; } else { // pick some fallbacks... const otk::Rect &a = openbox->screen(_screen)->area(); x = a.x() + a.width() / 4; y = a.y() + a.height() / 4; w = a.width() / 2; h = a.height() / 2; } } changeAllowedActions(); // based on the new _functions // when fullscreening, don't obey things like increments, fill the screen internal_resize(TopLeft, w, h, !fs, x, y); // raise (back) into our stacking layer openbox->screen(_screen)->raiseWindow(this); // try focus us when we go into fullscreen mode if (fs) focus(); }

FunctionFlags ob::Client::funtions (    )  const [inline]

Returns the functions that the user can perform on the window. Definition at line 585 of file client.hh. { return _functions; }

void ob::Client::getArea (    )  [private]

Gets the position and size of the window and sets Client::_area. Definition at line 353 of file client.cc. References _area, _border_width, and otk::Rect::setRect(). Referenced by Client(). { XWindowAttributes wattrib; Status ret; ret = XGetWindowAttributes(**otk::display, _window, &wattrib); assert(ret != BadWindow); _area.setRect(wattrib.x, wattrib.y, wattrib.width, wattrib.height); _border_width = wattrib.border_width; }

void ob::Client::getDesktop (    )  [private]

Retrieves the desktop hint's value and sets Client::_desktop. Definition at line 146 of file client.cc. References _desktop, ob::Screen::desktop(), otk::Property::get(), ob::openbox, and ob::Openbox::screen(). Referenced by Client(). { // defaults to the current desktop _desktop = openbox->screen(_screen)->desktop(); if (otk::Property::get(_window, otk::Property::atoms.net_wm_desktop, otk::Property::atoms.cardinal, (long unsigned*)&_desktop)) { #ifdef DEBUG // printf("Window requested desktop: %ld\n", _desktop); #endif } }

void ob::Client::getGravity (    )  [private]

Retrieves the window's initial gravity. Definition at line 135 of file client.cc. References _gravity. Referenced by Client(). { XWindowAttributes wattrib; Status ret; ret = XGetWindowAttributes(**otk::display, _window, &wattrib); assert(ret != BadWindow); _gravity = wattrib.win_gravity; }

void ob::Client::getMwmHints (    )  [private]

Gets the MWM Hints and adjusts Client::_functions and Client::_decorations. Definition at line 330 of file client.cc. References _mwmhints, ob::MwmHints::decorations, ob::MwmHints::flags, ob::MwmHints::functions, and otk::Property::get(). Referenced by Client(). { unsigned long num = MwmHints::elements; unsigned long *hints; _mwmhints.flags = 0; // default to none if (!otk::Property::get(_window, otk::Property::atoms.motif_wm_hints, otk::Property::atoms.motif_wm_hints, &num, (unsigned long **)&hints)) return; if (num >= MwmHints::elements) { // retrieved the hints _mwmhints.flags = hints[0]; _mwmhints.functions = hints[1]; _mwmhints.decorations = hints[2]; } delete [] hints; }

void ob::Client::getShaped (    )  [private]

Determines if the window uses the Shape extension and sets Client::_shaped. Definition at line 404 of file client.cc. References _shaped. Referenced by Client(). { _shaped = false; #ifdef SHAPE if (otk::display->shape()) { int foo; unsigned int ufoo; int s; XShapeSelectInput(**otk::display, _window, ShapeNotifyMask); XShapeQueryExtents(**otk::display, _window, &s, &foo, &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo); _shaped = (s != 0); } #endif // SHAPE }

void ob::Client::getState (    )  [private]

Gets the net_state hint and sets the boolean flags for any states set in the hint. Definition at line 366 of file client.cc. References _above, _below, _fullscreen, _iconic, _max_horz, _max_vert, _modal, _shaded, _skip_pager, _skip_taskbar, otk::Property::atoms, and otk::Property::get(). Referenced by Client(). { _modal = _shaded = _max_horz = _max_vert = _fullscreen = _above = _below = _iconic = _skip_taskbar = _skip_pager = false; unsigned long *state; unsigned long num = (unsigned) -1; if (otk::Property::get(_window, otk::Property::atoms.net_wm_state, otk::Property::atoms.atom, &num, &state)) { for (unsigned long i = 0; i < num; ++i) { if (state[i] == otk::Property::atoms.net_wm_state_modal) _modal = true; else if (state[i] == otk::Property::atoms.net_wm_state_shaded) _shaded = true; else if (state[i] == otk::Property::atoms.net_wm_state_hidden) _iconic = true; else if (state[i] == otk::Property::atoms.net_wm_state_skip_taskbar) _skip_taskbar = true; else if (state[i] == otk::Property::atoms.net_wm_state_skip_pager) _skip_pager = true; else if (state[i] == otk::Property::atoms.net_wm_state_fullscreen) _fullscreen = true; else if (state[i] == otk::Property::atoms.net_wm_state_maximized_vert) _max_vert = true; else if (state[i] == otk::Property::atoms.net_wm_state_maximized_horz) _max_horz = true; else if (state[i] == otk::Property::atoms.net_wm_state_above) _above = true; else if (state[i] == otk::Property::atoms.net_wm_state_below) _below = true; } delete [] state; } }

void ob::Client::getType (    )  [private]

Retrieves the window's type and sets Client::_type. Definition at line 161 of file client.cc. References _mwmhints, _type, otk::Property::atoms, ob::MwmHints::decorations, ob::MwmHints::flags, ob::MwmHints::functions, otk::Property::get(), MwmFlag_Decorations, MwmFlag_Functions, Type_Desktop, Type_Dialog, Type_Dock, Type_Menu, Type_Normal, Type_Splash, Type_Toolbar, and Type_Utility. Referenced by Client(), and propertyHandler(). { _type = (WindowType) -1; unsigned long *val; unsigned long num = (unsigned) -1; if (otk::Property::get(_window, otk::Property::atoms.net_wm_window_type, otk::Property::atoms.atom, &num, &val)) { // use the first value that we know about in the array for (unsigned long i = 0; i < num; ++i) { if (val[i] == otk::Property::atoms.net_wm_window_type_desktop) _type = Type_Desktop; else if (val[i] == otk::Property::atoms.net_wm_window_type_dock) _type = Type_Dock; else if (val[i] == otk::Property::atoms.net_wm_window_type_toolbar) _type = Type_Toolbar; else if (val[i] == otk::Property::atoms.net_wm_window_type_menu) _type = Type_Menu; else if (val[i] == otk::Property::atoms.net_wm_window_type_utility) _type = Type_Utility; else if (val[i] == otk::Property::atoms.net_wm_window_type_splash) _type = Type_Splash; else if (val[i] == otk::Property::atoms.net_wm_window_type_dialog) _type = Type_Dialog; else if (val[i] == otk::Property::atoms.net_wm_window_type_normal) _type = Type_Normal; else if (val[i] == otk::Property::atoms.kde_net_wm_window_type_override){ // prevent this window from getting any decor or functionality _mwmhints.flags &= MwmFlag_Functions | MwmFlag_Decorations; _mwmhints.decorations = 0; _mwmhints.functions = 0; } if (_type != (WindowType) -1) break; // grab the first known type } delete val; } if (_type == (WindowType) -1) { /* * the window type hint was not set, which means we either classify ourself * as a normal window or a dialog, depending on if we are a transient. */ if (_transient_for) _type = Type_Dialog; else _type = Type_Normal; } }

int ob::Client::gravity (    )  const [inline]

Returns the window's gravity. This value determines where to place the decorated window in relation to its position without decorations. One of: NorthWestGravity, SouthWestGravity, EastGravity, ..., SouthGravity, StaticGravity, ForgetGravity Definition at line 569 of file client.hh. Referenced by ob::Frame::clientGravity(), and ob::Frame::frameGravity(). { return _gravity; }

bool ob::Client::iconic (    )  const [inline]

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 Definition at line 615 of file client.hh. { return _iconic; }

const otk::ustring& ob::Client::iconTitle (    )  const [inline]

Returns the window's title when it is iconified. Definition at line 542 of file client.hh. { return _title; }

void ob::Client::installColormap (  bool    install )  const

Definition at line 1620 of file client.cc. Referenced by ob::Openbox::setFocusedClient(). { XWindowAttributes wa; if (XGetWindowAttributes(**otk::display, _window, &wa)) { if (install) XInstallColormap(**otk::display, wa.colormap); else XUninstallColormap(**otk::display, wa.colormap); } }

void ob::Client::internal_move (  int    x, int    y )  [private]

Internal version of the Client::move function. Parameters: x  The X coordinate to move to. y  The Y coordinate to move to. Definition at line 1219 of file client.cc. References _area, _border_width, _window, ob::Frame::adjustPosition(), frame, otk::Rect::height(), otk::Strut::left, ob::Frame::plate(), otk::Rect::setPos(), ob::Frame::size(), otk::Strut::top, and otk::Rect::width(). Referenced by configureRequestHandler(), internal_resize(), and move(). { _area.setPos(x, y); // move the frame to be in the requested position if (frame) { // this can be called while mapping, before frame exists frame->adjustPosition(); // send synthetic configure notify (we don't need to if we aren't mapped // yet) XEvent event; event.type = ConfigureNotify; event.xconfigure.display = **otk::display; event.xconfigure.event = _window; event.xconfigure.window = _window; // root window coords with border in mind event.xconfigure.x = x - _border_width + frame->size().left; event.xconfigure.y = y - _border_width + frame->size().top; event.xconfigure.width = _area.width(); event.xconfigure.height = _area.height(); event.xconfigure.border_width = _border_width; event.xconfigure.above = frame->plate(); event.xconfigure.override_redirect = False; XSendEvent(event.xconfigure.display, event.xconfigure.window, False, StructureNotifyMask, &event); #if 0//def DEBUG printf("Sent synthetic ConfigureNotify %d,%d %d,%d to 0x%lx\n", event.xconfigure.x, event.xconfigure.y, event.xconfigure.width, event.xconfigure.height, event.xconfigure.window); #endif } }

void ob::Client::internal_resize (  Corner    anchor, int    w, int    h, bool    user = true, int    x = INT_MIN, int    y = INT_MIN )  [private]

Internal version of the Client::resize function. This also maintains things like the client's minsize, and size increments. Parameters: anchor  The corner to keep in the same position when resizing. w  The width component of the new size for the client. h  The height component of the new size for the client. user  Specifies whether this is a user-requested change or a program requested change. x  An optional X coordinate to which the window will be moved after resizing. 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. Definition at line 1129 of file client.cc. References _area, _base_size, _logical_size, _max_ratio, _max_size, _min_ratio, _min_size, _size_inc, ob::Frame::adjustSize(), BottomLeft, BottomRight, frame, otk::Rect::height(), internal_move(), otk::Point::setPoint(), otk::Rect::setSize(), TopLeft, TopRight, otk::Rect::width(), otk::Rect::x(), otk::Point::x(), otk::Rect::y(), and otk::Point::y(). Referenced by configureRequestHandler(), fullscreen(), maximize(), and resize(). { w -= _base_size.x(); h -= _base_size.y(); if (user) { // for interactive resizing. have to move half an increment in each // direction. int mw = w % _size_inc.x(); // how far we are towards the next size inc int mh = h % _size_inc.y(); int aw = _size_inc.x() / 2; // amount to add int ah = _size_inc.y() / 2; // don't let us move into a new size increment if (mw + aw >= _size_inc.x()) aw = _size_inc.x() - mw - 1; if (mh + ah >= _size_inc.y()) ah = _size_inc.y() - mh - 1; w += aw; h += ah; // if this is a user-requested resize, then check against min/max sizes // and aspect ratios // smaller than min size or bigger than max size? if (w < _min_size.x()) w = _min_size.x(); else if (w > _max_size.x()) w = _max_size.x(); if (h < _min_size.y()) h = _min_size.y(); else if (h > _max_size.y()) h = _max_size.y(); // adjust the height ot match the width for the aspect ratios if (_min_ratio) if (h * _min_ratio > w) h = static_cast<int>(w / _min_ratio); if (_max_ratio) if (h * _max_ratio < w) h = static_cast<int>(w / _max_ratio); } // keep to the increments w /= _size_inc.x(); h /= _size_inc.y(); // you cannot resize to nothing if (w < 1) w = 1; if (h < 1) h = 1; // store the logical size _logical_size.setPoint(w, h); w *= _size_inc.x(); h *= _size_inc.y(); w += _base_size.x(); h += _base_size.y(); if (x == INT_MIN || y == INT_MIN) { x = _area.x(); y = _area.y(); switch (anchor) { case TopLeft: break; case TopRight: x -= w - _area.width(); break; case BottomLeft: y -= h - _area.height(); break; case BottomRight: x -= w - _area.width(); y -= h - _area.height(); break; } } _area.setSize(w, h); XResizeWindow(**otk::display, _window, w, h); // resize the frame to match the request frame->adjustSize(); internal_move(x, y); }

StackLayer ob::Client::layer (    )  const [inline]

Returns the window's stacking layer. Definition at line 621 of file client.hh. References StackLayer. Referenced by ob::Screen::lowerWindow(), and ob::Screen::raiseWindow(). { return _layer; }

const otk::Point& ob::Client::logicalSize (    )  const [inline]

Returns 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. Definition at line 630 of file client.hh. { return _logical_size; }

void ob::Client::mapRequestHandler (  const XMapRequestEvent &    e )  [virtual]

Called when a different client tries to map a window. Reimplemented from otk::EventHandler. Definition at line 1853 of file client.cc. References ob::Screen::desktop(), ob::openbox, ob::Openbox::screen(), and setDesktop(). { #ifdef DEBUG printf("MapRequest for already managed 0x%lx\n", e.window); #endif // DEBUG assert(_iconic); // we shouldn't be able to get this unless we're iconic // move to the current desktop (uniconify) setDesktop(openbox->screen(_screen)->desktop()); // XXX: should we focus/raise the window? (basically a net_wm_active_window) }

bool ob::Client::maxHorz (    )  const [inline]

Returns if the window is maximized horizontally. Definition at line 619 of file client.hh. Referenced by ob::ButtonWidget::setTextures(), and ob::ButtonWidget::update(). { return _max_horz; }

void ob::Client::maximize (  bool    max, int    dir, bool    savearea )  [private]

Maximize or unmaximize the client window. Parameters: max  true if the window should be maximized; false if it should be returned to normal size. dir  0 to set both horz and vert, 1 to set horz, 2 to set vert. 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. Definition at line 1431 of file client.cc. References _area, _functions, _max_horz, _max_vert, ob::Screen::area(), otk::Strut::bottom, changeState(), otk::Property::erase(), frame, ob::Frame::frameGravity(), Func_Maximize, otk::Property::get(), otk::Rect::height(), internal_resize(), ob::openbox, otk::Widget::rect(), ob::Openbox::screen(), otk::Property::set(), ob::Frame::size(), otk::Strut::top, otk::Rect::width(), otk::Rect::x(), and otk::Rect::y(). Referenced by applyStartupState(), remaximize(), and setState(). { assert(dir == 0 || dir == 1 || dir == 2); if (!(_functions & Func_Maximize)) return; // can't // check if already done if (max) { if (dir == 0 && _max_horz && _max_vert) return; if (dir == 1 && _max_horz) return; if (dir == 2 && _max_vert) return; } else { if (dir == 0 && !_max_horz && !_max_vert) return; if (dir == 1 && !_max_horz) return; if (dir == 2 && !_max_vert) return; } const otk::Rect &a = openbox->screen(_screen)->area(); int x = frame->rect().x(), y = frame->rect().y(), w = _area.width(), h = _area.height(); if (max) { if (savearea) { long dimensions[4]; long *readdim; unsigned long n = 4; dimensions[0] = x; dimensions[1] = y; dimensions[2] = w; dimensions[3] = h; // get the property off the window and use it for the dimentions we are // already maxed on if (otk::Property::get(_window, otk::Property::atoms.openbox_premax, otk::Property::atoms.cardinal, &n, (long unsigned**) &readdim)) { if (n >= 4) { if (_max_horz) { dimensions[0] = readdim[0]; dimensions[2] = readdim[2]; } if (_max_vert) { dimensions[1] = readdim[1]; dimensions[3] = readdim[3]; } } delete readdim; } otk::Property::set(_window, otk::Property::atoms.openbox_premax, otk::Property::atoms.cardinal, (long unsigned*)dimensions, 4); } if (dir == 0 || dir == 1) { // horz x = a.x(); w = a.width(); } if (dir == 0 || dir == 2) { // vert y = a.y(); h = a.height() - frame->size().top - frame->size().bottom; } } else { long *dimensions; long unsigned n = 4; if (otk::Property::get(_window, otk::Property::atoms.openbox_premax, otk::Property::atoms.cardinal, &n, (long unsigned**) &dimensions)) { if (n >= 4) { if (dir == 0 || dir == 1) { // horz x = (signed int)dimensions[0]; w = (signed int)dimensions[2]; } if (dir == 0 || dir == 2) { // vert y = (signed int)dimensions[1]; h = (signed int)dimensions[3]; } } delete dimensions; } else { // pick some fallbacks... if (dir == 0 || dir == 1) { // horz x = a.x() + a.width() / 4; w = a.width() / 2; } if (dir == 0 || dir == 2) { // vert y = a.y() + a.height() / 4; h = a.height() / 2; } } } if (dir == 0 || dir == 1) // horz _max_horz = max; if (dir == 0 || dir == 2) // vert _max_vert = max; if (!_max_horz && !_max_vert) otk::Property::erase(_window, otk::Property::atoms.openbox_premax); changeState(); // change the state hints on the client frame->frameGravity(x, y); // figure out where the client should be going internal_resize(TopLeft, w, h, true, x, y); }

bool ob::Client::maxVert (    )  const [inline]

Returns if the window is maximized vertically. Definition at line 617 of file client.hh. Referenced by ob::ButtonWidget::setTextures(), and ob::ButtonWidget::update(). { return _max_vert; }

bool ob::Client::modal (    )  const [inline]

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. Definition at line 598 of file client.hh. Referenced by ob::Screen::lowerWindow(), and setState(). { return _modal; }

Client* ob::Client::modalChild (    )  const [inline]

Returns the window which is a modal child of this window. Definition at line 591 of file client.hh. Referenced by ob::Screen::raiseWindow(). { return _modal_child; }

void ob::Client::move (  int    x, int    y )

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. Parameters: x  The X coordinate to move to. y  The Y coordinate to move to. Definition at line 1210 of file client.cc. References _functions, frame, ob::Frame::frameGravity(), Func_Move, and internal_move(). { if (!(_functions & Func_Move)) return; frame->frameGravity(x, y); // get the client's position based on x,y for the // frame internal_move(x, y); }

bool ob::Client::normal (    )  const [inline]

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. Definition at line 528 of file client.hh. References Type_Desktop, Type_Dock, and Type_Splash. { return ! (_type == Type_Desktop || _type == Type_Dock || _type == Type_Splash); }

bool ob::Client::positionRequested (    )  const [inline]

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 Definition at line 576 of file client.hh. { return _positioned; }

void ob::Client::propertyHandler (  const XPropertyEvent &    e )  [virtual]

Called when a property of a window changes. Reimplemented from otk::EventHandler. Definition at line 693 of file client.cc. References otk::Property::atoms, calcLayer(), getType(), otk::EventHandler::propertyHandler(), setupDecorAndFunctions(), updateClass(), updateIconTitle(), updateNormalHints(), updateProtocols(), updateStrut(), updateTitle(), updateTransientFor(), updateWMHints(), and validate(). { otk::EventHandler::propertyHandler(e); // validate cuz we query stuff off the client here if (!validate()) return; // compress changes to a single property into a single change XEvent ce; while (XCheckTypedEvent(**otk::display, e.type, &ce)) { // XXX: it would be nice to compress ALL changes to a property, not just // changes in a row without other props between. if (ce.xproperty.atom != e.atom) { XPutBackEvent(**otk::display, &ce); break; } } if (e.atom == XA_WM_NORMAL_HINTS) { updateNormalHints(); setupDecorAndFunctions(); // normal hints can make a window non-resizable } else if (e.atom == XA_WM_HINTS) updateWMHints(); else if (e.atom == XA_WM_TRANSIENT_FOR) { updateTransientFor(); getType(); calcLayer(); // type may have changed, so update the layer setupDecorAndFunctions(); } else if (e.atom == otk::Property::atoms.net_wm_name || e.atom == otk::Property::atoms.wm_name) updateTitle(); else if (e.atom == otk::Property::atoms.net_wm_icon_name || e.atom == otk::Property::atoms.wm_icon_name) updateIconTitle(); else if (e.atom == otk::Property::atoms.wm_class) updateClass(); else if (e.atom == otk::Property::atoms.wm_protocols) { updateProtocols(); setupDecorAndFunctions(); } else if (e.atom == otk::Property::atoms.net_wm_strut) updateStrut(); }

void ob::Client::remaximize (    )

Reapplies the maximized state to the window. Use this to make the window readjust its maximized size to new surroundings (struts, etc). Definition at line 1350 of file client.cc. References _max_horz, _max_vert, and maximize(). { int dir; if (_max_horz && _max_vert) dir = 0; else if (_max_horz) dir = 1; else if (_max_vert) dir = 2; else return; // not maximized _max_horz = _max_vert = false; maximize(true, dir, false); }

void ob::Client::reparentHandler (  const XReparentEvent &    e )  [virtual]

Called when a window is reparented. Reimplemented from otk::EventHandler. Definition at line 1825 of file client.cc. References frame, ob::openbox, ob::Frame::plate(), otk::EventHandler::reparentHandler(), ob::Openbox::screen(), and ob::Screen::unmanageWindow(). { // this is when the client is first taken captive in the frame if (e.parent == frame->plate()) return; #ifdef DEBUG printf("ReparentNotify for 0x%lx\n", e.window); #endif // DEBUG otk::EventHandler::reparentHandler(e); /* This event is quite rare and is usually handled in unmapHandler. However, if the window is unmapped when the reparent event occurs, the window manager never sees it because an unmap event is not sent to an already unmapped window. */ // we don't want the reparent event, put it back on the stack for the X // server to deal with after we unmanage the window XEvent ev; ev.xreparent = e; XPutBackEvent(**otk::display, &ev); // this deletes us etc openbox->screen(_screen)->unmanageWindow(this); }

void ob::Client::resize (  Corner    anchor, int    w, int    h )

Resizes the client window, anchoring it in a given corner. This also maintains things like the client's minsize, and size increments. Parameters: anchor  The corner to keep in the same position when resizing. w  The width component of the new size for the client. h  The height component of the new size for the client. Definition at line 1122 of file client.cc. References _functions, Func_Resize, and internal_resize(). { if (!(_functions & Func_Resize)) return; internal_resize(anchor, w, h); }

const std::string& ob::Client::role (    )  const [inline]

Returns the program-specified role of the window. Definition at line 548 of file client.hh. { return _role; }

int ob::Client::screen (    )  const [inline]

Returns the screen on which the clien resides. Definition at line 516 of file client.hh. Referenced by ob::Actions::buttonPressHandler(), ob::Actions::buttonReleaseHandler(), ob::Actions::enterHandler(), ob::Actions::leaveHandler(), and ob::Actions::motionHandler(). { return _screen; }

void ob::Client::setDesktop (  long    desktop )  [private]

Sends the window to the specified desktop. A window is iconified by sending it to the ICONIC_DESKTOP, and restored by sending it to any other valid desktop. Definition at line 754 of file client.cc. References _desktop, _iconic, _wmstate, ob::Frame::adjustState(), changeState(), ob::Screen::desktop(), frame, otk::Widget::hide(), ICONIC_DESKTOP, ignore_unmaps, ob::openbox, ob::Openbox::screen(), otk::Property::set(), and otk::Widget::show(). Referenced by applyStartupState(), clientMessageHandler(), mapRequestHandler(), and setWMState(). { if (target == _desktop) return; printf("Setting desktop %ld\n", target); if (!(target >= 0 || target == (signed)0xffffffff || target == ICONIC_DESKTOP)) return; _desktop = target; // set the desktop hint, but not if we're iconifying if (_desktop != ICONIC_DESKTOP) otk::Property::set(_window, otk::Property::atoms.net_wm_desktop, otk::Property::atoms.cardinal, (unsigned)_desktop); // 'move' the window to the new desktop if (_desktop == openbox->screen(_screen)->desktop() || _desktop == (signed)0xffffffff) frame->show(); else frame->hide(); // Handle Iconic state. Iconic state is maintained by the client being a // member of the ICONIC_DESKTOP, so this is where we make iconifying and // uniconifying happen. bool i = _desktop == ICONIC_DESKTOP; if (i != _iconic) { // has the state changed? _iconic = i; if (_iconic) { _wmstate = IconicState; ignore_unmaps++; // we unmap the client itself so that we can get MapRequest events, and // because the ICCCM tells us to! XUnmapWindow(**otk::display, _window); } else { _wmstate = NormalState; XMapWindow(**otk::display, _window); } changeState(); } frame->adjustState(); }

void ob::Client::setModal (  bool    modal )  [private]

Set whether the window is modal or not. This adjusts references in parents etc to match. Definition at line 818 of file client.cc. References _modal, _modal_child, _transient_for, and findModalChild(). Referenced by applyStartupState(), setState(), ob::Screen::unmanageWindow(), and updateTransientFor(). { if (modal == _modal) return; if (modal) { Client *c = this; while (c->_transient_for) { c = c->_transient_for; if (c->_modal_child) break; // already has a modal child c->_modal_child = this; } } else { // try find a replacement modal dialog Client *replacement = 0; Client *c = this; while (c->_transient_for) // go up the tree c = c->_transient_for; replacement = c->findModalChild(this); // find a modal child, skipping this c = this; while (c->_transient_for) { c = c->_transient_for; if (c->_modal_child != this) break; // has a different modal child c->_modal_child = replacement; } } _modal = modal; }

void ob::Client::setState (  StateAction    action, long    data1, long    data2 )  [private]

Adjusts the window's net_state. This should not be called as part of the window mapping process! It is for use when updating the state post-mapping. Client::applyStartupState is used to do the same things during the mapping process. Definition at line 849 of file client.cc. References _above, _below, _fullscreen, _max_horz, _max_vert, _modal, _shaded, _skip_pager, _skip_taskbar, otk::Property::atoms, calcLayer(), changeState(), fullscreen(), maximize(), modal(), setModal(), shade(), State_Add, State_Remove, and State_Toggle. Referenced by clientMessageHandler(). { bool shadestate = _shaded; bool fsstate = _fullscreen; bool maxh = _max_horz; bool maxv = _max_vert; bool modal = _modal; if (!(action == State_Add || action == State_Remove || action == State_Toggle)) return; // an invalid action was passed to the client message, ignore it for (int i = 0; i < 2; ++i) { Atom state = i == 0 ? data1 : data2; if (! state) continue; // if toggling, then pick whether we're adding or removing if (action == State_Toggle) { if (state == otk::Property::atoms.net_wm_state_modal) action = _modal ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_maximized_vert) action = _max_vert ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_maximized_horz) action = _max_horz ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_shaded) action = _shaded ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) action = _skip_taskbar ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_skip_pager) action = _skip_pager ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_fullscreen) action = _fullscreen ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_above) action = _above ? State_Remove : State_Add; else if (state == otk::Property::atoms.net_wm_state_below) action = _below ? State_Remove : State_Add; } if (action == State_Add) { if (state == otk::Property::atoms.net_wm_state_modal) { if (_modal) continue; modal = true; } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) { maxv = true; } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) { if (_max_horz) continue; maxh = true; } else if (state == otk::Property::atoms.net_wm_state_shaded) { shadestate = true; } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) { _skip_taskbar = true; } else if (state == otk::Property::atoms.net_wm_state_skip_pager) { _skip_pager = true; } else if (state == otk::Property::atoms.net_wm_state_fullscreen) { fsstate = true; } else if (state == otk::Property::atoms.net_wm_state_above) { if (_above) continue; _above = true; } else if (state == otk::Property::atoms.net_wm_state_below) { if (_below) continue; _below = true; } } else { // action == State_Remove if (state == otk::Property::atoms.net_wm_state_modal) { if (!_modal) continue; modal = false; } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) { maxv = false; } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) { maxh = false; } else if (state == otk::Property::atoms.net_wm_state_shaded) { shadestate = false; } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) { _skip_taskbar = false; } else if (state == otk::Property::atoms.net_wm_state_skip_pager) { _skip_pager = false; } else if (state == otk::Property::atoms.net_wm_state_fullscreen) { fsstate = false; } else if (state == otk::Property::atoms.net_wm_state_above) { if (!_above) continue; _above = false; } else if (state == otk::Property::atoms.net_wm_state_below) { if (!_below) continue; _below = false; } } } if (maxh != _max_horz || maxv != _max_vert) { if (maxh != _max_horz && maxv != _max_vert) { // toggling both if (maxh == maxv) { // both going the same way maximize(maxh, 0, true); } else { maximize(maxh, 1, true); maximize(maxv, 2, true); } } else { // toggling one if (maxh != _max_horz) maximize(maxh, 1, true); else maximize(maxv, 2, true); } } if (modal != _modal) setModal(modal); // change fullscreen state before shading, as it will affect if the window // can shade or not if (fsstate != _fullscreen) fullscreen(fsstate, true); if (shadestate != _shaded) shade(shadestate); calcLayer(); changeState(); // change the hint to relect these changes }

void ob::Client::setupDecorAndFunctions (    )  [private]

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. Definition at line 212 of file client.cc. References _decorations, _disabled_decorations, _functions, _max_size, _min_size, _mwmhints, ob::Frame::adjustPosition(), ob::Frame::adjustSize(), changeAllowedActions(), Decor_AllDesktops, Decor_Border, Decor_Close, Decor_Handle, Decor_Iconify, Decor_Maximize, Decor_Titlebar, ob::MwmHints::decorations, ob::MwmHints::flags, frame, Func_Close, Func_Fullscreen, Func_Iconify, Func_Maximize, Func_Move, Func_Resize, Func_Shade, ob::MwmHints::functions, MwmDecor_All, MwmDecor_Border, MwmDecor_Handle, MwmDecor_Iconify, MwmDecor_Maximize, MwmDecor_Title, MwmFlag_Decorations, MwmFlag_Functions, MwmFunc_All, MwmFunc_Iconify, MwmFunc_Maximize, MwmFunc_Move, MwmFunc_Resize, Type_Desktop, Type_Dialog, Type_Dock, Type_Menu, Type_Normal, Type_Splash, Type_Toolbar, Type_Utility, otk::Point::x(), and otk::Point::y(). Referenced by Client(), disableDecorations(), and propertyHandler(). { // start with everything (cept fullscreen) _decorations = Decor_Titlebar | Decor_Handle | Decor_Border | Decor_AllDesktops | Decor_Iconify | Decor_Maximize; _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize | Func_Shade; if (_delete_window) { _decorations |= Decor_Close; _functions |= Func_Close; } if (!(_min_size.x() < _max_size.x() || _min_size.y() < _max_size.y())) { _decorations &= ~(Decor_Maximize | Decor_Handle); _functions &= ~(Func_Resize | Func_Maximize); } switch (_type) { case Type_Normal: // normal windows retain all of the possible decorations and // functionality, and are the only windows that you can fullscreen _functions |= Func_Fullscreen; break; case Type_Dialog: // dialogs cannot be maximized _decorations &= ~Decor_Maximize; _functions &= ~Func_Maximize; break; case Type_Menu: case Type_Toolbar: case Type_Utility: // these windows get less functionality _decorations &= ~(Decor_Iconify | Decor_Handle); _functions &= ~(Func_Iconify | Func_Resize); break; case Type_Desktop: case Type_Dock: case Type_Splash: // none of these windows are manipulated by the window manager _decorations = 0; _functions = 0; break; } // Mwm Hints are applied subtractively to what has already been chosen for // decor and functionality if (_mwmhints.flags & MwmFlag_Decorations) { if (! (_mwmhints.decorations & MwmDecor_All)) { if (! (_mwmhints.decorations & MwmDecor_Border)) _decorations &= ~Decor_Border; if (! (_mwmhints.decorations & MwmDecor_Handle)) _decorations &= ~Decor_Handle; if (! (_mwmhints.decorations & MwmDecor_Title)) { _decorations &= ~Decor_Titlebar; // if we don't have a titlebar, then we cannot shade! _functions &= ~Func_Shade; } if (! (_mwmhints.decorations & MwmDecor_Iconify)) _decorations &= ~Decor_Iconify; if (! (_mwmhints.decorations & MwmDecor_Maximize)) _decorations &= ~Decor_Maximize; } } if (_mwmhints.flags & MwmFlag_Functions) { if (! (_mwmhints.functions & MwmFunc_All)) { if (! (_mwmhints.functions & MwmFunc_Resize)) _functions &= ~Func_Resize; if (! (_mwmhints.functions & MwmFunc_Move)) _functions &= ~Func_Move; if (! (_mwmhints.functions & MwmFunc_Iconify)) _functions &= ~Func_Iconify; if (! (_mwmhints.functions & MwmFunc_Maximize)) _functions &= ~Func_Maximize; // dont let mwm hints kill the close button //if (! (_mwmhints.functions & MwmFunc_Close)) // _functions &= ~Func_Close; } } // can't maximize without moving/resizing if (!((_functions & Func_Move) && (_functions & Func_Resize))) _functions &= ~Func_Maximize; // finally, user specified disabled decorations are applied to subtract // decorations if (_disabled_decorations & Decor_Titlebar) _decorations &= ~Decor_Titlebar; if (_disabled_decorations & Decor_Handle) _decorations &= ~Decor_Handle; if (_disabled_decorations & Decor_Border) _decorations &= ~Decor_Border; if (_disabled_decorations & Decor_Iconify) _decorations &= ~Decor_Iconify; if (_disabled_decorations & Decor_Maximize) _decorations &= ~Decor_Maximize; if (_disabled_decorations & Decor_AllDesktops) _decorations &= ~Decor_AllDesktops; if (_disabled_decorations & Decor_Close) _decorations &= ~Decor_Close; // You can't shade without a titlebar if (!(_decorations & Decor_Titlebar)) _functions &= ~Func_Shade; changeAllowedActions(); if (frame) { frame->adjustSize(); // change the decors on the frame frame->adjustPosition(); // with more/less decorations, we may need to be // moved } }

void ob::Client::setWMState (  long    state )  [private]

Sets the wm_state to the specified value. Definition at line 739 of file client.cc. References _wmstate, ob::Screen::desktop(), ob::openbox, ob::Openbox::screen(), and setDesktop(). Referenced by clientMessageHandler(). { if (state == _wmstate) return; // no change switch (state) { case IconicState: setDesktop(ICONIC_DESKTOP); break; case NormalState: setDesktop(openbox->screen(_screen)->desktop()); break; } }

void ob::Client::shade (  bool    shade )  [private]

Shades or unshades the client window. Parameters: shade  true if the window should be shaded; false if it should be unshaded. Definition at line 1417 of file client.cc. References _functions, _iconic, _shaded, _wmstate, ob::Frame::adjustSize(), changeState(), frame, and Func_Shade. Referenced by applyStartupState(), clientMessageHandler(), and setState(). { if (!(_functions & Func_Shade) || // can't _shaded == shade) return; // already done // when we're iconic, don't change the wmstate if (!_iconic) _wmstate = shade ? IconicState : NormalState; _shaded = shade; changeState(); frame->adjustSize(); }

bool ob::Client::shaded (    )  const [inline]

Returns if the window is shaded. When the window is shaded, only its titlebar is visible. Definition at line 607 of file client.hh. Referenced by ob::Frame::adjustSize(). { return _shaded; }

bool ob::Client::shaped (    )  const [inline]

Returns if the window uses the Shape extension. Definition at line 561 of file client.hh. Referenced by ob::Frame::adjustShape(). { return _shaped; }

bool ob::Client::skipPager (    )  const [inline]

The window should not be displayed by pagers. Definition at line 600 of file client.hh. { return _skip_pager; }

bool ob::Client::skipTaskbar (    )  const [inline]

The window should not be displayed by taskbars. Definition at line 602 of file client.hh. { return _skip_taskbar; }

const otk::Strut& ob::Client::strut (    )  const [inline]

Returns the client's strut definition. Definition at line 636 of file client.hh. { return _strut; }

const otk::ustring& ob::Client::title (    )  const [inline]

Returns the window's title. Definition at line 540 of file client.hh. Referenced by ob::Frame::Frame(). { return _title; }

void ob::Client::toggleClientBorder (  bool    addborder )  [private]

Removes or reapplies the client's border to its window. Used when managing and unmanaging a window. Parameters: addborder  true if adding the border to the client; false if removing from the client Definition at line 966 of file client.cc. References _area, _border_width, otk::Rect::setPos(), otk::Rect::x(), and otk::Rect::y(). Referenced by ob::Screen::manageWindow(), and ob::Screen::unmanageWindow(). { // adjust our idea of where the client is, based on its border. When the // border is removed, the client should now be considered to be in a // different position. // when re-adding the border to the client, the same operation needs to be // reversed. int oldx = _area.x(), oldy = _area.y(); int x = oldx, y = oldy; switch(_gravity) { default: case NorthWestGravity: case WestGravity: case SouthWestGravity: break; case NorthEastGravity: case EastGravity: case SouthEastGravity: if (addborder) x -= _border_width * 2; else x += _border_width * 2; break; case NorthGravity: case SouthGravity: case CenterGravity: case ForgetGravity: case StaticGravity: if (addborder) x -= _border_width; else x += _border_width; break; } switch(_gravity) { default: case NorthWestGravity: case NorthGravity: case NorthEastGravity: break; case SouthWestGravity: case SouthGravity: case SouthEastGravity: if (addborder) y -= _border_width * 2; else y += _border_width * 2; break; case WestGravity: case EastGravity: case CenterGravity: case ForgetGravity: case StaticGravity: if (addborder) y -= _border_width; else y += _border_width; break; } _area.setPos(x, y); if (addborder) { XSetWindowBorderWidth(**otk::display, _window, _border_width); // move the client so it is back it the right spot _with_ its border! if (x != oldx || y != oldy) XMoveWindow(**otk::display, _window, x, y); } else XSetWindowBorderWidth(**otk::display, _window, 0); }

Client* ob::Client::transientFor (    )  const [inline]

Return the client this window is transient for. Definition at line 588 of file client.hh. Referenced by ob::Screen::lowerWindow(). { return _transient_for; }

WindowType ob::Client::type (    )  const [inline]

Returns the type of the window, one of the Client::WindowType values. Reimplemented from ob::WidgetBase. Definition at line 522 of file client.hh. References WindowType. { return _type; }

void ob::Client::unfocus (    )  const

Remove focus from the client window. Definition at line 1685 of file client.cc. References _focused, ob::Openbox::focusedClient(), ob::openbox, and ob::Openbox::setFocusedClient(). Referenced by ob::Screen::unmanageWindow(). { if (!_focused) return; assert(openbox->focusedClient() == this); openbox->setFocusedClient(0); }

void ob::Client::unfocusHandler (  const XFocusChangeEvent &    e )  [virtual]

Called when a window looses focus. Reimplemented from otk::EventHandler. Definition at line 1709 of file client.cc. References _focused, ob::Openbox::focusedClient(), frame, ob::openbox, ob::Openbox::setFocusedClient(), ob::Frame::unfocus(), and otk::EventHandler::unfocusHandler(). { #ifdef DEBUG // printf("FocusOut for 0x%lx\n", e.window); #endif // DEBUG otk::EventHandler::unfocusHandler(e); frame->unfocus(); _focused = false; if (openbox->focusedClient() == this) openbox->setFocusedClient(0); }

void ob::Client::unmapHandler (  const XUnmapEvent &    e )  [virtual]

Called when a window is unmapped. Reimplemented from otk::EventHandler. Definition at line 1791 of file client.cc. References ignore_unmaps, ob::openbox, ob::Openbox::screen(), ob::Screen::unmanageWindow(), and otk::EventHandler::unmapHandler(). Referenced by focus(). { if (ignore_unmaps) { #ifdef DEBUG // printf("Ignored UnmapNotify for 0x%lx (event 0x%lx)\n", e.window, e.event); #endif // DEBUG ignore_unmaps--; return; } #ifdef DEBUG printf("UnmapNotify for 0x%lx\n", e.window); #endif // DEBUG otk::EventHandler::unmapHandler(e); // this deletes us etc openbox->screen(_screen)->unmanageWindow(this); }

void ob::Client::updateClass (    )  [private]

Updates the window's application name and class. Definition at line 606 of file client.cc. References _app_class, _app_name, _role, otk::Property::get(), and otk::Property::StringVect. Referenced by Client(), and propertyHandler(). { // set the defaults _app_name = _app_class = _role = ""; otk::Property::StringVect v; unsigned long num = 2; if (otk::Property::get(_window, otk::Property::atoms.wm_class, otk::Property::ascii, &num, &v)) { if (num > 0) _app_name = v[0].c_str(); if (num > 1) _app_class = v[1].c_str(); } v.clear(); num = 1; if (otk::Property::get(_window, otk::Property::atoms.wm_window_role, otk::Property::ascii, &num, &v)) { if (num > 0) _role = v[0].c_str(); } }

void ob::Client::updateIconTitle (    )  [private]

Updates the window's icon title. Definition at line 589 of file client.cc. References _, _icon_title, _title, otk::ustring::empty(), and otk::Property::get(). Referenced by Client(), and propertyHandler(). { _icon_title = ""; // try netwm if (!otk::Property::get(_window, otk::Property::atoms.net_wm_icon_name, otk::Property::utf8, &_icon_title)) { // try old x stuff otk::Property::get(_window, otk::Property::atoms.wm_icon_name, otk::Property::ascii, &_icon_title); } if (_title.empty()) _icon_title = _("Unnamed Window"); }

void ob::Client::updateNormalHints (    )  [private]

Updates the WMNormalHints and adjusts things if they change. Definition at line 473 of file client.cc. References _area, _base_size, _gravity, _max_ratio, _max_size, _min_ratio, _min_size, _positioned, _size_inc, frame, ob::Frame::frameGravity(), otk::Widget::rect(), otk::Point::setPoint(), and otk::Rect::setPos(). Referenced by Client(), and propertyHandler(). { XSizeHints size; long ret; int oldgravity = _gravity; // defaults _min_ratio = 0.0; _max_ratio = 0.0; _size_inc.setPoint(1, 1); _base_size.setPoint(0, 0); _min_size.setPoint(0, 0); _max_size.setPoint(INT_MAX, INT_MAX); // get the hints from the window if (XGetWMNormalHints(**otk::display, _window, &size, &ret)) { _positioned = (size.flags & (PPosition|USPosition)); if (size.flags & PWinGravity) { _gravity = size.win_gravity; // if the client has a frame, i.e. has already been mapped and is // changing its gravity if (frame && _gravity != oldgravity) { // move our idea of the client's position based on its new gravity int x = frame->rect().x(), y = frame->rect().y(); frame->frameGravity(x, y); _area.setPos(x, y); } } if (size.flags & PAspect) { if (size.min_aspect.y) _min_ratio = size.min_aspect.x/size.min_aspect.y; if (size.max_aspect.y) _max_ratio = size.max_aspect.x/size.max_aspect.y; } if (size.flags & PMinSize) _min_size.setPoint(size.min_width, size.min_height); if (size.flags & PMaxSize) _max_size.setPoint(size.max_width, size.max_height); if (size.flags & PBaseSize) _base_size.setPoint(size.base_width, size.base_height); if (size.flags & PResizeInc) _size_inc.setPoint(size.width_inc, size.height_inc); } }

void ob::Client::updateProtocols (    )  [private]

Update the protocols that the window supports and adjusts things if they change. Definition at line 450 of file client.cc. References _delete_window, _focus_notify, and otk::Property::atoms. Referenced by Client(), and propertyHandler(). { Atom *proto; int num_return = 0; _focus_notify = false; _delete_window = false; if (XGetWMProtocols(**otk::display, _window, &proto, &num_return)) { for (int i = 0; i < num_return; ++i) { if (proto[i] == otk::Property::atoms.wm_delete_window) { // this means we can request the window to close _delete_window = true; } else if (proto[i] == otk::Property::atoms.wm_take_focus) // if this protocol is requested, then the window will be notified // by the window manager whenever it receives focus _focus_notify = true; } XFree(proto); } }

void ob::Client::updateStrut (    )  [private]

Updates the strut for the client. Definition at line 629 of file client.cc. References _strut, otk::Strut::bottom, otk::Property::get(), otk::Strut::left, ob::openbox, otk::Strut::right, ob::Openbox::screen(), otk::Strut::top, and ob::Screen::updateStrut(). Referenced by Client(), and propertyHandler(). { unsigned long num = 4; unsigned long *data; if (!otk::Property::get(_window, otk::Property::atoms.net_wm_strut, otk::Property::atoms.cardinal, &num, &data)) return; if (num == 4) { _strut.left = data[0]; _strut.right = data[1]; _strut.top = data[2]; _strut.bottom = data[3]; // updating here is pointless while we're being mapped cuz we're not in // the screen's client list yet if (frame) openbox->screen(_screen)->updateStrut(); } delete [] data; }

void ob::Client::updateTitle (    )  [private]

Updates the window's title. Definition at line 569 of file client.cc. References _, _title, otk::ustring::empty(), frame, otk::Property::get(), and ob::Frame::setTitle(). Referenced by Client(), and propertyHandler(). { _title = ""; // try netwm if (!otk::Property::get(_window, otk::Property::atoms.net_wm_name, otk::Property::utf8, &_title)) { // try old x stuff otk::Property::get(_window, otk::Property::atoms.wm_name, otk::Property::ascii, &_title); } if (_title.empty()) _title = _("Unnamed Window"); if (frame) frame->setTitle(_title); }

void ob::Client::updateTransientFor (    )  [private]

Updates the window's transient status, and any parents of it. Definition at line 653 of file client.cc. References _modal, _transient_for, _transients, _window, ob::Openbox::findClient(), ob::openbox, and setModal(). Referenced by Client(), and propertyHandler(). { Window t = 0; Client *c = 0; if (XGetTransientForHint(**otk::display, _window, &t) && t != _window) { // cant be transient to itself! c = openbox->findClient(t); assert(c != this); // if this happens then we need to check for it if (!c /*XXX: && _group*/) { // not transient to a client, see if it is transient for a group if (//t == _group->leader() || t == None || t == otk::display->screenInfo(_screen)->rootWindow()) { // window is a transient for its group! // XXX: for now this is treated as non-transient. // this needs to be fixed! } } } // if anything has changed... if (c != _transient_for) { bool m = _modal; if (_modal) setModal(false); if (_transient_for) _transient_for->_transients.remove(this); // remove from old parent _transient_for = c; if (_transient_for) _transient_for->_transients.push_back(this); // add to new parent if (m) setModal(true); } }

void ob::Client::updateWMHints (  bool    initstate = false )  [private]

Updates the WMHints and adjusts things if they change. Parameters: initstate  Whether to read the initial_state property from the WMHints. This should only be used during the mapping process. Definition at line 524 of file client.cc. References _can_focus, _group, _iconic, _urgent, and fireUrgent(). Referenced by Client(), and propertyHandler(). { XWMHints *hints; // assume a window takes input if it doesnt specify _can_focus = true; bool ur = false; if ((hints = XGetWMHints(**otk::display, _window)) != NULL) { if (hints->flags & InputHint) _can_focus = hints->input; // only do this when initstate is true! if (initstate && (hints->flags & StateHint)) _iconic = hints->initial_state == IconicState; if (hints->flags & XUrgencyHint) ur = true; if (hints->flags & WindowGroupHint) { if (hints->window_group != _group) { // XXX: remove from the old group if there was one _group = hints->window_group; // XXX: do stuff with the group } } else // no group! _group = None; XFree(hints); } if (ur != _urgent) { _urgent = ur; #ifdef DEBUG printf("DEBUG: Urgent Hint for 0x%lx: %s\n", (long)_window, _urgent ? "ON" : "OFF"); #endif // fire the urgent callback if we're mapped, otherwise, wait until after // we're mapped if (frame) fireUrgent(); } }

bool ob::Client::urgent (    )  const [inline]

Returns if the window has indicated that it needs urgent attention. Definition at line 555 of file client.hh. { return _urgent; }

bool ob::Client::validate (    )  const

Validate client, by making sure no Destroy or Unmap events exist in the event queue for the window. Returns: true if the client is valid; false if the client has already been unmapped/destroyed, and so is invalid. Definition at line 120 of file client.cc. Referenced by clientMessageHandler(), and propertyHandler(). { XSync(**otk::display, false); // get all events on the server XEvent e; if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &e) || XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &e)) { XPutBackEvent(**otk::display, &e); return false; } return true; }

Window ob::Client::window (    )  const [inline]

Returns the window id that the Client object is handling. Definition at line 519 of file client.hh. Referenced by ob::Frame::adjustShape(), ob::Frame::grabClient(), ob::Frame::releaseClient(), and ob::Screen::unmanageWindow(). { return _window; }

---

Friends And Related Function Documentation

void Screen::manageWindow (  Window    )  [friend]

void Screen::unmanageWindow (  Client *    )  [friend]

---

Member Data Documentation

bool ob::Client::_above [private]

The window should be on top of other windows of the same type. Definition at line 321 of file client.hh. Referenced by getState(), and setState().

std::string ob::Client::_app_class [private]

The class of the window, can used for grouping. Definition at line 203 of file client.hh. Referenced by updateClass().

std::string ob::Client::_app_name [private]

The application that created the window. Definition at line 201 of file client.hh. Referenced by updateClass().

otk::Rect ob::Client::_area [private]

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. Definition at line 216 of file client.hh. Referenced by configureRequestHandler(), fullscreen(), getArea(), internal_move(), internal_resize(), maximize(), toggleClientBorder(), and updateNormalHints().

otk::Point ob::Client::_base_size [private]

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 Definition at line 269 of file client.hh. Referenced by internal_resize(), and updateNormalHints().

bool ob::Client::_below [private]

The window should be underneath other windows of the same type. Definition at line 323 of file client.hh. Referenced by calcLayer(), getState(), and setState().

int ob::Client::_border_width [private]

Width of the border on the window. The window manager will set this to 0 while the window is being managed, but needs to restore it afterwards, so it is saved here. Definition at line 239 of file client.hh. Referenced by configureRequestHandler(), getArea(), internal_move(), and toggleClientBorder().

bool ob::Client::_can_focus [private]

Can the window receive input focus? Definition at line 289 of file client.hh. Referenced by focus(), and updateWMHints().

DecorationFlags ob::Client::_decorations [private]

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. Definition at line 332 of file client.hh. Referenced by fullscreen(), and setupDecorAndFunctions().

bool ob::Client::_delete_window [private]

True if the client supports the delete_window protocol. Definition at line 282 of file client.hh. Referenced by updateProtocols().

long ob::Client::_desktop [private]

The desktop on which the window resides (0xffffffff for all desktops). Definition at line 193 of file client.hh. Referenced by Client(), getDesktop(), and setDesktop().

DecorationFlags ob::Client::_disabled_decorations [private]

A bitmask of values in the Client::Decoration enum. Specifies the decorations that should NOT be displayed on the client. Definition at line 338 of file client.hh. Referenced by Client(), disableDecorations(), and setupDecorAndFunctions().

bool ob::Client::_focus_notify [private]

Notify the window when it receives focus? Definition at line 293 of file client.hh. Referenced by focus(), and updateProtocols().

bool ob::Client::_focused [private]

Does the client window have the input focus? Definition at line 295 of file client.hh. Referenced by Client(), focusHandler(), unfocus(), and unfocusHandler().

bool ob::Client::_fullscreen [private]

The window is a 'fullscreen' window, and should be on top of all others. Definition at line 319 of file client.hh. Referenced by applyStartupState(), fullscreen(), getState(), and setState().

FunctionFlags ob::Client::_functions [private]

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. Definition at line 345 of file client.hh. Referenced by changeAllowedActions(), close(), fullscreen(), maximize(), move(), resize(), setupDecorAndFunctions(), and shade().

int ob::Client::_gravity [private]

Where to place the decorated window in relation to the undecorated window. Definition at line 275 of file client.hh. Referenced by getGravity(), and updateNormalHints().

Window ob::Client::_group [private]

The id of the group the window belongs to. Definition at line 184 of file client.hh. Referenced by Client(), and updateWMHints().

otk::ustring ob::Client::_icon_title [private]

Window title when iconifiged. Definition at line 198 of file client.hh. Referenced by updateIconTitle().

bool ob::Client::_iconic [private]

The window is iconified. Definition at line 309 of file client.hh. Referenced by applyStartupState(), configureRequestHandler(), getState(), setDesktop(), shade(), and updateWMHints().

StackLayer ob::Client::_layer [private]

Definition at line 325 of file client.hh. Referenced by calcLayer(), and Client().

otk::Point ob::Client::_logical_size [private]

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. Definition at line 232 of file client.hh. Referenced by internal_resize().

bool ob::Client::_max_horz [private]

The window is maximized to fill the screen horizontally. Definition at line 313 of file client.hh. Referenced by applyStartupState(), getState(), maximize(), remaximize(), and setState().

float ob::Client::_max_ratio [private]

The maximum aspect ratio the client window can be sized to. A value of 0 means this is ignored. Definition at line 250 of file client.hh. Referenced by internal_resize(), and updateNormalHints().

otk::Point ob::Client::_max_size [private]

The maximum size of the client window. If the min is > the max, then the window is not resizable Definition at line 261 of file client.hh. Referenced by internal_resize(), setupDecorAndFunctions(), and updateNormalHints().

bool ob::Client::_max_vert [private]

The window is maximized to fill the screen vertically. Definition at line 311 of file client.hh. Referenced by applyStartupState(), getState(), maximize(), remaximize(), and setState().

float ob::Client::_min_ratio [private]

The minimum aspect ratio the client window can be sized to. A value of 0 means this is ignored. Definition at line 245 of file client.hh. Referenced by internal_resize(), and updateNormalHints().

otk::Point ob::Client::_min_size [private]

The minimum size of the client window. If the min is > the max, then the window is not resizable Definition at line 256 of file client.hh. Referenced by internal_resize(), setupDecorAndFunctions(), and updateNormalHints().

bool ob::Client::_modal [private]

The window is modal, so it must be processed before any windows it is related to can be focused. Definition at line 305 of file client.hh. Referenced by applyStartupState(), getState(), setModal(), setState(), and updateTransientFor().

Client* ob::Client::_modal_child [private]

If the window has a modal child window, then this will point to it. Definition at line 301 of file client.hh. Referenced by Client(), focus(), and setModal().

MwmHints ob::Client::_mwmhints [private]

Window decoration and functionality hints. Definition at line 272 of file client.hh. Referenced by getMwmHints(), getType(), and setupDecorAndFunctions().

bool ob::Client::_positioned [private]

Was the window's position requested by the application? if not, we should place the window ourselves when it first appears. Definition at line 286 of file client.hh. Referenced by Client(), and updateNormalHints().

std::string ob::Client::_role [private]

The specified role of the window, used for identification. Definition at line 205 of file client.hh. Referenced by updateClass().

int ob::Client::_screen [private]

The screen number on which the client resides. Definition at line 178 of file client.hh.

bool ob::Client::_shaded [private]

Only the window's titlebar is displayed. Definition at line 307 of file client.hh. Referenced by applyStartupState(), clientMessageHandler(), configureRequestHandler(), getState(), setState(), and shade().

bool ob::Client::_shaped [private]

The window uses shape extension to be non-rectangular? Definition at line 298 of file client.hh. Referenced by getShaped().

otk::Point ob::Client::_size_inc [private]

The size of increments to resize the client window by. Definition at line 263 of file client.hh. Referenced by internal_resize(), and updateNormalHints().

bool ob::Client::_skip_pager [private]

The window should not be displayed by pagers. Definition at line 315 of file client.hh. Referenced by getState(), and setState().

bool ob::Client::_skip_taskbar [private]

The window should not be displayed by taskbars. Definition at line 317 of file client.hh. Referenced by getState(), and setState().

otk::Strut ob::Client::_strut [private]

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. Definition at line 223 of file client.hh. Referenced by updateStrut().

otk::ustring ob::Client::_title [private]

Normal window title. Definition at line 196 of file client.hh. Referenced by updateIconTitle(), and updateTitle().

Client* ob::Client::_transient_for [private]

The client which this client is a transient (child) for. Definition at line 187 of file client.hh. Referenced by Client(), setModal(), updateTransientFor(), and ~Client().

Client::List ob::Client::_transients [private]

The clients which are transients (children) of this client. Definition at line 190 of file client.hh. Referenced by findModalChild(), updateTransientFor(), and ~Client().

WindowType ob::Client::_type [private]

The type of window (what its function is). Reimplemented from ob::WidgetBase. Definition at line 208 of file client.hh. Referenced by calcLayer(), Client(), and getType().

bool ob::Client::_urgent [private]

Urgency flag. Definition at line 291 of file client.hh. Referenced by Client(), and updateWMHints().

Window ob::Client::_window [private]

The actual window that this class is wrapping up. Definition at line 181 of file client.hh. Referenced by close(), focus(), internal_move(), and updateTransientFor().

long ob::Client::_wmstate [private]

The state of the window, one of WithdrawnState, IconicState, or NormalState. Definition at line 279 of file client.hh. Referenced by changeState(), Client(), setDesktop(), setWMState(), and shade().

const long ob::Client::event_mask [static]

Initial value: PropertyChangeMask | FocusChangeMask | StructureNotifyMask The event mask to grab on client windows. Definition at line 158 of file client.hh.

Frame* ob::Client::frame

The frame window which decorates around the client window. NOTE: This should NEVER be used inside the client class's constructor! Definition at line 66 of file client.hh. Referenced by changeState(), focus(), focusHandler(), ob::Bindings::grabButton(), internal_move(), internal_resize(), ob::Screen::lowerWindow(), ob::Screen::manageWindow(), maximize(), move(), ob::Screen::raiseWindow(), reparentHandler(), setDesktop(), setupDecorAndFunctions(), shade(), unfocusHandler(), ob::Screen::unmanageWindow(), updateNormalHints(), and updateTitle().

const long ob::Client::ICONIC_DESKTOP = 0xfffffffe [static]

The desktop value which indicated the window is iconified and not on any desktop. Definition at line 171 of file client.hh. Referenced by setDesktop().

int ob::Client::ignore_unmaps

The number of unmap events to ignore on the window. Definition at line 174 of file client.hh. Referenced by Client(), ob::Frame::grabClient(), setDesktop(), and unmapHandler().

const long ob::Client::no_propagate_mask [static]

Initial value: ButtonPressMask | ButtonReleaseMask | ButtonMotionMask 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. Definition at line 166 of file client.hh.

---

The documentation for this class was generated from the following files:

• /src/client.hh
• /src/client.cc

---