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;
+}