fbcompose - A compositing addon for fluxbox window manager.

 fbcompose(1) is an optional compositing addon for fluxbox window manager. It
 augments fluxbox with a number of graphical features. Most notably, fbcompose
 allows fluxbox to properly display applications that require compositing
 (docky, for example), adds support for true window transparency (as opposed to
 fluxbox's pseudo transparency) and provides a plugin framework to extend the
 compositor's functionality.

 As this is still a beta version of the compositor, the bugs are likely.

1 files changed, 440 insertions, 0 deletions

diff --git a/util/fbcompose/Compositor.cc b/util/fbcompose/Compositor.cc
new file mode 100644
index 0000000..48fd64f
--- /dev/null
+++ b/util/fbcompose/Compositor.cc
@@ -0,0 +1,440 @@
+/** Compositor.cc file for the fluxbox compositor. */
+
+// Copyright (c) 2011 Gediminas Liktaras (gliktaras at gmail dot com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+
+#ifdef HAVE_CONFIG_H
+    #include "config.h"
+#endif  // HAVE_CONFIG_H
+
+#include "Compositor.hh"
+
+#include "Atoms.hh"
+#include "BaseScreen.hh"
+#include "CompositorConfig.hh"
+#include "Constants.hh"
+#include "Logging.hh"
+#include "OpenGLScreen.hh"
+#include "XRenderScreen.hh"
+
+#ifdef USE_OPENGL_COMPOSITING
+    #include <GL/glxew.h>
+    #include <GL/glx.h>
+#endif  // USE_OPENGL_COMPOSITING
+
+#include <X11/extensions/shape.h>
+#include <X11/extensions/Xcomposite.h>
+#include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xfixes.h>
+#ifdef XINERAMA
+    #include <X11/extensions/Xinerama.h>
+#endif  // XINERAMA
+#ifdef USE_XRENDER_COMPOSITING
+    #include <X11/extensions/Xrender.h>
+#endif  // USE_XRENDER_COMPOSITING
+#include <X11/Xutil.h>
+
+#include <sstream>
+
+#ifdef HAVE_CTIME
+    #include <ctime>
+#else
+#ifdef HAVE_TIME_H
+    #include <time.h>
+#endif
+#endif
+
+#include <csignal>
+
+using namespace FbCompositor;
+
+
+//--- CONSTANTS ----------------------------------------------------------------
+
+/** Length of the error buffer in X error handler. */
+const int ERROR_BUFFER_LENGTH = 128;
+
+/** Name of the relevant error database with X error messages in X error handler. */
+const char ERROR_DB_TEXT_NAME[] = "XRequest";
+
+/** Default name for unknown requests in X error handler. */
+const char REQUEST_NAME_UNKNOWN_MESSAGE[] = "<UNKNOWN>";
+
+/** How many microseconds to sleep before restarting the event loop. */
+const int SLEEP_TIME = 5000;
+
+
+//--- CONSTRUCTORS AND DESTRUCTORS ---------------------------------------------
+
+// The constructor.
+Compositor::Compositor(const CompositorConfig &config) :
+    App(config.displayName().c_str()) {
+
+    if (config.synchronize()) {
+        XSynchronize(display(), True);
+    }
+
+    if (config.renderingMode() == RM_ServerAuto) {
+        throw InitException("Compositor class does not provide the serverauto renderer.");
+    }
+    m_rendering_mode = config.renderingMode();
+
+    if (config.showXErrors()) {
+        XSetErrorHandler(&printXError);
+    } else {
+        XSetErrorHandler(&ignoreXError);
+    }
+
+    initAllExtensions();
+
+    int screen_count = XScreenCount(display());
+    m_screens.reserve(screen_count);
+
+    for (int i = 0; i < screen_count; i++) {
+        Window cm_selection_owner = getCMSelectionOwnership(i);
+
+        switch (m_rendering_mode) {
+#ifdef USE_OPENGL_COMPOSITING
+        case RM_OpenGL :
+            m_screens.push_back(new OpenGLScreen(i, config));
+            break;
+#endif  // USE_OPENGL_COMPOSITING
+#ifdef USE_XRENDER_COMPOSITING
+        case RM_XRender :
+            m_screens.push_back(new XRenderScreen(i, config));
+            break;
+#endif  // USE_XRENDER_COMPOSITING
+        default :
+            throw InitException("Unknown rendering mode selected.");
+            break;
+        }
+
+        m_screens[i]->ignoreWindow(cm_selection_owner);
+    }
+
+    initHeads();
+    for (size_t i = 0; i < m_screens.size(); i++) {
+        m_screens[i]->initPlugins(config);
+        m_screens[i]->initWindows();
+    }
+
+    m_timer.setTickSize(1000000 / config.framesPerSecond());
+    m_timer.start();
+
+    XFlush(display());
+
+    signal(SIGINT, handleSignal);
+    signal(SIGTERM, handleSignal);
+}
+
+// Destructor.
+Compositor::~Compositor() {
+    std::vector<BaseScreen*>::iterator it = m_screens.begin();
+    while (it != m_screens.end()) {
+        delete *it;
+        ++it;
+    }
+}
+
+
+//--- INITIALIZATION FUNCTIONS -----------------------------------------
+
+// Acquires the ownership of compositing manager selections.
+Window Compositor::getCMSelectionOwnership(int screen_number) {
+    Atom cm_atom = Atoms::compositingSelectionAtom(screen_number);
+
+    Window cur_owner = XGetSelectionOwner(display(), cm_atom);
+    if (cur_owner != None) {
+        // TODO: More detailed message - what is the other program?
+        throw InitException("Another compositing manager is running.");
+    }
+
+    cur_owner = XCreateSimpleWindow(display(), XRootWindow(display(), screen_number), -10, -10, 1, 1, 0, None, None);
+    XmbSetWMProperties(display(), cur_owner, APP_NAME, APP_NAME, NULL, 0, NULL, NULL, NULL);
+    XSetSelectionOwner(display(), cm_atom, cur_owner, CurrentTime);
+
+    return cur_owner;
+}
+
+// Initializes X's extensions.
+void Compositor::initAllExtensions() {
+#ifdef USE_OPENGL_COMPOSITING
+    if (m_rendering_mode == RM_OpenGL) {
+        initExtension("GLX", &glXQueryExtension, &glXQueryVersion, 1, 3, m_glx_event_base, m_glx_error_base);
+        initExtension("XComposite", &XCompositeQueryExtension, &XCompositeQueryVersion, 0, 4, m_composite_event_base, m_composite_error_base);
+        initExtension("XDamage", &XDamageQueryExtension, &XDamageQueryVersion, 1, 0, m_damage_event_base, m_damage_error_base);
+        initExtension("XFixes", &XFixesQueryExtension, &XFixesQueryVersion, 2, 0, m_fixes_event_base, m_fixes_error_base);
+        initExtension("XShape", &XShapeQueryExtension, &XShapeQueryVersion, 1, 1, m_shape_event_base, m_shape_error_base);
+    } else
+#endif  // USE_OPENGL_COMPOSITING
+
+#ifdef USE_XRENDER_COMPOSITING
+    if (m_rendering_mode == RM_XRender) {
+        initExtension("XComposite", &XCompositeQueryExtension, &XCompositeQueryVersion, 0, 4, m_composite_event_base, m_composite_error_base);
+        initExtension("XDamage", &XDamageQueryExtension, &XDamageQueryVersion, 1, 0, m_damage_event_base, m_damage_error_base);
+        initExtension("XFixes", &XFixesQueryExtension, &XFixesQueryVersion, 2, 0, m_fixes_event_base, m_fixes_error_base);
+        initExtension("XRender", &XRenderQueryExtension, &XRenderQueryVersion, 0, 1, m_render_event_base, m_render_error_base);
+        initExtension("XShape", &XShapeQueryExtension, &XShapeQueryVersion, 1, 1, m_shape_event_base, m_shape_error_base);
+    } else
+#endif  // USE_XRENDER_COMPOSITING
+
+    { }
+}
+
+// Initializes a particular X server extension.
+void Compositor::initExtension(const char *extension_name, QueryExtensionFunction extension_func,
+                               QueryVersionFunction version_func, const int min_major_ver, const int min_minor_ver,
+                               int &event_base, int &error_base) {
+    int major_ver;
+    int minor_ver;
+
+    // Check that the extension exists.
+    if (!(*extension_func)(display(), &event_base, &error_base)) {
+        event_base = -1;
+        error_base = -1;
+
+        std::stringstream ss;
+        ss << extension_name << " extension not found.";
+        throw InitException(ss.str());
+    }
+
+    // Get extension version.
+    if (!(*version_func)(display(), &major_ver, &minor_ver)) {
+        event_base = -1;
+        error_base = -1;
+
+        std::stringstream ss;
+        ss << "Could not query the version of " << extension_name << " extension.";
+        throw InitException(ss.str());
+    }
+
+    // Make sure the extension version is at least what we require.
+    if ((major_ver < min_major_ver) || ((major_ver == min_major_ver) && (minor_ver < min_minor_ver))) {
+        event_base = -1;
+        error_base = -1;
+
+        std::stringstream ss;
+        ss << "Unsupported " << extension_name << " extension version found (required >=" << min_major_ver
+           << "." << min_minor_ver << ", got " << major_ver << "." << minor_ver << ").";
+        throw InitException(ss.str());
+    }
+}
+
+// Initializes monitor heads on every screen.
+void Compositor::initHeads() {
+    HeadMode head_mode = Heads_One;
+
+#ifdef XINERAMA
+    try {
+        initExtension("Xinerama", &XineramaQueryExtension, &XCompositeQueryVersion, 0, 0, m_xinerama_event_base, m_xinerama_error_base);
+        if (XineramaIsActive(display())) {
+            head_mode = Heads_Xinerama;
+        }
+    } catch (const InitException &e) { }
+
+    if (head_mode != Heads_Xinerama) {
+        fbLog_warn << "Could not initialize Xinerama." << std::endl;
+    }
+#endif  // XINERAMA
+
+    for (size_t i = 0; i < m_screens.size(); i++) {
+        m_screens[i]->updateHeads(head_mode);
+    }
+}
+
+
+//--- EVENT LOOP ---------------------------------------------------------------
+
+// The event loop.
+void Compositor::eventLoop() {
+    union {
+        XEvent event_x;
+        XDamageNotifyEvent event_x_damage_notify;
+        XShapeEvent event_x_shape;
+    } event_union;
+    XEvent &event = event_union.event_x;
+
+    int event_screen;
+    timespec sleep_timespec = { 0, SLEEP_TIME * 1000 };
+
+    while (!done()) {
+        while (XPending(display())) {
+            XNextEvent(display(), &event);
+
+            event_screen = screenOfEvent(event);
+            if (event_screen < 0) {
+                fbLog_info << "Event " << std::dec << event.xany.serial << " (window " << std::hex << event.xany.window
+                           << ", type " << std::dec << event.xany.type << ") does not affect any managed windows, skipping."
+                           << std::endl;
+                continue;
+            }
+
+            switch (event.type) {
+            case CirculateNotify :
+                m_screens[event_screen]->circulateWindow(event.xcirculate.window, event.xcirculate.place);
+                fbLog_debug << "CirculateNotify on " << std::hex << event.xcirculate.window << std::endl;
+                break;
+
+            case ConfigureNotify :
+                m_screens[event_screen]->reconfigureWindow(event.xconfigure);
+                fbLog_debug << "ConfigureNotify on " << std::hex << event.xconfigure.window << std::endl;
+                break;
+
+            case CreateNotify :
+                m_screens[event_screen]->createWindow(event.xcreatewindow.window);
+                fbLog_debug << "CreateNotify on " << std::hex << event.xcreatewindow.window << std::endl;
+                break;
+
+            case DestroyNotify :
+                m_screens[event_screen]->destroyWindow(event.xdestroywindow.window);
+                fbLog_debug << "DestroyNotify on " << std::hex << event.xdestroywindow.window << std::endl;
+                break;
+
+            case Expose :
+                m_screens[event_screen]->damageWindow(event.xexpose.window, getExposedRect(event.xexpose));
+                fbLog_debug << "Expose on " << std::hex << event.xexpose.window << std::endl;
+                break;
+
+            case GravityNotify :
+                fbLog_debug << "GravityNotify on " << std::hex << event.xgravity.window << std::endl;
+                break;
+
+            case MapNotify :
+                m_screens[event_screen]->mapWindow(event.xmap.window);
+                fbLog_debug << "MapNotify on " << std::hex << event.xmap.window << std::endl;
+                break;
+
+            case PropertyNotify :
+                m_screens[event_screen]->updateWindowProperty(event.xproperty.window, event.xproperty.atom, event.xproperty.state);
+                fbLog_debug << "PropertyNotify on " << std::hex << event.xproperty.window << " ("
+                            << XGetAtomName(display(), event.xproperty.atom) << ")" << std::endl;
+                break;
+
+            case ReparentNotify :
+                m_screens[event_screen]->reparentWindow(event.xreparent.window, event.xreparent.parent);
+                fbLog_debug << "ReparentNotify on " << std::hex << event.xreparent.window << " (parent "
+                            << event.xreparent.parent << ")" << std::endl;
+                break;
+
+            case UnmapNotify :
+                m_screens[event_screen]->unmapWindow(event.xunmap.window);
+                fbLog_debug << "UnmapNotify on " << std::hex << event.xunmap.window << std::endl;
+                break;
+
+            default :
+                if (event.type == (m_damage_event_base + XDamageNotify)) {
+                    XDamageNotifyEvent damageEvent = event_union.event_x_damage_notify;
+                    m_screens[event_screen]->damageWindow(damageEvent.drawable, damageEvent.area);
+                    fbLog_debug << "DamageNotify on " << std::hex << damageEvent.drawable << std::endl;
+
+                } else if (event.type == (m_shape_event_base + ShapeNotify)) {
+                    XShapeEvent shapeEvent = event_union.event_x_shape;
+                    m_screens[event_screen]->updateShape(shapeEvent.window);
+                    fbLog_debug << "ShapeNotify on " << std::hex << shapeEvent.window << std::endl;
+
+                } else {
+                    fbLog_debug << "Other event " << std::dec << event.xany.type << " received on screen "
+                                << event_screen << " and window " << std::hex << event.xany.window << std::endl;
+                }
+                break;
+            }
+        }
+
+        if (m_timer.newElapsedTicks()) {
+            for (size_t i = 0; i < m_screens.size(); i++) {
+                m_screens[i]->renderScreen();
+                m_screens[i]->clearScreenDamage();
+            }
+            XSync(display(), False);
+
+            fbLog_debugDump << m_screens.size() << " screen(s) available." << std::endl;
+            for (size_t i = 0; i < m_screens.size(); i++) {
+                fbLog_debugDump << *m_screens[i];
+            }
+            fbLog_debugDump << "======================================" << std::endl;
+        } else {
+            nanosleep(&sleep_timespec, NULL);
+        }
+    }
+}
+
+
+//--- INTERNAL FUNCTIONS -----------------------------------------------
+
+// Returns the exposed area in a XExposeEvent as an XRectangle.
+XRectangle Compositor::getExposedRect(const XExposeEvent &event) {
+    XRectangle rect = { event.x, event.y, event.width, event.height };
+    return rect;
+}
+
+// Locates the screen an event affects. Returns -1 on failure.
+int Compositor::screenOfEvent(const XEvent &event) {
+    if (m_screens.size() == 1) {
+        return 0;
+    } else {
+        for (size_t i = 0; i < m_screens.size(); i++) {
+            if ((event.xany.window == m_screens[i]->rootWindow().window())
+                    || (m_screens[i]->isWindowManaged(event.xany.window))) {
+                return i;
+            }
+        }
+    }
+
+    return -1;
+}
+
+
+//--- VARIOUS HANDLERS ---------------------------------------------------------
+
+// Custom signal handler.
+void FbCompositor::handleSignal(int sig) {
+    if ((sig == SIGINT) || (sig == SIGTERM)) {
+        FbTk::App::instance()->end();
+    }
+}
+
+
+// Custom X error handler (ignore).
+int FbCompositor::ignoreXError(Display * /*display*/, XErrorEvent * /*error*/) {
+    return 0;
+}
+
+// Custom X error handler (print, continue).
+int FbCompositor::printXError(Display *display, XErrorEvent *error) {
+    static std::stringstream ss;
+    ss.str("");
+
+    char error_text[ERROR_BUFFER_LENGTH];
+    XGetErrorText(display, error->error_code, error_text, ERROR_BUFFER_LENGTH);
+
+    ss << int(error->request_code);
+
+    char request_name[ERROR_BUFFER_LENGTH];
+    XGetErrorDatabaseText(display, (char*)(ERROR_DB_TEXT_NAME), (char*)(ss.str().c_str()),
+                          (char*)(REQUEST_NAME_UNKNOWN_MESSAGE), request_name, ERROR_BUFFER_LENGTH);
+
+    fbLog_warn << "X Error: " << error_text << " in " << request_name << " request, errorCode="
+               << std::dec << int(error->error_code) << ", majorOpCode=" << int(error->request_code)
+               << ", minorOpCode=" << int(error->minor_code) << ", resourceId=" << std::hex
+               << error->resourceid << "." << std::endl;
+
+    return 0;
+}