Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-05 00:25:27 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
0ae8092bff
gecko-dev/lib/layout/laycell.c
cyeh%netscape.com 79abd7d8a7 Remove old MOCHA #ifdefs
1998-09-29 20:55:21 +00:00

1120 lines
25 KiB
C
Raw Blame History

/* -*- 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 "pa_parse.h"
#include "layout.h"
#include "laylayer.h"
#include "layers.h"
#ifdef PROFILE
#pragma profile on
#endif
#ifdef TEST_16BIT
#define XP_WIN16
#endif /* TEST_16BIT */
void
lo_DisplayCellContents(MWContext *context, LO_CellStruct *cell,
int32 base_x, int32 base_y,
int32 x, int32 y,
uint32 width, uint32 height)
{
LO_Element *eptr;
eptr = cell->cell_list;
while (eptr)
{
lo_DisplayElement(context, eptr, base_x, base_y, x, y, width, height);
eptr = eptr->lo_any.next;
}
eptr = cell->cell_float_list;
while (eptr)
{
lo_DisplayElement(context, eptr, base_x, base_y, x, y, width, height);
eptr = eptr->lo_any.next;
}
}
PRIVATE
LO_Element *
lo_search_element_list(MWContext *context, LO_Element *eptr, int32 x, int32 y)
{
while (eptr != NULL)
{
int32 width, height;
width = eptr->lo_any.width;
/*
* Images need to account for border width
*/
if (eptr->type == LO_IMAGE)
{
width = width + (2 * eptr->lo_image.border_width);
}
if (width <= 0)
{
width = 1;
}
height = eptr->lo_any.height;
/*
* Images need to account for border width
*/
if (eptr->type == LO_IMAGE)
{
height = height + (2 * eptr->lo_image.border_width);
}
if ((y < (eptr->lo_any.y + eptr->lo_any.y_offset + height))&&
(y >= eptr->lo_any.y))
{
if ((x < (eptr->lo_any.x + eptr->lo_any.x_offset +
width))&&(x >= eptr->lo_any.x))
{
/*
* Don't stop on tables, they are containers
* we must look inside of.
*/
if (eptr->type != LO_TABLE)
{
break;
}
}
}
eptr = eptr->lo_any.next;
}
return(eptr);
}
int32
lo_GetCellBaseline(LO_CellStruct *cell)
{
LO_Element *eptr;
if (cell == NULL)
{
return(0);
}
/*
* Make eptr point to the start of the element chain
* for this subdoc.
*/
if (cell->cell_list == NULL)
{
return(0);
}
eptr = cell->cell_list;
while (eptr != NULL)
{
if (eptr->type == LO_LINEFEED)
{
break;
}
eptr = eptr->lo_any.next;
}
if (eptr == NULL)
{
return(0);
}
return(eptr->lo_linefeed.baseline);
}
LO_Element *
lo_XYToCellElement(MWContext *context, lo_DocState *state,
LO_CellStruct *cell, int32 x, int32 y,
Bool check_float, Bool into_cells, Bool into_ilayers)
{
LO_Element *eptr;
LO_Element *element;
eptr = cell->cell_list;
element = lo_search_element_list(context, eptr, x, y);
if ((element == NULL)&&(check_float != FALSE))
{
eptr = cell->cell_float_list;
element = lo_search_element_list(context, eptr, x, y);
}
if ((element != NULL)&&(element->type == LO_SUBDOC))
{
LO_SubDocStruct *subdoc;
int32 new_x, new_y;
int32 ret_new_x, ret_new_y;
subdoc = (LO_SubDocStruct *)element;
new_x = x - (subdoc->x + subdoc->x_offset +
subdoc->border_width);
new_y = y - (subdoc->y + subdoc->y_offset +
subdoc->border_width);
element = lo_XYToDocumentElement(context,
(lo_DocState *)subdoc->state, new_x, new_y,
check_float, into_cells, into_ilayers,
&ret_new_x, &ret_new_y);
x = ret_new_x;
y = ret_new_y;
}
else if ((element != NULL)&&(element->type == LO_CELL)&&
(into_cells != FALSE))
{
if (!element->lo_cell.cell_inflow_layer || into_ilayers)
element = lo_XYToCellElement(context, state,
(LO_CellStruct *)element, x, y,
check_float, into_cells, into_ilayers);
}
return(element);
}
LO_Element *
lo_XYToNearestCellElement(MWContext *context, lo_DocState *state,
LO_CellStruct *cell, int32 x, int32 y)
{
LO_Element *eptr, *eptrsave;
int32 x2;
/* int32 ysave; */
eptr = lo_XYToCellElement(context, state, cell, x, y, TRUE, TRUE, TRUE);
eptrsave = NULL;
/*
* If no exact hit, find nearest in Y (and then X) overlap.
*/
if (eptr == NULL)
{
eptr = cell->cell_list;
while (eptr != NULL)
{
int32 y2;
/*
* Skip tables, we just walk into them.
*/
if (eptr->type == LO_TABLE)
{
eptr = eptr->lo_any.next;
continue;
}
y2 = eptr->lo_any.y + eptr->lo_any.y_offset +
eptr->lo_any.height;
/*
* Images and cells need to account for border width
*/
if (eptr->type == LO_IMAGE)
{
y2 = y2 + (2 * eptr->lo_image.border_width);
}
else if (eptr->type == LO_CELL)
{
y2 = y2 + (2 * eptr->lo_cell.border_width);
}
/*
* If we've already found something that's greater in y,
* let's look for something that's closer in x.
*/
if (eptrsave)
{
/*
* If the current y is larger than that of the saved element
* we'll just take the saved element.
*/
/* if (y2 > ysave)
break; */
eptrsave = eptr;
/* ysave = y2; */
/* Calculate the x extent of the element */
x2 = eptr->lo_any.x + eptr->lo_any.x_offset +
eptr->lo_any.width;
if (eptr->type == LO_IMAGE)
x2 = x2 + (2 * eptr->lo_image.border_width);
else if (eptr->type == LO_CELL)
x2 = x2 + (2 * eptr->lo_cell.border_width);
/*
* If we've gone too far in x, we'll take the currently
* saved element.
*/
if (x <= x2)
break;
}
else if (y <= y2)
{
/*
* This is the first element that's greater in y, so
* save it and look out for others that are closer in
* x, but identical in y.
*/
eptrsave = eptr;
/* ysave = y2; */
/* Calculate the x extent of the element */
x2 = eptr->lo_any.x + eptr->lo_any.x_offset +
eptr->lo_any.width;
if (eptr->type == LO_IMAGE)
x2 = x2 + (2 * eptr->lo_image.border_width);
else if (eptr->type == LO_CELL)
x2 = x2 + (2 * eptr->lo_cell.border_width);
/*
* If we've gone too far in x, we'll take the currently
* saved element.
*/
if (x <= x2)
break;
}
eptr = eptr->lo_any.next;
}
eptr = eptrsave;
/*
* If nothing overlaps y, match the last element in the cell.
*/
if (eptr == NULL)
{
eptr = cell->cell_list_end;
}
/*
* If we matched on a cell, recurse into it.
*/
if ((eptr != NULL)&&(eptr->type == LO_CELL))
{
eptr = lo_XYToNearestCellElement(context, state,
(LO_CellStruct *)eptr, x, y);
}
}
return(eptr);
}
static void lo_MoveElementLayers( LO_Element *eptr )
{
if (eptr->type == LO_IMAGE)
{
CL_MoveLayer(eptr->lo_image.layer,
eptr->lo_any.x + eptr->lo_any.x_offset + eptr->lo_image.border_width,
eptr->lo_any.y + eptr->lo_any.y_offset + eptr->lo_image.border_width);
}
else if (eptr->type == LO_EMBED)
{
CL_MoveLayer(eptr->lo_embed.objTag.layer,
eptr->lo_any.x + eptr->lo_any.x_offset + eptr->lo_embed.objTag.border_width,
eptr->lo_any.y + eptr->lo_any.y_offset + eptr->lo_embed.objTag.border_width);
}
#ifdef JAVA
else if (eptr->type == LO_JAVA)
{
CL_MoveLayer(eptr->lo_java.objTag.layer,
eptr->lo_any.x + eptr->lo_any.x_offset + eptr->lo_java.objTag.border_width,
eptr->lo_any.y + eptr->lo_any.y_offset + eptr->lo_java.objTag.border_width);
}
#endif
else if (eptr->type == LO_FORM_ELE)
{
CL_MoveLayer(eptr->lo_form.layer,
eptr->lo_any.x + eptr->lo_any.x_offset + eptr->lo_form.border_horiz_space,
eptr->lo_any.y + eptr->lo_any.y_offset + eptr->lo_form.border_vert_space);
}
}
void
lo_ShiftCell(LO_CellStruct *cell, int32 dx, int32 dy)
{
LO_Element *eptr;
if (cell == NULL)
{
return;
}
if (cell->cell_bg_layer) {
int32 x_offset, y_offset;
lo_GetLayerXYShift(CL_GetLayerParent(cell->cell_bg_layer),
&x_offset, &y_offset);
CL_MoveLayer(cell->cell_bg_layer,
cell->x - x_offset, cell->y - y_offset);
CL_ResizeLayer(cell->cell_bg_layer, cell->width, cell->height);
}
if (cell->cell_inflow_layer)
lo_OffsetInflowLayer(cell->cell_inflow_layer, dx, dy);
eptr = cell->cell_list;
while (eptr != NULL)
{
eptr->lo_any.x += dx;
eptr->lo_any.y += dy;
if (eptr->type == LO_CELL)
{
/*
* This would cause an infinite loop.
*/
if ((LO_CellStruct *)eptr == cell)
{
XP_ASSERT(FALSE);
break;
}
lo_ShiftCell((LO_CellStruct *)eptr, dx, dy);
}
lo_MoveElementLayers( eptr );
eptr = eptr->lo_any.next;
}
eptr = cell->cell_float_list;
while (eptr != NULL)
{
eptr->lo_any.x += dx;
eptr->lo_any.y += dy;
if (eptr->type == LO_CELL)
{
lo_ShiftCell((LO_CellStruct *)eptr, dx, dy);
}
lo_MoveElementLayers( eptr );
eptr = eptr->lo_any.next;
}
}
static void
lo_recolor_backgrounds(lo_DocState *state, LO_CellStruct *cell,
LO_Element *eptr)
{
LO_TextAttr *old_attr;
LO_TextAttr *attr;
LO_TextAttr tmp_attr;
if (cell->backdrop.bg_color == NULL)
{
return;
}
attr = NULL;
old_attr = NULL;
if (eptr->type == LO_TEXT)
{
old_attr = eptr->lo_text.text_attr;
}
else if (eptr->type == LO_LINEFEED)
{
old_attr = eptr->lo_linefeed.text_attr;
}
else if (eptr->type == LO_IMAGE)
{
old_attr = eptr->lo_image.text_attr;
}
else if (eptr->type == LO_FORM_ELE)
{
old_attr = eptr->lo_form.text_attr;
}
if (old_attr != NULL)
{
lo_CopyTextAttr(old_attr, &tmp_attr);
/* don't recolor the background if it was
* explicitly set to another color
*/
if(tmp_attr.no_background == TRUE)
tmp_attr.bg = *cell->backdrop.bg_color;
/* removed by Lou 4-3-97 to allow overlapping
* text in tables to work right. Windows
* never before payed attention to this attr
* so I'm guessing that it won't break anything :)
*/
/* tmp_attr.no_background = FALSE; */
attr = lo_FetchTextAttr(state, &tmp_attr);
}
if (eptr->type == LO_TEXT)
{
eptr->lo_text.text_attr = attr;
}
else if (eptr->type == LO_LINEFEED)
{
eptr->lo_linefeed.text_attr = attr;
}
else if (eptr->type == LO_IMAGE)
{
eptr->lo_image.text_attr = attr;
}
else if (eptr->type == LO_FORM_ELE)
{
eptr->lo_form.text_attr = attr;
}
}
/*
* In addition to renumbering the cell, we now
* also make sure that text in cell with a bg_color
* have their text_attr->bg set correctly.
*/
void
lo_RenumberCell(lo_DocState *state, LO_CellStruct *cell)
{
LO_Element *eptr;
if (cell == NULL)
{
return;
}
eptr = cell->cell_list;
while (eptr != NULL)
{
/* Keep element IDs in order */
eptr->lo_any.ele_id = NEXT_ELEMENT;
/*
* If the display is blocked for an element
* we havn't reached yet, check to see if
* this element is it, and if so, save its
* y position.
*/
if ((state->display_blocked != FALSE)&&
(state->is_a_subdoc == SUBDOC_NOT)&&
(state->display_blocking_element_y == 0)&&
(state->display_blocking_element_id != -1)&&
(eptr->lo_any.ele_id >=
state->display_blocking_element_id))
{
state->display_blocking_element_y = eptr->lo_any.y;
}
/*
* If this is a cell with a BGCOLOR attribute, pass
* that color on to the bg of all text in this cell.
*/
if ((cell->backdrop.bg_color != NULL)&&((eptr->type == LO_TEXT)||
(eptr->type == LO_LINEFEED)||(eptr->type == LO_IMAGE)||
(eptr->type == LO_FORM_ELE)))
{
lo_recolor_backgrounds(state, cell, eptr);
}
if (eptr->type == LO_CELL)
{
lo_RenumberCell(state, (LO_CellStruct *)eptr);
}
eptr = eptr->lo_any.next;
}
eptr = cell->cell_float_list;
while (eptr != NULL)
{
/* Keep element IDs in order */
eptr->lo_any.ele_id = NEXT_ELEMENT;
/*
* If the display is blocked for an element
* we havn't reached yet, check to see if
* this element is it, and if so, save its
* y position.
*/
if ((state->display_blocked != FALSE)&&
(state->is_a_subdoc == SUBDOC_NOT)&&
(state->display_blocking_element_y == 0)&&
(state->display_blocking_element_id != -1)&&
(eptr->lo_any.ele_id >=
state->display_blocking_element_id))
{
state->display_blocking_element_y = eptr->lo_any.y;
}
/*
* If this is a cell with a BGCOLOR attribute, pass
* that color on to the bg of all text in this cell.
*/
if ((cell->backdrop.bg_color != NULL)&&((eptr->type == LO_TEXT)||
(eptr->type == LO_LINEFEED)||(eptr->type == LO_IMAGE)||
(eptr->type == LO_FORM_ELE)))
{
lo_recolor_backgrounds(state, cell, eptr);
}
if (eptr->type == LO_CELL)
{
lo_RenumberCell(state, (LO_CellStruct *)eptr);
}
eptr = eptr->lo_any.next;
}
}
static void
lo_free_subdoc_state(MWContext *context, lo_DocState *parent_state,
lo_DocState *state, Bool free_all)
{
LO_Element **line_array;
if (state == NULL)
{
return;
}
/*
* If this subdoc is not nested inside another subdoc,
* free any re-parse tags stored on this subdoc.
*/
if ((state->subdoc_tags != NULL)&&
(parent_state->is_a_subdoc != SUBDOC_CELL)&&
(parent_state->is_a_subdoc != SUBDOC_CAPTION))
{
PA_Tag *tptr;
PA_Tag *tag;
tptr = state->subdoc_tags;
while ((tptr != state->subdoc_tags_end)&&(tptr != NULL))
{
tag = tptr;
tptr = tptr->next;
tag->next = NULL;
PA_FreeTag(tag);
}
if (tptr != NULL)
{
tptr->next = NULL;
PA_FreeTag(tptr);
}
state->subdoc_tags = NULL;
state->subdoc_tags_end = NULL;
}
if (state->left_margin_stack != NULL)
{
lo_MarginStack *mptr;
lo_MarginStack *margin;
mptr = state->left_margin_stack;
while (mptr != NULL)
{
margin = mptr;
mptr = mptr->next;
XP_DELETE(margin);
}
state->left_margin_stack = NULL;
}
if (state->right_margin_stack != NULL)
{
lo_MarginStack *mptr;
lo_MarginStack *margin;
mptr = state->right_margin_stack;
while (mptr != NULL)
{
margin = mptr;
mptr = mptr->next;
XP_DELETE(margin);
}
state->right_margin_stack = NULL;
}
if (state->line_list != NULL)
{
lo_FreeElementList(context, state->line_list);
state->line_list = NULL;
}
if (state->font_stack != NULL)
{
lo_FontStack *fstack;
lo_FontStack *fptr;
fptr = state->font_stack;
while (fptr != NULL)
{
fstack = fptr;
fptr = fptr->next;
XP_DELETE(fstack);
}
state->font_stack = NULL;
}
if (state->align_stack != NULL)
{
lo_AlignStack *aptr;
lo_AlignStack *align;
aptr = state->align_stack;
while (aptr != NULL)
{
align = aptr;
aptr = aptr->next;
XP_DELETE(align);
}
state->align_stack = NULL;
}
if (state->list_stack != NULL)
{
lo_ListStack *lptr;
lo_ListStack *list;
lptr = state->list_stack;
while (lptr != NULL)
{
list = lptr;
lptr = lptr->next;
XP_DELETE(list);
}
state->list_stack = NULL;
}
if (state->line_buf != NULL)
{
PA_FREE(state->line_buf);
state->line_buf = NULL;
}
if (state->float_list != NULL)
{
/*
* Don't free these, they are squished into the cell.
* Only free them if this is a free_all.
*/
if (free_all != FALSE)
{
lo_FreeElementList(context, state->float_list);
}
state->float_list = NULL;
}
if (state->line_array != NULL)
{
LO_Element *eptr;
#ifdef XP_WIN16
{
XP_Block *larray_array;
intn cnt;
XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array);
cnt = state->larray_array_size - 1;
while (cnt > 0)
{
XP_FREE_BLOCK(larray_array[cnt]);
cnt--;
}
state->line_array = larray_array[0];
XP_UNLOCK_BLOCK(state->larray_array);
XP_FREE_BLOCK(state->larray_array);
}
#endif /* XP_WIN16 */
eptr = NULL;
XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
eptr = line_array[0];
if (eptr != NULL)
{
/*
* Don't free these, they are squished into the cell.
* Only free them if this is a free_all.
*/
if (free_all != FALSE)
{
lo_FreeElementList(context, eptr);
}
}
XP_UNLOCK_BLOCK(state->line_array);
XP_FREE_BLOCK(state->line_array);
}
XP_DELETE(state);
}
void
lo_FreePartialSubDoc(MWContext *context, lo_DocState *state,
LO_SubDocStruct *subdoc)
{
lo_DocState *subdoc_state;
if (subdoc == NULL)
{
return;
}
subdoc_state = (lo_DocState *)subdoc->state;
if (subdoc_state != NULL)
{
lo_free_subdoc_state(context, state, subdoc_state, TRUE);
}
subdoc->state = NULL;
lo_FreeElement(context, (LO_Element *)subdoc, TRUE);
}
void
lo_FreePartialCell(MWContext *context, lo_DocState *state,
LO_CellStruct *cell)
{
if (cell == NULL)
{
return;
}
lo_FreeElement(context, (LO_Element *)cell, TRUE);
}
LO_CellStruct *
lo_SmallSquishSubDocToCell(MWContext *context, lo_DocState *state,
LO_SubDocStruct *subdoc, int32 *ptr_dx, int32 *ptr_dy)
{
LO_CellStruct *cell;
/* lo_DocState *subdoc_state; */
if (subdoc == NULL)
{
return(NULL);
}
cell = (LO_CellStruct *)lo_NewElement(context, state, LO_CELL, NULL, 0);
cell->isCaption = FALSE;
cell->cell_bg_layer = NULL;
cell->cell_inflow_layer = NULL;
lo_CreateCellFromSubDoc (context, state, subdoc, cell, ptr_dx, ptr_dy );
return(cell);
}
/* This is only called when creating a LO_CELL layout element for a
<CAPTION>. */
LO_CellStruct *
lo_SquishSubDocToCell(MWContext *context, lo_DocState *state,
LO_SubDocStruct *subdoc, Bool free_subdoc)
{
LO_CellStruct *cell;
int32 dx, dy;
dx = 0;
dy = 0;
cell = lo_SmallSquishSubDocToCell(context, state, subdoc, &dx, &dy);
/* Fix for bug# 301664. Need to initialize the LO_CELL element's pointers
to table state to NULL becase this LO_CELL element is being used for
holding the contents of a <CAPTION> tag and does not have a peer lo_TableCell
structure to point to. If we don't do this, then during freeing of this table,
the dangling pointers to table state will be dereferenced in an attempt to free
the peer lo_TableCell structure. */
cell->table_cell = NULL;
cell->table_row = NULL;
cell->table = NULL;
if (cell == NULL)
{
return(NULL);
}
lo_ShiftCell(cell, dx, dy);
lo_RenumberCell(state, cell);
if ((subdoc->state != NULL)&&(free_subdoc != FALSE))
{
lo_DocState *subdoc_state;
subdoc_state = (lo_DocState *)subdoc->state;
lo_free_subdoc_state(context, state, subdoc_state, FALSE);
subdoc->state = NULL;
}
if (free_subdoc != FALSE)
{
lo_FreeElement(context, (LO_Element *)subdoc, free_subdoc);
}
return(cell);
}
/* Used during layout and relayout and called from lo_SmallSquishSubdocToCell() */
void lo_CreateCellFromSubDoc( MWContext *context, lo_DocState *state,
LO_SubDocStruct *subdoc, LO_CellStruct *cell, int32 *ptr_dx, int32 *ptr_dy )
{
lo_DocState *subdoc_state;
/* Fix this later */
if (subdoc == NULL)
{
return;
}
*ptr_dx = 0;
*ptr_dy = 0;
/* Fix this later */
if (cell == NULL)
{
return;
}
cell->type = LO_CELL;
cell->ele_id = NEXT_ELEMENT;
cell->x = subdoc->x;
cell->x_offset = subdoc->x_offset;
cell->y = subdoc->y;
cell->y_offset = subdoc->y_offset;
cell->width = subdoc->width;
cell->height = subdoc->height;
cell->next = subdoc->next;
cell->prev = subdoc->prev;
cell->FE_Data = subdoc->FE_Data;
cell->backdrop = subdoc->backdrop;
/*
* Clear out the bg_color struct from the subdocs so it doesn't
* get freed twice.
*/
subdoc->backdrop.bg_color = NULL;
subdoc->backdrop.url = NULL;
cell->border_width = subdoc->border_width;
cell->border_vert_space = subdoc->border_vert_space;
cell->border_horiz_space = subdoc->border_horiz_space;
cell->ele_attrmask = 0;
cell->ele_attrmask |= (subdoc->ele_attrmask & LO_ELE_SECURE);
cell->ele_attrmask |= (subdoc->ele_attrmask & LO_ELE_SELECTED);
cell->sel_start = subdoc->sel_start;
cell->sel_end = subdoc->sel_end;
cell->cell_list = NULL;
cell->cell_list_end = NULL;
cell->cell_float_list = NULL;
subdoc_state = (lo_DocState *)subdoc->state;
if (subdoc_state != NULL)
{
LO_Element **line_array;
LO_Element *eptr;
int32 base_x, base_y;
/*
* Make eptr point to the start of the element chain
* for this subdoc.
*/
#ifdef XP_WIN16
{
XP_Block *larray_array;
XP_LOCK_BLOCK(larray_array, XP_Block *,
subdoc_state->larray_array);
subdoc_state->line_array = larray_array[0];
XP_UNLOCK_BLOCK(subdoc_state->larray_array);
}
#endif /* XP_WIN16 */
XP_LOCK_BLOCK(line_array, LO_Element **,
subdoc_state->line_array);
eptr = line_array[0];
XP_UNLOCK_BLOCK(subdoc_state->line_array);
cell->cell_list = eptr;
base_x = subdoc->x + subdoc->x_offset + subdoc->border_width;
base_y = subdoc->y + subdoc->y_offset + subdoc->border_width;
cell->cell_list_end = subdoc_state->end_last_line;
if (cell->cell_list_end == NULL)
{
cell->cell_list_end = cell->cell_list;
}
cell->cell_float_list = subdoc_state->float_list;
*ptr_dx = base_x;
*ptr_dy = base_y;
/*
* MOCHA needs to reuse mocha objects allocated in the namelist
* when a cell is relaid out. This means we must always squish
* back up to the top level state, instead of propogating up
* like we used to.
*/
lo_AddNameList(state->top_state->doc_state, subdoc_state);
}
}
/*
** New functions used by the editor to improve the performance of typing in tables
**/
/* Creates and returns a new lo_DocState for an existing LO_CELL layout element to get
relaid out on. Sets the dimensions of the lo_DocState structure to those
of the LO_CELL element. */
lo_DocState * lo_CreateStateForCellLayout(MWContext *context, LO_CellStruct *cell)
{
lo_DocState *new_doc = NULL;
if (context && cell)
{
new_doc = lo_NewLayout( context, cell->width, cell->height, 0, 0, NULL );
}
return new_doc;
}
/* This function is identical to lo_ShiftCell() except that it does not move
the cell's layers */
static void
lo_OffsetCellContents(LO_CellStruct *cell, int32 dx, int32 dy)
{
LO_Element *eptr;
if (cell == NULL)
return;
eptr = cell->cell_list;
while (eptr != NULL)
{
eptr->lo_any.x += dx;
eptr->lo_any.y += dy;
if (eptr->type == LO_CELL)
{
/*
* This would cause an infinite loop.
*/
if ((LO_CellStruct *)eptr == cell)
{
XP_ASSERT(FALSE);
break;
}
lo_OffsetCellContents((LO_CellStruct *)eptr, dx, dy);
}
lo_MoveElementLayers( eptr );
eptr = eptr->lo_any.next;
}
eptr = cell->cell_float_list;
while (eptr != NULL)
{
eptr->lo_any.x += dx;
eptr->lo_any.y += dy;
if (eptr->type == LO_CELL)
{
lo_OffsetCellContents((LO_CellStruct *)eptr, dx, dy);
}
lo_MoveElementLayers( eptr );
eptr = eptr->lo_any.next;
}
}
/* Populates the LO_CELL element with the freshly generated contents of the
lo_DocState structure. Assumes that the layout elements on the lo_DocState
are hooked up to their peer editor elements in the editor content model.
Recycles the old layout elements contained in the LO_CELL element. */
void lo_RebuildCell(MWContext *context, lo_DocState *state, LO_CellStruct *cell)
{
/*** Recycle old contents of the cell ***/
if (!cell)
return;
/* If cell list exists, cell_list_end must exist too */
XP_ASSERT((cell->cell_list && cell->cell_list_end) ||
(!cell->cell_list && !cell->cell_list_end));
if (cell->cell_list && cell->cell_list_end)
{
XP_ASSERT(cell->cell_list_end->lo_any.next == NULL);
lo_RecycleElements(context, state, cell->cell_list);
}
if (cell->cell_float_list)
lo_RecycleElements(context, state, cell->cell_float_list);
cell->cell_list = NULL;
cell->cell_float_list = NULL;
cell->cell_list_end = NULL;
/*** Copy pointers to new content from the doc state to the cell ***/
/* If line array exists, end_last_line must exist too */
XP_ASSERT((state->line_array[0] && state->end_last_line) ||
(!state->line_array[0] && !state->end_last_line));
/* Ensure that the line list on the doc state has been flushed to
the line array */
XP_ASSERT(state->line_list == NULL);
if (state->line_array[0] && state->end_last_line)
{
XP_ASSERT(state->end_last_line->lo_any.next == NULL);
cell->cell_list = ((LO_Element**)state->line_array)[0];
cell->cell_list_end = state->end_last_line;
state->line_array[0] = NULL;
state->end_last_line = NULL;
}
if (state->float_list)
{
cell->cell_float_list = state->float_list;
state->float_list = NULL;
}
/*** Offset new content of the cell relative to the cell's position ***/
lo_OffsetCellContents( cell, cell->x, cell->y );
}
#ifdef TEST_16BIT
#undef XP_WIN16
#endif /* TEST_16BIT */
#ifdef PROFILE
#pragma profile off
#endif
Reference in New Issue View Git Blame Copy Permalink