mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-06 12:43:53 +00:00
4524 lines
91 KiB
C
4524 lines
91 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "xp.h"
|
|
#include "shist.h"
|
|
#include "pa_parse.h"
|
|
#include "layout.h"
|
|
#include "libmocha.h"
|
|
|
|
|
|
#define TOP_EDGE 0
|
|
#define BOTTOM_EDGE 1
|
|
#define LEFT_EDGE 2
|
|
#define RIGHT_EDGE 3
|
|
|
|
|
|
static lo_GridPercent *
|
|
lo_parse_percent_list(MWContext *context, char *str, int32 *rows)
|
|
{
|
|
char *tptr;
|
|
int32 i, cnt;
|
|
lo_GridPercent *percent_list;
|
|
|
|
if ((str == NULL)||(*str == '\0'))
|
|
{
|
|
return((lo_GridPercent *)NULL);
|
|
}
|
|
|
|
cnt = 0;
|
|
tptr = strchr(str, ',');
|
|
while (tptr != NULL)
|
|
{
|
|
cnt++;
|
|
tptr++;
|
|
tptr = strchr(tptr, ',');
|
|
}
|
|
cnt++;
|
|
*rows = cnt;
|
|
|
|
percent_list = (lo_GridPercent *)XP_ALLOC(cnt * sizeof(lo_GridPercent));
|
|
if (percent_list == NULL)
|
|
{
|
|
return((lo_GridPercent *)NULL);
|
|
}
|
|
|
|
tptr = str;
|
|
for (i=0; i<cnt; i++)
|
|
{
|
|
char *ptr;
|
|
char *end_ptr;
|
|
|
|
ptr = strchr(tptr, ',');
|
|
if (ptr != NULL)
|
|
{
|
|
*ptr = '\0';
|
|
}
|
|
|
|
/*
|
|
* Need the end of the string to check if the number
|
|
* ends in '%', '*', or 'p'.
|
|
*/
|
|
if (ptr != NULL)
|
|
{
|
|
end_ptr = (char *)(ptr - 1);
|
|
if (end_ptr < tptr)
|
|
{
|
|
end_ptr = tptr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
end_ptr = (char *)(str + XP_STRLEN(str) - 1);
|
|
}
|
|
|
|
if (*end_ptr == '*')
|
|
{
|
|
percent_list[i].type = LO_PERCENT_FREE;
|
|
percent_list[i].original_value = (int32)XP_ATOI(tptr);
|
|
if (percent_list[i].original_value < 1)
|
|
{
|
|
percent_list[i].original_value = 1;
|
|
}
|
|
}
|
|
else if (*end_ptr == '%')
|
|
{
|
|
percent_list[i].type = LO_PERCENT_NORMAL;
|
|
percent_list[i].original_value = (int32)XP_ATOI(tptr);
|
|
if (percent_list[i].original_value <= 0)
|
|
{
|
|
percent_list[i].original_value = 100 / cnt;
|
|
if (percent_list[i].original_value == 0)
|
|
{
|
|
percent_list[i].original_value = 1;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
* Default is in "pixels"
|
|
*/
|
|
else
|
|
{
|
|
int32 val;
|
|
|
|
percent_list[i].type = LO_PERCENT_FIXED;
|
|
val = (int32)XP_ATOI(tptr);
|
|
val = FEUNITS_X(val, context);
|
|
if (val < 1)
|
|
{
|
|
val = 1;
|
|
}
|
|
percent_list[i].original_value = val;
|
|
}
|
|
|
|
if (ptr != NULL)
|
|
{
|
|
*ptr = ',';
|
|
tptr = (char *)(ptr + 1);
|
|
}
|
|
}
|
|
return(percent_list);
|
|
}
|
|
|
|
|
|
void
|
|
lo_FreeGridEdge(lo_GridEdge *edge)
|
|
{
|
|
if (edge->cell_array != NULL)
|
|
{
|
|
XP_FREE(edge->cell_array);
|
|
}
|
|
XP_DELETE(edge);
|
|
}
|
|
|
|
|
|
void
|
|
lo_FreeGridRec(lo_GridRec *grid)
|
|
{
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (grid->row_percents != NULL)
|
|
{
|
|
XP_FREE(grid->row_percents);
|
|
}
|
|
if (grid->col_percents != NULL)
|
|
{
|
|
XP_FREE(grid->col_percents);
|
|
}
|
|
|
|
if (grid->edge_list != NULL)
|
|
{
|
|
lo_GridEdge *tmp_edge;
|
|
lo_GridEdge *edge_list;
|
|
|
|
edge_list = grid->edge_list;
|
|
while (edge_list != NULL)
|
|
{
|
|
tmp_edge = edge_list;
|
|
edge_list = edge_list->next;
|
|
lo_FreeGridEdge(tmp_edge);
|
|
}
|
|
}
|
|
|
|
XP_DELETE(grid);
|
|
}
|
|
|
|
|
|
void
|
|
lo_FreeGridCellRec(MWContext *context, lo_GridRec *grid, lo_GridCellRec *cell)
|
|
{
|
|
History_entry *hist;
|
|
|
|
if (cell == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cell->url != NULL)
|
|
{
|
|
XP_FREE(cell->url);
|
|
}
|
|
if (cell->name != NULL)
|
|
{
|
|
XP_FREE(cell->name);
|
|
}
|
|
if (cell->context != NULL)
|
|
{
|
|
/*
|
|
* If the cell has a context, use it instead of the
|
|
* parent's context. Otherwise use the parent context.
|
|
* This is bogus but needed to keep the winfe from
|
|
* dumping because it blindly dereferences the context
|
|
* even though it doesn't use it.
|
|
*/
|
|
context = cell->context;
|
|
}
|
|
if (cell->hist_list != NULL)
|
|
{
|
|
XP_List *list_ptr;
|
|
|
|
list_ptr = (XP_List *)cell->hist_list;
|
|
hist = (History_entry *)XP_ListRemoveTopObject(list_ptr);
|
|
while (hist != NULL)
|
|
{
|
|
SHIST_DropEntry(context, hist);
|
|
hist =(History_entry *)XP_ListRemoveTopObject(list_ptr);
|
|
}
|
|
XP_ListDestroy(list_ptr);
|
|
}
|
|
if (cell->hist_array != NULL)
|
|
{
|
|
int32 i;
|
|
|
|
for (i = 0; i < grid->hist_size; i++)
|
|
{
|
|
hist = (History_entry *)cell->hist_array[i].hist;
|
|
SHIST_DropEntry(context, hist);
|
|
}
|
|
XP_FREE(cell->hist_array);
|
|
}
|
|
XP_DELETE(cell);
|
|
}
|
|
|
|
|
|
static lo_GridEdge *
|
|
lo_new_horizontal_edge(MWContext *context, lo_DocState *state,
|
|
int32 cols, int32 x, int32 y, int32 width, int32 height)
|
|
{
|
|
lo_GridEdge *edge;
|
|
LO_EdgeStruct *fe_edge;
|
|
|
|
edge = XP_NEW(lo_GridEdge);
|
|
if (edge == NULL)
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
fe_edge = (LO_EdgeStruct *)lo_NewElement(context, state, LO_EDGE, NULL, 0);
|
|
if (fe_edge == NULL)
|
|
{
|
|
XP_DELETE(edge);
|
|
return(NULL);
|
|
}
|
|
|
|
edge->x = x;
|
|
edge->y = y;
|
|
edge->width = width;
|
|
edge->height = height;
|
|
edge->is_vertical = FALSE;
|
|
edge->left_top_bound = 0;
|
|
edge->right_bottom_bound = 0;
|
|
edge->cell_cnt = 0;
|
|
edge->cell_max = 0;
|
|
edge->cell_array = NULL;
|
|
edge->next = NULL;
|
|
|
|
if (cols > 0)
|
|
{
|
|
int32 cells;
|
|
|
|
cells = 2 * cols;
|
|
edge->cell_array = (lo_GridCellRec **)XP_ALLOC(cells *
|
|
sizeof(lo_GridCellRec *));
|
|
if (edge->cell_array != NULL)
|
|
{
|
|
edge->cell_max = cells;
|
|
}
|
|
}
|
|
|
|
fe_edge->type = LO_EDGE;
|
|
fe_edge->ele_id = NEXT_ELEMENT;
|
|
fe_edge->x = x;
|
|
fe_edge->x_offset = 0;
|
|
fe_edge->y = y;
|
|
fe_edge->y_offset = 0;
|
|
fe_edge->width = edge->width;
|
|
fe_edge->height = edge->height;
|
|
fe_edge->line_height = 0;
|
|
fe_edge->next = NULL;
|
|
fe_edge->prev = NULL;
|
|
|
|
fe_edge->FE_Data = NULL;
|
|
fe_edge->lo_edge_info = (void *)edge;
|
|
fe_edge->is_vertical = edge->is_vertical;
|
|
fe_edge->visible = TRUE;
|
|
fe_edge->movable = TRUE;
|
|
fe_edge->left_top_bound = 0;
|
|
fe_edge->right_bottom_bound = 0;
|
|
|
|
edge->fe_edge = fe_edge;
|
|
|
|
return(edge);
|
|
}
|
|
|
|
|
|
static lo_GridEdge *
|
|
lo_new_vertical_edge(MWContext *context, lo_DocState *state,
|
|
int32 rows, int32 x, int32 y, int32 width, int32 height)
|
|
{
|
|
lo_GridEdge *edge;
|
|
LO_EdgeStruct *fe_edge;
|
|
|
|
edge = XP_NEW(lo_GridEdge);
|
|
if (edge == NULL)
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
fe_edge = (LO_EdgeStruct *)lo_NewElement(context, state, LO_EDGE, NULL, 0);
|
|
if (fe_edge == NULL)
|
|
{
|
|
XP_DELETE(edge);
|
|
return(NULL);
|
|
}
|
|
|
|
edge->x = x;
|
|
edge->y = y;
|
|
edge->width = width;
|
|
edge->height = height;
|
|
edge->is_vertical = TRUE;
|
|
edge->left_top_bound = 0;
|
|
edge->right_bottom_bound = 0;
|
|
edge->cell_cnt = 0;
|
|
edge->cell_max = 0;
|
|
edge->cell_array = NULL;
|
|
edge->next = NULL;
|
|
|
|
if (rows > 0)
|
|
{
|
|
int32 cells;
|
|
|
|
cells = 2 * rows;
|
|
edge->cell_array = (lo_GridCellRec **)XP_ALLOC(cells *
|
|
sizeof(lo_GridCellRec *));
|
|
if (edge->cell_array != NULL)
|
|
{
|
|
edge->cell_max = cells;
|
|
}
|
|
}
|
|
|
|
fe_edge->type = LO_EDGE;
|
|
fe_edge->ele_id = NEXT_ELEMENT;
|
|
fe_edge->x = x;
|
|
fe_edge->x_offset = 0;
|
|
fe_edge->y = y;
|
|
fe_edge->y_offset = 0;
|
|
fe_edge->width = edge->width;
|
|
fe_edge->height = edge->height;
|
|
fe_edge->line_height = 0;
|
|
fe_edge->next = NULL;
|
|
fe_edge->prev = NULL;
|
|
|
|
fe_edge->FE_Data = NULL;
|
|
fe_edge->lo_edge_info = (void *)edge;
|
|
fe_edge->is_vertical = edge->is_vertical;
|
|
fe_edge->visible = TRUE;
|
|
fe_edge->movable = TRUE;
|
|
fe_edge->left_top_bound = 0;
|
|
fe_edge->right_bottom_bound = 0;
|
|
|
|
edge->fe_edge = fe_edge;
|
|
|
|
return(edge);
|
|
}
|
|
|
|
|
|
static void
|
|
lo_grow_edge_cell_array(lo_GridEdge *edge, int32 more)
|
|
{
|
|
lo_GridCellRec **old_array;
|
|
lo_GridCellRec **new_array;
|
|
int32 new_size;
|
|
|
|
/*
|
|
* Error condition, punt.
|
|
*/
|
|
if (more <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If we are not growing the array, but instead allocating a new
|
|
* array.
|
|
*/
|
|
if (edge->cell_max == 0)
|
|
{
|
|
edge->cell_array = (lo_GridCellRec **)XP_ALLOC(more *
|
|
sizeof(lo_GridCellRec *));
|
|
if (edge->cell_array != NULL)
|
|
{
|
|
edge->cell_max = more;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Attempt to grow the old array.
|
|
*/
|
|
new_size = edge->cell_max + more;
|
|
old_array = edge->cell_array;
|
|
new_array = (lo_GridCellRec **)XP_REALLOC(old_array, (new_size *
|
|
sizeof(lo_GridCellRec *)));
|
|
/*
|
|
* If realloc fails, punt.
|
|
*/
|
|
if (new_array == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
edge->cell_array = new_array;
|
|
edge->cell_max = new_size;
|
|
}
|
|
|
|
|
|
static void
|
|
lo_add_cell_to_edge(lo_GridEdge *edge, lo_GridCellRec *cell)
|
|
{
|
|
/*
|
|
* Error.
|
|
*/
|
|
if ((cell == NULL)||(edge == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If I did my math right earlier, this will never happen.
|
|
*/
|
|
if (edge->cell_cnt >= edge->cell_max)
|
|
{
|
|
lo_grow_edge_cell_array(edge, 1);
|
|
/*
|
|
* This may fail
|
|
*/
|
|
if (edge->cell_cnt >= edge->cell_max)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
edge->cell_array[edge->cell_cnt] = cell;
|
|
edge->cell_cnt++;
|
|
}
|
|
|
|
|
|
static void
|
|
lo_adjust_percents(int32 count, lo_GridPercent *percents, int32 max)
|
|
{
|
|
int32 i;
|
|
int32 fixed_percent;
|
|
int32 free_percent;
|
|
int32 total;
|
|
|
|
if (max == 0)
|
|
max = 1;
|
|
|
|
/*
|
|
* Total up the three different type of grid cell percentages.
|
|
*/
|
|
fixed_percent = 0;
|
|
free_percent = 0;
|
|
total = 0;
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_FIXED)
|
|
{
|
|
/*
|
|
* Now that we know the max dimension turn
|
|
* fixed pixel dimensions into percents.
|
|
*/
|
|
percents[i].value = 100 * percents[i].original_value / max;
|
|
if (percents[i].value < 1)
|
|
{
|
|
percents[i].value = 1;
|
|
}
|
|
fixed_percent += percents[i].value;
|
|
}
|
|
else if (percents[i].type == LO_PERCENT_FREE)
|
|
{
|
|
percents[i].value = percents[i].original_value;
|
|
free_percent += percents[i].original_value;
|
|
}
|
|
else
|
|
{
|
|
percents[i].value = percents[i].original_value;
|
|
total += percents[i].original_value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the user didn't explicitly use up all the space.
|
|
*/
|
|
if ((total + fixed_percent) < 100)
|
|
{
|
|
int32 val;
|
|
|
|
/*
|
|
* We have some free percentage cells that want to
|
|
* soak up the excess space.
|
|
*/
|
|
if (free_percent > 0)
|
|
{
|
|
int32 used;
|
|
int32 last_i;
|
|
|
|
last_i = -1;
|
|
used = 0;
|
|
val = 100 - (total + fixed_percent);
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_FREE)
|
|
{
|
|
percents[i].value *= val;
|
|
percents[i].value /= free_percent;
|
|
if (percents[i].value < 1)
|
|
{
|
|
percents[i].value = 1;
|
|
}
|
|
used += percents[i].value;
|
|
last_i = i;
|
|
}
|
|
}
|
|
/*
|
|
* Slop the extra into the last qualifying cell.
|
|
*/
|
|
if (((used + total + fixed_percent) < 100)&&
|
|
(last_i >= 0))
|
|
{
|
|
percents[last_i].value +=
|
|
(100 - total - fixed_percent - used);
|
|
}
|
|
}
|
|
/*
|
|
* Else we have no free cells, but have some normal
|
|
* percentage cells, distribute the extra space among them.
|
|
*/
|
|
else if (total > 0)
|
|
{
|
|
int32 used;
|
|
int32 last_i;
|
|
|
|
last_i = -1;
|
|
used = 0;
|
|
val = (100 - fixed_percent);
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_NORMAL)
|
|
{
|
|
percents[i].value *= val;
|
|
percents[i].value /= total;
|
|
used += percents[i].value;
|
|
last_i = i;
|
|
}
|
|
}
|
|
/*
|
|
* Slop the extra into the last qualifying cell.
|
|
*/
|
|
if ((used < val)&&(last_i >= 0))
|
|
{
|
|
percents[last_i].value += (val - used);
|
|
}
|
|
}
|
|
/*
|
|
* Else all we have are fixed percentage cells, we will
|
|
* have to grow them.
|
|
*/
|
|
else
|
|
{
|
|
int32 used;
|
|
|
|
used = 0;
|
|
for (i=0; i < count; i++)
|
|
{
|
|
percents[i].value *= 100;
|
|
percents[i].value /= (total + fixed_percent);
|
|
used += percents[i].value;
|
|
}
|
|
/*
|
|
* Slop the extra into the last cell.
|
|
*/
|
|
if ((used < 100)&&(count > 0))
|
|
{
|
|
percents[count - 1].value += (100 - used);
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
* Else if the user allocated too much space, we need to shrink
|
|
* something.
|
|
*/
|
|
else if ((total + fixed_percent) > 100)
|
|
{
|
|
int32 val;
|
|
|
|
/*
|
|
* If there is not too much fixed percentage
|
|
* added, we can just shrink the normal percentage
|
|
* cells to make things fit.
|
|
*/
|
|
if (fixed_percent <= 100)
|
|
{
|
|
int32 used;
|
|
int32 last_i;
|
|
|
|
last_i = -1;
|
|
used = 0;
|
|
val = (100 - fixed_percent);
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_NORMAL)
|
|
{
|
|
percents[i].value *= val;
|
|
percents[i].value /= total;
|
|
used += percents[i].value;
|
|
}
|
|
}
|
|
/*
|
|
* Since integer division always truncates, we either
|
|
* made it fit exactly, or overcompensated and made
|
|
* it too small.
|
|
*/
|
|
if ((used < val)&&(last_i >= 0))
|
|
{
|
|
percents[last_i].value += (val - used);
|
|
}
|
|
}
|
|
/*
|
|
* Else there is too much fixed percentage as well, we will
|
|
* just shrink all the cells.
|
|
*/
|
|
else
|
|
{
|
|
int32 used;
|
|
|
|
used = 0;
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_FREE)
|
|
{
|
|
percents[i].value = 0;
|
|
}
|
|
else
|
|
{
|
|
percents[i].value *= 100;
|
|
percents[i].value /=
|
|
(total + fixed_percent);
|
|
}
|
|
used += percents[i].value;
|
|
}
|
|
/*
|
|
* Since integer division always truncates, we either
|
|
* made it fit exactly, or overcompensated and made
|
|
* it too small.
|
|
*/
|
|
if (used < 100)
|
|
{
|
|
percents[count - 1].value += (100 - used);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
lo_adjust_subpercents(int32 count, lo_GridPercent *percents, int32 percent, int32 max)
|
|
{
|
|
int32 i;
|
|
int32 fixed_percent;
|
|
int32 free_percent;
|
|
int32 total;
|
|
|
|
if (max == 0)
|
|
max = 1;
|
|
|
|
/*
|
|
* Total up the three different type of grid cell percentages.
|
|
*/
|
|
fixed_percent = 0;
|
|
free_percent = 0;
|
|
total = 0;
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_FIXED)
|
|
{
|
|
/*
|
|
* Now that we know the max dimension turn
|
|
* fixed pixel dimensions into percents.
|
|
*/
|
|
percents[i].value = percent * percents[i].original_value / max;
|
|
if (percents[i].value < 1)
|
|
{
|
|
percents[i].value = 1;
|
|
}
|
|
fixed_percent += percents[i].value;
|
|
}
|
|
else if (percents[i].type == LO_PERCENT_FREE)
|
|
{
|
|
percents[i].value = percents[i].original_value;
|
|
free_percent += percents[i].original_value;
|
|
}
|
|
else
|
|
{
|
|
percents[i].value = percent * percents[i].original_value / 100;
|
|
total += percents[i].original_value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the user didn't explicitly use up all the space.
|
|
*/
|
|
if ((total + fixed_percent) < 100)
|
|
{
|
|
int32 val;
|
|
|
|
/*
|
|
* We have some free percentage cells that want to
|
|
* soak up the excess space.
|
|
*/
|
|
if (free_percent > 0)
|
|
{
|
|
int32 used;
|
|
int32 last_i;
|
|
|
|
last_i = -1;
|
|
used = 0;
|
|
val = 100 - (total + fixed_percent);
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_FREE)
|
|
{
|
|
percents[i].value *= val;
|
|
percents[i].value /= free_percent;
|
|
if (percents[i].value < 1)
|
|
{
|
|
percents[i].value = 1;
|
|
}
|
|
used += percents[i].value;
|
|
last_i = i;
|
|
}
|
|
}
|
|
/*
|
|
* Slop the extra into the last qualifying cell.
|
|
*/
|
|
if (((used + total + fixed_percent) < 100)&&
|
|
(last_i >= 0))
|
|
{
|
|
percents[last_i].value +=
|
|
(100 - total - fixed_percent - used);
|
|
}
|
|
}
|
|
/*
|
|
* Else we have no free cells, but have some normal
|
|
* percentage cells, distribute the extra space among them.
|
|
*/
|
|
else if (total > 0)
|
|
{
|
|
int32 used;
|
|
int32 last_i;
|
|
|
|
last_i = -1;
|
|
used = 0;
|
|
val = (100 - fixed_percent);
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_NORMAL)
|
|
{
|
|
percents[i].value *= val;
|
|
percents[i].value /= total;
|
|
used += percents[i].value;
|
|
last_i = i;
|
|
}
|
|
}
|
|
/*
|
|
* Slop the extra into the last qualifying cell.
|
|
*/
|
|
if ((used < val)&&(last_i >= 0))
|
|
{
|
|
percents[last_i].value += (val - used);
|
|
}
|
|
}
|
|
/*
|
|
* Else all we have are fixed percentage cells, we will
|
|
* have to grow them.
|
|
*/
|
|
else
|
|
{
|
|
int32 used;
|
|
|
|
used = 0;
|
|
for (i=0; i < count; i++)
|
|
{
|
|
percents[i].value *= 100;
|
|
percents[i].value /= (total + fixed_percent);
|
|
used += percents[i].value;
|
|
}
|
|
/*
|
|
* Slop the extra into the last cell.
|
|
*/
|
|
if ((used < 100)&&(count > 0))
|
|
{
|
|
percents[count - 1].value += (100 - used);
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
* Else if the user allocated too much space, we need to shrink
|
|
* something.
|
|
*/
|
|
else if ((total + fixed_percent) > 100)
|
|
{
|
|
int32 val;
|
|
|
|
/*
|
|
* If there is not too much fixed percentage
|
|
* added, we can just shrink the normal percentage
|
|
* cells to make things fit.
|
|
*/
|
|
if (fixed_percent <= 100)
|
|
{
|
|
int32 used;
|
|
int32 last_i;
|
|
|
|
last_i = -1;
|
|
used = 0;
|
|
val = (100 - fixed_percent);
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_NORMAL)
|
|
{
|
|
percents[i].value *= val;
|
|
percents[i].value /= total;
|
|
used += percents[i].value;
|
|
}
|
|
}
|
|
/*
|
|
* Since integer division always truncates, we either
|
|
* made it fit exactly, or overcompensated and made
|
|
* it too small.
|
|
*/
|
|
if ((used < val)&&(last_i >= 0))
|
|
{
|
|
percents[last_i].value += (val - used);
|
|
}
|
|
}
|
|
/*
|
|
* Else there is too much fixed percentage as well, we will
|
|
* just shrink all the cells.
|
|
*/
|
|
else
|
|
{
|
|
int32 used;
|
|
|
|
used = 0;
|
|
for (i=0; i < count; i++)
|
|
{
|
|
if (percents[i].type == LO_PERCENT_FREE)
|
|
{
|
|
percents[i].value = 0;
|
|
}
|
|
else
|
|
{
|
|
percents[i].value *= 100;
|
|
percents[i].value /=
|
|
(total + fixed_percent);
|
|
}
|
|
used += percents[i].value;
|
|
}
|
|
/*
|
|
* Since integer division always truncates, we either
|
|
* made it fit exactly, or overcompensated and made
|
|
* it too small.
|
|
*/
|
|
if (used < 100)
|
|
{
|
|
percents[count - 1].value += (100 - used);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
PRIVATE
|
|
void
|
|
lo_LayoutGridCells(MWContext *context, lo_DocState *state,
|
|
int32 x, int32 y, int32 width, int32 height,
|
|
lo_GridRec *grid, lo_GridEdge **edges)
|
|
{
|
|
int32 cols, rows;
|
|
int32 col_cnt, row_cnt;
|
|
int32 orig_x, orig_y;
|
|
lo_GridCellRec *cell_parent;
|
|
lo_GridCellRec *cell_list;
|
|
lo_GridEdge **col_edges;
|
|
lo_GridEdge *top_edge;
|
|
lo_GridEdge *new_edges[4]; /* top, bottom, left, right */
|
|
|
|
new_edges[TOP_EDGE] = NULL;
|
|
new_edges[BOTTOM_EDGE] = NULL;
|
|
new_edges[LEFT_EDGE] = NULL;
|
|
new_edges[RIGHT_EDGE] = NULL;
|
|
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
cols = grid->cols;
|
|
rows = grid->rows;
|
|
cell_list = grid->cell_list;
|
|
|
|
/*
|
|
* Allocate space for the temporary array of column
|
|
* edge pointer we will need here.
|
|
*/
|
|
col_edges = (lo_GridEdge **)XP_ALLOC(sizeof(lo_GridEdge *) * cols);
|
|
if (col_edges == NULL)
|
|
{
|
|
return;
|
|
}
|
|
top_edge = NULL;
|
|
|
|
/*
|
|
* If we came in with bounding edges, we are a sub-grid, and we need
|
|
* to increase the size of the cell arrays in those edges to reflect
|
|
* the extra cells now bordering them.
|
|
*/
|
|
if (edges[TOP_EDGE] != NULL)
|
|
{
|
|
int32 more;
|
|
|
|
more = (cols * 2) - 1;
|
|
lo_grow_edge_cell_array(edges[TOP_EDGE], more);
|
|
}
|
|
if (edges[BOTTOM_EDGE] != NULL)
|
|
{
|
|
int32 more;
|
|
|
|
more = (cols * 2) - 1;
|
|
lo_grow_edge_cell_array(edges[BOTTOM_EDGE], more);
|
|
}
|
|
if (edges[LEFT_EDGE] != NULL)
|
|
{
|
|
int32 more;
|
|
|
|
more = (rows * 2) - 1;
|
|
lo_grow_edge_cell_array(edges[LEFT_EDGE], more);
|
|
}
|
|
if (edges[RIGHT_EDGE] != NULL)
|
|
{
|
|
int32 more;
|
|
|
|
more = (rows * 2) - 1;
|
|
lo_grow_edge_cell_array(edges[RIGHT_EDGE], more);
|
|
}
|
|
|
|
orig_x = x;
|
|
orig_y = y;
|
|
col_cnt = 0;
|
|
row_cnt = 0;
|
|
cell_parent = NULL;
|
|
while (cell_list != NULL)
|
|
{
|
|
lo_GridEdge *tmp_edge;
|
|
|
|
tmp_edge = NULL; /* make gcc happy */
|
|
|
|
cell_list->width_percent =
|
|
(intn)grid->col_percents[col_cnt].value;
|
|
cell_list->has_percent_width =
|
|
(grid->col_percents[col_cnt].type != LO_PERCENT_FIXED);
|
|
cell_list->height_percent =
|
|
(intn)grid->row_percents[row_cnt].value;
|
|
cell_list->has_percent_height =
|
|
(grid->row_percents[row_cnt].type != LO_PERCENT_FIXED);
|
|
|
|
cell_list->x = x;
|
|
if (col_cnt != 0)
|
|
{
|
|
cell_list->x += grid->grid_cell_border;
|
|
}
|
|
cell_list->y = y;
|
|
if (row_cnt != 0)
|
|
{
|
|
cell_list->y += grid->grid_cell_border;
|
|
}
|
|
|
|
cell_list->width = width * (float)cell_list->width_percent / 100.0;
|
|
if (cell_list->width < grid->grid_cell_min_dim)
|
|
{
|
|
cell_list->width = grid->grid_cell_min_dim;
|
|
}
|
|
if (col_cnt > 0)
|
|
{
|
|
cell_list->width -= grid->grid_cell_border;
|
|
}
|
|
if (col_cnt < (cols - 1))
|
|
{
|
|
cell_list->width -= grid->grid_cell_border;
|
|
}
|
|
|
|
/*
|
|
* Make sure the last column uses all the remaining space.
|
|
* We subtract orig_x to get cell_list->x into the same coord
|
|
* space as width.
|
|
*/
|
|
if (col_cnt == (cols - 1))
|
|
{
|
|
cell_list->width = width - (cell_list->x - orig_x);
|
|
}
|
|
|
|
cell_list->height = height * (float)cell_list->height_percent / 100.0;
|
|
if (cell_list->height < grid->grid_cell_min_dim)
|
|
{
|
|
cell_list->height = grid->grid_cell_min_dim;
|
|
}
|
|
if (row_cnt > 0)
|
|
{
|
|
cell_list->height -= grid->grid_cell_border;
|
|
}
|
|
if (row_cnt < (rows - 1))
|
|
{
|
|
cell_list->height -= grid->grid_cell_border;
|
|
}
|
|
|
|
/*
|
|
* Make sure the last row uses all the remaining space.
|
|
* We subtract orig_y to get cell_list->y into the same coord
|
|
* space as height.
|
|
*/
|
|
if (row_cnt == (rows - 1))
|
|
{
|
|
cell_list->height = height - (cell_list->y - orig_y);
|
|
}
|
|
|
|
/*
|
|
* If this is the first column, for any row but the
|
|
* last row, create a new edge to be the bottom of this
|
|
* row.
|
|
*/
|
|
if ((col_cnt == 0)&&(row_cnt < (rows - 1)))
|
|
{
|
|
tmp_edge = lo_new_horizontal_edge(context, state,
|
|
cols, x, (cell_list->y + cell_list->height),
|
|
width, (2 * grid->grid_cell_border));
|
|
if (tmp_edge != NULL)
|
|
{
|
|
tmp_edge->next = grid->edge_list;
|
|
grid->edge_list = tmp_edge;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* When in the first row, create a new side edge on
|
|
* each column but the last one.
|
|
*/
|
|
if ((row_cnt == 0)&&(col_cnt < (cols - 1)))
|
|
{
|
|
lo_GridEdge *v_edge;
|
|
|
|
v_edge = lo_new_vertical_edge(context, state,
|
|
rows, (cell_list->x + cell_list->width), y,
|
|
(2 * grid->grid_cell_border), height);
|
|
if (v_edge != NULL)
|
|
{
|
|
v_edge->next = grid->edge_list;
|
|
grid->edge_list = v_edge;
|
|
}
|
|
col_edges[col_cnt] = v_edge;
|
|
}
|
|
|
|
/*
|
|
* If this is the first column in the row, we need to
|
|
* set top and bottom edges, for later columns in
|
|
* the same row, they remain unchanged.
|
|
*/
|
|
if (col_cnt == 0)
|
|
{
|
|
new_edges[TOP_EDGE] = top_edge;
|
|
if (row_cnt == 0)
|
|
{
|
|
new_edges[TOP_EDGE] = edges[TOP_EDGE];
|
|
}
|
|
new_edges[BOTTOM_EDGE] = tmp_edge;
|
|
if (row_cnt == (rows - 1))
|
|
{
|
|
new_edges[BOTTOM_EDGE] = edges[BOTTOM_EDGE];
|
|
}
|
|
/*
|
|
* Set top_edge for next time around.
|
|
*/
|
|
top_edge = tmp_edge;
|
|
}
|
|
|
|
/*
|
|
* Set the left and right edges for this column.
|
|
*/
|
|
if (col_cnt == 0)
|
|
{
|
|
new_edges[LEFT_EDGE] = edges[LEFT_EDGE];
|
|
}
|
|
else
|
|
{
|
|
new_edges[LEFT_EDGE] = col_edges[(col_cnt - 1)];
|
|
}
|
|
if (col_cnt == (cols - 1))
|
|
{
|
|
new_edges[RIGHT_EDGE] = edges[RIGHT_EDGE];
|
|
}
|
|
else
|
|
{
|
|
new_edges[RIGHT_EDGE] = col_edges[col_cnt];
|
|
}
|
|
|
|
x += cell_list->width;
|
|
if (col_cnt > 0)
|
|
{
|
|
x += grid->grid_cell_border;
|
|
}
|
|
if (col_cnt < (cols - 1))
|
|
{
|
|
x += grid->grid_cell_border;
|
|
}
|
|
col_cnt++;
|
|
if (col_cnt >= cols)
|
|
{
|
|
x = orig_x;
|
|
y += cell_list->height;
|
|
if (row_cnt > 0)
|
|
{
|
|
y += grid->grid_cell_border;
|
|
}
|
|
if (row_cnt < (rows - 1))
|
|
{
|
|
y += grid->grid_cell_border;
|
|
}
|
|
col_cnt = 0;
|
|
row_cnt++;
|
|
}
|
|
|
|
if (cell_list->subgrid != NULL)
|
|
{
|
|
lo_GridRec *subgrid;
|
|
lo_GridCellRec *dummy_cell;
|
|
|
|
subgrid = cell_list->subgrid;
|
|
dummy_cell = cell_list;
|
|
|
|
subgrid->grid_cell_border = grid->grid_cell_border;
|
|
subgrid->grid_cell_min_dim = grid->grid_cell_min_dim;
|
|
|
|
/*
|
|
* Make sure the subgrid percentages add up to our percent
|
|
* height.
|
|
*/
|
|
lo_adjust_subpercents(subgrid->rows, subgrid->row_percents,
|
|
cell_list->height_percent,
|
|
cell_list->height);
|
|
|
|
/*
|
|
* Make sure the subgrid percentages add up to our percent
|
|
* height.
|
|
*/
|
|
lo_adjust_subpercents(subgrid->cols, subgrid->col_percents,
|
|
cell_list->width_percent,
|
|
cell_list->width);
|
|
|
|
lo_LayoutGridCells(context, state,
|
|
cell_list->x, cell_list->y,
|
|
cell_list->width, cell_list->height,
|
|
subgrid, new_edges);
|
|
|
|
/*
|
|
** XXXX
|
|
** There next two if statements attempt to solve a problem -- that
|
|
** a frameset that defines columns is given a percentage height of 100%.
|
|
** and one that defines rows is given a percentage width of 100%.
|
|
** Unfortunately, this breaks resizing when the sub frameset was given a fixed
|
|
** width.
|
|
**
|
|
** So, we go through all the cells and make sure they
|
|
** don't have a percent_width/percent_height if their
|
|
** parent grid didn't have one.
|
|
*/
|
|
if (!cell_list->has_percent_width)
|
|
{
|
|
lo_GridCellRec *sub_cell_list = subgrid->cell_list;
|
|
|
|
/* make sure none of the subgrid cells has percent width set. */
|
|
|
|
while (sub_cell_list)
|
|
{
|
|
sub_cell_list->has_percent_width = FALSE;
|
|
sub_cell_list = sub_cell_list->next;
|
|
}
|
|
}
|
|
|
|
if (!cell_list->has_percent_height)
|
|
{
|
|
/* make sure none of the subgrid cells has percent height set. */
|
|
lo_GridCellRec *sub_cell_list = subgrid->cell_list;
|
|
|
|
/* make sure none of the subgrid cells has percent width set. */
|
|
|
|
while (sub_cell_list)
|
|
{
|
|
sub_cell_list->has_percent_height = FALSE;
|
|
sub_cell_list = sub_cell_list->next;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Merge the edge list of the sub-grid with that of
|
|
* the parent grid.
|
|
*/
|
|
if (subgrid->edge_list != NULL)
|
|
{
|
|
lo_GridEdge *a_edge;
|
|
|
|
a_edge = subgrid->edge_list;
|
|
while (a_edge->next != NULL)
|
|
{
|
|
a_edge = a_edge->next;
|
|
}
|
|
a_edge->next = grid->edge_list;
|
|
grid->edge_list = subgrid->edge_list;
|
|
subgrid->edge_list = NULL;
|
|
}
|
|
|
|
/*
|
|
* Replace the subgrid cell in the list with its
|
|
* own list of member cells.
|
|
*/
|
|
/*
|
|
* If the cell to be replace is not the head of the
|
|
* list.
|
|
*/
|
|
if (cell_parent != NULL)
|
|
{
|
|
/*
|
|
* If the cell is being replaced with a list
|
|
* of one or more cells.
|
|
*/
|
|
if (subgrid->cell_list != NULL)
|
|
{
|
|
cell_parent->next = subgrid->cell_list;
|
|
subgrid->cell_list_last->next = cell_list->next;
|
|
/*
|
|
* If the cell being replaced was the end of
|
|
* the list, set the new end properly.
|
|
*/
|
|
if (grid->cell_list_last == cell_list)
|
|
{
|
|
grid->cell_list_last =
|
|
subgrid->cell_list_last;
|
|
}
|
|
cell_parent = subgrid->cell_list_last;
|
|
cell_list = cell_list->next;
|
|
}
|
|
/*
|
|
* If the cell is being replaced with
|
|
* no cells (just remove it.)
|
|
*/
|
|
else
|
|
{
|
|
cell_parent->next = cell_list->next;
|
|
/*
|
|
* If the cell being replaced was the end of
|
|
* the list, set the new end properly.
|
|
*/
|
|
if (grid->cell_list_last == cell_list)
|
|
{
|
|
grid->cell_list_last = cell_parent;
|
|
}
|
|
cell_parent = cell_parent;
|
|
cell_list = cell_list->next;
|
|
}
|
|
}
|
|
/*
|
|
* Else we are replacing the head of the list.
|
|
*/
|
|
else
|
|
{
|
|
/*
|
|
* If the cell is being replaced with a list
|
|
* of one or more cells.
|
|
*/
|
|
if (subgrid->cell_list != NULL)
|
|
{
|
|
grid->cell_list = subgrid->cell_list;
|
|
subgrid->cell_list_last->next = cell_list->next;
|
|
/*
|
|
* If the cell being replaced was the end of
|
|
* the list, set the new end properly.
|
|
*/
|
|
if (grid->cell_list_last == cell_list)
|
|
{
|
|
grid->cell_list_last =
|
|
subgrid->cell_list_last;
|
|
}
|
|
cell_parent = subgrid->cell_list_last;
|
|
cell_list = cell_list->next;
|
|
}
|
|
/*
|
|
* If the cell is being replaced with
|
|
* no cells (just remove it.)
|
|
*/
|
|
else
|
|
{
|
|
grid->cell_list = cell_list->next;
|
|
/*
|
|
* If the cell being replaced was the end of
|
|
* the list, set the new end properly.
|
|
*/
|
|
if (grid->cell_list_last == cell_list)
|
|
{
|
|
grid->cell_list_last = cell_list->next;
|
|
}
|
|
cell_parent = cell_parent;
|
|
cell_list = cell_list->next;
|
|
}
|
|
}
|
|
|
|
lo_FreeGridRec(subgrid);
|
|
lo_FreeGridCellRec(context, grid, dummy_cell);
|
|
}
|
|
/*
|
|
* Else this was a normal cell.
|
|
*/
|
|
else
|
|
{
|
|
/*
|
|
* Add this cell to the cell array for each edge
|
|
* it borders.
|
|
*/
|
|
if (new_edges[TOP_EDGE] != NULL)
|
|
{
|
|
lo_add_cell_to_edge(new_edges[TOP_EDGE],
|
|
cell_list);
|
|
}
|
|
if (new_edges[BOTTOM_EDGE] != NULL)
|
|
{
|
|
lo_add_cell_to_edge(new_edges[BOTTOM_EDGE],
|
|
cell_list);
|
|
}
|
|
if (new_edges[LEFT_EDGE] != NULL)
|
|
{
|
|
lo_add_cell_to_edge(new_edges[LEFT_EDGE],
|
|
cell_list);
|
|
}
|
|
if (new_edges[RIGHT_EDGE] != NULL)
|
|
{
|
|
lo_add_cell_to_edge(new_edges[RIGHT_EDGE],
|
|
cell_list);
|
|
}
|
|
|
|
cell_list->side_edges[TOP_EDGE] =
|
|
new_edges[TOP_EDGE];
|
|
cell_list->side_edges[BOTTOM_EDGE] =
|
|
new_edges[BOTTOM_EDGE];
|
|
cell_list->side_edges[LEFT_EDGE] =
|
|
new_edges[LEFT_EDGE];
|
|
cell_list->side_edges[RIGHT_EDGE] =
|
|
new_edges[RIGHT_EDGE];
|
|
|
|
cell_parent = cell_list;
|
|
cell_list = cell_list->next;
|
|
}
|
|
|
|
}
|
|
|
|
if (col_edges != NULL)
|
|
{
|
|
XP_FREE(col_edges);
|
|
}
|
|
}
|
|
|
|
static void
|
|
lo_set_edge_bounds(lo_GridEdge *edge)
|
|
{
|
|
int32 i;
|
|
int32 min, max;
|
|
Bool visible;
|
|
Bool movable;
|
|
int16 size;
|
|
int8 color_priority;
|
|
LO_Color *bg_color;
|
|
|
|
if (edge == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
visible = FALSE;
|
|
movable = TRUE;
|
|
size = -1;
|
|
color_priority = 0;
|
|
bg_color = NULL;
|
|
|
|
min = -1;
|
|
max = -1;
|
|
/*
|
|
* For horizontal edges
|
|
*/
|
|
if (edge->is_vertical == FALSE)
|
|
{
|
|
for (i=0; i < edge->cell_cnt; i++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* If a cell on this edge is not resizable,
|
|
* this edge is not movable.
|
|
*/
|
|
if (cell->resizable == FALSE)
|
|
{
|
|
movable = FALSE;
|
|
}
|
|
|
|
/*
|
|
* If a cell on this edge has visible edges,
|
|
* this edge is visible.
|
|
*/
|
|
if (cell->no_edges == FALSE)
|
|
{
|
|
visible = TRUE;
|
|
}
|
|
|
|
/*
|
|
* A cell's size is the max of the edge_size
|
|
* of all cells next to it.
|
|
*/
|
|
if (cell->edge_size > size)
|
|
{
|
|
size = cell->edge_size;
|
|
}
|
|
|
|
/*
|
|
* A cell sets a color on an edge that doesn't
|
|
* already have a color, or has a lower
|
|
* priority, it wins.
|
|
*/
|
|
if ((cell->border_color != NULL)&&
|
|
((bg_color == NULL)||
|
|
(cell->color_priority > color_priority)))
|
|
{
|
|
bg_color = XP_NEW(LO_Color);
|
|
if (bg_color != NULL)
|
|
{
|
|
bg_color->red = cell->border_color->red;
|
|
bg_color->green = cell->border_color->green;
|
|
bg_color->blue = cell->border_color->blue;
|
|
color_priority = cell->color_priority;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the cell is above the edge.
|
|
*/
|
|
if (cell->y < edge->y)
|
|
{
|
|
if ((cell->y > min)||(min == -1))
|
|
{
|
|
min = cell->y;
|
|
}
|
|
}
|
|
/*
|
|
* Else the cell is below the edge.
|
|
*/
|
|
else
|
|
{
|
|
int32 bottom;
|
|
|
|
bottom = cell->y + cell->height - 1;
|
|
if ((bottom < max)||(max == -1))
|
|
{
|
|
max = bottom;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Make min and max be the inclusive bounds through
|
|
* which edge->y can move.
|
|
* We should never move an edge so that cell->y
|
|
* becomes equal to edge->y or else in the future we
|
|
* will thing that cell is on the wrong side of the
|
|
* edge. To prevent this, it min is set by a cell's
|
|
* bounds, we increment it by one.
|
|
*/
|
|
if (min == -1)
|
|
{
|
|
min = edge->y;
|
|
}
|
|
else
|
|
{
|
|
min = min + 1;
|
|
}
|
|
if (max == -1)
|
|
{
|
|
max = edge->y + edge->height - 1;
|
|
}
|
|
else
|
|
{
|
|
max = max - edge->height + 1;
|
|
}
|
|
/*
|
|
* Sanity check bounds
|
|
*/
|
|
if (max < min)
|
|
{
|
|
max = min;
|
|
}
|
|
edge->left_top_bound = min;
|
|
edge->right_bottom_bound = max;
|
|
}
|
|
/*
|
|
* Else for vertical edges.
|
|
*/
|
|
else
|
|
{
|
|
for (i=0; i < edge->cell_cnt; i++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* If a cell on this edge is not resizable,
|
|
* this edge is not movable.
|
|
*/
|
|
if (cell->resizable == FALSE)
|
|
{
|
|
movable = FALSE;
|
|
}
|
|
|
|
/*
|
|
* If a cell on this edge has visible edges,
|
|
* this edge is visible.
|
|
*/
|
|
if (cell->no_edges == FALSE)
|
|
{
|
|
visible = TRUE;
|
|
}
|
|
|
|
/*
|
|
* A cells size is the max of the edge_size
|
|
* of all cells next to it.
|
|
*/
|
|
if (cell->edge_size > size)
|
|
{
|
|
size = cell->edge_size;
|
|
}
|
|
|
|
/*
|
|
* A cell sets a color on an edge that doesn't
|
|
* already have a color, or has a lower
|
|
* priority, it wins.
|
|
*/
|
|
if ((cell->border_color != NULL)&&
|
|
((bg_color == NULL)||
|
|
(cell->color_priority > color_priority)))
|
|
{
|
|
bg_color = XP_NEW(LO_Color);
|
|
if (bg_color != NULL)
|
|
{
|
|
bg_color->red = cell->border_color->red;
|
|
bg_color->green = cell->border_color->green;
|
|
bg_color->blue = cell->border_color->blue;
|
|
color_priority = cell->color_priority;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the cell is left of the edge.
|
|
*/
|
|
if (cell->x < edge->x)
|
|
{
|
|
if ((cell->x > min)||(min == -1))
|
|
{
|
|
min = cell->x;
|
|
}
|
|
}
|
|
/*
|
|
* Else the cell is right of the edge.
|
|
*/
|
|
else
|
|
{
|
|
int32 right;
|
|
|
|
right = cell->x + cell->width - 1;
|
|
if ((right < max)||(max == -1))
|
|
{
|
|
max = right;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Make min and max be the inclusive bounds through
|
|
* which edge->x can move.
|
|
* We should never move an edge so that cell->x
|
|
* becomes equal to edge->x or else in the future we
|
|
* will thing that cell is on the wrong side of the
|
|
* edge. To prevent this, it min is set by a cell's
|
|
* bounds, we increment it by one.
|
|
*/
|
|
if (min == -1)
|
|
{
|
|
min = edge->x;
|
|
}
|
|
else
|
|
{
|
|
min = min + 1;
|
|
}
|
|
if (max == -1)
|
|
{
|
|
max = edge->x + edge->width - 1;
|
|
}
|
|
else
|
|
{
|
|
max = max - edge->width + 1;
|
|
}
|
|
/*
|
|
* Sanity check bounds
|
|
*/
|
|
if (max < min)
|
|
{
|
|
max = min;
|
|
}
|
|
edge->left_top_bound = min;
|
|
edge->right_bottom_bound = max;
|
|
}
|
|
|
|
edge->fe_edge->left_top_bound = edge->left_top_bound;
|
|
edge->fe_edge->right_bottom_bound = edge->right_bottom_bound;
|
|
edge->fe_edge->visible = visible;
|
|
edge->fe_edge->movable = movable;
|
|
edge->fe_edge->size = size;
|
|
edge->fe_edge->bg_color = bg_color;
|
|
}
|
|
|
|
|
|
static void
|
|
lo_set_all_edge_bounds(MWContext *context, lo_DocState *state, lo_GridRec *grid)
|
|
{
|
|
lo_GridEdge *edge_list;
|
|
|
|
if ((grid == NULL)||(grid->edge_list == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
edge_list = grid->edge_list;
|
|
while (edge_list != NULL)
|
|
{
|
|
lo_set_edge_bounds(edge_list);
|
|
|
|
/*
|
|
* Insert this edge into the float list.
|
|
*/
|
|
edge_list->fe_edge->next = state->float_list;
|
|
state->float_list = (LO_Element *)edge_list->fe_edge;
|
|
|
|
lo_DisplayEdge(context, edge_list->fe_edge);
|
|
edge_list = edge_list->next;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Use the cell's history index to reload the document
|
|
* it should now be currently displaying.
|
|
* (Note, history index starts at 1, and array starts at 0).
|
|
*/
|
|
static void
|
|
lo_reload_cell_from_history(lo_GridCellRec *cell_ptr,
|
|
NET_ReloadMethod force_reload)
|
|
{
|
|
void *hist;
|
|
|
|
hist = cell_ptr->hist_array[cell_ptr->hist_indx - 1].hist;
|
|
|
|
/*
|
|
* If we have a history entry, and a context to load
|
|
* it into, have the FE load it now.
|
|
*/
|
|
if ((hist != NULL)&&(cell_ptr->context != NULL))
|
|
{
|
|
FE_LoadGridCellFromHistory(cell_ptr->context, hist,
|
|
force_reload);
|
|
}
|
|
}
|
|
|
|
|
|
static lo_GridCellRec *reconnecting_cell = NULL;
|
|
|
|
|
|
PRIVATE
|
|
void
|
|
lo_MakeGrid(MWContext *context, lo_DocState *state, lo_GridRec *grid)
|
|
{
|
|
int32 x, y;
|
|
int32 edge_size;
|
|
int32 width, height;
|
|
lo_GridCellRec *cell_ptr;
|
|
lo_GridEdge *edges[4]; /* top, bottom, left, right */
|
|
|
|
width = state->win_width;
|
|
height = state->win_height;
|
|
FE_GetFullWindowSize(context, &width, &height);
|
|
|
|
if (width <= 0)
|
|
width = 1;
|
|
|
|
if (height <= 0)
|
|
height = 1;
|
|
|
|
grid->main_width = width;
|
|
grid->main_height = height;
|
|
|
|
#ifdef NO_FRAMESET_BORDER
|
|
edge_size = 1;
|
|
FE_GetEdgeMinSize(context, &edge_size);
|
|
if (edge_size < 1)
|
|
{
|
|
edge_size = 1;
|
|
}
|
|
#else
|
|
if (grid->edge_size < 0)
|
|
{
|
|
edge_size = 1;
|
|
FE_GetEdgeMinSize(context, &edge_size
|
|
#if defined(XP_WIN) || defined(XP_OS2)
|
|
/* need this information here under windows */
|
|
, grid->no_edges
|
|
#endif
|
|
);
|
|
}
|
|
else
|
|
{
|
|
edge_size = grid->edge_size;
|
|
}
|
|
if (edge_size < 0)
|
|
{
|
|
edge_size = 0;
|
|
}
|
|
#endif /* NO_FRAMESET_BORDER */
|
|
grid->grid_cell_border = (edge_size + 1) / 2;
|
|
grid->grid_cell_min_dim = (2 * grid->grid_cell_border) + 1;
|
|
|
|
x = 0;
|
|
y = 0;
|
|
|
|
/*
|
|
* Make sure all the row percentages total up
|
|
* to 100%
|
|
*/
|
|
lo_adjust_percents(grid->rows, grid->row_percents, height);
|
|
|
|
/*
|
|
* Make sure all the col percentages total up
|
|
* to 100%
|
|
*/
|
|
lo_adjust_percents(grid->cols, grid->col_percents, width);
|
|
|
|
edges[TOP_EDGE] = NULL;
|
|
edges[BOTTOM_EDGE] = NULL;
|
|
edges[LEFT_EDGE] = NULL;
|
|
edges[RIGHT_EDGE] = NULL;
|
|
lo_LayoutGridCells(context, state, x, y, width, height, grid, edges);
|
|
lo_set_all_edge_bounds(context, state, grid);
|
|
|
|
/*
|
|
* If there is an old_grid in the top_state, that means we restored
|
|
* from history with the sizes changed. Go through that old_grid
|
|
* now, and put those urls back into the cells, then free the old_grid.
|
|
*/
|
|
if (state->top_state->old_grid != NULL)
|
|
{
|
|
lo_GridRec *old_grid;
|
|
lo_GridCellRec *old_cell_ptr;
|
|
lo_SavedGridData tmp_saved_grid;
|
|
|
|
old_grid = state->top_state->old_grid;
|
|
grid->current_hist = old_grid->current_hist;
|
|
grid->max_hist = old_grid->max_hist;
|
|
grid->hist_size = old_grid->hist_size;
|
|
old_cell_ptr = old_grid->cell_list;
|
|
cell_ptr = grid->cell_list;
|
|
while ((cell_ptr != NULL)&&(old_cell_ptr != NULL))
|
|
{
|
|
/*
|
|
* Free any initial URL loaded, and move the old
|
|
* url in place. Make sure to clear the old URL
|
|
* so we don't accidentally free it later.
|
|
*/
|
|
if (cell_ptr->url != NULL)
|
|
{
|
|
XP_FREE(cell_ptr->url);
|
|
cell_ptr->url = NULL;
|
|
}
|
|
cell_ptr->url = old_cell_ptr->url;
|
|
old_cell_ptr->url = NULL;
|
|
|
|
/*
|
|
* Also copy over the old history.
|
|
*/
|
|
cell_ptr->hist_indx = old_cell_ptr->hist_indx;
|
|
cell_ptr->hist_array = old_cell_ptr->hist_array;
|
|
old_cell_ptr->hist_array = NULL;
|
|
cell_ptr->hist_list = old_cell_ptr->hist_list;
|
|
old_cell_ptr->hist_list = NULL;
|
|
|
|
cell_ptr = cell_ptr->next;
|
|
old_cell_ptr = old_cell_ptr->next;
|
|
}
|
|
|
|
/*
|
|
* Free up the old saved grid.
|
|
*/
|
|
tmp_saved_grid.main_width = 0;
|
|
tmp_saved_grid.main_height = 0;
|
|
tmp_saved_grid.the_grid = state->top_state->old_grid;
|
|
state->top_state->old_grid = NULL;
|
|
lo_FreeDocumentGridData(context, &tmp_saved_grid);
|
|
}
|
|
|
|
/*
|
|
* Go through all the cells creating them where specified.
|
|
*/
|
|
cell_ptr = grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
/*
|
|
* Have the front end create the grid cell.
|
|
*/
|
|
if (cell_ptr->url != NULL)
|
|
{
|
|
void *history;
|
|
void *hist_list;
|
|
|
|
history = NULL;
|
|
hist_list = NULL;
|
|
if (cell_ptr->hist_list != NULL)
|
|
{
|
|
hist_list = cell_ptr->hist_list;
|
|
cell_ptr->hist_indx = grid->current_hist;
|
|
history = cell_ptr->hist_array[cell_ptr->hist_indx - 1].hist;
|
|
if (history == NULL)
|
|
{
|
|
hist_list = NULL;
|
|
}
|
|
}
|
|
reconnecting_cell = cell_ptr;
|
|
cell_ptr->context = FE_MakeGridWindow (context,
|
|
hist_list,
|
|
history,
|
|
cell_ptr->x, cell_ptr->y,
|
|
cell_ptr->width, cell_ptr->height,
|
|
(char *)cell_ptr->url, (char *)cell_ptr->name,
|
|
cell_ptr->scrolling,
|
|
FORCE_RELOAD_FLAG(state->top_state),
|
|
cell_ptr->no_edges);
|
|
reconnecting_cell = NULL;
|
|
if (cell_ptr->context)
|
|
{
|
|
XP_ASSERT(cell_ptr->context->forceJSEnabled ==
|
|
context->forceJSEnabled);
|
|
if (history)
|
|
{
|
|
cell_ptr->context->hist.cur_doc_ptr = history;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell_ptr->context = NULL;
|
|
}
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
lo_BeginGrid(MWContext *context, lo_DocState *state, PA_Tag *tag)
|
|
{
|
|
PA_Block buff;
|
|
char *str;
|
|
int32 rows, cols;
|
|
lo_GridPercent *row_percents;
|
|
lo_GridPercent *col_percents;
|
|
lo_GridRec *grid;
|
|
|
|
rows = 1;
|
|
cols = 1;
|
|
|
|
grid = XP_NEW(lo_GridRec);
|
|
if (grid == NULL)
|
|
{
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
|
|
grid->no_edges = FALSE;
|
|
grid->edge_size = -1;
|
|
grid->color_priority = 0;
|
|
grid->border_color = NULL;
|
|
grid->edge_list = NULL;
|
|
grid->cell_list = NULL;
|
|
grid->cell_list_last = NULL;
|
|
grid->subgrid = NULL;
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_FRAMEBORDER);
|
|
if (buff != NULL)
|
|
{
|
|
Bool no_edges;
|
|
|
|
no_edges = FALSE;
|
|
PA_LOCK(str, char *, buff);
|
|
if (pa_TagEqual("no", str))
|
|
{
|
|
no_edges = TRUE;
|
|
}
|
|
else if (pa_TagEqual("0", str))
|
|
{
|
|
no_edges = TRUE;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
grid->no_edges = no_edges;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_BORDER);
|
|
if (buff != NULL)
|
|
{
|
|
int32 border;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
border = XP_ATOI(str);
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (border < 0)
|
|
{
|
|
border = 0;
|
|
}
|
|
if (border > 100)
|
|
{
|
|
border = 100;
|
|
}
|
|
grid->edge_size = (int16)border;
|
|
}
|
|
|
|
/*
|
|
* A borderwidth of zero automatically turns off edges.
|
|
*/
|
|
if (grid->edge_size == 0)
|
|
{
|
|
grid->no_edges = TRUE;
|
|
}
|
|
|
|
/*
|
|
* Check for a border color attribute
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_BORDERCOLOR);
|
|
if (buff != NULL)
|
|
{
|
|
uint8 red, green, blue;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
LO_ParseRGB(str, &red, &green, &blue);
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
grid->border_color = XP_NEW(LO_Color);
|
|
if (grid->border_color != NULL)
|
|
{
|
|
grid->border_color->red = red;
|
|
grid->border_color->green = green;
|
|
grid->border_color->blue = blue;
|
|
grid->color_priority = 1;
|
|
}
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_ROWS);
|
|
if (buff != NULL)
|
|
{
|
|
int32 len;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
|
|
row_percents = lo_parse_percent_list(context, str, &rows);
|
|
if ((row_percents == NULL)&&(rows >= 1))
|
|
{
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
XP_DELETE(grid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (rows <= 0)
|
|
{
|
|
row_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (row_percents == NULL)
|
|
{
|
|
XP_DELETE(grid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
row_percents[0].type = LO_PERCENT_NORMAL;
|
|
row_percents[0].original_value = 100;
|
|
rows = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
row_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (row_percents == NULL)
|
|
{
|
|
XP_DELETE(grid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
row_percents[0].type = LO_PERCENT_NORMAL;
|
|
row_percents[0].original_value = 100;
|
|
rows = 1;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_COLS);
|
|
if (buff != NULL)
|
|
{
|
|
int32 len;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
|
|
col_percents = lo_parse_percent_list(context, str, &cols);
|
|
if ((col_percents == NULL)&&(cols >= 1))
|
|
{
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
XP_DELETE(grid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (cols <= 0)
|
|
{
|
|
col_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (col_percents == NULL)
|
|
{
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
XP_DELETE(grid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
col_percents[0].type = LO_PERCENT_NORMAL;
|
|
col_percents[0].original_value = 100;
|
|
cols = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
col_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (col_percents == NULL)
|
|
{
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
XP_DELETE(grid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
col_percents[0].type = LO_PERCENT_NORMAL;
|
|
col_percents[0].original_value = 100;
|
|
cols = 1;
|
|
}
|
|
|
|
if ((rows == 1)&&(cols == 1))
|
|
{
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
if (col_percents != NULL)
|
|
{
|
|
XP_FREE(col_percents);
|
|
}
|
|
XP_DELETE(grid);
|
|
return;
|
|
}
|
|
|
|
(void)lo_ProcessContextEventHandlers(context, state, tag);
|
|
|
|
grid->rows = rows;
|
|
grid->row_percents = row_percents;
|
|
grid->cols = cols;
|
|
grid->col_percents = col_percents;
|
|
grid->cell_count = 0;
|
|
|
|
grid->current_hist = 0;
|
|
grid->max_hist = 0;
|
|
grid->hist_size = 10;
|
|
|
|
grid->main_width = state->win_width;
|
|
grid->main_height = state->win_height;
|
|
grid->current_cell_margin_width = 0;
|
|
grid->current_cell_margin_height = 0;
|
|
|
|
state->current_grid = grid;
|
|
}
|
|
|
|
|
|
void
|
|
lo_EndGrid(MWContext *context, lo_DocState *state, lo_GridRec *grid)
|
|
{
|
|
int32 cell_cnt;
|
|
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
cell_cnt = grid->rows * grid->cols;
|
|
|
|
state->top_state->the_grid = grid;
|
|
|
|
lo_MakeGrid(context, state, grid);
|
|
}
|
|
|
|
|
|
static Bool
|
|
lo_is_grid_recursion(MWContext *context, lo_DocState *state, char *url)
|
|
{
|
|
MWContext *cptr;
|
|
|
|
/*
|
|
* If this cell has its parent's URL, it is recursion.
|
|
*/
|
|
if ((state->top_state->url != NULL)&&
|
|
(XP_STRCMP(url, state->top_state->url) == 0))
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
cptr = context->grid_parent;
|
|
while (cptr != NULL)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
char *anc_url;
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(cptr);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
/*
|
|
* We have to get the ancenstor URL from the state because
|
|
* context->url doesn't seem to be reliable.
|
|
*/
|
|
if (top_state == NULL)
|
|
{
|
|
anc_url = NULL;
|
|
}
|
|
else
|
|
{
|
|
anc_url = top_state->url;
|
|
}
|
|
|
|
/*
|
|
* if this cell has the same URL as any of its ancestors
|
|
* this is recursion.
|
|
*/
|
|
if ((anc_url != NULL)&&(XP_STRCMP(url, anc_url) == 0))
|
|
{
|
|
return(TRUE);
|
|
}
|
|
cptr = cptr->grid_parent;
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
void
|
|
lo_BeginGridCell(MWContext *context, lo_DocState *state, PA_Tag *tag)
|
|
{
|
|
PA_Block buff;
|
|
char *str;
|
|
lo_GridRec *grid;
|
|
int32 col_cnt, row_cnt;
|
|
lo_GridCellRec *cell;
|
|
|
|
/*
|
|
* Get the current grid, if there is none, error out.
|
|
*/
|
|
grid = state->current_grid;
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If we have subgrids, the deepest one is at the TOP of the
|
|
* subgrid stack.
|
|
*/
|
|
if (grid->subgrid != NULL)
|
|
{
|
|
grid = grid->subgrid;
|
|
}
|
|
|
|
/*
|
|
* If this grid has its full complement of cells, ignore
|
|
* this cell.
|
|
*/
|
|
if (grid->cell_count >= (grid->rows * grid->cols))
|
|
{
|
|
return;
|
|
}
|
|
|
|
cell = XP_NEW(lo_GridCellRec);
|
|
if (cell == NULL)
|
|
{
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
|
|
row_cnt = grid->cell_count / grid->cols;
|
|
col_cnt = grid->cell_count - (row_cnt * grid->cols);
|
|
|
|
cell->x = 0;
|
|
cell->y = 0;
|
|
cell->width = 0;
|
|
cell->height = 0;
|
|
cell->margin_width = 0;
|
|
cell->margin_height = 0;
|
|
cell->width_percent = 0;
|
|
cell->height_percent = 0;
|
|
cell->url = NULL;
|
|
cell->name = NULL;
|
|
cell->context = NULL;
|
|
cell->hist_list = NULL;
|
|
cell->hist_array = (lo_GridHistory *)XP_ALLOC(grid->hist_size *
|
|
sizeof(lo_GridHistory));
|
|
if (cell->hist_array == NULL)
|
|
{
|
|
XP_DELETE(cell);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
XP_MEMSET(cell->hist_array, 0, grid->hist_size *
|
|
sizeof(lo_GridHistory));
|
|
cell->hist_indx = 0;
|
|
cell->next = NULL;
|
|
cell->subgrid = NULL;
|
|
cell->side_edges[TOP_EDGE] = NULL;
|
|
cell->side_edges[BOTTOM_EDGE] = NULL;
|
|
cell->side_edges[LEFT_EDGE] = NULL;
|
|
cell->side_edges[RIGHT_EDGE] = NULL;
|
|
cell->scrolling = LO_SCROLL_AUTO;
|
|
cell->no_edges = grid->no_edges;
|
|
cell->resizable = TRUE;
|
|
cell->edge_size = -1;
|
|
cell->color_priority = 0;
|
|
cell->border_color = NULL;
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_FRAMEBORDER);
|
|
if (buff != NULL)
|
|
{
|
|
Bool no_edges;
|
|
|
|
no_edges = FALSE;
|
|
PA_LOCK(str, char *, buff);
|
|
if (pa_TagEqual("no", str))
|
|
{
|
|
no_edges = TRUE;
|
|
}
|
|
else if (pa_TagEqual("0", str))
|
|
{
|
|
no_edges = TRUE;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
cell->no_edges = no_edges;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_BORDER);
|
|
if (buff != NULL)
|
|
{
|
|
int32 border;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
border = XP_ATOI(str);
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (border < 0)
|
|
{
|
|
border = 0;
|
|
}
|
|
if (border > 100)
|
|
{
|
|
border = 100;
|
|
}
|
|
cell->edge_size = (int16)border;
|
|
}
|
|
|
|
/*
|
|
* A borderwidth of zero automatically turns off edges.
|
|
*/
|
|
if (cell->edge_size == 0)
|
|
{
|
|
cell->no_edges = TRUE;
|
|
}
|
|
|
|
/*
|
|
* Check for a border color attribute
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_BORDERCOLOR);
|
|
if (buff != NULL)
|
|
{
|
|
uint8 red, green, blue;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
LO_ParseRGB(str, &red, &green, &blue);
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
cell->border_color = XP_NEW(LO_Color);
|
|
if (cell->border_color != NULL)
|
|
{
|
|
cell->border_color->red = red;
|
|
cell->border_color->green = green;
|
|
cell->border_color->blue = blue;
|
|
cell->color_priority = 3;
|
|
}
|
|
}
|
|
/*
|
|
* Else we might inherit a border color from parent.
|
|
*/
|
|
else if (grid->border_color != NULL)
|
|
{
|
|
cell->border_color = XP_NEW(LO_Color);
|
|
if (cell->border_color != NULL)
|
|
{
|
|
cell->border_color->red = grid->border_color->red;
|
|
cell->border_color->green = grid->border_color->green;
|
|
cell->border_color->blue = grid->border_color->blue;
|
|
cell->color_priority = grid->color_priority;
|
|
}
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_NORESIZE);
|
|
if (buff != NULL)
|
|
{
|
|
PA_FREE(buff);
|
|
cell->resizable = FALSE;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_SCROLLING);
|
|
if (buff != NULL)
|
|
{
|
|
int8 scrolling;
|
|
|
|
scrolling = LO_SCROLL_AUTO;
|
|
PA_LOCK(str, char *, buff);
|
|
if (pa_TagEqual("yes", str))
|
|
{
|
|
scrolling = LO_SCROLL_YES;
|
|
}
|
|
else if (pa_TagEqual("scroll", str))
|
|
{
|
|
scrolling = LO_SCROLL_YES;
|
|
}
|
|
else if (pa_TagEqual("no", str))
|
|
{
|
|
scrolling = LO_SCROLL_NO;
|
|
}
|
|
else if (pa_TagEqual("noscroll", str))
|
|
{
|
|
scrolling = LO_SCROLL_NO;
|
|
}
|
|
else if (pa_TagEqual("on", str))
|
|
{
|
|
scrolling = LO_SCROLL_YES;
|
|
}
|
|
else if (pa_TagEqual("off", str))
|
|
{
|
|
scrolling = LO_SCROLL_NO;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
cell->scrolling = scrolling;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_SRC);
|
|
if (buff != NULL)
|
|
{
|
|
char *new_str;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
if (str != NULL)
|
|
{
|
|
int32 len;
|
|
|
|
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
|
|
}
|
|
new_str = NET_MakeAbsoluteURL(state->top_state->base_url, str);
|
|
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
cell->url = new_str;
|
|
/*
|
|
* Don't allow cells to have the same URL as their parent
|
|
* or any of their ancestors as that would cause infinite
|
|
* recursion.
|
|
*/
|
|
if (lo_is_grid_recursion(context, state, cell->url) != FALSE)
|
|
{
|
|
XP_FREE(new_str);
|
|
cell->url = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell->url = NULL;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_NAME);
|
|
if (buff != NULL)
|
|
{
|
|
char *name;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
if (str != NULL)
|
|
{
|
|
int32 len;
|
|
|
|
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
|
|
}
|
|
name = (char *)XP_ALLOC(XP_STRLEN(str) + 1);
|
|
if (name == NULL)
|
|
{
|
|
cell->name = NULL;
|
|
}
|
|
else
|
|
{
|
|
XP_STRCPY(name, str);
|
|
cell->name = name;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
}
|
|
else
|
|
{
|
|
cell->name = NULL;
|
|
}
|
|
|
|
/*
|
|
* Get the margin width.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_MARGINWIDTH);
|
|
if (buff != NULL)
|
|
{
|
|
int32 val;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
val = XP_ATOI(str);
|
|
if (val < 1)
|
|
{
|
|
val = 1;
|
|
}
|
|
cell->margin_width = val;
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
}
|
|
cell->margin_width = FEUNITS_X(cell->margin_width, context);
|
|
|
|
/*
|
|
* Get the margin height.
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_MARGINHEIGHT);
|
|
if (buff != NULL)
|
|
{
|
|
int32 val;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
val = XP_ATOI(str);
|
|
if (val < 1)
|
|
{
|
|
val = 1;
|
|
}
|
|
cell->margin_height = val;
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
}
|
|
cell->margin_height = FEUNITS_Y(cell->margin_height, context);
|
|
|
|
grid->cell_count++;
|
|
|
|
if (grid->cell_list_last == NULL)
|
|
{
|
|
grid->cell_list = cell;
|
|
grid->cell_list_last = cell;
|
|
}
|
|
else
|
|
{
|
|
grid->cell_list_last->next = cell;
|
|
grid->cell_list_last = cell;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
lo_BeginSubgrid(MWContext *context, lo_DocState *state, PA_Tag *tag)
|
|
{
|
|
PA_Block buff;
|
|
char *str;
|
|
lo_GridRec *grid;
|
|
int32 col_cnt, row_cnt;
|
|
lo_GridRec *subgrid;
|
|
int32 rows, cols;
|
|
lo_GridPercent *row_percents;
|
|
lo_GridPercent *col_percents;
|
|
lo_GridCellRec *cell;
|
|
|
|
/*
|
|
* Get the current grid, if there is none, error out.
|
|
*/
|
|
grid = state->current_grid;
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If we have subgrids, the deepest one is at the TOP of the
|
|
* subgrid stack.
|
|
*/
|
|
if (grid->subgrid != NULL)
|
|
{
|
|
grid = grid->subgrid;
|
|
}
|
|
|
|
/*
|
|
* If this grid has its full complement of cells, ignore
|
|
* this subgrid cell.
|
|
*/
|
|
if (grid->cell_count >= (grid->rows * grid->cols))
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
********************************
|
|
* Create and parse the subgrid *
|
|
********************************
|
|
*/
|
|
rows = 1;
|
|
cols = 1;
|
|
|
|
subgrid = XP_NEW(lo_GridRec);
|
|
if (subgrid == NULL)
|
|
{
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
|
|
subgrid->no_edges = grid->no_edges;
|
|
subgrid->edge_size = grid->edge_size;
|
|
subgrid->color_priority = 0;
|
|
subgrid->border_color = NULL;
|
|
subgrid->edge_list = NULL;
|
|
subgrid->cell_list = NULL;
|
|
subgrid->cell_list_last = NULL;
|
|
subgrid->subgrid = NULL;
|
|
|
|
/*
|
|
* Check for a border color attribute
|
|
*/
|
|
buff = lo_FetchParamValue(context, tag, PARAM_BORDERCOLOR);
|
|
if (buff != NULL)
|
|
{
|
|
uint8 red, green, blue;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
LO_ParseRGB(str, &red, &green, &blue);
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
subgrid->border_color = XP_NEW(LO_Color);
|
|
if (subgrid->border_color != NULL)
|
|
{
|
|
subgrid->border_color->red = red;
|
|
subgrid->border_color->green = green;
|
|
subgrid->border_color->blue = blue;
|
|
subgrid->color_priority = 2;
|
|
}
|
|
}
|
|
/*
|
|
* Else we might inherit a border color from parent.
|
|
*/
|
|
else if (grid->border_color != NULL)
|
|
{
|
|
subgrid->border_color = XP_NEW(LO_Color);
|
|
if (subgrid->border_color != NULL)
|
|
{
|
|
subgrid->border_color->red = grid->border_color->red;
|
|
subgrid->border_color->green = grid->border_color->green;
|
|
subgrid->border_color->blue = grid->border_color->blue;
|
|
subgrid->color_priority = grid->color_priority;
|
|
}
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_FRAMEBORDER);
|
|
if (buff != NULL)
|
|
{
|
|
Bool no_edges;
|
|
|
|
no_edges = FALSE;
|
|
PA_LOCK(str, char *, buff);
|
|
if (pa_TagEqual("no", str))
|
|
{
|
|
no_edges = TRUE;
|
|
}
|
|
else if (pa_TagEqual("0", str))
|
|
{
|
|
no_edges = TRUE;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
subgrid->no_edges = no_edges;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_ROWS);
|
|
if (buff != NULL)
|
|
{
|
|
int32 len;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
|
|
row_percents = lo_parse_percent_list(context, str, &rows);
|
|
if ((row_percents == NULL)&&(rows >= 1))
|
|
{
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
XP_DELETE(subgrid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (rows <= 0)
|
|
{
|
|
row_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (row_percents == NULL)
|
|
{
|
|
XP_DELETE(subgrid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
row_percents[0].type = LO_PERCENT_NORMAL;
|
|
row_percents[0].original_value = 100;
|
|
rows = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
row_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (row_percents == NULL)
|
|
{
|
|
XP_DELETE(subgrid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
row_percents[0].type = LO_PERCENT_NORMAL;
|
|
row_percents[0].original_value = 100;
|
|
rows = 1;
|
|
}
|
|
|
|
buff = lo_FetchParamValue(context, tag, PARAM_COLS);
|
|
if (buff != NULL)
|
|
{
|
|
int32 len;
|
|
|
|
PA_LOCK(str, char *, buff);
|
|
len = lo_StripTextWhitespace(str, XP_STRLEN(str));
|
|
col_percents = lo_parse_percent_list(context, str, &cols);
|
|
if ((col_percents == NULL)&&(cols >= 1))
|
|
{
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
XP_DELETE(subgrid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
PA_UNLOCK(buff);
|
|
PA_FREE(buff);
|
|
if (cols <= 0)
|
|
{
|
|
col_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (col_percents == NULL)
|
|
{
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
XP_DELETE(subgrid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
col_percents[0].type = LO_PERCENT_NORMAL;
|
|
col_percents[0].original_value = 100;
|
|
cols = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
col_percents = (lo_GridPercent *)
|
|
XP_ALLOC(sizeof(lo_GridPercent));
|
|
if (col_percents == NULL)
|
|
{
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
XP_DELETE(subgrid);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
col_percents[0].type = LO_PERCENT_NORMAL;
|
|
col_percents[0].original_value = 100;
|
|
cols = 1;
|
|
}
|
|
|
|
if ((rows == 1)&&(cols == 1))
|
|
{
|
|
if (row_percents != NULL)
|
|
{
|
|
XP_FREE(row_percents);
|
|
}
|
|
if (col_percents != NULL)
|
|
{
|
|
XP_FREE(col_percents);
|
|
}
|
|
XP_DELETE(subgrid);
|
|
return;
|
|
}
|
|
|
|
(void)lo_ProcessContextEventHandlers(context, state, tag);
|
|
|
|
subgrid->rows = rows;
|
|
subgrid->row_percents = row_percents;
|
|
subgrid->cols = cols;
|
|
subgrid->col_percents = col_percents;
|
|
subgrid->cell_count = 0;
|
|
|
|
subgrid->current_hist = 0;
|
|
subgrid->max_hist = 0;
|
|
subgrid->hist_size = 10;
|
|
|
|
subgrid->main_width = state->win_width;
|
|
subgrid->main_height = state->win_height;
|
|
subgrid->current_cell_margin_width = 0;
|
|
subgrid->current_cell_margin_height = 0;
|
|
|
|
subgrid->subgrid = state->current_grid->subgrid;
|
|
state->current_grid->subgrid = subgrid;
|
|
|
|
/*
|
|
******************************************
|
|
* Subgrid parsing done. *
|
|
* Create a dummy cell to hang it off of. *
|
|
******************************************
|
|
*/
|
|
|
|
cell = XP_NEW(lo_GridCellRec);
|
|
if (cell == NULL)
|
|
{
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
|
|
row_cnt = grid->cell_count / grid->cols;
|
|
col_cnt = grid->cell_count - (row_cnt * grid->cols);
|
|
|
|
cell->x = 0;
|
|
cell->y = 0;
|
|
cell->width = 0;
|
|
cell->height = 0;
|
|
cell->margin_width = 0;
|
|
cell->margin_height = 0;
|
|
cell->width_percent = 0;
|
|
cell->height_percent = 0;
|
|
cell->url = NULL;
|
|
cell->name = NULL;
|
|
cell->context = NULL;
|
|
cell->hist_list = NULL;
|
|
cell->hist_array = (lo_GridHistory *)XP_ALLOC(grid->hist_size *
|
|
sizeof(lo_GridHistory));
|
|
if (cell->hist_array == NULL)
|
|
{
|
|
XP_DELETE(cell);
|
|
state->top_state->out_of_memory = TRUE;
|
|
return;
|
|
}
|
|
XP_MEMSET(cell->hist_array, 0, grid->hist_size *
|
|
sizeof(lo_GridHistory));
|
|
cell->hist_indx = 0;
|
|
cell->next = NULL;
|
|
cell->subgrid = subgrid;
|
|
cell->side_edges[TOP_EDGE] = NULL;
|
|
cell->side_edges[BOTTOM_EDGE] = NULL;
|
|
cell->side_edges[LEFT_EDGE] = NULL;
|
|
cell->side_edges[RIGHT_EDGE] = NULL;
|
|
cell->scrolling = LO_SCROLL_AUTO;
|
|
cell->no_edges = subgrid->no_edges;
|
|
cell->resizable = TRUE;
|
|
cell->edge_size = -1;
|
|
cell->color_priority = 0;
|
|
cell->border_color = NULL;
|
|
|
|
grid->cell_count++;
|
|
|
|
if (grid->cell_list_last == NULL)
|
|
{
|
|
grid->cell_list = cell;
|
|
grid->cell_list_last = cell;
|
|
}
|
|
else
|
|
{
|
|
grid->cell_list_last->next = cell;
|
|
grid->cell_list_last = cell;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
lo_EndSubgrid(MWContext *context, lo_DocState *state, lo_GridRec *grid)
|
|
{
|
|
lo_GridRec *subgrid;
|
|
|
|
if ((grid == NULL)||(grid->subgrid == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
subgrid = grid->subgrid;
|
|
grid->subgrid = grid->subgrid->subgrid;
|
|
subgrid->subgrid = NULL;
|
|
}
|
|
|
|
|
|
#ifdef DEBUG_EDGES
|
|
static void
|
|
lo_print_edge_info(lo_GridEdge *edge)
|
|
{
|
|
int32 i;
|
|
|
|
fprintf(stderr, "\nEdge %ld,%ld %ldx%ld; Range is %ld to %ld\n",
|
|
(long) edge->x, (long) edge->y, (long) edge->width,
|
|
(long) edge->height, (long) edge->left_top_bound,
|
|
(long) edge->right_bottom_bound);
|
|
fprintf(stderr, "\tBounds %ld cells\n", (long) edge->cell_cnt);
|
|
for (i=0; i < edge->cell_cnt; i++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge->cell_array[i];
|
|
fprintf(stderr, "\t(%ld) %ld,%ld %ldx%ld\n",
|
|
(long) i, (long) cell->x, (long) cell->y,
|
|
(long) cell->width, (long) cell->height);
|
|
}
|
|
fprintf(stderr, "\n");
|
|
}
|
|
#endif /* DEBUG_EDGES */
|
|
|
|
|
|
LO_Element *
|
|
lo_XYToGridEdge(MWContext *context, lo_DocState *state, int32 x, int32 y)
|
|
{
|
|
lo_GridRec *grid;
|
|
lo_GridEdge *edge_list;
|
|
|
|
if ((state->top_state->is_grid == FALSE)||
|
|
(state->top_state->the_grid == NULL))
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
grid = state->top_state->the_grid;
|
|
edge_list = grid->edge_list;
|
|
while (edge_list != NULL)
|
|
{
|
|
/*
|
|
* You cannot grab invisible edges.
|
|
*/
|
|
if (edge_list->fe_edge->visible == FALSE)
|
|
{
|
|
edge_list = edge_list->next;
|
|
continue;
|
|
}
|
|
|
|
if (edge_list->is_vertical == FALSE)
|
|
{
|
|
if ((y >= edge_list->y)&&
|
|
(y < (edge_list->y + edge_list->height))&&
|
|
(x >= edge_list->x)&&
|
|
(x < (edge_list->x + edge_list->width)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((x >= edge_list->x)&&
|
|
(x < (edge_list->x + edge_list->width))&&
|
|
(y >= edge_list->y)&&
|
|
(y < (edge_list->y + edge_list->height)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
edge_list = edge_list->next;
|
|
}
|
|
|
|
if (edge_list != NULL)
|
|
{
|
|
#ifdef DEBUG_EDGES
|
|
lo_print_edge_info(edge_list);
|
|
#endif /* DEBUG_EDGES */
|
|
return((LO_Element *)edge_list->fe_edge);
|
|
}
|
|
else
|
|
{
|
|
return(NULL);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Edges left of a moved vertical edge may need to be shrunk
|
|
* or grown with the edge.
|
|
*/
|
|
static void
|
|
lo_change_left_edges(MWContext *context, lo_GridEdge *edge,
|
|
int32 bound, int32 diff, Bool call_display_edge)
|
|
{
|
|
if (edge != NULL)
|
|
{
|
|
/*
|
|
* If this edge abuts the edge moved,
|
|
* change this edges width just like
|
|
* the cell.
|
|
*/
|
|
if ((edge->x + edge->width) == bound)
|
|
{
|
|
edge->width += diff;
|
|
edge->fe_edge->width += diff;
|
|
|
|
if (call_display_edge)
|
|
/*
|
|
* Display the edge that was just changed.
|
|
*/
|
|
lo_DisplayEdge(context, edge->fe_edge);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Edges right of a moved vertical edge may need to be moved and shrunk
|
|
* or grown with the edge.
|
|
*/
|
|
static void
|
|
lo_change_right_edges(MWContext *context, lo_GridEdge *edge,
|
|
int32 bound, int32 diff, Bool call_display_edge)
|
|
{
|
|
if (edge != NULL)
|
|
{
|
|
/*
|
|
* If this edge abuts the edge moved,
|
|
* change this edges position and width just like
|
|
* the cell.
|
|
*/
|
|
if ((edge->x - 1) == bound)
|
|
{
|
|
edge->x += diff;
|
|
edge->width -= diff;
|
|
edge->fe_edge->x += diff;
|
|
edge->fe_edge->width -= diff;
|
|
if (call_display_edge)
|
|
/*
|
|
* Display the edge that was just changed.
|
|
*/
|
|
lo_DisplayEdge(context, edge->fe_edge);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Edges above a moved vertical edge may need to be shrunk
|
|
* or grown with the edge.
|
|
*/
|
|
static void
|
|
lo_change_top_edges(MWContext *context, lo_GridEdge *edge,
|
|
int32 bound, int32 diff, Bool call_display_edge)
|
|
{
|
|
if (edge != NULL)
|
|
{
|
|
/*
|
|
* If this edge abuts the edge moved,
|
|
* change this edges width just like
|
|
* the cell.
|
|
*/
|
|
if ((edge->y + edge->height) == bound)
|
|
{
|
|
edge->height += diff;
|
|
edge->fe_edge->height += diff;
|
|
if (call_display_edge)
|
|
/*
|
|
* Display the edge that was just changed.
|
|
*/
|
|
lo_DisplayEdge(context, edge->fe_edge);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Edges below a moved horizontal edge may need to be moved and shrunk
|
|
* or grown with the edge.
|
|
*/
|
|
static void
|
|
lo_change_bottom_edges(MWContext *context, lo_GridEdge *edge,
|
|
int32 bound, int32 diff, Bool call_display_edge)
|
|
{
|
|
if (edge != NULL)
|
|
{
|
|
/*
|
|
* If this edge abuts the edge moved,
|
|
* change this edges position and width just like
|
|
* the cell.
|
|
*/
|
|
if ((edge->y - 1) == bound)
|
|
{
|
|
edge->y += diff;
|
|
edge->height -= diff;
|
|
edge->fe_edge->y += diff;
|
|
edge->fe_edge->height -= diff;
|
|
if (call_display_edge)
|
|
/*
|
|
* Display the edge that was just changed.
|
|
*/
|
|
lo_DisplayEdge(context, edge->fe_edge);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
LO_MoveGridEdge(MWContext *context, LO_EdgeStruct *fe_edge, int32 x, int32 y)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_DocState *state;
|
|
int32 i;
|
|
lo_GridEdge *edge;
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->doc_state == NULL))
|
|
{
|
|
return;
|
|
}
|
|
state = top_state->doc_state;
|
|
|
|
edge = (lo_GridEdge *)fe_edge->lo_edge_info;
|
|
if (edge == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* For horizontal edges
|
|
*/
|
|
if (edge->is_vertical == FALSE)
|
|
{
|
|
int32 diff;
|
|
|
|
diff = y - edge->y;
|
|
|
|
for (i=0; i < edge->cell_cnt; i++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
/*
|
|
* If the cell is above the edge.
|
|
* Grow the cell and any abutting
|
|
* edges.
|
|
*/
|
|
if (cell->y < edge->y)
|
|
{
|
|
cell->height += diff;
|
|
lo_change_top_edges(context,
|
|
cell->side_edges[LEFT_EDGE],
|
|
edge->y, diff, TRUE);
|
|
lo_change_top_edges(context,
|
|
cell->side_edges[RIGHT_EDGE],
|
|
edge->y, diff, TRUE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[TOP_EDGE]);
|
|
}
|
|
/*
|
|
* Else the cell is below the edge.
|
|
* Move and shrink the cell and any abutting
|
|
* edges.
|
|
*/
|
|
else
|
|
{
|
|
cell->y += diff;
|
|
cell->height -= diff;
|
|
lo_change_bottom_edges(context,
|
|
cell->side_edges[LEFT_EDGE],
|
|
(edge->y + edge->height - 1), diff, TRUE);
|
|
lo_change_bottom_edges(context,
|
|
cell->side_edges[RIGHT_EDGE],
|
|
(edge->y + edge->height - 1), diff, TRUE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[BOTTOM_EDGE]);
|
|
}
|
|
/*
|
|
* Only restructure cells that have windows(contexts)
|
|
*/
|
|
if (cell->context != NULL)
|
|
{
|
|
FE_RestructureGridWindow (cell->context,
|
|
cell->x, cell->y,
|
|
cell->width, cell->height);
|
|
}
|
|
}
|
|
edge->y = y;
|
|
edge->fe_edge->y = y;
|
|
}
|
|
/*
|
|
* Else for vertical edges.
|
|
*/
|
|
else
|
|
{
|
|
int32 diff;
|
|
|
|
diff = x - edge->x;
|
|
|
|
for (i=0; i < edge->cell_cnt; i++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
/*
|
|
* If the cell is left of the edge.
|
|
* Grow the cell and any abutting
|
|
* edges.
|
|
*/
|
|
if (cell->x < edge->x)
|
|
{
|
|
cell->width += diff;
|
|
lo_change_left_edges(context,
|
|
cell->side_edges[TOP_EDGE],
|
|
edge->x, diff, TRUE);
|
|
lo_change_left_edges(context,
|
|
cell->side_edges[BOTTOM_EDGE],
|
|
edge->x, diff, TRUE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[LEFT_EDGE]);
|
|
}
|
|
/*
|
|
* Else the cell is right of the edge.
|
|
* Move and shrink the cell and any abutting
|
|
* edges.
|
|
*/
|
|
else
|
|
{
|
|
cell->x += diff;
|
|
cell->width -= diff;
|
|
lo_change_right_edges(context,
|
|
cell->side_edges[TOP_EDGE],
|
|
(edge->x + edge->width - 1), diff, TRUE);
|
|
lo_change_right_edges(context,
|
|
cell->side_edges[BOTTOM_EDGE],
|
|
(edge->x + edge->width - 1), diff, TRUE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[RIGHT_EDGE]);
|
|
}
|
|
/*
|
|
* Only restructure cells that have windows(contexts)
|
|
*/
|
|
if (cell->context != NULL)
|
|
{
|
|
FE_RestructureGridWindow (cell->context,
|
|
cell->x, cell->y,
|
|
cell->width, cell->height);
|
|
}
|
|
}
|
|
edge->x = x;
|
|
edge->fe_edge->x = x;
|
|
}
|
|
/*
|
|
* Display the edge that was just moved.
|
|
*/
|
|
lo_DisplayEdge(context, edge->fe_edge);
|
|
}
|
|
|
|
intn
|
|
lo_GetCurrentGridCellStatus(lo_GridCellRec *cell)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
|
|
/*
|
|
* This is a blank cell, always considered complete.
|
|
*/
|
|
if ((cell == NULL)||(cell->context == NULL))
|
|
{
|
|
return(PA_COMPLETE);
|
|
}
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(cell->context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if (top_state == NULL)
|
|
{
|
|
return(-1);
|
|
}
|
|
return(top_state->layout_status);
|
|
}
|
|
|
|
|
|
char *
|
|
lo_GetCurrentGridCellUrl(lo_GridCellRec *cell)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
char *url;
|
|
|
|
if ((cell == NULL)||(cell->context == NULL))
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(cell->context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if (top_state == NULL)
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
if (top_state->url == NULL)
|
|
{
|
|
url = NULL;
|
|
}
|
|
else
|
|
{
|
|
url = XP_STRDUP(top_state->url);
|
|
}
|
|
return(url);
|
|
}
|
|
|
|
|
|
void
|
|
lo_GetGridCellMargins(MWContext *context,
|
|
int32 *margin_width, int32 *margin_height)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
MWContext *parent;
|
|
lo_GridCellRec *cell_ptr;
|
|
|
|
if ((context == NULL)||(context->grid_parent == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
parent = context->grid_parent;
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(parent);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->the_grid == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Find the cell whose context matches the passed in context.
|
|
*/
|
|
cell_ptr = top_state->the_grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
if (cell_ptr->context == context)
|
|
{
|
|
break;
|
|
}
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
|
|
/*
|
|
* If we found the cell, set our margins.
|
|
*/
|
|
if (cell_ptr != NULL)
|
|
{
|
|
*margin_width = cell_ptr->margin_width;
|
|
*margin_height = cell_ptr->margin_height;
|
|
}
|
|
/*
|
|
* If we didn't find the cell, it is
|
|
* in the middle of creation, get the
|
|
* margins from the parent grid.
|
|
*/
|
|
else
|
|
{
|
|
*margin_width = top_state->the_grid->current_cell_margin_width;
|
|
*margin_height = top_state->the_grid->current_cell_margin_height;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
lo_reset_all_edge_bounds(MWContext *context, lo_DocState *state,
|
|
lo_GridRec *grid)
|
|
{
|
|
lo_GridEdge *edge_list;
|
|
|
|
if ((grid == NULL)||(grid->edge_list == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
edge_list = grid->edge_list;
|
|
while (edge_list != NULL)
|
|
{
|
|
LO_EdgeStruct *fe_edge;
|
|
|
|
fe_edge = (LO_EdgeStruct *)lo_NewElement(context, state,
|
|
LO_EDGE, NULL, 0);
|
|
if (fe_edge == NULL)
|
|
{
|
|
}
|
|
|
|
fe_edge->type = LO_EDGE;
|
|
fe_edge->ele_id = NEXT_ELEMENT;
|
|
fe_edge->x = edge_list->x;
|
|
fe_edge->x_offset = 0;
|
|
fe_edge->y = edge_list->y;
|
|
fe_edge->y_offset = 0;
|
|
fe_edge->width = edge_list->width;
|
|
fe_edge->height = edge_list->height;
|
|
fe_edge->line_height = 0;
|
|
fe_edge->next = NULL;
|
|
fe_edge->prev = NULL;
|
|
|
|
fe_edge->FE_Data = NULL;
|
|
fe_edge->lo_edge_info = (void *)edge_list;
|
|
fe_edge->is_vertical = edge_list->is_vertical;
|
|
fe_edge->movable = TRUE;
|
|
fe_edge->left_top_bound = 0;
|
|
fe_edge->right_bottom_bound = 0;
|
|
|
|
edge_list->fe_edge = fe_edge;
|
|
|
|
lo_set_edge_bounds(edge_list);
|
|
|
|
/*
|
|
* Insert this edge into the float list.
|
|
*/
|
|
edge_list->fe_edge->next = state->float_list;
|
|
state->float_list = (LO_Element *)edge_list->fe_edge;
|
|
|
|
lo_DisplayEdge(context, edge_list->fe_edge);
|
|
edge_list = edge_list->next;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
lo_RecreateGrid(MWContext *context, lo_DocState *state, lo_GridRec *grid)
|
|
{
|
|
lo_GridCellRec *cell_ptr;
|
|
int32 width, height;
|
|
|
|
width = state->win_width;
|
|
height = state->win_height;
|
|
FE_GetFullWindowSize(context, &width, &height);
|
|
|
|
if (width <= 0)
|
|
width = 1;
|
|
|
|
if (height <= 0)
|
|
height = 1;
|
|
|
|
/* already set.
|
|
grid->main_width = width;
|
|
grid->main_height = height;
|
|
*/
|
|
|
|
lo_reset_all_edge_bounds(context, state, grid);
|
|
|
|
state->top_state->the_grid = grid;
|
|
|
|
/*
|
|
* Go through all the cells creating them where specified.
|
|
*/
|
|
cell_ptr = grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
/*
|
|
* Have the front end create the grid cell.
|
|
*/
|
|
if (cell_ptr->url != NULL)
|
|
{
|
|
void *history;
|
|
void *hist_list;
|
|
|
|
history = NULL;
|
|
hist_list = NULL;
|
|
if (cell_ptr->hist_list != NULL)
|
|
{
|
|
hist_list = cell_ptr->hist_list;
|
|
cell_ptr->hist_indx = grid->current_hist;
|
|
history = cell_ptr->hist_array[cell_ptr->hist_indx - 1].hist;
|
|
if (history == NULL)
|
|
{
|
|
hist_list = NULL;
|
|
}
|
|
}
|
|
grid->current_cell_margin_width = cell_ptr->margin_width;
|
|
grid->current_cell_margin_height = cell_ptr->margin_height;
|
|
reconnecting_cell = cell_ptr;
|
|
cell_ptr->context = FE_MakeGridWindow (context,
|
|
hist_list,
|
|
history,
|
|
cell_ptr->x, cell_ptr->y,
|
|
cell_ptr->width, cell_ptr->height,
|
|
(char *)cell_ptr->url, (char *)cell_ptr->name,
|
|
cell_ptr->scrolling,
|
|
FORCE_RELOAD_FLAG(state->top_state),
|
|
cell_ptr->no_edges);
|
|
reconnecting_cell = NULL;
|
|
grid->current_cell_margin_width = 0;
|
|
grid->current_cell_margin_height = 0;
|
|
if (cell_ptr->context)
|
|
{
|
|
XP_ASSERT(cell_ptr->context->forceJSEnabled ==
|
|
context->forceJSEnabled);
|
|
if (history)
|
|
{
|
|
cell_ptr->context->hist.cur_doc_ptr = history;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell_ptr->context = NULL;
|
|
}
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
lo_GridCellRec *
|
|
lo_ContextToCell(MWContext *context, Bool reconnect, lo_GridRec **grid_ptr)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
MWContext *parent;
|
|
lo_GridCellRec *cell_ptr;
|
|
|
|
*grid_ptr = NULL;
|
|
if ((context == NULL)||(context->grid_parent == NULL))
|
|
{
|
|
return((lo_GridCellRec *)NULL);
|
|
}
|
|
|
|
parent = context->grid_parent;
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(parent);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->the_grid == NULL))
|
|
{
|
|
return((lo_GridCellRec *)NULL);
|
|
}
|
|
|
|
*grid_ptr = top_state->the_grid;
|
|
|
|
/*
|
|
* Find the cell whose context matches the passed in context.
|
|
*/
|
|
cell_ptr = top_state->the_grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
if (cell_ptr->context == context)
|
|
{
|
|
return(cell_ptr);
|
|
}
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
|
|
if (reconnect && (cell_ptr = reconnecting_cell) != NULL)
|
|
{
|
|
cell_ptr->context = context;
|
|
if (context->grid_parent)
|
|
{
|
|
context->forceJSEnabled =
|
|
context->grid_parent->forceJSEnabled;
|
|
}
|
|
|
|
return(cell_ptr);
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
static void
|
|
lo_set_hist(MWContext *context, void **hep, History_entry *hist)
|
|
{
|
|
History_entry *oldhist = *hep;
|
|
|
|
if (oldhist == hist)
|
|
return;
|
|
*hep = SHIST_HoldEntry(hist);
|
|
SHIST_DropEntry(context, oldhist);
|
|
}
|
|
|
|
|
|
PRIVATE
|
|
void
|
|
lo_UpdateOtherCells(lo_GridRec *grid, lo_GridCellRec *the_cell)
|
|
{
|
|
lo_GridCellRec *cell_ptr;
|
|
|
|
cell_ptr = grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
if ((cell_ptr != the_cell)&&
|
|
(cell_ptr->hist_indx < grid->current_hist))
|
|
{
|
|
int32 i;
|
|
int32 old;
|
|
|
|
/*
|
|
* Make sure se don't go backwards off the beginning
|
|
* of the array.
|
|
*/
|
|
old = cell_ptr->hist_indx - 1;
|
|
if (old < 0)
|
|
{
|
|
old = 0;
|
|
}
|
|
|
|
for (i = cell_ptr->hist_indx; i < grid->current_hist; i++)
|
|
{
|
|
lo_set_hist(cell_ptr->context,
|
|
&cell_ptr->hist_array[i].hist,
|
|
cell_ptr->hist_array[old].hist);
|
|
cell_ptr->hist_array[i].position =
|
|
cell_ptr->hist_array[old].position;
|
|
}
|
|
|
|
/*
|
|
* If we got here and hist_indx is zero, that means
|
|
* we are trying to update this cell, before it ever
|
|
* had its initializing load. In that case, we
|
|
* want to leave hist_indx zero so we will be able to
|
|
* detect that initializing load when it occurs.
|
|
*/
|
|
if (cell_ptr->hist_indx > 0)
|
|
{
|
|
cell_ptr->hist_indx = grid->current_hist;
|
|
}
|
|
}
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
lo_grow_grid_hist_arrays(lo_GridRec *grid)
|
|
{
|
|
int32 new_size;
|
|
lo_GridCellRec *cell_ptr;
|
|
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
new_size = grid->hist_size + 10;
|
|
cell_ptr = grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
lo_GridHistory *new_array;
|
|
|
|
new_array = (lo_GridHistory *)XP_REALLOC(cell_ptr->hist_array,
|
|
(new_size * sizeof(lo_GridHistory)));
|
|
if (new_array == NULL)
|
|
{
|
|
/* XXX should set top_state->out_of_memory somehow */
|
|
return;
|
|
}
|
|
XP_MEMSET(new_array + grid->hist_size, 0,
|
|
(10 * sizeof(lo_GridHistory)));
|
|
cell_ptr->hist_array = new_array;
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
grid->hist_size = new_size;
|
|
}
|
|
|
|
|
|
void
|
|
LO_UpdateGridHistory(MWContext *context)
|
|
{
|
|
lo_GridRec *grid;
|
|
lo_GridCellRec *cell_ptr;
|
|
History_entry *hist;
|
|
|
|
cell_ptr = lo_ContextToCell(context, TRUE, &grid);
|
|
if (cell_ptr == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
hist = SHIST_GetCurrent(&context->hist);
|
|
if (hist == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cell_ptr->hist_indx >= grid->current_hist)
|
|
{
|
|
if (grid->current_hist >= grid->hist_size)
|
|
{
|
|
lo_grow_grid_hist_arrays(grid);
|
|
}
|
|
grid->current_hist = cell_ptr->hist_indx + 1;
|
|
if (grid->current_hist > grid->max_hist)
|
|
{
|
|
grid->max_hist = grid->current_hist;
|
|
}
|
|
else if (grid->current_hist < grid->max_hist)
|
|
{
|
|
grid->max_hist = grid->current_hist;
|
|
}
|
|
if (grid->current_hist > 1)
|
|
{
|
|
lo_UpdateOtherCells(grid, cell_ptr);
|
|
if ((context->grid_parent != NULL)&&
|
|
(context->grid_parent->is_grid_cell != FALSE))
|
|
{
|
|
LO_UpdateGridHistory(context->grid_parent);
|
|
}
|
|
}
|
|
}
|
|
lo_set_hist(context,
|
|
&cell_ptr->hist_array[cell_ptr->hist_indx].hist,
|
|
hist);
|
|
if (cell_ptr->hist_indx == 0)
|
|
{
|
|
cell_ptr->hist_array[cell_ptr->hist_indx].position = 1;
|
|
/*
|
|
* This means some other grid cell already progressed before
|
|
* we got our first load, now that we are loaded, catch up.
|
|
*/
|
|
if (grid->current_hist > 1)
|
|
{
|
|
int32 i;
|
|
|
|
for (i = 1; i < grid->current_hist; i++)
|
|
{
|
|
lo_set_hist(context,
|
|
&cell_ptr->hist_array[i].hist,
|
|
cell_ptr->hist_array[0].hist);
|
|
cell_ptr->hist_array[i].position =
|
|
cell_ptr->hist_array[0].position;
|
|
}
|
|
cell_ptr->hist_indx = grid->current_hist - 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Drop held MochaDecoder if any, we needed it only during
|
|
* resize-reload and don't now that we've moved forward in
|
|
* this frame context's history.
|
|
*/
|
|
hist = cell_ptr->hist_array[cell_ptr->hist_indx - 1].hist;
|
|
if (hist && hist->savedData.Window)
|
|
{
|
|
LM_DropSavedWindow(context, hist->savedData.Window);
|
|
hist->savedData.Window = NULL;
|
|
}
|
|
|
|
cell_ptr->hist_array[cell_ptr->hist_indx].position =
|
|
cell_ptr->hist_array[cell_ptr->hist_indx - 1].position + 1;
|
|
}
|
|
cell_ptr->hist_indx++;
|
|
}
|
|
|
|
|
|
PRIVATE
|
|
void
|
|
lo_BackupGridHistory(lo_GridRec *grid)
|
|
{
|
|
lo_GridCellRec *cell_ptr;
|
|
|
|
cell_ptr = grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
if (cell_ptr->hist_indx > 1)
|
|
{
|
|
int32 indx;
|
|
|
|
cell_ptr->hist_indx--;
|
|
indx = cell_ptr->hist_indx - 1;
|
|
|
|
if (cell_ptr->hist_array[indx].hist !=
|
|
cell_ptr->hist_array[cell_ptr->hist_indx].hist)
|
|
{
|
|
lo_reload_cell_from_history(cell_ptr,
|
|
NET_DONT_RELOAD);
|
|
}
|
|
else if ((cell_ptr->hist_array[indx].position !=
|
|
cell_ptr->hist_array[cell_ptr->hist_indx].position)&&
|
|
(cell_ptr->context != NULL)&&
|
|
(cell_ptr->context->grid_children != NULL))
|
|
{
|
|
(void)LO_BackInGrid(cell_ptr->context);
|
|
}
|
|
}
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
}
|
|
|
|
|
|
PRIVATE
|
|
void
|
|
lo_ForwardGridHistory(lo_GridRec *grid)
|
|
{
|
|
lo_GridCellRec *cell_ptr;
|
|
|
|
cell_ptr = grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
if (cell_ptr->hist_indx < grid->max_hist)
|
|
{
|
|
int32 indx;
|
|
|
|
cell_ptr->hist_indx++;
|
|
indx = cell_ptr->hist_indx - 1;
|
|
|
|
if (cell_ptr->hist_array[indx].hist !=
|
|
cell_ptr->hist_array[indx - 1].hist)
|
|
{
|
|
lo_reload_cell_from_history(cell_ptr,
|
|
NET_DONT_RELOAD);
|
|
}
|
|
else if ((cell_ptr->hist_array[indx].position !=
|
|
cell_ptr->hist_array[indx - 1].position)&&
|
|
(cell_ptr->context != NULL)&&
|
|
(cell_ptr->context->grid_children != NULL))
|
|
{
|
|
(void)LO_ForwardInGrid(cell_ptr->context);
|
|
}
|
|
}
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
}
|
|
|
|
|
|
Bool
|
|
LO_BackInGrid(MWContext *context)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_GridRec *grid;
|
|
|
|
if ((context == NULL)||(context->grid_children == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->the_grid == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
grid = top_state->the_grid;
|
|
|
|
if (grid->current_hist <= 1)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
lo_BackupGridHistory(grid);
|
|
grid->current_hist--;
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
Bool
|
|
LO_ForwardInGrid(MWContext *context)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_GridRec *grid;
|
|
|
|
if ((context == NULL)||(context->grid_children == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->the_grid == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
grid = top_state->the_grid;
|
|
|
|
if (grid->current_hist >= grid->max_hist)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
lo_ForwardGridHistory(grid);
|
|
grid->current_hist++;
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
Bool
|
|
LO_GridCanGoForward(MWContext *context)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_GridRec *grid;
|
|
|
|
if ((context == NULL)||(context->grid_children == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->the_grid == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
grid = top_state->the_grid;
|
|
|
|
if (grid->current_hist < grid->max_hist)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
Bool
|
|
LO_GridCanGoBackward(MWContext *context)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_GridRec *grid;
|
|
|
|
if ((context == NULL)||(context->grid_children == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->the_grid == NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
grid = top_state->the_grid;
|
|
|
|
if (grid->current_hist > 1)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
static void
|
|
lo_cleanup_grid_history(MWContext *context, lo_GridRec *grid)
|
|
{
|
|
lo_GridCellRec *cell_ptr;
|
|
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Set the current history to be the new maximum.
|
|
*/
|
|
grid->max_hist = grid->current_hist;
|
|
|
|
/*
|
|
* Go through all the cells, truncating their history lists
|
|
*/
|
|
cell_ptr = grid->cell_list;
|
|
while (cell_ptr != NULL)
|
|
{
|
|
int32 indx, count;
|
|
XP_List *list_ptr;
|
|
History_entry *cell_hist;
|
|
|
|
list_ptr = (XP_List *)cell_ptr->hist_list;
|
|
cell_hist = cell_ptr->hist_array[grid->current_hist - 1].hist;
|
|
if ((list_ptr != NULL)&&(cell_hist != NULL))
|
|
{
|
|
indx = XP_ListGetNumFromObject(list_ptr, cell_hist);
|
|
for (count = XP_ListCount(list_ptr); count > indx; count--)
|
|
{
|
|
History_entry *old_entry;
|
|
|
|
old_entry =
|
|
(History_entry *)XP_ListRemoveEndObject(list_ptr);
|
|
SHIST_DropEntry(context, old_entry);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the last history entry in the cells chain
|
|
* is itself a grid, it may need to be cleaned
|
|
* up recursively.
|
|
*/
|
|
if (cell_hist != NULL)
|
|
{
|
|
lo_SavedGridData *saved_grid;
|
|
|
|
saved_grid =(lo_SavedGridData *)(cell_hist->savedData.Grid);
|
|
if ((saved_grid != NULL)&&(saved_grid->the_grid != NULL))
|
|
{
|
|
lo_cleanup_grid_history(context, saved_grid->the_grid);
|
|
}
|
|
}
|
|
|
|
cell_ptr = cell_ptr->next;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* When we have just added a session history after
|
|
* this one, clean up the grid's history chains if
|
|
* it is the parent we just left.
|
|
*/
|
|
void
|
|
LO_CleanupGridHistory(MWContext *context)
|
|
{
|
|
History_entry *hist;
|
|
lo_SavedGridData *saved_grid;
|
|
lo_GridRec *grid;
|
|
|
|
/*
|
|
* Look back one, if the is no back, return.
|
|
*/
|
|
hist = SHIST_GetPrevious(context);
|
|
if (hist == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Is the document back one in history a valid grid,
|
|
* if not, return.
|
|
*/
|
|
saved_grid = (lo_SavedGridData *)(hist->savedData.Grid);
|
|
if ((saved_grid == NULL)||(saved_grid->the_grid == NULL))
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Since we are appending after this history stage,
|
|
* the current history chains must be
|
|
* clipped so this is the new max.
|
|
*/
|
|
grid = saved_grid->the_grid;
|
|
lo_cleanup_grid_history(context, grid);
|
|
}
|
|
|
|
static void
|
|
lo_MoveGridEdgeForRelayout(MWContext *context, LO_EdgeStruct *fe_edge, int32 x, int32 y)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_DocState *state;
|
|
int32 i;
|
|
lo_GridEdge *edge;
|
|
|
|
/*
|
|
* Get the unique document ID, and retreive this
|
|
* documents layout state.
|
|
*/
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if ((top_state == NULL)||(top_state->doc_state == NULL))
|
|
{
|
|
return;
|
|
}
|
|
state = top_state->doc_state;
|
|
|
|
edge = (lo_GridEdge *)fe_edge->lo_edge_info;
|
|
if (edge == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* For horizontal edges
|
|
*/
|
|
if (edge->is_vertical == FALSE)
|
|
{
|
|
int32 diff;
|
|
|
|
diff = y - edge->y;
|
|
|
|
for (i=0; i < edge->cell_cnt; i++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
/*
|
|
* If the cell is above the edge.
|
|
* Grow the cell and any abutting
|
|
* edges.
|
|
*/
|
|
if (cell->y < edge->y)
|
|
{
|
|
#if 0
|
|
cell->height += diff;
|
|
#endif
|
|
lo_change_top_edges(context,
|
|
cell->side_edges[LEFT_EDGE],
|
|
edge->y, diff, FALSE);
|
|
lo_change_top_edges(context,
|
|
cell->side_edges[RIGHT_EDGE],
|
|
edge->y, diff, FALSE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[TOP_EDGE]);
|
|
}
|
|
/*
|
|
* Else the cell is below the edge.
|
|
* Move and shrink the cell and any abutting
|
|
* edges.
|
|
*/
|
|
else
|
|
{
|
|
#if 0
|
|
cell->y += diff;
|
|
cell->height -= diff;
|
|
#endif
|
|
lo_change_bottom_edges(context,
|
|
cell->side_edges[LEFT_EDGE],
|
|
(edge->y + edge->height - 1), diff, FALSE);
|
|
lo_change_bottom_edges(context,
|
|
cell->side_edges[RIGHT_EDGE],
|
|
(edge->y + edge->height - 1), diff, FALSE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[BOTTOM_EDGE]);
|
|
}
|
|
/*
|
|
* Only restructure cells that have windows(contexts)
|
|
*/
|
|
if (cell->context != NULL)
|
|
{
|
|
cell->needs_restructuring = TRUE;
|
|
}
|
|
}
|
|
edge->y = y;
|
|
edge->fe_edge->y = y;
|
|
}
|
|
/*
|
|
* Else for vertical edges.
|
|
*/
|
|
else
|
|
{
|
|
int32 diff;
|
|
|
|
diff = x - edge->x;
|
|
|
|
for (i=0; i < edge->cell_cnt; i++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
/*
|
|
* If the cell is left of the edge.
|
|
* Grow the cell and any abutting
|
|
* edges.
|
|
*/
|
|
if (cell->x < edge->x)
|
|
{
|
|
#if 0
|
|
cell->width += diff;
|
|
#endif
|
|
lo_change_left_edges(context,
|
|
cell->side_edges[TOP_EDGE],
|
|
edge->x, diff, FALSE);
|
|
lo_change_left_edges(context,
|
|
cell->side_edges[BOTTOM_EDGE],
|
|
edge->x, diff, FALSE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[LEFT_EDGE]);
|
|
}
|
|
/*
|
|
* Else the cell is right of the edge.
|
|
* Move and shrink the cell and any abutting
|
|
* edges.
|
|
*/
|
|
else
|
|
{
|
|
#if 0
|
|
cell->x += diff;
|
|
cell->width -= diff;
|
|
#endif
|
|
lo_change_right_edges(context,
|
|
cell->side_edges[TOP_EDGE],
|
|
(edge->x + edge->width - 1), diff, FALSE);
|
|
lo_change_right_edges(context,
|
|
cell->side_edges[BOTTOM_EDGE],
|
|
(edge->x + edge->width - 1), diff, FALSE);
|
|
/*
|
|
* The bounds of this edge are effected
|
|
*/
|
|
lo_set_edge_bounds(cell->side_edges[RIGHT_EDGE]);
|
|
}
|
|
/*
|
|
* Only restructure cells that have windows(contexts)
|
|
*/
|
|
if (cell->context != NULL)
|
|
{
|
|
cell->needs_restructuring = TRUE;
|
|
}
|
|
}
|
|
edge->x = x;
|
|
edge->fe_edge->x = x;
|
|
}
|
|
}
|
|
|
|
PRIVATE
|
|
void
|
|
lo_ReLayoutGridCells(MWContext *context,
|
|
int32 width, int32 height,
|
|
lo_GridRec *grid)
|
|
{
|
|
int32 orig_x, orig_y;
|
|
lo_GridCellRec *cell_list;
|
|
int32 new_cell_width, new_cell_height;
|
|
|
|
if (grid == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
cell_list = grid->cell_list;
|
|
|
|
orig_x = 0;
|
|
orig_y = 0;
|
|
while (cell_list != NULL)
|
|
{
|
|
|
|
if (cell_list->side_edges[TOP_EDGE])
|
|
{
|
|
cell_list->y = (cell_list->side_edges[TOP_EDGE]->y
|
|
+ grid->grid_cell_border * 2);
|
|
}
|
|
else
|
|
{
|
|
cell_list->y = 0;
|
|
}
|
|
|
|
if (cell_list->side_edges[LEFT_EDGE])
|
|
{
|
|
cell_list->x = (cell_list->side_edges[LEFT_EDGE]->x
|
|
+ grid->grid_cell_border * 2);
|
|
}
|
|
else
|
|
{
|
|
cell_list->x = 0;
|
|
}
|
|
|
|
if (cell_list->has_percent_width)
|
|
{
|
|
new_cell_width = width * (float)cell_list->width_percent / 100.0;
|
|
|
|
if (new_cell_width < grid->grid_cell_min_dim)
|
|
{
|
|
new_cell_width = grid->grid_cell_min_dim;
|
|
}
|
|
|
|
if (cell_list->side_edges[LEFT_EDGE])
|
|
{
|
|
new_cell_width -= grid->grid_cell_border;
|
|
}
|
|
if (cell_list->side_edges[RIGHT_EDGE])
|
|
{
|
|
new_cell_width -= grid->grid_cell_border;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Make sure the last column uses all the remaining space.
|
|
* We subtract orig_x to get cell_list->x into the same coord
|
|
* space as width.
|
|
*/
|
|
new_cell_width = width - (cell_list->x - orig_x);
|
|
}
|
|
}
|
|
else
|
|
new_cell_width = cell_list->width;
|
|
|
|
if (cell_list->has_percent_height)
|
|
{
|
|
new_cell_height = height * (float)cell_list->height_percent / 100.0;
|
|
|
|
if (new_cell_height < grid->grid_cell_min_dim)
|
|
{
|
|
new_cell_height = grid->grid_cell_min_dim;
|
|
}
|
|
if (cell_list->side_edges[TOP_EDGE])
|
|
{
|
|
new_cell_height -= grid->grid_cell_border;
|
|
}
|
|
if (cell_list->side_edges[BOTTOM_EDGE])
|
|
{
|
|
new_cell_height -= grid->grid_cell_border;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Make sure the last row uses all the remaining space.
|
|
* We subtract orig_y to get cell_list->y into the same coord
|
|
* space as height.
|
|
*/
|
|
new_cell_height = height - (cell_list->y - orig_y);
|
|
}
|
|
}
|
|
else
|
|
new_cell_height = cell_list->height;
|
|
|
|
cell_list->width = new_cell_width;
|
|
cell_list->height = new_cell_height;
|
|
|
|
if (cell_list->side_edges[RIGHT_EDGE])
|
|
{
|
|
if (cell_list->side_edges[RIGHT_EDGE]->dealt_with_in_relayout == FALSE)
|
|
{
|
|
lo_MoveGridEdgeForRelayout(context,
|
|
cell_list->side_edges[RIGHT_EDGE]->fe_edge,
|
|
cell_list->x + cell_list->width,
|
|
cell_list->side_edges[RIGHT_EDGE]->y);
|
|
cell_list->side_edges[RIGHT_EDGE]->dealt_with_in_relayout = TRUE;
|
|
}
|
|
}
|
|
|
|
if (cell_list->side_edges[BOTTOM_EDGE])
|
|
{
|
|
if (cell_list->side_edges[BOTTOM_EDGE]->dealt_with_in_relayout == FALSE)
|
|
{
|
|
lo_MoveGridEdgeForRelayout(context,
|
|
cell_list->side_edges[BOTTOM_EDGE]->fe_edge,
|
|
cell_list->side_edges[BOTTOM_EDGE]->x,
|
|
cell_list->y + cell_list->height);
|
|
cell_list->side_edges[BOTTOM_EDGE]->dealt_with_in_relayout = TRUE;
|
|
}
|
|
}
|
|
|
|
cell_list = cell_list->next;
|
|
}
|
|
}
|
|
|
|
static void
|
|
lo_PrepareGridForRelayout(MWContext *context,
|
|
lo_GridRec *grid)
|
|
{
|
|
lo_GridEdge *edge_list;
|
|
lo_GridCellRec *cell_list;
|
|
|
|
cell_list = grid->cell_list;
|
|
while(cell_list)
|
|
{
|
|
cell_list->needs_restructuring = FALSE;
|
|
cell_list = cell_list->next;
|
|
}
|
|
|
|
edge_list = grid->edge_list;
|
|
while (edge_list != NULL)
|
|
{
|
|
/* FE_HideEdge(context, FE_VIEW, edge_list->fe_edge);*/
|
|
edge_list->dealt_with_in_relayout = FALSE;
|
|
edge_list = edge_list->next;
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
lo_ResyncEdgeSizes(MWContext *context,
|
|
lo_GridRec *grid)
|
|
{
|
|
lo_GridEdge *edge_list;
|
|
|
|
edge_list = grid->edge_list;
|
|
while (edge_list != NULL)
|
|
{
|
|
int i;
|
|
|
|
lo_set_edge_bounds(edge_list);
|
|
|
|
if (edge_list->is_vertical == FALSE) /* horizontal edge */
|
|
{
|
|
int32 width = 0;
|
|
for (i = 0; i < edge_list->cell_cnt; i ++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge_list->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (cell->x + cell->width > edge_list->x + width)
|
|
width = cell->x + cell->width - edge_list->x;
|
|
}
|
|
|
|
edge_list->width = width;
|
|
edge_list->fe_edge->width = width;
|
|
}
|
|
else /* vertical edge */
|
|
{
|
|
int32 height = 0;
|
|
for (i = 0; i < edge_list->cell_cnt; i ++)
|
|
{
|
|
lo_GridCellRec *cell;
|
|
|
|
cell = edge_list->cell_array[i];
|
|
if (cell == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (cell->y + cell->height > edge_list->y + height)
|
|
height = cell->y + cell->height - edge_list->y;
|
|
}
|
|
|
|
edge_list->height = height;
|
|
edge_list->fe_edge->height = height;
|
|
}
|
|
|
|
lo_DisplayEdge(context, edge_list->fe_edge);
|
|
|
|
edge_list = edge_list->next;
|
|
}
|
|
}
|
|
|
|
static void
|
|
lo_RestructureCells(MWContext *context,
|
|
lo_GridRec *grid)
|
|
{
|
|
lo_GridCellRec *cell_list;
|
|
cell_list = grid->cell_list;
|
|
while(cell_list)
|
|
{
|
|
if (cell_list->needs_restructuring &&
|
|
cell_list->context != NULL)
|
|
{
|
|
FE_RestructureGridWindow (cell_list->context,
|
|
cell_list->x, cell_list->y,
|
|
cell_list->width, cell_list->height);
|
|
}
|
|
|
|
cell_list = cell_list->next;
|
|
}
|
|
}
|
|
|
|
void
|
|
lo_RelayoutGridDocumentOnResize(MWContext *context,
|
|
lo_TopState *top_state,
|
|
int32 width, int32 height)
|
|
{
|
|
lo_GridRec *grid = top_state->the_grid;
|
|
|
|
lo_PrepareGridForRelayout(context, grid);
|
|
|
|
lo_ReLayoutGridCells(context, width, height, grid);
|
|
|
|
lo_RestructureCells(context, grid);
|
|
|
|
lo_ResyncEdgeSizes(context, grid);
|
|
}
|
|
|