mirror of
https://github.com/aseprite/aseprite.git
synced 2024-10-05 14:29:45 +00:00
77c009de55
Refactored jwidget_set_text to Widget::setText (same for setFont, setEnabled, etc.). Created "Frame" class. Refactored "jwindow_funcname" functions to "Frame::funcname". Renamed JWidgetPtr to FramePtr.
625 lines
17 KiB
C++
625 lines
17 KiB
C++
/* Jinete - a GUI library
|
|
* Copyright (C) 2003-2009 David Capello.
|
|
* 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.
|
|
* * Neither the name of the author nor the names of its contributors may
|
|
* be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "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 COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS 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.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
#include "jinete/jlist.h"
|
|
#include "jinete/jmessage.h"
|
|
#include "jinete/jrect.h"
|
|
#include "jinete/jwidget.h"
|
|
#include "jinete/jtheme.h"
|
|
|
|
struct Cell
|
|
{
|
|
struct Cell *parent;
|
|
JWidget child;
|
|
int hspan;
|
|
int vspan;
|
|
int align;
|
|
int w, h;
|
|
};
|
|
|
|
struct Strip
|
|
{
|
|
int size;
|
|
int expand_count;
|
|
};
|
|
|
|
struct Grid
|
|
{
|
|
bool same_width_columns;
|
|
int cols;
|
|
int rows;
|
|
Strip *colstrip;
|
|
Strip *rowstrip;
|
|
Cell **cells;
|
|
};
|
|
|
|
static bool grid_msg_proc(JWidget widget, JMessage msg);
|
|
static void grid_request_size(JWidget widget, int *w, int *h);
|
|
static void grid_set_position(JWidget widget, JRect rect);
|
|
static void grid_calculate_size(JWidget widget);
|
|
static void grid_distribute_size(JWidget widget, JRect rect);
|
|
static bool grid_put_widget_in_cell(JWidget widget, JWidget child, int hspan, int vspan, int align);
|
|
static void grid_expand_rows(JWidget widget, int rows);
|
|
static void grid_inc_col_size(Grid *grid, int col, int size);
|
|
static void grid_inc_row_size(Grid *grid, int row, int size);
|
|
|
|
JWidget jgrid_new(int columns, bool same_width_columns)
|
|
{
|
|
Widget* widget = new Widget(JI_GRID);
|
|
Grid *grid = jnew(Grid, 1);
|
|
int col;
|
|
|
|
assert(columns > 0);
|
|
|
|
grid->same_width_columns = same_width_columns;
|
|
grid->cols = columns;
|
|
grid->rows = 0;
|
|
grid->colstrip = (Strip*)jmalloc(sizeof(Strip) * grid->cols);
|
|
grid->rowstrip = NULL;
|
|
grid->cells = NULL;
|
|
|
|
for (col=0; col<grid->cols; ++col) {
|
|
grid->colstrip[col].size = 0;
|
|
grid->colstrip[col].expand_count = 0;
|
|
}
|
|
|
|
jwidget_add_hook(widget, JI_GRID, grid_msg_proc, grid);
|
|
jwidget_init_theme(widget);
|
|
|
|
return widget;
|
|
}
|
|
|
|
/**
|
|
* Adds a child widget in the specified grid.
|
|
*
|
|
* @param widget The grid widget.
|
|
* @param child The child widget.
|
|
* @param hspan
|
|
* @param vspan
|
|
* @param align
|
|
* It's a combination of the following values:
|
|
*
|
|
* - JI_HORIZONTAL: The widget'll get excess horizontal space.
|
|
* - JI_VERTICAL: The widget'll get excess vertical space.
|
|
*
|
|
* - JI_LEFT: Sets horizontal alignment to the beginning of cell.
|
|
* - JI_CENTER: Sets horizontal alignment to the center of cell.
|
|
* - JI_RIGHT: Sets horizontal alignment to the end of cell.
|
|
* - None: Uses the whole horizontal space of the cell.
|
|
*
|
|
* - JI_TOP: Sets vertical alignment to the beginning of the cell.
|
|
* - JI_MIDDLE: Sets vertical alignment to the center of the cell.
|
|
* - JI_BOTTOM: Sets vertical alignment to the end of the cell.
|
|
* - None: Uses the whole vertical space of the cell.
|
|
*/
|
|
void jgrid_add_child(JWidget widget, JWidget child,
|
|
int hspan, int vspan, int align)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
|
|
assert(hspan > 0);
|
|
assert(vspan > 0);
|
|
|
|
jwidget_add_child(widget, child);
|
|
|
|
if (!grid_put_widget_in_cell(widget, child, hspan, vspan, align)) {
|
|
grid_expand_rows(widget, grid->rows+1);
|
|
grid_put_widget_in_cell(widget, child, hspan, vspan, align);
|
|
}
|
|
}
|
|
|
|
static bool grid_msg_proc(JWidget widget, JMessage msg)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
|
|
switch (msg->type) {
|
|
|
|
case JM_DESTROY:
|
|
if (grid->cells != NULL) {
|
|
int row;
|
|
for (row=0; row<grid->rows; ++row)
|
|
jfree(grid->cells[row]);
|
|
jfree(grid->cells);
|
|
}
|
|
|
|
if (grid->colstrip != NULL)
|
|
jfree(grid->colstrip);
|
|
|
|
if (grid->rowstrip != NULL)
|
|
jfree(grid->rowstrip);
|
|
|
|
jfree(grid);
|
|
break;
|
|
|
|
case JM_REQSIZE:
|
|
grid_request_size(widget, &msg->reqsize.w, &msg->reqsize.h);
|
|
return true;
|
|
|
|
case JM_SETPOS:
|
|
grid_set_position(widget, &msg->setpos.rect);
|
|
return true;
|
|
|
|
case JM_DRAW:
|
|
widget->theme->draw_grid(widget, &msg->draw.rect);
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void grid_request_size(JWidget widget, int *w, int *h)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
int i, j;
|
|
|
|
grid_calculate_size(widget);
|
|
|
|
/* calculate the total */
|
|
|
|
#define SUMSTRIPS(p_cols, p_colstrip, p_w) \
|
|
*p_w = 0; \
|
|
for (i=j=0; i<grid->p_cols; ++i) { \
|
|
if (grid->p_colstrip[i].size > 0) { \
|
|
*p_w += grid->p_colstrip[i].size; \
|
|
if (++j > 1) \
|
|
*p_w += widget->child_spacing; \
|
|
} \
|
|
}
|
|
|
|
SUMSTRIPS(cols, colstrip, w);
|
|
SUMSTRIPS(rows, rowstrip, h);
|
|
|
|
*w += widget->border_width.l + widget->border_width.r;
|
|
*h += widget->border_width.t + widget->border_width.b;
|
|
}
|
|
|
|
static void grid_set_position(JWidget widget, JRect rect)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
JRect cpos = jrect_new(0, 0, 0, 0);
|
|
int pos_x, pos_y;
|
|
int req_w, req_h;
|
|
int x, y, w, h;
|
|
int col, row;
|
|
int i, j;
|
|
Cell *cell;
|
|
|
|
jrect_copy(widget->rc, rect);
|
|
|
|
grid_calculate_size(widget);
|
|
grid_distribute_size(widget, rect);
|
|
|
|
pos_y = rect->y1 + widget->border_width.t;
|
|
for (row=0; row<grid->rows; ++row) {
|
|
pos_x = rect->x1 + widget->border_width.l;
|
|
|
|
cell = grid->cells[row];
|
|
for (col=0; col<grid->cols; ++col, ++cell) {
|
|
if (cell->child != NULL &&
|
|
cell->parent == NULL &&
|
|
!(cell->child->flags & JI_HIDDEN)) {
|
|
x = pos_x;
|
|
y = pos_y;
|
|
w = 0;
|
|
h = 0;
|
|
|
|
#define CALCULATE_CELL_SIZE(p_col, p_span, p_colstrip, p_w) \
|
|
for (i=p_col,j=0; i<p_col+cell->p_span; ++i) { \
|
|
if (grid->p_colstrip[i].size > 0) { \
|
|
p_w += grid->p_colstrip[i].size; \
|
|
if (++j > 1) \
|
|
p_w += widget->child_spacing; \
|
|
} \
|
|
}
|
|
|
|
CALCULATE_CELL_SIZE(col, hspan, colstrip, w);
|
|
CALCULATE_CELL_SIZE(row, vspan, rowstrip, h);
|
|
|
|
jwidget_request_size(cell->child, &req_w, &req_h);
|
|
|
|
if (cell->align & JI_LEFT) {
|
|
w = req_w;
|
|
}
|
|
else if (cell->align & JI_CENTER) {
|
|
x += w/2 - req_w/2;
|
|
w = req_w;
|
|
}
|
|
else if (cell->align & JI_RIGHT) {
|
|
x += w - req_w;
|
|
w = req_w;
|
|
}
|
|
|
|
if (cell->align & JI_TOP) {
|
|
h = req_h;
|
|
}
|
|
else if (cell->align & JI_MIDDLE) {
|
|
y += h/2 - req_h/2;
|
|
h = req_h;
|
|
}
|
|
else if (cell->align & JI_BOTTOM) {
|
|
y += h - req_h;
|
|
h = req_h;
|
|
}
|
|
|
|
jrect_replace(cpos, x, y, x+w, y+h);
|
|
jwidget_set_rect(cell->child, cpos);
|
|
}
|
|
|
|
if (grid->colstrip[col].size > 0)
|
|
pos_x += grid->colstrip[col].size + widget->child_spacing;
|
|
}
|
|
|
|
if (grid->rowstrip[row].size > 0)
|
|
pos_y += grid->rowstrip[row].size + widget->child_spacing;
|
|
}
|
|
|
|
jrect_free(cpos);
|
|
}
|
|
|
|
/**
|
|
* Calculates the size of each strip (rows and columns) in the grid.
|
|
*/
|
|
static void grid_calculate_size(JWidget widget)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
int row, col, size;
|
|
int req_w, req_h;
|
|
int i, expand;
|
|
int expand_count;
|
|
int last_expand;
|
|
int current_span;
|
|
bool more_span;
|
|
Cell *cell;
|
|
|
|
if (grid->rows == 0)
|
|
return;
|
|
|
|
#define CALCULATE_STRIPS(p_col, p_cols, p_row, p_rows, p_span, \
|
|
p_req, p_colstrip, p_align) \
|
|
/* for each column */ \
|
|
for (p_col=0; p_col<grid->p_cols; ++p_col) { \
|
|
/* a counter of widgets that want more space in this column */ \
|
|
expand_count = 0; \
|
|
/* for each row */ \
|
|
for (p_row=0; p_row<grid->p_rows; ++p_row) { \
|
|
/* for each cell */ \
|
|
cell = grid->cells[row]+col; \
|
|
req_w = req_h = 0; \
|
|
\
|
|
if (cell->child != NULL) { \
|
|
if (cell->parent == NULL) { \
|
|
/* if the widget isn't hidden then we can request its size */ \
|
|
if (!(cell->child->flags & JI_HIDDEN)) { \
|
|
jwidget_request_size(cell->child, &req_w, &req_h); \
|
|
cell->w = req_w - (cell->hspan-1) * widget->child_spacing; \
|
|
cell->h = req_h - (cell->vspan-1) * widget->child_spacing; \
|
|
if ((cell->align & p_align) == p_align) \
|
|
++expand_count; \
|
|
} \
|
|
else \
|
|
cell->w = cell->h = 0; \
|
|
} \
|
|
else { \
|
|
if (!(cell->child->flags & JI_HIDDEN)) { \
|
|
if ((cell->parent->align & p_align) == p_align) \
|
|
++expand_count; \
|
|
} \
|
|
} \
|
|
p_row += cell->p_span-1; \
|
|
} \
|
|
} \
|
|
grid->p_colstrip[p_col].size = 0; \
|
|
grid->p_colstrip[p_col].expand_count = expand_count; \
|
|
}
|
|
|
|
#define EXPAND_STRIPS(p_col, p_cols, p_row, p_rows, p_span, \
|
|
p_size, p_colstrip, p_inc_col) \
|
|
current_span = 1; \
|
|
do { \
|
|
more_span = false; \
|
|
for (p_col=0; p_col<grid->p_cols; ++p_col) { \
|
|
for (p_row=0; p_row<grid->p_rows; ++p_row) { \
|
|
cell = grid->cells[row]+col; \
|
|
\
|
|
if (cell->child != NULL && cell->parent == NULL && \
|
|
cell->p_size > 0) { \
|
|
assert(cell->p_span > 0); \
|
|
\
|
|
if (cell->p_span == current_span) { \
|
|
expand = 0; \
|
|
expand_count = 0; \
|
|
last_expand = 0; \
|
|
\
|
|
for (i=p_col; i<p_col+cell->p_span; ++i) \
|
|
expand_count = MAX(expand_count, \
|
|
grid->p_colstrip[i].expand_count); \
|
|
\
|
|
for (i=p_col; i<p_col+cell->p_span; ++i) { \
|
|
if (grid->p_colstrip[i].expand_count == expand_count) { \
|
|
++expand; \
|
|
last_expand = i; \
|
|
} \
|
|
} \
|
|
\
|
|
size = cell->p_size / expand; \
|
|
\
|
|
for (i=p_col; i<p_col+cell->p_span; ++i) { \
|
|
if (grid->p_colstrip[i].expand_count == expand_count) { \
|
|
if (last_expand == i) \
|
|
size = cell->p_size; \
|
|
\
|
|
p_inc_col(grid, i, size); \
|
|
} \
|
|
} \
|
|
} \
|
|
else if (cell->p_span > current_span) { \
|
|
more_span = true; \
|
|
} \
|
|
} \
|
|
} \
|
|
} \
|
|
++current_span; \
|
|
} while (more_span);
|
|
|
|
CALCULATE_STRIPS(col, cols, row, rows, vspan, req_w, colstrip, JI_HORIZONTAL);
|
|
CALCULATE_STRIPS(row, rows, col, cols, hspan, req_h, rowstrip, JI_VERTICAL);
|
|
EXPAND_STRIPS(col, cols, row, rows, hspan, w, colstrip, grid_inc_col_size);
|
|
EXPAND_STRIPS(row, rows, col, cols, vspan, h, rowstrip, grid_inc_row_size);
|
|
|
|
/* same width in all columns */
|
|
if (grid->same_width_columns) {
|
|
int max_w = 0;
|
|
for (col=0; col<grid->cols; ++col)
|
|
max_w = MAX(max_w, grid->colstrip[col].size);
|
|
|
|
for (col=0; col<grid->cols; ++col)
|
|
grid->colstrip[col].size = max_w;
|
|
}
|
|
}
|
|
|
|
static void grid_distribute_size(JWidget widget, JRect rect)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
int total_req, expand_count, wantmore_count;
|
|
int i, j;
|
|
int extra_total;
|
|
int extra_foreach;
|
|
|
|
if (grid->rows == 0)
|
|
return;
|
|
|
|
#define DISTRIBUTE_SIZE(p_cols, p_colstrip, p_l, p_r, \
|
|
p_jrect_w, p_same_width) \
|
|
expand_count = 0; \
|
|
for (i=0; i<grid->p_cols; ++i) \
|
|
expand_count = MAX(expand_count, \
|
|
grid->p_colstrip[i].expand_count); \
|
|
\
|
|
total_req = 0; \
|
|
wantmore_count = 0; \
|
|
for (i=j=0; i<grid->p_cols; ++i) { \
|
|
if (grid->p_colstrip[i].size > 0) { \
|
|
total_req += grid->p_colstrip[i].size; \
|
|
if (++j > 1) \
|
|
total_req += widget->child_spacing; \
|
|
} \
|
|
\
|
|
if (grid->p_colstrip[i].expand_count == expand_count || \
|
|
p_same_width) { \
|
|
++wantmore_count; \
|
|
} \
|
|
} \
|
|
total_req += widget->border_width.p_l + widget->border_width.p_r; \
|
|
\
|
|
if (wantmore_count > 0) { \
|
|
extra_total = p_jrect_w(rect) - total_req; \
|
|
if (extra_total > 0) { \
|
|
/* if a expandable column-strip was empty (size=0) then */ \
|
|
/* we have to reduce the extra_total size because a new */ \
|
|
/* child-spacing is added by this column */ \
|
|
for (i=0; i<grid->p_cols; ++i) { \
|
|
if ((grid->p_colstrip[i].size == 0) && \
|
|
(grid->p_colstrip[i].expand_count == expand_count || \
|
|
p_same_width)) { \
|
|
extra_total -= widget->child_spacing; \
|
|
} \
|
|
} \
|
|
\
|
|
extra_foreach = extra_total / wantmore_count; \
|
|
\
|
|
for (i=0; i<grid->p_cols; ++i) { \
|
|
if (grid->p_colstrip[i].expand_count == expand_count || \
|
|
p_same_width) { \
|
|
assert(wantmore_count > 0); \
|
|
\
|
|
grid->p_colstrip[i].size += extra_foreach; \
|
|
extra_total -= extra_foreach; \
|
|
\
|
|
if (--wantmore_count == 0) { \
|
|
grid->p_colstrip[i].size += extra_total; \
|
|
extra_total = 0; \
|
|
} \
|
|
} \
|
|
} \
|
|
assert(wantmore_count == 0); \
|
|
assert(extra_total == 0); \
|
|
} \
|
|
}
|
|
|
|
DISTRIBUTE_SIZE(cols, colstrip, l, r, jrect_w, grid->same_width_columns);
|
|
DISTRIBUTE_SIZE(rows, rowstrip, t, b, jrect_h, false);
|
|
}
|
|
|
|
static bool grid_put_widget_in_cell(JWidget widget, JWidget child, int hspan, int vspan, int align)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
int col, row, colbeg, colend, rowend;
|
|
Cell *cell, *parentcell;
|
|
|
|
for (row=0; row<grid->rows; ++row) {
|
|
cell = grid->cells[row];
|
|
for (col=0; col<grid->cols; ++col, ++cell) {
|
|
if (cell->child == NULL) {
|
|
cell->child = child;
|
|
cell->hspan = hspan;
|
|
cell->vspan = vspan;
|
|
cell->align = align;
|
|
|
|
parentcell = cell;
|
|
colbeg = col;
|
|
colend = MIN(col+hspan, grid->cols);
|
|
rowend = row+vspan;
|
|
|
|
grid_expand_rows(widget, row+vspan);
|
|
|
|
for (++col, ++cell; col<colend; ++col, ++cell) {
|
|
/* if these asserts fails, it's really possible that you
|
|
specified bad values for hspan or vspan (they are
|
|
overlapping with other cells) */
|
|
assert(cell->parent == NULL);
|
|
assert(cell->child == NULL);
|
|
|
|
cell->parent = parentcell;
|
|
cell->child = child;
|
|
cell->hspan = colend - col;
|
|
cell->vspan = rowend - row;
|
|
}
|
|
|
|
for (++row; row<rowend; ++row) {
|
|
for (col=colbeg; col<colend; ++col) {
|
|
cell = grid->cells[row]+col;
|
|
|
|
assert(cell->parent == NULL);
|
|
assert(cell->child == NULL);
|
|
|
|
cell->parent = parentcell;
|
|
cell->child = child;
|
|
cell->hspan = colend - col;
|
|
cell->vspan = rowend - row;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Expands the grid's rows to reach the specified quantity of rows in
|
|
* the parameter.
|
|
*/
|
|
static void grid_expand_rows(JWidget widget, int rows)
|
|
{
|
|
Grid* grid = reinterpret_cast<Grid*>(jwidget_get_data(widget, JI_GRID));
|
|
Cell* cell;
|
|
int row;
|
|
|
|
if (grid->rows < rows) {
|
|
grid->cells = (Cell**)jrealloc(grid->cells, sizeof(Cell*) * rows);
|
|
grid->rowstrip = (Strip*)jrealloc(grid->rowstrip, sizeof(Strip) * rows);
|
|
|
|
for (row=grid->rows; row<rows; ++row) {
|
|
grid->cells[row] = (Cell*)jmalloc(sizeof(Cell)*grid->cols);
|
|
grid->rowstrip[row].size = 0;
|
|
grid->rowstrip[row].expand_count = 0;
|
|
|
|
for (cell=grid->cells[row];
|
|
cell<grid->cells[row]+grid->cols; ++cell) {
|
|
cell->parent = NULL;
|
|
cell->child = NULL;
|
|
cell->hspan = 0;
|
|
cell->vspan = 0;
|
|
cell->align = 0;
|
|
cell->w = 0;
|
|
cell->h = 0;
|
|
}
|
|
}
|
|
|
|
grid->rows = rows;
|
|
}
|
|
}
|
|
|
|
static void grid_inc_col_size(Grid *grid, int col, int size)
|
|
{
|
|
Cell *cell;
|
|
int row;
|
|
|
|
grid->colstrip[col].size += size;
|
|
|
|
for (row=0; row<grid->rows; ) {
|
|
cell = grid->cells[row]+col;
|
|
|
|
if (cell->child != NULL) {
|
|
if (cell->parent != NULL)
|
|
cell->parent->w -= size;
|
|
else
|
|
cell->w -= size;
|
|
|
|
row += cell->vspan;
|
|
}
|
|
else
|
|
++row;
|
|
}
|
|
}
|
|
|
|
static void grid_inc_row_size(Grid *grid, int row, int size)
|
|
{
|
|
Cell *cell;
|
|
int col;
|
|
|
|
grid->rowstrip[row].size += size;
|
|
|
|
for (col=0; col<grid->cols; ) {
|
|
cell = grid->cells[row]+col;
|
|
|
|
if (cell->child != NULL) {
|
|
if (cell->parent != NULL)
|
|
cell->parent->h -= size;
|
|
else
|
|
cell->h -= size;
|
|
|
|
col += cell->hspan;
|
|
}
|
|
else
|
|
++col;
|
|
}
|
|
}
|