ltkx

ltk.c (16253B)

---

 /*
  * This file is part of the Lumidify ToolKit (LTK)
  * Copyright (c) 2016, 2017, 2018, 2020 lumidify <nobody@lumidify.org>
  *
  * 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 <stdio.h>
 #include <stdlib.h>
 #include "ini.h"
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include "khash.h"
 #include "stb_truetype.h"
 #include <fribidi.h>
 #include <harfbuzz/hb.h>
 #include <fontconfig/fontconfig.h>
 #include "array.h"
 #include "text_common.h"
 #include "ltk.h"
 #include "text_buffer.h"
 
 /* Window hash */
 KHASH_MAP_INIT_INT(winhash, LtkWindow*)
 
 static struct {
 	LtkTheme *theme;
 	LtkTextManager *tm;
 	Display *display;
 	int screen;
 	Colormap colormap;
 	khash_t(winhash) *window_hash;
 	int window_num;
 	Atom wm_delete_msg;
 } ltk_global;
 
 struct ltk_redraw_queue {
 	LtkWindow *window;
 	LtkRect rect;
 };
 
 LtkTextManager *
 ltk_get_text_manager(void) {
 	return ltk_global.tm;
 }
 
 LtkTheme *
 ltk_get_theme(void) {
 	return ltk_global.theme;
 }
 
 Display *
 ltk_get_display(void) {
 	return ltk_global.display;
 }
 
 Colormap
 ltk_get_colormap(void) {
 	return ltk_global.colormap;
 }
 
 static struct ltk_redraw_queue *redraw_queue = NULL;
 static int num_redraws = 0;
 static int redraw_queue_bufsize = 0;
 
 static LtkRect
 ltk_rect_union(LtkRect r1, LtkRect r2) {
 	LtkRect u;
 	u.x = r1.x < r2.x ? r1.x : r2.x;
 	u.y = r1.y < r2.y ? r1.y : r2.y;
 	int x2 = r1.x + r1.w < r2.x + r2.w ? r2.x + r2.w : r1.x + r1.w;
 	int y2 = r1.y + r1.h < r2.y + r2.h ? r2.y + r2.h : r1.y + r1.h;
 	u.w = x2 - u.x;
 	u.h = y2 - u.y;
 	return u;
 }
 
 void
 ltk_window_invalidate_rect(LtkWindow *window, LtkRect rect) {
 	int index = -1;
 	if (redraw_queue) {
 		for (int i = 0; i < num_redraws; i++) {
 			if (redraw_queue[i].window == window) {
 				index = i;
 				break;
 			}
 		}
 	}
 	if (index == -1) {
 		if (num_redraws == redraw_queue_bufsize) {
 			struct ltk_redraw_queue *tmp = realloc(
 			    redraw_queue, sizeof(struct ltk_redraw_queue) * (redraw_queue_bufsize + 1));
 			if (!tmp) goto error;
 			redraw_queue = tmp;
 			redraw_queue_bufsize++;
 		}
 		index = num_redraws;
 		num_redraws++;
 		redraw_queue[index].window = window;
 		redraw_queue[index].rect = rect;
 	} else {
 		redraw_queue[index].rect = ltk_rect_union(rect, redraw_queue[index].rect);
 	}
 
 	return;
 error:
 	(void)fprintf(stderr, "Out of memory\n");
 	exit(1);
 }
 
 void
 ltk_widget_set_floating_collision(LtkWidget *widget) {
 	LtkWindow *window = widget->window;
 	for (int i = 0; i < window->num_float_widgets; i++) {
 		if (window->float_widgets[i] == widget)
 			return;
 	}
 	if (window->num_float_widgets + 1 > window->max_float_widgets) {
 		LtkWidget **new = realloc(
 		    window->float_widgets,
 		    sizeof(LtkWidget *) * (window->max_float_widgets + 1));
 		if (!new) goto error;
 		window->float_widgets = new;
 		window->max_float_widgets++;
 	}
 	window->float_widgets[window->num_float_widgets] = widget;
 	window->num_float_widgets++;
 	return;
 error:
 	(void)fprintf(stderr, "Out of memory\n");
 	exit(1);
 }
 
 void
 ltk_widget_unset_floating_collision(LtkWidget *widget) {
 	LtkWindow *window = widget->window;
 	for (int i = 0; i < window->num_float_widgets; i++) {
 		if (window->float_widgets[i] == widget) {
 			for (int j = i + 1; j < window->num_float_widgets; j++) {
 				window->float_widgets[j - 1] = window->float_widgets[j];
 			}
 			window->num_float_widgets--;
 			break;
 		}
 	}
 }
 
 void
 ltk_init(const char *theme_path) {
 	ltk_global.display = XOpenDisplay(NULL);
 	ltk_global.screen = DefaultScreen(ltk_global.display);
 	ltk_global.colormap = DefaultColormap(ltk_global.display, ltk_global.screen);
 	ltk_global.theme = ltk_load_theme(theme_path);
 	ltk_global.window_hash = kh_init(winhash);
 	ltk_global.wm_delete_msg = XInternAtom(ltk_global.display, "WM_DELETE_WINDOW", False);
 	ltk_global.tm = ltk_init_text(ltk_global.theme->window->font);
 }
 
 void
 ltk_clean_up(void) {
 	LtkWindow *window;
 	for (int k = kh_begin(ltk_global.window_hash); k != kh_end(ltk_global.window_hash); k++) {
 		if (kh_exist(ltk_global.window_hash, k)) {
 			ltk_destroy_window(kh_value(ltk_global.window_hash, k));
 		}
 	}
 	kh_destroy(winhash, ltk_global.window_hash);
 	XCloseDisplay(ltk_global.display);
 	ltk_destroy_theme(ltk_global.theme);
 	ltk_destroy_text_manager(ltk_global.tm);
 	if (redraw_queue) free(redraw_queue);
 }
 
 void
 ltk_quit(void) {
 	ltk_clean_up();
 	exit(0);
 }
 
 void
 ltk_fatal(const char *msg) {
 	(void)fprintf(stderr, msg);
 	ltk_clean_up();
 	exit(1);
 };
 
 XColor
 ltk_create_xcolor(const char *hex) {
 	XColor color;
 	XParseColor(ltk_global.display, ltk_global.colormap, hex,
 		    &color);
 	XAllocColor(ltk_global.display, ltk_global.colormap, &color);
 
 	return color;
 }
 
 void
 ltk_mainloop(void) {
 	XEvent event;
 	KeySym key;
 	char text[255];
 
 	/* FIXME: compress motion events */
 	while (1) {
 		if (XPending(ltk_global.display) || !num_redraws) {
 			XNextEvent(ltk_global.display, &event);
 			ltk_handle_event(event);
 		} else if (num_redraws) {
 			for (int i = 0; i < num_redraws; i++)
 				ltk_redraw_window(redraw_queue[i].window, redraw_queue[i].rect);
 			num_redraws = 0;
 		}
 	}
 }
 
 void
 ltk_redraw_window(LtkWindow *window, LtkRect rect) {
 	LtkWidget *ptr;
 	if (!window) return;
 	if (rect.x >= window->rect.w) return;
 	if (rect.y >= window->rect.h) return;
 	if (rect.x + rect.w > window->rect.w)
 		rect.w -= rect.x + rect.w - window->rect.w;
 	if (rect.y + rect.h > window->rect.h)
 		rect.h -= rect.y + rect.h - window->rect.h;
 	XClearArea(ltk_global.display, window->xwindow, rect.x, rect.y, rect.w, rect.h, False);
 	if (!window->root_widget) return;
 	ptr = window->root_widget;
 	ptr->draw(ptr);
 }
 
 LtkWindow *
 ltk_create_window(const char *title, int x, int y, unsigned int w, unsigned int h) {
 	LtkWindow *window = malloc(sizeof(LtkWindow));
 	if (!window)
 		ltk_fatal("Not enough memory left for window!\n");
 	LtkWindowTheme *wtheme = ltk_global.theme->window;	/* For convenience */
 	Display *display = ltk_global.display;	/* For convenience */
 	window->xwindow =
 	    XCreateSimpleWindow(display, DefaultRootWindow(display), x, y,
 				w, h, wtheme->border_width,
 				wtheme->fg.pixel, wtheme->bg.pixel);
 	window->gc = XCreateGC(display, window->xwindow, 0, 0);
 	XSetForeground(display, window->gc, wtheme->fg.pixel);
 	XSetBackground(display, window->gc, wtheme->bg.pixel);
 	XSetStandardProperties(display, window->xwindow, title, NULL, None,
 			       NULL, 0, NULL);
 	XSetWMProtocols(display, window->xwindow,
 			&ltk_global.wm_delete_msg, 1);
 	window->root_widget = NULL;
 
 	window->other_event = &ltk_window_other_event;
 
 	window->rect.w = 0;
 	window->rect.h = 0;
 	window->rect.x = 0;
 	window->rect.y = 0;
 
 	window->num_float_widgets = 0;
 	window->max_float_widgets = 0;
 	window->float_widgets = NULL;
 
 	XClearWindow(display, window->xwindow);
 	XMapRaised(display, window->xwindow);
 	XSelectInput(display, window->xwindow,
 		     ExposureMask | KeyPressMask | KeyReleaseMask |
 		     ButtonPressMask | ButtonReleaseMask |
 		     StructureNotifyMask | PointerMotionMask);
 
 	int ret;
 	int k = kh_put(winhash, ltk_global.window_hash, window->xwindow, &ret);
 	kh_value(ltk_global.window_hash, k) = window;
 	ltk_global.window_num++;
 
 	return window;
 }
 
 void
 ltk_remove_window(LtkWindow *window) {
 	/* FIXME: also remove from event queue */
 	ltk_destroy_window(window);
 	if (ltk_global.window_num == 0)
 		ltk_quit();
 }
 
 void
 ltk_destroy_window(LtkWindow * window) {
 	int k = kh_get(winhash, ltk_global.window_hash, window->xwindow);
 	kh_del(winhash, ltk_global.window_hash, k);
 	LtkWidget *ptr = window->root_widget;
 	if (ptr)
 		ptr->destroy(ptr);
 	XDestroyWindow(ltk_global.display, window->xwindow);
 	free(window);
 	ltk_global.window_num--;
 }
 
 void
 ltk_window_other_event(LtkWindow *window, XEvent event) {
 	LtkWidget *ptr = window->root_widget;
 	int retval = 0;
 	if (event.type == ConfigureNotify) {
 		unsigned int w, h;
 		w = event.xconfigure.width;
 		h = event.xconfigure.height;
 		int orig_w = window->rect.w;
 		int orig_h = window->rect.h;
 		if (ptr && ptr->resize
 		    && (orig_w != w || orig_h != h)) {
 			window->rect.w = w;
 			window->rect.h = h;
 			ptr->rect.w = w;
 			ptr->rect.h = h;
 			ptr->resize(ptr, orig_w, orig_h);
 		}
 	} else if (event.type == Expose && event.xexpose.count == 0) {
 		LtkRect r;
 		r.x = event.xexpose.x;
 		r.y = event.xexpose.y;
 		r.w = event.xexpose.width;
 		r.h = event.xexpose.height;
 		ltk_window_invalidate_rect(window, r);
 	} else if (event.type == ClientMessage
 	    && event.xclient.data.l[0] == ltk_global.wm_delete_msg) {
 		ltk_remove_window(window);
 	}
 }
 
 void
 ltk_window_ini_handler(LtkTheme *theme, const char *prop, const char *value) {
 	if (strcmp(prop, "border_width") == 0) {
 		theme->window->border_width = atoi(value);
 	} else if (strcmp(prop, "bg") == 0) {
 		theme->window->bg = ltk_create_xcolor(value);
 	} else if (strcmp(prop, "fg") == 0) {
 		theme->window->fg = ltk_create_xcolor(value);
 	} else if (strcmp(prop, "font") == 0) {
 		theme->window->font = strdup(value);
 	}
 }
 
 int
 ltk_ini_handler(void *theme, const char *widget, const char *prop, const char *value) {
 	if (strcmp(widget, "window") == 0) {
 		ltk_window_ini_handler(theme, prop, value);
 	} else if (strcmp(widget, "button") == 0) {
 		ltk_button_ini_handler(theme, prop, value);
 	}
 }
 
 LtkTheme *
 ltk_load_theme(const char *path) {
 	LtkTheme *theme = malloc(sizeof(LtkTheme));
 	theme->window = malloc(sizeof(LtkWindowTheme));
 	theme->button = NULL;
 	if (ini_parse(path, ltk_ini_handler, theme) < 0) {
 		(void)fprintf(stderr, "ERROR: Can't load theme %s\n.", path);
 		exit(1);
 	}
 
 	return theme;
 }
 
 void
 ltk_destroy_theme(LtkTheme * theme) {
 	free(theme->button);
 	free(theme->window);
 	free(theme);
 }
 
 char *
 ltk_read_file(const char *path, unsigned long *len) {
 	FILE *f;
 	char *file_contents;
 	f = fopen(path, "rb");
 	fseek(f, 0, SEEK_END);
 	*len = ftell(f);
 	fseek(f, 0, SEEK_SET);
 	file_contents = malloc(*len + 1);
 	fread(file_contents, 1, *len, f);
 	file_contents[*len] = '\0';
 	fclose(f);
 
 	return file_contents;
 }
 
 int
 ltk_collide_rect(LtkRect rect, int x, int y) {
 	return (rect.x <= x && (rect.x + rect.w) >= x && rect.y <= y
 		&& (rect.y + rect.h) >= y);
 }
 
 void
 ltk_remove_active_widget(void *widget) {
 	if (!widget)
 		return;
 	LtkWidget *parent = widget;
 	LtkWidget *child;
 	while (parent->active_widget) {
 		child = parent->active_widget;
 		child->state = LTK_NORMAL;
 		if (child->needs_redraw)
 			child->draw(child);
 		parent->active_widget = NULL;
 		parent = child;
 	}
 }
 
 void
 ltk_change_active_widget_state(void *widget, LtkWidgetState state) {
 	if (!widget)
 		return;
 	LtkWidget *ptr = widget;
 	while (ptr = ptr->active_widget) {
 		ptr->state = state;
 		ptr->draw(ptr);
 	}
 }
 
 void
 ltk_remove_hover_widget(void *widget) {
 	if (!widget)
 		return;
 	LtkWidget *parent = widget;
 	LtkWidget *child;
 	while (parent->hover_widget) {
 		child = parent->hover_widget;
 		child->state =
 		    child->state ==
 		    LTK_HOVERACTIVE ? LTK_ACTIVE : LTK_NORMAL;
 		child->draw(child);
 		parent->hover_widget = NULL;
 		parent = child;
 	}
 }
 
 void
 ltk_fill_widget_defaults(LtkWidget *widget, LtkWindow *window,
     void (*draw) (void *), void (*destroy) (void *), unsigned int needs_redraw) {
 	widget->window = window;
 	widget->active_widget = NULL;
 	widget->hover_widget = NULL;
 	widget->parent = NULL;
 
 	widget->key_press = NULL;
 	widget->key_release = NULL;
 	widget->mouse_press = NULL;
 	widget->mouse_release = NULL;
 	widget->motion_notify = NULL;
 
 	widget->resize = NULL;
 	widget->draw = draw;
 	widget->destroy = destroy;
 
 	widget->needs_redraw = needs_redraw;
 	widget->state = LTK_NORMAL;
 	widget->row = 0;
 	widget->rect.x = 0;
 	widget->rect.y = 0;
 	widget->rect.w = 100;
 	widget->rect.h = 100;
 	widget->collision_rect.x = 0;
 	widget->collision_rect.y = 0;
 	widget->collision_rect.w = 0;
 	widget->collision_rect.h = 0;
 
 	widget->row = NULL;
 	widget->column = NULL;
 	widget->row_span = NULL;
 	widget->column_span = NULL;
 	widget->sticky = 0;
 }
 
 void
 ltk_widget_mouse_press_event(void *widget, XEvent event) {
 	LtkWidget *ptr = widget;
 	if (!ptr || ptr->state == LTK_DISABLED)
 		return;
 	if (event.xbutton.button == 1) {
 		LtkWidget *parent = ptr->parent;
 		if (parent) {
 			ltk_remove_active_widget(parent);
 			parent->active_widget = ptr;
 		}
 		ptr->state = LTK_PRESSED;
 		if (ptr->needs_redraw)
 			ptr->draw(ptr);
 	}
 	if (ptr->mouse_press) {
 		ptr->mouse_press(ptr, event);
 	}
 }
 
 void
 ltk_window_mouse_press_event(LtkWindow *window, XEvent event) {
 	if (window->float_widgets) {
 		int x = event.xbutton.x;
 		int y = event.xbutton.y;
 		for (int i = 0; i < window->num_float_widgets; i++) {
 			if (ltk_collide_rect(window->float_widgets[i]->collision_rect, x, y)) {
 				ltk_widget_mouse_press_event(window->float_widgets[i], event);
 				return;
 			}
 		}
 	}
 	if (window->root_widget) {
 		ltk_widget_mouse_press_event(window->root_widget, event);
 	}
 }
 
 void
 ltk_widget_mouse_release_event(void *widget, XEvent event) {
 	LtkWidget *ptr = widget;
 	if (!ptr || ptr->state == LTK_DISABLED)
 		return;
 	if (ptr->state == LTK_PRESSED) {
 		ptr->state = LTK_HOVERACTIVE;
 		if (ptr->needs_redraw)
 			ptr->draw(ptr);
 	}
 	if (ptr->mouse_release) {
 		ptr->mouse_release(ptr, event);
 	}
 }
 
 void
 ltk_window_mouse_release_event(LtkWindow *window, XEvent event) {
 	if (window->float_widgets) {
 		int x = event.xbutton.x;
 		int y = event.xbutton.y;
 		for (int i = 0; i < window->num_float_widgets; i++) {
 			if (ltk_collide_rect(window->float_widgets[i]->collision_rect, x, y)) {
 				ltk_widget_mouse_release_event(window->float_widgets[i], event);
 				return;
 			}
 		}
 	}
 	if (window->root_widget) {
 		ltk_widget_mouse_release_event(window->root_widget, event);
 	}
 }
 
 void
 ltk_widget_motion_notify_event(void *widget, XEvent event) {
 	LtkWidget *ptr = widget;
 	LtkWidget *parent;
 	if (!ptr) return;
 	short pressed = (event.xmotion.state & Button1Mask) == Button1Mask;
 	if ((ptr->state == LTK_NORMAL || ptr->state == LTK_ACTIVE)
 	    && !pressed) {
 		ptr->state =
 		    ptr->state == LTK_ACTIVE ? LTK_HOVERACTIVE : LTK_HOVER;
 		parent = ptr->parent;
 		if (parent) {
 			ltk_remove_hover_widget(parent);
 			parent->hover_widget = ptr;
 		}
 		if (ptr->needs_redraw)
 			ptr->draw(ptr);
 	}
 	if (ptr->motion_notify)
 		ptr->motion_notify(ptr, event);
 }
 
 void
 ltk_window_motion_notify_event(LtkWindow *window, XEvent event) {
 	if (window->float_widgets) {
 		int x = event.xbutton.x;
 		int y = event.xbutton.y;
 		for (int i = 0; i < window->num_float_widgets; i++) {
 			if (ltk_collide_rect(window->float_widgets[i]->collision_rect, x, y)) {
 				ltk_widget_motion_notify_event(window->float_widgets[i], event);
 				return;
 			}
 		}
 	}
 	if (window->root_widget) {
 		ltk_widget_motion_notify_event(window->root_widget, event);
 	}
 }
 
 void
 ltk_handle_event(XEvent event) {
 	LtkWidget *root_widget;
 	int k = kh_get(winhash, ltk_global.window_hash, event.xany.window);
 	LtkWindow *window = kh_value(ltk_global.window_hash, k);
 	if (!window) return;
 	switch (event.type) {
 	case KeyPress:
 		break;
 	case KeyRelease:
 		break;
 	case ButtonPress:
 		ltk_window_mouse_press_event(window, event);
 		break;
 	case ButtonRelease:
 		ltk_window_mouse_release_event(window, event);
 		break;
 	case MotionNotify:
 		ltk_window_motion_notify_event(window, event);
 		break;
 	default:
 		/* FIXME: users should be able to register other events like closing the window */
 		if (window->other_event)
 			window->other_event(window, event);
 	}
 }