//
// Copyright(C) 2005-2014 Simon Howard
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

#include "doomkeys.h"

#include "txt_desktop.h"
#include "txt_gui.h"
#include "txt_io.h"
#include "txt_main.h"
#include "txt_separator.h"
#include "txt_strut.h"
#include "txt_table.h"

txt_widget_t txt_table_overflow_right;
txt_widget_t txt_table_overflow_down;
txt_widget_t txt_table_eol;
txt_widget_t txt_table_empty;

// Returns true if the given widget in the table's widgets[] array refers
// to an actual widget - not NULL, or one of the special overflow pointers.
static int IsActualWidget(txt_widget_t *widget)
{
    return widget != NULL
        && widget != &txt_table_overflow_right
        && widget != &txt_table_overflow_down;
}

// Remove all entries from a table

void TXT_ClearTable(TXT_UNCAST_ARG(table))
{
    TXT_CAST_ARG(txt_table_t, table);
    int i;

    // Free all widgets
    // Skip over the first (num_columns) widgets in the array, as these
    // are the column struts used to control column width

    for (i=table->columns; i<table->num_widgets; ++i)
    {
        if (IsActualWidget(table->widgets[i]))
        {
            TXT_DestroyWidget(table->widgets[i]);
        }
    }

    // Shrink the table to just the column strut widgets

    table->num_widgets = table->columns;
}

static void TXT_TableDestructor(TXT_UNCAST_ARG(table))
{
    TXT_CAST_ARG(txt_table_t, table);

    TXT_ClearTable(table);
}

static int TableRows(txt_table_t *table)
{
    return (table->num_widgets + table->columns - 1) / table->columns;
}

// Most widgets occupy just one cell of a table, but if the special
// overflow constants are used, they can occupy multiple cells.
// This function figures out for a widget in a given cell, which
// cells it should actually occupy (always a rectangle).
static void CellOverflowedSize(txt_table_t *table, int x, int y,
                               int *w, int *h)
{
    txt_widget_t *widget;
    int x1, y1;

    if (!IsActualWidget(table->widgets[y * table->columns + x]))
    {
        *w = 0; *h = 0;
        return;
    }

    *w = table->columns - x;
    *h = 0;
    for (y1 = y; y1 < TableRows(table); ++y1)
    {
        // Every overflow cell must point to either (x, y) or another
        // overflow cell. This means the first in every row must be
        // txt_table_overflow_down.

        if (y1 * table->columns + x >= table->num_widgets)
        {
            break;
        }

        widget = table->widgets[y1 * table->columns + x];

        if (y1 != y && widget != &txt_table_overflow_down)
        {
            break;
        }

        for (x1 = x + 1; x1 < x + *w; ++x1)
        {
            if (y1 * table->columns + x1 >= table->num_widgets)
            {
                break;
            }

            // Can be either type of overflow, except on the first row.
            // Otherwise we impose a limit on the width.
            widget = table->widgets[y1 * table->columns + x1];
            if (widget != &txt_table_overflow_right
             && (widget != &txt_table_overflow_down || y1 == y))
            {
                *w = x1 - x;
                break;
            }
        }

        ++*h;
    }
}

static int IsOverflowingCell(txt_table_t *table, int x, int y)
{
    int w, h;
    CellOverflowedSize(table, x, y, &w, &h);
    return w > 1 || h > 1;
}

// Using the given column/row size tables, calculate the size of the given
// widget, storing the result in (w, h).
static void CalculateWidgetDimensions(txt_table_t *table,
                                      int x, int y,
                                      unsigned int *column_widths,
                                      unsigned int *row_heights,
                                      unsigned int *w, unsigned int *h)
{
    int cell_w, cell_h;
    int x1, y1;

    // Find which cells this widget occupies.
    CellOverflowedSize(table, x, y, &cell_w, &cell_h);

    // Add up column / row widths / heights to get the actual dimensions.
    *w = 0;
    for (x1 = x; x1 < x + cell_w; ++x1)
    {
        *w += column_widths[x1];
    }

    *h = 0;
    for (y1 = y; y1 < y + cell_h; ++y1)
    {
        *h += row_heights[y1];
    }
}

static void CalcRowColSizes(txt_table_t *table,
                            unsigned int *row_heights,
                            unsigned int *col_widths)
{
    int x, y;
    int rows;
    txt_widget_t *widget;

    rows = TableRows(table);

    memset(col_widths, 0, sizeof(int) * table->columns);

    for (y = 0; y < rows; ++y)
    {
        row_heights[y] = 0;

        for (x = 0; x < table->columns; ++x)
        {
            if (y * table->columns + x >= table->num_widgets)
                break;

            widget = table->widgets[y * table->columns + x];

            if (IsActualWidget(widget))
            {
                TXT_CalcWidgetSize(widget);
            }

            // In the first pass we ignore overflowing cells.
            if (IsOverflowingCell(table, x, y))
            {
                continue;
            }

            // NULL represents an empty spacer
            if (IsActualWidget(widget))
            {
                if (widget->h > row_heights[y])
                    row_heights[y] = widget->h;
                if (widget->w > col_widths[x])
                    col_widths[x] = widget->w;
            }
        }
    }

    // In the second pass, we go through again and process overflowing
    // widgets, to ensure that they will fit.
    for (y = 0; y < rows; ++y)
    {
        for (x = 0; x < table->columns; ++x)
        {
            unsigned int w, h;

            if (y * table->columns + x >= table->num_widgets)
                break;

            widget = table->widgets[y * table->columns + x];
            if (!IsActualWidget(widget))
            {
                continue;
            }

            // Expand column width and row heights as needed.
            CalculateWidgetDimensions(table, x, y, col_widths, row_heights,
                                      &w, &h);
            if (w < widget->w)
            {
                col_widths[x] += widget->w - w;
            }
            if (h < widget->h)
            {
                row_heights[y] += widget->h - h;
            }
        }
    }
}

static void TXT_CalcTableSize(TXT_UNCAST_ARG(table))
{
    TXT_CAST_ARG(txt_table_t, table);
    unsigned int *column_widths;
    unsigned int *row_heights;
    int x, y;
    int rows;

    rows = TableRows(table);

    row_heights = malloc(sizeof(int) * rows);
    column_widths = malloc(sizeof(int) * table->columns);

    CalcRowColSizes(table, row_heights, column_widths);

    table->widget.w = 0;

    for (x=0; x<table->columns; ++x)
    {
        table->widget.w += column_widths[x];
    }

    table->widget.h = 0;

    for (y=0; y<rows; ++y)
    {
        table->widget.h += row_heights[y];
    }

    free(row_heights);
    free(column_widths);
}

static void FillRowToEnd(txt_table_t *table)
{
    while ((table->num_widgets % table->columns) != 0)
    {
        TXT_AddWidget(table, &txt_table_overflow_right);
    }
}

void TXT_AddWidget(TXT_UNCAST_ARG(table), TXT_UNCAST_ARG(widget))
{
    TXT_CAST_ARG(txt_table_t, table);
    TXT_CAST_ARG(txt_widget_t, widget);
    int is_separator;
    int i;

    // Convenience alias for NULL:
    if (widget == &txt_table_empty)
    {
        widget = NULL;
    }
    else if (widget == &txt_table_eol)
    {
        FillRowToEnd(table);
        return;
    }

    // We have special handling for the separator widget:
    is_separator = IsActualWidget(widget)
                && widget->widget_class == &txt_separator_class;

    // If we add two separators consecutively, the new separator replaces the
    // first. This allows us to override the "implicit" separator that is
    // added at the top of a window when it is created.
    if (is_separator)
    {
        for (i = table->num_widgets - 1; i >= 0; --i)
        {
            txt_widget_t *last_widget;
            last_widget = table->widgets[i];

            if (IsActualWidget(last_widget)
             && widget->widget_class == &txt_separator_class
             && last_widget->widget_class == &txt_separator_class)
            {
                table->widgets[i] = widget;
                TXT_DestroyWidget(last_widget);
                return;
            }
            else if (last_widget != &txt_table_overflow_right)
            {
                break;
            }
        }
    }

    // Separators begin on a new line.
    if (is_separator)
    {
        FillRowToEnd(table);
    }

    table->widgets = realloc(table->widgets,
                             sizeof(txt_widget_t *) * (table->num_widgets + 1));
    table->widgets[table->num_widgets] = widget;
    ++table->num_widgets;

    // Maintain parent pointer.
    if (IsActualWidget(widget))
    {
        widget->parent = &table->widget;
    }

    // Separators always take up the entire line.
    if (is_separator)
    {
        FillRowToEnd(table);
    }
}

// Add multiple widgets to a table.

void TXT_AddWidgets(TXT_UNCAST_ARG(table), ...)
{
    TXT_CAST_ARG(txt_table_t, table);
    va_list args;
    txt_widget_t *widget;

    va_start(args, TXT_UNCAST_ARG_NAME(table));

    // Keep adding widgets until a NULL is reached.
   
    for (;;) 
    {
        widget = va_arg(args, txt_widget_t *);

        if (widget == NULL)
        {
            break;
        }

        TXT_AddWidget(table, widget);
    }

    va_end(args);
}

static int SelectableCell(txt_table_t *table, int x, int y)
{
    txt_widget_t *widget;
    int i;

    if (x < 0 || x >= table->columns)
    {
        return 0;
    }

    i = y * table->columns + x;

    if (i >= 0 && i < table->num_widgets)
    {
        widget = table->widgets[i];
        return IsActualWidget(widget)
            && TXT_SelectableWidget(widget)
            && widget->visible;
    }

    return 0;
}

// Tries to locate a selectable widget in the given row, returning
// the column number of the first column available or -1 if none are 
// available in the given row.
//
// Starts from start_col, then searches nearby columns.

static int FindSelectableColumn(txt_table_t *table, int row, int start_col)
{
    int x;

    for (x=0; x<table->columns; ++x)
    {
        // Search to the right

        if (SelectableCell(table, start_col + x, row))
        {
            return start_col + x;
        }

        // Search to the left

        if (SelectableCell(table, start_col - x, row))
        {
            return start_col - x;
        }
    }

    // None available

    return -1;
}

// Change the selected widget.

static void ChangeSelection(txt_table_t *table, int x, int y)
{
    txt_widget_t *cur_widget;
    txt_widget_t *new_widget;
    int i;

    // No change?

    if (x == table->selected_x && y == table->selected_y)
    {
        return;
    }

    // Unfocus current widget:

    i = table->selected_y * table->columns + table->selected_x;

    if (i < table->num_widgets)
    {
        cur_widget = table->widgets[i];

        if (table->widget.focused && IsActualWidget(cur_widget))
        {
            TXT_SetWidgetFocus(cur_widget, 0);
        }
    }

    // Focus new widget.

    new_widget = table->widgets[y * table->columns + x];

    table->selected_x = x;
    table->selected_y = y;

    if (table->widget.focused && new_widget != NULL)
    {
        TXT_SetWidgetFocus(new_widget, 1);
    }
}

static int TXT_TableKeyPress(TXT_UNCAST_ARG(table), int key)
{
    TXT_CAST_ARG(txt_table_t, table);
    int selected;
    int rows;

    rows = TableRows(table);

    // Send to the currently selected widget first

    selected = table->selected_y * table->columns + table->selected_x;

    if (selected >= 0 && selected < table->num_widgets)
    {
        if (IsActualWidget(table->widgets[selected])
         && TXT_SelectableWidget(table->widgets[selected])
         && TXT_WidgetKeyPress(table->widgets[selected], key))
        {
            return 1;
        }
    }

    if (key == KEY_TAB)
    {
        int dir;
        int i;

        dir = TXT_GetModifierState(TXT_MOD_SHIFT) ? -1 : 1;

        // Cycle through all widgets until we find one that can be selected.
        for (i = table->selected_y * table->columns + table->selected_x + dir;
             i >= 0 && i < table->num_widgets;
             i += dir)
        {
            if (IsActualWidget(table->widgets[i])
             && TXT_SelectableWidget(table->widgets[i]))
            {
                ChangeSelection(table, i % table->columns, i / table->columns);
                return 1;
            }
        }

        return 0;
    }

    if (key == KEY_DOWNARROW)
    {
        int new_x, new_y;

        // Move cursor down to the next selectable widget

        for (new_y = table->selected_y + 1; new_y < rows; ++new_y)
        {
            new_x = FindSelectableColumn(table, new_y, table->selected_x);

            if (new_x >= 0)
            {
                // Found a selectable widget in this column!

                ChangeSelection(table, new_x, new_y);

                return 1;
            }
        }
    }

    if (key == KEY_UPARROW)
    {
        int new_x, new_y;

        // Move cursor up to the next selectable widget

        for (new_y = table->selected_y - 1; new_y >= 0; --new_y)
        {
            new_x = FindSelectableColumn(table, new_y, table->selected_x);

            if (new_x >= 0)
            {
                // Found a selectable widget in this column!

                ChangeSelection(table, new_x, new_y);

                return 1;
            }
        }
    }

    if (key == KEY_LEFTARROW)
    {
        int new_x;

        // Move cursor left

        for (new_x = table->selected_x - 1; new_x >= 0; --new_x)
        {
            if (SelectableCell(table, new_x, table->selected_y))
            {
                // Found a selectable widget!

                ChangeSelection(table, new_x, table->selected_y);

                return 1;
            }
        }
    }

    if (key == KEY_RIGHTARROW)
    {
        int new_x;

        // Move cursor left

        for (new_x = table->selected_x + 1; new_x < table->columns; ++new_x)
        {
            if (SelectableCell(table, new_x, table->selected_y))
            {
                // Found a selectable widget!

                ChangeSelection(table, new_x, table->selected_y);

                return 1;
            }
        }
    }

    return 0;
}

// Check the currently selected widget in the table is valid.

static void CheckValidSelection(txt_table_t *table)
{
    int rows;
    int new_x, new_y;

    rows = TableRows(table);

    for (new_y = table->selected_y; new_y < rows; ++new_y)
    {
        new_x = FindSelectableColumn(table, new_y, table->selected_x);

        if (new_x >= 0)
        {
            // Found a selectable column.

            ChangeSelection(table, new_x, new_y);

            break;
        }
    }
}

static void LayoutCell(txt_table_t *table, int x, int y,
                       int draw_x, int draw_y)
{
    txt_widget_t *widget;
    int col_width;

    widget = table->widgets[y * table->columns + x];

    col_width = widget->w;

    // Adjust x position based on alignment property

    switch (widget->align)
    {
        case TXT_HORIZ_LEFT:
            widget->w = col_width;
            break;

        case TXT_HORIZ_CENTER:
            TXT_CalcWidgetSize(widget);

            // Separators are always drawn left-aligned.

            if (widget->widget_class != &txt_separator_class)
            {
                draw_x += (col_width - widget->w) / 2;
            }

            break;

        case TXT_HORIZ_RIGHT:
            TXT_CalcWidgetSize(widget);

            if (widget->widget_class != &txt_separator_class)
            {
                draw_x += col_width - widget->w;
            }
            break;
    }

    // Set the position for this widget

    widget->x = draw_x;
    widget->y = draw_y;

    // Recursively lay out any widgets contained in the widget

    TXT_LayoutWidget(widget);
}

static void TXT_TableLayout(TXT_UNCAST_ARG(table))
{
    TXT_CAST_ARG(txt_table_t, table);
    unsigned int *column_widths;
    unsigned int *row_heights;
    txt_widget_t *widget;
    int draw_x, draw_y;
    int x, y;
    int i;
    int rows;

    // Work out the column widths and row heights

    rows = TableRows(table);

    column_widths = malloc(sizeof(int) * table->columns);
    row_heights = malloc(sizeof(int) * rows);

    CalcRowColSizes(table, row_heights, column_widths);

    // If this table only has one column, expand column size to fit
    // the display width.  Ensures that separators reach the window edges 
    // when drawing windows.

    if (table->columns == 1)
    {
        column_widths[0] = table->widget.w;
    }

    // Draw all cells

    draw_y = table->widget.y;

    for (y=0; y<rows; ++y)
    {
        draw_x = table->widget.x;

        for (x=0; x<table->columns; ++x)
        {
            i = y * table->columns + x;

            if (i >= table->num_widgets)
                break;

            widget = table->widgets[i];

            if (IsActualWidget(widget))
            {
                CalculateWidgetDimensions(table, x, y,
                                          column_widths, row_heights,
                                          &widget->w, &widget->h);
                LayoutCell(table, x, y, draw_x, draw_y);
            }

            draw_x += column_widths[x];
        }

        draw_y += row_heights[y];
    }

    free(row_heights);
    free(column_widths);
}

static void TXT_TableDrawer(TXT_UNCAST_ARG(table))
{
    TXT_CAST_ARG(txt_table_t, table);
    txt_widget_t *widget;
    int i;

    // Check the table's current selection points at something valid before
    // drawing.

    CheckValidSelection(table);

    // Draw all cells

    for (i=0; i<table->num_widgets; ++i)
    {
        widget = table->widgets[i];

        if (IsActualWidget(widget))
        {
            TXT_GotoXY(widget->x, widget->y);
            TXT_DrawWidget(widget);
        }
    }
}

// Responds to mouse presses

static void TXT_TableMousePress(TXT_UNCAST_ARG(table), int x, int y, int b)
{
    TXT_CAST_ARG(txt_table_t, table);
    txt_widget_t *widget;
    int i;

    for (i=0; i<table->num_widgets; ++i)
    {
        widget = table->widgets[i];

        // NULL widgets are spacers

        if (IsActualWidget(widget))
        {
            if (x >= widget->x && x < (signed) (widget->x + widget->w)
             && y >= widget->y && y < (signed) (widget->y + widget->h))
            {
                // This is the widget that was clicked!

                // Select the cell if the widget is selectable

                if (TXT_SelectableWidget(widget))
                {
                    ChangeSelection(table, i % table->columns,
                                           i / table->columns);
                }

                // Propagate click

                TXT_WidgetMousePress(widget, x, y, b);

                break;
            }
        }
    }
}

// Determine whether the table is selectable.

static int TXT_TableSelectable(TXT_UNCAST_ARG(table))
{
    TXT_CAST_ARG(txt_table_t, table);
    int i;

    // Is the currently-selected cell selectable?

    if (SelectableCell(table, table->selected_x, table->selected_y))
    {
        return 1;
    }

    // Find the first selectable cell and set selected_x, selected_y.

    for (i = 0; i < table->num_widgets; ++i)
    {
        if (IsActualWidget(table->widgets[i])
         && TXT_SelectableWidget(table->widgets[i]))
        {
            ChangeSelection(table, i % table->columns, i / table->columns);
            return 1;
        }
    }

    // No selectable widgets exist within the table.

    return 0;
}

// Need to pass through focus changes to the selected child widget.

static void TXT_TableFocused(TXT_UNCAST_ARG(table), int focused)
{
    TXT_CAST_ARG(txt_table_t, table);
    int i;

    i = table->selected_y * table->columns + table->selected_x;

    if (i < table->num_widgets)
    {
        if (IsActualWidget(table->widgets[i]))
        {
            TXT_SetWidgetFocus(table->widgets[i], focused);
        }
    }
}

txt_widget_class_t txt_table_class =
{
    TXT_TableSelectable,
    TXT_CalcTableSize,
    TXT_TableDrawer,
    TXT_TableKeyPress,
    TXT_TableDestructor,
    TXT_TableMousePress,
    TXT_TableLayout,
    TXT_TableFocused,
};

void TXT_InitTable(txt_table_t *table, int columns)
{
    int i;

    TXT_InitWidget(table, &txt_table_class);
    table->columns = columns;
    table->widgets = NULL;
    table->num_widgets = 0;
    table->selected_x = 0;
    table->selected_y = 0;

    // Add a strut for each column at the start of the table. 
    // These are used by the TXT_SetColumnWidths function below:
    // the struts are created with widths of 0 each, but this
    // function changes them.

    for (i=0; i<columns; ++i)
    {
        TXT_AddWidget(table, TXT_NewStrut(0, 0));
    }
}

txt_table_t *TXT_NewTable(int columns)
{
    txt_table_t *table;

    table = malloc(sizeof(txt_table_t));

    TXT_InitTable(table, columns);

    return table;
}

// Create a horizontal table from a list of widgets.

txt_table_t *TXT_NewHorizBox(TXT_UNCAST_ARG(first_widget), ...)
{
    TXT_CAST_ARG(txt_widget_t, first_widget);
    txt_table_t *result;
    va_list args;
    int num_args;

    // First, find the number of arguments to determine the width of
    // the box.

    va_start(args, TXT_UNCAST_ARG_NAME(first_widget));

    num_args = 1;

    for (;;)
    {
        txt_widget_t *widget;

        widget = va_arg(args, txt_widget_t *);

        if (widget == NULL)
        {
            // End of list

            break;
        }
        else
        {
            ++num_args;
        }
    }
    
    va_end(args);

    // Create the table.

    result = TXT_NewTable(num_args);
    TXT_AddWidget(result, first_widget);

    // Go through the list again and add each widget.

    va_start(args, TXT_UNCAST_ARG_NAME(first_widget));

    for (;;)
    {
        txt_widget_t *widget;

        widget = va_arg(args, txt_widget_t *);

        if (widget == NULL)
        {
            // End of list

            break;
        }
        else
        {
            TXT_AddWidget(result, widget);
        }
    }
    
    va_end(args);

    return result;
}

// Get the currently-selected widget in a table, recursively searching
// through sub-tables if necessary.

txt_widget_t *TXT_GetSelectedWidget(TXT_UNCAST_ARG(table))
{
    TXT_CAST_ARG(txt_table_t, table);
    txt_widget_t *result;
    int index;

    index = table->selected_y * table->columns + table->selected_x;

    result = NULL;

    if (index >= 0 && index < table->num_widgets)
    {
        result = table->widgets[index];

        if (!IsActualWidget(result))
        {
            result = NULL;
        }
    }

    if (result != NULL && result->widget_class == &txt_table_class)
    {
        result = TXT_GetSelectedWidget(result);
    }

    return result;
}

// Selects a given widget in a table, recursively searching any tables
// within this table.  Returns 1 if successful, 0 if unsuccessful.

int TXT_SelectWidget(TXT_UNCAST_ARG(table), TXT_UNCAST_ARG(widget))
{
    TXT_CAST_ARG(txt_table_t, table);
    TXT_CAST_ARG(txt_widget_t, widget);
    int i;

    for (i=0; i<table->num_widgets; ++i)
    {
        if (!IsActualWidget(table->widgets[i]))
        {
            continue;
        }

        if (table->widgets[i] == widget)
        {
            // Found the item!  Select it and return.

            ChangeSelection(table, i % table->columns, i / table->columns);

            return 1;
        }

        if (table->widgets[i]->widget_class == &txt_table_class)
        {
            // This item is a subtable.  Recursively search this table.

            if (TXT_SelectWidget(table->widgets[i], widget))
            {
                // Found it in the subtable.  Select this subtable and return.

                ChangeSelection(table, i % table->columns, i / table->columns);

                return 1;
            }
        }
    }

    // Not found.

    return 0;
}

void TXT_SetTableColumns(TXT_UNCAST_ARG(table), int new_columns)
{
    TXT_CAST_ARG(txt_table_t, table);
    txt_widget_t **new_widgets;
    txt_widget_t *widget;
    int new_num_widgets;
    int i, j, x;

    // We need as many full rows as are in the current list, plus the
    // remainder from the last row.
    new_num_widgets = (table->num_widgets / table->columns) * new_columns
                    + (table->num_widgets % table->columns);
    new_widgets = calloc(new_num_widgets, sizeof(txt_widget_t *));

    // Reset and add one by one from the old table.
    new_num_widgets = 0;

    for (i = 0; i < table->num_widgets; ++i)
    {
        widget = table->widgets[i];
        x = i % table->columns;

        if (x < new_columns)
        {
            new_widgets[new_num_widgets] = widget;
            ++new_num_widgets;
        }
        else if (IsActualWidget(widget))
        {
            TXT_DestroyWidget(widget);
        }

        // When we reach the last column of a row, we must pad it out with
        // extra widgets to reach the next row.
        if (x == table->columns - 1)
        {
            for (j = table->columns; j < new_columns; ++j)
            {
                // First row? We need to add struts that are used to apply
                // the column widths.
                if (i < table->columns)
                {
                    widget = &TXT_NewStrut(0, 0)->widget;
                }
                else
                {
                    widget = &txt_table_overflow_right;
                }
                new_widgets[new_num_widgets] = widget;
                ++new_num_widgets;
            }
        }
    }

    free(table->widgets);
    table->widgets = new_widgets;
    table->num_widgets = new_num_widgets;
    table->columns = new_columns;
}

// Sets the widths of columns in a table.

void TXT_SetColumnWidths(TXT_UNCAST_ARG(table), ...)
{
    TXT_CAST_ARG(txt_table_t, table);
    va_list args;
    txt_strut_t *strut;
    int i;
    int width;

    va_start(args, TXT_UNCAST_ARG_NAME(table));

    for (i=0; i<table->columns; ++i)
    {
        width = va_arg(args, int);

        strut = (txt_strut_t *) table->widgets[i];
        strut->width = width;
    }

    va_end(args);
}

// Moves the select by at least the given number of characters.
// Currently quietly ignores pagex, as we don't use it.

int TXT_PageTable(TXT_UNCAST_ARG(table), int pagex, int pagey)
{
    TXT_CAST_ARG(txt_table_t, table);
    unsigned int *column_widths;
    unsigned int *row_heights;
    int rows;
    int changed = 0;

    rows = TableRows(table);

    row_heights = malloc(sizeof(int) * rows);
    column_widths = malloc(sizeof(int) * table->columns);

    CalcRowColSizes(table, row_heights, column_widths);

    if (pagex)
    {
        // @todo Jump selection to the left or right as needed
    }

    if (pagey)
    {
        int new_x, new_y;
        int distance = 0;
        int dir;

        // What direction are we moving?

        if (pagey > 0)
        {
            dir = 1;
        }
        else
        {
            dir = -1;
        }

        // Move the cursor until the desired distance is reached.

        new_y = table->selected_y;

        while (new_y >= 0 && new_y < rows)
        {
            // We are about to travel a distance equal to the height of the row
            // we are about to leave.

            distance += row_heights[new_y];

            // *Now* increment the loop.

            new_y += dir;

            new_x = FindSelectableColumn(table, new_y, table->selected_x);

            if (new_x >= 0)
            {
                // Found a selectable widget in this column!
                // Select it anyway in case we don't find something better.

                ChangeSelection(table, new_x, new_y);
                changed = 1;

                // ...but is it far enough away?

                if (distance >= abs(pagey))
                {
                    break;
                }
            }
        }
    }

    free(row_heights);
    free(column_widths);

    return changed;
}

