Merge lp:~mc-return/compiz/compiz.merge-src-screen.cpp-improvements into lp:compiz/0.9.11

[MC Return]

src/screen.cpp, cleanup:

Merged if condition checks.
Declaration and assignment of variables in one line.
Declaration of variables outside of loops.
Use pre- instead of postfix in- and decrement.
if (something == 0) == if (!something).
Removed redundant brackets.
Added and removed newlines.
Added default case, if missing (just a style issue).
Fixed indentation.
Added TODOs.

src/screen.cpp, other improvements:

Do not assign values to variables, that are never used -
(int i = 0; for example).
int dSize = nDesktop * 2 + nDesktop * 2 + nDesktop * 4 + 1; ==
int dSize = nDesktop * 8 + 1;.

src/screen.cpp, other fixes:

Initialize multiple non-static class member variables (escapeKeyCode,
returnKeyCode, wmSnTimestamp) and fields (attrib) that are not
initialized in the PrivateScreen::PrivateScreen (CompScreen *, compiz::
private_screen::WindowManager &) constructor nor in any functions that it
calls.
(LP: #1101639)

Also initialize the class members xSync, xRandr, xShape, viewPort,
orphanData, outputDevices, colormap, screenNum, fullscreenOutput,
screenEdge, workArea, xkbEvent, xineramaExtension, displayString_,
region, pingTimer, edgeDelaySettings and pluginManager in the same ctor.

Initialize the non-static class member "grabbed" in the EventManager::
EventManager () ctor.
(LP: #1101590)

quilting needs to be adjusted...

dh_quilt_patch
Applying patch ubuntu_super_p.patch
patching file src/screen.cpp
Hunk #1 FAILED at 3253.
1 out of 1 hunk FAILED -- rejects in file src/screen.cpp
Patch ubuntu_super_p.patch does not apply (enforce with -f)
dh_quilt_patch: quilt --quiltrc /dev/null push -a || test $? = 2 returned exit code 1

Still WIP.

Unmerged revisions

3758. By MC Return on 2013-07-21

Merged latest lp:compiz

3757. By MC Return on 2013-07-07

Initialize multiple non-static class member variables (escapeKeyCode,
returnKeyCode, wmSnTimestamp) and fields (attrib) that are not
initialized in the PrivateScreen::PrivateScreen (CompScreen *, compiz::
private_screen::WindowManager &) constructor nor in any functions that it
calls (LP: #1101639)

Also initialize the class members xSync, xRandr, xShape, viewPort,
orphanData, outputDevices, colormap, screenNum, fullscreenOutput,
screenEdge, workArea, xkbEvent, xineramaExtension, displayString_,
region, pingTimer, edgeDelaySettings and pluginManager in the same ctor

3756. By MC Return on 2013-07-07

Initialize the non-static class member "grabbed" in the EventManager::
EventManager () ctor
(LP: #1101590)

3755. By MC Return on 2013-07-05

Fixed minor style ssues

3754. By MC Return on 2013-07-05

src/screen.cpp, massive cleanup
(please see main commit message for details)

=== modified file 'src/screen.cpp'
--- src/screen.cpp	2013-05-13 13:27:30 +0000
+++ src/screen.cpp	2013-07-24 16:11:44 +0000
@@ -67,12 +67,12 @@
 
 CompOutput *targetOutput;
 
-int lastPointerX = 0;
-int lastPointerY = 0;
+int          lastPointerX    = 0;
+int          lastPointerY    = 0;
 unsigned int lastPointerMods = 0;
-int pointerX     = 0;
-int pointerY     = 0;
-unsigned int pointerMods = 0;
+int          pointerX        = 0;
+int          pointerY        = 0;
+unsigned int pointerMods     = 0;
 
 namespace
 {
@@ -85,18 +85,17 @@
 #define MwmHintsDecorations (1L << 1)
 static const unsigned short PropMotifWmHintElements = 3;
 
-typedef struct {
+typedef struct
+{
     unsigned long flags;
     unsigned long functions;
     unsigned long decorations;
 } MwmHints;
 
 namespace cps = compiz::private_screen;
-namespace ca = compiz::actions;
-
-
-
-CompScreen *screen;
+namespace ca  = compiz::actions;
+
+CompScreen      *screen;
 ModifierHandler *modHandler;
 
 PluginClassStorage::Indices screenPluginClassIndices (0);
@@ -112,9 +111,9 @@
     privateScreen.setWindowState (state, id);
 }
 
-void CompScreenImpl::addToDestroyedWindows(CompWindow * cw)
+void CompScreenImpl::addToDestroyedWindows (CompWindow * cw)
 {
-    windowManager.addToDestroyedWindows(cw);
+    windowManager.addToDestroyedWindows (cw);
 }
 
 void CompScreenImpl::processEvents () { privateScreen.processEvents (); }
@@ -146,10 +145,12 @@
 	case SIGTERM:
 	    mainloop->quit ();
 	    break;
+
 	case SIGHUP:
 	    restartSignal = true;
 	    mainloop->quit ();
 	    break;
+
 	default:
 	    break;
     }
@@ -160,11 +161,11 @@
 void
 CompScreenImpl::eventLoop ()
 {
-    privateScreen.eventManager.startEventLoop (dpy());
+    privateScreen.eventManager.startEventLoop (dpy ());
 }
 
 void
-cps::EventManager::startEventLoop(Display* dpy)
+cps::EventManager::startEventLoop (Display *dpy)
 {
     source = CompEventSource::create ();
     timeout = CompTimeoutSource::create (ctx);
@@ -173,13 +174,13 @@
 
     XFlush (dpy);
 
-    mainloop->run();
+    mainloop->run ();
 }
 
 CompFileWatchHandle
 CompScreenImpl::addFileWatch (const char        *path,
-			  int               mask,
-			  FileWatchCallBack callBack)
+			      int               mask,
+			      FileWatchCallBack callBack)
 {
     CompFileWatch *fileWatch = privateScreen.eventManager.addFileWatch (path, mask, callBack);
 
@@ -192,17 +193,17 @@
 }
 
 CompFileWatch*
-cps::EventManager::addFileWatch (
-    const char        *path,
-    int               mask,
-    FileWatchCallBack callBack)
+cps::EventManager::addFileWatch (const char        *path,
+				 int               mask,
+				 FileWatchCallBack callBack)
 {
     CompFileWatch *fw = new CompFileWatch ();
+
     if (!fw)
 	return 0;
 
-    fw->path	= path;
-    fw->mask	= mask;
+    fw->path     = path;
+    fw->mask     = mask;
     fw->callBack = callBack;
     fw->handle   = lastFileWatchHandle++;
 
@@ -237,7 +238,7 @@
     if (it == fileWatch.end ())
 	return 0;
 
-    CompFileWatch* w = (*it);
+    CompFileWatch *w = (*it);
     fileWatch.erase (it);
 
     return w;
@@ -255,7 +256,7 @@
     return fileWatch;
 }
 
-CompWatchFd::CompWatchFd (int		    fd,
+CompWatchFd::CompWatchFd (int               fd,
 			  Glib::IOCondition events,
 			  FdWatchCallBack   callback) :
     Glib::IOSource (fd, events),
@@ -282,29 +283,33 @@
 
 CompWatchFdHandle
 CompScreenImpl::addWatchFd (int             fd,
-			short int       events,
-			FdWatchCallBack callBack)
+			    short int       events,
+			    FdWatchCallBack callBack)
 {
     return privateScreen.eventManager.addWatchFd (fd, events, callBack);
 }
 
 CompWatchFdHandle
 cps::EventManager::addWatchFd (int             fd,
-			short int       events,
-			FdWatchCallBack callBack)
+			       short int       events,
+			       FdWatchCallBack callBack)
 {
     Glib::IOCondition gEvents;
-    
+
     memset (&gEvents, 0, sizeof (Glib::IOCondition));
 
     if (events & POLLIN)
 	gEvents |= Glib::IO_IN;
+
     if (events & POLLOUT)
 	gEvents |= Glib::IO_OUT;
+
     if (events & POLLPRI)
 	gEvents |= Glib::IO_PRI;
+
     if (events & POLLERR)
 	gEvents |= Glib::IO_ERR;
+
     if (events & POLLHUP)
 	gEvents |= Glib::IO_HUP;
 
@@ -314,7 +319,8 @@
 
     if (!watchFd)
 	return 0;
-    watchFd->mHandle   = lastWatchFdHandle++;
+
+    watchFd->mHandle = ++lastWatchFdHandle;
 
     if (lastWatchFdHandle == MAXSHORT)
 	lastWatchFdHandle = 1;
@@ -334,19 +340,16 @@
 cps::EventManager::removeWatchFd (CompWatchFdHandle handle)
 {
     std::list<CompWatchFd * >::iterator it;
-    CompWatchFd *			w;
 
-    for (it = watchFds.begin();
+    for (it = watchFds.begin ();
 	 it != watchFds.end (); ++it)
-    {
 	if ((*it)->mHandle == handle)
 	    break;
-    }
 
     if (it == watchFds.end ())
 	return;
 
-    w = (*it);
+    CompWatchFd *w = (*it);
 
     if (w->mExecuting)
     {
@@ -383,14 +386,19 @@
 
     if (events & Glib::IO_IN)
 	revents |= POLLIN;
+
     if (events & Glib::IO_OUT)
 	revents |= POLLOUT;
+
     if (events & Glib::IO_PRI)
 	revents |= POLLPRI;
+
     if (events & Glib::IO_ERR)
 	revents |= POLLERR;
+
     if (events & Glib::IO_HUP)
 	revents |= POLLHUP;
+
     if (events & Glib::IO_NVAL)
 	return false;
 
@@ -405,9 +413,9 @@
 	//screen->priv->watchFds.remove (this);
 	return false;
     }
-    
+
     return true;
-}    
+}
 
 void
 CompScreenImpl::eraseValue (CompString key)
@@ -444,18 +452,18 @@
 				const char        *name,
 				CompOption::Value &value)
 {
-    WRAPABLE_HND_FUNCTN_RETURN (bool, setOptionForPlugin,
-			      plugin, name, value)
+    WRAPABLE_HND_FUNCTN_RETURN (bool, setOptionForPlugin, plugin, name, value)
 
     return _setOptionForPlugin(plugin, name, value);
 }
 
 bool
 CompScreenImpl::_setOptionForPlugin (const char        *plugin,
-				const char        *name,
-				CompOption::Value &value)
+				     const char        *name,
+				     CompOption::Value &value)
 {
     CompPlugin *p = CompPlugin::find (plugin);
+
     if (p)
 	return p->vTable->setOption (name, value);
 
@@ -472,7 +480,7 @@
 
 void
 CompScreenImpl::_sessionEvent (CompSession::Event event,
-			  CompOption::Vector &arguments)
+			       CompOption::Vector &arguments)
 {
 }
 
@@ -515,7 +523,7 @@
     char str[128];
 #endif
 
-    errors++;
+    ++errors;
 
 #ifdef DEBUG
     XGetErrorDatabaseText (dpy, "XlibMessage", "XError", "", str, 128);
@@ -529,8 +537,10 @@
 
     snprintf (str, 128, "%d", e->request_code);
     XGetErrorDatabaseText (dpy, "XRequest", str, "", str, 128);
+
     if (strcmp (str, ""))
 	fprintf (stderr, " (%s)", str);
+
     fprintf (stderr, "\n  ");
 
     XGetErrorDatabaseText (dpy, "XlibMessage", "MinorCode", "%d", str, 128);
@@ -550,11 +560,9 @@
 int
 CompScreen::checkForError (Display *dpy)
 {
-    int e;
-
     XSync (dpy, false);
 
-    e = errors;
+    int e  = errors;
     errors = 0;
 
     return e;
@@ -639,7 +647,7 @@
 void
 PrivateScreen::setAudibleBell (bool audible)
 {
-    if (xkbEvent.isEnabled())
+    if (xkbEvent.isEnabled ())
 	XkbChangeEnabledControls (dpy,
 				  XkbUseCoreKbd,
 				  XkbAudibleBellMask,
@@ -649,22 +657,23 @@
 bool
 CompScreenImpl::handlePingTimeout ()
 {
-    return Ping::handlePingTimeout(
-	    windowManager.begin(),
-	    windowManager.end(),
-	    privateScreen.dpy);
+    return Ping::handlePingTimeout (windowManager.begin (),
+				    windowManager.end (),
+				    privateScreen.dpy);
 }
 
 bool
-cps::Ping::handlePingTimeout (WindowManager::iterator begin, WindowManager::iterator end, Display* dpy)
+cps::Ping::handlePingTimeout (WindowManager::iterator begin,
+			      WindowManager::iterator end,
+			      Display                 *dpy)
 {
-    XEvent      ev;
-    int		ping = lastPing_ + 1;
+    XEvent ev;
+    int    ping = lastPing_ + 1;
 
-    ev.type		    = ClientMessage;
-    ev.xclient.window	    = 0;
+    ev.type                 = ClientMessage;
+    ev.xclient.window       = 0;
     ev.xclient.message_type = Atoms::wmProtocols;
-    ev.xclient.format	    = 32;
+    ev.xclient.format       = 32;
     ev.xclient.data.l[0]    = Atoms::wmPing;
     ev.xclient.data.l[1]    = ping;
     ev.xclient.data.l[2]    = 0;
@@ -674,6 +683,7 @@
     for (WindowManager::iterator i = begin; i != end; ++i)
     {
 	CompWindow* const w(*i);
+
 	if (w->priv->handlePingTimeout (lastPing_))
 	{
 	    ev.xclient.window    = w->id ();
@@ -696,7 +706,7 @@
 
 bool
 CompScreenImpl::setOption (const CompString  &name,
-		       CompOption::Value &value)
+			   CompOption::Value &value)
 {
     return privateScreen.setOption (name, value);
 }
@@ -709,48 +719,54 @@
 
     bool rv = CoreOptions::setOption (name, value);
 
-    if (!rv)
+    if (!rv ||
+	!CompOption::findOption (getOptions (), name, &index))
 	return false;
 
-    if (!CompOption::findOption (getOptions (), name, &index))
-        return false;
-
-    switch (index) {
+    switch (index)
+    {
 	case CoreOptions::ActivePlugins:
 	    pluginManager.setDirtyPluginList ();
 	    break;
+
 	case CoreOptions::PingDelay:
 	    pingTimer.setTimes (optionGetPingDelay (),
 				optionGetPingDelay () + 500);
 	    break;
+
 	case CoreOptions::AudibleBell:
 	    setAudibleBell (optionGetAudibleBell ());
 	    break;
+
 	case CoreOptions::DetectOutputs:
 	    if (optionGetDetectOutputs ())
 		detectOutputDevices (*this);
 	    break;
+
 	case CoreOptions::Hsize:
 	case CoreOptions::Vsize:
-
-	    if (optionGetHsize () * screen->width () > MAXSHORT)
-		return false;
-	    if (optionGetVsize () * screen->height () > MAXSHORT)
+	    if (optionGetHsize () * screen->width ()  > MAXSHORT ||
+		optionGetVsize () * screen->height () > MAXSHORT)
 		return false;
 
 	    setVirtualScreenSize (optionGetHsize (), optionGetVsize ());
 	    break;
+
 	case CoreOptions::NumberOfDesktops:
 	    setNumberOfDesktops (optionGetNumberOfDesktops ());
 	    break;
+
 	case CoreOptions::DefaultIcon:
 	    return screen->updateDefaultIcon ();
 	    break;
+
 	case CoreOptions::Outputs:
 	    if (optionGetDetectOutputs ())
 		return false;
+
 	    updateOutputDevices (*this);
 	    break;
+
 	default:
 	    break;
     }
@@ -763,6 +779,7 @@
 {
     if (!XEventsQueued (dpy, QueuedAlready))
 	return false;
+
     XNextEvent (dpy, &ev);
 
     /* Skip to the last MotionNotify
@@ -770,6 +787,7 @@
     if (ev.type == MotionNotify)
     {
 	XEvent peekEvent;
+
 	while (XPending (dpy))
 	{
 	    XPeekEvent (dpy, &peekEvent);
@@ -790,9 +808,7 @@
     StackDebugger *dbg = StackDebugger::Default ();
 
     if (StackDebugger::Default ())
-    {
 	return dbg->getNextEvent (ev);
-    }
     else
 	return getNextXEvent (ev);
 }
@@ -804,77 +820,83 @@
 
     if (pluginManager.isDirtyPluginList ())
     {
-	eventManager.resetPossibleTap();
-	pluginManager.updatePlugins (screen, optionGetActivePlugins());
+	eventManager.resetPossibleTap ();
+	pluginManager.updatePlugins (screen, optionGetActivePlugins ());
     }
 
-    windowManager.validateServerWindows();
+    windowManager.validateServerWindows ();
 
     if (dbg)
     {
 	dbg->windowsChanged (false);
 	dbg->serverWindowsChanged (false);
-	dbg->loadStack (windowManager.getServerWindows());
+	dbg->loadStack (windowManager.getServerWindows ());
     }
 
-    windowManager.invalidateServerWindows();
+    windowManager.invalidateServerWindows ();
 
     XEvent event;
 
     while (getNextEvent (event))
     {
-	switch (event.type) {
-	case ButtonPress:
-	case ButtonRelease:
-	    pointerX = event.xbutton.x_root;
-	    pointerY = event.xbutton.y_root;
-	    pointerMods = event.xbutton.state;
-	    break;
-	case KeyPress:
-	case KeyRelease:
-	    pointerX = event.xkey.x_root;
-	    pointerY = event.xkey.y_root;
-	    pointerMods = event.xkey.state;
-	    break;
-	case MotionNotify:
-
-	    pointerX = event.xmotion.x_root;
-	    pointerY = event.xmotion.y_root;
-	    pointerMods = event.xmotion.state;
-	    break;
-	case EnterNotify:
-	case LeaveNotify:
-	    pointerX = event.xcrossing.x_root;
-	    pointerY = event.xcrossing.y_root;
-	    pointerMods = event.xcrossing.state;
-	    break;
-	case ClientMessage:
-	    if (event.xclient.message_type == Atoms::xdndPosition)
-	    {
-		pointerX = event.xclient.data.l[2] >> 16;
-		pointerY = event.xclient.data.l[2] & 0xffff;
-		/* FIXME: Xdnd provides us no way of getting the pointer mods
-		 * without doing XQueryPointer, which is a round-trip */
-		pointerMods = 0;
-	    }
-	    else if (event.xclient.message_type == Atoms::wmMoveResize)
-	    {
-		int i;
-		Window child, root;
-		/* _NET_WM_MOVERESIZE is most often sent by clients who provide
-		 * a special "grab space" on a window for the user to initiate
-		 * adjustment by the window manager. Since we don't have a
-		 * passive grab on Button1 for active and raised windows, we
-		 * need to update the pointer buffer here */
-
-		XQueryPointer (screen->dpy (), screen->root (),
-			       &root, &child, &pointerX, &pointerY,
-			       &i, &i, &pointerMods);
-	    }
-	    break;
-	default:
-	    break;
-        }
+	switch (event.type)
+	{
+	    case ButtonPress:
+	    case ButtonRelease:
+		pointerX = event.xbutton.x_root;
+		pointerY = event.xbutton.y_root;
+		pointerMods = event.xbutton.state;
+		break;
+
+	    case KeyPress:
+	    case KeyRelease:
+		pointerX = event.xkey.x_root;
+		pointerY = event.xkey.y_root;
+		pointerMods = event.xkey.state;
+		break;
+
+	    case MotionNotify:
+		pointerX = event.xmotion.x_root;
+		pointerY = event.xmotion.y_root;
+		pointerMods = event.xmotion.state;
+		break;
+
+	    case EnterNotify:
+	    case LeaveNotify:
+		pointerX = event.xcrossing.x_root;
+		pointerY = event.xcrossing.y_root;
+		pointerMods = event.xcrossing.state;
+		break;
+
+	    case ClientMessage:
+		if (event.xclient.message_type == Atoms::xdndPosition)
+		{
+		    pointerX = event.xclient.data.l[2] >> 16;
+		    pointerY = event.xclient.data.l[2] & 0xffff;
+		    /* FIXME: Xdnd provides us no way of getting the pointer mods
+		     * without doing XQueryPointer, which is a round-trip */
+		    pointerMods = 0;
+		}
+		else if (event.xclient.message_type == Atoms::wmMoveResize)
+		{
+		    int i;
+		    Window child, root;
+		    /* _NET_WM_MOVERESIZE is most often sent by clients who provide
+		     * a special "grab space" on a window for the user to initiate
+		     * adjustment by the window manager. Since we don't have a
+		     * passive grab on Button1 for active and raised windows, we
+		     * need to update the pointer buffer here */
+
+		    XQueryPointer (screen->dpy (), screen->root (),
+				   &root, &child, &pointerX, &pointerY,
+				   &i, &i, &pointerMods);
+		}
+
+		break;
+
+	    default:
+		break;
+	}
 
 	sn_display_process_event (snDisplay, &event);
 
@@ -895,20 +917,23 @@
     if (dbg)
     {
 	if (dbg->windowsChanged () &&
-	    dbg->cmpStack (windowManager.getWindows(), windowManager.getServerWindows()))
+	    dbg->cmpStack (windowManager.getWindows (),
+			   windowManager.getServerWindows ()))
 	{
 	    compLogMessage ("core", CompLogLevelDebug, "stacks are out of sync");
+
 	    if (dbg->timedOut ())
 		compLogMessage ("core", CompLogLevelDebug, "however, this may be a false positive");
 	}
 
-	if (dbg->serverWindowsChanged () && dbg->checkSanity (windowManager.getWindows()))
+	if (dbg->serverWindowsChanged () &&
+	    dbg->checkSanity (windowManager.getWindows ()))
 	    compLogMessage ("core", CompLogLevelDebug, "windows are stacked incorrectly");
     }
 }
 
 void
-cps::WindowManager::validateServerWindows()
+cps::WindowManager::validateServerWindows ()
 {
     /* Restacks recently processed, ensure that
      * plugins use the stack last received from
@@ -927,30 +952,32 @@
 }
 
 void
-cps::WindowManager::invalidateServerWindows()
+cps::WindowManager::invalidateServerWindows ()
 {
     stackIsFresh = false;
 }
 
 void
-cps::WindowManager::clearFullscreenHints() const
+cps::WindowManager::clearFullscreenHints () const
 {
     /* clear out fullscreen monitor hints of all windows as
        suggested on monitor layout changes in EWMH */
-    for (iterator i = windows.begin(); i != windows.end(); ++i)
+    for (iterator i = windows.begin (); i != windows.end (); ++i)
     {
-	CompWindow* const w(*i);
+	CompWindow* const w (*i);
+
 	if (w->priv->fullscreenMonitorsSet)
 	    w->priv->setFullscreenMonitors (NULL);
     }
 }
 
 void
-cps::WindowManager::showOrHideForDesktop(unsigned int desktop) const
+cps::WindowManager::showOrHideForDesktop (unsigned int desktop) const
 {
     for (iterator i = windows.begin(); i != windows.end(); ++i)
     {
-	CompWindow* const w(*i);
+	CompWindow* const w (*i);
+
 	if (w->desktop () == 0xffffffff)
 	    continue;
 
@@ -962,22 +989,24 @@
 }
 
 void
-cps::WindowManager::setWindowActiveness(cps::History& history) const
+cps::WindowManager::setWindowActiveness (cps::History &history) const
 {
-    for (iterator i = windows.begin(); i != windows.end(); ++i)
+    for (iterator i = windows.begin (); i != windows.end (); ++i)
     {
 	CompWindow* const w(*i);
+
 	if (w->isViewable ())
 	    w->priv->activeNum = history.nextActiveNum ();
     }
 }
 
 void
-cps::WindowManager::setNumberOfDesktops(unsigned int desktops) const
+cps::WindowManager::setNumberOfDesktops (unsigned int desktops) const
 {
-    for (iterator i = windows.begin(); i != windows.end(); ++i)
+    for (iterator i = windows.begin (); i != windows.end (); ++i)
     {
 	CompWindow* const w(*i);
+
 	if (w->desktop () == 0xffffffff)
 	    continue;
 
@@ -987,9 +1016,9 @@
 }
 
 void
-cps::WindowManager::updateWindowSizes() const
+cps::WindowManager::updateWindowSizes () const
 {
-    for (iterator i = windows.begin(); i != windows.end(); ++i)
+    for (iterator i = windows.begin (); i != windows.end (); ++i)
     {
 	CompWindow* const w(*i);
 	w->priv->updateSize ();
@@ -1003,7 +1032,7 @@
     CompOption::Value::Vector result;
 
     /* Must have core as first plugin */
-    result.push_back("core");
+    result.push_back ("core");
 
     /* Add initial plugins */
     foreach(CompString & p, initialPlugins)
@@ -1018,21 +1047,21 @@
     }
 
     /* Add plugins not in the initial list */
-    foreach(CompOption::Value const& opt, extraPluginsRequested)
+    foreach (CompOption::Value const &opt, extraPluginsRequested)
     {
-	if (opt.s() == "core")
+	if (opt.s () == "core")
 	    continue;
 
-	if (blacklist.find (opt.s()) != blacklist.end ())
+	if (blacklist.find (opt.s ()) != blacklist.end ())
 	    continue;
 
 	typedef std::list<CompString>::iterator iterator;
 	bool skip = false;
 
-	for (iterator it = initialPlugins.begin(); it != initialPlugins.end();
-		++it)
+	for (iterator it = initialPlugins.begin ();
+	     it != initialPlugins.end (); ++it)
 	{
-	    if ((*it) == opt.s())
+	    if ((*it) == opt.s ())
 	    {
 		skip = true;
 		break;
@@ -1040,70 +1069,70 @@
 	}
 
 	if (!skip)
-	{
-	    result.push_back(opt.s());
-	}
+	    result.push_back(opt.s ());
     }
+
     return result;
 }
 
-
 void
-cps::PluginManager::updatePlugins (CompScreen* screen, CompOption::Value::Vector const& extraPluginsRequested)
+cps::PluginManager::updatePlugins (CompScreen                      *screen,
+				   CompOption::Value::Vector const &extraPluginsRequested)
 {
     dirtyPluginList = false;
 
-    CompOption::Value::Vector const desiredPlugins(mergedPluginList(extraPluginsRequested));
+    CompOption::Value::Vector const desiredPlugins (mergedPluginList (extraPluginsRequested));
 
     unsigned int pluginIndex;
+
     for (pluginIndex = 1;
 	pluginIndex < plugin.list ().size () && pluginIndex < desiredPlugins.size ();
-	pluginIndex++)
-    {
+	++pluginIndex)
 	if (plugin.list ().at (pluginIndex).s () != desiredPlugins.at (pluginIndex).s ())
 	    break;
-    }
 
     unsigned int desireIndex = pluginIndex;
 
     // We have pluginIndex pointing at first difference (or end).
     // Now pop plugins off stack to this point, but keep track that they are loaded
     CompPlugin::List alreadyLoaded;
-    if (const unsigned int nPop = plugin.list().size() - pluginIndex)
+
+    if (const unsigned int nPop = plugin.list ().size () - pluginIndex)
     {
-	for (pluginIndex = 0; pluginIndex < nPop; pluginIndex++)
+	for (pluginIndex = 0; pluginIndex < nPop; ++pluginIndex)
 	{
-	    alreadyLoaded.push_back(CompPlugin::pop());
-	    plugin.list().pop_back();
+	    alreadyLoaded.push_back(CompPlugin::pop ());
+	    plugin.list ().pop_back ();
 	}
     }
 
+    CompPlugin *p;
+    bool       failedPush;
+
     // Now work forward through requested plugins
-    for (; desireIndex < desiredPlugins.size(); desireIndex++)
+    for (; desireIndex < desiredPlugins.size (); ++desireIndex)
     {
-	CompPlugin *p = NULL;
-	bool failedPush = false;
+	p          = NULL;
+	failedPush = false;
 
 	// If already loaded, just try to push it...
-	foreach(CompPlugin * pp, alreadyLoaded)
+	foreach (CompPlugin *pp, alreadyLoaded)
 	{
-	    if (desiredPlugins[desireIndex].s() == pp->vTable->name())
+	    if (desiredPlugins[desireIndex].s () == pp->vTable->name ())
 	    {
 		if (CompPlugin::push (pp))
 		{
 		    p = pp;
-		    alreadyLoaded.erase(
-			    std::find(alreadyLoaded.begin(),
-				    alreadyLoaded.end(), pp));
+		    alreadyLoaded.erase (std::find (alreadyLoaded.begin (),
+						    alreadyLoaded.end (), pp));
 		    break;
 		}
 		else
 		{
-		    alreadyLoaded.erase(
-			    std::find(alreadyLoaded.begin(),
-				    alreadyLoaded.end(), pp));
+		    alreadyLoaded.erase (std::find (alreadyLoaded.begin (),
+						    alreadyLoaded.end (), pp));
 		    blacklist.insert (desiredPlugins[desireIndex].s ());
-		    CompPlugin::unload(pp);
+		    CompPlugin::unload (pp);
 		    p = NULL;
 		    failedPush = true;
 		    break;
@@ -1114,25 +1143,23 @@
 	// ...otherwise, try to load and push
 	if (p == 0 && !failedPush)
 	{
-	    p = CompPlugin::load(desiredPlugins[desireIndex].s ().c_str ());
+	    p = CompPlugin::load (desiredPlugins[desireIndex].s ().c_str ());
 
 	    if (p)
 	    {
-		if (!CompPlugin::push(p))
+		if (!CompPlugin::push (p))
 		{
 		    blacklist.insert (desiredPlugins[desireIndex].s ());
-		    CompPlugin::unload(p);
+		    CompPlugin::unload (p);
 		    p = 0;
 		}
 	    }
 	    else
-	    {
 		blacklist.insert (desiredPlugins[desireIndex].s ());
-	    }
 	}
 
 	if (p)
-	    plugin.list().push_back(p->vTable->name());
+	    plugin.list ().push_back(p->vTable->name ());
     }
 
     // Any plugins that are loaded, but were not re-initialized can be unloaded.
@@ -1151,8 +1178,7 @@
 		 Atom    target,
 		 Atom    property)
 {
-
-static const unsigned short N_TARGETS = 4;
+    static const unsigned short N_TARGETS = 4;
 
     Atom conversionTargets[N_TARGETS];
 
@@ -1192,7 +1218,7 @@
 PrivateScreen::handleSelectionRequest (XEvent *event)
 {
     if (wmSnSelectionWindow != event->xselectionrequest.owner ||
-	wmSnAtom != event->xselectionrequest.selection)
+	wmSnAtom            != event->xselectionrequest.selection)
 	return;
 
     XSelectionEvent reply;
@@ -1209,8 +1235,8 @@
     {
 	if (event->xselectionrequest.property != None)
 	{
-	    Atom	  type, *adata;
-	    int		  i, format;
+	    Atom          type;
+	    int           format;
 	    unsigned long num, rest;
 	    unsigned char *data;
 
@@ -1227,8 +1253,9 @@
 	     * but since we have 4 possible targets, we will hardly ever
 	     * meet multiple requests with a length > 8
 	     */
-	    adata = (Atom *) data;
-	    i = 0;
+	    Atom *adata = (Atom *) data;
+	    int  i      = 0;
+
 	    while (i < (int) num)
 	    {
 		if (!convertProperty (dpy, wmSnTimestamp,
@@ -1276,23 +1303,23 @@
     eventManager.quit ();
 }
 
-static const std::string IMAGEDIR("images");
-static const std::string HOMECOMPIZDIR(".compiz-1");
+static const std::string IMAGEDIR      = "images";
+static const std::string HOMECOMPIZDIR = ".compiz-1";
 
 bool
 CompScreenImpl::readImageFromFile (CompString &name,
-			       CompString &pname,
-			       CompSize   &size,
-			       void       *&data)
+				   CompString &pname,
+				   CompSize   &size,
+				   void       *&data)
 {
-    bool status;
     int  stride;
+    bool status = fileToImage (name, size, stride, data);
 
-    status = fileToImage (name, size, stride, data);
     if (!status)
     {
 	char       *home = getenv ("HOME");
 	CompString path;
+
 	if (home)
 	{
 	    path =  home;
@@ -1326,9 +1353,9 @@
 
 bool
 CompScreenImpl::writeImageToFile (CompString &path,
-			      const char *format,
-			      CompSize   &size,
-			      void       *data)
+				  const char *format,
+				  CompSize   &size,
+				  void       *data)
 {
     CompString formatString (format);
     return imageToFile (path, formatString, size, size.width () * 4, data);
@@ -1337,21 +1364,22 @@
 Window
 PrivateScreen::getActiveWindow (Window root)
 {
-    Atom	  actual;
-    int		  result, format;
+    Atom          actual;
+    int           format;
     unsigned long n, left;
     unsigned char *data;
     Window	  w = None;
 
-    result = XGetWindowProperty (dpy, root,
-				 Atoms::winActive, 0L, 1L, false,
-				 XA_WINDOW, &actual, &format,
-				 &n, &left, &data);
+    int result = XGetWindowProperty (dpy, root,
+				     Atoms::winActive, 0L, 1L, false,
+				     XA_WINDOW, &actual, &format,
+				     &n, &left, &data);
 
     if (result == Success && data)
     {
 	if (n)
 	    memcpy (&w, data, sizeof (Window));
+
 	XFree (data);
     }
 
@@ -1370,9 +1398,9 @@
 
 bool
 CompScreenImpl::_fileToImage (CompString &name,
-			 CompSize   &size,
-			 int        &stride,
-			 void       *&data)
+			      CompSize   &size,
+			      int        &stride,
+			      void       *&data)
 {
     return false;
 }
@@ -1384,17 +1412,17 @@
 			 int        stride,
 			 void       *data)
 {
-    WRAPABLE_HND_FUNCTN_RETURN (bool, imageToFile, path, format, size,
-			      stride, data);
+    WRAPABLE_HND_FUNCTN_RETURN (bool, imageToFile, path, format,
+				size, stride, data);
     return _imageToFile (path, format, size, stride, data);
 }
 
 bool
 CompScreenImpl::_imageToFile (CompString &path,
-			 CompString &format,
-			 CompSize   &size,
-			 int        stride,
-			 void       *data)
+			      CompString &format,
+			      CompSize   &size,
+			      int        stride,
+			      void       *data)
 {
     return false;
 }
@@ -1410,8 +1438,8 @@
 
 void
 CompScreenImpl::_logMessage (const char   *componentName,
-			CompLogLevel level,
-			const char   *message)
+			     CompLogLevel level,
+			     const char   *message)
 {
     ::logMessage (componentName, level, message);
 }
@@ -1419,21 +1447,22 @@
 int
 cps::XWindowInfo::getWmState (Window id)
 {
-    Atom	  actual;
-    int		  result, format;
+    Atom          actual;
+    int           format;
     unsigned long n, left;
     unsigned char *data;
     unsigned long state = NormalState;
 
-    result = XGetWindowProperty (dpy, id,
-				 Atoms::wmState, 0L, 2L, false,
-				 Atoms::wmState, &actual, &format,
-				 &n, &left, &data);
+    int result = XGetWindowProperty (dpy, id,
+				     Atoms::wmState, 0L, 2L, false,
+				     Atoms::wmState, &actual, &format,
+				     &n, &left, &data);
 
     if (result == Success && data)
     {
 	if (n)
 	    memcpy (&state, data, sizeof (unsigned long));
+
 	XFree ((void *) data);
     }
 
@@ -1441,7 +1470,8 @@
 }
 
 void
-cps::XWindowInfo::setWmState (int state, Window id) const
+cps::XWindowInfo::setWmState (int    state,
+			      Window id) const
 {
     unsigned long data[2];
 
@@ -1520,16 +1550,16 @@
 unsigned int
 cps::XWindowInfo::getWindowState (Window id)
 {
-    Atom	  actual;
-    int		  result, format;
+    Atom          actual;
+    int           format;
     unsigned long n, left;
     unsigned char *data;
     unsigned int  state = 0;
 
-    result = XGetWindowProperty (dpy, id,
-				 Atoms::winState,
-				 0L, 1024L, false, XA_ATOM, &actual, &format,
-				 &n, &left, &data);
+    int result = XGetWindowProperty (dpy, id,
+				     Atoms::winState,
+				     0L, 1024L, false, XA_ATOM, &actual,
+				     &format, &n, &left, &data);
 
     if (result == Success && data)
     {
@@ -1545,9 +1575,10 @@
 }
 
 unsigned int
-compiz::window::fillStateData (unsigned int state, Atom *data)
+compiz::window::fillStateData (unsigned int state,
+			       Atom         *data)
 {
-    int	 i = 0;
+    int i = 0;
 
     if (state & CompWindowStateModalMask)
 	data[i++] = Atoms::winStateModal;
@@ -1582,34 +1613,35 @@
 }
 
 void
-PrivateScreen::setWindowState (unsigned int state, Window id)
+PrivateScreen::setWindowState (unsigned int state,
+			       Window       id)
 {
-    int i = 0;
     Atom data[32];
 
-    i = compiz::window::fillStateData (state, data);
+    int i = compiz::window::fillStateData (state, data);
     XChangeProperty (dpy, id, Atoms::winState,
-                     XA_ATOM, 32, PropModeReplace,
-                     (unsigned char *) data, i);
+		     XA_ATOM, 32, PropModeReplace,
+		     (unsigned char *) data, i);
 }
 
 unsigned int
 cps::XWindowInfo::getWindowType (Window id)
 {
-    Atom	  actual, a = None;
-    int		  result, format;
+    Atom          actual, a = None;
+    int           format;
     unsigned long n, left;
     unsigned char *data;
 
-    result = XGetWindowProperty (dpy , id,
-				 Atoms::winType,
-				 0L, 1L, false, XA_ATOM, &actual, &format,
-				 &n, &left, &data);
+    int result = XGetWindowProperty (dpy , id,
+				     Atoms::winType,
+				     0L, 1L, false, XA_ATOM, &actual,
+				     &format, &n, &left, &data);
 
     if (result == Success && data)
     {
 	if (n)
 	    memcpy (&a, data, sizeof (Atom));
+
 	XFree ((void *) data);
     }
 
@@ -1650,21 +1682,21 @@
 
 void
 cps::XWindowInfo::getMwmHints (Window       id,
-			    unsigned int *func,
-			    unsigned int *decor) const
+			       unsigned int *func,
+			       unsigned int *decor) const
 {
-    Atom	  actual;
-    int		  result, format;
+    Atom          actual;
+    int           format;
     unsigned long n, left;
     unsigned char *data;
 
     *func  = MwmFuncAll;
     *decor = MwmDecorAll;
 
-    result = XGetWindowProperty (dpy, id,
-				 Atoms::mwmHints,
-				 0L, 20L, false, Atoms::mwmHints,
-				 &actual, &format, &n, &left, &data);
+    int result = XGetWindowProperty (dpy, id,
+				     Atoms::mwmHints,
+				     0L, 20L, false, Atoms::mwmHints,
+				     &actual, &format, &n, &left, &data);
 
     if (result == Success && data)
     {
@@ -1692,7 +1724,7 @@
 
     if (XGetWMProtocols (dpy, id, &protocol, &count))
     {
-	for (int i = 0; i < count; i++)
+	for (int i = 0; i < count; ++i)
 	{
 	    if (protocol[i] == Atoms::wmDeleteWindow)
 		protocols |= CompWindowProtocolDeleteMask;
@@ -1712,18 +1744,18 @@
 
 unsigned int
 CompScreenImpl::getWindowProp (Window       id,
-			   Atom         property,
-			   unsigned int defaultValue)
+			       Atom         property,
+			       unsigned int defaultValue)
 {
-    Atom	  actual;
-    int		  result, format;
+    Atom          actual;
+    int           format;
     unsigned long n, left;
     unsigned char *data;
     unsigned int  retval = defaultValue;
 
-    result = XGetWindowProperty (privateScreen.dpy, id, property,
-				 0L, 1L, false, XA_CARDINAL, &actual, &format,
-				 &n, &left, &data);
+    int result = XGetWindowProperty (privateScreen.dpy, id, property,
+				     0L, 1L, false, XA_CARDINAL, &actual, &format,
+				     &n, &left, &data);
 
     if (result == Success && data)
     {
@@ -1742,8 +1774,8 @@
 
 void
 CompScreenImpl::setWindowProp (Window       id,
-			   Atom         property,
-			   unsigned int value)
+			       Atom         property,
+			       unsigned int value)
 {
     unsigned long data = value;
 
@@ -1757,15 +1789,15 @@
 				 Atom           property,
 				 unsigned short *returnValue)
 {
-    Atom	  actual;
-    int		  result, format;
+    Atom          actual;
+    int           format;
     unsigned long n, left;
     unsigned char *data;
     bool          retval = false;
 
-    result = XGetWindowProperty (dpy, id, property,
-				 0L, 1L, false, XA_CARDINAL, &actual, &format,
-				 &n, &left, &data);
+    int result = XGetWindowProperty (dpy, id, property,
+				     0L, 1L, false, XA_CARDINAL, &actual,
+				     &format, &n, &left, &data);
 
     if (result == Success && data)
     {
@@ -1786,8 +1818,8 @@
 
 unsigned short
 CompScreenImpl::getWindowProp32 (Window         id,
-			     Atom           property,
-			     unsigned short defaultValue)
+				 Atom           property,
+				 unsigned short defaultValue)
 {
     unsigned short result;
 
@@ -1799,12 +1831,10 @@
 
 void
 CompScreenImpl::setWindowProp32 (Window         id,
-			     Atom           property,
-			     unsigned short value)
+				 Atom           property,
+				 unsigned short value)
 {
-    CARD32 value32;
-
-    value32 = value << 16 | value;
+    CARD32 value32 = value << 16 | value;
 
     XChangeProperty (privateScreen.dpy, id, property,
 		     XA_CARDINAL, 32, PropModeReplace,
@@ -1875,40 +1905,39 @@
 void
 PrivateScreen::setDesktopHints ()
 {
-    unsigned long *data;
-
-    int dSize = nDesktop * 2 + nDesktop * 2 + nDesktop * 4 + 1;
-
-    data = (unsigned long *) malloc (sizeof (unsigned long) * dSize);
+    int dSize = nDesktop * 8 + 1;
+
+    unsigned long *data = (unsigned long *) malloc (sizeof (unsigned long) * dSize);
+
     if (!data)
 	return;
 
-    unsigned int  i;
+    unsigned int i;
     int offset   = 0;
     int hintSize = nDesktop * 2;
 
-    for (i = 0; i < nDesktop; i++)
+    for (i = 0; i < nDesktop; ++i)
     {
 	data[offset + i * 2 + 0] = viewPort.vp.x () * screen->width ();
 	data[offset + i * 2 + 1] = viewPort.vp.y () * screen->height ();
     }
 
     if (!desktopHintEqual (data, dSize, offset, hintSize))
-	XChangeProperty (dpy, rootWindow(),
+	XChangeProperty (dpy, rootWindow (),
 			 Atoms::desktopViewport,
 			 XA_CARDINAL, 32, PropModeReplace,
 			 (unsigned char *) &data[offset], hintSize);
 
     offset += hintSize;
 
-    for (i = 0; i < nDesktop; i++)
+    for (i = 0; i < nDesktop; ++i)
     {
-	data[offset + i * 2 + 0] = screen->width () * viewPort.vpSize.width ();
+	data[offset + i * 2 + 0] = screen->width ()  * viewPort.vpSize.width ();
 	data[offset + i * 2 + 1] = screen->height () * viewPort.vpSize.height ();
     }
 
     if (!desktopHintEqual (data, dSize, offset, hintSize))
-	XChangeProperty (dpy, rootWindow(),
+	XChangeProperty (dpy, rootWindow (),
 			 Atoms::desktopGeometry,
 			 XA_CARDINAL, 32, PropModeReplace,
 			 (unsigned char *) &data[offset], hintSize);
@@ -1916,7 +1945,7 @@
     offset += hintSize;
     hintSize = nDesktop * 4;
 
-    for (i = 0; i < nDesktop; i++)
+    for (i = 0; i < nDesktop; ++i)
     {
 	data[offset + i * 4 + 0] = workArea.x ();
 	data[offset + i * 4 + 1] = workArea.y ();
@@ -1925,7 +1954,7 @@
     }
 
     if (!desktopHintEqual (data, dSize, offset, hintSize))
-	XChangeProperty (dpy, rootWindow(),
+	XChangeProperty (dpy, rootWindow (),
 			 Atoms::workarea,
 			 XA_CARDINAL, 32, PropModeReplace,
 			 (unsigned char *) &data[offset], hintSize);
@@ -1936,7 +1965,7 @@
     hintSize = 1;
 
     if (!desktopHintEqual (data, dSize, offset, hintSize))
-	XChangeProperty (dpy, rootWindow(),
+	XChangeProperty (dpy, rootWindow (),
 			 Atoms::numberOfDesktops,
 			 XA_CARDINAL, 32, PropModeReplace,
 			 (unsigned char *) &data[offset], hintSize);
@@ -1949,14 +1978,15 @@
 }
 
 void
-PrivateScreen::setVirtualScreenSize (int newh, int newv)
+PrivateScreen::setVirtualScreenSize (int newh,
+				     int newv)
 {
     /* if newh or newv is being reduced */
     if (newh < screen->vpSize ().width () ||
 	newv < screen->vpSize ().height ())
     {
-	int        tx = 0;
-	int        ty = 0;
+	int tx = 0;
+	int ty = 0;
 
 	if (screen->vp ().x () >= newh)
 	    tx = screen->vp ().x () - (newh - 1);
@@ -1966,12 +1996,16 @@
 	if (tx != 0 || ty != 0)
 	    screen->moveViewport (tx, ty, TRUE);
 
+	int moveX, moveY;
+	int vpX;   /* x index of a window's vp */
+	int vpY;   /* y index of a window's vp */
+
 	/* Move windows that were in one of the deleted viewports into the
 	   closest viewport */
 	foreach (CompWindow *w, screen->windows ())
 	{
-	    int moveX = 0;
-	    int moveY = 0;
+	    moveX = 0;
+	    moveY = 0;
 
 	    if (w->onAllViewports ())
 		continue;
@@ -1981,9 +2015,8 @@
 	       vertical index range */
 	    if (newh < screen->vpSize ().width ())
 	    {
-		int vpX;   /* x index of a window's vp */
-
 		vpX = w->serverX () / screen->width ();
+
 		if (w->serverX () < 0)
 		    vpX -= 1;
 
@@ -1993,11 +2026,11 @@
 		if (vpX >= newh)
 		    moveX = ((newh - 1) - vpX) * screen->width ();
 	    }
+
 	    if (newv < screen->vpSize ().height ())
 	    {
-		int vpY;   /* y index of a window's vp */
-
 		vpY = w->serverY () / screen->height ();
+
 		if (w->serverY () < 0)
 		    vpY -= 1;
 
@@ -2032,7 +2065,7 @@
 {
     outputDevices.updateOutputDevices(coreOptions, screen);
 
-    windowManager.clearFullscreenHints();
+    windowManager.clearFullscreenHints ();
 
     screen->updateWorkarea ();
 
@@ -2040,7 +2073,7 @@
 }
 
 void
-PrivateScreen::detectOutputDevices (CoreOptions& coreOptions)
+PrivateScreen::detectOutputDevices (CoreOptions &coreOptions)
 {
     if (coreOptions.optionGetDetectOutputs ())
     {
@@ -2050,11 +2083,10 @@
 	if (!screenInfo.empty ())
 	{
 	    CompOption::Value::Vector l;
+
 	    foreach (XineramaScreenInfo xi, screenInfo)
-	    {
 		l.push_back (compPrintf ("%dx%d+%d+%d", xi.width, xi.height,
 					 xi.x_org, xi.y_org));
-	    }
 
 	    value.set (CompOption::TypeString, l);
 	}
@@ -2071,12 +2103,9 @@
 	coreOptions.getOptions()[CoreOptions::DetectOutputs].value ().set (true);
     }
     else
-    {
 	updateOutputDevices (coreOptions);
-    }
 }
 
-
 void
 cps::StartupSequenceImpl::updateStartupFeedback ()
 {
@@ -2089,13 +2118,14 @@
     }
 }
 
+/* TODO: Investigate this magic number timeout, can it be reduced ? */
 static const unsigned int STARTUP_TIMEOUT_DELAY = 15000;
 
 bool
 cps::StartupSequence::handleStartupSequenceTimeout ()
 {
-    struct timeval	now, active;
-    double		elapsed;
+    struct timeval now, active;
+    double         elapsed;
 
     gettimeofday (&now, NULL);
 
@@ -2116,11 +2146,11 @@
 }
 
 void
-cps::StartupSequence::addSequence (SnStartupSequence *sequence, CompPoint const& vp)
+cps::StartupSequence::addSequence (SnStartupSequence *sequence,
+				   CompPoint const   &vp)
 {
-    CompStartupSequence *s;
+    CompStartupSequence *s = new CompStartupSequence ();
 
-    s = new CompStartupSequence ();
     if (!s)
 	return;
 
@@ -2188,35 +2218,41 @@
 
 void
 PrivateScreen::compScreenSnEvent (SnMonitorEvent *event,
-			       void           *userData)
+				  void           *userData)
 {
-    PrivateScreen	      *self = (PrivateScreen *) userData;
-    SnStartupSequence *sequence;
-
-    sequence = sn_monitor_event_get_startup_sequence (event);
-
-    switch (sn_monitor_event_get_type (event)) {
-    case SN_MONITOR_EVENT_INITIATED:
-	self->startupSequence.addSequence (sequence, self->viewPort.vp);
-	break;
-    case SN_MONITOR_EVENT_COMPLETED:
-	self->startupSequence.removeSequence (sequence);
-	break;
-    case SN_MONITOR_EVENT_CHANGED:
-    case SN_MONITOR_EVENT_CANCELED:
-	break;
+    PrivateScreen     *self     = (PrivateScreen *) userData;
+    SnStartupSequence *sequence = sn_monitor_event_get_startup_sequence (event);
+
+    switch (sn_monitor_event_get_type (event))
+    {
+	case SN_MONITOR_EVENT_INITIATED:
+	    self->startupSequence.addSequence (sequence, self->viewPort.vp);
+	    break;
+
+	case SN_MONITOR_EVENT_COMPLETED:
+	    self->startupSequence.removeSequence (sequence);
+	    break;
+
+	case SN_MONITOR_EVENT_CHANGED:
+	case SN_MONITOR_EVENT_CANCELED:
+	    break;
+
+	default:
+	    break;
     }
 }
 
 void
 PrivateScreen::updateScreenEdges ()
 {
-    struct screenEdgeGeometry {
+    struct screenEdgeGeometry
+    {
 	int xw, x0;
 	int yh, y0;
 	int ww, w0;
 	int hh, h0;
-    } geometry[SCREEN_EDGE_NUM] = {
+    } geometry[SCREEN_EDGE_NUM] =
+    {
 	{ 0, -1,   0,  2,   0,  2,   1, -4 }, /* left */
 	{ 1, -1,   0,  2,   0,  2,   1, -4 }, /* right */
 	{ 0,  2,   0, -1,   1, -4,   0,  2 }, /* top */
@@ -2227,8 +2263,7 @@
 	{ 1, -1,   1, -1,   0,  2,   0,  2 }  /* bottom-right */
     };
 
-    for (int i = 0; i < SCREEN_EDGE_NUM; i++)
-    {
+    for (int i = 0; i < SCREEN_EDGE_NUM; ++i)
 	if (screenEdge[i].id)
 	    XMoveResizeWindow (dpy, screenEdge[i].id,
 			       geometry[i].xw * screen->width () +
@@ -2239,11 +2274,11 @@
 			       geometry[i].w0,
 			       geometry[i].hh * screen->height () +
 			       geometry[i].h0);
-    }
 }
 
 void
-PrivateScreen::reshape (int w, int h)
+PrivateScreen::reshape (int w,
+			int h)
 {
     updateScreenInfo ();
 
@@ -2271,12 +2306,12 @@
 	reshape (ce->width, ce->height);
 
 	detectOutputDevices (*this);
-
 	updateOutputDevices (*this);
 }
 
 void
-cps::EventManager::setSupportingWmCheck (Display* dpy, Window root)
+cps::EventManager::setSupportingWmCheck (Display* dpy,
+					 Window   root)
 {
     XChangeProperty (dpy, grabWindow,
 		     Atoms::supportingWmCheck,
@@ -2286,13 +2321,15 @@
     XChangeProperty (dpy, grabWindow, Atoms::wmName,
 		     Atoms::utf8String, 8, PropModeReplace,
 		     (unsigned char *) PACKAGE, strlen (PACKAGE));
+
     XChangeProperty (dpy, grabWindow, Atoms::winState,
 		     XA_ATOM, 32, PropModeReplace,
-		     (unsigned char *) &Atoms::winStateSkipTaskbar,
-		     1);
+		     (unsigned char *) &Atoms::winStateSkipTaskbar, 1);
+
     XChangeProperty (dpy, grabWindow, Atoms::winState,
 		     XA_ATOM, 32, PropModeAppend,
 		     (unsigned char *) &Atoms::winStateSkipPager, 1);
+
     XChangeProperty (dpy, grabWindow, Atoms::winState,
 		     XA_ATOM, 32, PropModeAppend,
 		     (unsigned char *) &Atoms::winStateHidden, 1);
@@ -2354,6 +2391,7 @@
     atoms.push_back (Atoms::workarea);
 
     atoms.push_back (Atoms::wmName);
+    // TODO: Why is this below commented out ?
 /*
     atoms.push_back (Atoms::wmVisibleName);
 */
@@ -2361,6 +2399,7 @@
     atoms.push_back (Atoms::wmStrut);
     atoms.push_back (Atoms::wmStrutPartial);
 
+    // TODO: Why is this below commented out ?
 /*
     atoms.push_back (Atoms::wmPid);
 */
@@ -2387,7 +2426,7 @@
     atoms.push_back (Atoms::winOpacity);
     atoms.push_back (Atoms::winBrightness);
 
-/* FIXME */
+/* TODO: FIXME */
 #if 0
     if (canDoSaturated)
     {
@@ -2435,14 +2474,14 @@
 PrivateScreen::getDesktopHints (unsigned int showingDesktopMask)
 {
     unsigned long data[2];
-    Atom	  actual;
-    int		  result, format;
+    Atom          actual;
+    int           result, format;
     unsigned long n, left;
     unsigned char *propData;
 
     if (useDesktopHints)
     {
-	result = XGetWindowProperty (dpy, rootWindow(),
+	result = XGetWindowProperty (dpy, rootWindow (),
 				     Atoms::numberOfDesktops,
 				     0L, 1L, false, XA_CARDINAL, &actual,
 				     &format, &n, &left, &propData);
@@ -2452,6 +2491,7 @@
 	    if (n)
 	    {
 		memcpy (data, propData, sizeof (unsigned long));
+
 		if (data[0] > 0 && data[0] < 0xffffffff)
 		    nDesktop = data[0];
 	    }
@@ -2459,7 +2499,7 @@
 	    XFree (propData);
 	}
 
-	result = XGetWindowProperty (dpy, rootWindow(),
+	result = XGetWindowProperty (dpy, rootWindow (),
 				     Atoms::desktopViewport, 0L, 2L,
 				     false, XA_CARDINAL, &actual, &format,
 				     &n, &left, &propData);
@@ -2482,7 +2522,7 @@
 	    XFree (propData);
 	}
 
-	result = XGetWindowProperty (dpy, rootWindow(),
+	result = XGetWindowProperty (dpy, rootWindow (),
 				     Atoms::currentDesktop,
 				     0L, 1L, false, XA_CARDINAL, &actual,
 				     &format, &n, &left, &propData);
@@ -2492,6 +2532,7 @@
 	    if (n)
 	    {
 		memcpy (data, propData, sizeof (unsigned long));
+
 		if (data[0] < nDesktop)
 		    currentDesktop = data[0];
 	    }
@@ -2500,7 +2541,7 @@
 	}
     }
 
-    result = XGetWindowProperty (dpy, rootWindow(),
+    result = XGetWindowProperty (dpy, rootWindow (),
 				 Atoms::showingDesktop,
 				 0L, 1L, false, XA_CARDINAL, &actual, &format,
 				 &n, &left, &propData);
@@ -2510,6 +2551,7 @@
 	if (n)
 	{
 	    memcpy (data, propData, sizeof (unsigned long));
+
 	    if (data[0])
 		screen->enterShowDesktopMode ();
 	}
@@ -2519,13 +2561,13 @@
 
     data[0] = currentDesktop;
 
-    XChangeProperty (dpy, rootWindow(), Atoms::currentDesktop,
+    XChangeProperty (dpy, rootWindow (), Atoms::currentDesktop,
 		     XA_CARDINAL, 32, PropModeReplace,
 		     (unsigned char *) data, 1);
 
     data[0] = showingDesktopMask ? true : false;
 
-    XChangeProperty (dpy, rootWindow(), Atoms::showingDesktop,
+    XChangeProperty (dpy, rootWindow (), Atoms::showingDesktop,
 		     XA_CARDINAL, 32, PropModeReplace,
 		     (unsigned char *) data, 1);
 }
@@ -2537,29 +2579,31 @@
     _enterShowDesktopMode ();
 }
 
-unsigned int CompScreenImpl::showingDesktopMask() const
+unsigned int CompScreenImpl::showingDesktopMask () const
 {
     return showingDesktopMask_;
 }
 
-bool CompScreenImpl::grabsEmpty() const
+bool CompScreenImpl::grabsEmpty () const
 {
-    return privateScreen.eventManager.grabsEmpty();
+    return privateScreen.eventManager.grabsEmpty ();
 }
 
 void
 CompScreenImpl::_enterShowDesktopMode ()
 {
-    unsigned long data = 1;
-    int		  count = 0;
-    bool          st = privateScreen.optionGetHideSkipTaskbarWindows ();
+    unsigned long data  = 1;
+    int           count = 0;
+    bool          st    = privateScreen.optionGetHideSkipTaskbarWindows ();
 
     showingDesktopMask_ = ~(CompWindowTypeDesktopMask |
 				 CompWindowTypeDockMask);
 
-    for (cps::WindowManager::iterator i = windowManager.begin(); i != windowManager.end(); ++i)
+    for (cps::WindowManager::iterator i = windowManager.begin ();
+	 i != windowManager.end (); ++i)
     {
 	CompWindow* const w(*i);
+
 	if ((showingDesktopMask_ & w->wmType ()) &&
 	    (!(w->state () & CompWindowStateSkipTaskbarMask) || st))
 	{
@@ -2573,7 +2617,7 @@
 	}
 
 	if (w->inShowDesktopMode ())
-	    count++;
+	    ++count;
     }
 
     if (!count)
@@ -2610,9 +2654,10 @@
 	window->priv->show ();
 
 	/* return if some other window is still in show desktop mode */
-	for (cps::WindowManager::iterator i = windowManager.begin(); i != windowManager.end(); ++i)
+	for (cps::WindowManager::iterator i = windowManager.begin (); i != windowManager.end (); ++i)
 	{
 	    CompWindow* const w(*i);
+
 	    if (w->inShowDesktopMode ())
 		return;
 	}
@@ -2622,9 +2667,10 @@
     {
 	showingDesktopMask_ = 0;
 
-	for (cps::WindowManager::iterator i = windowManager.begin(); i != windowManager.end(); ++i)
+	for (cps::WindowManager::iterator i = windowManager.begin (); i != windowManager.end (); ++i)
 	{
 	    CompWindow* const w(*i);
+
 	    if (!w->inShowDesktopMode ())
 		continue;
 
@@ -2638,7 +2684,7 @@
 	focusDefaultWindow ();
     }
 
-    XChangeProperty (privateScreen.dpy, privateScreen.rootWindow(),
+    XChangeProperty (privateScreen.dpy, privateScreen.rootWindow (),
 		     Atoms::showingDesktop,
 		     XA_CARDINAL, 32, PropModeReplace,
 		     (unsigned char *) &data, 1);
@@ -2676,11 +2722,11 @@
 	    /* huh, we didn't find d->below ... perhaps it's out of date;
 	       try grabbing it through the server */
 
-	    status = XQueryPointer (dpy (), privateScreen.rootWindow(), &rootReturn,
+	    status = XQueryPointer (dpy (), privateScreen.rootWindow (), &rootReturn,
 				    &childReturn, &dummyInt, &dummyInt,
 				    &dummyInt, &dummyInt, &dummyUInt);
 
-	    if (status && rootReturn == privateScreen.rootWindow())
+	    if (status && rootReturn == privateScreen.rootWindow ())
 	    {
 		w = findTopLevelWindow (childReturn);
 
@@ -2697,8 +2743,8 @@
     if (!focus)
     {
 	/* Traverse down the stack */
-	for (cps::WindowManager::reverse_iterator rit = windowManager.rbegin();
-	     rit != windowManager.rend(); ++rit)
+	for (cps::WindowManager::reverse_iterator rit = windowManager.rbegin ();
+	     rit != windowManager.rend (); ++rit)
 	{
 	    w = (*rit);
 
@@ -2745,8 +2791,8 @@
     }
     else
     {
-	XSetInputFocus (privateScreen.dpy, privateScreen.rootWindow(), RevertToPointerRoot,
-			CurrentTime);
+	XSetInputFocus (privateScreen.dpy, privateScreen.rootWindow (),
+			RevertToPointerRoot, CurrentTime);
     }
 }
 
@@ -2760,26 +2806,23 @@
 cps::WindowManager::findWindow (Window id) const
 {
     if (lastFoundWindow && lastFoundWindow->id () == id)
-    {
 	return lastFoundWindow;
-    }
     else
     {
-        CompWindow::Map::const_iterator it = windowsMap.find (id);
+	CompWindow::Map::const_iterator it = windowsMap.find (id);
 
-        if (it != windowsMap.end ())
-            return (lastFoundWindow = it->second);
+	if (it != windowsMap.end ())
+	    return (lastFoundWindow = it->second);
     }
 
     return 0;
 }
 
 CompWindow *
-CompScreenImpl::findTopLevelWindow (Window id, bool override_redirect)
+CompScreenImpl::findTopLevelWindow (Window id,
+				    bool   override_redirect)
 {
-    CompWindow *w;
-
-    w = findWindow (id);
+    CompWindow *w = findWindow (id);
 
     if (w)
     {
@@ -2792,6 +2835,7 @@
     for (cps::WindowManager::iterator i = windowManager.begin(); i != windowManager.end(); ++i)
     {
 	CompWindow* const w(*i);
+
 	if (w->priv->serverFrame == id)
 	{
 	    if (w->overrideRedirect () && !override_redirect)
@@ -2805,7 +2849,8 @@
 }
 
 void
-CompScreenImpl::insertWindow (CompWindow *w, Window	aboveId)
+CompScreenImpl::insertWindow (CompWindow *w,
+			      Window     aboveId)
 {
     windowManager.insertWindow (w, aboveId);
 }
@@ -2817,7 +2862,7 @@
     if (dbg)
 	dbg->windowsChanged (true);
 
-    invalidateServerWindows();
+    invalidateServerWindows ();
 
     w->prev = NULL;
     w->next = NULL;
@@ -2829,9 +2874,9 @@
 	    windows.front ()->prev = w;
 	    w->next = windows.front ();
 	}
+
 	windows.push_front (w);
-
-	addWindowToMap(w);
+	addWindowToMap (w);
 
 	return;
     }
@@ -2842,9 +2887,8 @@
     {
 	if ((*it)->id () == aboveId ||
 	    ((*it)->priv->frame && (*it)->priv->frame == aboveId))
-	{
 	    break;
-	}
+
 	++it;
     }
 
@@ -2863,16 +2907,15 @@
     (*it)->next = w;
 
     if (w->next)
-    {
 	w->next->prev = w;
-    }
 
     windows.insert (++it, w);
-    addWindowToMap(w);
+    addWindowToMap (w);
 }
 
 void
-CompScreenImpl::insertServerWindow (CompWindow *w, Window	aboveId)
+CompScreenImpl::insertServerWindow (CompWindow *w,
+				    Window     aboveId)
 {
     windowManager.insertServerWindow(w, aboveId);
 }
@@ -2895,6 +2938,7 @@
 	    serverWindows.front ()->serverPrev = w;
 	    w->serverNext = serverWindows.front ();
 	}
+
 	serverWindows.push_front (w);
 
 	return;
@@ -2906,9 +2950,8 @@
     {
 	if ((*it)->priv->serverId == aboveId ||
 	    ((*it)->priv->serverFrame && (*it)->priv->serverFrame == aboveId))
-	{
 	    break;
-	}
+
 	++it;
     }
 
@@ -2927,9 +2970,7 @@
     (*it)->serverNext = w;
 
     if (w->serverNext)
-    {
 	w->serverNext->serverPrev = w;
-    }
 
     serverWindows.insert (++it, w);
 }
@@ -2938,7 +2979,7 @@
 cps::WindowManager::eraseWindowFromMap (Window id)
 {
     if (id != 1)
-        windowsMap.erase (id);
+	windowsMap.erase (id);
 }
 
 void
@@ -2948,17 +2989,16 @@
 }
 
 void
-cps::WindowManager::unhookWindow(CompWindow* w)
+cps::WindowManager::unhookWindow (CompWindow* w)
 {
     StackDebugger *dbg = StackDebugger::Default ();
 
     if (dbg)
 	dbg->windowsChanged (true);
 
-    CompWindowList::iterator it =
-	std::find (windows.begin(), windows.end(), w);
+    CompWindowList::iterator it = std::find (windows.begin (), windows.end (), w);
 
-    if (it == windows.end())
+    if (it == windows.end ())
     {
 	compLogMessage ("core", CompLogLevelWarn, "a broken plugin tried to remove a window twice, we won't allow that!");
 	return;
@@ -2976,7 +3016,7 @@
     w->next = NULL;
     w->prev = NULL;
 
-    removeFromFindWindowCache(w);
+    removeFromFindWindowCache (w);
 }
 
 void
@@ -3029,25 +3069,26 @@
 #define POINTER_GRAB_MASK (ButtonReleaseMask | \
 			   ButtonPressMask   | \
 			   PointerMotionMask)
+
 CompScreenImpl::GrabHandle
-CompScreenImpl::pushGrab (Cursor cursor, const char *name)
+CompScreenImpl::pushGrab (Cursor     cursor,
+			  const char *name)
 {
     if (privateScreen.eventManager.grabsEmpty ())
     {
-	int status;
-
-	status = XGrabPointer (privateScreen.dpy, privateScreen.eventManager.getGrabWindow(), true,
-			       POINTER_GRAB_MASK,
-			       GrabModeAsync, GrabModeAsync,
-			       privateScreen.rootWindow(), cursor,
-			       CurrentTime);
+	int status = XGrabPointer (privateScreen.dpy, privateScreen.eventManager.getGrabWindow (),
+				   true, POINTER_GRAB_MASK,
+				   GrabModeAsync, GrabModeAsync,
+				   privateScreen.rootWindow (), cursor,
+				   CurrentTime);
 
 	if (status == GrabSuccess)
 	{
 	    status = XGrabKeyboard (privateScreen.dpy,
-				    privateScreen.eventManager.getGrabWindow(), true,
+				    privateScreen.eventManager.getGrabWindow (), true,
 				    GrabModeAsync, GrabModeAsync,
 				    CurrentTime);
+
 	    if (status != GrabSuccess)
 	    {
 		XUngrabPointer (privateScreen.dpy, CurrentTime);
@@ -3058,10 +3099,8 @@
 	    return NULL;
     }
     else
-    {
 	XChangeActivePointerGrab (privateScreen.dpy, POINTER_GRAB_MASK,
 				  cursor, CurrentTime);
-    }
 
     cps::Grab *grab = new cps::Grab (cursor, name);
     privateScreen.eventManager.grabsPush (grab);
@@ -3070,7 +3109,8 @@
 }
 
 void
-CompScreenImpl::updateGrab (CompScreen::GrabHandle handle, Cursor cursor)
+CompScreenImpl::updateGrab (CompScreen::GrabHandle handle,
+			    Cursor                 cursor)
 {
     if (!handle)
 	return;
@@ -3083,12 +3123,12 @@
 
 void
 CompScreenImpl::removeGrab (CompScreen::GrabHandle handle,
-			CompPoint *restorePointer)
+			    CompPoint              *restorePointer)
 {
     if (!handle)
 	return;
 
-    privateScreen.eventManager.grabsRemove(handle);
+    privateScreen.eventManager.grabsRemove (handle);
 
     if (!privateScreen.eventManager.grabsEmpty ())
     {
@@ -3109,7 +3149,7 @@
 }
 
 void
-cps::GrabList::grabsRemove(Grab* handle)
+cps::GrabList::grabsRemove (Grab *handle)
 {
     GrabIterator it = std::find (grabsBegin (), grabsEnd (), handle);
 
@@ -3125,18 +3165,21 @@
    plugins listed, returns false otherwise. */
 
 bool
-CompScreenImpl::otherGrabExist (const char *first, ...)
+CompScreenImpl::otherGrabExist (const char *first,
+				...)
 {
     va_list    ap;
     const char *name;
 
     std::list<cps::Grab *>::iterator it;
 
-    for (it = privateScreen.eventManager.grabsBegin (); it != privateScreen.eventManager.grabsEnd (); ++it)
+    for (it = privateScreen.eventManager.grabsBegin ();
+	 it != privateScreen.eventManager.grabsEnd (); ++it)
     {
 	va_start (ap, first);
 
 	name = first;
+
 	while (name)
 	{
 	    if (strcmp (name, (*it)->name) == 0)
@@ -3164,23 +3207,22 @@
 cps::GrabList::grabExist (const char *grab)
 {
     foreach (cps::Grab* g, grabs)
-    {
 	if (strcmp (g->name, grab) == 0)
 	    return true;
-    }
+
     return false;
 }
 
 bool
 CompScreenImpl::grabbed ()
 {
-    return privateScreen.eventManager.isGrabbed();
+    return privateScreen.eventManager.isGrabbed ();
 }
 
 void
 cps::GrabManager::grabUngrabOneKey (unsigned int modifiers,
-				 int          keycode,
-				 bool         grab)
+				    int          keycode,
+				    bool         grab)
 {
     if (grab)
     {
@@ -3188,62 +3230,51 @@
 	 * Always grab the keyboard Sync-ronously. This is so that we can
 	 * choose to ReplayKeyboard in alwaysHandleEvent if need be.
 	 */
-	XGrabKey (screen->dpy(),
+	XGrabKey (screen->dpy (),
 		  keycode,
 		  modifiers,
-		  screen->root(),
+		  screen->root (),
 		  true,
 		  GrabModeAsync,
 		  GrabModeSync);
     }
     else
     {
-	XUngrabKey (screen->dpy(),
+	XUngrabKey (screen->dpy (),
 		    keycode,
 		    modifiers,
-		    screen->root());
+		    screen->root ());
     }
 }
 
 bool
 cps::GrabManager::grabUngrabKeys (unsigned int modifiers,
-			       int          keycode,
-			       bool         grab)
+				  int          keycode,
+				  bool         grab)
 {
-    int             mod, k;
-    unsigned int    ignore;
-
-    CompScreen::checkForError (screen->dpy());
-
-    for (ignore = 0; ignore <= modHandler->ignoredModMask (); ignore++)
+    int          mod, k;
+    int          minCode, maxCode;
+    unsigned int ignore;
+
+    CompScreen::checkForError (screen->dpy ());
+
+    for (ignore = 0; ignore <= modHandler->ignoredModMask (); ++ignore)
     {
 	if (ignore & ~modHandler->ignoredModMask ())
 	    continue;
 
 	if (keycode != 0)
-	{
 	    grabUngrabOneKey (modifiers | ignore, keycode, grab);
-	}
 	else
 	{
-	    for (mod = 0; mod < 8; mod++)
-	    {
+	    for (mod = 0; mod < 8; ++mod)
 		if (modifiers & (1 << mod))
-		{
 		    for (k = mod * modHandler->modMap ()->max_keypermod;
-			 k < (mod + 1) * modHandler->modMap ()->max_keypermod;
-			 k++)
-		    {
+			 k < (mod + 1) * modHandler->modMap ()->max_keypermod; ++k)
 			if (modHandler->modMap ()->modifiermap[k])
-			{
-			    grabUngrabOneKey ((modifiers & ~(1 << mod)) |
-					      ignore,
+			    grabUngrabOneKey ((modifiers & ~(1 << mod)) | ignore,
 					      modHandler->modMap ()->modifiermap[k],
 					      grab);
-			}
-		    }
-		}
-	    }
 
 	    /*
 	     * keycode == 0, so this is a modifier-only keybinding.
@@ -3255,15 +3286,15 @@
 	     * keys, and know to cancel the tap if <modifier>+k is pressed.
 	     */
 	    if (!(currentState & CompAction::StateIgnoreTap))
-            {
- 		int minCode, maxCode;
- 		XDisplayKeycodes (screen->dpy(), &minCode, &maxCode);
- 		for (k = minCode; k <= maxCode; k++)
- 		    grabUngrabOneKey (modifiers | ignore, k, grab);
-            }
+	    {
+		XDisplayKeycodes (screen->dpy (), &minCode, &maxCode);
+
+		for (k = minCode; k <= maxCode; ++k)
+		    grabUngrabOneKey (modifiers | ignore, k, grab);
+	    }
 	}
 
-	if (CompScreen::checkForError (screen->dpy()))
+	if (CompScreen::checkForError (screen->dpy ()))
 	    return false;
     }
 
@@ -3273,29 +3304,22 @@
 bool
 cps::GrabManager::addPassiveKeyGrab (CompAction::KeyBinding &key)
 {
-    KeyGrab                      newKeyGrab;
-    unsigned int                 mask;
-    std::list<KeyGrab>::iterator it;
-
-    mask = modHandler->virtualToRealModMask (key.modifiers ());
-
-    for (it = keyGrabs.begin (); it != keyGrabs.end (); ++it)
+    KeyGrab      newKeyGrab;
+    unsigned int mask = modHandler->virtualToRealModMask (key.modifiers ());
+
+    for (std::list<KeyGrab>::iterator it = keyGrabs.begin (); it != keyGrabs.end (); ++it)
     {
 	if (key.keycode () == (*it).keycode &&
 	    mask           == (*it).modifiers)
 	{
-	    (*it).count++;
+	    ++(*it).count;
 	    return true;
 	}
     }
 
-
-
-    if (!(mask & CompNoMask))
-    {
-	if (!grabUngrabKeys (mask, key.keycode (), true))
-	    return false;
-    }
+    if (!(mask & CompNoMask) &&
+	!grabUngrabKeys (mask, key.keycode (), true))
+	return false;
 
     newKeyGrab.keycode   = key.keycode ();
     newKeyGrab.modifiers = mask;
@@ -3309,17 +3333,16 @@
 void
 cps::GrabManager::removePassiveKeyGrab (CompAction::KeyBinding &key)
 {
-    unsigned int                 mask;
-    std::list<KeyGrab>::iterator it;
-
-    mask = modHandler->virtualToRealModMask (key.modifiers ());
-
-    for (it = keyGrabs.begin (); it != keyGrabs.end (); ++it)
+    unsigned int mask = modHandler->virtualToRealModMask (key.modifiers ());
+
+    for (std::list<KeyGrab>::iterator it = keyGrabs.begin ();
+	 it != keyGrabs.end (); ++it)
     {
 	if (key.keycode () == (*it).keycode &&
 	    mask           == (*it).modifiers)
 	{
-	    (*it).count--;
+	    --(*it).count;
+
 	    if ((*it).count)
 		return;
 
@@ -3342,32 +3365,27 @@
 void
 cps::GrabManager::updatePassiveKeyGrabs ()
 {
-    std::list<cps::KeyGrab>::iterator it;
-
-    XUngrabKey (screen->dpy(), AnyKey, AnyModifier, screen->root());
-
-    for (it = keyGrabs.begin (); it != keyGrabs.end (); ++it)
-    {
+    XUngrabKey (screen->dpy (), AnyKey, AnyModifier, screen->root ());
+
+    for (std::list<cps::KeyGrab>::iterator it = keyGrabs.begin ();
+	 it != keyGrabs.end (); ++it)
 	if (!((*it).modifiers & CompNoMask))
-	{
 	    grabUngrabKeys ((*it).modifiers,
 			    (*it).keycode, true);
-	}
-    }
 }
 
 bool
 cps::GrabManager::addPassiveButtonGrab (CompAction::ButtonBinding &button)
 {
-    ButtonGrab                      newButtonGrab;
-    std::list<ButtonGrab>::iterator it;
+    ButtonGrab newButtonGrab;
 
-    for (it = buttonGrabs.begin (); it != buttonGrabs.end (); ++it)
+    for (std::list<ButtonGrab>::iterator it = buttonGrabs.begin ();
+	 it != buttonGrabs.end (); ++it)
     {
 	if (button.button ()    == (*it).button &&
 	    button.modifiers () == (*it).modifiers)
 	{
-	    (*it).count++;
+	    ++(*it).count;
 	    return true;
 	}
     }
@@ -3395,18 +3413,17 @@
 	    continue;
 
 	for (unsigned int ignore = 0;
-		 ignore <= modHandler->ignoredModMask (); ignore++)
+		 ignore <= modHandler->ignoredModMask (); ++ignore)
 	{
 	    if (ignore & ~modHandler->ignoredModMask ())
 		continue;
 
-	    XGrabButton (screen->dpy(),
+	    XGrabButton (screen->dpy (),
 			 bind.button,
 			 mods | ignore,
 			 serverFrame,
 			 false,
-			 ButtonPressMask | ButtonReleaseMask |
-			    ButtonMotionMask,
+			 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,
 			 GrabModeSync,
 			 GrabModeAsync,
 			 None,
@@ -3418,14 +3435,14 @@
 void
 cps::GrabManager::removePassiveButtonGrab (CompAction::ButtonBinding &button)
 {
-    std::list<ButtonGrab>::iterator it;
-
-    for (it = buttonGrabs.begin (); it != buttonGrabs.end (); ++it)
+    for (std::list<ButtonGrab>::iterator it = buttonGrabs.begin ();
+	 it != buttonGrabs.end (); ++it)
     {
 	if (button.button ()    == (*it).button &&
 	    button.modifiers () == (*it).modifiers)
 	{
-	    (*it).count--;
+	    --(*it).count;
+
 	    if ((*it).count)
 		return;
 
@@ -3447,37 +3464,30 @@
 CompScreenImpl::addAction (CompAction *action)
 {
     assert (privateScreen.initialized);
-    if (!privateScreen.initialized)
-	return false;
-
-    if (action->active ())
-	return false;
-
-    grabManager.setCurrentState(action->state());
-
-    if (action->type () & CompAction::BindingTypeKey)
-    {
-	if (!grabManager.addPassiveKeyGrab (action->key ()))
-	    return false;
-    }
-
-    if (action->type () & CompAction::BindingTypeButton)
-    {
-	if (!grabManager.addPassiveButtonGrab (action->button ()))
-	{
-	    if (action->type () & CompAction::BindingTypeKey)
-		grabManager.removePassiveKeyGrab (action->key ());
-
-	    return false;
-	}
+
+    if (!privateScreen.initialized ||
+	action->active ())
+	return false;
+
+    grabManager.setCurrentState(action->state ());
+
+    if (action->type () & CompAction::BindingTypeKey &&
+	!grabManager.addPassiveKeyGrab (action->key ()))
+	return false;
+
+    if (action->type () & CompAction::BindingTypeButton &&
+	!grabManager.addPassiveButtonGrab (action->button ()))
+    {
+	if (action->type () & CompAction::BindingTypeKey)
+	    grabManager.removePassiveKeyGrab (action->key ());
+
+	return false;
     }
 
     if (action->edgeMask ())
-    {
-	for (int i = 0; i < SCREEN_EDGE_NUM; i++)
+	for (int i = 0; i < SCREEN_EDGE_NUM; ++i)
 	    if (action->edgeMask () & (1 << i))
 		privateScreen.enableEdge (i);
-    }
 
     ca::setActionActiveState (*action, true);
 
@@ -3491,7 +3501,7 @@
         !action->active ())
 	return;
 
-    grabManager.setCurrentState(action->state());
+    grabManager.setCurrentState(action->state ());
 
     if (action->type () & CompAction::BindingTypeKey)
 	grabManager.removePassiveKeyGrab (action->key ());
@@ -3500,11 +3510,9 @@
 	grabManager.removePassiveButtonGrab (action->button ());
 
     if (action->edgeMask ())
-    {
-	for (int i = 0; i < SCREEN_EDGE_NUM; i++)
+	for (int i = 0; i < SCREEN_EDGE_NUM; ++i)
 	    if (action->edgeMask () & (1 << i))
 		privateScreen.disableEdge (i);
-    }
 
     ca::setActionActiveState (*action, false);
 }
@@ -3512,14 +3520,14 @@
 void
 CompScreenImpl::updateWorkarea ()
 {
-    CompRect workArea;
-    CompRegion allWorkArea = CompRegion ();
-    bool     workAreaChanged = false;
-    privateScreen.outputDevices.computeWorkAreas(
-	    workArea,
-	    workAreaChanged,
-	    allWorkArea,
-	    windowManager.getWindows());
+    CompRect   workArea;
+    CompRegion allWorkArea     = CompRegion ();
+    bool       workAreaChanged = false;
+
+    privateScreen.outputDevices.computeWorkAreas (workArea,
+						  workAreaChanged,
+						  allWorkArea,
+						  windowManager.getWindows ());
 
     workArea = allWorkArea.boundingRect ();
 
@@ -3535,7 +3543,7 @@
     {
 	/* as work area changed, update all maximized windows on this
 	   screen to snap to the new work area */
-	windowManager.updateWindowSizes();
+	windowManager.updateWindowSizes ();
     }
 }
 
@@ -3545,17 +3553,10 @@
     /* windows with client id less than 2 have been destroyed and only exists
        because some plugin keeps a reference to them. they should not be in
        client lists */
-    if (w->id () < 2)
-	return false;
-
-    if (w->overrideRedirect ())
-	return false;
-
-    if (!w->isViewable ())
-    {
-	if (!(w->state () & CompWindowStateHiddenMask))
-	    return false;
-    }
+    if (w->id () < 2		||
+	w->overrideRedirect ()	||
+	(!w->isViewable () && !(w->state () & CompWindowStateHiddenMask)))
+	return false;
 
     return true;
 }
@@ -3565,9 +3566,7 @@
 		       int        *n)
 {
     if (isClientListWindow (w))
-    {
 	*n = *n + 1;
-    }
 }
 
 static bool
@@ -3578,15 +3577,15 @@
 }
 
 void
-cps::WindowManager::updateClientList (PrivateScreen& ps)
+cps::WindowManager::updateClientList (PrivateScreen &ps)
 {
-    bool   updateClientList = false;
-    bool   updateClientListStacking = false;
-    int	   n = 0;
+    bool updateClientList         = false;
+    bool updateClientListStacking = false;
+    int  n = 0;
 
     screen->forEachWindow (boost::bind (countClientListWindow, _1, &n));
 
-    if (n == 0)
+    if (!n)
     {
 	if ((unsigned int) n != clientList.size ())
 	{
@@ -3595,14 +3594,14 @@
 	    clientIdList.clear ();
 	    clientIdListStacking.clear ();
 
-	    XChangeProperty (ps.dpy, ps.rootWindow(),
+	    XChangeProperty (ps.dpy, ps.rootWindow (),
 			     Atoms::clientList,
 			     XA_WINDOW, 32, PropModeReplace,
-			     (unsigned char *) &ps.eventManager.getGrabWindow(), 1);
-	    XChangeProperty (ps.dpy, ps.rootWindow(),
+			     (unsigned char *) &ps.eventManager.getGrabWindow (), 1);
+	    XChangeProperty (ps.dpy, ps.rootWindow (),
 			     Atoms::clientListStacking,
 			     XA_WINDOW, 32, PropModeReplace,
-			     (unsigned char *) &ps.eventManager.getGrabWindow(), 1);
+			     (unsigned char *) &ps.eventManager.getGrabWindow (), 1);
 	}
 
 	return;
@@ -3618,9 +3617,10 @@
 
     clientListStacking.clear ();
 
-    for (iterator i = begin(); i != end(); ++i)
+    for (iterator i = begin (); i != end (); ++i)
     {
 	CompWindow* const w(*i);
+
 	if (isClientListWindow (w))
 	    clientListStacking.push_back (w);
     }
@@ -3633,61 +3633,57 @@
 	  compareMappingOrder);
 
     /* make sure client id lists are up-to-date */
-    for (int i = 0; i < n; i++)
+    for (int i = 0; i < n; ++i)
     {
 	if (!updateClientList &&
 	    clientIdList[i] != clientList[i]->id ())
-	{
 	    updateClientList = true;
-	}
 
 	clientIdList[i] = clientList[i]->id ();
     }
-    for (int i = 0; i < n; i++)
+    for (int i = 0; i < n; ++i)
     {
 	if (!updateClientListStacking &&
 	    clientIdListStacking[i] != clientListStacking[i]->id ())
-	{
 	    updateClientListStacking = true;
-	}
 
 	clientIdListStacking[i] = clientListStacking[i]->id ();
     }
 
     if (updateClientList)
-	XChangeProperty (ps.dpy, ps.rootWindow(),
+	XChangeProperty (ps.dpy, ps.rootWindow (),
 			 Atoms::clientList,
 			 XA_WINDOW, 32, PropModeReplace,
 			 (unsigned char *) &clientIdList.at (0), n);
 
     if (updateClientListStacking)
-	XChangeProperty (ps.dpy, ps.rootWindow(),
+	XChangeProperty (ps.dpy, ps.rootWindow (),
 			 Atoms::clientListStacking,
 			 XA_WINDOW, 32, PropModeReplace,
-			 (unsigned char *) &clientIdListStacking.at (0),
-			 n);
+			 (unsigned char *) &clientIdListStacking.at (0), n);
 }
 
 const CompWindowVector &
 CompScreenImpl::clientList (bool stackingOrder)
 {
-   return stackingOrder ? windowManager.getClientListStacking() : windowManager.getClientList();
+   return stackingOrder ? windowManager.getClientListStacking () :
+			  windowManager.getClientList ();
 }
 
 void
 CompScreenImpl::toolkitAction (Atom   toolkitAction,
-			   Time   eventTime,
-			   Window window,
-			   long   data0,
-			   long   data1,
-			   long   data2)
+			       Time   eventTime,
+			       Window window,
+			       long   data0,
+			       long   data1,
+			       long   data2)
 {
     XEvent ev;
 
-    ev.type		    = ClientMessage;
-    ev.xclient.window	    = window;
+    ev.type                 = ClientMessage;
+    ev.xclient.window       = window;
     ev.xclient.message_type = Atoms::toolkitAction;
-    ev.xclient.format	    = 32;
+    ev.xclient.format       = 32;
     ev.xclient.data.l[0]    = toolkitAction;
     ev.xclient.data.l[1]    = eventTime;
     ev.xclient.data.l[2]    = data0;
@@ -3697,7 +3693,7 @@
     XUngrabPointer (privateScreen.dpy, CurrentTime);
     XUngrabKeyboard (privateScreen.dpy, CurrentTime);
 
-    XSendEvent (privateScreen.dpy, privateScreen.rootWindow(), false,
+    XSendEvent (privateScreen.dpy, privateScreen.rootWindow (), false,
 		StructureNotifyMask, &ev);
 }
 
@@ -3709,23 +3705,21 @@
 
     if (fork () == 0)
     {
-	size_t       pos;
-	CompString   env (privateScreen.displayString ());
+	CompString env (privateScreen.displayString ());
 
 	setsid ();
 
-	pos = env.find (':');
+	size_t pos = env.find (':');
+
 	if (pos != std::string::npos)
 	{
-            size_t pointPos = env.find ('.', pos);
+	    size_t pointPos = env.find ('.', pos);
 
 	    if (pointPos != std::string::npos)
-	    {
 		env.erase (pointPos);
-	    }
 	    else
 	    {
-                unsigned int displayNum = atoi (env.substr (pos + 1).c_str ());
+		unsigned int displayNum = atoi (env.substr (pos + 1).c_str ());
 		env.erase (pos);
 		env.append (compPrintf (":%i", displayNum));
 	    }
@@ -3740,7 +3734,9 @@
 }
 
 void
-CompScreenImpl::moveViewport (int tx, int ty, bool sync)
+CompScreenImpl::moveViewport (int  tx,
+			      int  ty,
+			      bool sync)
 {
     CompPoint pnt;
 
@@ -3761,11 +3757,14 @@
     tx *= -width ();
     ty *= -height ();
 
-    for (cps::WindowManager::iterator i = windowManager.begin(); i != windowManager.end(); ++i)
+    unsigned int valueMask;
+
+    for (cps::WindowManager::iterator i = windowManager.begin ();
+	 i != windowManager.end (); ++i)
     {
-	CompWindow* const w(*i);
-	unsigned int valueMask = CWX | CWY;
-	XWindowChanges xwc= XWINDOWCHANGES_INIT;
+	CompWindow* const w (*i);
+	valueMask = CWX | CWY;
+	XWindowChanges xwc = XWINDOWCHANGES_INIT;
 
 	if (w->onAllViewports ())
 	    continue;
@@ -3786,18 +3785,15 @@
 
     if (sync)
     {
-	CompWindow *w;
-
 	privateScreen.setDesktopHints ();
 
 	setCurrentActiveWindowHistory (privateScreen.viewPort.vp.x (), privateScreen.viewPort.vp.y ());
 
-	w = findWindow (privateScreen.orphanData.activeWindow);
+	CompWindow *w = findWindow (privateScreen.orphanData.activeWindow);
+
 	if (w)
 	{
-	    CompPoint dvp;
-
-	    dvp = w->defaultViewport ();
+	    CompPoint dvp = w->defaultViewport ();
 
 	    /* add window to current history if it's default viewport is
 	       still the current one. */
@@ -3823,7 +3819,8 @@
 void
 cps::WindowManager::removeGroup (CompGroup *group)
 {
-    group->refCnt--;
+    --group->refCnt;
+
     if (group->refCnt)
 	return;
 
@@ -3831,9 +3828,7 @@
 	std::find (groups.begin (), groups.end (), group);
 
     if (it != groups.end ())
-    {
 	groups.erase (it);
-    }
 
     delete group;
 }
@@ -3849,16 +3844,16 @@
 }
 
 void
-cps::StartupSequence::applyStartupProperties (CompScreen* screen, CompWindow *window)
+cps::StartupSequence::applyStartupProperties (CompScreen *screen,
+					      CompWindow *window)
 {
     CompStartupSequence *s = NULL;
     const char	        *startupId = window->startupId ();
 
     if (!startupId)
     {
-	CompWindow *leader;
+	CompWindow *leader = screen->findWindow (window->clientLeader ());
 
-	leader = screen->findWindow (window->clientLeader ());
 	if (leader)
 	    startupId = leader->startupId ();
 
@@ -3868,9 +3863,8 @@
 
     foreach (CompStartupSequence *ss, startupSequences)
     {
-	const char *id;
+	const char *id = sn_startup_sequence_get_id (ss->sequence);
 
-	id = sn_startup_sequence_get_id (ss->sequence);
 	if (strcmp (id, startupId) == 0)
 	{
 	    s = ss;
@@ -3892,7 +3886,7 @@
     xev.xclient.format  = 32;
 
     xev.xclient.message_type = Atoms::winActive;
-    xev.xclient.window	     = id;
+    xev.xclient.window       = id;
 
     xev.xclient.data.l[0] = ClientTypePager;
     xev.xclient.data.l[1] = 0;
@@ -3900,7 +3894,7 @@
     xev.xclient.data.l[3] = 0;
     xev.xclient.data.l[4] = 0;
 
-    XSendEvent (privateScreen.dpy, privateScreen.rootWindow(), false,
+    XSendEvent (privateScreen.dpy, privateScreen.rootWindow (), false,
 		SubstructureRedirectMask | SubstructureNotifyMask, &xev);
 }
 
@@ -3912,7 +3906,8 @@
 void
 PrivateScreen::enableEdge (int edge)
 {
-    screenEdge[edge].count++;
+    ++screenEdge[edge].count;
+
     if (screenEdge[edge].count == 1)
 	XMapRaised (dpy, screenEdge[edge].id);
 }
@@ -3920,13 +3915,14 @@
 void
 PrivateScreen::disableEdge (int edge)
 {
-    screenEdge[edge].count--;
+    --screenEdge[edge].count;
+
     if (screenEdge[edge].count == 0)
 	XUnmapWindow (dpy, screenEdge[edge].id);
 }
 
 CompWindow *
-cps::WindowManager::getTopWindow() const
+cps::WindowManager::getTopWindow () const
 {
     /* return first window that has not been destroyed */
     if (!windows.empty ())
@@ -3951,7 +3947,8 @@
 }
 
 int
-CompScreenImpl::outputDeviceForPoint (int x, int y)
+CompScreenImpl::outputDeviceForPoint (int x,
+				      int y)
 {
     CompWindow::Geometry geom (x, y, 1, 1, 0);
 
@@ -3992,7 +3989,7 @@
 
     unsigned long data = desktop;
 
-    XChangeProperty (dpy, rootWindow(), Atoms::currentDesktop,
+    XChangeProperty (dpy, rootWindow (), Atoms::currentDesktop,
 		     XA_CARDINAL, 32, PropModeReplace,
 		     (unsigned char *) &data, 1);
 }
@@ -4024,6 +4021,11 @@
  * XXX: It is possible for this function to return a negative viewport, which
  * definitely feels wrong, however it seems that some plugins depend on this behaviour
  * so they need to be fixed first
+ *
+ * TODO: This function is responsible for several problems as the viewport containing
+ *       the center of the window is not always the correct one.
+ *       A example for this buggy behaviour is that a window maximizes offscreen, if
+ *       it's center is offscreen !
  */
 void
 compiz::private_screen::viewports::viewportForGeometry (const CompWindow::Geometry &gm,
@@ -4032,30 +4034,31 @@
 							const CompSize &           screenSize)
 {
     CompRect rect (gm);
-    int      offset;
 
-    const CompPoint &vp = viewports->getCurrentViewport ();
-    const CompSize &vpSize = viewports->viewportDimensions ();
+    const CompPoint &vp     = viewports->getCurrentViewport ();
+    const CompSize  &vpSize = viewports->viewportDimensions ();
 
     rect.setWidth  (gm.widthIncBorders ());
     rect.setHeight (gm.heightIncBorders ());
 
-    offset = rect.centerX () < 0 ? -1 : 0;
-    viewport.setX (vp.x () + ((rect.centerX () / screenSize.width ()) + offset) % vpSize.width ());
+    int offset = rect.centerX () < 0 ? -1 : 0;
+    viewport.setX (vp.x () + ((rect.centerX () / screenSize.width ()) + offset) %
+		   vpSize.width ());
 
     offset = rect.centerY () < 0 ? -1 : 0;
-    viewport.setY (vp.y () + ((rect.centerY () / screenSize.height ()) + offset ) % vpSize.height ());
+    viewport.setY (vp.y () + ((rect.centerY () / screenSize.height ()) + offset ) %
+		   vpSize.height ());
 }
 
 void
-CompScreenImpl::viewportForGeometry (const CompWindow::Geometry& gm,
-				     CompPoint&                  viewport)
+CompScreenImpl::viewportForGeometry (const CompWindow::Geometry &gm,
+				     CompPoint                  &viewport)
 {
     compiz::private_screen::viewports::viewportForGeometry (gm, viewport, &privateScreen.viewPort, *this);
 }
 
 int
-CompScreenImpl::outputDeviceForGeometry (const CompWindow::Geometry& gm)
+CompScreenImpl::outputDeviceForGeometry (const CompWindow::Geometry &gm)
 {
     return privateScreen.outputDevices.outputDeviceForGeometry (gm, privateScreen.optionGetOverlappingOutputs (), this);
 }
@@ -4094,11 +4097,12 @@
 }
 
 void
-cps::History::setCurrentActiveWindowHistory (int x, int y)
+cps::History::setCurrentActiveWindowHistory (int x,
+					     int y)
 {
     int	i, min = 0;
 
-    for (i = 0; i < ACTIVE_WINDOW_HISTORY_NUM; i++)
+    for (i = 0; i < ACTIVE_WINDOW_HISTORY_NUM; ++i)
     {
 	if (history[i].x == x && history[i].y == y)
 	{
@@ -4107,7 +4111,7 @@
 	}
     }
 
-    for (i = 1; i < ACTIVE_WINDOW_HISTORY_NUM; i++)
+    for (i = 1; i < ACTIVE_WINDOW_HISTORY_NUM; ++i)
 	if (history[i].activeNum < history[min].activeNum)
 	    min = i;
 
@@ -4124,10 +4128,10 @@
 cps::History::addToCurrentActiveWindowHistory (Window id)
 {
     CompActiveWindowHistory *history = &this->history[currentHistory_];
-    Window		    tmp, next = id;
+    Window                  tmp, next = id;
 
     /* walk and move history */
-    for (int i = 0; i < ACTIVE_WINDOW_HISTORY_SIZE; i++)
+    for (int i = 0; i < ACTIVE_WINDOW_HISTORY_SIZE; ++i)
     {
 	tmp = history->id[i];
 	history->id[i] = next;
@@ -4161,7 +4165,7 @@
 Window
 CompScreenImpl::root ()
 {
-    return privateScreen.rootWindow();
+    return privateScreen.rootWindow ();
 }
 
 int
@@ -4171,10 +4175,11 @@
 }
 
 void
-PrivateScreen::identifyEdgeWindow(Window id)
+PrivateScreen::identifyEdgeWindow (Window id)
 {
     edgeWindow = 0;
-    for (unsigned int i = 0; i < SCREEN_EDGE_NUM; i++)
+
+    for (unsigned int i = 0; i < SCREEN_EDGE_NUM; ++i)
     {
 	if (id == screenEdge[i].id)
 	{
@@ -4186,9 +4191,9 @@
 
 void
 CompScreenImpl::warpPointer (int dx,
-			 int dy)
+			     int dy)
 {
-    XEvent      event;
+    XEvent event;
 
     pointerX += dx;
     pointerY += dy;
@@ -4204,7 +4209,7 @@
 	pointerY = 0;
 
     XWarpPointer (privateScreen.dpy,
-		  None, privateScreen.rootWindow(),
+		  None, privateScreen.rootWindow (),
 		  0, 0, 0, 0,
 		  pointerX, pointerY);
 
@@ -4228,17 +4233,11 @@
 			    EnterWindowMask |
 			    PointerMotionMask,
 			    &event))
-    {
-	if (event.type == EnterNotify)
-	{
-	    if (event.xcrossing.mode != NotifyGrab ||
-		event.xcrossing.mode != NotifyUngrab ||
-		event.xcrossing.mode != NotifyInferior)
-	    {
-		privateScreen.identifyEdgeWindow(event.xcrossing.window);
-	    }
-	}
-    }
+	if (event.type == EnterNotify &&
+	    (event.xcrossing.mode != NotifyGrab	    ||
+	     event.xcrossing.mode != NotifyUngrab   ||
+	     event.xcrossing.mode != NotifyInferior))
+	    privateScreen.identifyEdgeWindow(event.xcrossing.window);
 
     if (!inHandleEvent)
     {
@@ -4250,22 +4249,21 @@
 CompWindowList &
 CompScreenImpl::windows ()
 {
-    return windowManager.getWindows();
+    return windowManager.getWindows ();
 }
 
 CompWindowList &
 CompScreenImpl::serverWindows ()
 {
-    return windowManager.getServerWindows();
+    return windowManager.getServerWindows ();
 }
 
 CompWindowList &
 CompScreenImpl::destroyedWindows ()
 {
-    return windowManager.getDestroyedWindows();
+    return windowManager.getDestroyedWindows ();
 }
 
-
 Time
 CompScreenImpl::getCurrentTime ()
 {
@@ -4379,7 +4377,7 @@
 	    }
 	}
 
-	pendingDestroys--;
+	--pendingDestroys;
     }
 }
 
@@ -4401,7 +4399,6 @@
     return privateScreen.fullscreenOutput;
 }
 
-
 XWindowAttributes
 CompScreenImpl::attrib ()
 {
@@ -4426,27 +4423,28 @@
 }
 
 CompScreenImpl::CompScreenImpl () :
-    cps::XWindowInfo(privateScreen.dpy),
-    below(),
-    autoRaiseTimer_(),
-    autoRaiseWindow_(0),
-    defaultIcon_(0),
+    cps::XWindowInfo (privateScreen.dpy),
+    below (),
+    autoRaiseTimer_ (),
+    autoRaiseWindow_ (0),
+    defaultIcon_ (0),
     grabManager (this),
     eventHandled (false),
-    privateScreen(this, windowManager),
-    showingDesktopMask_(0)
+    privateScreen (this, windowManager),
+    showingDesktopMask_ (0)
 {
     ValueHolder::SetDefault (&valueHolder);
 
     CompPrivate p;
     CompOption::Value::Vector vList;
 
-    privateScreen.setPingTimerCallback(
+    privateScreen.setPingTimerCallback (
 	boost::bind (&CompScreenImpl::handlePingTimeout, this));
 
     screenInitalized = true;
 
-    CompPlugin* corePlugin = CompPlugin::load ("core");
+    CompPlugin *corePlugin = CompPlugin::load ("core");
+
     if (!corePlugin)
     {
 	compLogMessage ("core", CompLogLevelFatal,
@@ -4470,22 +4468,22 @@
 }
 
 void
-PrivateScreen::setPlugins(CompOption::Value::Vector const& vList)
+PrivateScreen::setPlugins (CompOption::Value::Vector const &vList)
 {
     pluginManager.setPlugins(vList);
 }
 
 void
-PrivateScreen::initPlugins()
+PrivateScreen::initPlugins ()
 {
     pluginManager.setDirtyPluginList ();
-    pluginManager.updatePlugins (screen, optionGetActivePlugins());
+    pluginManager.updatePlugins (screen, optionGetActivePlugins ());
 }
 
 bool
 CompScreenImpl::init (const char *name)
 {
-    privateScreen.eventManager.init();
+    privateScreen.eventManager.init ();
 
     if (privateScreen.initDisplay(name, *this, showingDesktopMask_))
     {
@@ -4502,10 +4500,8 @@
 	privateScreen.optionSetMinimizeWindowKeyInitiate (CompScreenImpl::minimizeWin);
 	privateScreen.optionSetMinimizeWindowButtonInitiate (CompScreenImpl::minimizeWin);
 	privateScreen.optionSetMaximizeWindowKeyInitiate (CompScreenImpl::maximizeWin);
-	privateScreen.optionSetMaximizeWindowHorizontallyKeyInitiate (
-	    CompScreenImpl::maximizeWinHorizontally);
-	privateScreen.optionSetMaximizeWindowVerticallyKeyInitiate (
-	    CompScreenImpl::maximizeWinVertically);
+	privateScreen.optionSetMaximizeWindowHorizontallyKeyInitiate (CompScreenImpl::maximizeWinHorizontally);
+	privateScreen.optionSetMaximizeWindowVerticallyKeyInitiate (CompScreenImpl::maximizeWinVertically);
 
 	privateScreen.optionSetWindowMenuKeyInitiate (CompScreenImpl::windowMenu);
 	privateScreen.optionSetWindowMenuButtonInitiate (CompScreenImpl::windowMenu);
@@ -4523,34 +4519,33 @@
 
 	privateScreen.optionSetToggleWindowShadedKeyInitiate (CompScreenImpl::shadeWin);
 
-	privateScreen.initPlugins();
+	privateScreen.initPlugins ();
 
 	if (debugOutput)
 	{
-	    StackDebugger::SetDefault (
-		new StackDebugger (
-		    dpy (),
-		    root (),
-		    &privateScreen));
+	    StackDebugger::SetDefault (new StackDebugger (dpy (),
+							  root (),
+							  &privateScreen));
 	}
 
 	return true;
     }
+
     return false;
 }
 
 void
 cps::EventManager::init ()
 {
-    ctx = Glib::MainContext::get_default ();
-    mainloop = Glib::MainLoop::create (ctx, false);
-    sighupSource = CompSignalSource::create (SIGHUP, boost::bind (&EventManager::handleSignal, this, _1));
-    sigintSource = CompSignalSource::create (SIGINT, boost::bind (&EventManager::handleSignal, this, _1));
+    ctx           = Glib::MainContext::get_default ();
+    mainloop      = Glib::MainLoop::create (ctx, false);
+    sighupSource  = CompSignalSource::create (SIGHUP, boost::bind (&EventManager::handleSignal, this, _1));
+    sigintSource  = CompSignalSource::create (SIGINT, boost::bind (&EventManager::handleSignal, this, _1));
     sigtermSource = CompSignalSource::create (SIGTERM, boost::bind (&EventManager::handleSignal, this, _1));
 }
 
 bool
-CompScreenImpl::displayInitialised() const
+CompScreenImpl::displayInitialised () const
 {
     return privateScreen.initialized;
 }
@@ -4568,31 +4563,31 @@
 }
 
 void
-CompScreenImpl::updateClientList()
+CompScreenImpl::updateClientList ()
 {
     privateScreen.updateClientList ();
 }
 
 CompWindow *
-CompScreenImpl::getTopWindow() const
+CompScreenImpl::getTopWindow () const
 {
-    return windowManager.getTopWindow();
+    return windowManager.getTopWindow ();
 }
 
 CompWindow *
 CompScreenImpl::getTopServerWindow () const
 {
-    return windowManager.getTopServerWindow();
+    return windowManager.getTopServerWindow ();
 }
 
-CoreOptions&
-CompScreenImpl::getCoreOptions()
+CoreOptions &
+CompScreenImpl::getCoreOptions ()
 {
     return privateScreen;
 }
 
 Colormap
-CompScreenImpl::colormap() const
+CompScreenImpl::colormap () const
 {
     return privateScreen.colormap;
 }
@@ -4600,11 +4595,11 @@
 void
 CompScreenImpl::setCurrentDesktop (unsigned int desktop)
 {
-    privateScreen.setCurrentDesktop(desktop);
+    privateScreen.setCurrentDesktop (desktop);
 }
 
 Window
-CompScreenImpl::activeWindow() const
+CompScreenImpl::activeWindow () const
 {
     return privateScreen.orphanData.activeWindow;
 }
@@ -4612,70 +4607,73 @@
 void
 CompScreenImpl::updatePassiveButtonGrabs(Window serverFrame)
 {
-    grabManager.updatePassiveButtonGrabs(serverFrame);
+    grabManager.updatePassiveButtonGrabs (serverFrame);
 }
 
 bool
-CompScreenImpl::grabWindowIsNot(Window w) const
+CompScreenImpl::grabWindowIsNot (Window w) const
 {
-    return privateScreen.eventManager.notGrabWindow(w);
+    return privateScreen.eventManager.notGrabWindow (w);
 }
 
 void
-CompScreenImpl::incrementPendingDestroys()
+CompScreenImpl::incrementPendingDestroys ()
 {
-    windowManager.incrementPendingDestroys();
+    windowManager.incrementPendingDestroys ();
 }
 
-cps::DesktopWindowCount::DesktopWindowCount() :
+cps::DesktopWindowCount::DesktopWindowCount () :
 count(0)
 {
 }
 
 void
-cps::DesktopWindowCount::incrementDesktopWindowCount()
+cps::DesktopWindowCount::incrementDesktopWindowCount ()
 {
-    count++;
+    ++count;
 }
 void
-cps::DesktopWindowCount::decrementDesktopWindowCount()
+cps::DesktopWindowCount::decrementDesktopWindowCount ()
 {
-    count--;
+    --count;
 }
 
-cps::MapNum::MapNum() :
+cps::MapNum::MapNum () :
 mapNum (1)
 {
 }
 
 unsigned int
-cps::MapNum::nextMapNum()
+cps::MapNum::nextMapNum ()
 {
     return mapNum++;
 }
 
 void
-CompScreenImpl::setNextActiveWindow(Window id)
+CompScreenImpl::setNextActiveWindow (Window id)
 {
     privateScreen.orphanData.nextActiveWindow = id;
 }
+
 Window
-CompScreenImpl::getNextActiveWindow() const
+CompScreenImpl::getNextActiveWindow () const
 {
     return privateScreen.orphanData.nextActiveWindow;
 }
 
 namespace
 {
-void sendStartupMessageToClients (Display *dpy, bool success)
+void
+sendStartupMessageToClients (Display *dpy,
+			     bool    success)
 {
     /* Send a client message indicating that our startup is complete if
      * we were asked to do so */
     if (sendStartupMessage)
     {
-	Atom   startupMessageAtom = XInternAtom (dpy,
-						 "_COMPIZ_TESTING_STARTUP",
-						 FALSE);
+	Atom startupMessageAtom = XInternAtom (dpy,
+					       "_COMPIZ_TESTING_STARTUP",
+					       FALSE);
 	XEvent startupMessageEvent;
 	Window root = DefaultRootWindow (dpy);
 
@@ -4699,11 +4697,13 @@
 }
 }
 
-
 bool
-PrivateScreen::initDisplay (const char *name, cps::History& history, unsigned int showingDesktopMask)
+PrivateScreen::initDisplay (const char   *name,
+			    cps::History &history,
+			    unsigned int showingDesktopMask)
 {
     dpy = XOpenDisplay (name);
+
     if (!dpy)
     {
 	compLogMessage ("core", CompLogLevelFatal,
@@ -4723,13 +4723,14 @@
     XSetErrorHandler (errorHandler);
 
     snDisplay = sn_display_new (dpy, NULL, NULL);
+
     if (!snDisplay)
 	return true;
 
     if (!xSync.init<XSyncQueryExtension> (dpy))
     {
 	compLogMessage ("core", CompLogLevelFatal,
-		       "No sync extension");
+			"No sync extension");
 	sendStartupMessageToClients (dpy, false);
 	return false;
     }
@@ -4738,23 +4739,20 @@
     xShape.init<XShapeQueryExtension> (dpy);
 
     xkbEvent.init<XkbQueryExtension> (dpy);
+
     if (xkbEvent.isEnabled ())
-    {
 	XkbSelectEvents (dpy, XkbUseCoreKbd,
 			 XkbBellNotifyMask | XkbStateNotifyMask,
 			 XkbAllEventsMask);
-    }
     else
-    {
 	compLogMessage ("core", CompLogLevelFatal,
 			"No XKB extension");
-    }
-
-    int  xineramaError;
-    int  xineramaEvent;
+
+    int xineramaError, xineramaEvent;
+
     xineramaExtension = XineramaQueryExtension (dpy,
-						      &xineramaEvent,
-						      &xineramaError);
+						&xineramaEvent,
+						&xineramaError);
 
     updateScreenInfo ();
 
@@ -4765,9 +4763,8 @@
 
     Window root_tmp = XRootWindow (dpy, DefaultScreen (dpy));
 
-
     /* Don't select for SubstructureRedirectMask or
-     * SubstructureNotifyMask yet since we need to
+     * SubstructureNotifyMask yet, since we need to
      * act in complete synchronization here when
      * doing the initial window init in order to ensure
      * that windows don't receive invalid stack positions
@@ -4787,11 +4784,11 @@
 
     /* We need to register for EnterWindowMask |
      * ButtonPressMask | FocusChangeMask on other
-     * root windows as well because focus happens
+     * root windows as well, because focus happens
      * on a display level and we need to check
-     * if the screen we are running on lost focus */
+     * if the screen, we are running on, lost focus */
 
-    for (int i = 0; i <= ScreenCount (dpy) - 1; i++)
+    for (int i = 0; i <= ScreenCount (dpy) - 1; ++i)
     {
 	Window rt = XRootWindow (dpy, i);
 
@@ -4803,7 +4800,7 @@
 		      SubstructureNotifyMask);
     }
 
-    for (int i = 0; i < SCREEN_EDGE_NUM; i++)
+    for (int i = 0; i < SCREEN_EDGE_NUM; ++i)
     {
 	screenEdge[i].id    = None;
 	screenEdge[i].count = 0;
@@ -4816,17 +4813,18 @@
     snContext = sn_monitor_context_new (snDisplay, screenNum,
 					      compScreenSnEvent, this, NULL);
 
-    if (!XGetWindowAttributes (dpy, rootWindow(), &attrib))
+    if (!XGetWindowAttributes (dpy, rootWindow (), &attrib))
 	return false;
 
     workArea.setWidth (attrib.width);
     workArea.setHeight (attrib.height);
 
-    XVisualInfo          templ;
+    XVisualInfo templ;
     templ.visualid = XVisualIDFromVisual (attrib.visual);
 
-    int                  nvisinfo;
-    XVisualInfo* visinfo = XGetVisualInfo (dpy, VisualIDMask, &templ, &nvisinfo);
+    int nvisinfo;
+    XVisualInfo *visinfo = XGetVisualInfo (dpy, VisualIDMask, &templ, &nvisinfo);
+
     if (!nvisinfo)
     {
 	compLogMessage ("core", CompLogLevelFatal,
@@ -4835,7 +4833,7 @@
 	return false;
     }
 
-    XColor               black;
+    XColor black;
     black.red = black.green = black.blue = 0;
 
     if (!XAllocColor (dpy, colormap, &black))
@@ -4847,8 +4845,9 @@
 	return false;
     }
 
-    static char          data = 0;
-    Pixmap bitmap = XCreateBitmapFromData (dpy, rootWindow(), &data, 1, 1);
+    static char data = 0;
+    Pixmap bitmap = XCreateBitmapFromData (dpy, rootWindow (), &data, 1, 1);
+
     if (!bitmap)
     {
 	compLogMessage ("core", CompLogLevelFatal,
@@ -4859,7 +4858,7 @@
     }
 
     invisibleCursor = XCreatePixmapCursor (dpy, bitmap, bitmap,
-						 &black, &black, 0, 0);
+					   &black, &black, 0, 0);
     if (!invisibleCursor)
     {
 	compLogMessage ("core", CompLogLevelFatal,
@@ -4960,12 +4959,12 @@
     /* Wait for old window manager to go away */
     if (currentWmSnOwner != None)
     {
-	do {
+	do
+	{
 	    XWindowEvent (dpy, currentWmSnOwner, StructureNotifyMask, &event);
 	} while (event.type != DestroyNotify);
     }
 
-
     /* Server grab from here, we are creating windows */
 
     XGrabServer (dpy);
@@ -4975,13 +4974,13 @@
 	attrib.override_redirect = 1;
 	attrib.event_mask = PropertyChangeMask;
 
-	eventManager.createGrabWindow(dpy, rootWindow(), &attrib);
+	eventManager.createGrabWindow(dpy, rootWindow (), &attrib);
 
-	for (int i = 0; i < SCREEN_EDGE_NUM; i++)
+	for (int i = 0; i < SCREEN_EDGE_NUM; ++i)
 	{
 	    long xdndVersion = 3;
 
-	    screenEdge[i].id = XCreateWindow (dpy, rootWindow(),
+	    screenEdge[i].id = XCreateWindow (dpy, rootWindow (),
 						    -100, -100, 1, 1, 0,
 						    CopyFromParent, InputOnly,
 						    CopyFromParent,
@@ -5006,7 +5005,7 @@
 
     updateScreenEdges ();
 
-    eventManager.setSupportingWmCheck (dpy, rootWindow());
+    eventManager.setSupportingWmCheck (dpy, rootWindow ());
     screen->updateSupportedWmHints ();
 
     XIGetClientPointer (dpy, None, &clientPointerDeviceId);
@@ -5021,7 +5020,7 @@
 
     /* We should get DestroyNotify events for any windows that were
      * destroyed while initializing windows here now */
-    XSelectInput (dpy, rootWindow(), attrib.your_event_mask |
+    XSelectInput (dpy, rootWindow (), attrib.your_event_mask |
 		  SubstructureRedirectMask | SubstructureNotifyMask);
 
     if (CompScreenImpl::checkForError (dpy))
@@ -5038,12 +5037,12 @@
     }
 
     wmSnSelectionWindow = newWmSnOwner;
-    this->wmSnTimestamp       = wmSnTimestamp;
+    this->wmSnTimestamp = wmSnTimestamp;
 
     Window rootReturn, parentReturn;
     Window               *children;
     unsigned int         nchildren;
-    XQueryTree (dpy, rootWindow(),
+    XQueryTree (dpy, rootWindow (),
 		&rootReturn, &parentReturn,
 		&children, &nchildren);
 
@@ -5052,7 +5051,7 @@
 
     /* Start initializing windows here */
 
-    for (unsigned int i = 0; i < nchildren; i++)
+    for (unsigned int i = 0; i < nchildren; ++i)
     {
 	XWindowAttributes attrib;
 
@@ -5073,7 +5072,7 @@
      * using list last sent to server
     i = 0;
     for (CompWindowList::reverse_iterator rit = serverWindows.rbegin ();
-	 rit != serverWindows.rend (); rit++)
+	 rit != serverWindows.rend (); ++rit)
 	children[i++] = ROOTPARENT ((*rit));
 
     XRestackWindows (dpy, children, i);
@@ -5082,23 +5081,20 @@
 
     windowManager.setWindowActiveness(history);
 
-    Window               focus;
-    int                  revertTo;
+    Window focus;
+    int    revertTo;
     XGetInputFocus (dpy, &focus, &revertTo);
 
     /* move input focus to root window so that we get a FocusIn event when
        moving it to the default window */
-    XSetInputFocus (dpy, rootWindow(), RevertToPointerRoot, CurrentTime);
+    XSetInputFocus (dpy, rootWindow (), RevertToPointerRoot, CurrentTime);
 
     if (focus == None || focus == PointerRoot)
-    {
 	screen->focusDefaultWindow ();
-    }
     else
     {
-	CompWindow *w;
+	CompWindow *w = screen->findWindow (focus);
 
-	w = screen->findWindow (focus);
 	if (w)
 	    w->moveInputFocusTo ();
 	else
@@ -5120,6 +5116,7 @@
      * screens from option changes */
     bool init_succeeded = CompPlugin::screenInitPlugins (screen);
     assert (init_succeeded);
+
     if (!init_succeeded)
       return false;
 
@@ -5131,9 +5128,9 @@
 
     setAudibleBell (optionGetAudibleBell ());
 
-
+    /* TODO: just query optionGetPingDelay () once */
     pingTimer.setTimes (optionGetPingDelay (),
-			      optionGetPingDelay () + 500);
+			optionGetPingDelay () + 500);
 
     pingTimer.start ();
 
@@ -5146,8 +5143,8 @@
 {
     privateScreen.startupSequence.removeAllSequences ();
 
-    while (!windowManager.getWindows().empty ())
-        delete windowManager.getWindows().front ();
+    while (!windowManager.getWindows ().empty ())
+	delete windowManager.getWindows ().front ();
 
     while (CompPlugin* p = CompPlugin::pop ())
 	CompPlugin::unload (p);
@@ -5159,110 +5156,134 @@
 }
 
 cps::GrabManager::GrabManager (CompScreen *screen) :
-    screen(screen),
-    currentState(0),
+    screen (screen),
+    currentState (0),
     buttonGrabs (),
     keyGrabs ()
 {
 }
 
-cps::ViewPort::ViewPort() :
+cps::ViewPort::ViewPort () :
     vp (0, 0),
     vpSize (1, 1)
 {
 }
 
-cps::StartupSequence::StartupSequence() :
+cps::StartupSequence::StartupSequence () :
     startupSequences (),
     startupSequenceTimer ()
 {
     startupSequenceTimer.setCallback (
 	boost::bind (&cps::StartupSequence::handleStartupSequenceTimeout, this));
+
+    /* TODO: Magic number alert */
     startupSequenceTimer.setTimes (1000, 1500);
 }
 
 PrivateScreen::PrivateScreen (CompScreen *screen, cps::WindowManager& windowManager) :
-    CoreOptions(false),
+    CoreOptions (false),
     dpy (NULL),
-    startupSequence(this),
+    xSync (),
+    xRandr (),
+    xShape (),
+    viewPort (),
+    startupSequence (this),
     eventManager (),
+    orphanData (),
+    outputDevices (),
+    colormap (),
+    screenNum (0),
     nDesktop (1),
     currentDesktop (0),
+    fullscreenOutput (),
+    screenEdge (),
     wmSnSelectionWindow (None),
     clientPointerDeviceId (None),
     normalCursor (None),
     busyCursor (None),
     invisibleCursor (None),
+    workArea (),
     initialized (false),
-    screen(screen),
+    screen (screen),
+    xkbEvent (),
+    xineramaExtension (false),
     screenInfo (),
-    snDisplay(0),
-    root(None),
+    snDisplay (0),
+    displayString_ (),
+    escapeKeyCode (),
+    returnKeyCode (),
+    region (),
+    root (None),
+    attrib (),
     snContext (0),
     wmSnAtom (None),
+    wmSnTimestamp (0),
     desktopHintData (0),
     desktopHintSize (0),
     edgeWindow (None),
+    pingTimer (),
     edgeDelayTimer (),
+    edgeDelaySettings (),
     xdndWindow (None),
-    windowManager(windowManager)
+    pluginManager (),
+    windowManager (windowManager)
 {
-    for (int i = 0; i < SCREEN_EDGE_NUM; i++)
+    for (int i = 0; i < SCREEN_EDGE_NUM; ++i)
     {
 	screenEdge[i].id    = None;
 	screenEdge[i].count = 0;
     }
-
 }
 
-cps::History::History() :
+cps::History::History () :
     currentHistory_(0),
     activeNum_ (1)
 {
     memset (history, 0, sizeof history);
 }
 
-cps::WindowManager::WindowManager() :
+cps::WindowManager::WindowManager () :
     windows (),
     serverWindows (),
     destroyedWindows (),
     stackIsFresh (false),
     groups (0),
     pendingDestroys (0),
-    lastFoundWindow(0)
+    lastFoundWindow (0)
 {
 }
 
-cps::PluginManager::PluginManager() :
+cps::PluginManager::PluginManager () :
     plugin (),
     dirtyPluginList (true)
 {
 }
 
 cps::EventManager::EventManager () :
-    possibleTap(NULL),
-    source(0),
-    timeout(0),
-    sighupSource(0),
-    sigtermSource(0),
-    sigintSource(0),
+    possibleTap (NULL),
+    source (0),
+    timeout (0),
+    sighupSource (0),
+    sigtermSource (0),
+    sigintSource (0),
     fileWatch (0),
     lastFileWatchHandle (1),
     watchFds (0),
     lastWatchFdHandle (1),
+    grabbed (false),
     grabWindow (None)
 {
     TimeoutHandler *dTimeoutHandler = new TimeoutHandler ();
     TimeoutHandler::SetDefault (dTimeoutHandler);
 }
 
-cps::OrphanData::OrphanData() :
+cps::OrphanData::OrphanData () :
     activeWindow (0),
     nextActiveWindow(0)
 {
 }
 
-cps::OrphanData::~OrphanData()
+cps::OrphanData::~OrphanData ()
 {
 }
 
@@ -5275,16 +5296,15 @@
 	 * See LP: #1085590 */
 	g_source_destroy (timeout->gobj ());
     }
+
     delete sigintSource;
     delete sigtermSource;
     delete sighupSource;
 
     /* Not guaranteed to be created by EventManager's constructor */
     if (source)
-    {
 	/* This will implicitly call ~CompEventSource */
 	g_source_destroy (source->gobj ());
-    }
 
     /* This will implicitly call ~CompWatchFd */
     foreach (CompWatchFd *fd, watchFds)
@@ -5302,11 +5322,12 @@
 
     if (dpy != NULL)
     {
-	XUngrabKey (dpy, AnyKey, AnyModifier, rootWindow());
+	XUngrabKey (dpy, AnyKey, AnyModifier, rootWindow ());
 
-	for (int i = 0; i < SCREEN_EDGE_NUM; i++)
+	for (int i = 0; i < SCREEN_EDGE_NUM; ++i)
 	{
 	    Window id = screenEdge[i].id;
+
 	    if (id != None)
 		XDestroyWindow (dpy, id);
 	}
@@ -5340,7 +5361,7 @@
 	 * windows
 	 */
 
-	XSync (dpy, False);  // Redundant?
+	XSync (dpy, False);  // TODO: Redundant?
 	XCloseDisplay (dpy);
     }