initHEADmaster

1 files changed, 475 insertions, 0 deletions

diff --git a/src/damage.c b/src/damage.c
new file mode 100644
index 0000000..caae80a
--- /dev/null
+++ b/src/damage.c
@@ -0,0 +1,475 @@
+#include "../include/damage.h"
+#include "../include/utils.h"
+#include "../include/window/window.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xrandr.h>
+
+typedef struct {
+    vec2i pos;
+    vec2i size;
+} gsr_rectangle;
+
+static bool rectangles_intersect(gsr_rectangle rect1, gsr_rectangle rect2) {
+    return rect1.pos.x < rect2.pos.x + rect2.size.x && rect1.pos.x + rect1.size.x > rect2.pos.x &&
+        rect1.pos.y < rect2.pos.y + rect2.size.y && rect1.pos.y + rect1.size.y > rect2.pos.y;
+}
+
+static bool xrandr_is_supported(Display *display) {
+    int major_version = 0;
+    int minor_version = 0;
+    if(!XRRQueryVersion(display, &major_version, &minor_version))
+        return false;
+
+    return major_version > 1 || (major_version == 1 && minor_version >= 2);
+}
+
+static int gsr_damage_get_tracked_monitor_index(const gsr_damage *self, const char *monitor_name) {
+    for(int i = 0; i < self->num_monitors_tracked; ++i) {
+        if(strcmp(self->monitors_tracked[i].monitor_name, monitor_name) == 0)
+            return i;
+    }
+    return -1;
+}
+
+static void add_monitor_callback(const gsr_monitor *monitor, void *userdata) {
+    gsr_damage *self = userdata;
+
+    const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor->name);
+    gsr_damage_monitor *damage_monitor = NULL;
+    if(damage_monitor_index != -1) {
+        damage_monitor = &self->monitors_tracked[damage_monitor_index];
+        damage_monitor->monitor = NULL;
+    }
+
+    if(self->num_monitors + 1 > GSR_DAMAGE_MAX_MONITORS) {
+        fprintf(stderr, "gsr error: gsr_damage_on_output_change: max monitors reached\n");
+        return;
+    }
+
+    char *monitor_name_copy = strdup(monitor->name);
+    if(!monitor_name_copy) {
+        fprintf(stderr, "gsr error: gsr_damage_on_output_change: strdup failed for monitor: %s\n", monitor->name);
+        return;
+    }
+
+    self->monitors[self->num_monitors] = *monitor;
+    self->monitors[self->num_monitors].name = monitor_name_copy;
+    ++self->num_monitors;
+
+    if(damage_monitor)
+        damage_monitor->monitor = &self->monitors[self->num_monitors - 1];
+}
+
+bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, gsr_cursor *cursor, bool track_cursor) {
+    memset(self, 0, sizeof(*self));
+    self->egl = egl;
+    self->track_cursor = track_cursor;
+    self->cursor = cursor;
+
+    if(gsr_window_get_display_server(egl->window) != GSR_DISPLAY_SERVER_X11) {
+        fprintf(stderr, "gsr error: gsr_damage_init: damage tracking is not supported on wayland\n");
+        return false;
+    }
+    self->display = gsr_window_get_display(egl->window);
+
+    if(!XDamageQueryExtension(self->display, &self->damage_event, &self->damage_error)) {
+        fprintf(stderr, "gsr error: gsr_damage_init: XDamage is not supported by your X11 server\n");
+        gsr_damage_deinit(self);
+        return false;
+    }
+
+    if(!XRRQueryExtension(self->display, &self->randr_event, &self->randr_error)) {
+        fprintf(stderr, "gsr error: gsr_damage_init: XRandr is not supported by your X11 server\n");
+        gsr_damage_deinit(self);
+        return false;
+    }
+
+    if(!xrandr_is_supported(self->display)) {
+        fprintf(stderr, "gsr error: gsr_damage_init: your X11 randr version is too old\n");
+        gsr_damage_deinit(self);
+        return false;
+    }
+
+    XRRSelectInput(self->display, DefaultRootWindow(self->display), RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask);
+
+    self->monitor_damage = XDamageCreate(self->display, DefaultRootWindow(self->display), XDamageReportNonEmpty);
+    if(!self->monitor_damage) {
+        fprintf(stderr, "gsr error: gsr_damage_init: XDamageCreate failed\n");
+        gsr_damage_deinit(self);
+        return false;
+    }
+    XDamageSubtract(self->display, self->monitor_damage, None, None);
+
+    for_each_active_monitor_output_x11_not_cached(self->display, add_monitor_callback, self);
+
+    self->damaged = true;
+    return true;
+}
+
+static void gsr_damage_deinit_monitors(gsr_damage *self) {
+    for(int i = 0; i < self->num_monitors; ++i) {
+        free((char*)self->monitors[i].name);
+    }
+    self->num_monitors = 0;
+}
+
+void gsr_damage_deinit(gsr_damage *self) {
+    if(self->monitor_damage) {
+        XDamageDestroy(self->display, self->monitor_damage);
+        self->monitor_damage = None;
+    }
+
+    for(int i = 0; i < self->num_monitors_tracked; ++i) {
+        free(self->monitors_tracked[i].monitor_name);
+    }
+    self->num_monitors_tracked = 0;
+
+    for(int i = 0; i < self->num_windows_tracked; ++i) {
+        XSelectInput(self->display, self->windows_tracked[i].window_id, 0);
+        XDamageDestroy(self->display, self->windows_tracked[i].damage);
+    }
+    self->num_windows_tracked = 0;
+
+    self->all_monitors_tracked_refcount = 0;
+    gsr_damage_deinit_monitors(self);
+
+    self->damage_event = 0;
+    self->damage_error = 0;
+
+    self->randr_event = 0;
+    self->randr_error = 0;
+}
+
+static int gsr_damage_get_tracked_window_index(const gsr_damage *self, int64_t window) {
+    for(int i = 0; i < self->num_windows_tracked; ++i) {
+        if(self->windows_tracked[i].window_id == window)
+            return i;
+    }
+    return -1;
+}
+
+bool gsr_damage_start_tracking_window(gsr_damage *self, int64_t window) {
+    if(self->damage_event == 0 || window == None)
+        return false;
+
+    const int damage_window_index = gsr_damage_get_tracked_window_index(self, window);
+    if(damage_window_index != -1) {
+        ++self->windows_tracked[damage_window_index].refcount;
+        return true;
+    }
+
+    if(self->num_windows_tracked + 1 > GSR_DAMAGE_MAX_TRACKED_TARGETS) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_window: max window targets reached\n");
+        return false;
+    }
+
+    XWindowAttributes win_attr;
+    win_attr.x = 0;
+    win_attr.y = 0;
+    win_attr.width = 0;
+    win_attr.height = 0;
+    if(!XGetWindowAttributes(self->display, window, &win_attr))
+        fprintf(stderr, "gsr warning: gsr_damage_start_tracking_window failed: failed to get window attributes: %ld\n", (long)window);
+
+    const Damage damage = XDamageCreate(self->display, window, XDamageReportNonEmpty);
+    if(!damage) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_window: XDamageCreate failed\n");
+        return false;
+    }
+    XDamageSubtract(self->display, damage, None, None);
+
+    XSelectInput(self->display, window, StructureNotifyMask | ExposureMask);
+
+    gsr_damage_window *damage_window = &self->windows_tracked[self->num_windows_tracked];
+    ++self->num_windows_tracked;
+
+    damage_window->window_id = window;
+    damage_window->window_pos.x = win_attr.x;
+    damage_window->window_pos.y = win_attr.y;
+    damage_window->window_size.x = win_attr.width;
+    damage_window->window_size.y = win_attr.height;
+    damage_window->damage = damage;
+    damage_window->refcount = 1;
+    return true;
+}
+
+void gsr_damage_stop_tracking_window(gsr_damage *self, int64_t window) {
+    if(window == None)
+        return;
+
+    const int damage_window_index = gsr_damage_get_tracked_window_index(self, window);
+    if(damage_window_index == -1)
+        return;
+
+    gsr_damage_window *damage_window = &self->windows_tracked[damage_window_index];
+    --damage_window->refcount;
+    if(damage_window->refcount <= 0) {
+        XSelectInput(self->display, damage_window->window_id, 0);
+        XDamageDestroy(self->display, damage_window->damage);
+        self->windows_tracked[damage_window_index] = self->windows_tracked[self->num_windows_tracked - 1];
+        --self->num_windows_tracked;
+    }
+}
+
+static gsr_monitor* gsr_damage_get_monitor_by_id(gsr_damage *self, RRCrtc id) {
+    for(int i = 0; i < self->num_monitors; ++i) {
+        if(self->monitors[i].monitor_identifier == id)
+            return &self->monitors[i];
+    }
+    return NULL;
+}
+
+static gsr_monitor* gsr_damage_get_monitor_by_name(gsr_damage *self, const char *name) {
+    for(int i = 0; i < self->num_monitors; ++i) {
+        if(strcmp(self->monitors[i].name, name) == 0)
+            return &self->monitors[i];
+    }
+    return NULL;
+}
+
+bool gsr_damage_start_tracking_monitor(gsr_damage *self, const char *monitor_name) {
+    if(self->damage_event == 0)
+        return false;
+
+    if(strcmp(monitor_name, "screen-direct") == 0 || strcmp(monitor_name, "screen-direct-force") == 0)
+        monitor_name = NULL;
+
+    if(!monitor_name) {
+        ++self->all_monitors_tracked_refcount;
+        return true;
+    }
+
+    const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor_name);
+    if(damage_monitor_index != -1) {
+        ++self->monitors_tracked[damage_monitor_index].refcount;
+        return true;
+    }
+
+    if(self->num_monitors_tracked + 1 > GSR_DAMAGE_MAX_TRACKED_TARGETS) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: max monitor targets reached\n");
+        return false;
+    }
+
+    char *monitor_name_copy = strdup(monitor_name);
+    if(!monitor_name_copy) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: strdup failed for monitor: %s\n", monitor_name);
+        return false;
+    }
+
+    gsr_monitor *monitor = gsr_damage_get_monitor_by_name(self, monitor_name);
+    if(!monitor) {
+        fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: failed to find monitor: %s\n", monitor_name);
+        free(monitor_name_copy);
+        return false;
+    }
+
+    gsr_damage_monitor *damage_monitor = &self->monitors_tracked[self->num_monitors_tracked];
+    ++self->num_monitors_tracked;
+
+    damage_monitor->monitor_name = monitor_name_copy;
+    damage_monitor->monitor = monitor;
+    damage_monitor->refcount = 1;
+    return true;
+}
+
+void gsr_damage_stop_tracking_monitor(gsr_damage *self, const char *monitor_name) {
+    if(strcmp(monitor_name, "screen-direct") == 0 || strcmp(monitor_name, "screen-direct-force") == 0)
+        monitor_name = NULL;
+
+    if(!monitor_name) {
+        --self->all_monitors_tracked_refcount;
+        if(self->all_monitors_tracked_refcount < 0)
+            self->all_monitors_tracked_refcount = 0;
+        return;
+    }
+
+    const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor_name);
+    if(damage_monitor_index == -1)
+        return;
+
+    gsr_damage_monitor *damage_monitor = &self->monitors_tracked[damage_monitor_index];
+    --damage_monitor->refcount;
+    if(damage_monitor->refcount <= 0) {
+        free(damage_monitor->monitor_name);
+        self->monitors_tracked[damage_monitor_index] = self->monitors_tracked[self->num_monitors_tracked - 1];
+        --self->num_monitors_tracked;
+    }
+}
+
+static void gsr_damage_on_crtc_change(gsr_damage *self, XEvent *xev) {
+    const XRRCrtcChangeNotifyEvent *rr_crtc_change_event = (XRRCrtcChangeNotifyEvent*)xev;
+    if(rr_crtc_change_event->crtc == 0)
+        return;
+
+    if(rr_crtc_change_event->width == 0 || rr_crtc_change_event->height == 0)
+        return;
+
+    gsr_monitor *monitor = gsr_damage_get_monitor_by_id(self, rr_crtc_change_event->crtc);
+    if(!monitor)
+        return;
+
+    if(rr_crtc_change_event->x != monitor->pos.x || rr_crtc_change_event->y != monitor->pos.y ||
+        (int)rr_crtc_change_event->width != monitor->size.x || (int)rr_crtc_change_event->height != monitor->size.y) {
+        monitor->pos.x = rr_crtc_change_event->x;
+        monitor->pos.y = rr_crtc_change_event->y;
+
+        monitor->size.x = rr_crtc_change_event->width;
+        monitor->size.y = rr_crtc_change_event->height;
+    }
+}
+
+static void gsr_damage_on_output_change(gsr_damage *self, XEvent *xev) {
+    const XRROutputChangeNotifyEvent *rr_output_change_event = (XRROutputChangeNotifyEvent*)xev;
+    if(!rr_output_change_event->output)
+        return;
+
+    gsr_damage_deinit_monitors(self);
+    for_each_active_monitor_output_x11_not_cached(self->display, add_monitor_callback, self);
+}
+
+static void gsr_damage_on_randr_event(gsr_damage *self, XEvent *xev) {
+    const XRRNotifyEvent *rr_event = (XRRNotifyEvent*)xev;
+    switch(rr_event->subtype) {
+        case RRNotify_CrtcChange:
+            gsr_damage_on_crtc_change(self, xev);
+            break;
+        case RRNotify_OutputChange:
+            gsr_damage_on_output_change(self, xev);
+            break;
+    }
+}
+
+static void gsr_damage_on_damage_event(gsr_damage *self, XEvent *xev) {
+    const XDamageNotifyEvent *de = (XDamageNotifyEvent*)xev;
+    XserverRegion region = XFixesCreateRegion(self->display, NULL, 0);
+    /* Subtract all the damage, repairing the window */
+    XDamageSubtract(self->display, de->damage, None, region);
+
+    if(self->all_monitors_tracked_refcount > 0)
+        self->damaged = true;
+
+    if(!self->damaged) {
+        for(int i = 0; i < self->num_windows_tracked; ++i) {
+            const gsr_damage_window *damage_window = &self->windows_tracked[i];
+            if(damage_window->window_id == (int64_t)de->drawable) {
+                self->damaged = true;
+                break;
+            }
+        }
+    }
+
+    if(!self->damaged) {
+        int num_rectangles = 0;
+        XRectangle *rectangles = XFixesFetchRegion(self->display, region, &num_rectangles);
+        if(rectangles) {
+            for(int i = 0; i < num_rectangles; ++i) {
+                const gsr_rectangle damage_region = { (vec2i){rectangles[i].x, rectangles[i].y}, (vec2i){rectangles[i].width, rectangles[i].height} };
+                for(int j = 0; j < self->num_monitors_tracked; ++j) {
+                    const gsr_monitor *monitor = self->monitors_tracked[j].monitor;
+                    if(!monitor)
+                        continue;
+
+                    const gsr_rectangle monitor_region = { monitor->pos, monitor->size };
+                    self->damaged = rectangles_intersect(monitor_region, damage_region);
+                    if(self->damaged)
+                        goto intersection_found;
+                }
+            }
+
+            intersection_found:
+            XFree(rectangles);
+        }
+    }
+
+    XFixesDestroyRegion(self->display, region);
+    XFlush(self->display);
+}
+
+static void gsr_damage_on_tick_cursor(gsr_damage *self) {
+    if(self->cursor->position.x == self->cursor_pos.x && self->cursor->position.y == self->cursor_pos.y)
+        return;
+
+    self->cursor_pos = self->cursor->position;
+    const gsr_rectangle cursor_region = { self->cursor->position, self->cursor->size };
+
+    if(self->all_monitors_tracked_refcount > 0)
+        self->damaged = true;
+
+    if(!self->damaged) {
+        for(int i = 0; i < self->num_windows_tracked; ++i) {
+            const gsr_damage_window *damage_window = &self->windows_tracked[i];
+            const gsr_rectangle window_region = { damage_window->window_pos, damage_window->window_size };
+            if(rectangles_intersect(window_region, cursor_region)) {
+                self->damaged = true;
+                break;
+            }
+        }
+    }
+
+    if(!self->damaged) {
+        for(int i = 0; i < self->num_monitors_tracked; ++i) {
+            const gsr_monitor *monitor = self->monitors_tracked[i].monitor;
+            if(!monitor)
+                continue;
+
+            const gsr_rectangle monitor_region = { monitor->pos, monitor->size };
+            if(rectangles_intersect(monitor_region, cursor_region)) {
+                self->damaged = true;
+                break;
+            }
+        }
+    }
+}
+
+static void gsr_damage_on_window_configure_notify(gsr_damage *self, XEvent *xev) {
+    for(int i = 0; i < self->num_windows_tracked; ++i) {
+        gsr_damage_window *damage_window = &self->windows_tracked[i];
+        if(damage_window->window_id == (int64_t)xev->xconfigure.window) {
+            damage_window->window_pos.x = xev->xconfigure.x;
+            damage_window->window_pos.y = xev->xconfigure.y;
+
+            damage_window->window_size.x = xev->xconfigure.width;
+            damage_window->window_size.y = xev->xconfigure.height;
+            break;
+        }
+    }
+}
+
+void gsr_damage_on_event(gsr_damage *self, XEvent *xev) {
+    if(self->damage_event == 0)
+        return;
+
+    if(xev->type == ConfigureNotify)
+        gsr_damage_on_window_configure_notify(self, xev);
+
+    if(self->randr_event) {
+        if(xev->type == self->randr_event + RRScreenChangeNotify)
+            XRRUpdateConfiguration(xev);
+
+        if(xev->type == self->randr_event + RRNotify)
+            gsr_damage_on_randr_event(self, xev);
+    }
+
+    if(self->damage_event && xev->type == self->damage_event + XDamageNotify)
+        gsr_damage_on_damage_event(self, xev);
+}
+
+void gsr_damage_tick(gsr_damage *self) {
+    if(self->damage_event == 0)
+        return;
+
+    if(self->track_cursor && self->cursor->visible && !self->damaged)
+        gsr_damage_on_tick_cursor(self);
+}
+
+bool gsr_damage_is_damaged(gsr_damage *self) {
+    return self->damage_event == 0 || self->damaged;
+}
+
+void gsr_damage_clear(gsr_damage *self) {
+    self->damaged = false;
+}