---

ob::Screen Class Reference

#include <screen.hh>

Inheritance diagram for ob::Screen:

[legend]Collaboration diagram for ob::Screen:

[legend]List of all members.

---

Detailed Description

Manages a single screen.

Definition at line 32 of file screen.hh.

Public Types
typedef std::list< otk::Strut * >	StrutList
	Holds a list of otk::Strut objects.
typedef std::list< Client * >	ClientList
	Holds a list of Clients.
Public Methods
	Screen (int screen)
	Constructs a new Screen object.
virtual	~Screen ()
	Destroys the Screen object.
int	number () const
bool	managed () const
	Returns if the screen was successfully managed.
const otk::Rect &	area () const
	Returns the area of the screen not reserved by applications' Struts.
const otk::RenderStyle *	style () const
	Returns the style in use on the screen.
Window	focuswindow () const
	An offscreen window which gets focus when nothing else has it.
long	desktop () const
	Returns the desktop being displayed.
long	numDesktops () const
	Returns the number of desktops.
void	updateStrut ()
	Update's the screen's combined strut of all the clients.
void	manageExisting ()
	Manage any pre-existing windows on the screen.
void	manageWindow (Window window)
	Manage a client window.
void	unmanageWindow (Client *client)
	Unmanage a client.
void	raiseWindow (Client *client)
	Raises a client window above all others in its stacking layer.
void	lowerWindow (Client *client)
	Lowers a client window below all others in its stacking layer.
void	setDesktopName (long i, const otk::ustring &name)
	Sets the name of a desktop by changing the root window property.
void	installColormap (bool install) const
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	mapRequestHandler (const XMapRequestEvent &e)
	Called when a different client tries to map a window.
Public Attributes
ClientList	clients
	All managed clients on the screen (in order of being mapped).
Static Public Attributes
const unsigned long	event_mask
Private Methods
void	calcArea ()
	Calculate the Screen::_area member.
void	changeSupportedAtoms ()
	Set the list of supported NETWM atoms on the root window.
void	changeClientList ()
	Set the client list on the root window.
void	changeStackingList ()
	Set the client stacking list on the root window.
void	changeWorkArea ()
	Set the work area hint on the root window.
void	updateDesktopNames ()
	Get desktop names from the root window property.
void	changeDesktop (long desktop)
	Changes to the specified desktop, displaying windows on it and hiding windows on the others.
void	changeNumDesktops (long num)
	Changes the number of desktops.
Private Attributes
bool	_managed
	Was Openbox able to manage the screen?
int	_number
	The number of the screen on the X server.
const otk::ScreenInfo *	_info
	Information about this screen.
otk::RenderStyle	_style
	The style with which to render on the screen.
bool	_root_cmap_installed
	Is the root colormap currently installed?
otk::Rect	_area
	Area usable for placement etc (total - struts).
otk::Strut	_strut
	Combined strut from all of the clients' struts.
Window	_focuswindow
	An offscreen window which gets focus when nothing else has it.
Window	_supportwindow
	An offscreen window which shows that a NETWM compliant window manager is running.
ClientList	_stacking
	A list of all managed clients on the screen, in their stacking order.
long	_desktop
	The desktop currently being displayed.
long	_num_desktops
	The number of desktops.
otk::Property::StringVect	_desktop_names
	The names of all desktops.

---

Member Typedef Documentation

typedef std::list<Client*> ob::Screen::ClientList

Holds a list of Clients. Definition at line 47 of file screen.hh.

typedef std::list<otk::Strut*> ob::Screen::StrutList

Holds a list of otk::Strut objects. Definition at line 35 of file screen.hh.

---

Constructor & Destructor Documentation

ob::Screen::Screen (  int    screen )

Constructs a new Screen object. Definition at line 49 of file screen.cc. References _, _desktop, _focuswindow, _info, _managed, _num_desktops, _style, otk::Property::atoms, ob::Openbox::bindings(), calcArea(), changeClientList(), changeDesktop(), changeNumDesktops(), changeSupportedAtoms(), ob::Openbox::cursors(), otk::ScreenInfo::depth(), ob::Bindings::fireEvent(), otk::ScreenInfo::height(), ob::openbox, ob::python_get_long(), ob::python_get_stringlist(), otk::EventDispatcher::registerHandler(), otk::RenderStyle::rootColor(), otk::ScreenInfo::rootWindow(), ob::Cursors::session, otk::Property::set(), otk::Property::utf8, otk::ScreenInfo::visual(), and otk::ScreenInfo::width(). : WidgetBase(WidgetBase::Type_Root), _number(screen), _style(screen, "") { assert(screen >= 0); assert(screen < ScreenCount(**otk::display)); _info = otk::display->screenInfo(screen); ::running = false; XErrorHandler old = XSetErrorHandler(::anotherWMRunning); XSelectInput(**otk::display, _info->rootWindow(), Screen::event_mask); XSync(**otk::display, false); XSetErrorHandler(old); _managed = !::running; if (! _managed) return; // was unable to manage the screen printf(_("Managing screen %d: visual 0x%lx, depth %d\n"), _number, XVisualIDFromVisual(_info->visual()), _info->depth()); otk::Property::set(_info->rootWindow(), otk::Property::atoms.openbox_pid, otk::Property::atoms.cardinal, (unsigned long) getpid()); // set the mouse cursor for the root window (the default cursor) XDefineCursor(**otk::display, _info->rootWindow(), openbox->cursors().session); // XXX: initialize the screen's style /* otk::ustring stylepath; python_get_string("THEME", &stylepath); otk::Configuration sconfig(false); sconfig.setFile(otk::expandTilde(stylepath.c_str())); if (!sconfig.load()) { sconfig.setFile(otk::expandTilde(DEFAULTSTYLE)); if (!sconfig.load()) { printf(_("Unable to load default style: %s. Aborting.\n"), DEFAULTSTYLE); ::exit(1); } } _style.load(sconfig); */ otk::display->renderControl(_number)->drawRoot(*_style.rootColor()); // set up notification of netwm support changeSupportedAtoms(); // Set the netwm properties for geometry unsigned long geometry[] = { _info->width(), _info->height() }; otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_desktop_geometry, otk::Property::atoms.cardinal, geometry, 2); // Set the net_desktop_names property std::vector<otk::ustring> names; python_get_stringlist("DESKTOP_NAMES", &names); otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_desktop_names, otk::Property::utf8, names); // the above set() will cause the updateDesktopNames to fire right away so // we have a list of desktop names _desktop = 0; if (!python_get_long("NUMBER_OF_DESKTOPS", &_num_desktops)) _num_desktops = 1; changeNumDesktops(_num_desktops); // set the hint changeDesktop(0); // set the hint // create the window which gets focus when no clients get it XSetWindowAttributes attr; attr.override_redirect = true; _focuswindow = XCreateWindow(**otk::display, _info->rootWindow(), -100, -100, 1, 1, 0, 0, InputOnly, _info->visual(), CWOverrideRedirect, &attr); XMapRaised(**otk::display, _focuswindow); // these may be further updated if any pre-existing windows are found in // the manageExising() function changeClientList(); // initialize the client lists, which will be empty calcArea(); // initialize the available working area // register this class as the event handler for the root window openbox->registerHandler(_info->rootWindow(), this); // call the python Startup callbacks EventData data(_number, 0, EventAction::Startup, 0); openbox->bindings()->fireEvent(&data); }

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

Destroys the Screen object. Definition at line 143 of file screen.cc. References _info, _managed, ob::Openbox::bindings(), clients, ob::Bindings::fireEvent(), ob::openbox, otk::ScreenInfo::rootWindow(), and unmanageWindow(). { if (! _managed) return; XSelectInput(**otk::display, _info->rootWindow(), NoEventMask); // unmanage all windows while (!clients.empty()) unmanageWindow(clients.front()); // call the python Shutdown callbacks EventData data(_number, 0, EventAction::Shutdown, 0); openbox->bindings()->fireEvent(&data); XDestroyWindow(**otk::display, _focuswindow); XDestroyWindow(**otk::display, _supportwindow); }

---

Member Function Documentation

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

Returns the area of the screen not reserved by applications' Struts. Definition at line 148 of file screen.hh. Referenced by ob::Client::fullscreen(), and ob::Client::maximize(). { return _area; }

void ob::Screen::calcArea (    )  [private]

Calculate the Screen::_area member. Definition at line 226 of file screen.cc. References _area, _info, _strut, otk::Strut::bottom, changeWorkArea(), clients, otk::ScreenInfo::height(), otk::Strut::left, otk::Strut::right, otk::Rect::setRect(), otk::Strut::top, and otk::ScreenInfo::width(). Referenced by Screen(), and updateStrut(). { otk::Rect old_area = _area; /* #ifdef XINERAMA // reset to the full areas if (isXineramaActive()) xineramaUsableArea = getXineramaAreas(); #endif // XINERAMA */ _area.setRect(_strut.left, _strut.top, _info->width() - (_strut.left + _strut.right), _info->height() - (_strut.top + _strut.bottom)); /* #ifdef XINERAMA if (isXineramaActive()) { // keep each of the ximerama-defined areas inside the strut RectList::iterator xit, xend = xineramaUsableArea.end(); for (xit = xineramaUsableArea.begin(); xit != xend; ++xit) { if (xit->x() < usableArea.x()) { xit->setX(usableArea.x()); xit->setWidth(xit->width() - usableArea.x()); } if (xit->y() < usableArea.y()) { xit->setY(usableArea.y()); xit->setHeight(xit->height() - usableArea.y()); } if (xit->x() + xit->width() > usableArea.width()) xit->setWidth(usableArea.width() - xit->x()); if (xit->y() + xit->height() > usableArea.height()) xit->setHeight(usableArea.height() - xit->y()); } } #endif // XINERAMA */ if (old_area != _area) { // the area has changed, adjust all the maximized windows ClientList::iterator it, end = clients.end(); for (it = clients.begin(); it != end; ++it) (*it)->remaximize(); } changeWorkArea(); }

void ob::Screen::changeClientList (    )  [private]

Set the client list on the root window. Sets the _NET_CLIENT_LIST root window property. Also calls Screen::updateStackingList. Definition at line 363 of file screen.cc. References _info, otk::Property::atoms, changeStackingList(), clients, otk::ScreenInfo::rootWindow(), and otk::Property::set(). Referenced by manageWindow(), Screen(), and unmanageWindow(). { Window *windows; unsigned int size = clients.size(); // create an array of the window ids if (size > 0) { Window *win_it; windows = new Window[size]; win_it = windows; ClientList::const_iterator it = clients.begin(); const ClientList::const_iterator end = clients.end(); for (; it != end; ++it, ++win_it) *win_it = (*it)->window(); } else windows = (Window*) 0; otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_client_list, otk::Property::atoms.window, windows, size); if (size) delete [] windows; changeStackingList(); }

void ob::Screen::changeDesktop (  long    desktop )  [private]

Changes to the specified desktop, displaying windows on it and hiding windows on the others. Parameters: desktop  The number of the desktop to switch to (starts from 0). If the desktop is out of valid range, it is ignored. Definition at line 704 of file screen.cc. References _desktop, _info, _num_desktops, otk::Property::atoms, clients, ob::Openbox::focusedClient(), ob::openbox, otk::ScreenInfo::rootWindow(), otk::Property::set(), and ob::Openbox::setFocusedClient(). Referenced by changeNumDesktops(), clientMessageHandler(), and Screen(). { if (!(desktop >= 0 && desktop < _num_desktops)) return; printf("Moving to desktop %ld\n", desktop); long old = _desktop; _desktop = desktop; otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_current_desktop, otk::Property::atoms.cardinal, _desktop); if (old == _desktop) return; ClientList::iterator it, end = clients.end(); for (it = clients.begin(); it != end; ++it) { if ((*it)->desktop() == old) { (*it)->frame->hide(); } else if ((*it)->desktop() == _desktop) { (*it)->frame->show(); } } // force the callbacks to fire if (!openbox->focusedClient()) openbox->setFocusedClient(0); }

void ob::Screen::changeNumDesktops (  long    num )  [private]

Changes the number of desktops. Parameters: num  The number of desktops that should exist. This value must be greater than 0 or it will be ignored. Definition at line 733 of file screen.cc. References _desktop, _info, _num_desktops, otk::Property::atoms, changeDesktop(), changeWorkArea(), clients, otk::ScreenInfo::rootWindow(), and otk::Property::set(). Referenced by clientMessageHandler(), and Screen(). { assert(num > 0); if (!(num > 0)) return; // move windows on desktops that will no longer exist! ClientList::iterator it, end = clients.end(); for (it = clients.begin(); it != end; ++it) { int d = (*it)->desktop(); if (d >= num && !(d == (signed) 0xffffffff || d == Client::ICONIC_DESKTOP)) { XEvent ce; ce.xclient.type = ClientMessage; ce.xclient.message_type = otk::Property::atoms.net_wm_desktop; ce.xclient.display = **otk::display; ce.xclient.window = (*it)->window(); ce.xclient.format = 32; ce.xclient.data.l[0] = num - 1; XSendEvent(**otk::display, _info->rootWindow(), False, SubstructureNotifyMask | SubstructureRedirectMask, &ce); } } _num_desktops = num; otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_number_of_desktops, otk::Property::atoms.cardinal, _num_desktops); // set the viewport hint unsigned long *viewport = new unsigned long[_num_desktops * 2]; memset(viewport, 0, sizeof(unsigned long) * _num_desktops * 2); otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_desktop_viewport, otk::Property::atoms.cardinal, viewport, _num_desktops * 2); delete [] viewport; // update the work area hint changeWorkArea(); // change our desktop if we're on one that no longer exists! if (_desktop >= num) changeDesktop(num - 1); }

void ob::Screen::changeStackingList (    )  [private]

Set the client stacking list on the root window. Set the _NET_CLIENT_LIST_STACKING root window property. Definition at line 391 of file screen.cc. References _info, _stacking, otk::Property::atoms, clients, otk::ScreenInfo::rootWindow(), and otk::Property::set(). Referenced by changeClientList(), lowerWindow(), and raiseWindow(). { Window *windows; unsigned int size = _stacking.size(); assert(size == clients.size()); // just making sure.. :) // create an array of the window ids (from bottom to top, reverse order!) if (size > 0) { Window *win_it; windows = new Window[size]; win_it = windows; ClientList::const_reverse_iterator it = _stacking.rbegin(); const ClientList::const_reverse_iterator end = _stacking.rend(); for (; it != end; ++it, ++win_it) *win_it = (*it)->window(); } else windows = (Window*) 0; otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_client_list_stacking, otk::Property::atoms.window, windows, size); if (size) delete [] windows; }

void ob::Screen::changeSupportedAtoms (    )  [private]

Set the list of supported NETWM atoms on the root window. Definition at line 276 of file screen.cc. References _info, _supportwindow, otk::Property::atoms, otk::ScreenInfo::rootWindow(), and otk::Property::set(). Referenced by Screen(). { // create the netwm support window _supportwindow = XCreateSimpleWindow(**otk::display, _info->rootWindow(), 0, 0, 1, 1, 0, 0, 0); // set supporting window otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_supporting_wm_check, otk::Property::atoms.window, _supportwindow); //set properties on the supporting window otk::Property::set(_supportwindow, otk::Property::atoms.net_wm_name, otk::Property::utf8, "Openbox"); otk::Property::set(_supportwindow, otk::Property::atoms.net_supporting_wm_check, otk::Property::atoms.window, _supportwindow); Atom supported[] = { otk::Property::atoms.net_current_desktop, otk::Property::atoms.net_number_of_desktops, otk::Property::atoms.net_desktop_geometry, otk::Property::atoms.net_desktop_viewport, otk::Property::atoms.net_active_window, otk::Property::atoms.net_workarea, otk::Property::atoms.net_client_list, otk::Property::atoms.net_client_list_stacking, otk::Property::atoms.net_desktop_names, otk::Property::atoms.net_close_window, otk::Property::atoms.net_wm_name, otk::Property::atoms.net_wm_visible_name, otk::Property::atoms.net_wm_icon_name, otk::Property::atoms.net_wm_visible_icon_name, /* otk::Property::atoms.net_wm_desktop, */ otk::Property::atoms.net_wm_strut, otk::Property::atoms.net_wm_window_type, otk::Property::atoms.net_wm_window_type_desktop, otk::Property::atoms.net_wm_window_type_dock, otk::Property::atoms.net_wm_window_type_toolbar, otk::Property::atoms.net_wm_window_type_menu, otk::Property::atoms.net_wm_window_type_utility, otk::Property::atoms.net_wm_window_type_splash, otk::Property::atoms.net_wm_window_type_dialog, otk::Property::atoms.net_wm_window_type_normal, /* otk::Property::atoms.net_wm_moveresize, otk::Property::atoms.net_wm_moveresize_size_topleft, otk::Property::atoms.net_wm_moveresize_size_topright, otk::Property::atoms.net_wm_moveresize_size_bottomleft, otk::Property::atoms.net_wm_moveresize_size_bottomright, otk::Property::atoms.net_wm_moveresize_move, */ otk::Property::atoms.net_wm_allowed_actions, otk::Property::atoms.net_wm_action_move, otk::Property::atoms.net_wm_action_resize, otk::Property::atoms.net_wm_action_minimize, otk::Property::atoms.net_wm_action_shade, /* otk::Property::atoms.net_wm_action_stick,*/ otk::Property::atoms.net_wm_action_maximize_horz, otk::Property::atoms.net_wm_action_maximize_vert, otk::Property::atoms.net_wm_action_fullscreen, otk::Property::atoms.net_wm_action_change_desktop, otk::Property::atoms.net_wm_action_close, otk::Property::atoms.net_wm_state, otk::Property::atoms.net_wm_state_modal, otk::Property::atoms.net_wm_state_maximized_vert, otk::Property::atoms.net_wm_state_maximized_horz, otk::Property::atoms.net_wm_state_shaded, otk::Property::atoms.net_wm_state_skip_taskbar, otk::Property::atoms.net_wm_state_skip_pager, otk::Property::atoms.net_wm_state_hidden, otk::Property::atoms.net_wm_state_fullscreen, otk::Property::atoms.net_wm_state_above, otk::Property::atoms.net_wm_state_below, }; const int num_supported = sizeof(supported)/sizeof(Atom); otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_supported, otk::Property::atoms.atom, supported, num_supported); }

void ob::Screen::changeWorkArea (    )  [private]

Set the work area hint on the root window. Set the _NET_WORKAREA root window property. Definition at line 421 of file screen.cc. References _area, _info, _num_desktops, otk::Property::atoms, otk::Rect::height(), otk::ScreenInfo::rootWindow(), otk::Property::set(), otk::Rect::width(), otk::Rect::x(), and otk::Rect::y(). Referenced by calcArea(), and changeNumDesktops(). { unsigned long *dims = new unsigned long[4 * _num_desktops]; for (long i = 0; i < _num_desktops; ++i) { dims[(i * 4) + 0] = _area.x(); dims[(i * 4) + 1] = _area.y(); dims[(i * 4) + 2] = _area.width(); dims[(i * 4) + 3] = _area.height(); } otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_workarea, otk::Property::atoms.cardinal, dims, 4 * _num_desktops); delete [] dims; }

void ob::Screen::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 837 of file screen.cc. References otk::Property::atoms, changeDesktop(), changeNumDesktops(), and otk::EventHandler::clientMessageHandler(). { otk::EventHandler::clientMessageHandler(e); if (e.format != 32) return; if (e.message_type == otk::Property::atoms.net_current_desktop) { changeDesktop(e.data.l[0]); } else if (e.message_type == otk::Property::atoms.net_number_of_desktops) { changeNumDesktops(e.data.l[0]); } }

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

Returns the desktop being displayed. Definition at line 154 of file screen.hh. Referenced by ob::Client::clientMessageHandler(), ob::Client::getDesktop(), ob::Client::mapRequestHandler(), ob::Client::setDesktop(), and ob::Client::setWMState(). { return _desktop; }

Window ob::Screen::focuswindow (    )  const [inline]

An offscreen window which gets focus when nothing else has it. Definition at line 152 of file screen.hh. Referenced by ob::Openbox::setFocusedClient(). { return _focuswindow; }

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

Definition at line 807 of file screen.cc. References _info, and otk::ScreenInfo::colormap(). Referenced by ob::Openbox::setFocusedClient(). { if (install) XInstallColormap(**otk::display, _info->colormap()); else XUninstallColormap(**otk::display, _info->colormap()); }

void ob::Screen::lowerWindow (  Client *    client )

Lowers a client window below all others in its stacking layer. Definition at line 634 of file screen.cc. References _focuswindow, _stacking, changeStackingList(), ob::Client::frame, ob::Client::layer(), ob::Client::modal(), ob::Client::transientFor(), and otk::Widget::window(). Referenced by ob::Client::configureRequestHandler(). { Window wins[2]; // only ever restack 2 windows. assert(!_stacking.empty()); // this would be bad ClientList::iterator it = --_stacking.end(); const ClientList::iterator end = _stacking.begin(); if (client->modal() && client->transientFor()) { // don't let a modal window lower below its transient_for it = std::find(_stacking.begin(), _stacking.end(), client->transientFor()); assert(it != _stacking.end()); wins[0] = (it == _stacking.begin() ? _focuswindow : ((*(--ClientList::const_iterator(it)))->frame->window())); wins[1] = client->frame->window(); if (wins[0] == wins[1]) return; // already right above the window _stacking.remove(client); _stacking.insert(it, client); } else { for (; it != end && (*it)->layer() < client->layer(); --it); if (*it == client) return; // already the bottom, return wins[0] = (*it)->frame->window(); wins[1] = client->frame->window(); _stacking.remove(client); _stacking.insert(++it, client); } XRestackWindows(**otk::display, wins, 2); changeStackingList(); }

bool ob::Screen::managed (    )  const [inline]

Returns if the screen was successfully managed. If this is false, then the screen should be deleted and should NOT be used. Definition at line 146 of file screen.hh. Referenced by ob::Openbox::Openbox(). { return _managed; }

void ob::Screen::manageExisting (    )

Manage any pre-existing windows on the screen. Definition at line 162 of file screen.cc. References _info, manageWindow(), and otk::ScreenInfo::rootWindow(). { unsigned int i, j, nchild; Window r, p, *children; XQueryTree(**otk::display, _info->rootWindow(), &r, &p, &children, &nchild); // preen the window list of all icon windows... for better dockapp support for (i = 0; i < nchild; i++) { if (children[i] == None) continue; XWMHints *wmhints = XGetWMHints(**otk::display, children[i]); if (wmhints) { if ((wmhints->flags & IconWindowHint) && (wmhints->icon_window != children[i])) { for (j = 0; j < nchild; j++) { if (children[j] == wmhints->icon_window) { children[j] = None; break; } } } XFree(wmhints); } } // manage shown windows for (i = 0; i < nchild; ++i) { if (children[i] == None) continue; XWindowAttributes attrib; if (XGetWindowAttributes(**otk::display, children[i], &attrib)) { if (attrib.override_redirect) continue; if (attrib.map_state != IsUnmapped) { manageWindow(children[i]); } } } XFree(children); }

void ob::Screen::manageWindow (  Window    window )

Manage a client window. This gives the window a frame, reparents it, selects events on it, etc. Definition at line 435 of file screen.cc. References _desktop, _stacking, ob::Openbox::addClient(), ob::Client::applyStartupState(), ob::Openbox::bindings(), ob::Frame::button_alldesk(), ob::Frame::button_close(), ob::Frame::button_iconify(), ob::Frame::button_max(), changeClientList(), otk::EventDispatcher::clearHandler(), clients, ob::Client::desktop(), ob::Bindings::fireEvent(), ob::Client::frame, ob::Bindings::grabButtons(), ob::Frame::grabClient(), ob::Frame::grip_left(), ob::Frame::grip_right(), ob::Frame::handle(), ob::Frame::label(), ob::openbox, ob::Frame::plate(), raiseWindow(), otk::EventDispatcher::registerHandler(), otk::Widget::show(), ob::Openbox::state(), ob::Frame::titlebar(), ob::Client::toggleClientBorder(), updateStrut(), and otk::Widget::window(). Referenced by manageExisting(), and mapRequestHandler(). { Client *client = 0; XWMHints *wmhint; XSetWindowAttributes attrib_set; XEvent e; XWindowAttributes attrib; otk::display->grab(); // check if it has already been unmapped by the time we started mapping // the grab does a sync so we don't have to here if (XCheckTypedWindowEvent(**otk::display, window, DestroyNotify, &e) || XCheckTypedWindowEvent(**otk::display, window, UnmapNotify, &e)) { XPutBackEvent(**otk::display, &e); otk::display->ungrab(); return; // don't manage it } if (!XGetWindowAttributes(**otk::display, window, &attrib) || attrib.override_redirect) { otk::display->ungrab(); return; // don't manage it } // is the window a docking app if ((wmhint = XGetWMHints(**otk::display, window))) { if ((wmhint->flags & StateHint) && wmhint->initial_state == WithdrawnState) { //slit->addClient(w); // XXX: make dock apps work! otk::display->ungrab(); XFree(wmhint); return; } XFree(wmhint); } // choose the events we want to receive on the CLIENT window attrib_set.event_mask = Client::event_mask; attrib_set.do_not_propagate_mask = Client::no_propagate_mask; XChangeWindowAttributes(**otk::display, window, CWEventMask|CWDontPropagate, &attrib_set); // create the Client class, which gets all of the hints on the window client = new Client(_number, window); // register for events openbox->registerHandler(window, client); // add to the wm's map openbox->addClient(window, client); // we dont want a border on the client client->toggleClientBorder(false); // specify that if we exit, the window should not be destroyed and should be // reparented back to root automatically XChangeSaveSet(**otk::display, window, SetModeInsert); // create the decoration frame for the client window client->frame = new Frame(client, &_style); // register the plate for events (map req's) // this involves removing itself from the handler list first, since it is // auto added to the list, being a widget. we won't get any events on the // plate except for events for the client (SubstructureRedirectMask) openbox->clearHandler(client->frame->plate()); openbox->registerHandler(client->frame->plate(), client); // add to the wm's map openbox->addClient(client->frame->window(), client); openbox->addClient(client->frame->plate(), client); openbox->addClient(client->frame->titlebar(), client); openbox->addClient(client->frame->label(), client); openbox->addClient(client->frame->button_max(), client); openbox->addClient(client->frame->button_iconify(), client); openbox->addClient(client->frame->button_alldesk(), client); openbox->addClient(client->frame->button_close(), client); openbox->addClient(client->frame->handle(), client); openbox->addClient(client->frame->grip_left(), client); openbox->addClient(client->frame->grip_right(), client); // reparent the client to the frame client->frame->grabClient(); if (openbox->state() != Openbox::State_Starting) { // position the window intelligenty .. hopefully :) // call the python PLACEWINDOW binding EventData data(_number, client, EventAction::PlaceWindow, 0); openbox->bindings()->fireEvent(&data); } EventData ddata(_number, client, EventAction::DisplayingWindow, 0); openbox->bindings()->fireEvent(&ddata); // if on the current desktop.. (or all desktops) if (client->desktop() == _desktop || client->desktop() == (signed)0xffffffff) { client->frame->show(); } client->applyStartupState(); otk::display->ungrab(); // add to the screen's list clients.push_back(client); // once the client is in the list, update our strut to include the new // client's (it is good that this happens after window placement!) updateStrut(); // this puts into the stacking order, then raises it _stacking.push_back(client); raiseWindow(client); // update the root properties changeClientList(); openbox->bindings()->grabButtons(true, client); EventData ndata(_number, client, EventAction::NewWindow, 0); openbox->bindings()->fireEvent(&ndata); #ifdef DEBUG printf("Managed window 0x%lx frame 0x%lx\n", window, client->frame->window()); #endif }

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

Called when a different client tries to map a window. Reimplemented from otk::EventHandler. Definition at line 851 of file screen.cc. References ob::Openbox::findClient(), manageWindow(), otk::EventHandler::mapRequestHandler(), and ob::openbox. { otk::EventHandler::mapRequestHandler(e); #ifdef DEBUG printf("MapRequest for 0x%lx\n", e.window); #endif // DEBUG Client *c = openbox->findClient(e.window); if (c) { #ifdef DEBUG printf("DEBUG: MAP REQUEST CAUGHT IN SCREEN. IGNORED.\n"); #endif } else manageWindow(e.window); }

int ob::Screen::number (    )  const [inline]

Definition at line 139 of file screen.hh. Referenced by ob::Openbox::setFocusedClient(). { return _number; }

long ob::Screen::numDesktops (    )  const [inline]

Returns the number of desktops. Definition at line 156 of file screen.hh. { return _num_desktops; }

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

Called when a property of a window changes. Reimplemented from otk::EventHandler. Definition at line 816 of file screen.cc. References _info, otk::Property::atoms, otk::EventHandler::propertyHandler(), otk::ScreenInfo::rootWindow(), and updateDesktopNames(). { otk::EventHandler::propertyHandler(e); // compress changes to a single property into a single change XEvent ce; while (XCheckTypedWindowEvent(**otk::display, _info->rootWindow(), 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 == otk::Property::atoms.net_desktop_names) updateDesktopNames(); }

void ob::Screen::raiseWindow (  Client *    client )

Raises a client window above all others in its stacking layer. raiseWindow has a couple of constraints that lowerWindow does not. 1) raiseWindow can be called after changing a Client's stack layer, and the list will be reorganized properly. 2) raiseWindow guarantees that XRestackWindows() will always be called for the specified client. Definition at line 670 of file screen.cc. References _focuswindow, _stacking, changeStackingList(), ob::Client::frame, ob::Client::layer(), ob::Client::modalChild(), and otk::Widget::window(). Referenced by ob::Client::calcLayer(), ob::Client::clientMessageHandler(), ob::Client::configureRequestHandler(), ob::Client::fullscreen(), and manageWindow(). { Window wins[2]; // only ever restack 2 windows. assert(!_stacking.empty()); // this would be bad // remove the client before looking so we can't run into ourselves _stacking.remove(client); ClientList::iterator it = _stacking.begin(); const ClientList::iterator end = _stacking.end(); // the stacking list is from highest to lowest for (; it != end && (*it)->layer() > client->layer(); ++it); /* if our new position is the top, we want to stack under the _focuswindow otherwise, we want to stack under the previous window in the stack. */ wins[0] = (it == _stacking.begin() ? _focuswindow : ((*(--ClientList::const_iterator(it)))->frame->window())); wins[1] = client->frame->window(); _stacking.insert(it, client); XRestackWindows(**otk::display, wins, 2); // if the window has a modal child, then raise it after us to put it on top if (client->modalChild()) raiseWindow(client->modalChild()); else changeStackingList(); // no need to do this twice! }

void ob::Screen::setDesktopName (  long    i, const otk::ustring &    name )

Sets the name of a desktop by changing the root window property. Parameters: i  The index of the desktop to set the name for (starts at 0) name  The name to set for the desktop If the index is too large, it is simply ignored. Definition at line 793 of file screen.cc. References _desktop_names, _info, _num_desktops, otk::Property::atoms, otk::ScreenInfo::rootWindow(), otk::Property::set(), otk::Property::StringVect, and otk::Property::utf8. { assert(i >= 0); if (i >= _num_desktops) return; otk::Property::StringVect newnames = _desktop_names; newnames[i] = name; otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_desktop_names, otk::Property::utf8, newnames); }

const otk::RenderStyle* ob::Screen::style (    )  const [inline]

Returns the style in use on the screen. Definition at line 150 of file screen.hh. { return &_style; }

void ob::Screen::unmanageWindow (  Client *    client )

Unmanage a client. This removes the window's frame, reparents it to root, unselects events on it, etc. Parameters: client  The client to unmanage Definition at line 562 of file screen.cc. References _stacking, ob::Openbox::bindings(), ob::Frame::button_alldesk(), ob::Frame::button_close(), ob::Frame::button_iconify(), ob::Frame::button_max(), changeClientList(), otk::EventDispatcher::clearHandler(), clients, ob::Bindings::fireEvent(), ob::Client::frame, ob::Bindings::grabButtons(), ob::Frame::grip_left(), ob::Frame::grip_right(), ob::Frame::handle(), otk::Widget::hide(), ob::Frame::label(), ob::openbox, ob::Frame::plate(), ob::Frame::releaseClient(), ob::Openbox::removeClient(), ob::Client::setModal(), ob::Frame::titlebar(), ob::Client::toggleClientBorder(), ob::Client::unfocus(), updateStrut(), otk::Widget::window(), and ob::Client::window(). Referenced by ob::Client::destroyHandler(), ob::Client::reparentHandler(), ob::Client::unmapHandler(), and ~Screen(). { Frame *frame = client->frame; // call the python CLOSEWINDOW binding EventData data(_number, client, EventAction::CloseWindow, 0); openbox->bindings()->fireEvent(&data); openbox->bindings()->grabButtons(false, client); // remove from the wm's map openbox->removeClient(client->window()); openbox->removeClient(frame->window()); openbox->removeClient(frame->plate()); openbox->removeClient(frame->titlebar()); openbox->removeClient(frame->label()); openbox->removeClient(frame->button_max()); openbox->removeClient(frame->button_iconify()); openbox->removeClient(frame->button_alldesk()); openbox->removeClient(frame->button_close()); openbox->removeClient(frame->handle()); openbox->removeClient(frame->grip_left()); openbox->removeClient(frame->grip_right()); // unregister for handling events openbox->clearHandler(client->window()); // remove the window from our save set XChangeSaveSet(**otk::display, client->window(), SetModeDelete); // we dont want events no more XSelectInput(**otk::display, client->window(), NoEventMask); frame->hide(); // give the client its border back client->toggleClientBorder(true); // reparent the window out of the frame frame->releaseClient(); #ifdef DEBUG Window framewin = client->frame->window(); #endif delete client->frame; client->frame = 0; // remove from the stacking order _stacking.remove(client); // remove from the screen's list clients.remove(client); // once the client is out of the list, update our strut to remove it's // influence updateStrut(); // unset modal before dropping our focus client->setModal(false); // unfocus the client (calls the focus callbacks) client->unfocus(); #ifdef DEBUG printf("Unmanaged window 0x%lx frame 0x%lx\n", client->window(), framewin); #endif delete client; // update the root properties changeClientList(); }

void ob::Screen::updateDesktopNames (    )  [private]

Get desktop names from the root window property. Definition at line 780 of file screen.cc. References _desktop_names, _info, _num_desktops, otk::Property::atoms, otk::Property::get(), otk::ScreenInfo::rootWindow(), and otk::Property::utf8. Referenced by propertyHandler(). { unsigned long num = (unsigned) -1; if (!otk::Property::get(_info->rootWindow(), otk::Property::atoms.net_desktop_names, otk::Property::utf8, &num, &_desktop_names)) _desktop_names.clear(); while ((long)_desktop_names.size() < _num_desktops) _desktop_names.push_back("Unnamed"); }

void ob::Screen::updateStrut (    )

Update's the screen's combined strut of all the clients. Clients should call this whenever they change their strut. Definition at line 210 of file screen.cc. References _strut, otk::Strut::bottom, calcArea(), clients, otk::Strut::left, otk::Strut::right, and otk::Strut::top. Referenced by manageWindow(), unmanageWindow(), and ob::Client::updateStrut(). { _strut.left = _strut.right = _strut.top = _strut.bottom = 0; ClientList::iterator it, end = clients.end(); for (it = clients.begin(); it != end; ++it) { const otk::Strut &s = (*it)->strut(); _strut.left = std::max(_strut.left, s.left); _strut.right = std::max(_strut.right, s.right); _strut.top = std::max(_strut.top, s.top); _strut.bottom = std::max(_strut.bottom, s.bottom); } calcArea(); }

---

Member Data Documentation

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

Area usable for placement etc (total - struts). Definition at line 68 of file screen.hh. Referenced by calcArea(), and changeWorkArea().

long ob::Screen::_desktop [private]

The desktop currently being displayed. Definition at line 84 of file screen.hh. Referenced by changeDesktop(), changeNumDesktops(), manageWindow(), and Screen().

otk::Property::StringVect ob::Screen::_desktop_names [private]

The names of all desktops. Definition at line 90 of file screen.hh. Referenced by setDesktopName(), and updateDesktopNames().

Window ob::Screen::_focuswindow [private]

An offscreen window which gets focus when nothing else has it. Definition at line 74 of file screen.hh. Referenced by lowerWindow(), raiseWindow(), and Screen().

const otk::ScreenInfo* ob::Screen::_info [private]

Information about this screen. Definition at line 59 of file screen.hh. Referenced by calcArea(), changeClientList(), changeDesktop(), changeNumDesktops(), changeStackingList(), changeSupportedAtoms(), changeWorkArea(), installColormap(), manageExisting(), propertyHandler(), Screen(), setDesktopName(), updateDesktopNames(), and ~Screen().

bool ob::Screen::_managed [private]

Was Openbox able to manage the screen? Definition at line 53 of file screen.hh. Referenced by Screen(), and ~Screen().

long ob::Screen::_num_desktops [private]

The number of desktops. Definition at line 87 of file screen.hh. Referenced by changeDesktop(), changeNumDesktops(), changeWorkArea(), Screen(), setDesktopName(), and updateDesktopNames().

int ob::Screen::_number [private]

The number of the screen on the X server. Definition at line 56 of file screen.hh.

bool ob::Screen::_root_cmap_installed [private]

Is the root colormap currently installed? Definition at line 65 of file screen.hh.

ClientList ob::Screen::_stacking [private]

A list of all managed clients on the screen, in their stacking order. Definition at line 81 of file screen.hh. Referenced by changeStackingList(), lowerWindow(), manageWindow(), raiseWindow(), and unmanageWindow().

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

Combined strut from all of the clients' struts. Definition at line 71 of file screen.hh. Referenced by calcArea(), and updateStrut().

otk::RenderStyle ob::Screen::_style [private]

The style with which to render on the screen. Definition at line 62 of file screen.hh. Referenced by Screen().

Window ob::Screen::_supportwindow [private]

An offscreen window which shows that a NETWM compliant window manager is running. Definition at line 78 of file screen.hh. Referenced by changeSupportedAtoms().

ClientList ob::Screen::clients

All managed clients on the screen (in order of being mapped). Definition at line 49 of file screen.hh. Referenced by ob::Bindings::addButton(), calcArea(), changeClientList(), changeDesktop(), changeNumDesktops(), changeStackingList(), manageWindow(), ob::Bindings::removeAllButtons(), unmanageWindow(), updateStrut(), and ~Screen().

const unsigned long ob::Screen::event_mask [static]

Initial value: ColormapChangeMask | EnterWindowMask | LeaveWindowMask | PropertyChangeMask | SubstructureNotifyMask | SubstructureRedirectMask | ButtonPressMask | ButtonReleaseMask Definition at line 37 of file screen.hh.

---

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

• /src/screen.hh
• /src/screen.cc

---