1 files changed, 258 insertions, 0 deletions

diff --git a/util/fbcompose/BaseCompWindow.cc b/util/fbcompose/BaseCompWindow.cc
new file mode 100644
index 0000000..618a1fd
--- /dev/null
+++ b/util/fbcompose/BaseCompWindow.cc
@@ -0,0 +1,258 @@
+/** BaseCompWindow.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.
+
+
+#include "BaseCompWindow.hh"
+
+#include "Atoms.hh"
+#include "BaseScreen.hh"
+#include "Logging.hh"
+
+#include <X11/extensions/shape.h>
+#include <X11/extensions/Xcomposite.h>
+
+#include <algorithm>
+#include <ostream>
+
+using namespace FbCompositor;
+
+
+//--- CONSTRUCTORS AND DESTRUCTORS ---------------------------------------------
+
+// Constructor.
+BaseCompWindow::BaseCompWindow(const BaseScreen &screen, Window window_xid, bool track_damage_deltas) :
+    FbTk::FbWindow(window_xid),
+    m_screen(screen) {
+
+    XWindowAttributes xwa;
+    XGetWindowAttributes(display(), window(), &xwa);
+
+    m_class = xwa.c_class;
+    m_is_mapped = (xwa.map_state != IsUnmapped);
+    m_is_remapped = true;
+    m_is_resized = true;
+    m_visual = xwa.visual;
+
+    m_clip_shape_changed = true;
+    m_clip_shape_rects = 0;
+    m_clip_shape_rect_count = 0;
+
+    m_is_ignored = false;
+
+    if (m_class == InputOutput) {
+        if (track_damage_deltas) {
+            m_damage = XDamageCreate(display(), window_xid, XDamageReportDeltaRectangles);
+        } else {
+            m_damage = XDamageCreate(display(), window_xid, XDamageReportNonEmpty);
+        }
+    } else {
+        m_damage = 0;
+    }
+
+    m_content_pixmap = None;
+
+    updateAlpha();
+    updateWindowType();
+
+    XShapeSelectInput(display(), window_xid, ShapeNotifyMask);
+}
+
+// Destructor.
+BaseCompWindow::~BaseCompWindow() {
+    if (m_clip_shape_rects) {
+        XFree(m_clip_shape_rects);
+    }
+    if (m_content_pixmap) {
+        XFreePixmap(display(), m_content_pixmap);
+    }
+    // m_damage is apparently destroyed server-side.
+}
+
+
+//--- WINDOW MANIPULATION ------------------------------------------------------
+
+// Add damage to a window.
+void BaseCompWindow::addDamage() {
+    m_is_damaged = true;
+}
+
+// Mark the window as mapped.
+void BaseCompWindow::setMapped() {
+    m_is_mapped = true;
+    m_is_remapped = true;
+}
+
+// Mark the window as unmapped.
+void BaseCompWindow::setUnmapped() {
+    m_is_mapped = false;
+}
+
+// Update the window's contents.
+// Note: this is an example implementation of this function. You should not
+// call this version at any time and override it in derived classes.
+void BaseCompWindow::updateContents() {
+    updateContentPixmap();
+    if (m_clip_shape_changed) {
+        updateShape();
+    }
+
+    clearDamage();
+}
+
+// Update window's geometry.
+void BaseCompWindow::updateGeometry() {
+    unsigned int old_border_width = borderWidth();
+    unsigned int old_height = height();
+    unsigned int old_width = width();
+    FbTk::FbWindow::updateGeometry();
+
+    if ((borderWidth() != old_border_width) || (height() != old_height) || (width() != old_width)) {
+        setClipShapeChanged();
+        m_is_resized = true;
+    }
+}
+
+// Update the window's clip shape.
+void BaseCompWindow::updateShape() {
+    int rect_order;
+
+    if (m_clip_shape_rects) {
+        XFree(m_clip_shape_rects);
+        m_clip_shape_rects = NULL;
+    }
+    m_clip_shape_rects = XShapeGetRectangles(display(), window(), ShapeClip, &m_clip_shape_rect_count, &rect_order);
+
+    if (!m_clip_shape_rects) {
+        m_clip_shape_rect_count = 0;
+    } else {
+        // We have to adjust the size here to account for borders.
+        for (int i = 0; i < m_clip_shape_rect_count; i++) {
+            m_clip_shape_rects[i].height = std::min(m_clip_shape_rects[i].height + 2 * borderWidth(), realHeight());
+            m_clip_shape_rects[i].width = std::min(m_clip_shape_rects[i].width + 2 * borderWidth(), realWidth());
+        }
+    }
+}
+
+// Update window's property.
+void BaseCompWindow::updateProperty(Atom property, int /*state*/) {
+    if (property == Atoms::opacityAtom()) {
+        updateAlpha();
+    } else if (property == Atoms::windowTypeAtom()) {
+        updateWindowType();
+    }
+}
+
+
+// Set the clip shape as changed.
+void BaseCompWindow::setClipShapeChanged() {
+    m_clip_shape_changed = true;
+}
+
+
+//--- PROTECTED WINDOW MANIPULATION --------------------------------------------
+
+// Removes all damage from the window.
+void BaseCompWindow::clearDamage() {
+    m_clip_shape_changed = false;
+    m_is_damaged = false;
+    m_is_remapped = false;
+    m_is_resized = false;
+}
+
+// Updates the window's content pixmap.
+void BaseCompWindow::updateContentPixmap() {
+    // We must reset the damage here, otherwise we may miss damage events.
+    // TODO: BadDamage might be thrown here, probably safe to ignore for now.
+    XDamageSubtract(display(), m_damage, None, None);
+
+    if (m_is_resized || m_is_remapped) {
+        XGrabServer(display());
+
+        XWindowAttributes xwa;
+        if (XGetWindowAttributes(display(), window(), &xwa)) {
+            if (xwa.map_state == IsViewable) {
+                Pixmap new_pixmap = XCompositeNameWindowPixmap(display(), window());
+                if (new_pixmap) {
+                    if (m_content_pixmap) {
+                        XFreePixmap(display(), m_content_pixmap);
+                    }
+                    m_content_pixmap = new_pixmap;
+                }
+            }
+        }
+        XUngrabServer(display());
+    }
+}
+
+
+//--- PROPERTY UPDATE FUNCTIONS ----------------------------------------
+
+// Updates window's alpha.
+void BaseCompWindow::updateAlpha() {
+    m_alpha = singlePropertyValue<long>(Atoms::opacityAtom(), 0xff) & 0xff;
+}
+
+// Updates the type of the window.
+void BaseCompWindow::updateWindowType() {
+    static std::vector< std::pair<Atom, WindowType> > type_list = Atoms::windowTypeAtomList();
+    Atom raw_type = singlePropertyValue<Atom>(Atoms::windowTypeAtom(), None);
+
+    m_type = WinType_Normal;
+    for (size_t i = 0; i < type_list.size(); i++) {
+        if (raw_type == type_list[i].first) {
+            m_type = type_list[i].second;
+            break;
+        }
+    }
+}
+
+
+//--- CONVENIENCE FUNCTIONS ----------------------------------------------------
+
+// Reads and returns raw property contents.
+bool BaseCompWindow::rawPropertyData(Atom property_atom, Atom property_type,
+                                     unsigned long *item_count_return, unsigned char **data_return) {
+    Atom actual_type;
+    int actual_format;
+    unsigned long bytes_left;
+
+    if (property(property_atom, 0, 0x7fffffff, False, property_type,
+                 &actual_type, &actual_format, item_count_return, &bytes_left, data_return)) {
+        if (*item_count_return > 0) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+//--- OPERATORS ----------------------------------------------------------------
+
+// << output stream operator for the window class.
+std::ostream &FbCompositor::operator<<(std::ostream& out, const BaseCompWindow& w) {
+    out << "Window " << std::hex << w.window() << ": Geometry[" << std::dec << w.x()
+        << "," << w.y() << "," << w.width() << "," << w.height() << " " << w.borderWidth()
+        << "] Depth=" << w.depth() << " Type=" << w.type() << " Map=" << w.isMapped()
+        << " Dmg=" << w.isDamaged() << " Ignore=" << w.isIgnored();
+    return out;
+}