/* -*- 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 "np.h"
#include "laystyle.h"
#include "edt.h"

#ifdef TEST_16BIT
#define XP_WIN16
#endif /* TEST_16BIT */


#define	TABLE_BORDERS_ON		1
#define	TABLE_BORDERS_OFF		0
#define	TABLE_BORDERS_GONE		-1

#define	TABLE_DEF_INNER_CELL_PAD	1
#define	TABLE_DEF_INTER_CELL_PAD	2
#define	TABLE_DEF_CELL_BORDER		1

#define	TABLE_DEF_BORDER		0
#define TABLE_DEF_BORDER_STYLE		BORDER_SOLID
#define	TABLE_DEF_VERTICAL_SPACE	0
#define	TABLE_DEF_HORIZONTAL_SPACE	0

#define	TABLE_MAX_COLSPAN		1000
#define	TABLE_MAX_ROWSPAN		10000

typedef struct lo_cell_data_struct {
#ifdef XP_WIN16
	/*
	 * This struct must be a power of 2 if we are going to allocate an
	 * array of more than 128K
	 */
	unsigned width, height;
#else
	int32 width, height;
#endif
	lo_TableCell *cell;
} lo_cell_data;


LO_SubDocStruct *
	lo_EndCellSubDoc(MWContext *context, lo_DocState *state, lo_DocState *old_state,
		LO_Element *element, Bool relayout);
LO_SubDocStruct *
	lo_RelayoutCaptionSubdoc(MWContext *context, lo_DocState *state, lo_TableCaption *caption,
		LO_SubDocStruct *subdoc, int32 width, Bool is_a_header);
LO_CellStruct *
lo_RelayoutCell(MWContext *context, lo_DocState *state,
	LO_SubDocStruct *subdoc, lo_TableCell *cell_ptr,
	LO_CellStruct *cell, int32 width, Bool is_a_header,
	Bool relayout);
void
	lo_BeginCaptionSubDoc(MWContext *context, lo_DocState *state,
		lo_TableCaption *caption, PA_Tag *tag);
void
	lo_BeginCellSubDoc(MWContext *context, 
 					lo_DocState *state,
 					lo_TableRec *table,
 					char *bgcolor_attr,
 					char *background_attr,
                    lo_TileMode tile_mode,
 					char *valign_attr,
 					char *halign_attr,
 					char *width_attr,
 					char *height_attr,
 					Bool is_a_header, 
 					intn draw_borders,
					Bool relayout);
Bool
	lo_subdoc_has_elements(lo_DocState *sub_state);
Bool
	lo_cell_has_elements(LO_CellStruct *cell);
int32
	lo_align_subdoc(MWContext *context, lo_DocState *state, lo_DocState *old_state,
		LO_SubDocStruct *subdoc, lo_TableRec *table, lo_table_span *row_max);
int32
	lo_align_cell(MWContext *context, lo_DocState *state, lo_TableCell *cell_ptr,
		LO_CellStruct *cell, lo_TableRec *table, lo_table_span *row_max);

void
	lo_RelayoutTags(MWContext *context, lo_DocState *state, PA_Tag * tag_ptr,
		PA_Tag * tag_end_ptr, LO_Element * elem_list);
	
PA_Tag *
	lo_FindReuseableElement(MWContext *context, lo_DocState *state,
		LO_Element ** elem_list);

static void
lo_reuse_current_state(MWContext *context, lo_DocState *state,
	int32 width, int32 height, int32 margin_width, int32 margin_height,
	Bool destroyLineLists);
/*
 ********************************************************************************
 * Some Helper Functions
 */
 
static int32 lo_CalculateCellPercentWidth( lo_TableRec *table, int32 percent);
static int32 lo_CalculateCellPercentHeight( lo_TableRec *table, lo_TableCell *table_cell);

static int32
	lo_ComputeCellEmptySpace(MWContext *context,lo_TableRec *table,
		LO_SubDocStruct *subdoc);
static int32
	lo_FindDefaultCellWidth(MWContext * context, lo_TableRec *table, lo_TableCell *table_cell,
		int32 desired_width, int32 cell_empty_space);
static int32
	lo_ComputeInternalTableWidth(MWContext *context, lo_TableRec *table,
		lo_DocState *state);
static void
	lo_SetDefaultCellWidth(MWContext *context, lo_TableRec *table, LO_SubDocStruct *subdoc,
		lo_TableCell *table_cell, int32 cell_width);


static void lo_ResetWidthSpans( lo_TableRec *table );

static void lo_UpdateCaptionCellFromSubDoc( MWContext *context, lo_DocState *state, LO_SubDocStruct *subdoc, LO_CellStruct *cell_ele);
static void lo_FreeCaptionCell( MWContext *context, lo_DocState *state, LO_CellStruct *cell_ele);
static void lo_FreeTableCaption( MWContext *context, lo_DocState *state, lo_TableRec *table );

static int32
lo_ComputeCellEmptySpace(MWContext *context, lo_TableRec *table,
	LO_SubDocStruct *subdoc)
{
	int32 left_inner_pad;
	int32 right_inner_pad;
	int32 cell_empty_space;
	
	left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
	right_inner_pad = FEUNITS_X(table->inner_right_pad, context);
	
	cell_empty_space =	(2 * subdoc->border_width) +
						(2 * subdoc->border_horiz_space) +
						(left_inner_pad + right_inner_pad);
	
	return cell_empty_space;
}


/*
 * Handle Fixed Table Layout. If the table has a COLS attribute
 * then the width of this cell may already be specified. The
 * trick is to know if this is the first row of the table. If
 * so, then this cell can choose it's width.
 */
static int32
lo_FindDefaultCellWidth(MWContext * context, lo_TableRec *table, lo_TableCell *table_cell,
	int32 desired_width, int32 cell_empty_space)
{
	lo_TableRow * row_ptr;
	int32 cell_num;
	int32 cell_width;
	int32 count;
	int32 cell_pad;
		
	cell_pad = FEUNITS_X(table->inter_cell_pad, context);
	
	row_ptr = table->row_ptr;
	cell_num = row_ptr->cells;
	
	/* if we don't have a width table or we're out of bounds, bail */
	if ( table->fixed_col_widths == NULL ||
		((cell_num+table_cell->colspan) > table->fixed_cols) )
	{
		table->fixed_cols = 0;
		table->default_cell_width = 0;
		return desired_width;
	}
	
	/* does this cell already have a width defined? */
	cell_width = table->fixed_col_widths[ cell_num ];
	if ( cell_width == 0 )
	{
		int32 col_width;
		
		/* use it's desired width or the default */
		cell_width = desired_width;
		if ( cell_width == 0 )
		{
			/*
			 * Get our size from the default cell width. We
			 * may need to clip it to the table width remaining.
			 */
			cell_width = table->default_cell_width * table_cell->colspan;
			
			/*
			 * If this is bigger than the width remaining the the table, then
			 * clip to the remaining space. If the table is already full, then
			 * we're going for broke and the cell gets all of it.
			 */
			if ( ( table->fixed_width_remaining > 0 ) &&
				( cell_width > table->fixed_width_remaining ) )
			{
				cell_width = table->fixed_width_remaining;
			}
	
			table->fixed_width_remaining -= cell_width;
			
			/*
			 * Remove any cell spacing so the cell will internally
			 * layout to the correct size.
			 */
			cell_width -= cell_empty_space * table_cell->colspan;
		}
		else
		{
			/*
			 * The cell has a specified size. Allocate all of it. If we
			 * don't have enough space, then we'll keep doing fixed layout,
			 * but the table may end up larger than expected.
			 */
			table->fixed_width_remaining -= cell_width + cell_empty_space;
		}
		
		/* make sure this stays reasonable */
		if ( table->fixed_width_remaining < 0 )
		{
			table->fixed_width_remaining = 0;
		}
					
		/* fill out the apropriate number of col widths */
		col_width = cell_width / table_cell->colspan;
		for ( count = table_cell->colspan; count > 0 ; --count )
		{
			table->fixed_col_widths[ cell_num ] = col_width;
			cell_num++;
		}
		
		/* add any odd amount to the last column */
		table->fixed_col_widths[ cell_num-1 ] += (cell_width-
			(col_width * table_cell->colspan));
	}
	else
	{		
		/* add up widths of each column our cell spans */
		for ( count = 1; count < table_cell->colspan; ++count )
		{
			cell_width += table->fixed_col_widths[ cell_num+count ];
		}
	}
			
	/*
	 * Add the empty space this cell spans
	 */
	cell_width += ( table_cell->colspan - 1 ) * ( cell_empty_space + cell_pad );
	
	return cell_width;
}


/*
 * For fixed layout, set the cell width for a cell after layout. This is used
 * for cases where we don't know how wide a cell is until after it's been layed
 * out (for example, when NOWRAP is set).
 *
 * We will have already chosen a default width for this cell. If our new width
 * is larger, then we need to resize the column/s.
 */
static void
lo_SetDefaultCellWidth(MWContext *context, lo_TableRec *table, LO_SubDocStruct *subdoc,
	lo_TableCell *table_cell, int32 cell_width)
{
	lo_TableRow * row_ptr;
	int32 cell_num;
	int32 count;
	int32 cur_width;
	int32 add_width;
	int32 cell_empty_space;
	int32 cell_pad;
			
	row_ptr = table->row_ptr;
	cell_num = row_ptr->cells;
	
	/* if we don't have a width table or we're out of bounds, bail */
	if ( table->fixed_col_widths == NULL ||
		((cell_num+table_cell->colspan) > table->fixed_cols) )
	{
		table->fixed_cols = 0;
		table->default_cell_width = 0;
		return;
	}
	
	/*
	 * Figure out the current width for these cells
	 */
	cur_width = 0;
	
	for ( count = table_cell->colspan-1; count >= 0 ; --count )
	{
		cur_width += table->fixed_col_widths[ cell_num+count ];
	}
	
	/*
	 * Add space for the empty space that this cell spans
	 */
	cell_empty_space = lo_ComputeCellEmptySpace(context, table, subdoc );
	cell_pad = FEUNITS_X(table->inter_cell_pad, context);

	cur_width += ( table_cell->colspan - 1 ) * ( cell_empty_space + cell_pad );
	
	/*
	 * If our new width is bigger, we need to grow the default width
	 */
	if ( cell_width > cur_width )
	{
		cell_width -= cur_width;
		add_width = cell_width / table_cell->colspan;
		
		table->fixed_width_remaining -= add_width;
		if ( table->fixed_width_remaining < 0 )
		{
			table->fixed_width_remaining = 0;
		}
		
		for ( count = table_cell->colspan; count > 0 ; --count )
		{
			table->fixed_col_widths[ cell_num ] += add_width;
			cell_width -= add_width;
			cell_num++;
		}
		
		/* add any odd amount to the last column */
		table->fixed_col_widths[ cell_num-1 ] += cell_width;
	}
}

static int32
lo_ComputeInternalTableWidth(MWContext *context,lo_TableRec *table,
	lo_DocState *state)
{
	int32 table_width;
	int32 cell_pad;
	int32 table_pad;
	
	cell_pad = FEUNITS_X(table->inter_cell_pad, context);
	
	table_width = table->width;
	if ( table_width == 0 )
	{
		/* Compute our starting width as the window width */
		table_width = (state->win_width - state->win_left -
			state->win_right);
	}
	
	/* remove space for the table borders */
	table_width -= ( table->table_ele->border_left_width
		+ table->table_ele->border_right_width );

	if (table->draw_borders == TABLE_BORDERS_OFF)
	{
		table_pad = FEUNITS_X(TABLE_DEF_CELL_BORDER, context);
		table_width -= 2 * table_pad;
	}
	
	if ( table->fixed_cols > 0 )
	{
		table_width -= ( table->fixed_cols + 1 ) * cell_pad;
	}
	else
	{
		table_width -= ( table->cols + 1 ) * cell_pad;
	}

	return table_width;
}

/*
 ********************************************************************************
 * Core Table Layout Code
 */
 
void
lo_BeginCaptionSubDoc(MWContext *context, lo_DocState *state,
	lo_TableCaption *caption, PA_Tag *tag)
{
	LO_SubDocStruct *subdoc;
	lo_DocState *new_state;
	int32 first_width, first_height;
	Bool allow_percent_width;
	Bool allow_percent_height;

	/*
	 * Fill in the subdoc structure with default data
	 */
	subdoc = (LO_SubDocStruct *)lo_NewElement(context, state, LO_SUBDOC, NULL, 0);
	if (subdoc == NULL)
	{
		return;
	}

	subdoc->type = LO_SUBDOC;
	subdoc->ele_id = NEXT_ELEMENT;
	subdoc->x = state->x;
	subdoc->x_offset = 0;
	subdoc->y = state->y;
	subdoc->y_offset = 0;
	subdoc->width = 0;
	subdoc->height = 0;
	subdoc->next = NULL;
	subdoc->prev = NULL;

	subdoc->anchor_href = state->current_anchor;

	if (state->font_stack == NULL)
	{
		subdoc->text_attr = NULL;
	}
	else
	{
		subdoc->text_attr = state->font_stack->text_attr;
	}

	subdoc->FE_Data = NULL;
	subdoc->backdrop.bg_color = NULL;
    subdoc->backdrop.url = NULL;
    subdoc->backdrop.tile_mode = LO_TILE_BOTH;
	subdoc->state = NULL;

	subdoc->vert_alignment = LO_ALIGN_CENTER;
	subdoc->horiz_alignment = caption->horiz_alignment;

	subdoc->alignment = LO_ALIGN_BOTTOM;

	subdoc->border_width = 0;
	subdoc->border_vert_space = 0;
	subdoc->border_horiz_space = 0;

	subdoc->ele_attrmask = 0;

	subdoc->sel_start = -1;
	subdoc->sel_end = -1;

	subdoc->border_width = FEUNITS_X(subdoc->border_width, context);

	if (subdoc->width == 0)
	{
		first_width = FEUNITS_X(5000, context);
		allow_percent_width = FALSE;
	}
	else
	{
		first_width = subdoc->width;
		allow_percent_width = TRUE;
	}

	if (subdoc->height == 0)
	{
		first_height = FEUNITS_Y(10000, context);
		allow_percent_height = FALSE;
	}
	else
	{
		first_height = subdoc->height;
		allow_percent_height = TRUE;
	}

	new_state = lo_NewLayout(context, first_width, first_height, 0, 0, NULL);
	if (new_state == NULL)
	{
		lo_FreeElement(context, (LO_Element *)subdoc, FALSE);
		return;
	}
	new_state->is_a_subdoc = SUBDOC_CAPTION;
	lo_InheritParentState(context, new_state, state);
	new_state->allow_percent_width = allow_percent_width;
	new_state->allow_percent_height = allow_percent_height;

	new_state->base_x = 0;
	new_state->base_y = 0;
	new_state->display_blocked = TRUE;
	if (subdoc->width == 0)
	{
		new_state->delay_align = TRUE;
	}

	new_state->win_left = 0;
	new_state->win_right = 0;
	new_state->x = new_state->win_left;
	new_state->y = 0;
	new_state->max_width = new_state->x + 1;
	new_state->left_margin = new_state->win_left;
	new_state->right_margin = new_state->win_width - new_state->win_right;
	new_state->list_stack->old_left_margin = new_state->left_margin;
	new_state->list_stack->old_right_margin = new_state->right_margin;

	/*
	 * Initialize the alignment stack for this state
	 * to match the caption alignment.
	 */
	if (subdoc->horiz_alignment != LO_ALIGN_LEFT)
	{
		lo_PushAlignment(new_state, tag->type, subdoc->horiz_alignment);
	}

	state->sub_state = new_state;

	state->current_ele = (LO_Element *)subdoc;
	
	/*
	 * We added a new state.
	 */
	lo_PushStateLevel ( context );
}


static void
lo_reuse_current_state(MWContext *context, lo_DocState *state,
	int32 width, int32 height, int32 margin_width, int32 margin_height,
	Bool destroyLineLists)
{
	lo_TopState *top_state;
	int32 doc_id;
    lo_DocLists *doc_lists;

	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	if ((top_state == NULL)||(state == NULL))
	{
		return;
	}

	state->subdoc_tags = NULL;
	state->subdoc_tags_end = NULL;

	state->text_fg.red = lo_master_colors[LO_COLOR_FG].red;
	state->text_fg.green = lo_master_colors[LO_COLOR_FG].green;
	state->text_fg.blue = lo_master_colors[LO_COLOR_FG].blue;

	state->text_bg.red = lo_master_colors[LO_COLOR_BG].red;
	state->text_bg.green = lo_master_colors[LO_COLOR_BG].green;
	state->text_bg.blue = lo_master_colors[LO_COLOR_BG].blue;

	state->anchor_color.red = lo_master_colors[LO_COLOR_LINK].red;
	state->anchor_color.green = lo_master_colors[LO_COLOR_LINK].green;
	state->anchor_color.blue = lo_master_colors[LO_COLOR_LINK].blue;

	state->visited_anchor_color.red = lo_master_colors[LO_COLOR_VLINK].red;
	state->visited_anchor_color.green = lo_master_colors[LO_COLOR_VLINK].green;
	state->visited_anchor_color.blue = lo_master_colors[LO_COLOR_VLINK].blue;

	state->active_anchor_color.red = lo_master_colors[LO_COLOR_ALINK].red;
	state->active_anchor_color.green = lo_master_colors[LO_COLOR_ALINK].green;
	state->active_anchor_color.blue = lo_master_colors[LO_COLOR_ALINK].blue;

	state->win_top = margin_height;
	state->win_bottom = margin_height;
	state->win_width = width;
	state->win_height = height;

	state->base_x = 0;
	state->base_y = 0;
	state->x = 0;
	state->y = 0;
	state->width = 0;
	state->line_num = 1;

	state->win_left = margin_width;
	state->win_right = margin_width;

	state->max_width = state->win_left + state->win_right;

	state->x = state->win_left;
	state->y = state->win_top;

	state->left_margin = state->win_left;
	state->right_margin = state->win_width - state->win_right;
	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;
	}

	state->break_holder = state->x;
	state->min_width = 0;
	state->text_divert = P_UNKNOWN;
	state->linefeed_state = 2;
	state->delay_align = FALSE;
	state->breakable = TRUE;
	state->allow_amp_escapes = TRUE;
	state->preformatted = PRE_TEXT_NO;
	state->preformat_cols = 0;

	state->in_paragraph = FALSE;

	state->display_blocked = FALSE;
	state->display_blocking_element_id = 0;
	state->display_blocking_element_y = 0;

	if (destroyLineLists == TRUE)
	{
		if (state->line_list != NULL)
		{
			lo_FreeElementList(context, state->line_list);
			state->line_list = NULL;
		}
		state->end_last_line = NULL;
		if (state->float_list != NULL)
		{	
			lo_FreeElementList(context, state->float_list);
			state->float_list = NULL;
		}
	}

	state->base_font_size = DEFAULT_BASE_FONT_SIZE;
	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;
	}
	state->font_stack = lo_DefaultFont(state, context);

	state->font_stack->text_attr->size = state->base_font_size;

	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;
	}
	state->list_stack = lo_DefaultList(state);

	state->text_info.max_width = 0;
	state->text_info.ascent = 0;
	state->text_info.descent = 0;
	state->text_info.lbearing = 0;
	state->text_info.rbearing = 0;

	state->line_buf_len = 0;

	state->baseline = 0;
	state->line_height = 0;
	state->break_pos = -1;
	state->break_width = 0;
	state->last_char_CR = FALSE;
	state->trailing_space = FALSE;
	state->at_begin_line = TRUE;

	state->old_break = NULL;
	state->old_break_block = NULL;
	state->old_break_pos = -1;
	state->old_break_width = 0;

	state->current_named_anchor = NULL;
	state->current_anchor = NULL;

	state->cur_ele_type = LO_NONE;
	state->current_ele = NULL;
	state->current_java = NULL;

	state->current_table = NULL;
	state->current_grid = NULL;
	state->current_multicol = NULL;

	if (state->top_state->doc_state)
		doc_lists = lo_GetCurrentDocLists(state->top_state->doc_state);
	else
		doc_lists = lo_GetCurrentDocLists(state);
	
	/*
	 * These values are saved into the (sub)doc here
	 * so that if it gets Relayout() later, we know where
	 * to reset the from counts to.
	 */
	if (doc_lists->form_list != NULL)
	{
		lo_FormData *form_list;

		form_list = doc_lists->form_list;
		state->form_ele_cnt = form_list->form_ele_cnt;
		state->form_id = form_list->id;
	}
	else
	{
		state->form_ele_cnt = 0;
		state->form_id = 0;
	}
	state->start_in_form = top_state->in_form;
	if (top_state->savedData.FormList != NULL)
	{
		lo_SavedFormListData *all_form_ele;

		all_form_ele = top_state->savedData.FormList;
		state->form_data_index = all_form_ele->data_index;
	}
	else
	{
		state->form_data_index = 0;
	}

	/*
	 * Remember number of embeds we had before beginning this
	 * (sub)doc. This information is used in laytable.c so
	 * it can preserve embed indices across a relayout.
	 */
	state->embed_count_base = top_state->embed_count;

	/*
	 * Ditto for anchors, images, applets and embeds
	 */
	state->url_count_base = doc_lists->url_list_len;
	state->image_list_count_base = doc_lists->image_list_count;
        state->applet_list_count_base = doc_lists->applet_list_count;
        state->embed_list_count_base = doc_lists->embed_list_count;
	state->current_layer_num_base = top_state->current_layer_num;
	state->current_layer_num_max = top_state->current_layer_num;

	state->must_relayout_subdoc = FALSE;
	state->allow_percent_width = TRUE;
	state->allow_percent_height = TRUE;
	state->is_a_subdoc = SUBDOC_NOT;
	state->current_subdoc = 0;
	state->sub_documents = NULL;
	state->sub_state = NULL;

	state->current_cell = NULL;

	state->extending_start = FALSE;
	state->selection_start = NULL;
	state->selection_start_pos = 0;
	state->selection_end = NULL;
	state->selection_end_pos = 0;
	state->selection_new = NULL;
	state->selection_new_pos = 0;

#ifdef EDITOR
	state->edit_force_offset = FALSE;
	state->edit_current_element = 0;
	state->edit_current_offset = 0;
	state->edit_relayout_display_blocked = FALSE;
#endif
#ifdef MOCHA
	state->in_relayout = FALSE;
#endif

	state->cur_text_block = NULL;
	
	/* we need min widths during the initial table layout pass */
	state->need_min_width = TRUE;
}


static void
lo_reuse_current_subdoc(MWContext *context, LO_SubDocStruct *subdoc)
{
	if (subdoc == NULL)
	{
		return;
	}

	subdoc->type = LO_SUBDOC;
	subdoc->ele_id = 0;
	subdoc->x = 0;
	subdoc->x_offset = 0;
	subdoc->y = 0;
	subdoc->y_offset = 0;
	subdoc->width = 0;
	subdoc->height = 0;
	subdoc->next = NULL;
	subdoc->prev = NULL;

	subdoc->FE_Data = NULL;

	/*
	 * We leave subdoc->state alone as it will get reused later.
	 */

    XP_FREEIF(subdoc->backdrop.bg_color);
    XP_FREEIF(subdoc->backdrop.url);

	/*
	 * These two come from lists of shared pointers, so
	 * we NULL them but don't free them.
	 */
	subdoc->anchor_href = NULL;
	subdoc->text_attr = NULL;

	subdoc->alignment = LO_ALIGN_LEFT;
	subdoc->vert_alignment = LO_ALIGN_TOP;
	subdoc->horiz_alignment = LO_ALIGN_LEFT;
	subdoc->border_width = 0;
	subdoc->border_vert_space = 0;
	subdoc->border_horiz_space = 0;
	subdoc->ele_attrmask = 0;
	subdoc->sel_start = -1;
	subdoc->sel_end = -1;
}


static void
lo_cleanup_old_state(lo_DocState *state)
{
	LO_Element **line_array;

	if (state == NULL)
	{
		return;
	}

	/*
	 * Clear out the start of the line_list.
	 */
#ifdef XP_WIN16
	{
		XP_Block *larray_array;

		XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array);
		state->line_array = larray_array[0];
		XP_UNLOCK_BLOCK(state->larray_array);
	}
#endif /* XP_WIN16 */
	XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
	line_array[0] = NULL;
	XP_UNLOCK_BLOCK(state->line_array);

	state->end_last_line = NULL;

	state->float_list = NULL;
}


static int32 lo_CalculateCellPercentWidth( lo_TableRec *table, int32 percent)
{
	int32 val = percent;

	if ( table->table_width_fixed != FALSE )
	{
		val = table->width * val / 100;
	}
	else
	{
		val = 0;
	}
	return val;
}

static int32 lo_CalculateCellPercentHeight( lo_TableRec *table, lo_TableCell *table_cell)
{
	int32 val;

	if ((table->height > 0)&&
		(table_cell->percent_height > 0))
	{
		val = table->height *
			table_cell->percent_height / 100;
	}
	else
	{
		val = 0;
	}
	return val;
}

void
lo_BeginCellSubDoc(MWContext *context, 
 					lo_DocState *state,
 					lo_TableRec *table,
 					char *bgcolor_attr,
 					char *background_attr,
                    lo_TileMode tile_mode,
 					char *valign_attr,
 					char *halign_attr,
 					char *width_attr,
 					char *height_attr,
 					Bool is_a_header, 
 					intn draw_borders,
					Bool relayout /* Is true during relayout without reload */)
{
	LO_SubDocStruct *subdoc;
	lo_DocState *new_state;
	lo_TableRow *table_row;
	lo_TableCell *table_cell;
	int32 val;
	int32 first_width, first_height;
	Bool allow_percent_width;
	Bool allow_percent_height;
	StyleStruct *style_struct=0;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_BeginCellSubDoc called\n");
#endif /* LOCAL_DEBUG */

	table_row = table->row_ptr;
	table_cell = table_row->cell_ptr;

	if (relayout == FALSE) 
	{
		if(state->top_state && state->top_state->style_stack)
			style_struct = STYLESTACK_GetStyleByIndex(
											state->top_state->style_stack,
											0);
	}

	/*
	 * Fill in the subdoc structure with default data
	 */
	lo_reuse_current_subdoc(context, table->current_subdoc);
	subdoc = table->current_subdoc;
	if (subdoc == NULL)
	{
		return;
	}

	subdoc->type = LO_SUBDOC;
	subdoc->ele_id = NEXT_ELEMENT;
	subdoc->x = state->x;
	subdoc->x_offset = 0;
	subdoc->y = state->y;
	subdoc->y_offset = 0;
	subdoc->width = 0;
	subdoc->height = 0;
	subdoc->next = NULL;
	subdoc->prev = NULL;

	subdoc->anchor_href = state->current_anchor;

	if (state->font_stack == NULL)
	{
		subdoc->text_attr = NULL;
	}
	else
	{
		subdoc->text_attr = state->font_stack->text_attr;
	}

	subdoc->FE_Data = NULL;

	subdoc->vert_alignment = table_row->vert_alignment;
	if (subdoc->vert_alignment == LO_ALIGN_DEFAULT)
	{
		subdoc->vert_alignment = LO_ALIGN_CENTER;
	}
	subdoc->horiz_alignment = table_row->horiz_alignment;
	if (subdoc->horiz_alignment == LO_ALIGN_DEFAULT)
	{
		if (is_a_header == FALSE)
		{
			subdoc->horiz_alignment = LO_ALIGN_LEFT;
		}
		else
		{
			subdoc->horiz_alignment = LO_ALIGN_CENTER;
		}
	}
	subdoc->alignment = LO_ALIGN_BOTTOM;

	if (draw_borders == TABLE_BORDERS_OFF)
	{
		subdoc->border_width = 0;
		subdoc->border_vert_space = TABLE_DEF_CELL_BORDER;
		subdoc->border_horiz_space = TABLE_DEF_CELL_BORDER;
	}
	else if (draw_borders == TABLE_BORDERS_ON)
	{
		subdoc->border_width = TABLE_DEF_CELL_BORDER;
		subdoc->border_vert_space = 0;
		subdoc->border_horiz_space = 0;
	}
	else
	{
		subdoc->border_width = 0;
		subdoc->border_vert_space = 0;
		subdoc->border_horiz_space = 0;
	}

	subdoc->ele_attrmask = 0;

	subdoc->sel_start = -1;
	subdoc->sel_end = -1;

	subdoc->backdrop.bg_color = NULL;
    subdoc->backdrop.url = NULL;
    subdoc->backdrop.tile_mode = LO_TILE_BOTH;

	/*
	 * May inherit a bg_color from your row.
	 */
	if (table_row->backdrop.bg_color != NULL)
	{
		subdoc->backdrop.bg_color = XP_NEW(LO_Color);
		if (subdoc->backdrop.bg_color != NULL)
			*subdoc->backdrop.bg_color = *table_row->backdrop.bg_color;
	}

	if (relayout == FALSE)
	{
		subdoc->backdrop.bg_color = NULL;
		subdoc->backdrop.url = NULL;
		subdoc->backdrop.tile_mode = LO_TILE_BOTH;

		/*
		 * May inherit a bg_color from your row.
		 */
		if (table_row->backdrop.bg_color != NULL)
		{
			subdoc->backdrop.bg_color = XP_NEW(LO_Color);
			if (subdoc->backdrop.bg_color != NULL)
				*subdoc->backdrop.bg_color = *table_row->backdrop.bg_color;
		}

		/*
		 * Else may inherit a bg_color from your table.
		 */
		else if (table->backdrop.bg_color != NULL)
		{
			subdoc->backdrop.bg_color = XP_NEW(LO_Color);
			if (subdoc->backdrop.bg_color != NULL)
				*subdoc->backdrop.bg_color = *table->backdrop.bg_color;
		}
		/*
		 * Else possibly inherit the background color attribute
		 * of a parent table cell.
		 */
		else if (state->is_a_subdoc == SUBDOC_CELL)
		{
			lo_DocState *up_state;

			/*
			 * Find the parent subdoc's state.
			 */
			up_state = state->top_state->doc_state;
			while ((up_state->sub_state != NULL)&&
				(up_state->sub_state != state))
			{
				up_state = up_state->sub_state;
			}
			if ((up_state->sub_state != NULL)&&
				(up_state->current_ele != NULL)&&
				(up_state->current_ele->type == LO_SUBDOC)&&
				(up_state->current_ele->lo_subdoc.backdrop.bg_color != NULL))
			{
				LO_Color *old_bg;

				old_bg = up_state->current_ele->lo_subdoc.backdrop.bg_color;
				subdoc->backdrop.bg_color = XP_NEW(LO_Color);
				if (subdoc->backdrop.bg_color != NULL)
					*subdoc->backdrop.bg_color = *old_bg;
			}
		}


		/* Use backdrop URL, if supplied. */
		if (background_attr)
		{
			subdoc->backdrop.url = XP_STRDUP(background_attr);
			subdoc->backdrop.tile_mode = tile_mode;
		}
    
		/*
		 * May inherit a backdrop_url from parent row.
		 */
		else if (table_row->backdrop.url)
		{
			subdoc->backdrop.url = XP_STRDUP(table_row->backdrop.url);
			subdoc->backdrop.tile_mode = table_row->backdrop.tile_mode;
		}

		/*
		 * Else may inherit a backdrop_url from parent table.
		 */
		else if (table->backdrop.url != NULL)
		{
			subdoc->backdrop.url = XP_STRDUP(table->backdrop.url);
			subdoc->backdrop.tile_mode = table->backdrop.tile_mode;
		}
		/*
		 * Else possibly inherit the backdrop_url
		 * of a parent table cell.
		 */
		else if (state->is_a_subdoc == SUBDOC_CELL)
		{
			lo_DocState *up_state;

			/*
			 * Find the parent subdoc's state.
			 */
			up_state = state->top_state->doc_state;
			while ((up_state->sub_state != NULL)&&
				(up_state->sub_state != state))
			{
				up_state = up_state->sub_state;
			}
			if ((up_state->sub_state != NULL)&&
				(up_state->current_ele != NULL)&&
				(up_state->current_ele->type == LO_SUBDOC)&&
				(up_state->current_ele->lo_subdoc.backdrop.url != NULL))
			{
				lo_Backdrop *src_backdrop = &up_state->current_ele->lo_subdoc.backdrop;
				subdoc->backdrop.url = XP_STRDUP(src_backdrop->url);
				subdoc->backdrop.tile_mode = src_backdrop->tile_mode;
			}
		}

		/*
		 * Check for a background color attribute
		 */
		if (bgcolor_attr)
		{
			uint8 red, green, blue;

			LO_ParseRGB(bgcolor_attr, &red, &green, &blue);
			XP_FREEIF(subdoc->backdrop.bg_color);
			subdoc->backdrop.bg_color = XP_NEW(LO_Color);
			if (subdoc->backdrop.bg_color != NULL)
			{
				subdoc->backdrop.bg_color->red = red;
				subdoc->backdrop.bg_color->green = green;
				subdoc->backdrop.bg_color->blue = blue;
			}
		}

		/* check for a style sheet directive for bgcolor */
		if(style_struct)
		{
			char *property = STYLESTRUCT_GetString(style_struct, BG_COLOR_STYLE);
		
			if(property)
			{
				uint8 red, green, blue;

				LO_ParseStyleSheetRGB(property, &red, &green, &blue);

				XP_FREEIF(subdoc->backdrop.bg_color);
				subdoc->backdrop.bg_color = XP_NEW(LO_Color);
				if (subdoc->backdrop.bg_color != NULL)
				{
					subdoc->backdrop.bg_color->red = red;
					subdoc->backdrop.bg_color->green = green;
					subdoc->backdrop.bg_color->blue = blue;
				}
				XP_FREE(property);
			}

			property = STYLESTRUCT_GetString(style_struct, BG_IMAGE_STYLE);
			if(property)
			{
				if(subdoc->backdrop.url)
					XP_FREE(subdoc->backdrop.url);
				subdoc->backdrop.url = NULL;

				if(strcasecomp(property, "none"))
			{
					subdoc->backdrop.url = XP_STRDUP(lo_ParseStyleSheetURL(property));
				}
				XP_FREE(property);
			}

			property = STYLESTRUCT_GetString(style_struct, BG_REPEAT_STYLE);
			if(property)
			{
				if(!strcasecomp(property, BG_REPEAT_NONE_STYLE))
					subdoc->backdrop.tile_mode = LO_NO_TILE;
				else if(!strcasecomp(property, BG_REPEAT_X_STYLE))
					subdoc->backdrop.tile_mode = LO_TILE_HORIZ;
				else if(!strcasecomp(property, BG_REPEAT_Y_STYLE))
					subdoc->backdrop.tile_mode = LO_TILE_VERT;
				else 
					subdoc->backdrop.tile_mode = LO_TILE_BOTH;
			}
		}
	}	
	else  /* If relayout is TRUE */
	{
		/*
		subdoc->backdrop.tile_mode = table_cell->cell->backdrop.tile_mode;		
		if (table_cell->cell->backdrop.bg_color != NULL)
		{
			subdoc->backdrop.bg_color = XP_NEW(LO_Color);
			subdoc->backdrop.bg_color->red = table_cell->cell->backdrop.bg_color->red;
			subdoc->backdrop.bg_color->green = table_cell->cell->backdrop.bg_color->green;
			subdoc->backdrop.bg_color->blue = table_cell->cell->backdrop.bg_color->blue;
		}
		if (table_cell->cell->backdrop.url != NULL)
		{
			subdoc->backdrop.url = XP_STRDUP(table_cell->cell->backdrop.url);
		}
		*/
		subdoc->backdrop = table_cell->cell->backdrop;
	}

	/*
	 * Check for a vertical align parameter
	 */
	if (valign_attr)
	{
		subdoc->vert_alignment = lo_EvalVAlignParam(valign_attr);
	}



	if(style_struct)
	{
		char *property = STYLESTRUCT_GetString(style_struct, VERTICAL_ALIGN_STYLE);
	
		if(property)
		{
			subdoc->vert_alignment = lo_EvalVAlignParam(property);
			XP_FREE(property);
		}
	}

	if (relayout)
	{
		subdoc->vert_alignment = table_cell->vert_alignment;
	}

	/*
	 * Check for a horizontal align parameter
	 */
	if (halign_attr)
	{
		subdoc->horiz_alignment = lo_EvalCellAlignParam(halign_attr);
	}

	if (relayout)
	{
		subdoc->horiz_alignment = table_cell->horiz_alignment;
	}

	subdoc->border_width = FEUNITS_X(subdoc->border_width, context);
	subdoc->border_vert_space =
		FEUNITS_Y(subdoc->border_vert_space, context);
	subdoc->border_horiz_space =
		FEUNITS_X(subdoc->border_horiz_space, context);

	/*
	 * Allow individual setting of cell
	 * width and height.
	 */
	if (width_attr)
	{
		Bool is_percent;

		val = lo_ValueOrPercent(width_attr, &is_percent);
		if (is_percent != FALSE)
		{
			/*
			 * Percentage width cells must be handled
			 * later after at least the whole row is
			 * processed.
			 */
			table_cell->percent_width = val;
			table_row->has_percent_width_cells = TRUE;
			table->has_percent_width_cells = TRUE;
			val = lo_CalculateCellPercentWidth( table, val );

			/* Copied to lo_CalculateCellPercentWidth() */
			/*
			if ( table->table_width_fixed != FALSE )
			{
				val = table->width * val / 100;
			}
			else
			{
				val = 0;
			}
			*/
		}
		else
		{
			table_cell->percent_width = 0;
			val = FEUNITS_X(val, context);
		}
		if (val < 0)
		{
			val = 0;
		}
		
		subdoc->width = val;
		table_cell->specified_width = subdoc->width;
	}

	/* During relayout without reload, recalculate width of subdoc */
	if (relayout)
	{
		if (table_cell->percent_width > 0)
		{
			subdoc->width = lo_CalculateCellPercentWidth( table, table_cell->percent_width);
			table_cell->specified_width = subdoc->width;
		}
		else {
			subdoc->width = table_cell->specified_width;
			if (subdoc->width < 0) {
				subdoc->width = 0;
			}
		}
		
	}
							
	/*
	 * If we're in the fixed layout case, figure out what our cell
	 * width should be.
	 */
	if ( table->fixed_cols > 0 )
	{
		int32 cell_empty_space;
		int32 def_cell_width;
		int32 desired_width;
		
		cell_empty_space = lo_ComputeCellEmptySpace ( context, table, subdoc);

		desired_width = subdoc->width;
		/*
		 * Obey percentage cell width in fixed columns if we
		 * already know table width.
		 */
		if ((table_cell->percent_width > 0)&&(table->width > 0))
		{
			int32 avail_width;
			int32 cell_pad;

			/*
			 * Percentage width is a percentage of the available
			 * cell space.
			 */
			cell_pad = FEUNITS_X(table->inter_cell_pad, context);
			avail_width = table->width -
				((table->fixed_cols + 1) * cell_pad);
			avail_width -= (table->table_ele->border_left_width +
					table->table_ele->border_right_width);
			desired_width = avail_width *
				table_cell->percent_width / 100;
			/*
			 * Pecentage width takes into account the
			 * cell padding/spacing already.
			 */
			desired_width -= cell_empty_space;
		}
		def_cell_width = lo_FindDefaultCellWidth (context, table,
			table_cell, desired_width, cell_empty_space);
		
		/*
		 * If NOWRAP is off, we can go ahead and layout to this width. Otherwise
		 * we want to layout to a dynamic width and then use the bigger of the
		 * default or computed width for the cell.
		 */
		if ( table_cell->nowrap == FALSE )
		{
			subdoc->width = def_cell_width;
		}
	}
		
	if (height_attr)
	{
		Bool is_percent;

		val = lo_ValueOrPercent(height_attr, &is_percent);
		if (is_percent != FALSE)
		{
			/*
			 * We can process percentage heights here if
			 * we have a known table height.
			 */
			table_cell->percent_height = val;
			table->has_percent_height_cells = TRUE;
			val = lo_CalculateCellPercentHeight(table, table_cell);

			/* Copied to lo_CalculateCellPercentHeight() */
			/*
			if ((table->height > 0)&&
				(table_cell->percent_height > 0))
			{
				val = table->height *
					table_cell->percent_height / 100;
			}
			else
			{
				val = 0;
			}
			*/
		}
		else
		{
			table_cell->percent_height = 0;
			val = FEUNITS_X(val, context);
		}
		subdoc->height = val;
		if (subdoc->height < 0)
		{
			subdoc->height = 0;
		}
		table_cell->specified_height = subdoc->height;
	}

	/* During relayout without reload, recalculate height of subdoc */
	if (relayout)
	{
		if (table_cell->percent_height > 0)
		{
			subdoc->height = lo_CalculateCellPercentHeight( table, table_cell);
			table_cell->specified_height = subdoc->height;
		}
		else {
			subdoc->height = table_cell->specified_height;
			if (subdoc->height < 0) {
				subdoc->height = 0;
			}
		}
		
	}

	if (subdoc->width == 0)
	{
		/*
		 * Choose a default size that will fit within the current table. If NOWRAP is
		 * on, we just want to go ahead and choose a big width so that we're sure
		 * to get the correct nonwrapping text layout.
		 */
		if ( table_cell->nowrap == FALSE )
		{
			first_width = lo_ComputeInternalTableWidth ( context, table, state );
			first_width -= lo_ComputeCellEmptySpace ( context, table, subdoc);
		}
		else
		{
			first_width = FEUNITS_X(5000, context);
		}
		
		allow_percent_width = FALSE;
	}
	else
	{
		first_width = subdoc->width;
		allow_percent_width = TRUE;
	}

	if (subdoc->height == 0)
	{
		first_height = FEUNITS_Y(10000, context);
		allow_percent_height = FALSE;
	}
	else
	{
		first_height = subdoc->height;
		allow_percent_height = TRUE;
	}

	lo_reuse_current_state(context, subdoc->state,
		first_width, first_height, 0, 0, TRUE);
	new_state = subdoc->state;
	subdoc->state = NULL;

	if (new_state == NULL)
	{
		lo_FreeElement(context, (LO_Element *)subdoc, FALSE);
		return;
	}
	new_state->is_a_subdoc = SUBDOC_CELL;
	lo_InheritParentState(context, new_state, state);
	new_state->allow_percent_width = allow_percent_width;
	new_state->allow_percent_height = allow_percent_height;

	new_state->base_x = 0;
	new_state->base_y = 0;
	new_state->display_blocked = TRUE;
	if (subdoc->width == 0)
	{
		new_state->delay_align = TRUE;
	}

	new_state->win_left = 0;
	new_state->win_right = 0;
	new_state->x = new_state->win_left;
	new_state->y = 0;
	new_state->max_width = new_state->x + 1;
	new_state->left_margin = new_state->win_left;
	new_state->right_margin = new_state->win_width - new_state->win_right;
	new_state->list_stack->old_left_margin = new_state->left_margin;
	new_state->list_stack->old_right_margin = new_state->right_margin;

	/*
	 * Initialize the alignment stack for this state
	 * to match the caption alignment.
	 */
	if (subdoc->horiz_alignment != LO_ALIGN_LEFT)
	{
		lo_PushAlignment(new_state, P_TABLE_DATA, subdoc->horiz_alignment);
	}

	state->sub_state = new_state;

	state->current_ele = (LO_Element *)subdoc;

	if (is_a_header != FALSE)
	{
		LO_TextAttr *old_attr;
		LO_TextAttr *attr;
		LO_TextAttr tmp_attr;

		old_attr = new_state->font_stack->text_attr;
		lo_CopyTextAttr(old_attr, &tmp_attr);
		tmp_attr.fontmask |= LO_FONT_BOLD;
		attr = lo_FetchTextAttr(new_state, &tmp_attr);

		lo_PushFont(new_state, P_TABLE_DATA, attr);
	}
}


Bool
lo_subdoc_has_elements(lo_DocState *sub_state)
{
	if (sub_state->end_last_line != NULL)
	{
		return(TRUE);
	}
	if (sub_state->float_list != NULL)
	{
		return(TRUE);
	}
	return(FALSE);
}


Bool
lo_cell_has_elements(LO_CellStruct *cell)
{
	if (cell->cell_list != NULL)
	{
		return(TRUE);
	}
	if (cell->cell_float_list != NULL)
	{
		return(TRUE);
	}
	return(FALSE);
}


int32
lo_align_subdoc(MWContext *context, lo_DocState *state, lo_DocState *old_state,
	LO_SubDocStruct *subdoc, lo_TableRec *table, lo_table_span *row_max)
{
	int32 ele_cnt;
	LO_Element *eptr;
	int32 vert_inc;
	int32 top_inner_pad;
	int32 bottom_inner_pad;
	int32 left_inner_pad;
	int32 right_inner_pad;
	LO_Element **line_array;

	top_inner_pad = FEUNITS_X(table->inner_top_pad, context);
	bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context);
	left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
	right_inner_pad = FEUNITS_X(table->inner_right_pad, context);

	ele_cnt = 0;

	/*
	 * Mess with vertical alignment.
	 */
	vert_inc = subdoc->height - (2 * subdoc->border_width) - 
		(top_inner_pad + bottom_inner_pad) - old_state->y;
	if (vert_inc > 0)
	{
		if (subdoc->vert_alignment == LO_ALIGN_CENTER)
		{
			vert_inc = vert_inc / 2;
		}
		else if (subdoc->vert_alignment == LO_ALIGN_BOTTOM)
		{
			/* vert_inc unchanged */
		}
		else if ((subdoc->vert_alignment == LO_ALIGN_BASELINE)&&
			(row_max != NULL))
		{
			int32 baseline;
			int32 tmp_val;

			baseline = lo_GetSubDocBaseline(subdoc);
			tmp_val = row_max->min_dim - baseline;
			if (tmp_val > vert_inc)
			{
				tmp_val = vert_inc;
			}
			if (tmp_val > 0)
			{
				vert_inc = tmp_val;
			}
			else
			{
				vert_inc = 0;
			}
		}
		else
		{
			vert_inc = 0;
		}
	}
	else
	{
		vert_inc = 0;
	}

	/*
	 * 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 *, old_state->larray_array);
	old_state->line_array = larray_array[0];
	XP_UNLOCK_BLOCK(old_state->larray_array);
}
#endif /* XP_WIN16 */
	XP_LOCK_BLOCK(line_array, LO_Element **, old_state->line_array);
	eptr = line_array[0];
	XP_UNLOCK_BLOCK(old_state->line_array);

	while (eptr != NULL)
	{
		eptr->lo_any.x += left_inner_pad;

		switch (eptr->type)
		{
		    case LO_LINEFEED:
			if (eptr->lo_linefeed.ele_attrmask &
				LO_ELE_DELAY_ALIGNED)
			{
			    if (eptr->lo_linefeed.ele_attrmask &
				LO_ELE_DELAY_CENTER)
			    {
				int32 side_inc;
				int32 inside_width;
				LO_Element *c_eptr;

				c_eptr = eptr;
				inside_width = subdoc->width -
				    (2 * subdoc->border_width) -
				    (2 * subdoc->border_horiz_space) -
				    (left_inner_pad + right_inner_pad);

				side_inc = inside_width -
					(c_eptr->lo_linefeed.x +
					c_eptr->lo_linefeed.x_offset -
					left_inner_pad);
				side_inc = side_inc / 2;
				if (side_inc > 0)
				{
					c_eptr->lo_linefeed.width -= side_inc;
					if (c_eptr->lo_linefeed.width < 0)
					{
						c_eptr->lo_linefeed.width = 0;
					}
					while ((c_eptr->lo_any.prev != NULL)&&
						(c_eptr->lo_any.prev->type !=
							LO_LINEFEED))
					{
						c_eptr->lo_any.x += side_inc;
						if (c_eptr->type == LO_CELL)
						{
						    lo_ShiftCell(
							(LO_CellStruct *)c_eptr,
							side_inc, 0);
						}
						c_eptr = c_eptr->lo_any.prev;
					}
					c_eptr->lo_any.x += side_inc;
					if (c_eptr->type == LO_CELL)
					{
					    lo_ShiftCell(
						(LO_CellStruct *)c_eptr,
						side_inc, 0);
					}
				}
			    }
			    else if (eptr->lo_linefeed.ele_attrmask &
				LO_ELE_DELAY_RIGHT)
			    {
				int32 side_inc;
				int32 inside_width;
				LO_Element *c_eptr;

				c_eptr = eptr;
				inside_width = subdoc->width -
				    (2 * subdoc->border_width) -
				    (2 * subdoc->border_horiz_space) -
				    (left_inner_pad + right_inner_pad);

				side_inc = inside_width -
					(c_eptr->lo_linefeed.x +
					c_eptr->lo_linefeed.x_offset -
					left_inner_pad);
				if (side_inc > 0)
				{
					c_eptr->lo_linefeed.width -= side_inc;
					if (c_eptr->lo_linefeed.width < 0)
					{
						c_eptr->lo_linefeed.width = 0;
					}
					while ((c_eptr->lo_any.prev != NULL)&&
						(c_eptr->lo_any.prev->type !=
							LO_LINEFEED))
					{
						c_eptr->lo_any.x += side_inc;
						if (c_eptr->type == LO_CELL)
						{
						    lo_ShiftCell(
							(LO_CellStruct *)c_eptr,
							side_inc, 0);
						}
						c_eptr = c_eptr->lo_any.prev;
					}
					c_eptr->lo_any.x += side_inc;
					if (c_eptr->type == LO_CELL)
					{
					    lo_ShiftCell(
						(LO_CellStruct *)c_eptr,
						side_inc, 0);
					}
				}
			    }
			    eptr->lo_linefeed.ele_attrmask &=
					(~(LO_ELE_DELAY_ALIGNED));
			}
			break;
		    default:
			break;
		}
		eptr->lo_any.y += (vert_inc + top_inner_pad);
		if (eptr->type == LO_CELL)
		{
			lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad,
				(vert_inc + top_inner_pad));
		}
		eptr = eptr->lo_any.next;
		ele_cnt++;
	}

	eptr = old_state->float_list;
	while (eptr != NULL)
	{
		eptr->lo_any.x += left_inner_pad;
		eptr->lo_any.y += (vert_inc + top_inner_pad);
		if (eptr->type == LO_CELL)
		{
			lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad,
				(vert_inc + top_inner_pad));
		}
		eptr = eptr->lo_any.next;
		ele_cnt++;
	}

	return(ele_cnt);
}


int32
lo_align_cell(MWContext *context, lo_DocState *state, lo_TableCell *cell_ptr,
	LO_CellStruct *cell, lo_TableRec *table, lo_table_span *row_max)
{
	int32 ele_cnt;
	LO_Element *eptr;
	int32 vert_inc;
	int32 top_inner_pad;
	int32 bottom_inner_pad;
	int32 left_inner_pad;
	int32 right_inner_pad;

	top_inner_pad = FEUNITS_X(table->inner_top_pad, context);
	bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context);
	left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
	right_inner_pad = FEUNITS_X(table->inner_right_pad, context);

	ele_cnt = 0;

	/*
	 * Mess with vertical alignment.
	 */
	vert_inc = cell->height - (2 * cell->border_width) - 
		(top_inner_pad + bottom_inner_pad) - cell_ptr->max_y;
	if (vert_inc > 0)
	{
		if (cell_ptr->vert_alignment == LO_ALIGN_CENTER)
		{
			vert_inc = vert_inc / 2;
		}
		else if (cell_ptr->vert_alignment == LO_ALIGN_BOTTOM)
		{
			/* vert_inc unchanged */
		}
		else if ((cell_ptr->vert_alignment == LO_ALIGN_BASELINE)&&
			(row_max != NULL))
		{
			int32 baseline;
			int32 tmp_val;

			baseline = lo_GetCellBaseline(cell);
			tmp_val = row_max->min_dim - baseline;
			if (tmp_val > vert_inc)
			{
				tmp_val = vert_inc;
			}
			if (tmp_val > 0)
			{
				vert_inc = tmp_val;
			}
			else
			{
				vert_inc = 0;
			}
		}
		else
		{
			vert_inc = 0;
		}
	}
	else
	{
		vert_inc = 0;
	}

	/*
	 * Make eptr point to the start of the element chain
	 * for this cell.
	 */
	eptr = cell->cell_list;

	while (eptr != NULL)
	{
		eptr->lo_any.x += left_inner_pad;

		switch (eptr->type)
		{
		    case LO_LINEFEED:
			if (eptr->lo_linefeed.ele_attrmask &
				LO_ELE_DELAY_ALIGNED)
			{
			    if (eptr->lo_linefeed.ele_attrmask &
				LO_ELE_DELAY_CENTER)
			    {
				int32 side_inc;
				int32 inside_width;
				LO_Element *c_eptr;

				c_eptr = eptr;
				inside_width = cell->width -
				    (2 * cell->border_width) -
				    (2 * cell->border_horiz_space) -
				    (left_inner_pad + right_inner_pad);

				side_inc = inside_width -
					(c_eptr->lo_linefeed.x +
					c_eptr->lo_linefeed.x_offset -
					left_inner_pad);
				side_inc = side_inc / 2;
				if (side_inc > 0)
				{
					c_eptr->lo_linefeed.width -= side_inc;
					if (c_eptr->lo_linefeed.width < 0)
					{
						c_eptr->lo_linefeed.width = 0;
					}
					while ((c_eptr->lo_any.prev != NULL)&&
						(c_eptr->lo_any.prev->type !=
							LO_LINEFEED))
					{
						c_eptr->lo_any.x += side_inc;
						if (c_eptr->type == LO_CELL)
						{
						    lo_ShiftCell(
							(LO_CellStruct *)c_eptr,
							side_inc, 0);
						}
						c_eptr = c_eptr->lo_any.prev;
					}
					c_eptr->lo_any.x += side_inc;
					if (c_eptr->type == LO_CELL)
					{
					    lo_ShiftCell(
						(LO_CellStruct *)c_eptr,
						side_inc, 0);
					}
				}
			    }
			    else if (eptr->lo_linefeed.ele_attrmask &
				LO_ELE_DELAY_RIGHT)
			    {
				int32 side_inc;
				int32 inside_width;
				LO_Element *c_eptr;

				c_eptr = eptr;
				inside_width = cell->width -
				    (2 * cell->border_width) -
				    (2 * cell->border_horiz_space) -
				    (left_inner_pad + right_inner_pad);

				side_inc = inside_width -
					(c_eptr->lo_linefeed.x +
					c_eptr->lo_linefeed.x_offset -
					left_inner_pad);
				if (side_inc > 0)
				{
					c_eptr->lo_linefeed.width -= side_inc;
					if (c_eptr->lo_linefeed.width < 0)
					{
						c_eptr->lo_linefeed.width = 0;
					}
					while ((c_eptr->lo_any.prev != NULL)&&
						(c_eptr->lo_any.prev->type !=
							LO_LINEFEED))
					{
						c_eptr->lo_any.x += side_inc;
						if (c_eptr->type == LO_CELL)
						{
						    lo_ShiftCell(
							(LO_CellStruct *)c_eptr,
							side_inc, 0);
						}
						c_eptr = c_eptr->lo_any.prev;
					}
					c_eptr->lo_any.x += side_inc;
					if (c_eptr->type == LO_CELL)
					{
					    lo_ShiftCell(
						(LO_CellStruct *)c_eptr,
						side_inc, 0);
					}
				}
			    }
			    eptr->lo_linefeed.ele_attrmask &=
					(~(LO_ELE_DELAY_ALIGNED));
			}
			break;
		    default:
			break;
		}
		eptr->lo_any.y += (vert_inc + top_inner_pad);
		if (eptr->type == LO_CELL)
		{
			lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad,
				(vert_inc + top_inner_pad));
		}
		eptr = eptr->lo_any.next;
		ele_cnt++;
	}

	eptr = cell->cell_float_list;
	while (eptr != NULL)
	{
		eptr->lo_any.x += left_inner_pad;
		eptr->lo_any.y += (vert_inc + top_inner_pad);
		if (eptr->type == LO_CELL)
		{
			lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad,
				(vert_inc + top_inner_pad));
		}
		eptr = eptr->lo_any.next;
		ele_cnt++;
	}

	return(ele_cnt);
}


LO_SubDocStruct *
lo_EndCellSubDoc(MWContext *context, lo_DocState *state, lo_DocState *old_state,
	LO_Element *element, Bool relayout)
{
	LO_Element *eptr;
	LO_SubDocStruct *subdoc;
	PA_Block buff;
	char *str;
	Bool line_break;
	int32 baseline_inc;
	int32 line_inc;
	int32 subdoc_height, subdoc_width;
	int32 doc_height;
	LO_TextStruct tmp_text;
	LO_TextInfo text_info;
	LO_Element **line_array;
	Bool dynamic_width;
	Bool dynamic_height;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_EndCellSubDoc called\n");
#endif /* LOCAL_DEBUG */

    /* Close any layers (blocks) that were opened in this cell, in case
	   the document author forgot to. */
    while (old_state->layer_nest_level > 0)
	{
		lo_EndLayer(context, old_state, PR_TRUE);
	}

	subdoc = (LO_SubDocStruct *)element;
	subdoc->state = (void *)old_state;

	/*
	 * All this work is to get the text_info filled in for the current
	 * font in the font stack. Yuck, there must be a better way.
	 */
	memset (&tmp_text, 0, sizeof (tmp_text));
	buff = PA_ALLOC(1);
	if (buff == NULL)
	{
		state->top_state->out_of_memory = TRUE;
		return(NULL);
	}
	PA_LOCK(str, char *, buff);
	str[0] = ' ';
	PA_UNLOCK(buff);
	tmp_text.text = buff;
	tmp_text.text_len = 1;
	tmp_text.text_attr =
		state->font_stack->text_attr;
	FE_GetTextInfo(context, &tmp_text, &text_info);
	PA_FREE(buff);

	if (relayout == FALSE)
	{
		/*
		 * We don't want to leave any end paragraph linbreaks in the subdoc
		 * as they give us a really ugly blank line at the bottom of a cell. So,
		 * if the last element in the list is paragraph break linefeed, then
		 * we kill it.
		 */
		eptr = old_state->end_last_line;
		if ( (eptr != NULL) && (eptr->type == LO_LINEFEED) &&
			(eptr->lo_linefeed.break_type == LO_LINEFEED_BREAK_PARAGRAPH) )
		{
			LO_Element *prev;
			
			prev = eptr->lo_any.prev;

			/*
			 * Kill this layout element and reset the subdoc height
			 */
			if ( prev != NULL )
			{
				prev->lo_any.next = NULL;
				old_state->end_last_line = prev;
			}
			else
			{
				old_state->line_list = NULL;
				old_state->end_last_line = NULL;
			}
			
			/* The if condition checks to make sure that the linefeed that we just killed
			 * was sticking out of the bottom of the cell.  This fixes bug 81282.
			 */
			if (eptr->lo_linefeed.y + eptr->lo_linefeed.line_height >= old_state->y) {
				/* shrink the document */
				old_state->y -= eptr->lo_linefeed.line_height;
			}

			lo_RecycleElements ( context, old_state, eptr );
		}
	}
	
	dynamic_width = FALSE;
	dynamic_height = FALSE;
	if (subdoc->width == 0)
	{
		dynamic_width = TRUE;
		/*
		 * Subdocs that were dynamically widthed, and which
		 * contained right aligned items, must be relaid out
		 * once their width is determined.
		 */
		eptr = old_state->float_list;
		while (eptr != NULL)
		{
			if ((eptr->type == LO_IMAGE)&&
				(eptr->lo_image.image_attr->alignment == LO_ALIGN_RIGHT))
			{
				old_state->must_relayout_subdoc = TRUE;
				break;
			}
			else if ((eptr->type == LO_SUBDOC)&&
				(eptr->lo_subdoc.alignment == LO_ALIGN_RIGHT))
			{
				old_state->must_relayout_subdoc = TRUE;
				break;
			}
			eptr = eptr->lo_any.next;
		}

		subdoc->width = old_state->max_width;
	}

	/*
	 * Add in the size of the subdoc's borders
	 */
	subdoc->width += (2 * subdoc->border_width);

	/*
	 * Figure the height the subdoc laid out in.
	 * Use this if we were passed no height, or if it is greater
	 * than the passed height.
	 */
	doc_height = old_state->y + (2 * subdoc->border_width);
	if (subdoc->height == 0)
	{
		dynamic_height = TRUE;
		subdoc->height = doc_height;
	}
	else if (subdoc->height < doc_height)
	{
		subdoc->height = doc_height;
	}

	/*
	 * 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 *, old_state->larray_array);
	old_state->line_array = larray_array[0];
	XP_UNLOCK_BLOCK(old_state->larray_array);
}
#endif /* XP_WIN16 */
	XP_LOCK_BLOCK(line_array, LO_Element **, old_state->line_array);
	eptr = line_array[0];
	XP_UNLOCK_BLOCK(old_state->line_array);

	while (eptr != NULL)
	{
		switch (eptr->type)
		{
		    case LO_LINEFEED:
			if ((eptr->lo_linefeed.x + eptr->lo_linefeed.x_offset +
				eptr->lo_linefeed.width) >= (subdoc->width - 1 -
				(2 * subdoc->border_width)))
			{
				eptr->lo_linefeed.width = (subdoc->width - 1 -
					(2 * subdoc->border_width)) -
					(eptr->lo_linefeed.x +
					eptr->lo_linefeed.x_offset);
				if (eptr->lo_linefeed.width < 0)
				{
					eptr->lo_linefeed.width = 0;
				}
			}
#ifdef OLD_DELAY_CENTERED
			if (eptr->lo_linefeed.ele_attrmask &
				LO_ELE_DELAY_CENTERED)
			{
				int32 side_inc;
				LO_Element *c_eptr;

				c_eptr = eptr;

				side_inc = subdoc->width - 1 -
					(2 * subdoc->border_width) -
					(eptr->lo_linefeed.x +
					eptr->lo_linefeed.x_offset);
				side_inc = side_inc / 2;
				if (side_inc > 0)
				{
					c_eptr->lo_linefeed.width -= side_inc;
					if (c_eptr->lo_linefeed.width < 0)
					{
						c_eptr->lo_linefeed.width = 0;
					}
					while ((c_eptr->lo_any.prev != NULL)&&
						(c_eptr->lo_any.prev->type !=
							LO_LINEFEED))
					{
						c_eptr->lo_any.x += side_inc;
						if (c_eptr->type == LO_CELL)
						{
						    lo_ShiftCell(
							(LO_CellStruct *)c_eptr,
							side_inc, 0);
						}
						c_eptr = c_eptr->lo_any.prev;
					}
					c_eptr->lo_any.x += side_inc;
					if (c_eptr->type == LO_CELL)
					{
					    lo_ShiftCell(
						(LO_CellStruct *)c_eptr,
						side_inc, 0);
					}
				}
				eptr->lo_linefeed.ele_attrmask &=
					(~(LO_ELE_DELAY_CENTERED));
			}
#endif /* OLD_DELAY_CENTERED */
			break;
		    /*
		     * This is awful, but any dynamically dimenstioned
		     * subdoc that contains one of these elements
		     * must be relayed out to take care of window
		     * width and height dependencies.
		     */
			/* case LO_HRULE:
		    case LO_SUBDOC:
		    case LO_TABLE:
				old_state->must_relayout_subdoc = TRUE;
			*/

			break;
		    case LO_IMAGE:
/* WILL NEED THIS LATER FOR PERCENT WIDTH IMAGES
			if ((old_state->allow_percent_width == FALSE)||
				(old_state->allow_percent_height == FALSE))
			{
				old_state->must_relayout_subdoc = TRUE;
			}
*/
			break;
		    default:
			break;
		}
		eptr = eptr->lo_any.next;
	}

	/*
	 * Remember: (2 * subdoc->border_width) has already been added to the subdoc
	 * width above...
	 */
	subdoc_width = subdoc->width + (2 * subdoc->border_horiz_space);
	subdoc_height = subdoc->height + (2 * subdoc->border_width) +
		(2 * subdoc->border_vert_space);

	if (old_state->display_blocked != FALSE)
	{
		old_state->display_blocked = FALSE;
	}

	/*
	 * Will this subdoc make the line too wide.
	 */
	if ((state->x + subdoc_width) > state->right_margin)
	{
		line_break = TRUE;
	}
	else
	{
		line_break = FALSE;
	}

	/*
	 * if we are at the beginning of the line.  There is
	 * no point in breaking, we are just too wide.
	 * Also don't break in unwrappedpreformatted text.
	 * Also can't break inside a NOBR section.
	 */
	if ((state->at_begin_line != FALSE)||
		(state->preformatted == PRE_TEXT_YES)||
		(state->breakable == FALSE))
	{
		line_break = FALSE;
	}

	/*
         * break on the subdoc if we have
         * a break.
         */
/* DOn't break in cell
        if (line_break != FALSE)
        {
                lo_SoftLineBreak(context, state, TRUE);
                subdoc->x = state->x;
                subdoc->y = state->y;
        }
*/

	/*
	 * Figure out how to align this subdoc.
	 * baseline_inc is how much to increase the baseline
	 * of previous element of this line.  line_inc is how
	 * much to increase the line height below the baseline.
	 */
	baseline_inc = 0;
	line_inc = 0;
	/*
	 * If we are at the beginning of a line, with no baseline,
	 * we first set baseline and line_height based on the current
	 * font, then place the subdoc.
	 */
	if (state->baseline == 0)
	{
		state->baseline = 0;
	}

	lo_CalcAlignOffsets(state, &text_info, (intn)subdoc->alignment,
		subdoc_width, subdoc_height,
		&subdoc->x_offset, &subdoc->y_offset, &line_inc, &baseline_inc);

	subdoc->x_offset += (int16)subdoc->border_horiz_space;
	subdoc->y_offset += (int32)subdoc->border_vert_space;

	old_state->base_x = subdoc->x + subdoc->x_offset +
		subdoc->border_width;
	old_state->base_y = subdoc->y + subdoc->y_offset +
		subdoc->border_width;

	/*
	 * Clean up state
	state->x = state->x + subdoc->x_offset +
		subdoc_width - subdoc->border_horiz_space;
	state->linefeed_state = 0;
	state->at_begin_line = FALSE;
	state->trailing_space = FALSE;
	state->cur_ele_type = LO_SUBDOC;
	 */

	return(subdoc);
}


void
lo_relayout_recycle(MWContext *context, lo_DocState *state, LO_Element *elist)
{
	LO_LockLayout();
    
	while (elist != NULL)
	{
		LO_Element *eptr;

		eptr = elist;
		elist = elist->lo_any.next;
		eptr->lo_any.next = NULL;

		if (eptr->type == LO_IMAGE)
		{
			eptr->lo_any.next = state->top_state->trash;
			state->top_state->trash = eptr;
		}
		else if (eptr->type == LO_CELL)
		{
			if (eptr->lo_cell.cell_list != NULL)
			{
			    if (eptr->lo_cell.cell_list_end != NULL)
			    {
				eptr->lo_cell.cell_list_end->lo_any.next = NULL;
			    }
			    lo_relayout_recycle(context, state,
					eptr->lo_cell.cell_list);
				eptr->lo_cell.cell_list = NULL;
				eptr->lo_cell.cell_list_end = NULL;
			}
			if (eptr->lo_cell.cell_float_list != NULL)
			{
			    lo_relayout_recycle(context, state,
					eptr->lo_cell.cell_float_list);
				eptr->lo_cell.cell_float_list = NULL;
			}
			lo_RecycleElements(context, state, eptr);
		}
		else
		{
			/*
			 * If this is an embed, tell it that it should
			 * recycle rather than delete itself.
			 */
			if (eptr->type == LO_EMBED)
			{
				NPL_SameElement((LO_EmbedStruct*)eptr);
			}
			lo_RecycleElements(context, state, eptr);
		}
	}
	LO_UnlockLayout();
}


static void
lo_cleanup_state(MWContext *context, lo_DocState *state)
{
	LO_Element **line_array;

	if (state == NULL)
	{
		return;
	}

	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_relayout_recycle(context, state, 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)
	{
		lo_relayout_recycle(context, state, 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)
		{
			lo_relayout_recycle(context, state, eptr);
		}
		XP_UNLOCK_BLOCK(state->line_array);
		XP_FREE_BLOCK(state->line_array);
	}

	XP_DELETE(state);
}


static lo_FormData *
lo_merge_form_data(lo_FormData *new_form_list, lo_FormData *hold_form_list)
{
	intn i;
	LO_FormElementStruct **new_ele_list;
	LO_FormElementStruct **hold_ele_list;

	PA_LOCK(new_ele_list, LO_FormElementStruct **,
			new_form_list->form_elements);
	PA_LOCK(hold_ele_list, LO_FormElementStruct **,
			hold_form_list->form_elements);
	for (i=0; i<new_form_list->form_ele_cnt; i++)
	{
		if (hold_ele_list[i] != new_ele_list[i])
		{
#ifdef MOCHA
			if (new_ele_list[i]->mocha_object == NULL)
			{
				new_ele_list[i]->mocha_object
				    = hold_ele_list[i]->mocha_object;
			}
#endif
			hold_ele_list[i] = new_ele_list[i];
		}
	}
	PA_UNLOCK(hold_form_list->form_elements);
	PA_UNLOCK(new_form_list->form_elements);

#ifdef MOCHA
	/* XXX sometimes the second pass does not reflect a form object! */
	if (new_form_list->mocha_object != NULL)
	{
		hold_form_list->mocha_object = new_form_list->mocha_object;
	}
#endif
	return(hold_form_list);
}


/*
 * Serious table magic.  Given a table cell subdoc,
 * redo the layout to the new width from the stored tag list,
 * and create a whole new subdoc, which is returned.
 */
LO_SubDocStruct *
lo_RelayoutCaptionSubdoc(MWContext *context, lo_DocState *state, lo_TableCaption *caption,
	LO_SubDocStruct *subdoc, int32 width, Bool is_a_header)
{
	int32 first_height;
	lo_TopState *top_state;
	lo_DocState *old_state;
	lo_DocState *new_state;
	PA_Tag *tag_list;
	PA_Tag *tag_ptr;
	PA_Tag *tag_end_ptr;
	int32 doc_id;
	Bool allow_percent_width;
	Bool allow_percent_height;
	int32 hold_form_ele_cnt;
	int32 hold_form_data_index;
	intn hold_form_id;
	intn hold_current_form_num;
	Bool hold_in_form;
	lo_FormData *hold_form_list;
	int32 hold_embed_global_index;
	int32 original_tag_count;
	intn hold_url_list_len;
	NET_ReloadMethod save_force;
	Bool save_diff_state;
	int32 save_state_pushes;
	int32 save_state_pops;
	lo_DocLists *doc_lists;
	int32 hold_image_list_count;
        int32 hold_applet_list_count;
        int32 hold_embed_list_count;
	int32 hold_current_layer_num;

	/*
	 * Relayout is NOT allowed to block on images, so never
	 * have the forced reload flag set.
	 */
	save_force = state->top_state->force_reload;
	state->top_state->force_reload = NET_CACHE_ONLY_RELOAD;

#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_RelayoutSubdoc called\n");
#endif /* LOCAL_DEBUG */

	top_state = state->top_state;
	old_state = (lo_DocState *) subdoc->state;
	
	/*
	 * We are going to reuse this subdoc element instead
	 * of allocating a new one.
	 */
	/* subdoc->state = NULL; */
	subdoc->width = width;
	subdoc->height = 0;

	doc_lists = lo_GetCurrentDocLists(state);
	
	/*
	 * If this subdoc contained form elements.  We want to reuse
	 * them without messing up the order of later form elements in
	 * other subdocs.
	 *
	 * We assume that relaying out the doc will create the exact
	 * same number of form elements in the same order as the first time.
	 * so we reset global form counters to before this subdoc
	 * was ever laid out, saving the current counts to restore later.
	 */
	if (doc_lists->form_list != NULL)
	{
		lo_FormData *form_list;
		lo_FormData *tmp_fptr;

		hold_form_id = old_state->form_id;
		hold_current_form_num = doc_lists->current_form_num;
		form_list = doc_lists->form_list;
		hold_form_list = NULL;
		while ((form_list != NULL)&&
			(form_list->id > hold_form_id))
		{
			tmp_fptr = form_list;
			form_list = form_list->next;
			tmp_fptr->next = hold_form_list;
			hold_form_list = tmp_fptr;
		}
		doc_lists->form_list = form_list;
		doc_lists->current_form_num = hold_form_id;
		if (form_list != NULL)
		{
			hold_form_ele_cnt = form_list->form_ele_cnt;
			form_list->form_ele_cnt = old_state->form_ele_cnt;
		}
		else
		{
			hold_form_ele_cnt = 0;
		}
	}
	else
	{
		hold_form_id = 0;
		hold_form_ele_cnt = 0;
		hold_form_list = NULL;
		hold_current_form_num = 0;
	}

	/*
	 * We're going to be deleting and then recreating the contents 
	 * of this subdoc.  We want the newly-created embeds to have
	 * the same embed indices as their recycled counterparts, so
	 * we reset the master embed index in the top_state to be the
	 * value it held at the time the old subdoc was created. When
	 * we're finished creating the new subdoc, the master index
	 * should be back to its original value (but just in case we
	 * save that value in a local variable here).
	 */
	hold_embed_global_index = top_state->embed_count;
	top_state->embed_count = old_state->embed_count_base;

	/* ditto here for the last comment.  We are trying to keep
	 * a tag count that reflects the order of tags coming in
 	 * on the stream.  We need that count to be correct across
	 * multiple relayout instances so we restore the top state
	 * count with the saved state
	 */
	original_tag_count = top_state->tag_count;
	top_state->tag_count = state->beginning_tag_count;

	/*
	 * Same goes for anchors and images
	 */
	hold_url_list_len = doc_lists->url_list_len;
	doc_lists->url_list_len = old_state->url_count_base;

	hold_image_list_count = doc_lists->image_list_count;
	doc_lists->image_list_count = old_state->image_list_count_base;

	hold_applet_list_count = doc_lists->applet_list_count;
	doc_lists->applet_list_count = old_state->applet_list_count_base;
	
	hold_embed_list_count = doc_lists->embed_list_count;
	doc_lists->embed_list_count = old_state->embed_list_count_base;

	hold_current_layer_num = top_state->current_layer_num;
	top_state->current_layer_num = old_state->current_layer_num_base;
	
	/*
	 * Save whether we are in a form or not, and restore
	 * to what we were when the subdoc was started.
	 */
	hold_in_form = top_state->in_form;
	top_state->in_form = old_state->start_in_form;

	if (top_state->savedData.FormList != NULL)
	{
		lo_SavedFormListData *all_form_ele;

		all_form_ele = top_state->savedData.FormList;
		hold_form_data_index = all_form_ele->data_index;
		all_form_ele->data_index = old_state->form_data_index;
	}
	else
	{
		hold_form_data_index = 0;
	}

	/*
	 * Still variable height, but we know the width now.
	 */
	first_height = FEUNITS_Y(10000, context);
	allow_percent_height = FALSE;
	allow_percent_width = TRUE;

	/*
	 * Get a new sub-state to create the new subdoc in.
	 */
	/*
	new_state = lo_NewLayout(context, width, first_height, 0, 0, NULL);
	*/
	lo_reuse_current_state(context, subdoc->state, width,
		first_height, 0, 0, FALSE);

	new_state = subdoc->state;
	subdoc->state = NULL;

	
	if (new_state == NULL)
	{
		state->top_state->force_reload = save_force;
		return(subdoc);
	}

	new_state->end_last_line = NULL;
	/*
	if (old_state->is_a_subdoc == SUBDOC_CAPTION)
	{
		new_state->is_a_subdoc = SUBDOC_CAPTION;
	}
	else
	{
		new_state->is_a_subdoc = SUBDOC_CELL;
	}
	*/
	new_state->is_a_subdoc = SUBDOC_CAPTION;

	lo_InheritParentColors(context, new_state, state);
	new_state->allow_percent_width = allow_percent_width;
	new_state->allow_percent_height = allow_percent_height;
	/*
	 * In relaying out subdocs, we NEVER link back up subdoc tags
	 */
	new_state->subdoc_tags = NULL;
	new_state->subdoc_tags_end = NULL;

	/*
	 * Initialize other new state sundries.
	 */
	new_state->base_x = 0;
	new_state->base_y = 0;
	new_state->display_blocked = TRUE;
	if (subdoc->width == 0)
	{
		new_state->delay_align = TRUE;
	}

	new_state->win_left = 0;
	new_state->win_right = 0;
	new_state->x = new_state->win_left;
	new_state->y = 0;
	new_state->max_width = new_state->x + 1;
	new_state->left_margin = new_state->win_left;
	new_state->right_margin = new_state->win_width - new_state->win_right;
	new_state->list_stack->old_left_margin = new_state->left_margin;
	new_state->list_stack->old_right_margin = new_state->right_margin;

	/* we don't need min widths during relayout */
	new_state->need_min_width = FALSE;

	/* reset line_height stack */
	while (new_state->line_height_stack)
		lo_PopLineHeight(new_state);

	/* 
	 * Initialize the alignment stack for this state
	 * to match the caption alignment.
	 */
	if (subdoc->horiz_alignment != LO_ALIGN_LEFT)
	{
		lo_PushAlignment(new_state, P_TABLE_DATA, subdoc->horiz_alignment);
	}

	state->sub_state = new_state;

	state->current_ele = (LO_Element *)subdoc;
	
	if (is_a_header != FALSE)
	{
		LO_TextAttr *old_attr;
		LO_TextAttr *attr;
		LO_TextAttr tmp_attr;

		old_attr = new_state->font_stack->text_attr;
		lo_CopyTextAttr(old_attr, &tmp_attr);
		tmp_attr.fontmask |= LO_FONT_BOLD;
		attr = lo_FetchTextAttr(new_state, &tmp_attr);

		lo_PushFont(new_state, P_TABLE_HEADER, attr);
	}

	/*
	 * Move our current state down into the new sub-state.
	 * Fetch the tag list from the old subdoc's state in preparation
	 * for relayout.
	 */
	state = new_state;

	/*
	tag_ptr = old_state->subdoc_tags;
	tag_end_ptr = old_state->subdoc_tags_end;
	old_state->subdoc_tags = NULL;
	old_state->subdoc_tags_end = NULL;
	if (tag_end_ptr != NULL)
	{
		tag_end_ptr = tag_end_ptr->next;
	}
	*/

	/*
	 * Clean up memory used by old subdoc state.
	 */
	/*
	lo_cleanup_state(context, old_state);
	*/

#if 0    /* Doesn't need to happen any more because we do non-destructive reflow
	/*
	 * Save our parent's state levels
	 */
	save_diff_state = top_state->diff_state;
	save_state_pushes = top_state->state_pushes;
	save_state_pops = top_state->state_pops;

	while (tag_ptr != tag_end_ptr)
	{
		PA_Tag *tag;
		lo_DocState *sub_state;
		lo_DocState *up_state;
		lo_DocState *tmp_state;
		Bool may_save;

		tag = tag_ptr;
		tag_ptr = tag_ptr->next;
		tag->next = NULL;
		tag_list = tag_ptr;

		up_state = NULL;
		sub_state = state;
		while (sub_state->sub_state != NULL)
		{
			up_state = sub_state;
			sub_state = sub_state->sub_state;
		}

		if ((sub_state->is_a_subdoc == SUBDOC_CELL)||
			(sub_state->is_a_subdoc == SUBDOC_CAPTION))
		{
			may_save = TRUE;
		}
		else
		{
			may_save = FALSE;
		}

		/*
		 * Reset these so we can tell if anything happened
		 */
		top_state->diff_state = FALSE;
		top_state->state_pushes = 0;
		top_state->state_pops = 0;

#ifdef MOCHA
		sub_state->in_relayout = TRUE;
#endif
		lo_LayoutTag(context, sub_state, tag);
		tmp_state = lo_CurrentSubState(state);
#ifdef MOCHA
		if (tmp_state == sub_state)
		{
			sub_state->in_relayout = FALSE;
		}
#endif

		if (may_save != FALSE)
		{
			int32 state_diff;
			
			/* how has our state level changed? */
			state_diff = top_state->state_pushes - top_state->state_pops;
			
			/*
			 * That tag popped us up one state level.  If this new
			 * state is still a subdoc, save the tag there.
			 */
			if (state_diff == -1)
			{
				if ((tmp_state->is_a_subdoc == SUBDOC_CELL)||
				    (tmp_state->is_a_subdoc == SUBDOC_CAPTION))
				{
                    /* if we just popped a table we need to insert
                     * a dummy end tag to pop the dummy start tag
                     * we shove on the stack after createing a table
                     */
   					PA_Tag *new_tag = LO_CreateStyleSheetDummyTag(tag);
					if(new_tag)
					{
						lo_SaveSubdocTags(context, tmp_state, new_tag);
					}

				    lo_SaveSubdocTags(context, tmp_state, tag);
				}
				else
				{
				    PA_FreeTag(tag);
				}
			}
			/*
			 * Else that tag put us in a new subdoc on the same
			 * level.  It needs to be saved one level up,
			 * if the parent is also a subdoc.
			 */
			else if (( up_state != NULL ) &&
				( top_state->diff_state != FALSE ) &&
				( state_diff == 0 ))
			{
				if ((up_state->is_a_subdoc == SUBDOC_CELL)||
				     (up_state->is_a_subdoc == SUBDOC_CAPTION))
				{
				    lo_SaveSubdocTags(context, up_state, tag);
				}
				else
				{
				    PA_FreeTag(tag);
				}
			}
			/*
			 * Else we are still in the same subdoc
			 */
			else if (( top_state->diff_state == FALSE ) &&
				( state_diff == 0 ))
			{
				lo_SaveSubdocTags(context, sub_state, tag);
			}
			/*
			 * Else that tag started a new, nested subdoc.
			 * Add the starting tag to the parent.
			 */
			else if (( state_diff == 1 ))
			{
				lo_SaveSubdocTags(context, sub_state, tag);
				/*
				 * Since we have extended the parent chain,
				 * we need to reset the child to the new
				 * parent end-chain.
				 */
				if ((tmp_state->is_a_subdoc == SUBDOC_CELL)||
				    (tmp_state->is_a_subdoc == SUBDOC_CAPTION))
				{
					PA_Tag *new_tag;
					
					tmp_state->subdoc_tags =
						sub_state->subdoc_tags_end;

					/* add an aditional dummy tag so that style sheets
					 * can use it to query styles from for this entry
					 * that created a table
					 */
					new_tag = LO_CreateStyleSheetDummyTag(tag);
					if(new_tag)
					{
						lo_SaveSubdocTags(context, tmp_state, new_tag);
					}
				}
			}
			/*
			 * This can never happen.
			 */
			else
			{
				PA_FreeTag(tag);
			}
		}
		tag_ptr = tag_list;
	}

	/*
	 * Restore our parent's state levels
	 */
	top_state->diff_state = save_diff_state;
	top_state->state_pushes = save_state_pushes;
	top_state->state_pops = save_state_pops;
#endif

	/*
	 * Link the end of this subdoc's tag chain back to
	 * its parent.  The beginning should have never been
	 * unlinked from the parent.
	 */
	/*
	if (state->subdoc_tags_end != NULL)
	{
		state->subdoc_tags_end->next = tag_end_ptr;
	}
	*/

	lo_rl_ReflowDocState( context, state );

	/*
	 * makes sure we are at the bottom
	 * of everything in the document.
	 */
	/*
	lo_CloseOutLayout(context, state);
	*/

	lo_EndLayoutDuringReflow( context, state );

	old_state = state;
	/*
	 * Get the unique document ID, and retreive this
	 * documents layout state.
	 */
	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	state = top_state->doc_state;

	while ((state->sub_state != NULL)&&
		(state->sub_state != old_state))
	{
		state = state->sub_state;
	}

	/*
	 * Ok, now reset the global form element counters
	 * to their original values.
	 */
	if ((doc_lists->form_list != NULL)||(hold_form_list != NULL))
	{
		lo_FormData *form_list;
		lo_FormData *new_form_list;
		lo_FormData *tmp_fptr;

		/*
		 * Remove any new forms created in this subdocs to a
		 * separate list.
		 */
		form_list = doc_lists->form_list;
		new_form_list = NULL;
		while ((form_list != NULL)&&
			(form_list->id > hold_form_id))
		{
			tmp_fptr = form_list;
			form_list = form_list->next;
			tmp_fptr->next = new_form_list;
			new_form_list = tmp_fptr;
		}

		/*
		 * Restore the element count in the form we started in
		 * because the subdoc may have left it half finished.
		 */
		if (form_list != NULL)
		{
			form_list->form_ele_cnt = hold_form_ele_cnt;
		}

		/*
		 * Merge the newly created forms with the old ones
		 * since the new ones may have partially complete
		 * data.
		 */
		while ((new_form_list != NULL)&&(hold_form_list != NULL))
		{
			tmp_fptr = lo_merge_form_data(new_form_list,
					hold_form_list);
			new_form_list = new_form_list->next;
			hold_form_list = hold_form_list->next;
			tmp_fptr->next = form_list;
			form_list = tmp_fptr;
		}

		/*
		 * Add back on forms that are from later subdocs.
		 */
		while (hold_form_list != NULL)
		{
			tmp_fptr = hold_form_list;
			hold_form_list = hold_form_list->next;
			tmp_fptr->next = form_list;
			form_list = tmp_fptr;
		}

		doc_lists->form_list = form_list;
		doc_lists->current_form_num = hold_current_form_num;
	}

	/*
	 * Restore in form status to what is
	 * was before this relayout.
	 */
	top_state->in_form = hold_in_form;

	if (top_state->savedData.FormList != NULL)
	{
		lo_SavedFormListData *all_form_ele;

		all_form_ele = top_state->savedData.FormList;
		all_form_ele->data_index = hold_form_data_index;
	}

	/*
	 * The master embed index is typically now be back
	 * to its original value, but might not be if we
	 * only had to relayout some (not all) of the embeds
	 * in this subdoc.  So, make sure it's set back to
	 * its original value here.
	 */
	top_state->embed_count = hold_embed_global_index;

	/* verify that the tag count is still correct */
	top_state->tag_count = original_tag_count;

	/*
	 * Likewise for the anchor list.
	 */
	doc_lists->url_list_len = hold_url_list_len;
	doc_lists->image_list_count = hold_image_list_count;
        doc_lists->applet_list_count = hold_applet_list_count;
        doc_lists->embed_list_count = hold_embed_list_count;
	top_state->current_layer_num = hold_current_layer_num;

	subdoc = NULL;
	if ((state != old_state)&&
		(state->current_ele != NULL))
	{
		subdoc = lo_EndCellSubDoc(context, state,
				old_state, state->current_ele, TRUE);
		state->sub_state = NULL;
		state->current_ele = NULL;
/*
		if ((state->is_a_subdoc == SUBDOC_CELL)||
			(state->is_a_subdoc == SUBDOC_CAPTION))
		{
			if (old_state->subdoc_tags_end != NULL)
			{
				state->subdoc_tags_end =
					old_state->subdoc_tags_end;
			}
		}
*/
	}

	old_state->must_relayout_subdoc = FALSE;

	state->top_state->force_reload = save_force;
	return(subdoc);
}


LO_CellStruct *
lo_RelayoutCell(MWContext *context, lo_DocState *state,
	LO_SubDocStruct *subdoc, lo_TableCell *cell_ptr,
	LO_CellStruct *cell, int32 width, Bool is_a_header,
	Bool relayout)
{
	LO_CellStruct *cell_ele;
	int32 first_height;
	lo_TopState *top_state;
	lo_DocState *old_state;
	lo_DocState *new_state;
	PA_Tag *tag_list;
	PA_Tag *tag_ptr;
	PA_Tag *tag_end_ptr;
	int32 doc_id;
	Bool allow_percent_width;
	Bool allow_percent_height;
	int32 hold_form_ele_cnt;
	int32 hold_form_data_index;
	intn hold_form_id;
	intn hold_current_form_num;
	Bool hold_in_form;
	lo_FormData *hold_form_list;
	int32 hold_embed_global_index;
	int32 original_tag_count;
	intn hold_url_list_len;
	NET_ReloadMethod save_force;
	Bool save_diff_state;
	int32 save_state_pushes;
	int32 save_state_pops;
	lo_DocLists *doc_lists;
	int32 hold_image_list_count;
        int32 hold_applet_list_count;
        int32 hold_embed_list_count;
	int32 hold_current_layer_num;
	LO_Element * elem_list;

	/*
	 * Relayout is NOT allowed to block on images, so never
	 * have the forced reload flag set.
	 */
	save_force = state->top_state->force_reload;
	state->top_state->force_reload = NET_CACHE_ONLY_RELOAD;

	top_state = state->top_state;
	
	/*
	 * We are going to reuse this subdoc element instead
	 * of allocating a new one.
	lo_reuse_current_subdoc(context, subdoc);
	subdoc->state = NULL;
	 */
	subdoc->width = width;
	subdoc->height = 0;

	subdoc->horiz_alignment = cell_ptr->horiz_alignment;

	doc_lists = lo_GetCurrentDocLists(state);
	
	/*
	 * If this subdoc contained form elements.  We want to reuse
	 * them without messing up the order of later form elements in
	 * other subdocs.
	 *
	 * We assume that relaying out the doc will create the exact
	 * same number of form elements in the same order as the first time.
	 * so we reset global form counters to before this subdoc
	 * was ever laid out, saving the current counts to restore later.
	 */
	if (doc_lists->form_list != NULL)
	{
		lo_FormData *form_list;
		lo_FormData *tmp_fptr;

		hold_form_id = cell_ptr->form_id;
		hold_current_form_num = doc_lists->current_form_num;
		form_list = doc_lists->form_list;
		hold_form_list = NULL;
		while ((form_list != NULL)&&
			(form_list->id > hold_form_id))
		{
			tmp_fptr = form_list;
			form_list = form_list->next;
			tmp_fptr->next = hold_form_list;
			hold_form_list = tmp_fptr;
		}
		doc_lists->form_list = form_list;
		doc_lists->current_form_num = hold_form_id;
		if (form_list != NULL)
		{
			hold_form_ele_cnt = form_list->form_ele_cnt;
			form_list->form_ele_cnt = cell_ptr->form_ele_cnt;
		}
		else
		{
			hold_form_ele_cnt = 0;
		}
	}
	else
	{
		hold_form_id = 0;
		hold_form_ele_cnt = 0;
		hold_form_list = NULL;
		hold_current_form_num = 0;
	}

	/*
	 * We're going to be deleting and then recreating the contents 
	 * of this subdoc.  We want the newly-created embeds to have
	 * the same embed indices as their recycled counterparts, so
	 * we reset the master embed index in the top_state to be the
	 * value it held at the time the old subdoc was created. When
	 * we're finished creating the new subdoc, the master index
	 * should be back to its original value (but just in case we
	 * save that value in a local variable here).
	 */
	hold_embed_global_index = top_state->embed_count;
	top_state->embed_count = cell_ptr->embed_count_base;

	/* same for tag count */
	original_tag_count = top_state->tag_count;
	top_state->tag_count = cell_ptr->beginning_tag_count;

	/*
	 * Same goes for anchors and images
	 */
	hold_url_list_len = doc_lists->url_list_len;
	doc_lists->url_list_len = cell_ptr->url_count_base;

	hold_image_list_count = doc_lists->image_list_count;
	doc_lists->image_list_count = cell_ptr->image_list_count_base;

	hold_applet_list_count = doc_lists->applet_list_count;
	doc_lists->applet_list_count = cell_ptr->applet_list_count_base;
	
	hold_embed_list_count = doc_lists->embed_list_count;
	doc_lists->embed_list_count = cell_ptr->embed_list_count_base;

	hold_current_layer_num = top_state->current_layer_num;
	top_state->current_layer_num = cell_ptr->current_layer_num_base;

	/*
	 * Save whether we are in a form or not, and restore
	 * to what we were when the subdoc was started.
	 */
	hold_in_form = top_state->in_form;
	top_state->in_form = cell_ptr->start_in_form;

	if (top_state->savedData.FormList != NULL)
	{
		lo_SavedFormListData *all_form_ele;

		all_form_ele = top_state->savedData.FormList;
		hold_form_data_index = all_form_ele->data_index;
		all_form_ele->data_index = cell_ptr->form_data_index;
	}
	else
	{
		hold_form_data_index = 0;
	}

	/*
	 * Still variable height, but we know the width now.
	 */
	first_height = FEUNITS_Y(10000, context);
	allow_percent_height = FALSE;
	allow_percent_width = TRUE;

	/*
	 * Get a new sub-state to create the new subdoc in.
	 */
	lo_reuse_current_state(context, subdoc->state,
		width, first_height, 0, 0, TRUE);
	new_state = subdoc->state;
	subdoc->state = NULL;


	if (new_state == NULL)
	{
		state->top_state->force_reload = save_force;
		return(cell);
	}
	if (cell_ptr->is_a_subdoc == SUBDOC_CAPTION)
	{
		new_state->is_a_subdoc = SUBDOC_CAPTION;
	}
	else
	{
		new_state->is_a_subdoc = SUBDOC_CELL;
	}

	lo_InheritParentState(context, new_state, state);
	new_state->allow_percent_width = allow_percent_width;
	new_state->allow_percent_height = allow_percent_height;
	/*
	 * In relaying out subdocs, we NEVER link back up subdoc tags
	 */
	new_state->subdoc_tags = NULL;
	new_state->subdoc_tags_end = NULL;

	/*
	 * Initialize other new state sundries.
	 */
	new_state->base_x = 0;
	new_state->base_y = 0;
	new_state->display_blocked = TRUE;
	if (subdoc->width == 0)
	{
		new_state->delay_align = TRUE;
	}

	new_state->win_left = 0;
	new_state->win_right = 0;
	new_state->x = new_state->win_left;
	new_state->y = 0;
	new_state->max_width = new_state->x + 1;
	new_state->left_margin = new_state->win_left;
	new_state->right_margin = new_state->win_width - new_state->win_right;
	new_state->list_stack->old_left_margin = new_state->left_margin;
	new_state->list_stack->old_right_margin = new_state->right_margin;
	
	/* we don't need min widths during relayout */
	new_state->need_min_width = FALSE;
    
    /* reset line_height stack */
    while(new_state->line_height_stack)
        lo_PopLineHeight(new_state);
    
    /*
	 * Initialize the alignment stack for this state
	 * to match the caption alignment.
	 */
	if (subdoc->horiz_alignment != LO_ALIGN_LEFT)
	{
		lo_PushAlignment(new_state, P_TABLE_DATA, subdoc->horiz_alignment);
	}

	state->sub_state = new_state;

	state->current_ele = (LO_Element *)subdoc;

	if (is_a_header != FALSE)
	{
		LO_TextAttr *old_attr;
		LO_TextAttr *attr;
		LO_TextAttr tmp_attr;

		old_attr = new_state->font_stack->text_attr;
		lo_CopyTextAttr(old_attr, &tmp_attr);
		tmp_attr.fontmask |= LO_FONT_BOLD;
		attr = lo_FetchTextAttr(new_state, &tmp_attr);

		lo_PushFont(new_state, P_TABLE_HEADER, attr);
	}

	/*
	 * Move our current state down into the new sub-state.
	 * Fetch the tag list from the old subdoc's state in preparation
	 * for relayout.
	 */
	
	state = new_state;
	/*
	tag_ptr = cell_ptr->subdoc_tags;
	tag_end_ptr = cell_ptr->subdoc_tags_end;
	cell_ptr->subdoc_tags = NULL;
	cell_ptr->subdoc_tags_end = NULL;
	
	if (tag_end_ptr != NULL)
	{
		tag_end_ptr = tag_end_ptr->next;
	}
	*/

	/*
	 * Copy some cell attribute state from the old cell to the subdoc
	 * so that we retain the correct state. Make sure that the bg_color
	 * doesn't get freed.
	 */
	subdoc->horiz_alignment = cell_ptr->horiz_alignment;
	subdoc->vert_alignment = cell_ptr->vert_alignment;
	subdoc->backdrop = cell->backdrop;
	/*
	cell->backdrop.bg_color = NULL;
	cell->backdrop.url = NULL;
	*/
	
	/*
	 * Clean up memory used by old cell.
	 */
	/*
	elem_list = cell->cell_list;
	cell->next = NULL;
	cell->cell_list = NULL;
	cell->cell_list_end = NULL;
	lo_relayout_recycle(context, state, (LO_Element *)cell);
	*/

	/*
	 * Relayout all the goodies
	 */
	/*
	lo_RelayoutTags(context, state, tag_ptr, tag_end_ptr, elem_list);
	*/

	/*
	 * Link the end of this subdoc's tag chain back to
	 * its parent.  The beginning should have never been
	 * unlinked from the parent.
	 */
	/*
	if (state->subdoc_tags_end != NULL)
	{
		state->subdoc_tags_end->next = tag_end_ptr;
	}
	*/

	/*
	 * makes sure we are at the bottom
	 * of everything in the document.
	 */

	lo_rl_ReflowCell( context, state, cell );
	
	/* Replaced with lo_EndLayoutDuringReflow()
	lo_CloseOutLayout(context, state);
	*/
	
	lo_EndLayoutDuringReflow( context, state );
	

	old_state = state;
	/*
	 * Get the unique document ID, and retreive this
	 * documents layout state.
	 */
	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	state = top_state->doc_state;

	while ((state->sub_state != NULL)&&
		(state->sub_state != old_state))
	{
		state = state->sub_state;
	}

	/*
	 * Ok, now reset the global form element counters
	 * to their original values.
	 */
	if ((doc_lists->form_list != NULL)||(hold_form_list != NULL))
	{
		lo_FormData *form_list;
		lo_FormData *new_form_list;
		lo_FormData *tmp_fptr;

		/*
		 * Remove any new forms created in this subdocs to a
		 * separate list.
		 */
		form_list = doc_lists->form_list;
		new_form_list = NULL;
		while ((form_list != NULL)&&
			(form_list->id > hold_form_id))
		{
			tmp_fptr = form_list;
			form_list = form_list->next;
			tmp_fptr->next = new_form_list;
			new_form_list = tmp_fptr;
		}

		/*
		 * Restore the element count in the form we started in
		 * because the subdoc may have left it half finished.
		 */
		if (form_list != NULL)
		{
			form_list->form_ele_cnt = hold_form_ele_cnt;
		}

		/*
		 * Merge the newly created forms with the old ones
		 * since the new ones may have partially complete
		 * data.
		 */
		while ((new_form_list != NULL)&&(hold_form_list != NULL))
		{
			tmp_fptr = lo_merge_form_data(new_form_list,
					hold_form_list);
			new_form_list = new_form_list->next;
			hold_form_list = hold_form_list->next;
			tmp_fptr->next = form_list;
			form_list = tmp_fptr;
		}

		/*
		 * Add back on forms that are from later subdocs.
		 */
		while (hold_form_list != NULL)
		{
			tmp_fptr = hold_form_list;
			hold_form_list = hold_form_list->next;
			tmp_fptr->next = form_list;
			form_list = tmp_fptr;
		}

		doc_lists->form_list = form_list;
		doc_lists->current_form_num = hold_current_form_num;
	}

	/*
	 * Restore in form status to what is
	 * was before this relayout.
	 */
	top_state->in_form = hold_in_form;

	if (top_state->savedData.FormList != NULL)
	{
		lo_SavedFormListData *all_form_ele;

		all_form_ele = top_state->savedData.FormList;
		all_form_ele->data_index = hold_form_data_index;
	}

	/*
	 * The master embed index is typically now be back
	 * to its original value, but might not be if we
	 * only had to relayout some (not all) of the embeds
	 * in this subdoc.  So, make sure it's set back to
	 * its original value here.
	 */
	top_state->embed_count = hold_embed_global_index;
	
	/* ditto for tag_count */
	top_state->tag_count = original_tag_count;

	/*
	 * Likewise for the anchor list and image list.
	 */
	doc_lists->url_list_len = hold_url_list_len;
	doc_lists->image_list_count = hold_image_list_count;
        doc_lists->applet_list_count = hold_applet_list_count;
        doc_lists->embed_list_count = hold_embed_list_count;
	top_state->current_layer_num = hold_current_layer_num;
	
	subdoc = NULL;
	cell_ele = NULL;
	if ((state != old_state)&&
		(state->current_ele != NULL))
	{
		lo_DocState *subdoc_state;
		int32 dx, dy;
		int32 base_x, base_y;

		subdoc = lo_EndCellSubDoc(context, state,
				old_state, state->current_ele, TRUE);
		state->sub_state = NULL;
		state->current_ele = NULL;
/*
		if ((state->is_a_subdoc == SUBDOC_CELL)||
			(state->is_a_subdoc == SUBDOC_CAPTION))
		{
			if (old_state->subdoc_tags_end != NULL)
			{
				state->subdoc_tags_end =
					old_state->subdoc_tags_end;
			}
		}
*/
		subdoc_state = (lo_DocState *)(subdoc->state);
		cell_ptr->start_in_form = subdoc_state->start_in_form;
		cell_ptr->form_id = subdoc_state->form_id;
		cell_ptr->form_ele_cnt = subdoc_state->form_ele_cnt;
		cell_ptr->form_data_index = subdoc_state->form_data_index;
		cell_ptr->embed_count_base = subdoc_state->embed_count_base;
		cell_ptr->url_count_base = subdoc_state->url_count_base;
		cell_ptr->image_list_count_base = subdoc_state->image_list_count_base;
		cell_ptr->applet_list_count_base = subdoc_state->applet_list_count_base;
		cell_ptr->embed_list_count_base = subdoc_state->embed_list_count_base;                
		cell_ptr->current_layer_num_base = subdoc_state->current_layer_num_base;
		cell_ptr->must_relayout = subdoc_state->must_relayout_subdoc;
		cell_ptr->is_a_subdoc = subdoc_state->is_a_subdoc;
		/*
		cell_ptr->subdoc_tags = subdoc_state->subdoc_tags;
		cell_ptr->subdoc_tags_end = subdoc_state->subdoc_tags_end;
		*/
		subdoc_state->subdoc_tags = NULL;
		subdoc_state->subdoc_tags_end = NULL;
		cell_ptr->max_y = subdoc_state->y;
		cell_ptr->horiz_alignment = subdoc->horiz_alignment;
		cell_ptr->vert_alignment = subdoc->vert_alignment;
			
		/*
		cell_ele = lo_SmallSquishSubDocToCell(context, state, subdoc,
				&dx, &dy);
		*/

		cell_ele = cell_ptr->cell;
		lo_CreateCellFromSubDoc(context, state, subdoc, cell_ele, &dx, &dy);

		lo_cleanup_old_state(subdoc->state);
		base_x = cell_ele->x + cell_ele->x_offset + cell_ele->border_width;
		base_y = cell_ele->y + cell_ele->y_offset + cell_ele->border_width;
		dx -= base_x;
		dy -= base_y;
		cell_ptr->cell_base_x = dx;
		cell_ptr->cell_base_y = dy;
	}

	XP_ASSERT ( cell_ele != NULL );

	old_state->must_relayout_subdoc = FALSE;

	state->top_state->force_reload = save_force;

	/* pop the style stack once to get rid of the extra dummy tag
	 * that we added to the stack to force styles on the begin
	 * subdoc in relayout
	 */
	if (relayout == FALSE)
	{
		LO_PopStyleTagByIndex(context, &state, P_TABLE_DATA, 0);
	}

	return(cell_ele);
}

/*
 * if normal borders is TRUE draw cell borders if the rest of
 * the table has borders.  If FALSE, never draw cell borders
 */
void
lo_BeginTableCellAttributes(MWContext *context, 
 							lo_DocState *state, 
 							lo_TableRec *table,
 							char * colspan_attr,
							char * rowspan_attr,
 							char * nowrap_attr,
 							char * bgcolor_attr,
 							char * background_attr,
                            lo_TileMode tile_mode,
 							char * valign_attr,
 							char * halign_attr,
  							char * width_attr,
							char * height_attr,
							Bool is_a_header,
							Bool normal_borders)
{
	lo_TableRow *table_row;
	lo_TableCell *table_cell;
	int32 val;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_BeginTableCell called\n");
#endif /* LOCAL_DEBUG */

	table_row = table->row_ptr;

	table_cell = XP_NEW(lo_TableCell);
	if (table_cell == NULL)
	{
		return;
	}

	if (state->is_a_subdoc != SUBDOC_NOT) 
	{
		table_cell->in_nested_table = TRUE;
	}
	else 
	{
		table_cell->in_nested_table = FALSE;
	}	

	/* Copied to lo_InitForBeginCell()
	table_cell->must_relayout = FALSE;
	*/
	table_cell->subdoc_tags = NULL;
	table_cell->subdoc_tags_end = NULL;

	/* Copied to lo_InitForBeginCell()
	table_cell->cell_done = FALSE;
	*/
	table_cell->nowrap = FALSE;
	table_cell->is_a_header = is_a_header;
	table_cell->percent_width = 0;
	table_cell->percent_height = 0;
	table_cell->specified_width = 0;
	table_cell->specified_height = 0;
	table_cell->min_width = 0;
	table_cell->max_width = 0;
	table_cell->height = 0;
	table_cell->baseline = 0;
	table_cell->rowspan = 1;
	table_cell->colspan = 1;
	table_cell->cell = NULL;
	table_cell->next = NULL;
	table_cell->beginning_tag_count = state->top_state->tag_count;

	lo_InitForBeginCell( table_row, table_cell );
	
    if (table->current_subdoc == NULL)
	{
		XP_DELETE(table_cell);
		return;
	}

	if (colspan_attr)
	{
		val = XP_ATOI(colspan_attr);
		if (val < 1)
		{
			val = 1;
		}
		/*
		 * Prevent huge colspan
		 */
		if (val > TABLE_MAX_COLSPAN)
		{
			val = TABLE_MAX_COLSPAN;
		}
		table_cell->colspan = val;
	}

	if (rowspan_attr)
	{
		val = XP_ATOI(rowspan_attr);
		if (val < 1)
		{
			val = 1;
		}
		/*
		 * Prevent huge rowspan
		 */
		if (val > TABLE_MAX_ROWSPAN)
		{
			val = TABLE_MAX_ROWSPAN;
		}
		table_cell->rowspan = val;
	}

	if (nowrap_attr)
	{
		table_cell->nowrap = TRUE;
	}

	/* Copied to lo_InitForBeginCell()
	if (table_row->cell_list == NULL)
	{
		table_row->cell_list = table_cell;
		table_row->cell_ptr = table_cell;
	}
	else
	{
		table_row->cell_ptr->next = table_cell;
		table_row->cell_ptr = table_cell;
	}
	*/

	lo_BeginCellSubDoc(context, 
						state, 
						table,
						bgcolor_attr,
                        background_attr,
                        tile_mode,
						valign_attr,
						halign_attr,
						width_attr,
						height_attr,
 						is_a_header, 
						normal_borders ? table->draw_borders : 0,
						FALSE);

	/*
	 * We added a new state.
	 */
	lo_PushStateLevel ( context );
}


void
lo_BeginTableCell(MWContext *context, lo_DocState *state, lo_TableRec *table,
	PA_Tag *tag, Bool is_a_header)
{
	char *colspan_attr = (char*)lo_FetchParamValue(context, tag, PARAM_COLSPAN);
	char *rowspan_attr = (char*)lo_FetchParamValue(context, tag, PARAM_ROWSPAN);
	char *nowrap_attr  = (char*)lo_FetchParamValue(context, tag, PARAM_NOWRAP);
	char *bgcolor_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BGCOLOR);
	char *background_attr= (char*)lo_FetchParamValue(context, tag, PARAM_BACKGROUND);
	char *valign_attr  = (char*)lo_FetchParamValue(context, tag, PARAM_VALIGN);
	char *halign_attr  = (char*)lo_FetchParamValue(context, tag, PARAM_ALIGN);
	char *width_attr   = (char*)lo_FetchParamValue(context, tag, PARAM_WIDTH);
	char *height_attr  = (char*)lo_FetchParamValue(context, tag, PARAM_HEIGHT);

	/* remove the PA_LOCK stuff */

	lo_BeginTableCellAttributes(context, 
								state, 
								table,
								colspan_attr,
								rowspan_attr,
								nowrap_attr,
								bgcolor_attr,
                                background_attr,
                                LO_TILE_BOTH, /* Default backdrop tile mode */
								valign_attr,
								halign_attr,
								width_attr,
								height_attr,
								is_a_header,
								TRUE);

	if(colspan_attr)
		PA_FREE(colspan_attr);
	if(rowspan_attr)
		PA_FREE(rowspan_attr);
	if(nowrap_attr)
		PA_FREE(nowrap_attr);
	if(bgcolor_attr)
		PA_FREE(bgcolor_attr);
	if(background_attr)
		PA_FREE(background_attr);
	if(valign_attr)
		PA_FREE(valign_attr);
	if(halign_attr)
		PA_FREE(halign_attr);
	if(width_attr)
		PA_FREE(width_attr);
	if(height_attr)
		PA_FREE(height_attr);
}


void
lo_EndTableCell(MWContext *context, lo_DocState *state, Bool relayout )
{
	LO_SubDocStruct *subdoc;
	LO_CellStruct *cell_ele;
	lo_TableRec *table;
	lo_TableRow *table_row;
	lo_TableCell *table_cell;
	lo_table_span *span_rec;
	int32 top_inner_pad;
	int32 bottom_inner_pad;
	int32 left_inner_pad;
	int32 right_inner_pad;
	int32 i;
	lo_TopState *top_state;
	lo_DocState *old_state;
	int32 doc_id;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_EndTableCell called\n");
#endif /* LOCAL_DEBUG */

	/*
	 * makes sure we are at the bottom
	 * of everything in the document.
	 */
	if (relayout == FALSE) 
	{
		lo_CloseOutLayout(context, state);
	}
	else
	{
		lo_EndLayoutDuringReflow( context, state );
	}

	old_state = state;
	/*
	 * Get the unique document ID, and retrieve this
	 * documents layout state.
	 */
	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	state = top_state->doc_state;

	while ((state->sub_state != NULL)&&
		(state->sub_state != old_state))
	{
		state = state->sub_state;
	}

	subdoc = NULL;
	cell_ele = NULL;
	if ((state != old_state)&&
		(state->current_ele != NULL))
	{
		subdoc = lo_EndCellSubDoc(context, state,
				old_state, state->current_ele, relayout);
		state->sub_state = NULL;
		state->current_ele = NULL;
		if ((state->is_a_subdoc == SUBDOC_CELL)||
			(state->is_a_subdoc == SUBDOC_CAPTION))
		{
			if (old_state->subdoc_tags_end != NULL)
			{
				state->subdoc_tags_end =
					old_state->subdoc_tags_end;
			}
		}
		else
		{
		}
	}

	/*
	 * We popped a state level.
	 */
	lo_PopStateLevel ( context );

	table = state->current_table;
	table_row = table->row_ptr;
	table_cell = table_row->cell_ptr;
	
	top_inner_pad = FEUNITS_X(table->inner_top_pad, context);
	bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context);
	left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
	right_inner_pad = FEUNITS_X(table->inner_right_pad, context);

	if (subdoc != NULL)
	{
		int32 subdoc_width;
		int32 subdoc_height;
		int32 min_cellwidth;
		int32 base_x, base_y;
		int32 dx, dy;
		int32 cell_internal_width;
		lo_DocState *subdoc_state;
		Bool reset_min_width;
		
		reset_min_width = FALSE;
		
		cell_internal_width = old_state->max_width;
		
		/* how big do we think this cell should be? */
		min_cellwidth = old_state->min_width;

		/*
		* If the cell is smaller than this, we need to grow it so that
		* any internal elements don't overwrite the cell borders.
		*/
		if (subdoc->width < min_cellwidth)
		{
			/*
			* We need to lay things out again as we now have more space.
			* Do we want to be smart and see if we contain things that
			* will change?
			 * Be sure to add in the width of the borders as later code expects it
			*/
			subdoc->width = min_cellwidth + (2 * subdoc->border_width);
			old_state->must_relayout_subdoc = TRUE;
			
			cell_internal_width = min_cellwidth;
		}

		subdoc_width = subdoc->width +
			(2 * subdoc->border_horiz_space) +
			(left_inner_pad + right_inner_pad);
		subdoc_height = subdoc->height +
			(2 * subdoc->border_vert_space) +
			(top_inner_pad + bottom_inner_pad);
		table_cell->max_width = subdoc_width;
		table_cell->min_width = old_state->min_width +
			(2 * subdoc->border_width) +
			(2 * subdoc->border_horiz_space) +
			(left_inner_pad + right_inner_pad);

		/*
		 * This is some nasty logic. We need to reset the min_width
		 * of the cell in cases where we're certain about how large
		 * the cell is.
		 */
		if ( (table_cell->min_width < table_cell->max_width) )
		{
			/*
			 * If we're a fixed width cell and fixed layout (COLS) is on.
			 * BRAIN DAMAGE: It's arguable that we should always do this - a width for
			 * the cell was specified, we should respect it. However, certain popular
			 * sites don't look too good if we do...
			 */
			if ( (table_cell->specified_width > 0) &&
				 (table_cell->percent_width == 0) &&
				 (table->fixed_cols > 0) )
			{
				reset_min_width = TRUE;
			}
			else
			/*
			 * If we're in a fixed width table who's width does not
			 * depend on it's parent and are using fixed layout (COLS).
			 */
			if ( (table->fixed_cols > 0) &&
				 (table->table_width_fixed != FALSE) )
			{
				reset_min_width = TRUE;
			}
		}
		
		/*
		 * If nowrap is on or min_width ended up being bigger than
		 * max_width
		 */
		if ((table_cell->nowrap != FALSE)||
			(table_cell->min_width > table_cell->max_width))
		{
			reset_min_width = TRUE;
		}
		
		if ( reset_min_width != FALSE )
		{
			table_cell->min_width = table_cell->max_width;
		}

		/*
		 * If we're in the fixed layout case, then we may need to grow this
		 * column to fit this new cell width. This will allow any subsequent
		 * columns to be layed out to the correct size and not have to be
		 * relayed out.
		 */
		if ( table->fixed_cols > 0 )
		{
			lo_SetDefaultCellWidth( context, table, subdoc, table_cell, cell_internal_width );
		}
				
		table_cell->height = subdoc_height;
		table_cell->baseline = lo_GetSubDocBaseline(subdoc);

		subdoc_state = (lo_DocState *)(subdoc->state);
		table_cell->start_in_form = subdoc_state->start_in_form;
		table_cell->form_id = subdoc_state->form_id;
		table_cell->form_ele_cnt = subdoc_state->form_ele_cnt;
		table_cell->form_data_index = subdoc_state->form_data_index;
		table_cell->embed_count_base = subdoc_state->embed_count_base;
		table_cell->url_count_base = subdoc_state->url_count_base;
		table_cell->image_list_count_base = subdoc_state->image_list_count_base;
		table_cell->applet_list_count_base = subdoc_state->applet_list_count_base;
		table_cell->embed_list_count_base = subdoc_state->embed_list_count_base;

		table_cell->current_layer_num_base = subdoc_state->current_layer_num_base;
		table_cell->must_relayout = subdoc_state->must_relayout_subdoc;
		table_cell->is_a_subdoc = subdoc_state->is_a_subdoc;
		if (relayout == FALSE)
		{
			table_cell->subdoc_tags = subdoc_state->subdoc_tags;
			table_cell->subdoc_tags_end = subdoc_state->subdoc_tags_end;
		}
		subdoc_state->subdoc_tags = NULL;
		subdoc_state->subdoc_tags_end = NULL;
		table_cell->max_y = subdoc_state->y;
		table_cell->horiz_alignment = subdoc->horiz_alignment;
		table_cell->vert_alignment = subdoc->vert_alignment;

		if (relayout == FALSE)
		{
			cell_ele = lo_SmallSquishSubDocToCell(context, state, subdoc,
				&dx, &dy);
			/* Keep ptr. back to table state structs for relayout */
			cell_ele->table_cell = table_cell;
			cell_ele->table_row = table_row;
			cell_ele->table = table;
		}
		else 
		{
			cell_ele = table_cell->cell;
			lo_CreateCellFromSubDoc(context, state, subdoc, cell_ele, &dx, &dy);
		}

		lo_cleanup_old_state(subdoc->state);
		base_x = cell_ele->x + cell_ele->x_offset + cell_ele->border_width;
		base_y = cell_ele->y + cell_ele->y_offset + cell_ele->border_width;
		dx -= base_x;
		dy -= base_y;
		table_cell->cell_base_x = dx;
		table_cell->cell_base_y = dy;
	}

	table_cell->cell = cell_ele;
	table_cell->cell_done = TRUE;

	i = 0;
	while (i < table_cell->colspan)
	{

		if ((table->width_spans == NULL)||
		    ((table->width_span_ptr != NULL)&&
		     (table->width_span_ptr->next == NULL)))
		{
			span_rec = XP_NEW(lo_table_span);
			if (span_rec == NULL)
			{
				return;
			}
			span_rec->dim = 1;
			span_rec->min_dim = 1;
			span_rec->span = 0;
			span_rec->next = NULL;

			if (table->width_spans == NULL)
			{
				table->width_spans = span_rec;
				table->width_span_ptr = span_rec;
			}
			else
			{
				table->width_span_ptr->next = span_rec;
				table->width_span_ptr = span_rec;
			}
		}
		else
		{
			if (table->width_span_ptr == NULL)
			{
				table->width_span_ptr = table->width_spans;
			}
			else
			{
				table->width_span_ptr =
					table->width_span_ptr->next;
			}
			span_rec = table->width_span_ptr;
		}

		if (span_rec->span > 0)
		{
			span_rec->span--;
			table_row->cells++;

			/*
			 * This only happens if a colspan on this
			 * row overlaps a rowspan from a previous row.
			 */
			if (i > 0)
			{
				int32 new_span;

				new_span = table_cell->rowspan - 1;
				if (new_span > span_rec->span)
				{
					span_rec->span = new_span;
				}
				i++;
				/*
				 * Don't count this cell twice.
				 */
				table_row->cells--;
			}
			continue;
		}
		else
		{
			span_rec->span = table_cell->rowspan - 1;
			i++;
			if (table_cell->colspan == 1)
			{
				if (table_cell->max_width > span_rec->dim)
				{
				    span_rec->dim = table_cell->max_width;
				}
				if (table_cell->min_width > span_rec->min_dim)
				{
				    span_rec->min_dim = table_cell->min_width;
				}
			}
		}
	}

	span_rec = table->height_span_ptr;
	if (table_cell->rowspan == 1)
	{
		int32 tmp_val;

		/*
		 * If the user specified a height for the cell,
		 * that becomes our min height.
		 */
		if ((table_cell->specified_height > 0)&&
			(table_cell->specified_height > span_rec->min_dim))
		{
			span_rec->min_dim = table_cell->specified_height;
		}

		tmp_val = table_cell->baseline - span_rec->min_dim;
		if (tmp_val > 0)
		{
			span_rec->min_dim += tmp_val;
			if (table_row->vert_alignment == LO_ALIGN_BASELINE)
			{
				span_rec->dim += tmp_val;
			}
		}

		if (table_row->vert_alignment == LO_ALIGN_BASELINE)
		{
			tmp_val = (table_cell->height - table_cell->baseline) -
				(span_rec->dim - span_rec->min_dim);
			if (tmp_val > 0)
			{
				span_rec->dim += tmp_val;
			}
		}
		else
		{
			if (table_cell->height > span_rec->dim)
			{
				span_rec->dim = table_cell->height;
			}
		}
	}

	table_row->cells += table_cell->colspan;
}


void
lo_BeginTableCaption(MWContext *context, lo_DocState *state, lo_TableRec *table,
	PA_Tag *tag)
{
	lo_TableCaption *caption;
	PA_Block buff;
	char *str;

	caption = XP_NEW(lo_TableCaption);
	if (caption == NULL)
	{
		return;
	}

	caption->vert_alignment = LO_ALIGN_TOP;
	caption->horiz_alignment = LO_ALIGN_CENTER;
	caption->min_width = 0;
	caption->max_width = 0;
	caption->height = 0;
	caption->subdoc = NULL;
	caption->cell_ele = NULL;

	/*
	 * Check for an align parameter
 	 */
	buff = lo_FetchParamValue(context, tag, PARAM_ALIGN);
	if (buff != NULL)
	{
		PA_LOCK(str, char *, buff);
		if (pa_TagEqual("bottom", str))
		{
			caption->vert_alignment = LO_ALIGN_BOTTOM;
		}
		PA_UNLOCK(buff);
		PA_FREE(buff);
	}

	table->caption = caption;

	lo_BeginCaptionSubDoc(context, state, caption, tag);
}


void
lo_EndTableCaption(MWContext *context, lo_DocState *state)
{
	LO_SubDocStruct *subdoc;
	lo_TableRec *table;
	lo_TableCaption *caption;
	lo_TopState *top_state;
	lo_DocState *old_state;
	int32 doc_id;
	int32 top_inner_pad;
	int32 bottom_inner_pad;
	int32 left_inner_pad;
	int32 right_inner_pad;

	/*
	 * makes sure we are at the bottom
	 * of everything in the document.
	 */
	lo_CloseOutLayout(context, state);

	old_state = state;
	/*
	 * Get the unique document ID, and retreive this
	 * documents layout state.
	 */
	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	state = top_state->doc_state;

	while ((state->sub_state != NULL)&&
		(state->sub_state != old_state))
	{
		state = state->sub_state;
	}

	subdoc = NULL;
	if ((state != old_state)&&
		(state->current_ele != NULL))
	{
		subdoc = lo_EndCellSubDoc(context, state,
				old_state, state->current_ele, FALSE);
		state->sub_state = NULL;
		state->current_ele = NULL;
		if ((state->is_a_subdoc == SUBDOC_CELL)||
			(state->is_a_subdoc == SUBDOC_CAPTION))
		{
			if (old_state->subdoc_tags_end != NULL)
			{
				state->subdoc_tags_end =
					old_state->subdoc_tags_end;
			}
		}
	}

	table = state->current_table;
	caption = table->caption;

	top_inner_pad = FEUNITS_X(table->inner_top_pad, context);
	bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context);
	left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
	right_inner_pad = FEUNITS_X(table->inner_right_pad, context);

	if (subdoc != NULL)
	{
		int32 subdoc_width;
		int32 subdoc_height;

		subdoc_width = subdoc->width +
			(2 * subdoc->border_horiz_space) +
			(left_inner_pad + right_inner_pad);
		subdoc_height = subdoc->height +
			(2 * subdoc->border_vert_space) + 
			(top_inner_pad + bottom_inner_pad);
		caption->max_width = subdoc_width;
		caption->min_width = old_state->min_width +
			(2 * subdoc->border_width) +
			(2 * subdoc->border_horiz_space) +
			(left_inner_pad + right_inner_pad);
		if (caption->min_width > caption->max_width)
		{
			caption->min_width = caption->max_width;
		}
		caption->height = subdoc_height;
	}

	caption->subdoc = subdoc;

	/* If the caption is empty, free the memory used by it */
	if (lo_subdoc_has_elements(caption->subdoc->state) == FALSE)
	{
		lo_FreeTableCaption( context, state, table );
	}
	
	/*
	 * We popped a state level.
	 */
	lo_PopStateLevel ( context );
}


void
lo_BeginTableRowAttributes(MWContext *context, 
				 			lo_DocState *state, 
				 			lo_TableRec *table,
				 			char *bgcolor_attr,
                            char *background_attr,
				 			char *valign_attr,
				 			char *halign_attr)
{
	lo_TableRow *table_row;
	lo_table_span *span_rec;
	char *bgcolor_from_style=NULL;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_BeginTableRow called\n");
#endif /* LOCAL_DEBUG */

	table_row = XP_NEW(lo_TableRow);
	if (table_row == NULL)
	{
		return;
	}

	/* copied to lo_UpdateTableStateForBeginRow()
	table_row->row_done = FALSE; 
	*/
	table_row->has_percent_width_cells = FALSE;
	table_row->backdrop.bg_color = NULL;
    table_row->backdrop.url = NULL;
    table_row->backdrop.tile_mode = LO_TILE_BOTH;
	/* copied to lo_UpdateTableStateForBeginRow()
	table_row->cells = 0;
	*/
	table_row->vert_alignment = LO_ALIGN_DEFAULT;
	table_row->horiz_alignment = LO_ALIGN_DEFAULT;

	/* copied to lo_UpdateTableStateForBeginRow()
	table_row->cell_list = NULL;
	table_row->cell_ptr = NULL;
	*/
	table_row->next = NULL;
	
	
	lo_UpdateTableStateForBeginRow( table, table_row );

	/* check for style sheet color and override if necessary */
	if(state->top_state && state->top_state->style_stack)
	{
		StyleStruct *style_struct;

		style_struct = STYLESTACK_GetStyleByIndex(
											state->top_state->style_stack,
											0);

		if(style_struct)
		{
			bgcolor_from_style = STYLESTRUCT_GetString(style_struct, BG_COLOR_STYLE);

			if(bgcolor_from_style)
			{
				bgcolor_attr = bgcolor_from_style;
			}
		}
	}

	/*
	 * Check for a background color attribute
	 */
	if (bgcolor_attr)
	{
		uint8 red, green, blue;
		XP_Bool rv;

		if(bgcolor_from_style)
			rv = LO_ParseStyleSheetRGB(bgcolor_attr, &red, &green, &blue);
		else
			rv = LO_ParseRGB(bgcolor_attr, &red, &green, &blue);

		if(rv)
		{
			table_row->backdrop.bg_color = XP_NEW(LO_Color);
			if (table_row->backdrop.bg_color != NULL)
			{
				table_row->backdrop.bg_color->red = red;
				table_row->backdrop.bg_color->green = green;
				table_row->backdrop.bg_color->blue = blue;
			}
		}
	}

    if (background_attr)
        table_row->backdrop.url = XP_STRDUP(background_attr);

	XP_FREEIF(bgcolor_from_style);


	/*
	 * Check for a vertical align parameter
	 */
	if (valign_attr)
	{
		table_row->vert_alignment = lo_EvalVAlignParam(valign_attr);
	}

	/*
	 * Check for a horizontal align parameter
	 */
	if (halign_attr)
	{
		table_row->horiz_alignment = lo_EvalCellAlignParam(halign_attr);
	}

	
	if (table->row_list == NULL)
	{
		table->row_list = table_row;
		table->row_ptr = table_row;
	}
	else
	{
		table->row_ptr->next = table_row;
		table->row_ptr = table_row;
	}

	/* copied to lo_UpdateTableStateForBeginRow()
	table->width_span_ptr = NULL;
	*/

	span_rec = XP_NEW(lo_table_span);
	if (span_rec == NULL)
	{
		return;
	}
	
	if (table->height_spans == NULL)
	{
		table->height_spans = span_rec;
		table->height_span_ptr = span_rec;
	}
	else
	{
		table->height_span_ptr->next = span_rec;
		table->height_span_ptr = span_rec;
	}

	span_rec->dim = 1;
	/*
	 * Since min_dim on the heights is never used.
	 * I am appropriating it to do baseline aligning.  It will
	 * start as 0, and eventually be the amount of baseline needed
	 * to align all these cells in this row
	 * by their baselines.
	 */
	span_rec->min_dim = 0;
	span_rec->span = 0;
	span_rec->next = NULL;
}


void
lo_BeginTableRow(MWContext *context, lo_DocState *state, lo_TableRec *table,
	PA_Tag *tag)
{
	char *bgcolor_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BGCOLOR);
	char *background_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BACKGROUND);
	char *valign_attr  = (char*)lo_FetchParamValue(context, tag, PARAM_VALIGN);
	char *halign_attr  = (char*)lo_FetchParamValue(context, tag, PARAM_ALIGN);

	/* remove the PA_LOCK stuff */

	lo_BeginTableRowAttributes(context,
								state, 
								table,
								bgcolor_attr,
                                background_attr,
								valign_attr,
								halign_attr);

	if(bgcolor_attr)
		PA_FREE(bgcolor_attr);
	if(valign_attr)
		PA_FREE(valign_attr);
	if(halign_attr)
		PA_FREE(halign_attr);
}


void
lo_EndTableRow(MWContext *context, lo_DocState *state, lo_TableRec *table)
{
	lo_TableRow *table_row;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_EndTableRow called\n");
#endif /* LOCAL_DEBUG */

	table_row = table->row_ptr;
	table_row->row_done = TRUE;
	table->rows++;

	while (table->width_span_ptr != NULL)
	{
		table->width_span_ptr = table->width_span_ptr->next;
		if (table->width_span_ptr != NULL)
		{
			table->width_span_ptr->span--;
			table_row->cells++;
		}
	}

	if (table_row->cells > table->cols)
	{
		table->cols = table_row->cells;
	}
	
	/*
	 * We've hit the end of a row, if it's the first row and
	 * we haven't allocated all columns yet and table width
	 * is remaining, then set their size now.
	 */
	if ( table->fixed_width_remaining > 0 )
	{
		if ( (table_row->cells < table->fixed_cols) && (table->fixed_col_widths != NULL) )
		{
			int32 count;
			int32 colwidth;
			int32 cell_extra_space;
			int32 left_inner_pad;
			int32 right_inner_pad;
			
			/* how much border/pad space do we need per cell */
			if (table->draw_borders == TABLE_BORDERS_OFF)
			{
				cell_extra_space = 2 * TABLE_DEF_CELL_BORDER;
			}
			else if (table->draw_borders == TABLE_BORDERS_ON)
			{
				cell_extra_space = 2 * TABLE_DEF_CELL_BORDER;
			}
			else
			{
				cell_extra_space = 0;
			}
			
			left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
			right_inner_pad = FEUNITS_X(table->inner_right_pad, context);
			cell_extra_space += left_inner_pad + right_inner_pad;
			
			/* divide space up to the remaining cols */
			colwidth = ( table->fixed_width_remaining / 
				( table->fixed_cols - table_row->cells )) - cell_extra_space;
			
			if ( colwidth < 0 )
			{
				colwidth = 0;
			}
			
			for ( count = table_row->cells; count < table->fixed_cols; ++count )
			{
				table->fixed_col_widths[ count ] = colwidth;
				table->fixed_width_remaining -= colwidth;
			}
			
			/* add any leftover space to the last row */
			table->fixed_col_widths[ table->fixed_cols - 1 ] += 
				table->fixed_width_remaining;
		}
		table->fixed_width_remaining = 0;
	}
}

void
lo_BeginTableAttributes(MWContext *context, 
						lo_DocState *state, 
						char *align_attr,
						char *border_attr,
						char *border_top_attr,
						char *border_bottom_attr,
						char *border_left_attr,
						char *border_right_attr,
						char *border_color_attr,
						char *border_style_attr,
						char *vspace_attr,
						char *hspace_attr,
						char *bgcolor_attr,
						char *background_attr,
						char *width_attr,
						char *height_attr,
						char *cellpad_attr,
						char *toppad_attr,
						char *bottompad_attr,
						char *leftpad_attr,
						char *rightpad_attr,
						char *cellspace_attr,
						char *cols_attr)
{
	lo_TableRec *table;
	LO_TableStruct *table_ele;
	int32 val;
	char *bgcolor_from_style = NULL;
	Bool allow_percent_width;
	Bool allow_percent_height;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "lo_BeginTable called\n");
#endif /* LOCAL_DEBUG */

	if (state == NULL)
	{
		return;
	}

	table_ele = (LO_TableStruct *)lo_NewElement(context, state, LO_TABLE, NULL, 0);
	if (table_ele == NULL)
	{
		state->top_state->out_of_memory = TRUE;
		return;
	}

	table_ele->type = LO_TABLE;
	/* Copied into lo_PositionTableElement() */
	/*
	table_ele->ele_id = NEXT_ELEMENT;
	table_ele->x = state->x;
	table_ele->x_offset = 0;
	table_ele->y = state->y;
	table_ele->y_offset = 0;
	table_ele->width = 0;
	table_ele->height = 0;
	table_ele->line_height = 0;
	*/
	
	table_ele->FE_Data = NULL;
	table_ele->anchor_href = state->current_anchor;

	/*
	 * Default to the current alignment
	 */
	if ( state->align_stack != NULL )
	{
		table_ele->alignment = state->align_stack->alignment;
	}
	else
	{
		table_ele->alignment = LO_ALIGN_LEFT;
	}

	table_ele->border_width = TABLE_DEF_BORDER;
	table_ele->border_top_width = TABLE_DEF_BORDER;
	table_ele->border_bottom_width = TABLE_DEF_BORDER;
	table_ele->border_left_width = TABLE_DEF_BORDER;
	table_ele->border_right_width = TABLE_DEF_BORDER;
	table_ele->border_style = TABLE_DEF_BORDER_STYLE;

	table_ele->border_vert_space = TABLE_DEF_VERTICAL_SPACE;
	table_ele->border_horiz_space = TABLE_DEF_HORIZONTAL_SPACE;

	table_ele->border_color.red = 0;
	table_ele->border_color.green = 0;
	table_ele->border_color.blue = 0;

	table_ele->ele_attrmask = 0;

	table_ele->sel_start = -1;
	table_ele->sel_end = -1;

	/* Copied into lo_PositionTableElement() */
	/*
	table_ele->next = NULL;
	table_ele->prev = NULL;
	*/

	/*
	 * Check for an align parameter
	 */
	if (align_attr)
	{
		Bool floating;

		floating = FALSE;
		table_ele->alignment = lo_EvalAlignParam(align_attr, &floating);
		/*
		 * Only allow left and right (floating) and center.
		 */
		if (floating != FALSE)
		{
			table_ele->ele_attrmask |= LO_ELE_FLOATING;
		}
		else
		{
			/*
			 * Tables can be left, center, right, justify or char alignment.
			 * We only do left, center and right. True left and right will
			 * hit the floating case above. So, we set all alignments to
			 * be either center or left.
			 */
			switch ( table_ele->alignment )
			{
				case LO_ALIGN_LEFT:
				case LO_ALIGN_RIGHT:
				case LO_ALIGN_CENTER:
					break;
					
				case LO_ALIGN_NCSA_CENTER:
					table_ele->alignment = LO_ALIGN_CENTER;
					break;
				
				default:
					table_ele->alignment = LO_ALIGN_LEFT;
					break;
			}
		}
	}

	lo_PositionTableElement(state, table_ele);

	/*
	 * Push our alignment state if we're not floating
	 */

	/* Copied into lo_PositionTableElement() */
	/*
	if ( !(table_ele->ele_attrmask & LO_ELE_FLOATING) )
	{
		lo_PushAlignment(state, P_TABLE_DATA, table_ele->alignment);
	}
	*/

	/*
	 * Get the border parameter.
	 */
	if (border_attr)
	{
		val = XP_ATOI(border_attr);
		if ((val == 0)&&(*border_attr == '0'))
		{
			val = -1;
		}
		else if (val < 1)
		{
			val = 1;
		}
		table_ele->border_width = val;
		table_ele->border_top_width = val;
		table_ele->border_bottom_width = val;
		table_ele->border_left_width = val;
		table_ele->border_right_width = val;
	}
	table_ele->border_width = FEUNITS_X(table_ele->border_width, context);

	/*
	 * Get the top border parameter.
	 */
	if (border_top_attr)
	{
		val = XP_ATOI(border_top_attr);
		if ((val == 0)&&(*border_top_attr == '0'))
		{
			val = -1;
		}
		else if (val < 1)
		{
			val = 1;
		}
		table_ele->border_top_width = val;
	}
	table_ele->border_top_width = FEUNITS_Y(table_ele->border_top_width, context);
	
	/*
	 * Get the bottom border parameter.
	 */
	if (border_bottom_attr)
	{
		val = XP_ATOI(border_bottom_attr);
		if ((val == 0)&&(*border_bottom_attr == '0'))
		{
			val = -1;
		}
		else if (val < 1)
		{
			val = 1;
		}
		table_ele->border_bottom_width = val;
	}
	table_ele->border_bottom_width = FEUNITS_Y(table_ele->border_bottom_width, context);
	
	/*
	 * Get the left border parameter.
	 */
	if (border_left_attr)
	{
		val = XP_ATOI(border_left_attr);
		if ((val == 0)&&(*border_left_attr == '0'))
		{
			val = -1;
		}
		else if (val < 1)
		{
			val = 1;
		}
		table_ele->border_left_width = val;
	}
	table_ele->border_left_width = FEUNITS_X(table_ele->border_left_width, context);
	
	/*
	 * Get the right border parameter.
	 */
	if (border_right_attr)
	{
		val = XP_ATOI(border_right_attr);
		if ((val == 0)&&(*border_right_attr == '0'))
		{
			val = -1;
		}
		else if (val < 1)
		{
			val = 1;
		}
		table_ele->border_right_width = val;
	}
	table_ele->border_right_width = FEUNITS_X(table_ele->border_right_width, context);

	/*
	 * Get the border style parameter.
	 */
	if (border_style_attr)
	{
		int32 border_style;
		
		border_style = BORDER_OUTSET;
		if ( pa_TagEqual("none", border_style_attr) )
		{
			border_style = BORDER_NONE;
		}
		else if ( pa_TagEqual("dotted", border_style_attr) )
		{
			border_style = BORDER_DOTTED;
		}
		else if ( pa_TagEqual("dashed", border_style_attr) )
		{
			border_style = BORDER_DASHED;
		}
		else if ( pa_TagEqual("solid", border_style_attr) )
		{
			border_style = BORDER_SOLID;
		}
		else if ( pa_TagEqual("double", border_style_attr) )
		{
			border_style = BORDER_DOUBLE;
		}
		else if ( pa_TagEqual("groove", border_style_attr) )
		{
			border_style = BORDER_GROOVE;
		}
		else if ( pa_TagEqual("ridge", border_style_attr) )
		{
			border_style = BORDER_RIDGE;
		}
		else if ( pa_TagEqual("inset", border_style_attr) )
		{
			border_style = BORDER_INSET;
		}
		else if ( pa_TagEqual("outset", border_style_attr) )
		{
			border_style = BORDER_OUTSET;
		}
		
		table_ele->border_style = border_style;
	}

	/*
	 * Get the border color parameter.
	 */
	if (border_color_attr)
	{
		uint8 red, green, blue;

		LO_ParseStyleSheetRGB(border_color_attr, &red, &green, &blue);
		table_ele->border_color.red = red;
		table_ele->border_color.green = green;
		table_ele->border_color.blue = blue;
	}
	
	/*
	 * Get the extra vertical space parameter.
	 */
	if (vspace_attr)
	{
		val = XP_ATOI(vspace_attr);
		if (val < 0)
		{
			val = 0;
		}
		table_ele->border_vert_space = val;
	}
	table_ele->border_vert_space = FEUNITS_Y(table_ele->border_vert_space,
						context);

	/*
	 * Get the extra horizontal space parameter.
	 */
	if (hspace_attr)
	{
		val = XP_ATOI(hspace_attr);
		if (val < 0)
		{
			val = 0;
		}
		table_ele->border_horiz_space = val;
	}
	table_ele->border_horiz_space = FEUNITS_X(table_ele->border_horiz_space,
						context);

	table = XP_NEW(lo_TableRec);
	
	/* Keep ptr to table state structure.  Will be needed during relayout */
	table_ele->table = table;

	if (table == NULL)
	{
		return;
	}

	if(table_ele->border_top_width < 0)
			table_ele->border_top_width = 0;
 	if(table_ele->border_bottom_width < 0)
			table_ele->border_bottom_width = 0;
	if(table_ele->border_right_width < 0)
			table_ele->border_right_width = 0;
	if(table_ele->border_left_width < 0)
			table_ele->border_left_width = 0;

	if(table_ele->border_width < 0)
	{
		/* backwards compatibility */
		table->draw_borders = TABLE_BORDERS_GONE;			
		table_ele->border_width = 0;
		table_ele->border_top_width = 0;
		table_ele->border_bottom_width = 0;
		table_ele->border_right_width = 0;
		table_ele->border_left_width = 0;
	}
	else if (table_ele->border_top_width == 0
		&& table_ele->border_bottom_width == 0
		&& table_ele->border_left_width == 0
		&& table_ele->border_right_width == 0)
	{
		table->draw_borders = TABLE_BORDERS_OFF;
	}
	else
	{
		table->draw_borders = TABLE_BORDERS_ON;
	}
	table->has_percent_width_cells = FALSE;
	table->has_percent_height_cells = FALSE;
	table->backdrop.bg_color = NULL;
    table->backdrop.url = NULL;
    table->backdrop.tile_mode = LO_TILE_BOTH;

	/* Copied to lo_InitTableRecord()
	/*
	table->rows = 0;
	table->cols = 0;
	*/

	table->width_spans = NULL;
	table->width_span_ptr = NULL;
	table->height_spans = NULL;
	/* Copied to lo_InitTableRecord()
	table->height_span_ptr = NULL;
	*/
	table->caption = NULL;
	table->table_ele = table_ele;
	table->current_subdoc = NULL;
	table->row_list = NULL;
	table->row_ptr = NULL;
	table->width = 0;
	table->height = 0;
	
	lo_InitTableRecord( table );

	/*
	 * Percent width, height added for relayout
	 */
	table->percent_width = 0;
	table->percent_height = 0;

	table->inner_top_pad = TABLE_DEF_INNER_CELL_PAD;
	table->inner_bottom_pad = TABLE_DEF_INNER_CELL_PAD;
	table->inner_left_pad = TABLE_DEF_INNER_CELL_PAD;
	table->inner_right_pad = TABLE_DEF_INNER_CELL_PAD;
	table->inter_cell_pad = TABLE_DEF_INTER_CELL_PAD;

	table->current_subdoc = (LO_SubDocStruct *)lo_NewElement(context, state, LO_SUBDOC, NULL, 0);
	table->current_subdoc->type = LO_SUBDOC;
	
	table->current_subdoc->backdrop.bg_color = NULL;
    table->current_subdoc->backdrop.url = NULL;
    table->current_subdoc->backdrop.tile_mode = LO_TILE_BOTH;
	table->current_subdoc->state = lo_NewLayout(context,
		state->win_width, state->win_height, 0, 0, NULL);

	table->default_cell_width = 0;
	table->fixed_width_remaining = 0;
	table->fixed_col_widths = NULL;
	table->table_width_fixed = FALSE;
	table->fixed_cols = 0;
	
	/*
	 * You can't do percentage widths if the parent's
	 * width is still undecided.
	 */
	allow_percent_width = TRUE;
	allow_percent_height = TRUE;
	if ((state->is_a_subdoc == SUBDOC_CELL)||
		(state->is_a_subdoc == SUBDOC_CAPTION))
	{
		lo_TopState *top_state;
		lo_DocState *new_state;
		int32 doc_id;

		/*
		 * Get the unique document ID, and retreive this
		 * documents layout state.
		 */
		doc_id = XP_DOCID(context);
		top_state = lo_FetchTopState(doc_id);
		new_state = top_state->doc_state;

		while ((new_state->sub_state != NULL)&&
			(new_state->sub_state != state))
		{
			new_state = new_state->sub_state;
		}

		if ((new_state->sub_state == state)&&
			(new_state->current_ele != NULL))
		{
			LO_SubDocStruct *subdoc;

			subdoc = (LO_SubDocStruct *)new_state->current_ele;
			if (subdoc->width == 0)
			{
				allow_percent_width = FALSE;
#ifdef LOCAL_DEBUG
 fprintf(stderr, "Percent width not allowed in this subdoc!\n");
#endif /* LOCAL_DEBUG */
			}
			else
			{
#ifdef LOCAL_DEBUG
 fprintf(stderr, "Percent width IS allowed in this subdoc!\n");
#endif /* LOCAL_DEBUG */
			}
			if (subdoc->height == 0)
			{
				allow_percent_height = FALSE;
			}
		}
	}

	
	/* check for style sheet color and override if necessary */
	if(state->top_state && state->top_state->style_stack)
	{
		StyleStruct *style_struct;

		style_struct = STYLESTACK_GetStyleByIndex(
											state->top_state->style_stack,
											0);

		if(style_struct)
		{
			bgcolor_from_style = STYLESTRUCT_GetString(style_struct, BG_COLOR_STYLE);

			if(bgcolor_from_style)
			{
				bgcolor_attr = bgcolor_from_style;
			}
		}
	}

	/*
	 * Check for a background color attribute
	 */
	if (bgcolor_attr)
	{
		uint8 red, green, blue;
		XP_Bool rv;

		if(bgcolor_from_style)
			rv = LO_ParseStyleSheetRGB(bgcolor_attr, &red, &green, &blue);
		else
			rv = LO_ParseRGB(bgcolor_attr, &red, &green, &blue);
		if(rv)
		{
			table->backdrop.bg_color = XP_NEW(LO_Color);
			if (table->backdrop.bg_color != NULL)
			{
				table->backdrop.bg_color->red = red;
				table->backdrop.bg_color->green = green;
				table->backdrop.bg_color->blue = blue;
			}
		}
	}

    if (background_attr)
        table->backdrop.url = XP_STRDUP(background_attr);
	XP_FREEIF(bgcolor_from_style);


	/*
	 * Get the width and height parameters, in absolute or percentage.
	 * If percentage, make it absolute.
	 */
	if (width_attr)
	{
		Bool is_percent;

		val = lo_ValueOrPercent(width_attr, &is_percent);
		if (is_percent != FALSE)
		{
			table->percent_width = val;
			/*
			if (allow_percent_width == FALSE)
			{
				val = 0;
			}
			else
			{
				val = (state->win_width - state->win_left -
					state->win_right) * val / 100;
			}
			*/
			
		}
		else
		{
			table->percent_width = 0;
			table->table_width_fixed = TRUE;
			val = FEUNITS_X(val, context);
		}
		if (val < 0)
		{
			val = 0;
		}
		table->width = val;
	}
	
	if (height_attr)
	{
		Bool is_percent;

		val = lo_ValueOrPercent(height_attr, &is_percent);
		if (is_percent != FALSE)
		{
			table->percent_height = val;
			/*
			if (allow_percent_height == FALSE)
			{
				val = 0;
			}
			else
			{
				val = (state->win_height - state->win_top -
					state->win_bottom) * val / 100;
			}
			*/
		}
		else
		{
			table->percent_height = 0;
			val = FEUNITS_X(val, context);
		}
		if (val < 0)
		{
			val = 0;
		}
		table->height = val;
	}

	lo_SetTableDimensions(state, table, allow_percent_width, allow_percent_height);

	if (cellpad_attr)
	{
		val = XP_ATOI(cellpad_attr);
		if (val < 0)
		{
			val = 0;
		}
		/* set all our pads to this value */
		table->inner_top_pad = val;
		table->inner_bottom_pad = val;
		table->inner_left_pad = val;
		table->inner_right_pad = val;
	}

	if (toppad_attr)
	{
		val = XP_ATOI(toppad_attr);
		if (val < 0)
		{
			val = 0;
		}
		table->inner_top_pad = val;
	}

	if (bottompad_attr)
	{
		val = XP_ATOI(bottompad_attr);
		if (val < 0)
		{
			val = 0;
		}
		table->inner_bottom_pad = val;
	}

	if (leftpad_attr)
	{
		val = XP_ATOI(leftpad_attr);
		if (val < 0)
		{
			val = 0;
		}
		table->inner_left_pad = val;
	}

	if (rightpad_attr)
	{
		val = XP_ATOI(rightpad_attr);
		if (val < 0)
		{
			val = 0;
		}
		table->inner_right_pad = val;
	}
	
	if (cellspace_attr)
	{
		val = XP_ATOI(cellspace_attr);
		if (val < 0)
		{
			val = 0;
		}
		table->inter_cell_pad = val;
	}

	/*
	 * Get the COLS parameter.
	 */
	if (cols_attr)
	{
		val = XP_ATOI(cols_attr);
		if (val < 0)
		{
			val = 0;
		}
		table_ele->border_horiz_space = val;
		
		/*
		 * If we have a specified number of columns, then
		 * we first need to make sure we have a real table
		 * width and then compute our default column width.
		 */
		table->fixed_cols = val;		
		if ( val > 0 )
		{
		
			/* Copied to lo_CalcFixedColWidths() */
			/*
			int32 count;
			int32 table_width;
			
			table->fixed_cols = val;
			
			table_width = lo_ComputeInternalTableWidth ( context, table, state );
			*/

			/* Split the space up evenly */
			/*
			table->default_cell_width = table_width / val;
			*/

			/* and we have all the table width left to play with */
			/*
			table->fixed_width_remaining = table_width;
			*/
			
			/* allocate and initialize our width array */			
			table->fixed_col_widths = XP_ALLOC(val * sizeof(int32));
			if (table->fixed_col_widths == NULL)
			{
				state->top_state->out_of_memory = TRUE;
				table->fixed_cols = 0;
				table->default_cell_width = 0;
				return;
			}


			/*
			for ( count = 0; count < val; ++count )
			{
				table->fixed_col_widths[ count ] = 0;
			}
			*/

			lo_CalcFixedColWidths( context, state, table );
		}
	}

	/* Copied to lo_UpdateStateAfterBeginTable() */
	/* 
	state->current_table = table;
	*/
	
	lo_UpdateStateAfterBeginTable( state, table );
}


/*
 * Preparse the tag attributes and call the real begin table
 */
void
lo_BeginTable(MWContext *context, lo_DocState *state, PA_Tag *tag)
{

	/* style sheets variables */
	StyleStruct *style_struct=NULL;
	SS_Number *top_padding, *bottom_padding, *left_padding, *right_padding;

    char *align_attr =    	(char*)lo_FetchParamValue(context, tag, PARAM_ALIGN);
    char *border_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_BORDER);
    char *border_top_attr =		NULL;
    char *border_bottom_attr =	NULL;
    char *border_left_attr =	NULL;
    char *border_right_attr =	NULL;
    char *border_color_attr =	(char*)lo_FetchParamValue(context, tag, PARAM_BORDERCOLOR);
    char *border_style_attr =	NULL;
    char *vspace_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_VSPACE);
    char *hspace_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_HSPACE);
	char *bgcolor_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_BGCOLOR);
	char *background_attr =  	(char*)lo_FetchParamValue(context, tag, PARAM_BACKGROUND);
	char *width_attr =     	(char*)lo_FetchParamValue(context, tag, PARAM_WIDTH);
	char *height_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_HEIGHT);
	char *cellpad_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_CELLPAD);
	char *toppad_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_TOPPAD);
	char *bottompad_attr =  (char*)lo_FetchParamValue(context, tag, PARAM_BOTTOMPAD);
	char *leftpad_attr =   	(char*)lo_FetchParamValue(context, tag, PARAM_LEFTPAD);
	char *rightpad_attr =   (char*)lo_FetchParamValue(context, tag, PARAM_RIGHTPAD);
	char *cellspace_attr = 	(char*)lo_FetchParamValue(context, tag, PARAM_CELLSPACE);
	char *cols_attr = 		(char*)lo_FetchParamValue(context, tag, PARAM_COLS);

	if(!border_style_attr)
	{
		border_style_attr = XP_STRDUP("outset"); 
	}

	if(!border_color_attr)
	{
		XP_ASSERT(state);
		if(state)
			border_color_attr = PR_smprintf("#%2x%2x%2x", 
								   state->text_bg.red,
								   state->text_bg.green,
								   state->text_bg.blue);
	}

	if(state->top_state->style_stack)
		style_struct = STYLESTACK_GetStyleByIndex(state->top_state->style_stack, 0);

	if(style_struct)
	{
		left_padding = STYLESTRUCT_GetNumber(style_struct, LEFTPADDING_STYLE);
		if(left_padding)
		{
			LO_AdjustSSUnits(left_padding, LEFTPADDING_STYLE, context, state);
			XP_FREEIF(leftpad_attr);
			leftpad_attr = PR_smprintf("%ld", (int32)left_padding->value);
		}

		right_padding = STYLESTRUCT_GetNumber(style_struct, RIGHTPADDING_STYLE);
		if(right_padding)
		{
			LO_AdjustSSUnits(right_padding, RIGHTPADDING_STYLE, context, state);
			XP_FREEIF(rightpad_attr);
			rightpad_attr = PR_smprintf("%ld", (int32)right_padding->value);
		}

		top_padding = STYLESTRUCT_GetNumber(style_struct, TOPPADDING_STYLE);
		if(top_padding)
		{
			LO_AdjustSSUnits(top_padding, TOPPADDING_STYLE, context, state);
			XP_FREEIF(toppad_attr);
			toppad_attr = PR_smprintf("%ld", (int32)top_padding->value);
		}

		bottom_padding = STYLESTRUCT_GetNumber(style_struct, BOTTOMPADDING_STYLE);
		if(bottom_padding)
		{
			LO_AdjustSSUnits(bottom_padding, BOTTOMPADDING_STYLE, context, state);
			XP_FREEIF(bottompad_attr);
			bottompad_attr = PR_smprintf("%ld", (int32)bottom_padding->value);
		}
	}

	/* remove the PA_LOCK stuff, it does nothing anyways */

	lo_BeginTableAttributes(context, 
							state, 
							align_attr,
							border_attr,
							border_top_attr,
							border_bottom_attr,
							border_left_attr,
							border_right_attr,
							border_color_attr,
							border_style_attr,
							vspace_attr,
							hspace_attr,
							bgcolor_attr,
                            background_attr,
							width_attr,
							height_attr,
							cellpad_attr,
							toppad_attr,
							bottompad_attr,
							leftpad_attr,
							rightpad_attr,
							cellspace_attr,
							cols_attr);

	if(align_attr)
		PA_FREE(align_attr);
	if(border_attr)
		PA_FREE(border_attr);
	if(border_top_attr)
		PA_FREE(border_top_attr);
	if(border_bottom_attr)
		PA_FREE(border_bottom_attr);
	if(border_left_attr)
		PA_FREE(border_left_attr);
	if(border_right_attr)
		PA_FREE(border_right_attr);
	if(border_color_attr)
		PA_FREE(border_color_attr);
	if(border_style_attr)
		PA_FREE(border_style_attr);
	if(vspace_attr)
		PA_FREE(vspace_attr);
	if(hspace_attr)
		PA_FREE(hspace_attr);
	if(bgcolor_attr)
		PA_FREE(bgcolor_attr);
	if(background_attr)
		PA_FREE(background_attr);
	if(width_attr)
		PA_FREE(width_attr);
	if(height_attr)
		PA_FREE(height_attr);
	if(cellpad_attr)
		PA_FREE(cellpad_attr);
	if(toppad_attr)
		PA_FREE(toppad_attr);
	if(bottompad_attr)
		PA_FREE(bottompad_attr);
	if(leftpad_attr)
		PA_FREE(leftpad_attr);
	if(rightpad_attr)
		PA_FREE(rightpad_attr);
	if(cellspace_attr)
		PA_FREE(cellspace_attr);
	if(cols_attr)
		PA_FREE(cols_attr);
}


static void
lo_fill_cell_array(lo_TableRec *table, lo_cell_data XP_HUGE *cell_array,
	lo_TableCell *blank_cell, int32 cell_pad, Bool *relayout_pass)
{
	int32 x, y;
	int32 indx;
	lo_table_span *row_max;
	lo_table_span *col_max;
	lo_TableRow *row_ptr;
	lo_TableCell *cell_ptr;

	row_max = table->height_spans;
	row_ptr = table->row_list;
	for (y = 0; y < table->rows; y++)
	{
		x = 0;
		col_max = table->width_spans;
		cell_ptr = row_ptr->cell_list;
		row_ptr->cells_in_row = 0;
		while (cell_ptr != NULL)
		{
			/*
			 * Also on this pass check if any of the cells
			 * NEED to be relaid out later.
			 */
			if (cell_ptr->must_relayout != FALSE)
			{
				*relayout_pass = TRUE;
			}

			/*
			 * "fix" up badly specified row spans.
			 */
			if ((y + cell_ptr->rowspan) > table->rows)
			{
				cell_ptr->rowspan = table->rows - y;
				if (cell_ptr->rowspan == 1)
				{
					if (cell_ptr->height > row_max->dim)
					{
						row_max->dim = cell_ptr->height;
					}
				}
			}

			indx = (y * table->cols) + x;

			if (cell_array[indx].cell == blank_cell)
			{
				x++;
				col_max = col_max->next;
				continue;
			}

			/*
			 * If the cell is not an empty cell, count it for this row
			 */
			/* if (cell_ptr->cell->cell_list != NULL || cell_ptr->cell->cell_float_list != NULL) */
				row_ptr->cells_in_row++;

			cell_array[indx].cell = cell_ptr;
			cell_array[indx].width = cell_ptr->max_width;
			cell_array[indx].height = cell_ptr->height;

			if (cell_ptr->colspan > 1)
			{
				int32 i;
				int32 width, min_width;
				lo_table_span *max_ptr;

				max_ptr = col_max;

				width = max_ptr->dim;
				min_width = max_ptr->min_dim;
				for (i=1; i < cell_ptr->colspan; i++)
				{
					cell_array[indx + i].cell = blank_cell;
					max_ptr = max_ptr->next;
					width = width + cell_pad + max_ptr->dim;
					min_width = min_width + cell_pad +
						max_ptr->min_dim;
				}

				if (width < cell_ptr->max_width)
				{
					int32 add_width;
					int32 add;
					lo_table_span *add_ptr;

					add_ptr = col_max;
					add_width = cell_ptr->max_width -
						width;
					add = 0;
					while (add_ptr != max_ptr)
					{
						int32 newWidth;

						newWidth = add_width *
							add_ptr->dim / width;
						add_ptr->dim += newWidth;
						add += newWidth;
						add_ptr = add_ptr->next;
					}
					add_ptr->dim += (add_width - add);
				}

				if (min_width < cell_ptr->min_width)
				{
					int32 add_width;
					int32 add;
					lo_table_span *add_ptr;

					add_ptr = col_max;
					add_width = cell_ptr->min_width -
						min_width;
					add = 0;
					while (add_ptr != max_ptr)
					{
						int32 newWidth;

						newWidth = add_width *
							add_ptr->min_dim /
							min_width;
						/*
						 * We are not allowed to add
						 * enough to put min_dim > dim.
						 */
						if ((add_ptr->min_dim +
						     newWidth) > add_ptr->dim)
						{
						    newWidth = add_ptr->dim -
							add_ptr->min_dim;
						    /*
						     * don't let newWidth become
						     * negative.
						     */
						    if (newWidth < 0)
						    {
								newWidth = 0;
						    }
						}
						add_ptr->min_dim += newWidth;
						add += newWidth;
						add_ptr = add_ptr->next;
					}
					add_ptr->min_dim += (add_width - add);
				}
				col_max = max_ptr;
			}

			if (cell_ptr->rowspan > 1)
			{
				int32 i;
				int32 height;
				int32 tmp_val;
				lo_table_span *max_ptr;

				max_ptr = row_max;

				height = max_ptr->dim;
				for (i=1; i < cell_ptr->rowspan; i++)
				{
				    cell_array[indx + (i * table->cols)].cell =
						blank_cell;
				    if (cell_ptr->colspan > 1)
				    {
						int32 j;

						for (j=1; j < cell_ptr->colspan; j++)
						{
						    cell_array[indx +
							(i * table->cols) + j].cell =
							blank_cell;
						}
				    }
				    max_ptr = max_ptr->next;
				    height = height + cell_pad + max_ptr->dim;
				}

				tmp_val = cell_ptr->baseline - row_max->min_dim;
				if (tmp_val > 0)
				{
					row_max->min_dim += tmp_val;
					if (row_ptr->vert_alignment ==
						LO_ALIGN_BASELINE)
					{
						row_max->dim += tmp_val;
						height += tmp_val;
					}
					/*
					 * Baseline spacing shouldn't grow the
					 * max height, except for baseline
					 * aligned rows as above.
					 */
					if (row_max->min_dim > row_max->dim)
					{
						row_max->min_dim = row_max->dim;
					}
				}

				if (height < cell_ptr->height)
				{
					int32 add_height;
					int32 add;
					lo_table_span *add_ptr;

					add_ptr = row_max;
					add_height = cell_ptr->height -
						height;
					add = 0;
					while (add_ptr != max_ptr)
					{
						int32 newHeight;

						newHeight = add_height *
							add_ptr->dim / height;
						add_ptr->dim += newHeight;
						add += newHeight;
						add_ptr = add_ptr->next;
					}
					add_ptr->dim += (add_height - add);
				}
			}

			x += cell_ptr->colspan;

			col_max = col_max->next;
			cell_ptr = cell_ptr->next;
			cell_array[indx].cell->next = NULL;
		}
		row_ptr = row_ptr->next;
		row_max = row_max->next;
	}
}

static void
lo_percent_width_cells(lo_TableRec *table, lo_cell_data XP_HUGE *cell_array,
	lo_TableCell *blank_cell, int32 cell_pad, int32 table_pad,
	int32 *table_width, int32 *min_table_width,
	int32 *base_table_width, int32 *min_base_table_width)
{
	int32 x, y;
	int32 indx;
	int32 new_table_width;
	int32 new_min_table_width;
	int32 new_base_table_width;
	int32 new_min_base_table_width;
	Bool need_pass_two;
	lo_table_span *row_max;
	lo_table_span *col_max;
	lo_TableRow *row_ptr;
	lo_TableCell *cell_ptr;

	new_table_width = 0;
	row_ptr = table->row_list;
	row_max = table->height_spans;
	for (y=0; y < table->rows; y++)
	{
	    if (row_ptr->has_percent_width_cells != FALSE)
	    {
			int32 reserve;
			int32 unknown, unknown_base;

			unknown = 0;
			unknown_base = 0;
			reserve = 100 - table->cols;
			col_max = table->width_spans;
			for (x=0; x < table->cols; x++)
			{
				indx = (y * table->cols) + x;
				cell_ptr = cell_array[indx].cell;
				if ((cell_ptr == blank_cell)||
					(cell_ptr == NULL))
				{
					col_max = col_max->next;
					continue;
				}
				if (cell_ptr->percent_width > 0)
				{
					int32 width;

					reserve += cell_ptr->colspan;
					if (cell_ptr->percent_width > reserve)
					{
					    cell_ptr->percent_width = reserve;
					    reserve = 0;
					}
					else
					{
					    reserve -= cell_ptr->percent_width;
					}
					width = cell_ptr->max_width * 100 /
						cell_ptr->percent_width;
					if (width > new_table_width)
					{
						new_table_width = width;
					}
				}
				else
				{
					unknown++;
					unknown_base += cell_ptr->max_width;
				}
				col_max = col_max->next;
			}
			if (unknown)
			{
			    col_max = table->width_spans;
			    for (x=0; x < table->cols; x++)
			    {
				indx = (y * table->cols) + x;
				cell_ptr = cell_array[indx].cell;
				if ((cell_ptr == blank_cell)||
					(cell_ptr == NULL))
				{
					col_max = col_max->next;
					continue;
				}
				if (cell_ptr->percent_width == 0)
				{
					int32 width;
					int32 percent;

					if (unknown == 1)
					{
					    percent = reserve;
					}
					else
					{
					    percent = reserve *
							cell_ptr->max_width /
							unknown_base;
					}
					reserve -= percent;
					if (reserve < 0)
					{
					    reserve = 0;
					}
					percent += cell_ptr->colspan;
					cell_ptr->percent_width = percent;

					width = cell_ptr->max_width * 100 /
						cell_ptr->percent_width;
					if (width > new_table_width)
					{
						new_table_width = width;
					}

					unknown--;
				}
				col_max = col_max->next;
			    }
			}
	    }
	    else
	    {
			int32 width;

			width = 0;
			col_max = table->width_spans;
			for (x=0; x < table->cols; x++)
			{
				indx = (y * table->cols) + x;
				cell_ptr = cell_array[indx].cell;
				if ((cell_ptr == blank_cell)||
					(cell_ptr == NULL))
				{
					col_max = col_max->next;
					continue;
				}
				width += cell_ptr->max_width;
				col_max = col_max->next;
			}
			if (width > new_table_width)
			{
				new_table_width = width;
			}
	    }
	    row_ptr = row_ptr->next;
	    row_max = row_max->next;
	}

	if (*table_width > new_table_width)
	{
		new_table_width = *table_width;
	}

	/*
	 * If we already know how wide this table must be
	 * Use that width when calculate percentage cell widths.
	 */
	if ((table->width > 0)&&(table->width >= *min_table_width))
	{
		new_table_width = table->width;
	}

	need_pass_two = FALSE;

	col_max = table->width_spans;
	for (x=0; x < table->cols; x++)
	{
		int32 current_max;

		current_max = col_max->dim;
		col_max->dim = 1;
		row_max = table->height_spans;
		for (y=0; y < table->rows; y++)
		{
			indx = (y * table->cols) + x;
			cell_ptr = cell_array[indx].cell;
			if ((cell_ptr == blank_cell)||
				(cell_ptr == NULL))
			{
				row_max = row_max->next;
				continue;
			}
			if ((cell_ptr->percent_width > 0)&&
				(cell_ptr->colspan == 1))
			{
				int32 p_width;

				p_width = new_table_width *
					cell_ptr->percent_width / 100;
				if (p_width < cell_ptr->min_width)
				{
					p_width = cell_ptr->min_width;
				}
				if (p_width > col_max->dim)
				{
					col_max->dim = p_width;
				}
			}
			else if (cell_ptr->colspan > 1)
			{
				need_pass_two = TRUE;
			}
			else
			{
				if (cell_ptr->max_width > col_max->dim)
				{
					col_max->dim =
						cell_ptr->max_width;
				}
			}
			row_max = row_max->next;
		}
		if (col_max->dim < col_max->min_dim)
		{
			col_max->dim = col_max->min_dim;
		}
		col_max = col_max->next;
	}
	/*
	 * Take care of spanning columns if any
	 */
	if (need_pass_two != FALSE)
	{
	    row_max = table->height_spans;
	    for (y=0; y < table->rows; y++)
	    {
			col_max = table->width_spans;
			for (x=0; x < table->cols; x++)
			{
				indx = (y * table->cols) + x;
				cell_ptr = cell_array[indx].cell;
				if ((cell_ptr == blank_cell)||
					(cell_ptr == NULL))
				{
					col_max = col_max->next;
					continue;
				}
				if (cell_ptr->colspan > 1)
				{
					int32 i;
					int32 width;
					lo_table_span *max_ptr;
					int32 p_width;
					int32 new_width;

					new_width = cell_ptr->max_width;
				    if (cell_ptr->percent_width > 0)
				    {
						p_width = new_table_width *
							cell_ptr->percent_width / 100;
						if (p_width >= cell_ptr->min_width)
						{
							new_width = p_width;
						}
				    }

					max_ptr = col_max;

					width = max_ptr->dim;
					for (i=1; i < cell_ptr->colspan; i++)
					{
						max_ptr = max_ptr->next;
						width = width + cell_pad +
							max_ptr->dim;
					}

					if (width < new_width)
					{
						int32 add_width;
						int32 add;
						lo_table_span *add_ptr;

						add_ptr = col_max;
						add_width = new_width - width;
						add = 0;
						while (add_ptr != max_ptr)
						{
							int32 newWidth;

							newWidth = add_width *
								add_ptr->dim /
								width;
							add_ptr->dim +=newWidth;
							add += newWidth;
							add_ptr = add_ptr->next;
						}
						add_ptr->dim += (add_width -
							add);
					}
				}
				col_max = col_max->next;
			}
			row_max = row_max->next;
	    }
	}

	new_table_width = 0;
	new_min_table_width = 0;
	new_base_table_width = 0;
	new_min_base_table_width = 0;
	col_max = table->width_spans;
	while (col_max != NULL)
	{
		new_base_table_width += col_max->dim;
		new_min_base_table_width += col_max->min_dim;
		new_table_width = new_table_width + cell_pad +
			col_max->dim;
		new_min_table_width = new_min_table_width + cell_pad +
			col_max->min_dim;
		col_max = col_max->next;
	}
	new_table_width += cell_pad;
	new_table_width += (table->table_ele->border_left_width + 
		table->table_ele->border_right_width);
	new_min_table_width += cell_pad;
	new_min_table_width += (table->table_ele->border_left_width + 
		table->table_ele->border_right_width);
	if (table->draw_borders == TABLE_BORDERS_OFF)
	{
		new_table_width += (2 * table_pad);
		new_min_table_width += (2 * table_pad);
	}

	*table_width = new_table_width;
	*min_table_width = new_min_table_width;
	*base_table_width = new_base_table_width;
	*min_base_table_width = new_min_base_table_width;
}

static void
lo_cell_relayout_pass(MWContext *context, lo_DocState *state,
	lo_TableRec *table, lo_cell_data XP_HUGE *cell_array, lo_TableCell *blank_cell,
	int32 cell_pad, Bool *rowspan_pass, Bool relayout)
{
	int32 x, y;
	int32 indx;
	lo_table_span *row_max;
	lo_table_span *col_max;
	lo_TableRow *row_ptr;
	lo_TableCell *cell_ptr;
	int32 top_inner_pad;
	int32 bottom_inner_pad;
	int32 left_inner_pad;
	int32 right_inner_pad;

	top_inner_pad = FEUNITS_X(table->inner_top_pad, context);
	bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context);
	left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
	right_inner_pad = FEUNITS_X(table->inner_right_pad, context);

	row_ptr = table->row_list;
	row_max = table->height_spans;
	for (y=0; y < table->rows; y++)
	{
		Bool max_height_valid;
		Bool changed_row_height;
		int32 max_row_height;
			
		max_height_valid = FALSE;
		changed_row_height = FALSE;
		
		max_row_height = 0;
		
		col_max = table->width_spans;

		for (x=0; x < table->cols; x++)
		{
			LO_CellStruct *cell_struct;
			int32 width;
			int32 inside_width;
			Bool has_elements;

			indx = (y * table->cols) + x;
			cell_ptr = cell_array[indx].cell;
			if ((cell_ptr == blank_cell)||
				(cell_ptr == NULL))
			{
				col_max = col_max->next;
				continue;
			}
			cell_struct = cell_ptr->cell;
			inside_width = col_max->dim;
			width = inside_width;
			if (cell_ptr->colspan > 1)
			{
				int32 i;
				lo_table_span *max_ptr;

				max_ptr = col_max;

				/*
				 * We need to add some cellpads for the spanned cells
				 * to our inside width
				 */
				inside_width += ( cell_ptr->colspan - 1 ) * cell_pad;
				
				for (i=1; i < cell_ptr->colspan; i++)
				{
					max_ptr = max_ptr->next;
					inside_width += max_ptr->dim;
					width += cell_pad + max_ptr->dim;
				}
			}
									
			/*
			 * We want to relayout the cell if it's been tagged as
			 * needing it or if it's been layed out to a different size.
			 */
			if ( (cell_ptr->must_relayout != FALSE) || 
				((width != cell_ptr->max_width)) )
			{
				cell_ptr->must_relayout = FALSE;
				
				inside_width = inside_width -
				    (2 * cell_struct->border_width) -
				    (2 * cell_struct->border_horiz_space) -
				    (left_inner_pad + right_inner_pad);
				    
				/*
				 * Don't relayout documents that have no
				 * elements, it causes errors.
				 */
				has_elements = lo_cell_has_elements(cell_ptr->cell);
				if ( has_elements == FALSE )
				{
					/*
					 * Simply record our new width in this case.
					 */
					 cell_struct->width = inside_width;
				}
				else
				{

					cell_struct = lo_RelayoutCell(context, state,
					    table->current_subdoc, cell_ptr,
					    cell_struct, inside_width,
					    cell_ptr->is_a_header, relayout);

					if (!cell_struct)	/* temporary fix for crash when cell_struct is null */
					{
						break;
					}
					cell_ptr->cell = cell_struct;
					cell_ptr->baseline = lo_GetCellBaseline(cell_struct);
					
					if (cell_ptr->rowspan == 1)
					{
						int32 tmp_val;

						/*
						 * We have changed the height of a single row cell, so we may need
						 * to update the row height later.
						 */
						changed_row_height = TRUE;
						
					    tmp_val = cell_ptr->baseline - row_max->min_dim;
					    if (tmp_val > 0)
					    {
							row_max->min_dim += tmp_val;
							if (row_ptr->vert_alignment ==
								LO_ALIGN_BASELINE)
							{
								row_max->dim += tmp_val;
							}
							/*
							 * Baseline spacing shouldn't grow the
							 * max height, except for baseline
							 * aligned rows as above.
							 */
							if (row_max->min_dim > row_max->dim)
							{
								row_max->min_dim = row_max->dim;
							}
					    }
					}
					else
					{
						*rowspan_pass = TRUE;
					}
				}
			}
			else
			{
				if (cell_ptr->rowspan > 1)
				{
					*rowspan_pass = TRUE;
				}
			}
			
			/*
			 * If this cell has anything inside it, see if it's height
			 * is the biggest for the row.
			 */
			has_elements = lo_cell_has_elements(cell_ptr->cell);
			if ( has_elements != FALSE )
			{
				int32 cell_row_height;

				/*
				 * What row height does this cell want?
				 */
			    cell_row_height = cell_struct->height +
					(top_inner_pad + bottom_inner_pad) +
					(2 * cell_struct->border_vert_space);
				
				/*
				 * Munge the height if the row is vertically aligned along
				 * the baseline and the cell only spans one row.
				 */
			    if (cell_ptr->rowspan == 1)
			    {
			    	if (row_ptr->vert_alignment == LO_ALIGN_BASELINE)
			    	{
				    	cell_row_height = (cell_row_height -
						    cell_ptr->baseline) + row_max->min_dim;
					}
				
					if ( cell_row_height > max_row_height )
					{
						/*
						 * Update to our new maximum and flag that it
						 * contains valid data.
						 */
						max_height_valid = TRUE;
						max_row_height = cell_row_height;
					}
			    }
			}
			col_max = col_max->next;
		}
		
		/*
		 * If we did relayout anything on that row which gave us a new
		 * valid max row height which is different to what we currently
		 * have, then use that.
		 */
		if ( max_height_valid != FALSE && changed_row_height != FALSE &&
			max_row_height != row_max->dim )
		{
			/*
			 * Can't reset height to be smaller than
			 * the minimum height.
			 */
			if (max_row_height >= row_max->min_dim)
			{
				row_max->dim = max_row_height;
			}
			else
			{
				row_max->dim = row_max->min_dim;
			}
		}
		row_max = row_max->next;
		row_ptr = row_ptr->next;
	}

}


static void
lo_cell_rowspan_pass(MWContext *context, lo_TableRec *table, lo_cell_data XP_HUGE *cell_array,
	lo_TableCell *blank_cell, int32 cell_pad)
{
	int32 x, y;
	int32 indx;
	lo_table_span *row_max;
	lo_table_span *col_max;
	lo_TableRow *row_ptr;
	lo_TableCell *cell_ptr;
	int32 top_inner_pad;
	int32 bottom_inner_pad;

	top_inner_pad = FEUNITS_X(table->inner_top_pad, context);
	bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context);

	row_max = table->height_spans;
	row_ptr = table->row_list;
	for (y=0; y < table->rows; y++)
	{
		col_max = table->width_spans;
		for (x=0; x < table->cols; x++)
		{
			LO_CellStruct *cell_struct;

			indx = (y * table->cols) + x;
			cell_ptr = cell_array[indx].cell;
			if ((cell_ptr == blank_cell)||
				(cell_ptr == NULL))
			{
				col_max = col_max->next;
				continue;
			}
			cell_struct = cell_ptr->cell;

			if (cell_ptr->rowspan > 1)
			{
				int32 i;
				int32 height;
				int32 tmp_val;
				int32 cell_height;
				lo_table_span *max_ptr;

				max_ptr = row_max;

				height = max_ptr->dim;
				for (i=1; i < cell_ptr->rowspan; i++)
				{
				    max_ptr = max_ptr->next;
				    height = height + cell_pad +
					max_ptr->dim;
				}
				tmp_val = cell_ptr->baseline -
				    row_max->min_dim;
				if (tmp_val > 0)
				{
				    row_max->min_dim += tmp_val;
				    if (row_ptr->vert_alignment ==
						LO_ALIGN_BASELINE)
				    {
						row_max->dim += tmp_val;
						height += tmp_val;
				    }
				    /*
				     * Baseline spacing shouldn't grow the
				     * max height, except for baseline
				     * aligned rows as above.
				     */
				    if (row_max->min_dim > row_max->dim)
				    {
						row_max->min_dim = row_max->dim;
				    }
				}

				cell_height = cell_struct->height +
					(top_inner_pad + bottom_inner_pad) +
					(2 * cell_struct->border_vert_space);

				if (height < cell_height)
				{
					int32 add_height;
					int32 add;
					lo_table_span *add_ptr;

					add_ptr = row_max;
					add_height = cell_height -
						height;
					add = 0;
					while (add_ptr != max_ptr)
					{
						int32 newHeight;

						newHeight = add_height *
							add_ptr->dim /
							height;
						add_ptr->dim +=
							newHeight;
						add += newHeight;
						add_ptr->min_dim = add_ptr->dim;
						add_ptr = add_ptr->next;
					}
					add_ptr->dim +=
						(add_height - add);
					add_ptr->min_dim = add_ptr->dim;
				}
			}
			col_max = col_max->next;
		}
		row_max = row_max->next;
		row_ptr = row_ptr->next;
	}
}


static void
lo_free_cell_record(MWContext *context, lo_DocState *state, lo_TableCell *cell)
{
	if (cell == NULL)
	{
		return;
	}

	/*
	 * If this table cell is not nested inside another table cell
	 * or caption, free any re-parse tags stored on this cell.
	 */
	if ((cell->in_nested_table == FALSE) &&
		(cell->subdoc_tags != NULL)&&
		(state->is_a_subdoc != SUBDOC_CELL)&&
		(state->is_a_subdoc != SUBDOC_CAPTION))
	{
		PA_Tag *tptr;
		PA_Tag *tag;

		tptr = cell->subdoc_tags;
		while ((tptr != cell->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);
		}
		cell->subdoc_tags = NULL;
		cell->subdoc_tags_end = NULL;
	}

	if (cell->cell != NULL) {
		cell->cell->table = NULL;
		cell->cell->table_row = NULL;
		cell->cell->table_cell = NULL;
	}	

	XP_DELETE(cell);
}


static void

lo_free_row_record(MWContext *context, lo_DocState *state,
			lo_TableRow *row, Bool partial)
{
	lo_TableCell *cell_ptr;
	lo_TableCell *cell;

	if (row->cell_list != NULL)
	{
		/*
		 * These are already freed on a completed table, and
		 * need to be freed on a partial table.
		 */

		if (partial != FALSE)
		{
			cell_ptr = row->cell_list;
			while (cell_ptr != NULL)
			{
				cell = cell_ptr;
				cell_ptr = cell_ptr->next;
				lo_free_cell_record(context, state, cell);
			}
		}

		row->cell_list = NULL;
		row->cell_ptr = NULL;
	}

    XP_FREEIF(row->backdrop.bg_color);
    XP_FREEIF(row->backdrop.url);

	XP_DELETE(row);
}


static void lo_FreeTableCaption( MWContext *context, lo_DocState *state, lo_TableRec *table )
{
	if (table->caption != NULL)
	{
		if (table->caption->cell_ele != NULL)
		{
			lo_FreeCaptionCell( context, state, table->caption->cell_ele );
			table->caption->cell_ele = NULL;
		}

		if ( table->caption->subdoc != NULL )
		{
			lo_FreePartialSubDoc ( context, state, table->caption->subdoc );
			table->caption->subdoc = NULL;
		}
		
		XP_DELETE(table->caption);
		table->caption = NULL;
	}
}

void lo_free_table_record(MWContext *context, lo_DocState *state,
			lo_TableRec *table, Bool partial)
{
	if (table->row_list != NULL)
	{
		lo_TableRow *row_ptr;
		lo_TableRow *row;

		row_ptr = table->row_list;
		while (row_ptr != NULL)
		{
			row = row_ptr;
			row_ptr = row_ptr->next;
			lo_free_row_record(context, state, row, partial);
		}
		table->row_list = NULL;
		table->row_ptr = NULL;
	}

	lo_FreeTableCaption( context, state, table );

	if (table->width_spans != NULL)
	{
		lo_table_span *span_ptr;
		lo_table_span *span;

		span_ptr = table->width_spans;
		while (span_ptr != NULL)
		{
			span = span_ptr;
			span_ptr = span_ptr->next;
			XP_DELETE(span);
		}
		table->width_spans = NULL;
		table->width_span_ptr = NULL;
	}

	if (table->height_spans != NULL)
	{
		lo_table_span *span_ptr;
		lo_table_span *span;

		span_ptr = table->height_spans;
		while (span_ptr != NULL)
		{
			span = span_ptr;
			span_ptr = span_ptr->next;
			XP_DELETE(span);
		}
		table->height_spans = NULL;
		table->height_span_ptr = NULL;
	}

    XP_FREEIF(table->backdrop.bg_color);
    XP_FREEIF(table->backdrop.url);

	/*
	 * Whether the partial flag is set or not, we always
	 * want to eliminate this subdoc and all its contents
	 * when the table is done.
	 */
	if (table->current_subdoc != NULL)
	{
		lo_FreePartialSubDoc(context, state, table->current_subdoc);
		table->current_subdoc = NULL;
	}

	if ( table->fixed_col_widths != NULL )
	{
		XP_FREE(table->fixed_col_widths);
	}
	
	/*
	 * Reset back pointer in table layout element
	 */
	if (table->table_ele != NULL) {
		table->table_ele->table = NULL;
	}

	XP_DELETE(table);
}



void
lo_FreePartialTable(MWContext *context, lo_DocState *state, lo_TableRec *table)
{
	lo_TableRow *row_ptr;
	lo_TableCell *cell_ptr;
	LO_SubDocStruct *subdoc;
	LO_CellStruct *cell_struct;

	if (table == NULL)
	{
		return;
	}

	row_ptr = table->row_list;
	while (row_ptr != NULL)
	{
		cell_ptr = row_ptr->cell_list;
		while (cell_ptr != NULL)
		{
			cell_struct = cell_ptr->cell;
			lo_FreePartialCell(context, state, cell_struct);
			cell_ptr->cell = NULL;
			cell_ptr = cell_ptr->next;
		}
		row_ptr = row_ptr->next;
	}

	if (table->caption != NULL)
	{
		subdoc = table->caption->subdoc;
		lo_FreePartialSubDoc(context, state, subdoc);
		table->caption->subdoc = NULL;
	}

	lo_free_table_record(context, state, table, TRUE);
}



void
lo_EndTable(MWContext *context, lo_DocState *state, lo_TableRec *table, Bool relayout)
{
	int32 save_doc_min_width;
	int32 x, y;
	int32 cell_x, cell_y;
	int32 indx;
	int32 cell_cnt;
	int32 ele_cnt;
	int32 table_width, min_table_width;
	int32 base_table_width, min_base_table_width;
	int32 table_height;
	int32 min_table_height;
	int32 width_limit;
	Bool relayout_pass;
	Bool rowspan_pass;
	Bool cut_to_window_width;
	lo_TableCell blank_cell;
	lo_cell_data XP_HUGE *cell_array;
	XP_Block cell_array_buff;
	lo_table_span *row_max;
	lo_table_span *col_max;
	lo_TableCell *cell_ptr;
	int32 cell_pad;
	int32 top_inner_pad;
	int32 bottom_inner_pad;
	int32 left_inner_pad;
	int32 right_inner_pad;
	int32 table_pad;
	Bool floating;
	int32 save_state_x, save_state_y;
	LO_Element *save_line_list;
#ifdef LOCAL_DEBUG
fprintf(stderr, "lo_EndTable called\n");
#endif /* LOCAL_DEBUG */

	cell_pad = FEUNITS_X(table->inter_cell_pad, context);
	table_pad = FEUNITS_X(TABLE_DEF_CELL_BORDER, context);
	
	top_inner_pad = FEUNITS_X(table->inner_top_pad, context);
	bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context);
	left_inner_pad = FEUNITS_X(table->inner_left_pad, context);
	right_inner_pad = FEUNITS_X(table->inner_right_pad, context);
	
	relayout_pass = FALSE;
	cut_to_window_width = TRUE;
	floating = FALSE;

	/*
	 * So gcc won't complain
	 */
	save_state_x = 0;
	save_state_y = 0;
	save_line_list = NULL;
/*
	state->current_table = NULL;
*/

	cell_cnt = table->rows * table->cols;
	/*
	 * Empty tables are completely ignored!
	 */
	if (cell_cnt <= 0)
	{
		/*
		 * Clear table state, and free up this structure.
		 */
		state->current_table = NULL;

		/* 
		 * Don't wanna free table record any more because this information
		 * is used during relayout.
		 */
		/*
		if (table != NULL)
		{
			lo_free_table_record(context, state, table, FALSE);
		}		  
		*/
		return;
	}
#ifdef XP_WIN16
	/*
	 * It had better be the case that the size of the struct is a
	 * power of 2
	 */
	XP_ASSERT(sizeof(lo_cell_data) == 8);
	cell_array = (lo_cell_data XP_HUGE *)_halloc(cell_cnt, sizeof(lo_cell_data));

	/*
	 * There isn't a runtime routine that can initialize a huge array
	 */
	if (cell_cnt * sizeof(lo_cell_data) <= 0xFFFFL)
		memset(cell_array, 0, (cell_cnt * sizeof(lo_cell_data)));
	else {
		BYTE XP_HUGE *tmp = (BYTE XP_HUGE *)cell_array;

		for (indx = 0; indx < cell_cnt * sizeof(lo_cell_data); indx++)
			tmp[indx] = 0;
	}
#else
	cell_array_buff = XP_ALLOC_BLOCK(cell_cnt * sizeof(lo_cell_data));
	XP_LOCK_BLOCK(cell_array, lo_cell_data *, cell_array_buff);
	memset(cell_array, 0, (cell_cnt * sizeof(lo_cell_data)));
#endif

	lo_fill_cell_array(table, cell_array, &blank_cell, cell_pad,
		&relayout_pass);

	table_width = 0;
	min_table_width = 0;
	base_table_width = 0;
	min_base_table_width = 0;
	col_max = table->width_spans;
	while (col_max != NULL)
	{
		base_table_width += col_max->dim;
		min_base_table_width += col_max->min_dim;
		table_width = table_width + cell_pad + col_max->dim;
		min_table_width = min_table_width + cell_pad + col_max->min_dim;
		col_max = col_max->next;
	}
	table_width += cell_pad;
	min_table_width += cell_pad;
	table_width += (table->table_ele->border_left_width + 
		table->table_ele->border_right_width);
	min_table_width += (table->table_ele->border_left_width + 
		table->table_ele->border_right_width);
	if (table->draw_borders == TABLE_BORDERS_OFF)
	{
		table_width += (2 * table_pad);
		min_table_width += (2 * table_pad);
	}

	/*
	 * Take care of cells with percentage widths unless we're in
	 * a fixed layout table (has the COLS attribute) in which case
	 * the cell widths are already set.
	 */
	if ((table->has_percent_width_cells != FALSE) &&
		(table->fixed_cols == 0))
	{
		lo_percent_width_cells(table, cell_array, &blank_cell,
			cell_pad, table_pad, &table_width, &min_table_width,
			&base_table_width, &min_base_table_width);
		relayout_pass = TRUE;
	}

	/*
	 * Use state->left_margin here instead of state->win_left to take
	 * indent from lists into account.
	 */
	width_limit = (state->win_width - state->left_margin - state->win_right);
	if (table->width > 0)
	{
		width_limit = table->width;
	}
	/*
	 * Else, if we are a nested table in an infinite width
	 * layout space, we don't want to cut to "window width"
	 */
	else if (state->allow_percent_width == FALSE)
	{
		cut_to_window_width = FALSE;
	}

	/*
	 * If we're in a fixed layout table, then we never
	 * want to cut to "window width" 
	 */
	if ( table->fixed_cols > 0 )
	{
		cut_to_window_width = FALSE;
	}

	/*
	 * If the table is too small, we always need to relayout.
	 */
	if ((min_table_width >= width_limit))
	{
		lo_table_span *sub_ptr;

		relayout_pass = TRUE;
		sub_ptr = table->width_spans;
		while (sub_ptr != NULL)
		{
			sub_ptr->dim = sub_ptr->min_dim;
			sub_ptr = sub_ptr->next;
		}
	}
	else if ((table_width > width_limit)&&(cut_to_window_width != FALSE))
	{
		intn pass;
		Bool expand_failed;
		int32 add_width;
		int32 div_width;
		int32 div_width_next;
		int32 add;
		int32 total_to_add;
		lo_table_span *add_ptr;

		relayout_pass = TRUE;

		expand_failed = TRUE;
		pass = 0;
		total_to_add = width_limit - min_table_width;
		div_width = table_width;
		while ((total_to_add > 0)&&(pass < 10)&&(expand_failed !=FALSE))
		{
			int32 extra;
			int32 min_extra;

			expand_failed = FALSE;
			add_ptr = table->width_spans;
			add_width = total_to_add;
			total_to_add = 0;
			div_width_next = (table->cols + 1) * cell_pad;
			add = 0;
			while (add_ptr->next != NULL)
			{
				if ((pass > 0)&&
					(add_ptr->min_dim == add_ptr->dim))
				{
					add_ptr = add_ptr->next;
					continue;
				}
				extra = add_width * add_ptr->dim /
					div_width;
				if ((add_ptr->min_dim + extra) > add_ptr->dim)
				{
					expand_failed = TRUE;
					min_extra = add_ptr->dim -
						add_ptr->min_dim;
					extra = min_extra;
				}

				add_ptr->min_dim += extra;
				if (add_ptr->min_dim < add_ptr->dim)
				{
					div_width_next += add_ptr->dim;
				}
				add += extra;
				add_ptr = add_ptr->next;
			}
			if ((pass == 0)||(add_ptr->min_dim < add_ptr->dim))
			{
				if (expand_failed == FALSE)
				{
					extra = add_width - add;
				}
				else
				{
					extra = add_width * add_ptr->dim /
						div_width;
				}
				if ((add_ptr->min_dim + extra) > add_ptr->dim)
				{
					expand_failed = TRUE;
					min_extra = add_ptr->dim -
						add_ptr->min_dim;
					extra = min_extra;
				}
				add_ptr->min_dim += extra;
				if (add_ptr->min_dim < add_ptr->dim)
				{
					div_width_next += add_ptr->dim;
				}
				add += extra;
			}
			total_to_add = add_width - add;
			div_width = div_width_next;
			pass++;
		}
		if (total_to_add > 0)
		{
			add = 0;
			add_ptr = table->width_spans;
			while ((add_ptr->next != NULL)&&(total_to_add > 0))
			{
				if ((add_ptr->min_dim + total_to_add) >
					add_ptr->dim)
				{
					add = add_ptr->dim - add_ptr->min_dim;
					total_to_add = total_to_add - add;
					add_ptr->min_dim += add;
				}
				else
				{
					add_ptr->min_dim += total_to_add;
					total_to_add = 0;
				}
				add_ptr = add_ptr->next;
			}
			add_ptr->min_dim += total_to_add;
		}

		add_ptr = table->width_spans;
		while (add_ptr != NULL)
		{
			add_ptr->dim = add_ptr->min_dim;
			add_ptr = add_ptr->next;
		}
	}

	/*
	 * If the user specified a wider width than the minimum
	 * width then we grow the sucker.
	 */
	if ((table->width > 0)&&(width_limit > table_width))
	{
		int32 add_width;
		int32 add;
		int32 newWidth;
		int32 min_add_width;
		int32 min_add;
		lo_table_span *add_ptr;

		/* relayout to fill all the space we're adding */
		relayout_pass = TRUE;
		
		add_ptr = table->width_spans;
		add_width = width_limit - table_width;
		if ( add_width < 0 )
		{
			add_width = 0;
		}
		add = 0;
		min_add_width = width_limit - min_table_width;
		min_add = 0;
		while ((add_ptr != NULL)&&(add_ptr->next != NULL))
		{
			newWidth = add_width * add_ptr->dim / base_table_width;
			add_ptr->dim += newWidth;
			add += newWidth;

			/*
			 * We only want to resize the min_dim's of the spans
			 * if we're a fixed width table.
			 */
			if ( table->table_width_fixed )
			{
				newWidth = min_add_width * add_ptr->min_dim / min_base_table_width;
				add_ptr->min_dim += newWidth;
				min_add += newWidth;
			}
			add_ptr = add_ptr->next;
		}
		if ( table->table_width_fixed )
		{
			add_ptr->min_dim += (min_add_width - min_add);
		}
		add_ptr->dim += (add_width - add);
	}

	rowspan_pass = FALSE;

	if ((state->top_state->doc_state == state) ||
		(state->top_state->in_cell_relayout == TRUE))
	{

		if (state->top_state->doc_state == state)
		{
			state->top_state->in_cell_relayout = TRUE;
		}		

		if (relayout_pass != FALSE)
		{	
			lo_cell_relayout_pass(context, state, table, cell_array,
				&blank_cell, cell_pad, &rowspan_pass, relayout);	
		}

		if (rowspan_pass != FALSE)
		{
			lo_cell_rowspan_pass(context, table, cell_array, &blank_cell,
				cell_pad);
		}

		if (state->top_state->doc_state == state)
		{
			state->top_state->in_cell_relayout = FALSE;
		}
	}

	table_width = 0;
	min_table_width = 0;
	col_max = table->width_spans;
	while (col_max != NULL)
	{
		table_width = table_width + cell_pad + col_max->dim;
		min_table_width = min_table_width + cell_pad + col_max->min_dim;
		col_max = col_max->next;
	}
	table_width += cell_pad;
	table_width += (table->table_ele->border_left_width + 
		table->table_ele->border_right_width);
	min_table_width += cell_pad;
	min_table_width += (table->table_ele->border_left_width + 
		table->table_ele->border_right_width);

	table_height = 0;
	min_table_height = 0;
	row_max = table->height_spans;
	while (row_max != NULL)
	{
		table_height = table_height + cell_pad + row_max->dim;
		min_table_height = min_table_height + cell_pad + row_max->min_dim;
		row_max = row_max->next;
	}
	table_height += cell_pad;
	min_table_height += cell_pad;
	table_height += (table->table_ele->border_top_width + 
		table->table_ele->border_bottom_width);
	min_table_height += (table->table_ele->border_top_width + 
		table->table_ele->border_bottom_width);
	if (table->draw_borders == TABLE_BORDERS_OFF)
	{
		table_width += (2 * table_pad);
		min_table_width += (2 * table_pad);
		table_height += (2 * table_pad);
		min_table_height += (2 * table_pad);
	}


	/*
	 * If the user specified a taller table than the min
	 * height we need to adjust the heights of all the rows.
	 */
	if ((table->height > 0)&&(table->height > min_table_height))
	{
		int32 add_height;
		int32 add;
		lo_table_span *add_ptr;
		int32 newHeight;
		int32 min_add_height;
		int32 min_add;

		add_ptr = table->height_spans;
		add_height = table->height - table_height;
		if ( add_height < 0 )
		{
			add_height = 0;
		}
		min_add_height = table->height - min_table_height;
		add = 0;
		min_add = 0;
		while((add_ptr != NULL) && (add_ptr->next != NULL))
		{
			newHeight = add_height * add_ptr->dim / table_height;
			add_ptr->dim += newHeight;
			add += newHeight;
			
			newHeight = min_add_height * add_ptr->min_dim / table_height;
			add_ptr->min_dim += newHeight;
			min_add += newHeight;
			
			add_ptr = add_ptr->next;
		}
		add_ptr->dim += (add_height - add);
		add_ptr->min_dim += (min_add_height - min_add);

		/*
		 * We can't make the height be less than the sum
		 * of the row heights.
		 */
		if (table_height < table->height)
		{
			table_height = table->height;
		}
		min_table_height = table->height;
	}

	table->table_ele->width = table_width;
	table->table_ele->height = table_height;

	/*
	 * Here, if we are floating we don't do the linebreak.
	 * We do save some state info and then "fake" a linebreak
	 * so we can use common code to place the rest of the table.
	 */
	if (table->table_ele->ele_attrmask & LO_ELE_FLOATING)
	{
		save_line_list = state->line_list;
		save_state_x = state->x;
		save_state_y = state->y;
		floating = TRUE;
		state->x = state->left_margin;
		state->y = state->y + state->line_height;
		state->line_list = NULL;
	}
	else
	{
		/*
		lo_SetSoftLineBreakState(context, state, FALSE, 1);
		*/
		lo_SetLineBreakState ( context, state, FALSE, LO_LINEFEED_BREAK_SOFT, 1, relayout );
	}

	table->table_ele->x = state->x;
	table->table_ele->y = state->y;
	/* Keep the element IDs in order */
	table->table_ele->ele_id = NEXT_ELEMENT;
    
    /*cmanske - Save spacing param for drawing table selection in Composer */
    table->table_ele->inter_cell_space = table->inter_cell_pad;

	lo_AppendToLineList(context, state,
		(LO_Element *)table->table_ele, 0);

#ifdef EDITOR
    /*cmanske - build list of tables we are laying out
     * so Editor can readjust it's data after all is finished 
     */
    EDT_AddToRelayoutTables(context, table->table_ele);
#endif

	state->x += (cell_pad + table->table_ele->border_left_width);
	state->y += (cell_pad + table->table_ele->border_top_width);
	if (table->draw_borders == TABLE_BORDERS_OFF)
	{
		state->x += table_pad;
		state->y += table_pad;
	}

	if (table->caption != NULL)
	{
		int32 new_width;
		LO_SubDocStruct *subdoc;
		Bool has_elements;

		subdoc = table->caption->subdoc;

		col_max = table->width_spans;
		new_width = col_max->dim;
		while (col_max->next != NULL)
		{
			col_max = col_max->next;
			new_width = new_width + cell_pad + col_max->dim;
		}
		/*
		 * Don't relayout documents that have no
		 * elements, it causes errors.
		 */
		has_elements = lo_subdoc_has_elements(subdoc->state);
		if ((new_width < table->caption->max_width)&&
			(has_elements == FALSE))
		{
			int32 inside_width;

			inside_width = new_width -
			    (2 * subdoc->border_width) -
			    (2 * subdoc->border_horiz_space) -
			    (left_inner_pad + right_inner_pad);
			subdoc->width = inside_width;
		}
		else /* if (new_width < table->caption->max_width) */
		{
			int32 inside_width;

			inside_width = new_width -
			    (2 * subdoc->border_width) -
			    (2 * subdoc->border_horiz_space) -
			    (left_inner_pad + right_inner_pad);
			table->caption->subdoc = lo_RelayoutCaptionSubdoc(context,
				state, table->caption, subdoc, inside_width, FALSE);
			subdoc = table->caption->subdoc;

			table->caption->height = subdoc->height +
				(2 * subdoc->border_vert_space) +
				(top_inner_pad + bottom_inner_pad);
			table->caption->max_width = new_width;
		}
		/*
		else
		{
			table->caption->max_width = new_width;
		}
		*/
	}

	state->current_table = NULL;
	cell_x = state->x;
	cell_y = state->y;

	if ((table->caption != NULL)&&
		(table->caption->vert_alignment == LO_ALIGN_TOP))
	{
		LO_SubDocStruct *subdoc;

		cell_x = state->x;
		subdoc = table->caption->subdoc;
		subdoc->x = cell_x;
		subdoc->y = table->table_ele->y;
		subdoc->x_offset = (int16)subdoc->border_horiz_space;
		subdoc->y_offset = (int32)subdoc->border_vert_space;
		subdoc->width = table->caption->max_width -
			(2 * subdoc->border_horiz_space);
		subdoc->height = table->caption->height -
			(2 * subdoc->border_vert_space);
		ele_cnt = lo_align_subdoc(context, state,
			(lo_DocState *)subdoc->state, subdoc, table, NULL);
		if (ele_cnt > 0)
		{
			LO_CellStruct *cell_ele;
			
			if (relayout == FALSE)
			{
				/*
				cell_ele = lo_SquishSubDocToCell(context, state,
					subdoc, TRUE);
				*/
				cell_ele = lo_SquishSubDocToCell(context, state,
					subdoc, FALSE);
				cell_ele->isCaption = TRUE;
				table->caption->cell_ele = cell_ele;
			}
			else
			{
				cell_ele = table->caption->cell_ele;
				lo_UpdateCaptionCellFromSubDoc(context, state, subdoc, cell_ele);
			}
			/* table->caption->subdoc = NULL; */

			if (cell_ele == NULL)
			{
				lo_AppendToLineList(context, state,
					(LO_Element *)subdoc, 0);
			}
			else
			{
                /*cmanske - Save spacing param for drawing cell selection by FEs */
                /* should we use cell_pad (converted to FE units) instead? */
                cell_ele->inter_cell_space = table->inter_cell_pad;
				lo_AppendToLineList(context, state,
					(LO_Element *)cell_ele, 0);
			}
			cell_x = state->x;
			cell_y = cell_y + table->caption->height + cell_pad;

			table->table_ele->y_offset = cell_y -
				table->table_ele->y;
			cell_y += (cell_pad + table->table_ele->border_top_width);
			if (table->draw_borders == TABLE_BORDERS_OFF)
			{
				cell_y += table_pad;
			}
		}
		else
		{
			LO_CellStruct *cell_ele;

			/*
			 * Free up the useless subdoc
			 */
			cell_ele = lo_SquishSubDocToCell(context, state,
						subdoc, TRUE);
			table->caption->subdoc = NULL;

			if (cell_ele != NULL)
			{
				lo_FreeElement(context,
					(LO_Element *)cell_ele, TRUE);
			}
		}
	}

	row_max = table->height_spans;
	for (y=0; y < table->rows; y++)
	{
		cell_x = state->x;
		col_max = table->width_spans;
		for (x=0; x < table->cols; x++)
		{
			LO_CellStruct *cell_struct;
			int32 new_x, new_y;

			indx = (y * table->cols) + x;
			cell_ptr = cell_array[indx].cell;
			if ((cell_ptr == &blank_cell)||(cell_ptr == NULL))
			{
				cell_x = cell_x + col_max->dim + cell_pad;
				col_max = col_max->next;
				continue;
			}
			cell_struct = cell_ptr->cell;
/*
			cell_struct->x = cell_x;
			cell_struct->y = cell_y;
			cell_struct->x_offset = (int16)cell_struct->border_horiz_space;
			cell_struct->y_offset = (int32)cell_struct->border_vert_space;
*/

			new_x = cell_x + (int16)cell_struct->border_horiz_space + cell_struct->border_width;
			new_y = cell_y + (int32)cell_struct->border_vert_space + cell_struct->border_width;

			cell_struct->width = col_max->dim;
			if (cell_ptr->colspan > 1)
			{
				int32 i;
				lo_table_span *max_ptr;

				max_ptr = col_max;

				for (i=1; i < cell_ptr->colspan; i++)
				{
					max_ptr = max_ptr->next;
					cell_struct->width = cell_struct->width +
						cell_pad + max_ptr->dim;
				}
			}
			cell_struct->width = cell_struct->width -
				(2 * cell_struct->border_horiz_space);
			cell_struct->height = row_max->dim;
			if (cell_ptr->rowspan > 1)
			{
				int32 i;
				lo_table_span *max_ptr;

				max_ptr = row_max;

				for (i=1; i < cell_ptr->rowspan; i++)
				{
					max_ptr = max_ptr->next;
					cell_struct->height = cell_struct->height +
						cell_pad + max_ptr->dim;
				}
			}
			cell_struct->height = cell_struct->height -
				(2 * cell_struct->border_vert_space);

			lo_ShiftCell(cell_struct,
				cell_ptr->cell_base_x, cell_ptr->cell_base_y);
			cell_ptr->cell_base_x = 0;
			cell_ptr->cell_base_y = 0;
			ele_cnt = lo_align_cell(context, state, cell_ptr,
					cell_struct, table, row_max);
			/*
			if (ele_cnt > 0)
			*/
			{
				LO_CellStruct *cell_ele;
				int32 shift_x, shift_y;



				shift_x = new_x - cell_struct->x -
					cell_struct->x_offset -
					cell_struct->border_width;
				shift_y = new_y - cell_struct->y -
					cell_struct->y_offset -
					cell_struct->border_width;
				cell_struct->x = cell_x;
				cell_struct->y = cell_y;
				cell_struct->x_offset = (int16)cell_struct->border_horiz_space;
				cell_struct->y_offset = (int32)cell_struct->border_vert_space;
				cell_ele = cell_struct;

/*
				lo_ShiftCell(cell_ele, shift_x, shift_y);
*/
				lo_ShiftCell(cell_ele, new_x, new_y);
				/*
				 * Keep element ids sequential.
				 */
				if (cell_ele != NULL)
				{
					cell_ele->ele_id = NEXT_ELEMENT;
					lo_RenumberCell(state, cell_ele);
				}

				if (cell_ele == NULL)
				{
					lo_AppendToLineList(context, state,
						(LO_Element *)cell_struct, 0);
				}
				else
				{
                    /*cmanske - Save spacing param for drawing cell selection by FEs */
                    cell_ele->inter_cell_space = table->inter_cell_pad;
					lo_AppendToLineList(context, state,
						(LO_Element *)cell_ele, 0);
				}

				if ( relayout == FALSE )
				{
					/*
					 * Cell backgrounds now sit in their own layer. This is needed
					 * for selection to work correctly.
					 * Cell backgrounds can exist in the main _BODY layer,
					 * so we need to special case the parent layer of the
					 * cell background,
					 */
					if (context->compositor &&
						(cell_ele->backdrop.bg_color || cell_ele->backdrop.url))
					{
						lo_TopState *top_state = state->top_state;
						CL_Layer *parent_layer = lo_CurrentLayer(state);
						if (parent_layer == top_state->doc_layer)
							parent_layer = top_state->body_layer;
						cell_ele->cell_bg_layer =
							lo_CreateCellBackgroundLayer(context, cell_ele,
														 parent_layer);
					}
					else
					{
						cell_ele->cell_bg_layer = NULL;
					}
				}
			}
			/*
			else
			{
			*/
				/*
				LO_CellStruct *cell_ele;
				*/
				/*
				 * Free up the useless cell
				 */			
			/*
				cell_ele = cell_struct;
				if (cell_ele != NULL)
				{
					lo_FreeElement(context,
						(LO_Element *)cell_ele, TRUE);
				}
				
			}
			*/
			cell_x = cell_x + col_max->dim + cell_pad;
			col_max = col_max->next;
		}
		cell_y = cell_y + row_max->dim + cell_pad;
		row_max = row_max->next;
	}
	cell_x = cell_x + table->table_ele->border_left_width;
	cell_y = cell_y + table->table_ele->border_top_width;
	if (table->draw_borders == TABLE_BORDERS_OFF)
	{
		cell_x += table_pad;
		cell_y += table_pad;
	}

	if ((table->caption != NULL)&&
		(table->caption->vert_alignment != LO_ALIGN_TOP))
	{
		LO_SubDocStruct *subdoc;

		subdoc = table->caption->subdoc;
		subdoc->x = state->x;
		subdoc->y = cell_y;
		subdoc->x_offset = (int16)subdoc->border_horiz_space;
		subdoc->y_offset = (int32)subdoc->border_vert_space;
		subdoc->width = table->caption->max_width -
			(2 * subdoc->border_horiz_space);
		subdoc->height = table->caption->height -
			(2 * subdoc->border_vert_space);
		ele_cnt = lo_align_subdoc(context, state,
			(lo_DocState *)subdoc->state, subdoc, table, NULL);
		if (ele_cnt > 0)
		{
			LO_CellStruct *cell_ele;

			if (relayout == FALSE)
			{
				/*
				cell_ele = lo_SquishSubDocToCell(context, state,
						subdoc, TRUE);
				*/
				cell_ele = lo_SquishSubDocToCell(context, state,
						subdoc, FALSE);
				cell_ele->isCaption = TRUE;
				table->caption->cell_ele = cell_ele;
			}
			else 
			{
				cell_ele = table->caption->cell_ele;
				lo_UpdateCaptionCellFromSubDoc(context, state, subdoc, cell_ele);
			}
			
			/* table->caption->subdoc = NULL; */

			if (cell_ele == NULL)
			{
				lo_AppendToLineList(context, state,
					(LO_Element *)subdoc, 0);
			}
			else
			{
                /*cmanske - Save spacing param for drawing cell selection by FEs */
                cell_ele->inter_cell_space = table->inter_cell_pad;
				lo_AppendToLineList(context, state,
					(LO_Element *)cell_ele, 0);
			}
			cell_y = cell_y + table->caption->height + cell_pad;
		}
		else
		{
			LO_CellStruct *cell_ele;

			/*
			 * Free up the useless subdoc
			 */
			cell_ele = lo_SquishSubDocToCell(context, state,
						subdoc, TRUE);
			table->caption->subdoc = NULL;
			
			if (cell_ele != NULL)
			{
				lo_FreeElement(context,
					(LO_Element *)cell_ele, TRUE);
			}
		}
	}

	/*
	 * This table may have contained named anchors.
	 * This will correct their positions in the name_list,
	 * and unblock us if we were blocked on them.
	 */
	lo_CheckNameList(context, state, table->table_ele->ele_id);

	/*
	 * The usual stuff for a table.
	 */
	if (floating == FALSE)
	{
		lo_AlignStack *aptr;
		int32 indent;

		state->x = cell_x;
		state->baseline = 0;
		state->line_height = cell_y - state->y;
		state->linefeed_state = 0;
		state->at_begin_line = FALSE;
		state->trailing_space = FALSE;
		state->cur_ele_type = LO_SUBDOC;

		table->table_ele->line_height = state->line_height;

		/*
		 * Find how far the table might be indented from
		 * being inside a list.
		 */
		indent = state->list_stack->old_left_margin - state->win_left;
		if (indent < 0)
		{
			indent = 0;
		}

		save_doc_min_width = state->min_width;
		if (relayout == FALSE) 
		{
			lo_SoftLineBreak(context, state, FALSE);
		}
		else
		{
			lo_rl_AddBreakAndFlushLine( context, state, LO_LINEFEED_BREAK_SOFT, LO_CLEAR_NONE, FALSE );
		}

		if ((min_table_width + indent) > save_doc_min_width)
		{
			save_doc_min_width = min_table_width + indent;
		}
		state->min_width = save_doc_min_width;
		
		/*
		 * Pop the table's alignment.
		 */
		aptr = lo_PopAlignment(state);
		if (aptr != NULL)
		{
			XP_DELETE(aptr);
		}
	}
	/*
	 * Else this is a floating table, rip it out of the "faked"
	 * line list, stuff itin the margin, and restore our state
	 * to where we left off.
	 */
	else
	{
		int32 push_right;
		int32 line_height;
                LO_Element *tptr;
                LO_Element *last;

		line_height = cell_y - state->y;
		push_right = 0;
		if (table->table_ele->alignment == LO_ALIGN_RIGHT)
		{
			push_right = state->right_margin - cell_x;
		}

		table->table_ele->x_offset +=
			(int16)table->table_ele->border_horiz_space;
		table->table_ele->y_offset +=
			(int32)table->table_ele->border_vert_space;

		last = NULL;
		tptr = state->line_list;
		while (tptr != NULL)
		{
			tptr->lo_any.x += push_right;
			if (tptr->type == LO_CELL)
			{
				tptr->lo_any.x +=
					table->table_ele->border_horiz_space;
				tptr->lo_any.y +=
					table->table_ele->border_vert_space;
				lo_ShiftCell((LO_CellStruct *)tptr,
					(push_right +
					table->table_ele->border_horiz_space),
					table->table_ele->border_vert_space);
			}
			last = tptr;
			tptr->lo_any.line_height = line_height;
			tptr = tptr->lo_any.next;
		}

		/*
		 * Stuff the whole line list into the float list, and
		 * restore the line list to its pre-table state.
		 */
		if (state->line_list != NULL)
		{
			last->lo_any.next = state->float_list;
			state->float_list = state->line_list;
			state->line_list = NULL;
		}

		if (relayout == FALSE)
		{
			lo_AppendFloatInLineList(state, (LO_Element *)table->table_ele, save_line_list );
		}
		else
		{
			state->line_list = save_line_list;
		}
		

		table->table_ele->line_height = line_height;
		table->table_ele->expected_y = table->table_ele->y;
		table->table_ele->y = -1;

		lo_AddMarginStack(state,
			table->table_ele->x, table->table_ele->y,
                        table->table_ele->width, table->table_ele->line_height,
                        table->table_ele->border_left_width + 
                        	table->table_ele->border_right_width,
                        table->table_ele->border_vert_space,
			table->table_ele->border_horiz_space,
                        (intn)table->table_ele->alignment);

		/*
		 * Restore state to pre-table values.
		 */
		state->x = save_state_x;
		state->y = save_state_y;

		/*
		 * All the doc_min_width stuff makes state->min_width
		 * be correct for tables nested inside tables.
		 */
		save_doc_min_width = state->min_width;

		/*
		 * Standard float stuff, if we happen to be at the start
		 * of a line, place the table now.
		 */
		if (state->at_begin_line != FALSE)
		{
			lo_FindLineMargins(context, state, (! relayout));
			state->x = state->left_margin;
		}

		if (min_table_width > save_doc_min_width)
		{
			save_doc_min_width = min_table_width;
		}
		state->min_width = save_doc_min_width;

	}

	/*  Now cell records get freed when the LO_TABLE element in the line list gets recycled
	for (y=0; y < table->rows; y++)
	{
		for (x=0; x < table->cols; x++)
		{
			indx = (y * table->cols) + x;
			cell_ptr = cell_array[indx].cell;
			if ((cell_ptr != &blank_cell)&&(cell_ptr != NULL))
			{
				lo_free_cell_record(context, state, cell_ptr);
			}
		}
	}
	*/

	
#ifdef XP_WIN16
	_hfree(cell_array);
#else
	XP_UNLOCK_BLOCK(cell_array_buff);
	XP_FREE_BLOCK(cell_array_buff);
#endif

	/* 
	 * Don't wanna free the table record any more because this information
	 * is used during relayout.
	 */
	/*

	lo_free_table_record(context, state, table, FALSE);

	*/
}

/*
 * This function relaysout the tags in a table cell. It knows how to handle
 * certain types of elements that can be resused directly rather than thrown
 * away and relayedout from scratch (the default case).
 */
void
lo_RelayoutTags(MWContext *context, lo_DocState *state, PA_Tag * tag_ptr,
	PA_Tag * tag_end_ptr, LO_Element * elem_list)
{
	PA_Tag * next_tag;
	Bool save_diff_state;
	int32 save_state_pushes;
	int32 save_state_pops;
	lo_TopState *top_state;
	PA_Tag *tag_list;
	
	next_tag = NULL;
	top_state = state->top_state;

	/*
	 * Save our parent's state levels
	 */
	save_diff_state = top_state->diff_state;
	save_state_pushes = top_state->state_pushes;
	save_state_pops = top_state->state_pops;

	while (tag_ptr != tag_end_ptr)
	{
		PA_Tag *tag;
		lo_DocState *sub_state;
		lo_DocState *up_state;
		lo_DocState *tmp_state;
		Bool may_save;

		tag = tag_ptr;
		tag_ptr = tag_ptr->next;
		tag->next = NULL;
		tag_list = tag_ptr;

		up_state = NULL;
		sub_state = state;
		while (sub_state->sub_state != NULL)
		{
			up_state = sub_state;
			sub_state = sub_state->sub_state;
		}

		if ((sub_state->is_a_subdoc == SUBDOC_CELL)||
			(sub_state->is_a_subdoc == SUBDOC_CAPTION))
		{
			may_save = TRUE;
		}
		else
		{
			may_save = FALSE;
		}

		/*
		 * Reset these so we can tell if anything happened
		 */
		top_state->diff_state = FALSE;
		top_state->state_pushes = 0;
		top_state->state_pops = 0;

#ifdef MOCHA
		sub_state->in_relayout = TRUE;
#endif
		/*
		 * If we're not currently searching for a tag, then find the next
		 * one to look for.
		 */
		if ( next_tag == NULL && elem_list != NULL )
		{
			next_tag = lo_FindReuseableElement ( context, state, &elem_list );
		}
				
		/*
		 * Can we reuse this current element?
		 */
		if ( (tag == next_tag) && (elem_list != NULL) )
		{			
			LO_Element *eptr;
			LO_Element *enext;
			
			/*
			 * Yup, remove it from the list and call the object layout code to
			 * do the relayout.
			 */
			eptr = elem_list;
			enext = eptr->lo_any.next;
			
			elem_list = enext;
			
			if ( enext != NULL )
			{
				enext->lo_any.prev = NULL;
			}
			
			eptr->lo_any.next = 0L;
			eptr->lo_any.prev = 0L;
			
			switch ( eptr->type )
			{
				case LO_EMBED:
					lo_RelayoutEmbed ( context, sub_state, &eptr->lo_embed, tag );
					break;
#ifdef JAVA
				case LO_JAVA:
					lo_RelayoutJavaApp ( context, sub_state, tag, &eptr->lo_java );
					break;
#endif /* JAVA */
				
				default:
					/*
					 * We goofed and got something we don't know how to relayout
					 */
					lo_relayout_recycle ( context, state, eptr );
					lo_LayoutTag(context, sub_state, tag);
					break;
			}
			
			/*
			 * Force us to look for the next reusable element.
			 */
			next_tag = NULL;
		}
		else
		{
			/*
			 * Nope, call the standard layout code.
			 */
			lo_LayoutTag(context, sub_state, tag);
		}

		tmp_state = lo_CurrentSubState(state);
#ifdef MOCHA
		if (tmp_state == sub_state)
		{
			sub_state->in_relayout = FALSE;
		}
#endif

		tmp_state = lo_CurrentSubState(state);
#ifdef MOCHA
		if (tmp_state == sub_state)
		{
			sub_state->in_relayout = FALSE;
		}
#endif

		if (may_save != FALSE)
		{
			int32 state_diff;
			
			/* how has our state level changed? */
			state_diff = top_state->state_pushes - top_state->state_pops;
			
			/*
			 * That tag popped us up one state level.  If this new
			 * state is still a subdoc, save the tag there.
			 */
			if (state_diff == -1)
			{
				if ((tmp_state->is_a_subdoc == SUBDOC_CELL)||
				    (tmp_state->is_a_subdoc == SUBDOC_CAPTION))
				{
                    /* if we just popped a table we need to insert
                     * a dummy end tag to pop the dummy start tag
                     * we shove on the stack after createing a table
                     */
   					PA_Tag *new_tag = LO_CreateStyleSheetDummyTag(tag);
					if(new_tag)
					{
						lo_SaveSubdocTags(context, tmp_state, new_tag);
					}

				    lo_SaveSubdocTags(context, tmp_state, tag);
				}
				else
				{
				    PA_FreeTag(tag);
				}
			}
			/*
			 * Else that tag put us in a new subdoc on the same
			 * level.  It needs to be saved one level up,
			 * if the parent is also a subdoc.
			 */
			else if (( up_state != NULL ) &&
				( top_state->diff_state != FALSE ) &&
				( state_diff == 0 ))
			{
				if ((up_state->is_a_subdoc == SUBDOC_CELL)||
				     (up_state->is_a_subdoc == SUBDOC_CAPTION))
				{
				    lo_SaveSubdocTags(context, up_state, tag);
				}
				else
				{
				    PA_FreeTag(tag);
				}
			}
			/*
			 * Else we are still in the same subdoc
			 */
			else if (( top_state->diff_state == FALSE ) &&
				( state_diff == 0 ))
			{
				lo_SaveSubdocTags(context, sub_state, tag);
			}
			/*
			 * Else that tag started a new, nested subdoc.
			 * Add the starting tag to the parent.
			 */
			else if (( state_diff == 1 ))
			{
				lo_SaveSubdocTags(context, sub_state, tag);
				/*
				 * Since we have extended the parent chain,
				 * we need to reset the child to the new
				 * parent end-chain.
				 */
				if ((tmp_state->is_a_subdoc == SUBDOC_CELL)||
				    (tmp_state->is_a_subdoc == SUBDOC_CAPTION))
				{
					PA_Tag *new_tag;
					
					tmp_state->subdoc_tags =
						sub_state->subdoc_tags_end;

					/* add an aditional dummy tag so that style sheets
					 * can use it to query styles from for this entry
					 * that created a table
					 */
					new_tag = LO_CreateStyleSheetDummyTag(tag);
					if(new_tag)
					{
						lo_SaveSubdocTags(context, tmp_state, new_tag);
					}
				}
			}
			/*
			 * This can never happen.
			 */
			else
			{
				PA_FreeTag(tag);
			}
		}
		tag_ptr = tag_list;
	}

	/*
	 * Restore our parent's state levels
	 */
	top_state->diff_state = save_diff_state;
	top_state->state_pushes = save_state_pushes;
	top_state->state_pops = save_state_pops;
}


/*
 * Walk the element list, throwing them away until we find one
 * that can be reused.
 */
PA_Tag *
lo_FindReuseableElement(MWContext *context, lo_DocState *state, LO_Element ** elem_list)
{
	LO_Element * eptr;
	LO_Element * enext;
	PA_Tag * tag;
	
	tag = NULL;
	eptr = *elem_list;
	enext = NULL;
	
	/*
	 * Keep going until we've gone through all the elements
	 * or found one that we can reuse.
	 */
	while ( (eptr != NULL) && (tag == NULL) )
	{		
		enext = eptr->lo_any.next;
		
		/*
		 * Any element found by this switch statement will attempt to be relayed out
		 * using the same element structure. DO NOT put anything in here that can
		 * have atributes set by style sheets until the lo_PreLayoutTag function
		 * can correctly handle stylesheets.
		 */
		switch ( eptr->type )
		{
			case LO_EMBED:
				tag = eptr->lo_embed.tag;
				break;
#ifdef JAVA
			case LO_JAVA:
				tag = eptr->lo_java.tag;
				break;
#endif /* JAVA */
		}
		
		/*
		 * If we didn't find a tag from that element, then dispose of it and
		 * keep looking.
		 */
		if ( tag == NULL )
		{
			/*
			 * We dunno how to reuse this type of element, so throw
			 * it away and someone else will relay it out from scratch.
			 */				
			eptr->lo_any.prev = NULL;
			eptr->lo_any.next = NULL;
			lo_relayout_recycle ( context, state, eptr );
			if ( enext != NULL )
			{
				enext->lo_any.prev = NULL;
			}
			eptr = enext;
		}
	}
	/*
	 * Advance the element list to the new head
	 */
	*elem_list = eptr;
	
	return tag;
}

/* 
 * Functions separated out of lo_BeginTableAttributes
 */

void lo_PositionTableElement(lo_DocState *state, LO_TableStruct *table_ele) 
{
	table_ele->ele_id = NEXT_ELEMENT;
	table_ele->x = state->x;
	table_ele->x_offset = 0;
	table_ele->y = state->y;
	table_ele->y_offset = 0;
	table_ele->width = 0;
	table_ele->height = 0;
	table_ele->line_height = 0;

	table_ele->next = NULL;
	table_ele->prev = NULL;

	/*
	 * Push our alignment state if we're not floating
	 */
	
	if ( !(table_ele->ele_attrmask & LO_ELE_FLOATING) )
	{
		lo_PushAlignment(state, P_TABLE_DATA, table_ele->alignment);
	}
	
}


void lo_InitTableRecord( lo_TableRec *table )
{
	/* Reset row and col counters */
	table->rows = 0;
	table->cols = 0;

	/* Reset width span array */
	lo_ResetWidthSpans(table);

	table->height_span_ptr = NULL;
}

static void lo_ResetWidthSpans( lo_TableRec *table )
{
	lo_table_span *span = table->width_spans;

	while (span != NULL)
	{
		span->dim = 1;
		span->min_dim = 1;
		span->span = 0;		
		span = span->next;
	}

}

void lo_SetTableDimensions( lo_DocState *state, lo_TableRec *table, int32 allow_percent_width, int32 allow_percent_height)
{
	int32 val;

	if (table->percent_width > 0) 
	{
		val = table->percent_width;
		if (allow_percent_width == FALSE)
		{
			val = 0;
		}
		else
		{
			val = (state->win_width - state->win_left -
				state->win_right) * val / 100;
		}
		if (val < 0)
		{
			val = 0;
		}
		table->width = val;
	}
	
	if (table->percent_height > 0)
	{
		val = table->percent_height;
		if (allow_percent_height == FALSE)
		{
			val = 0;
		}
		else
		{
			val = (state->win_height - state->win_top -
				state->win_bottom) * val / 100;
		}
		if (val < 0)
		{
			val = 0;
		}
		table->height = val;
	}
}

void lo_CalcFixedColWidths( MWContext *context, lo_DocState *state, lo_TableRec *table)
{
	int32 cols = table->fixed_cols;
	if (cols > 0) {
		int32 count;
		int32 table_width;
		
		table_width = lo_ComputeInternalTableWidth ( context, table, state );
		
		/* Split the space up evenly */
		table->default_cell_width = table_width / cols;
		
		/* and we have all the table width left to play with */
		table->fixed_width_remaining = table_width;
		
		/* Initialize our width array */
		for ( count = 0; count < cols; ++count )
		{
			table->fixed_col_widths[ count ] = 0;
		}
	}
}

void lo_UpdateStateAfterBeginTable( lo_DocState *state, lo_TableRec *table)
{
	state->current_table = table;
}

/* Relayout version of lo_BeginTableRowAttributes()  */
void lo_UpdateTableStateForBeginRow(lo_TableRec *table, lo_TableRow *table_row)
{
	table_row->row_done = FALSE;
	table_row->cells = 0;
	table_row->cell_list = NULL;
	table_row->cell_ptr = NULL;
	/* table_row->next = NULL;

	if (table->row_list == NULL)
	{
		table->row_list = table_row;
		table->row_ptr = table_row;
	}
	else
	{
		table->row_ptr->next = table_row;
		table->row_ptr = table_row;
	}
	*/

	table->width_span_ptr = NULL;
	
}

/* 
 * Functions for breaking up lo_BeginTableCellAttributes()
 */
void lo_InitForBeginCell(lo_TableRow *table_row, lo_TableCell *table_cell)
{
	table_cell->must_relayout = FALSE;
	table_cell->cell_done = FALSE;
	
	if (table_row->cell_list == NULL)
	{
		table_row->cell_list = table_cell;
		table_row->cell_ptr = table_cell;
	}
	else
	{
		table_row->cell_ptr->next = table_cell;
		table_row->cell_ptr = table_cell;
	}
}

void lo_InitSubDocForBeginCell( MWContext *context, lo_DocState *state, lo_TableRec *table )
{
	lo_TableCell *table_cell = table->row_ptr->cell_ptr;
	lo_BeginCellSubDoc(context, 
						state, 
						table,
						NULL,
                        NULL,
                        LO_TILE_BOTH,
						NULL,
						NULL,
						NULL,
						NULL,
 						table_cell->is_a_header, 
						table->draw_borders,
						TRUE);

	/*
	 * We added a new state.
	 */
	lo_PushStateLevel ( context );
}

static void lo_UpdateCaptionCellFromSubDoc( MWContext *context, lo_DocState *state, LO_SubDocStruct *subdoc, LO_CellStruct *cell_ele)
{
	int32 dx = 0;
	int32 dy = 0;

	lo_CreateCellFromSubDoc(context, state, subdoc, cell_ele, &dx, &dy);
	lo_ShiftCell(cell_ele, dx, dy);
	lo_RenumberCell(state, cell_ele);
}

/* Only deletes the cell itself.  Assumes that stuff the cell points to will get deleted
   elsewhere */
static void lo_FreeCaptionCell( MWContext *context, lo_DocState *state, LO_CellStruct *cell_ele)
{
	cell_ele->next = NULL;
	cell_ele->prev = NULL;
	cell_ele->cell_list = NULL;
	cell_ele->cell_list_end = NULL;
	cell_ele->cell_float_list = NULL;
	cell_ele->table_cell = NULL;
	cell_ele->table_row = NULL;
	cell_ele->table = NULL;

	lo_FreeElement(context, (LO_Element *)cell_ele, TRUE);

}
#ifdef TEST_16BIT
#undef XP_WIN16
#endif /* TEST_16BIT */