From 72869a4220ab321fd893e93fbec4532aa3892f8f Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Fri, 21 May 2021 21:08:30 +0200
Subject: GUI improvements and leak reduction

---
 libs/libgui/gfx.c |  85 +++++++++++++++++++---------
 libs/libgui/gfx.h |  31 +++++++++--
 libs/libgui/gui.c | 163 +++++++++++++++++++++++++++++++++++++++++++++---------
 libs/libgui/gui.h |  30 ++++++++++
 libs/libgui/msg.h |   7 ++-
 5 files changed, 259 insertions(+), 57 deletions(-)

(limited to 'libs')

diff --git a/libs/libgui/gfx.c b/libs/libgui/gfx.c
index d963a1b..fe8cf1e 100644
--- a/libs/libgui/gfx.c
+++ b/libs/libgui/gfx.c
@@ -72,7 +72,7 @@ static void free_fonts(void)
 
 static void write_char(struct context *ctx, vec2 pos, struct font *font, u32 c, char ch)
 {
-	int bypp = ctx->bpp >> 3;
+	u8 bypp = ctx->bpp >> 3;
 
 	char *draw = (char *)&ctx->fb[pos.x * bypp + pos.y * ctx->pitch];
 
@@ -262,10 +262,20 @@ void gfx_load_wallpaper(struct context *ctx, const char *path)
 	gfx_load_image(ctx, vec2(0, 0), path);
 }
 
+void gfx_draw_pixel(struct context *ctx, vec2 pos1, u32 c)
+{
+	u8 bypp = ctx->bpp >> 3;
+	u8 *draw = &ctx->fb[pos1.x * bypp + pos1.y * ctx->pitch];
+	draw[0] = GET_BLUE(c);
+	draw[1] = GET_GREEN(c);
+	draw[2] = GET_RED(c);
+	draw[3] = GET_ALPHA(c);
+}
+
 void gfx_draw_rectangle(struct context *ctx, vec2 pos1, vec2 pos2, u32 c)
 {
 	assert(pos1.x <= pos2.x && pos1.y <= pos2.y);
-	int bypp = ctx->bpp >> 3;
+	u8 bypp = ctx->bpp >> 3;
 	u8 *draw = &ctx->fb[pos1.x * bypp + pos1.y * ctx->pitch];
 	for (u32 i = 0; i < pos2.y - pos1.y; i++) {
 		for (u32 j = 0; j < pos2.x - pos1.x; j++) {
@@ -278,9 +288,54 @@ void gfx_draw_rectangle(struct context *ctx, vec2 pos1, vec2 pos2, u32 c)
 	}
 }
 
+void gfx_draw_border(struct context *ctx, u32 width, u32 c)
+{
+	if (width <= 0)
+		return;
+
+	u8 bypp = ctx->bpp >> 3;
+	u8 *draw = ctx->fb;
+	for (u32 i = 0; i < ctx->size.y; i++) {
+		for (u32 j = 0; j < ctx->size.x; j++) {
+			if (j <= width - 1 || i <= width - 1 || j - ctx->size.x + width <= width ||
+			    i - ctx->size.y + width <= width) {
+				draw[bypp * j + 0] = GET_BLUE(c);
+				draw[bypp * j + 1] = GET_GREEN(c);
+				draw[bypp * j + 2] = GET_RED(c);
+				draw[bypp * j + 3] = GET_ALPHA(c);
+			}
+		}
+		draw += ctx->pitch;
+	}
+}
+
+// Using Bresenham's algorithm
+void gfx_draw_line(struct context *ctx, vec2 pos1, vec2 pos2, u32 scale, u32 c)
+{
+	int dx = ABS(pos2.x - pos1.x), sx = pos1.x < pos2.x ? 1 : -1;
+	int dy = ABS(pos2.y - pos1.y), sy = pos1.y < pos2.y ? 1 : -1;
+	int err = (dx > dy ? dx : -dy) / 2, e2;
+
+	while (1) {
+		gfx_draw_rectangle(ctx, pos1, vec2_add(pos1, vec2(scale, scale)), c);
+		/* gfx_draw_pixel(ctx, pos1, c); */
+		if (pos1.x == pos2.x && pos1.y == pos2.y)
+			break;
+		e2 = err;
+		if (e2 > -dx) {
+			err -= dy;
+			pos1.x += sx;
+		}
+		if (e2 < dy) {
+			err += dx;
+			pos1.y += sy;
+		}
+	}
+}
+
 void gfx_copy(struct context *dest, struct context *src, vec2 pos, vec2 size)
 {
-	int bypp = dest->bpp >> 3;
+	u8 bypp = dest->bpp >> 3;
 	u8 *srcfb = &src->fb[pos.x * bypp + pos.y * src->pitch];
 	u8 *destfb = &dest->fb[pos.x * bypp + pos.y * dest->pitch];
 	for (u32 cy = 0; cy < size.y; cy++) {
@@ -292,7 +347,7 @@ void gfx_copy(struct context *dest, struct context *src, vec2 pos, vec2 size)
 
 // TODO: Support alpha values other than 0x0 and 0xff (blending)
 // TODO: Optimize!
-void gfx_ctx_on_ctx(struct context *dest, struct context *src, vec2 pos, u8 alpha)
+HOT void gfx_ctx_on_ctx(struct context *dest, struct context *src, vec2 pos, u8 alpha)
 {
 	// TODO: Some kind of alpha-acknowledging memcpy?
 	if (!alpha && src->size.x == dest->size.x && src->size.y == dest->size.y) {
@@ -332,28 +387,6 @@ void gfx_fill(struct context *ctx, u32 c)
 	gfx_draw_rectangle(ctx, vec2(0, 0), vec2(ctx->size.x, ctx->size.y), c);
 }
 
-void gfx_border(struct context *ctx, u32 c, u32 width)
-{
-	if (width <= 0)
-		return;
-
-	int bypp = ctx->bpp >> 3;
-	u8 *draw = ctx->fb;
-	for (u32 i = 0; i < ctx->size.y; i++) {
-		for (u32 j = 0; j < ctx->size.x; j++) {
-			if (j <= width - 1 || i <= width - 1 ||
-			    j - ctx->size.x + width + 1 <= width ||
-			    i - ctx->size.y + width <= width) {
-				draw[bypp * j + 0] = GET_BLUE(c);
-				draw[bypp * j + 1] = GET_GREEN(c);
-				draw[bypp * j + 2] = GET_RED(c);
-				draw[bypp * j + 3] = GET_ALPHA(c);
-			}
-		}
-		draw += ctx->pitch;
-	}
-}
-
 int gfx_font_height(enum font_type font_type)
 {
 	struct font *font = gfx_resolve_font(font_type);
diff --git a/libs/libgui/gfx.h b/libs/libgui/gfx.h
index eb98578..7c069f4 100644
--- a/libs/libgui/gfx.h
+++ b/libs/libgui/gfx.h
@@ -73,23 +73,46 @@ struct context {
 };
 
 struct context *gfx_new_ctx(struct context *ctx, vec2 size, u8 bpp) NONNULL;
+
+/**
+ * Text stuff
+ */
+
 struct font *gfx_resolve_font(enum font_type font_type);
 void gfx_write_char(struct context *ctx, vec2 pos, enum font_type font_type, u32 c,
 		    char ch) NONNULL;
 void gfx_write(struct context *ctx, vec2 pos, enum font_type font_type, u32 c,
 	       const char *text) NONNULL;
+
+int gfx_font_height(enum font_type);
+int gfx_font_width(enum font_type);
+
+/**
+ * Image loading
+ */
+
 void gfx_load_image(struct context *ctx, vec2 pos, const char *path) NONNULL;
 void gfx_load_image_filter(struct context *ctx, vec2 pos, enum gfx_filter filter,
 			   const char *path) NONNULL;
 void gfx_load_wallpaper(struct context *ctx, const char *path) NONNULL;
+
+/**
+ * Context copying
+ */
+
 void gfx_copy(struct context *dest, struct context *src, vec2 pos, vec2 size) NONNULL;
 void gfx_ctx_on_ctx(struct context *dest, struct context *src, vec2 pos, u8 alpha) NONNULL;
+
+/**
+ * Drawing functions
+ */
+
+void gfx_draw_pixel(struct context *ctx, vec2 pos1, u32 c);
 void gfx_draw_rectangle(struct context *ctx, vec2 pos1, vec2 pos2, u32 c) NONNULL;
+void gfx_draw_line(struct context *ctx, vec2 pos1, vec2 pos2, u32 scale, u32 c);
+
 void gfx_clear(struct context *ctx);
 void gfx_fill(struct context *ctx, u32 c) NONNULL;
-void gfx_border(struct context *ctx, u32 c, u32 width) NONNULL;
-
-int gfx_font_height(enum font_type);
-int gfx_font_width(enum font_type);
+void gfx_draw_border(struct context *ctx, u32 width, u32 c) NONNULL;
 
 #endif
diff --git a/libs/libgui/gui.c b/libs/libgui/gui.c
index 023bc98..859fb5a 100644
--- a/libs/libgui/gui.c
+++ b/libs/libgui/gui.c
@@ -17,13 +17,14 @@ struct gui_widget {
 	struct list *children;
 
 	struct {
-		void (*mousemove)(u32 widget_id, vec2 pos);
-		void (*mouseclick)(u32 widget_id, vec2 pos);
+		void (*mousemove)(struct gui_event_mouse *event);
+		void (*mouseclick)(struct gui_event_mouse *event);
 	} event;
 };
 
 struct gui_window {
 	u32 id;
+	vec2 off; // fb offset
 	vec2 pos;
 	struct context ctx;
 	struct list *widgets;
@@ -190,6 +191,50 @@ void gui_load_image(u32 win_id, u32 widget_id, enum gui_layer layer, vec2 pos, v
 	gui_load_image_filter(win_id, widget_id, layer, pos, size, GFX_FILTER_NONE, path);
 }
 
+void gui_draw_rectangle(u32 win_id, u32 widget_id, enum gui_layer layer, vec2 pos1, vec2 pos2,
+			u32 c)
+{
+	struct gui_widget *widget = gui_widget_by_id(win_id, widget_id);
+	if (!widget)
+		gui_error(ENOENT);
+
+	if (layer == GUI_LAYER_BG)
+		gfx_draw_rectangle(&widget->bg, pos1, pos2, c);
+	else if (layer == GUI_LAYER_FG)
+		gfx_draw_rectangle(&widget->fg, pos1, pos2, c);
+	else
+		gui_error(EINVAL);
+}
+
+void gui_draw_border(u32 win_id, u32 widget_id, enum gui_layer layer, u32 width, u32 c)
+{
+	struct gui_widget *widget = gui_widget_by_id(win_id, widget_id);
+	if (!widget)
+		gui_error(ENOENT);
+
+	if (layer == GUI_LAYER_BG)
+		gfx_draw_border(&widget->bg, width, c);
+	else if (layer == GUI_LAYER_FG)
+		gfx_draw_border(&widget->fg, width, c);
+	else
+		gui_error(EINVAL);
+}
+
+void gui_draw_line(u32 win_id, u32 widget_id, enum gui_layer layer, vec2 pos1, vec2 pos2, u32 scale,
+		   u32 c)
+{
+	struct gui_widget *widget = gui_widget_by_id(win_id, widget_id);
+	if (!widget)
+		gui_error(ENOENT);
+
+	if (layer == GUI_LAYER_BG)
+		gfx_draw_line(&widget->bg, pos1, pos2, scale, c);
+	else if (layer == GUI_LAYER_FG)
+		gfx_draw_line(&widget->fg, pos1, pos2, scale, c);
+	else
+		gui_error(EINVAL);
+}
+
 /**
  * Widgets
  */
@@ -266,6 +311,7 @@ static void gui_sync_sub_widgets(struct gui_widget *widget)
 	struct node *iterator = widget->children->head;
 	while (iterator) {
 		struct gui_widget *w = iterator->data;
+		gui_sync_sub_widgets(w);
 		gfx_ctx_on_ctx(&widget->bg, &w->bg, w->pos, GFX_NON_ALPHA);
 		gfx_ctx_on_ctx(&widget->fg, &w->fg, w->pos, GFX_NON_ALPHA);
 		iterator = iterator->next;
@@ -346,14 +392,14 @@ static vec2 gui_offset_widget(struct gui_widget *parent, struct gui_widget *chil
 static struct gui_widget *gui_new_plain_widget(vec2 pos, vec2 size, u8 bpp)
 {
 	struct gui_widget *widget = zalloc(sizeof(*widget));
-	struct context *bg = zalloc(sizeof(*bg));
-	struct context *fg = zalloc(sizeof(*fg));
+	struct context bg;
+	struct context fg;
 
 	static u32 id = 0;
 	widget->id = id++;
 	widget->pos = pos;
-	widget->bg = *gfx_new_ctx(bg, size, bpp);
-	widget->fg = *gfx_new_ctx(fg, size, bpp);
+	widget->bg = *gfx_new_ctx(&bg, size, bpp);
+	widget->fg = *gfx_new_ctx(&fg, size, bpp);
 	widget->children = list_new();
 
 	return widget;
@@ -371,6 +417,41 @@ void gui_add_widget(u32 *widget, u32 win_id, u32 widget_id, vec2 pos, vec2 size)
 	*widget = child->id;
 }
 
+static void gui_destroy_widget(u32 win_id, u32 widget_id)
+{
+	struct gui_widget *widget = gui_widget_by_id(win_id, widget_id);
+	if (!widget)
+		return;
+
+	struct node *iterator = widget->children->head;
+	while (iterator) {
+		struct gui_widget *sub = iterator->data;
+		gui_destroy_widget(win_id, sub->id);
+		iterator = iterator->next;
+	}
+
+	list_destroy(widget->children);
+	free(widget->bg.fb);
+	free(widget->fg.fb);
+	free(widget);
+}
+
+static void gui_destroy_widgets(u32 win_id)
+{
+	struct gui_window *win = gui_window_by_id(win_id);
+
+	if (!win->widgets)
+		return;
+
+	struct node *iterator = win->widgets->head;
+	while (iterator) {
+		struct gui_widget *widget = iterator->data;
+		gui_destroy_widget(win_id, widget->id);
+		iterator = iterator->next;
+	}
+	list_destroy(win->widgets);
+}
+
 void gui_new_widget(u32 *widget, u32 win_id, vec2 pos, vec2 size)
 {
 	struct gui_window *win = gui_window_by_id(win_id);
@@ -391,10 +472,10 @@ void gui_listen_widget(u32 win_id, u32 widget_id, enum gui_listener listener, u3
 
 	switch (listener) {
 	case GUI_LISTEN_MOUSEMOVE:
-		widget->event.mousemove = (void (*)(u32, vec2))func;
+		widget->event.mousemove = (void (*)(struct gui_event_mouse *))func;
 		break;
 	case GUI_LISTEN_MOUSECLICK:
-		widget->event.mouseclick = (void (*)(u32, vec2))func;
+		widget->event.mouseclick = (void (*)(struct gui_event_mouse *))func;
 		break;
 	default:
 		gui_error(ENOENT);
@@ -404,7 +485,7 @@ void gui_listen_widget(u32 win_id, u32 widget_id, enum gui_listener listener, u3
 void gui_redraw_widget(u32 win_id, u32 widget_id)
 {
 	gui_sync_widget(win_id, widget_id);
-	gui_redraw_window(win_id);
+	gui_redraw_window_only(win_id);
 }
 
 /**
@@ -467,6 +548,7 @@ void gui_new_custom_window(u32 *id, vec2 pos, vec2 size)
 	if (msg_send(GUI_NEW_WINDOW, &msg, sizeof(msg)) > 0 && msg_receive(&msg, sizeof(msg)) > 0 &&
 	    msg.header.type == (GUI_NEW_WINDOW | MSG_SUCCESS)) {
 		win->id = msg.id;
+		win->off = msg.off;
 		win->ctx = msg.ctx;
 		win->pos = msg.pos;
 		u32 buf_size;
@@ -497,10 +579,8 @@ INLINE void gui_new_window(u32 *id)
 	gui_new_custom_window(id, vec2(0, 0), vec2(0, 0));
 }
 
-void gui_redraw_window(u32 id)
+void gui_redraw_window_only(u32 id)
 {
-	gui_sync_widgets(id);
-
 	struct message_redraw_window msg = { .id = id, .header.state = MSG_NEED_ANSWER };
 	gui_connect_wm();
 	if (msg_send(GUI_REDRAW_WINDOW, &msg, sizeof(msg)) > 0 &&
@@ -511,6 +591,37 @@ void gui_redraw_window(u32 id)
 	gui_error(EINVAL);
 }
 
+void gui_redraw_window(u32 id)
+{
+	gui_sync_widgets(id);
+	gui_redraw_window_only(id);
+}
+
+static void gui_destroy_window(u32 id)
+{
+	gui_destroy_widgets(id);
+
+	struct gui_window *win = gui_window_by_id(id);
+	u8 *fb = win->ctx.fb - (win->off.y * win->ctx.pitch);
+	assert(sys_free(fb) == EOK);
+	free(win);
+}
+
+static void gui_destroy_all(void)
+{
+	struct node *iterator = windows->head;
+	while (iterator) {
+		struct gui_window *win = iterator->data;
+		struct message_destroy_window msg = { .id = win->id };
+		gui_destroy_window(win->id);
+		gui_connect_wm();
+		msg_send(GUI_DESTROY_WINDOW, &msg, sizeof(msg));
+		iterator = iterator->next;
+	}
+
+	list_destroy(windows);
+}
+
 /**
  * Message handling
  */
@@ -542,12 +653,23 @@ static void gui_handle_mouse(struct message_mouse *msg)
 
 	struct gui_window *win = gui_window_by_id(msg->id);
 	vec2 offset = gui_offset_widget(gui_main_widget(win), &widget);
+	vec2 pos = vec2_sub(msg->pos, offset);
+
+	struct gui_event_mouse event = {
+		.win = win->id,
+		.widget = widget.id,
+		.pos = pos,
+		.scroll = msg->scroll,
+		.but.left = msg->but.left,
+		.but.right = msg->but.right,
+		.but.middle = msg->but.middle,
+	};
 
 	if (widget.event.mousemove)
-		widget.event.mousemove(widget.id, vec2_sub(msg->pos, offset));
+		widget.event.mousemove(&event);
 
-	if (widget.event.mouseclick && msg->bits.click)
-		widget.event.mouseclick(widget.id, vec2_sub(msg->pos, offset));
+	if (widget.event.mouseclick && msg->but.left)
+		widget.event.mouseclick(&event);
 }
 
 static void gui_handle_exit(void)
@@ -555,16 +677,7 @@ static void gui_handle_exit(void)
 	if (!windows)
 		return;
 
-	struct node *iterator = windows->head;
-	while (iterator) {
-		struct gui_window *win = iterator->data;
-		struct message_destroy_window msg = { .id = win->id };
-		gui_connect_wm();
-		msg_send(GUI_DESTROY_WINDOW, &msg, sizeof(msg));
-		iterator = iterator->next;
-	}
-
-	list_destroy(windows);
+	gui_destroy_all();
 }
 
 /**
diff --git a/libs/libgui/gui.h b/libs/libgui/gui.h
index c7dc24f..66c6733 100644
--- a/libs/libgui/gui.h
+++ b/libs/libgui/gui.h
@@ -18,9 +18,30 @@ enum gui_layer {
 	GUI_LAYER_FG,
 };
 
+struct gui_event_mouse {
+	u32 win;
+	u32 widget;
+	vec2 pos;
+	s8 scroll; // Dir: -1 neg, +1 pos
+	struct {
+		u8 left : 1;
+		u8 right : 1;
+		u8 middle : 1;
+	} but;
+};
+
+/**
+ * Window operations
+ */
+
 void gui_new_custom_window(u32 *id, vec2 pos, vec2 size);
 void gui_new_window(u32 *id);
 void gui_redraw_window(u32 id);
+void gui_redraw_window_only(u32 id); // Without widgets
+
+/**
+ * GFX wrappers
+ */
 
 void gui_clear(u32 win_id, u32 widget_id, enum gui_layer layer);
 void gui_fill(u32 win_id, u32 widget_id, enum gui_layer layer, u32 c);
@@ -30,6 +51,15 @@ void gui_load_image(u32 win_id, u32 widget_id, enum gui_layer layer, vec2 pos, v
 		    const char *path) NONNULL;
 void gui_load_image_filter(u32 win_id, u32 widget_id, enum gui_layer layer, vec2 pos, vec2 size,
 			   enum gfx_filter filter, const char *path) NONNULL;
+void gui_draw_rectangle(u32 win_id, u32 widget_id, enum gui_layer layer, vec2 pos1, vec2 pos2,
+			u32 c);
+void gui_draw_border(u32 win_id, u32 widget_id, enum gui_layer layer, u32 width, u32 c);
+void gui_draw_line(u32 win_id, u32 widget_id, enum gui_layer layer, vec2 pos1, vec2 pos2, u32 scale,
+		   u32 c);
+
+/**
+ * Widget operations
+ */
 
 void gui_add_widget(u32 *widget, u32 win_id, u32 widget_id, vec2 pos, vec2 size);
 void gui_new_widget(u32 *widget, u32 win_id, vec2 pos, vec2 size);
diff --git a/libs/libgui/msg.h b/libs/libgui/msg.h
index b29d0c8..4bffb74 100644
--- a/libs/libgui/msg.h
+++ b/libs/libgui/msg.h
@@ -55,9 +55,12 @@ struct message_mouse {
 	struct message_header header;
 	u32 id;
 	vec2 pos;
+	s8 scroll; // Dir: -1 neg, +1 pos
 	struct {
-		u8 click : 1;
-	} bits;
+		u8 left : 1;
+		u8 right : 1;
+		u8 middle : 1;
+	} but;
 };
 
 enum message_type {
-- 
cgit v1.2.3