source: mainline/uspace/lib/gui/grid.c@ 09553a0

/*
 * Copyright (c) 2012 Petr Koupy
 * Copyright (c) 2013 Martin Decky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup gui
 * @{
 */
/**
 * @file
 */

#include <assert.h>
#include <mem.h>
#include <stdlib.h>
#include <surface.h>
#include "window.h"
#include "grid.h"

typedef struct {
        sysarg_t min;
        sysarg_t max;
        sysarg_t val;
} constraints_t;

static void paint_internal(widget_t *widget)
{
        grid_t *grid = (grid_t *) widget;

        surface_t *surface = window_claim(grid->widget.window);
        if (!surface) {
                window_yield(grid->widget.window);
                return;
        }

        // FIXME: Replace with (accelerated) rectangle fill
        for (sysarg_t y = widget->vpos; y < widget->vpos + widget->height; y++) {
                for (sysarg_t x = widget->hpos; x < widget->hpos + widget->width; x++)
                        surface_put_pixel(surface, x, y, grid->background);
        }

        window_yield(grid->widget.window);
}

static grid_cell_t *grid_cell_at(grid_t *grid, size_t col, size_t row)
{
        if ((col < grid->cols) && (row < grid->rows))
                return grid->layout + (row * grid->cols + col);

        return NULL;
}

static grid_cell_t *grid_coords_at(grid_t *grid, sysarg_t hpos, sysarg_t vpos)
{
        for (size_t c = 0; c < grid->cols; c++) {
                for (size_t r = 0; r < grid->rows; r++) {
                        grid_cell_t *cell = grid_cell_at(grid, c, r);
                        if (cell) {
                                widget_t *widget = cell->widget;

                                if ((widget) && (hpos >= widget->hpos) &&
                                    (vpos >= widget->vpos) &&
                                    (hpos < widget->hpos + widget->width) &&
                                    (vpos < widget->vpos + widget->height))
                                        return cell;
                        }
                }
        }

        return NULL;
}

void deinit_grid(grid_t *grid)
{
        widget_deinit(&grid->widget);
        free(grid->layout);
}

static void grid_destroy(widget_t *widget)
{
        grid_t *grid = (grid_t *) widget;

        deinit_grid(grid);
        free(grid);
}

static void grid_reconfigure(widget_t *widget)
{
        /* No-op */
}

static void adjust_constraints(constraints_t *cons, size_t run,
    sysarg_t dim_min, sysarg_t dim_max)
{
        assert(run > 0);

        sysarg_t dim_min_part = dim_min / run;
        sysarg_t dim_min_rem = dim_min % run;

        sysarg_t dim_max_part = dim_max / run;
        sysarg_t dim_max_rem = dim_max % run;

        for (size_t i = 0; i < run; i++) {
                sysarg_t dim_min_cur = dim_min_part;
                sysarg_t dim_max_cur = dim_max_part;

                if (i == run - 1) {
                        dim_min_cur += dim_min_rem;
                        dim_max_cur += dim_max_rem;
                }

                /*
                 * We want the strongest constraint
                 * for the minimum.
                 */
                if (cons[i].min < dim_min_cur)
                        cons[i].min = dim_min_cur;

                /*
                 * The comparison is correct, we want
                 * the weakest constraint for the
                 * maximum.
                 */
                if (cons[i].max < dim_max_cur)
                        cons[i].max = dim_max_cur;
        }
}

static void solve_constraints(constraints_t *cons, size_t run, sysarg_t sum)
{
        /* Initial solution */
        sysarg_t cur_sum = 0;

        for (size_t i = 0; i < run; i++) {
                cons[i].val = cons[i].min;
                cur_sum += cons[i].val;
        }

        /* Iterative improvement */
        while (cur_sum < sum) {
                sysarg_t delta = (sum - cur_sum) / run;
                if (delta == 0)
                        break;

                cur_sum = 0;

                for (size_t i = 0; i < run; i++) {
                        if (cons[i].val + delta < cons[i].max)
                                cons[i].val += delta;

                        cur_sum += cons[i].val;
                }
        }
}

static void grid_rearrange(widget_t *widget, sysarg_t hpos, sysarg_t vpos,
    sysarg_t width, sysarg_t height)
{
        grid_t *grid = (grid_t *) widget;

        widget_modify(widget, hpos, vpos, width, height);
        paint_internal(widget);

        /* Compute column widths */
        constraints_t *widths =
            (constraints_t *) calloc(grid->cols, sizeof(constraints_t));
        if (widths) {
                /* Constrain widths */
                for (size_t c = 0; c < grid->cols; c++) {
                        widths[c].min = 0;

                        for (size_t r = 0; r < grid->rows; r++) {
                                grid_cell_t *cell = grid_cell_at(grid, c, r);
                                if (!cell)
                                        continue;

                                widget_t *widget = cell->widget;
                                if (widget)
                                        adjust_constraints(&widths[c], cell->cols,
                                            widget->width_min, widget->width_max);
                        }
                }

                solve_constraints(widths, grid->cols, width);
        }

        /* Compute row heights */
        constraints_t *heights =
            (constraints_t *) calloc(grid->rows, sizeof(constraints_t));
        if (heights) {
                /* Constrain heights */
                for (size_t r = 0; r < grid->rows; r++) {
                        heights[r].min = 0;

                        for (size_t c = 0; c < grid->cols; c++) {
                                grid_cell_t *cell = grid_cell_at(grid, c, r);
                                if (!cell)
                                        continue;

                                widget_t *widget = cell->widget;
                                if (widget) {
                                        adjust_constraints(&heights[r], cell->rows,
                                            widget->height_min, widget->height_max);
                                }
                        }
                }

                solve_constraints(heights, grid->rows, height);
        }

        /* Rearrange widgets */
        if ((widths) && (heights)) {
                sysarg_t cur_vpos = vpos;

                for (size_t r = 0; r < grid->rows; r++) {
                        sysarg_t cur_hpos = hpos;

                        for (size_t c = 0; c < grid->cols; c++) {
                                grid_cell_t *cell = grid_cell_at(grid, c, r);
                                if (!cell)
                                        continue;

                                widget_t *widget = cell->widget;
                                if (widget) {
                                        sysarg_t cur_width = 0;
                                        sysarg_t cur_height = 0;

                                        for (size_t cd = 0; cd < cell->cols; cd++)
                                                cur_width += widths[c + cd].val;

                                        for (size_t rd = 0; rd < cell->rows; rd++)
                                                cur_height += heights[r + rd].val;

                                        if ((cur_width > 0) && (cur_height > 0)) {
                                                sysarg_t wwidth = cur_width;
                                                sysarg_t wheight = cur_height;

                                                /*
                                                 * Make sure the widget is respects its
                                                 * maximal constrains.
                                                 */

                                                if ((widget->width_max > 0) &&
                                                    (wwidth > widget->width_max))
                                                        wwidth = widget->width_max;

                                                if ((widget->height_max > 0) &&
                                                    (wheight > widget->height_max))
                                                        wheight = widget->height_max;

                                                widget->rearrange(widget, cur_hpos, cur_vpos,
                                                    wwidth, wheight);
                                        }


                                }

                                cur_hpos += widths[c].val;
                        }

                        cur_vpos += heights[r].val;
                }
        }

        if (widths)
                free(widths);

        if (heights)
                free(heights);
}

static void grid_repaint(widget_t *widget)
{
        paint_internal(widget);

        list_foreach(widget->children, link, widget_t, child) {
                child->repaint(child);
        }

        window_damage(widget->window);
}

static void grid_handle_keyboard_event(widget_t *widget, kbd_event_t event)
{
        /* No-op */
}

static void grid_handle_position_event(widget_t *widget, pos_event_t event)
{
        grid_t *grid = (grid_t *) widget;

        grid_cell_t *cell = grid_coords_at(grid, event.hpos, event.vpos);
        if ((cell) && (cell->widget))
                cell->widget->handle_position_event(cell->widget, event);
}

static bool grid_add(struct grid *grid, widget_t *widget, size_t col,
    size_t row, size_t cols, size_t rows)
{
        if ((cols == 0) || (rows == 0) || (col + cols > grid->cols) ||
            (row + rows > grid->rows))
                return false;

        grid_cell_t *cell = grid_cell_at(grid, col, row);
        if (!cell)
                return false;

        /*
         * Check whether the cell is not occupied by an
         * extension of a different cell.
         */
        if ((!cell->widget) && (cell->cols > 0) && (cell->rows > 0))
                return false;

        widget->parent = (widget_t *) grid;

        list_append(&widget->link, &grid->widget.children);
        widget->window = grid->widget.window;

        /* Mark cells in layout */
        for (size_t r = row; r < row + rows; r++) {
                for (size_t c = col; c < col + cols; c++) {
                        if ((r == row) && (c == col)) {
                                cell->widget = widget;
                                cell->cols = cols;
                                cell->rows = rows;
                        } else {
                                grid_cell_t *extension = grid_cell_at(grid, c, r);
                                if (extension) {
                                        extension->widget = NULL;
                                        extension->cols = 1;
                                        extension->rows = 1;
                                }
                        }
                }
        }

        return true;
}

bool init_grid(grid_t *grid, widget_t *parent, const void *data, size_t cols,
    size_t rows, pixel_t background)
{
        if ((cols == 0) || (rows == 0))
                return false;

        grid->layout =
            (grid_cell_t *) calloc(cols * rows, sizeof(grid_cell_t));
        if (!grid->layout)
                return false;

        memset(grid->layout, 0, cols * rows * sizeof(grid_cell_t));

        widget_init(&grid->widget, parent, data);

        grid->widget.destroy = grid_destroy;
        grid->widget.reconfigure = grid_reconfigure;
        grid->widget.rearrange = grid_rearrange;
        grid->widget.repaint = grid_repaint;
        grid->widget.handle_keyboard_event = grid_handle_keyboard_event;
        grid->widget.handle_position_event = grid_handle_position_event;

        grid->add = grid_add;
        grid->background = background;
        grid->cols = cols;
        grid->rows = rows;

        return true;
}

grid_t *create_grid(widget_t *parent, const void *data, size_t cols,
    size_t rows, pixel_t background)
{
        grid_t *grid = (grid_t *) malloc(sizeof(grid_t));
        if (!grid)
                return NULL;

        if (init_grid(grid, parent, data, cols, rows, background))
                return grid;

        free(grid);
        return NULL;
}

/** @}
 */