ltk

grid.c (21074B)

---

 /* FIXME: sometimes, resizing doesn't work properly when running test.sh */
 
 /*
  * Copyright (c) 2016-2024 lumidify <nobody@lumidify.org>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 /* TODO: make ungrid function also adjust static row/column width/height
    -> also, how should the grid deal with a widget spanning over multiple
       rows/columns with static size - if all are static, it could just
       divide the widget size (it would complicate things, though), but
       what should happen if some rows/columns under the span do have a
       positive weight? */
 
 #include <stddef.h>
 #include <limits.h>
 
 #include "memory.h"
 #include "rect.h"
 #include "widget.h"
 #include "util.h"
 #include "grid.h"
 #include "graphics.h"
 
 void ltk_grid_set_row_weight(ltk_grid *grid, int row, int weight);
 void ltk_grid_set_column_weight(ltk_grid *grid, int column, int weight);
 ltk_grid *ltk_grid_create(ltk_window *window, int rows, int columns);
 int ltk_grid_add(
 	ltk_grid *grid, ltk_widget *widget,
 	int row, int column, int row_span, int column_span,
 	ltk_sticky_mask sticky
 );
 /* just a wrapper around ltk_grid_remove to make types match */
 static int ltk_grid_remove_child(ltk_widget *self, ltk_widget *widget);
 int ltk_grid_remove(ltk_grid *grid, ltk_widget *widget);
 
 static void ltk_grid_draw(ltk_widget *self, ltk_surface *s, int x, int y, ltk_rect clip);
 static void ltk_grid_destroy(ltk_widget *self, int shallow);
 static void ltk_recalculate_grid(ltk_widget *self);
 static void ltk_grid_child_size_change(ltk_widget *self, ltk_widget *widget);
 static int ltk_grid_find_nearest_column(ltk_grid *grid, int x);
 static int ltk_grid_find_nearest_row(ltk_grid *grid, int y);
 static ltk_widget *ltk_grid_get_child_at_pos(ltk_widget *self, int x, int y);
 
 static ltk_widget *ltk_grid_prev_child(ltk_widget *self, ltk_widget *child);
 static ltk_widget *ltk_grid_next_child(ltk_widget *self, ltk_widget *child);
 static ltk_widget *ltk_grid_first_child(ltk_widget *self);
 static ltk_widget *ltk_grid_last_child(ltk_widget *self);
 
 static ltk_widget *ltk_grid_nearest_child(ltk_widget *self, ltk_rect rect);
 static ltk_widget *ltk_grid_nearest_child_left(ltk_widget *self, ltk_widget *widget);
 static ltk_widget *ltk_grid_nearest_child_right(ltk_widget *self, ltk_widget *widget);
 static ltk_widget *ltk_grid_nearest_child_above(ltk_widget *self, ltk_widget *widget);
 static ltk_widget *ltk_grid_nearest_child_below(ltk_widget *self, ltk_widget *widget);
 
 static void ltk_grid_recalc_ideal_size(ltk_widget *self);
 
 static struct ltk_widget_vtable vtable = {
 	.draw = &ltk_grid_draw,
 	.destroy = &ltk_grid_destroy,
 	.resize = &ltk_recalculate_grid,
 	.hide = NULL,
 	.change_state = NULL,
 	.child_size_change = &ltk_grid_child_size_change,
 	.remove_child = &ltk_grid_remove_child,
 	.mouse_press = NULL,
 	.mouse_scroll = NULL,
 	.mouse_release = NULL,
 	.motion_notify = NULL,
 	.get_child_at_pos = &ltk_grid_get_child_at_pos,
 	.mouse_leave = NULL,
 	.mouse_enter = NULL,
 	.key_press = NULL,
 	.key_release = NULL,
 	.prev_child = &ltk_grid_prev_child,
 	.next_child = &ltk_grid_next_child,
 	.first_child = &ltk_grid_first_child,
 	.last_child = &ltk_grid_last_child,
 	.nearest_child = &ltk_grid_nearest_child,
 	.nearest_child_left = &ltk_grid_nearest_child_left,
 	.nearest_child_right = &ltk_grid_nearest_child_right,
 	.nearest_child_above = &ltk_grid_nearest_child_above,
 	.nearest_child_below = &ltk_grid_nearest_child_below,
 	.recalc_ideal_size = &ltk_grid_recalc_ideal_size,
 	.type = LTK_WIDGET_GRID,
 	.flags = 0,
 	.invalid_signal = LTK_GRID_SIGNAL_INVALID,
 };
 
 /* FIXME: only set "dirty" bit to avoid constand recalculation when
    setting multiple row/column weights? */
 void
 ltk_grid_set_row_weight(ltk_grid *grid, int row, int weight) {
 	ltk_assert(row < grid->rows);
 	grid->row_weights[row] = weight;
 	ltk_recalculate_grid(LTK_CAST_WIDGET(grid));
 }
 
 void
 ltk_grid_set_column_weight(ltk_grid *grid, int column, int weight) {
 	ltk_assert(column < grid->columns);
 	grid->column_weights[column] = weight;
 	ltk_recalculate_grid(LTK_CAST_WIDGET(grid));
 }
 
 static void
 ltk_grid_draw(ltk_widget *self, ltk_surface *s, int x, int y, ltk_rect clip) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	int i;
 	ltk_rect real_clip = ltk_rect_intersect((ltk_rect){0, 0, self->lrect.w, self->lrect.h}, clip);
 	for (i = 0; i < grid->rows * grid->columns; i++) {
 		if (!grid->widget_grid[i])
 			continue;
 		ltk_widget *ptr = grid->widget_grid[i];
 		int max_w = grid->column_pos[ptr->column + ptr->column_span] - grid->column_pos[ptr->column];
 		int max_h = grid->row_pos[ptr->row + ptr->row_span] - grid->row_pos[ptr->row];
 		ltk_rect r = ltk_rect_intersect(
 		    (ltk_rect){grid->column_pos[ptr->column], grid->row_pos[ptr->row], max_w, max_h}, real_clip
 		);
 		ltk_widget_draw(ptr, s, x + ptr->lrect.x, y + ptr->lrect.y, ltk_rect_relative(ptr->lrect, r));
 	}
 }
 
 ltk_grid *
 ltk_grid_create(ltk_window *window, int rows, int columns) {
 	ltk_grid *grid = ltk_malloc(sizeof(ltk_grid));
 
 	ltk_fill_widget_defaults(LTK_CAST_WIDGET(grid), window, &vtable, 0, 0);
 
 	grid->rows = rows;
 	grid->columns = columns;
 	grid->widget_grid = ltk_malloc(rows * columns * sizeof(ltk_widget));
 	grid->row_heights = ltk_malloc(rows * sizeof(int));
 	grid->column_widths = ltk_malloc(rows * sizeof(int));
 	grid->row_weights = ltk_malloc(rows * sizeof(int));
 	grid->column_weights = ltk_malloc(columns * sizeof(int));
 	/* Positions have one extra for the end */
 	grid->row_pos = ltk_malloc((rows + 1) * sizeof(int));
 	grid->column_pos = ltk_malloc((columns + 1) * sizeof(int));
 	/* FIXME: wow, that's horrible, this should just use memset */
 	int i;
 	for (i = 0; i < rows; i++) {
 		grid->row_heights[i] = 0;
 		grid->row_weights[i] = 0;
 		grid->row_pos[i] = 0;
 	}
 	grid->row_pos[rows] = 0;
 	for (i = 0; i < columns; i++) {
 		grid->column_widths[i] = 0;
 		grid->column_weights[i] = 0;
 		grid->column_pos[i] = 0;
 	}
 	grid->column_pos[columns] = 0;
 	for (i = 0; i < rows * columns; i++) {
 		grid->widget_grid[i] = NULL;
 	}
 
 	ltk_recalculate_grid(LTK_CAST_WIDGET(grid));
 	return grid;
 }
 
 static void
 ltk_grid_destroy(ltk_widget *self, int shallow) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	ltk_widget *ptr;
 	for (int i = 0; i < grid->rows * grid->columns; i++) {
 		if (grid->widget_grid[i]) {
 			ptr = grid->widget_grid[i];
 			ptr->parent = NULL;
 			if (!shallow) {
 				/* required to avoid freeing a widget multiple times
 				   if row_span or column_span is not 1 */
 				for (int r = ptr->row; r < ptr->row + ptr->row_span; r++) {
 					for (int c = ptr->column; c < ptr->column + ptr->column_span; c++) {
 						grid->widget_grid[r * grid->columns + c] = NULL;
 					}
 				}
 				ltk_widget_destroy(ptr, shallow);
 			}
 		}
 	}
 	ltk_free(grid->widget_grid);
 	ltk_free(grid->row_heights);
 	ltk_free(grid->column_widths);
 	ltk_free(grid->row_weights);
 	ltk_free(grid->column_weights);
 	ltk_free(grid->row_pos);
 	ltk_free(grid->column_pos);
 	ltk_free(grid);
 }
 
 static void
 ltk_recalculate_grid(ltk_widget *self) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	int height_static = 0, width_static = 0;
 	int total_row_weight = 0, total_column_weight = 0;
 	double height_unit = 0, width_unit = 0;
 	int currentx = 0, currenty = 0;
 	int i, j;
 	for (i = 0; i < grid->rows; i++) {
 		total_row_weight += grid->row_weights[i];
 		if (grid->row_weights[i] == 0) {
 			height_static += grid->row_heights[i];
 		}
 	}
 	for (i = 0; i < grid->columns; i++) {
 		total_column_weight += grid->column_weights[i];
 		if (grid->column_weights[i] == 0) {
 			width_static += grid->column_widths[i];
 		}
 	}
 	/* FIXME: what should be done when static height or width is larger than grid? */
 	if (total_row_weight > 0) {
 		height_unit = (double)(self->lrect.h - height_static) / (double)total_row_weight;
 	}
 	if (total_column_weight > 0) {
 		width_unit = (double)(self->lrect.w - width_static) / (double)total_column_weight;
 	}
 	for (i = 0; i < grid->rows; i++) {
 		grid->row_pos[i] = currenty;
 		if (grid->row_weights[i] > 0) {
 			grid->row_heights[i] = grid->row_weights[i] * height_unit;
 		}
 		currenty += grid->row_heights[i];
 	}
 	grid->row_pos[grid->rows] = currenty;
 	for (i = 0; i < grid->columns; i++) {
 		grid->column_pos[i] = currentx;
 		if (grid->column_weights[i] > 0) {
 			grid->column_widths[i] = grid->column_weights[i] * width_unit;
 		}
 		currentx += grid->column_widths[i];
 	}
 	grid->column_pos[grid->columns] = currentx;
 	/*int orig_width, orig_height;*/
 	int end_column, end_row;
 	for (i = 0; i < grid->rows; i++) {
 		for (j = 0; j < grid->columns; j++) {
 			ltk_widget *ptr = grid->widget_grid[i * grid->columns + j];
 			if (!ptr || ptr->row != i || ptr->column != j)
 				continue;
 			/*orig_width = ptr->lrect.w;
 			orig_height = ptr->lrect.h;*/
 			ptr->lrect.w = ptr->ideal_w;
 			ptr->lrect.h = ptr->ideal_h;
 			end_row = i + ptr->row_span;
 			end_column = j + ptr->column_span;
 			int max_w = grid->column_pos[end_column] - grid->column_pos[j];
 			int max_h = grid->row_pos[end_row] - grid->row_pos[i];
 			int stretch_width = (ptr->sticky & LTK_STICKY_LEFT) && (ptr->sticky & LTK_STICKY_RIGHT);
 			int shrink_width = (ptr->sticky & LTK_STICKY_SHRINK_WIDTH) && ptr->lrect.w > max_w;
 			int stretch_height = (ptr->sticky & LTK_STICKY_TOP) && (ptr->sticky & LTK_STICKY_BOTTOM);
 			int shrink_height = (ptr->sticky & LTK_STICKY_SHRINK_HEIGHT) && ptr->lrect.h > max_h;
 			if (stretch_width || shrink_width)
 				ptr->lrect.w = max_w;
 			if (stretch_height || shrink_height)
 				ptr->lrect.h = max_h;
 			if (ptr->sticky & LTK_STICKY_PRESERVE_ASPECT_RATIO) {
 				if (!stretch_width && !shrink_width) {
 					ptr->lrect.w = (int)(((double)ptr->lrect.h / ptr->ideal_h) * ptr->ideal_w);
 				} else if (!stretch_height && !shrink_height) {
 					ptr->lrect.h = (int)(((double)ptr->lrect.w / ptr->ideal_w) * ptr->ideal_h);
 				} else {
 					double scale_w = (double)ptr->lrect.w / ptr->ideal_w;
 					double scale_h = (double)ptr->lrect.h / ptr->ideal_h;
 					if (scale_w * ptr->ideal_h > ptr->lrect.h)
 						ptr->lrect.w = (int)(scale_h * ptr->ideal_w);
 					else if (scale_h * ptr->ideal_w > ptr->lrect.w)
 						ptr->lrect.h = (int)(scale_w * ptr->ideal_h);
 				}
 			}
 
 			/* the "default" case needs to come first because the widget may be stretched
 			   with aspect ratio preserving, and in that case it should still be centered */
 			if (stretch_width || !(ptr->sticky & (LTK_STICKY_RIGHT|LTK_STICKY_LEFT))) {
 				ptr->lrect.x = grid->column_pos[j] + (grid->column_pos[end_column] - grid->column_pos[j] - ptr->lrect.w) / 2;
 			} else if (ptr->sticky & LTK_STICKY_RIGHT) {
 				ptr->lrect.x = grid->column_pos[end_column] - ptr->lrect.w;
 			} else if (ptr->sticky & LTK_STICKY_LEFT) {
 				ptr->lrect.x = grid->column_pos[j];
 			}
 
 			if (stretch_height || !(ptr->sticky & (LTK_STICKY_TOP|LTK_STICKY_BOTTOM))) {
 				ptr->lrect.y = grid->row_pos[i] + (grid->row_pos[end_row] - grid->row_pos[i] - ptr->lrect.h) / 2;
 			} else if (ptr->sticky & LTK_STICKY_BOTTOM) {
 				ptr->lrect.y = grid->row_pos[end_row] - ptr->lrect.h;
 			} else if (ptr->sticky & LTK_STICKY_TOP) {
 				ptr->lrect.y = grid->row_pos[i];
 			}
 			/* intersect both with the grid rect and with the rect of the covered cells since there may be
 			   weird cases where the layout doesn't work properly and the cells are partially outside the grid */
 			ptr->crect = ltk_rect_intersect((ltk_rect){0, 0, self->crect.w, self->crect.h}, ptr->lrect);
 			ptr->crect = ltk_rect_intersect((ltk_rect){grid->column_pos[j], grid->row_pos[i], max_w, max_h}, ptr->crect);
 
 			/* FIXME: Figure out a better system for this - it would be nice to make it more
 			   efficient by not doing anything if nothing changed, but that doesn't work when
 			   this function was called because of a child_size_change. In that case, if a
 			   container widget is nested inside another container widget and another widget
 			   inside the nested container sends a child_size_change but the toplevel container
 			   doesn't change the size of the container, the position/size of the widget at the
 			   bottom of the hierarchy will never be updated. That's why updates are forced
 			   here even if seemingly nothing changed, but there probably is a better way. */
 			/*if (orig_width != ptr->lrect.w || orig_height != ptr->lrect.h)*/
 				ltk_widget_resize(ptr);
 		}
 	}
 }
 
 /* FIXME: what should be done if widget spans multiple rows/columns with static size? */
 static void
 ltk_grid_recalc_ideal_size(ltk_widget *self) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	for (int j = 0; j < grid->columns; j++) {
 		if (grid->column_weights[j] == 0)
 			grid->column_widths[j] = 0;
 	}
 	for (int i = 0; i < grid->rows; i++) {
 		if (grid->row_weights[i] == 0)
 			grid->row_heights[i] = 0;
 		for (int j = 0; j < grid->columns; j++) {
 			ltk_widget *ptr = grid->widget_grid[i * grid->columns + j];
 			if (!ptr || ptr->row != i || ptr->column != j)
 				continue;
 			ltk_widget_recalc_ideal_size(ptr);
 			if (grid->row_weights[i] == 0 && ptr->ideal_h > (unsigned int)grid->row_heights[i])
 				grid->row_heights[i] = ptr->ideal_h;
 			if (grid->column_weights[j] == 0 && ptr->ideal_w > (unsigned int)grid->column_widths[j])
 				grid->column_widths[j] = ptr->ideal_w;
 		}
 	}
 	self->ideal_w = self->ideal_h = 0;
 	for (int i = 0; i < grid->rows; i++) {
 		if (grid->row_weights[i] == 0)
 			self->ideal_h += grid->row_heights[i];
 	}
 	for (int j = 0; j < grid->columns; j++) {
 		if (grid->column_weights[j] == 0)
 			self->ideal_w += grid->column_widths[j];
 	}
 }
 
 /* FIXME: Maybe add debug stuff to check that grid is actually parent of widget */
 static void
 ltk_grid_child_size_change(ltk_widget *self, ltk_widget *widget) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	short size_changed = 0;
 	int orig_w = widget->lrect.w;
 	int orig_h = widget->lrect.h;
 	widget->lrect.w = widget->ideal_w;
 	widget->lrect.h = widget->ideal_h;
 	if (grid->column_weights[widget->column] == 0 &&
 	    widget->lrect.w > grid->column_widths[widget->column]) {
 		self->ideal_w += widget->lrect.w - grid->column_widths[widget->column];
 		grid->column_widths[widget->column] = widget->lrect.w;
 		size_changed = 1;
 	}
 	if (grid->row_weights[widget->row] == 0 &&
 	    widget->lrect.h > grid->row_heights[widget->row]) {
 		self->ideal_h += widget->lrect.h - grid->row_heights[widget->row];
 		grid->row_heights[widget->row] = widget->lrect.h;
 		size_changed = 1;
 	}
 	if (size_changed && self->parent && self->parent->vtable->child_size_change)
 		self->parent->vtable->child_size_change(self->parent, LTK_CAST_WIDGET(grid));
 	else
 		ltk_recalculate_grid(LTK_CAST_WIDGET(grid));
 	if (widget->lrect.w != orig_w || widget->lrect.h != orig_h)
 		ltk_widget_resize(widget);
 }
 
 /* FIXME: Check if widget already exists at position */
 int
 ltk_grid_add(
 	ltk_grid *grid, ltk_widget *widget,
 	int row, int column, int row_span, int column_span,
 	ltk_sticky_mask sticky
 ) {
 	if (widget->parent)
 		return 1;
 	/* FIXME: decide which checks should be asserts and which should be error returns */
 	/* the client-server version of ltk shouldn't abort on errors like these */
 	ltk_assert(row >= 0 && row + row_span <= grid->rows);
 	ltk_assert(column >= 0 && column + column_span <= grid->columns);
 
 	ltk_widget_recalc_ideal_size(widget);
 
 	widget->sticky = sticky;
 	widget->row = row;
 	widget->column = column;
 	widget->row_span = row_span;
 	widget->column_span = column_span;
 	for (int i = row; i < row + row_span; i++) {
 		for (int j = column; j < column + column_span; j++) {
 			grid->widget_grid[i * grid->columns + j] = widget;
 		}
 	}
 	widget->parent = LTK_CAST_WIDGET(grid);
 	ltk_grid_child_size_change(LTK_CAST_WIDGET(grid), widget);
 	ltk_window_invalidate_widget_rect(LTK_CAST_WIDGET(grid)->window, LTK_CAST_WIDGET(grid));
 
 	return 0;
 }
 
 int
 ltk_grid_remove(ltk_grid *grid, ltk_widget *widget) {
 	if (widget->parent != LTK_CAST_WIDGET(grid))
 		return 1;
 	widget->parent = NULL;
 	for (int i = widget->row; i < widget->row + widget->row_span; i++) {
 		for (int j = widget->column; j < widget->column + widget->column_span; j++) {
 			grid->widget_grid[i * grid->columns + j] = NULL;
 		}
 	}
 	ltk_window_invalidate_widget_rect(LTK_CAST_WIDGET(grid)->window, LTK_CAST_WIDGET(grid));
 
 	return 0;
 }
 
 static int
 ltk_grid_remove_child(ltk_widget *self, ltk_widget *widget) {
 	return ltk_grid_remove(LTK_CAST_GRID(self), widget);
 }
 
 static int
 ltk_grid_find_nearest_column(ltk_grid *grid, int x) {
 	int i;
 	for (i = 0; i < grid->columns; i++) {
 		if (grid->column_pos[i] <= x && grid->column_pos[i + 1] >= x) {
 			return i;
 		}
 	}
 	return -1;
 }
 
 static int
 ltk_grid_find_nearest_row(ltk_grid *grid, int y) {
 	int i;
 	for (i = 0; i < grid->rows; i++) {
 		if (grid->row_pos[i] <= y && grid->row_pos[i + 1] >= y) {
 			return i;
 		}
 	}
 	return -1;
 }
 
 /* FIXME: maybe come up with a more efficient method */
 static ltk_widget *
 ltk_grid_nearest_child(ltk_widget *self, ltk_rect rect) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	ltk_widget *minw = NULL;
 	int min_dist = INT_MAX;
 	/* FIXME: rows and columns shouldn't be int */
 	for (size_t i = 0; i < (size_t)(grid->rows * grid->columns); i++) {
 		if (!grid->widget_grid[i])
 			continue;
 		/* FIXME: this checks widgets with row/columnspan > 1 multiple times */
 		ltk_rect r = grid->widget_grid[i]->lrect;
 		int dist = ltk_rect_fakedist(rect, r);
 		if (dist < min_dist) {
 			min_dist = dist;
 			minw = grid->widget_grid[i];
 		}
 	}
 	return minw;
 }
 
 /* FIXME: assertions to check that widget row/column are legal */
 static ltk_widget *
 ltk_grid_nearest_child_left(ltk_widget *self, ltk_widget *widget) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	unsigned int col = widget->column;
 	ltk_widget *cur = NULL;
 	while (col-- > 0) {
 		cur = grid->widget_grid[widget->row * grid->columns + col];
 		if (cur && cur != widget)
 			return cur;
 	}
 	return NULL;
 }
 
 static ltk_widget *
 ltk_grid_nearest_child_right(ltk_widget *self, ltk_widget *widget) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	ltk_widget *cur = NULL;
 	for (int col = widget->column + 1; col < grid->columns; col++) {
 		cur = grid->widget_grid[widget->row * grid->columns + col];
 		if (cur && cur != widget)
 			return cur;
 	}
 	return NULL;
 }
 
 /* FIXME: maybe these should also fall back to widgets in other columns if those
    exist but no widgets exist in the same column */
 static ltk_widget *
 ltk_grid_nearest_child_above(ltk_widget *self, ltk_widget *widget) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	unsigned int row = widget->row;
 	ltk_widget *cur = NULL;
 	while (row-- > 0) {
 		cur = grid->widget_grid[row * grid->columns + widget->column];
 		if (cur && cur != widget)
 			return cur;
 	}
 	return NULL;
 }
 
 static ltk_widget *
 ltk_grid_nearest_child_below(ltk_widget *self, ltk_widget *widget) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	ltk_widget *cur = NULL;
 	for (int row = widget->row + 1; row < grid->rows; row++) {
 		cur = grid->widget_grid[row * grid->columns + widget->column];
 		if (cur && cur != widget)
 			return cur;
 	}
 	return NULL;
 }
 
 static ltk_widget *
 ltk_grid_get_child_at_pos(ltk_widget *self, int x, int y) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	int row = ltk_grid_find_nearest_row(grid, y);
 	int column = ltk_grid_find_nearest_column(grid, x);
 	if (row == -1 || column == -1)
 		return 0;
 	ltk_widget *ptr = grid->widget_grid[row * grid->columns + column];
 	if (ptr && ltk_collide_rect(ptr->crect, x, y))
 		return ptr;
 	return NULL;
 }
 
 static ltk_widget *
 ltk_grid_prev_child(ltk_widget *self, ltk_widget *child) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	unsigned int start = child->row * grid->columns + child->column;
 	while (start-- > 0) {
 		if (grid->widget_grid[start])
 			return grid->widget_grid[start];
 	}
 	return NULL;
 }
 
 static ltk_widget *
 ltk_grid_next_child(ltk_widget *self, ltk_widget *child) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	unsigned int start = child->row * grid->columns + child->column;
 	while (++start < (unsigned int)(grid->rows * grid->columns)) {
 		if (grid->widget_grid[start] && grid->widget_grid[start] != child)
 			return grid->widget_grid[start];
 	}
 	return NULL;
 }
 
 static ltk_widget *
 ltk_grid_first_child(ltk_widget *self) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	for (unsigned int i = 0; i < (unsigned int)(grid->rows * grid->columns); i++) {
 		if (grid->widget_grid[i])
 			return grid->widget_grid[i];
 	}
 	return NULL;
 }
 
 static ltk_widget *
 ltk_grid_last_child(ltk_widget *self) {
 	ltk_grid *grid = LTK_CAST_GRID(self);
 	for (unsigned int i = grid->rows * grid->columns; i-- > 0;) {
 		if (grid->widget_grid[i])
 			return grid->widget_grid[i];
 	}
 	return NULL;
 }