diff options
Diffstat (limited to 'src/damage.c')
| -rw-r--r-- | src/damage.c | 327 |
1 files changed, 327 insertions, 0 deletions
diff --git a/src/damage.c b/src/damage.c new file mode 100644 index 0000000..25a2225 --- /dev/null +++ b/src/damage.c @@ -0,0 +1,327 @@ +#include "../include/damage.h" +#include "../include/utils.h" +#include "../include/window/window.h" + +#include <stdio.h> +#include <string.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); +} + +bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, bool track_cursor) { + memset(self, 0, sizeof(*self)); + self->egl = egl; + self->track_cursor = track_cursor; + + if(gsr_window_get_display_server(egl->window) != GSR_DISPLAY_SERVER_X11) { + fprintf(stderr, "gsr warning: 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 warning: 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 warning: 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 warning: gsr_damage_init: your X11 randr version is too old\n"); + gsr_damage_deinit(self); + return false; + } + + if(self->track_cursor) + self->track_cursor = gsr_cursor_init(&self->cursor, self->egl, self->display) == 0; + + XRRSelectInput(self->display, DefaultRootWindow(self->display), RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask); + + self->damaged = true; + return true; +} + +void gsr_damage_deinit(gsr_damage *self) { + if(self->damage) { + XDamageDestroy(self->display, self->damage); + self->damage = None; + } + + gsr_cursor_deinit(&self->cursor); + + self->damage_event = 0; + self->damage_error = 0; + + self->randr_event = 0; + self->randr_error = 0; +} + +bool gsr_damage_set_target_window(gsr_damage *self, uint64_t window) { + if(self->damage_event == 0) + return false; + + if(window == self->window) + return true; + + if(self->damage) { + XDamageDestroy(self->display, self->damage); + self->damage = None; + } + + if(self->window) + XSelectInput(self->display, self->window, 0); + + self->window = window; + XSelectInput(self->display, self->window, StructureNotifyMask | ExposureMask); + + XWindowAttributes win_attr; + win_attr.x = 0; + win_attr.y = 0; + win_attr.width = 0; + win_attr.height = 0; + if(!XGetWindowAttributes(self->display, self->window, &win_attr)) + fprintf(stderr, "gsr warning: gsr_damage_set_target_window failed: failed to get window attributes: %ld\n", (long)self->window); + + //self->window_pos.x = win_attr.x; + //self->window_pos.y = win_attr.y; + + self->window_size.x = win_attr.width; + self->window_size.y = win_attr.height; + + self->damage = XDamageCreate(self->display, window, XDamageReportNonEmpty); + if(self->damage) { + XDamageSubtract(self->display, self->damage, None, None); + self->damaged = true; + self->track_type = GSR_DAMAGE_TRACK_WINDOW; + return true; + } else { + fprintf(stderr, "gsr warning: gsr_damage_set_target_window: XDamageCreate failed\n"); + self->track_type = GSR_DAMAGE_TRACK_NONE; + return false; + } +} + +bool gsr_damage_set_target_monitor(gsr_damage *self, const char *monitor_name) { + if(self->damage_event == 0) + return false; + + if(strcmp(self->monitor_name, monitor_name) == 0) + return true; + + if(self->damage) { + XDamageDestroy(self->display, self->damage); + self->damage = None; + } + + memset(&self->monitor, 0, sizeof(self->monitor)); + if(strcmp(monitor_name, "screen-direct") != 0 && strcmp(monitor_name, "screen-direct-force") != 0) { + if(!get_monitor_by_name(self->egl, GSR_CONNECTION_X11, monitor_name, &self->monitor)) + fprintf(stderr, "gsr warning: gsr_damage_set_target_monitor: failed to find monitor: %s\n", monitor_name); + } + + if(self->window) + XSelectInput(self->display, self->window, 0); + + self->window = DefaultRootWindow(self->display); + self->damage = XDamageCreate(self->display, self->window, XDamageReportNonEmpty); + if(self->damage) { + XDamageSubtract(self->display, self->damage, None, None); + self->damaged = true; + snprintf(self->monitor_name, sizeof(self->monitor_name), "%s", monitor_name); + self->track_type = GSR_DAMAGE_TRACK_MONITOR; + return true; + } else { + fprintf(stderr, "gsr warning: gsr_damage_set_target_monitor: XDamageCreate failed\n"); + self->track_type = GSR_DAMAGE_TRACK_NONE; + return false; + } +} + +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 || self->monitor.monitor_identifier == 0) + return; + + if(rr_crtc_change_event->crtc != self->monitor.monitor_identifier) + return; + + if(rr_crtc_change_event->width == 0 || rr_crtc_change_event->height == 0) + return; + + if(rr_crtc_change_event->x != self->monitor.pos.x || rr_crtc_change_event->y != self->monitor.pos.y || + (int)rr_crtc_change_event->width != self->monitor.size.x || (int)rr_crtc_change_event->height != self->monitor.size.y) { + self->monitor.pos.x = rr_crtc_change_event->x; + self->monitor.pos.y = rr_crtc_change_event->y; + + self->monitor.size.x = rr_crtc_change_event->width; + self->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 || self->monitor.monitor_identifier == 0) + return; + + XRRScreenResources *screen_res = XRRGetScreenResources(self->display, DefaultRootWindow(self->display)); + if(!screen_res) + return; + + // TODO: What about scaled output? look at for_each_active_monitor_output_x11_not_cached + XRROutputInfo *out_info = XRRGetOutputInfo(self->display, screen_res, rr_output_change_event->output); + if(out_info && out_info->crtc && out_info->crtc == self->monitor.monitor_identifier) { + XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(self->display, screen_res, out_info->crtc); + if(crtc_info && (crtc_info->x != self->monitor.pos.x || crtc_info->y != self->monitor.pos.y || + (int)crtc_info->width != self->monitor.size.x || (int)crtc_info->height != self->monitor.size.y)) + { + self->monitor.pos.x = crtc_info->x; + self->monitor.pos.y = crtc_info->y; + + self->monitor.size.x = crtc_info->width; + self->monitor.size.y = crtc_info->height; + } + + if(crtc_info) + XRRFreeCrtcInfo(crtc_info); + } + + if(out_info) + XRRFreeOutputInfo(out_info); + + XRRFreeScreenResources(screen_res); +} + +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->track_type == GSR_DAMAGE_TRACK_WINDOW || (self->track_type == GSR_DAMAGE_TRACK_MONITOR && self->monitor.connector_id == 0)) { + self->damaged = true; + } else { + int num_rectangles = 0; + XRectangle *rectangles = XFixesFetchRegion(self->display, region, &num_rectangles); + if(rectangles) { + const gsr_rectangle monitor_region = { self->monitor.pos, self->monitor.size }; + 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} }; + self->damaged = rectangles_intersect(monitor_region, damage_region); + if(self->damaged) + break; + } + XFree(rectangles); + } + } + + XFixesDestroyRegion(self->display, region); + XFlush(self->display); +} + +static void gsr_damage_on_tick_cursor(gsr_damage *self) { + vec2i prev_cursor_pos = self->cursor.position; + gsr_cursor_tick(&self->cursor, self->window); + if(self->cursor.position.x != prev_cursor_pos.x || self->cursor.position.y != prev_cursor_pos.y) { + const gsr_rectangle cursor_region = { self->cursor.position, self->cursor.size }; + switch(self->track_type) { + case GSR_DAMAGE_TRACK_NONE: { + self->damaged = true; + break; + } + case GSR_DAMAGE_TRACK_WINDOW: { + const gsr_rectangle window_region = { (vec2i){0, 0}, self->window_size }; + self->damaged = self->window_size.x == 0 || rectangles_intersect(window_region, cursor_region); + break; + } + case GSR_DAMAGE_TRACK_MONITOR: { + const gsr_rectangle monitor_region = { self->monitor.pos, self->monitor.size }; + self->damaged = self->monitor.monitor_identifier == 0 || rectangles_intersect(monitor_region, cursor_region); + break; + } + } + } +} + +static void gsr_damage_on_window_configure_notify(gsr_damage *self, XEvent *xev) { + if(xev->xconfigure.window != self->window) + return; + + //self->window_pos.x = xev->xconfigure.x; + //self->window_pos.y = xev->xconfigure.y; + + self->window_size.x = xev->xconfigure.width; + self->window_size.y = xev->xconfigure.height; +} + +void gsr_damage_on_event(gsr_damage *self, XEvent *xev) { + if(self->damage_event == 0 || self->track_type == GSR_DAMAGE_TRACK_NONE) + return; + + if(self->track_type == GSR_DAMAGE_TRACK_WINDOW && 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); + + if(self->track_cursor) + gsr_cursor_on_event(&self->cursor, xev); +} + +void gsr_damage_tick(gsr_damage *self) { + if(self->damage_event == 0 || self->track_type == GSR_DAMAGE_TRACK_NONE) + 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->damage || self->damaged || self->track_type == GSR_DAMAGE_TRACK_NONE; +} + +void gsr_damage_clear(gsr_damage *self) { + self->damaged = false; +} |