gecko-dev/lib/layout/layutil.c

/* -*- Mode: C++; tab-width: 8; 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 "laystyle.h"
#include "libmocha.h"
#include "stystruc.h"
#include "stystack.h"
#include "layers.h"
#ifdef XP_MAC
#include "prpriv.h"
#else
#include "private/prpriv.h"		/* for PR_NewNamedMonitor */
#endif
#include "intl_csi.h"

#ifdef DOM
#include "lm_dom.h"
#endif

#ifdef EDITOR
#include "edt.h"
#endif
#ifdef PROFILE
#pragma profile on
#endif

#ifdef XP_WIN16
#define SIZE_LIMIT              32000
#endif /* XP_WIN16 */

#define	FONT_FACE_INC	10
#define	FONT_FACE_MAX	1000

void
lo_GetElementBbox(LO_Element *element, XP_Rect *rect) 
{
    rect->left = element->lo_any.x + element->lo_any.x_offset;
    rect->top = element->lo_any.y + element->lo_any.y_offset;
    rect->right = rect->left + element->lo_any.width;
    rect->bottom = rect->top + element->lo_any.height;

    switch(element->type)
    {
    case LO_IMAGE:
    {
        LO_ImageStruct *image = &element->lo_image;
        rect->right  += 2 * (image->border_width + image->border_horiz_space);
        rect->bottom += 2 * (image->border_width + image->border_vert_space);
    }
    break;

    case LO_SUBDOC:
    {
        LO_SubDocStruct *subdoc = &element->lo_subdoc;
        rect->right  += 2 * (subdoc->border_width + subdoc->border_horiz_space);
        rect->bottom += 2 * (subdoc->border_width + subdoc->border_vert_space);
    }
    break;

    case LO_TABLE:
    {
        LO_TableStruct *table = &element->lo_table;
        rect->right  += 2 * (table->border_width + table->border_horiz_space);
        rect->bottom += 2 * (table->border_width + table->border_vert_space);
    }
    break;

    case LO_CELL:
    {
        LO_CellStruct *cell = &element->lo_cell;
        rect->right  += 2 * (cell->border_width + cell->border_horiz_space);
        rect->bottom += 2 * (cell->border_width + cell->border_vert_space);
    }
    break;

    case LO_EMBED:
    {
        LO_EmbedStruct *embed = &element->lo_embed;
        rect->right  += 2 * (embed->objTag.border_width + embed->objTag.border_horiz_space);
        rect->bottom += 2 * (embed->objTag.border_width + embed->objTag.border_vert_space);
    }
    break;

    case LO_BUILTIN:
    {
        LO_BuiltinStruct *builtin = &element->lo_builtin;
        rect->right  += 2 * (builtin->border_width + builtin->border_horiz_space);
        rect->bottom += 2 * (builtin->border_width + builtin->border_vert_space);
    }
    break;

#ifdef JAVA
    case LO_JAVA:
    {
        LO_JavaAppStruct *java = &element->lo_java;
        rect->right  += 2 * (java->objTag.border_width + java->objTag.border_horiz_space);
        rect->bottom += 2 * (java->objTag.border_width + java->objTag.border_vert_space);
    }
    break;
#endif

    default:
        break;
    }
}

void
lo_RefreshElement(LO_Element *element, CL_Layer *layer, Bool update_now)
{
    XP_Rect rect;
    int32 x_offset, y_offset;
    CL_Compositor *compositor = CL_GetLayerCompositor(layer);

    lo_GetElementBbox(element, &rect);
    
    lo_GetLayerXYShift(layer, &x_offset, &y_offset);
    XP_OffsetRect(&rect, -x_offset, -y_offset);
    CL_UpdateLayerRect(compositor, layer, &rect, (PRBool)update_now);
}

/* Given a layout element, retrieve its anchor information. */
LO_AnchorData *
lo_GetElementAnchor(LO_Element *element)
{
	switch(element->type)
	{
		case LO_TEXT:
			return element->lo_text.anchor_href;

		case LO_IMAGE:
			return element->lo_image.anchor_href;

		case LO_TABLE:
			return element->lo_table.anchor_href;

		case LO_SUBDOC:
			return element->lo_subdoc.anchor_href;

		case LO_LINEFEED:
			return element->lo_linefeed.anchor_href;

		default:
			return NULL;
	}
}

/* Return an element's foreground color */
void
lo_GetElementFGColor(LO_Element *element, LO_Color *color)
{
	switch (element->type)
	{
	case LO_TEXT:
		color->red   = element->lo_text.text_attr->fg.red;
		color->green = element->lo_text.text_attr->fg.green;
		color->blue  = element->lo_text.text_attr->fg.blue;
		break;
		
	case LO_IMAGE:
		color->red   = element->lo_image.text_attr->fg.red;
		color->green = element->lo_image.text_attr->fg.green;
		color->blue  = element->lo_image.text_attr->fg.blue;
		break;

	case LO_SUBDOC:
		color->red   = element->lo_subdoc.text_attr->fg.red;
		color->green = element->lo_subdoc.text_attr->fg.green;
		color->blue  = element->lo_subdoc.text_attr->fg.blue;
		break;

	default:
		XP_ASSERT(0);			/* Not implemented */
		break;
	}
}

/* Set an element's foreground color */
void
lo_SetElementFGColor(LO_Element *element, LO_Color *color)
{
	switch (element->type)
	{
	case LO_TEXT:
		element->lo_text.text_attr->fg.red = color->red;
		element->lo_text.text_attr->fg.green = color->green;
		element->lo_text.text_attr->fg.blue = color->blue;
		break;
		
	case LO_IMAGE:
		element->lo_image.text_attr->fg.red = color->red;
		element->lo_image.text_attr->fg.green = color->green;
		element->lo_image.text_attr->fg.blue = color->blue;
		break;

	case LO_SUBDOC:
		element->lo_subdoc.text_attr->fg.red = color->red;
		element->lo_subdoc.text_attr->fg.green = color->green;
		element->lo_subdoc.text_attr->fg.blue = color->blue;
		break;

	default:
		XP_ASSERT(0);			/* Not implemented */
		break;
	}
}

NET_ReloadMethod
LO_GetReloadMethod(MWContext *context)
{
	int32 doc_id;
	lo_TopState *top_state;
	lo_DocState *state;

	/*
	 * Get the unique document ID, and retreive this
	 * documents layout state.
	 */
	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	if ((top_state == NULL)||(top_state->doc_state == NULL))
	{
		return NET_NORMAL_RELOAD;
	}
	state = top_state->doc_state;

	return (FORCE_RELOAD_FLAG(state->top_state));
}


void
LO_InvalidateFontData(MWContext *context)
{
	int32 i, doc_id;
	lo_TopState *top_state;
	lo_DocState *state;
	LO_TextAttr **text_attr_hash;
	LO_TextAttr *attr_ptr;

	/*
	 * Get the unique document ID, and retreive this
	 * documents layout state.
	 */
	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	if ((top_state == NULL)||(top_state->doc_state == NULL))
	{
		return;
	}
	state = top_state->doc_state;

	if (state->top_state->text_attr_hash == NULL)
	{
		return;
	}

	XP_LOCK_BLOCK(text_attr_hash, LO_TextAttr **,
		state->top_state->text_attr_hash);
	for (i=0; i < FONT_HASH_SIZE; i++)
	{
		attr_ptr = text_attr_hash[i];
		while (attr_ptr != NULL)
		{
			if (attr_ptr->FE_Data != NULL)
			{
				FE_ReleaseTextAttrFeData(context, attr_ptr);
			}
			attr_ptr->FE_Data = NULL;
			attr_ptr = attr_ptr->next;
		}
	}
}


static char *
lo_find_face_in_array(char **face_list, intn len, char *face)
{
	intn i;
	char *the_face;

	if (face == NULL)
	{
		return(NULL);
	}

	the_face = NULL;
	for (i=0; i<len; i++)
	{
		if ((face_list[i] != NULL)&&
			(XP_STRCMP(face, face_list[i]) == 0))
		{
			the_face = face_list[i];
			break;
		}
	}

	return(the_face);
}


Bool
lo_EvalTrueOrFalse(char *str, Bool default_val)
{
	Bool ret_val;

	ret_val = default_val;

	if (str == NULL)
	{
		return(ret_val);
	}

	if (pa_TagEqual("true", str))
	{
		ret_val = TRUE;
	}
	else if (pa_TagEqual("yes", str))
	{
		ret_val = TRUE;
	}
	else if (pa_TagEqual("no", str))
	{
		ret_val = FALSE;
	}
	else if (pa_TagEqual("false", str))
	{
		ret_val = FALSE;
	}

	return(ret_val);
}

char *
lo_FetchFontFace(MWContext *context, lo_DocState *state, char *face)
{
	char **face_list;
	char *new_face;

	/*
	 * If this is our first addition, allocate the array.
	 */
	if (state->top_state->font_face_array == NULL)
	{
		PA_Block buff;

		buff = PA_ALLOC(FONT_FACE_INC * sizeof(char *));
		if (buff == NULL)
		{
			state->top_state->out_of_memory = TRUE;
			return(NULL);
		}
		state->top_state->font_face_array = buff;
		state->top_state->font_face_array_size = FONT_FACE_INC;
		state->top_state->font_face_array_len = 0;
	}
	/*
	 * Else if the list is full, grow the array.
	 */
	else if (state->top_state->font_face_array_len >=
			state->top_state->font_face_array_size)
	{
		PA_Block buff;
		intn new_size;

		if (state->top_state->font_face_array_size >= FONT_FACE_MAX)
		{
			return(NULL);
		}

		new_size = state->top_state->font_face_array_size +
				FONT_FACE_INC;
		if (new_size > FONT_FACE_MAX)
		{
			new_size = FONT_FACE_MAX;
		}
		buff = XP_REALLOC_BLOCK(state->top_state->font_face_array,
			(new_size * sizeof(char *)));
		if (buff == NULL)
		{
			state->top_state->out_of_memory = TRUE;
			return(NULL);
		}
		state->top_state->font_face_array = buff;
		state->top_state->font_face_array_size = new_size;
	}

	PA_LOCK(face_list, char **, state->top_state->font_face_array);
	new_face = lo_find_face_in_array(face_list,
		state->top_state->font_face_array_len, face);
	if (new_face == NULL)
	{
		char *str;

		str = XP_STRDUP(face);
		if (str == NULL)
		{
			PA_UNLOCK(state->top_state->font_face_array);
			state->top_state->out_of_memory = TRUE;
			return(NULL);
		}
		face_list[state->top_state->font_face_array_len] = str;
		state->top_state->font_face_array_len++;
		new_face = str;
	}
	PA_UNLOCK(state->top_state->font_face_array);
	return(new_face);
}


Bool
lo_IsValidTarget(char *target)
{
	if (target == NULL)
	{
		return(FALSE);
	}
	if ((XP_IS_ALPHA(target[0]) != FALSE)||
	    (XP_IS_DIGIT(target[0]) != FALSE)||
	    (target[0] == '_'))
	{
		return(TRUE);
	}
	return(FALSE);
}


int32
lo_StripTextNewlines(char *text, int32 text_len)
{
	char *from_ptr;
	char *to_ptr;
	int32 len;

	if ((text == NULL)||(text_len < 1))
	{
		return(0);
	}

	/*
	 * remove all non-space whitespace from the middle of the string.
	 */
	from_ptr = text;
	len = text_len;
	to_ptr = text;
	while (*from_ptr != '\0')
	{
		if (XP_IS_SPACE(*from_ptr) && (*from_ptr != ' '))
		{
			from_ptr++;
			len--;
		}
		else
		{
			*to_ptr++ = *from_ptr++;
		}
	}
	*to_ptr = '\0';

	return(len);
}


PA_Block
lo_FEToNetLinebreaks(PA_Block text_block)
{
	PA_Block new_block;
	char *new_text;
	char *text;
	char *from_ptr;
	char *to_ptr;
	char break_char;
	int32 len, new_len;
	int32 linebreak;

	if (text_block == NULL)
	{
		return(NULL);
	}
	PA_LOCK(text, char *, text_block);

	XP_BCOPY(LINEBREAK, (char *)(&break_char), 1);
	len = 0;
	linebreak = 0;
	from_ptr = text;
	while (*from_ptr != '\0')
	{
		if (*from_ptr == break_char)
		{
			if (strncmp(from_ptr, LINEBREAK, LINEBREAK_LEN) == 0)
			{
				linebreak++;
				len += LINEBREAK_LEN;
				from_ptr = (char *)(from_ptr + LINEBREAK_LEN);
			}
			else
			{
				len++;
				from_ptr++;
			}
		}
		else
		{
			len++;
			from_ptr++;
		}
	}

	new_len = len - (LINEBREAK_LEN * linebreak) + (2 * linebreak);
	new_block = PA_ALLOC(new_len + 1);
	if (new_block == NULL)
	{
		PA_UNLOCK(text_block);
		return(NULL);
	}
	PA_LOCK(new_text, char *, new_block);
	from_ptr = text;
	to_ptr = new_text;
	while (*from_ptr != '\0')
	{
		if (*from_ptr == break_char)
		{
			if (strncmp(from_ptr, LINEBREAK, LINEBREAK_LEN) == 0)
			{
				from_ptr = (char *)(from_ptr + LINEBREAK_LEN);
				*to_ptr++ = CR;
				*to_ptr++ = LF;
			}
			else
			{
				*to_ptr++ = *from_ptr++;
			}
		}
		else
		{
			*to_ptr++ = *from_ptr++;
		}
	}
	*to_ptr = '\0';

	new_text[new_len] = '\0';
	PA_UNLOCK(new_block);
	PA_UNLOCK(text_block);
	return(new_block);
}


PA_Block
lo_ConvertToFELinebreaks(char *text, int32 text_len, int32 *new_len_ptr)
{
	PA_Block new_block;
	char *new_text;
	char *from_ptr;
	char *to_ptr;
	char break_char;
	int32 len, new_len;
	int32 skip, linebreak;

	if (text == NULL)
	{
		return(NULL);
	}

	break_char = '\0';
	len = 0;
	skip = 0;
	linebreak = 0;
	from_ptr = text;
	to_ptr = text;
	while (len < text_len)
	{
		if ((*from_ptr == CR)||(*from_ptr == LF))
		{
			if ((break_char != '\0')&&(break_char != *from_ptr))
			{
				skip++;
				break_char = '\0';
			}
			else
			{
				skip++;
				linebreak++;
				break_char = *from_ptr;
			}
		}
		from_ptr++;
		len++;
	}

	new_len = len - skip + (LINEBREAK_LEN * linebreak);
	new_block = PA_ALLOC(new_len + 1);
	if (new_block == NULL)
	{
		return(NULL);
	}
	PA_LOCK(new_text, char *, new_block);
	break_char = '\0';
	len = 0;
	from_ptr = text;
	to_ptr = new_text;
	while (len < text_len)
	{
		if ((*from_ptr == CR)||(*from_ptr == LF))
		{
			if ((break_char != '\0')&&(break_char != *from_ptr))
			{
				break_char = '\0';
			}
			else
			{
				XP_BCOPY(LINEBREAK, to_ptr, LINEBREAK_LEN);
				to_ptr = (char *)(to_ptr + LINEBREAK_LEN);
				break_char = *from_ptr;
			}
			from_ptr++;
			len++;
		}
		else
		{
			*to_ptr++ = *from_ptr++;
			len++;
		}
	}

	new_text[new_len] = '\0';
	*new_len_ptr = new_len;
	PA_UNLOCK(new_block);
	return(new_block);
}


intn
lo_EvalVAlignParam(char *str)
{
	intn alignment;

	alignment = LO_ALIGN_TOP;
	if (pa_TagEqual("top", str))
	{
		alignment = LO_ALIGN_TOP;
	}
	else if (pa_TagEqual("bottom", str))
	{
		alignment = LO_ALIGN_BOTTOM;
	}
	else if ((pa_TagEqual("middle", str))||
		(pa_TagEqual("center", str)))
	{
		alignment = LO_ALIGN_CENTER;
	}
	else if (pa_TagEqual("baseline", str))
	{
		alignment = LO_ALIGN_BASELINE;
	}
	return(alignment);
}


intn
lo_EvalDivisionAlignParam(char *str)
{
	intn alignment;

	alignment = LO_ALIGN_LEFT;
	if (pa_TagEqual("left", str))
	{
		alignment = LO_ALIGN_LEFT;
	}
	else if (pa_TagEqual("right", str))
	{
		alignment = LO_ALIGN_RIGHT;
	}
	else if (pa_TagEqual("center", str))
	{
		alignment = LO_ALIGN_CENTER;
	}
	else if (pa_TagEqual("justify", str))
	{
		alignment = LO_ALIGN_JUSTIFY;
	}
	return(alignment);
}


intn
lo_EvalCellAlignParam(char *str)
{
	intn alignment;

	alignment = LO_ALIGN_LEFT;
	if (pa_TagEqual("left", str))
	{
		alignment = LO_ALIGN_LEFT;
	}
	else if (pa_TagEqual("right", str))
	{
		alignment = LO_ALIGN_RIGHT;
	}
	else if ((pa_TagEqual("middle", str))||
		(pa_TagEqual("center", str)))
	{
		alignment = LO_ALIGN_CENTER;
	}
	return(alignment);
}

#if defined( EDITOR ) || !defined( MEMORY_ARENAS )
/* this is a replacement routine for the non-editor version and should eventually
 *	replace the non-edit version.  It uses an array of values. instead of an 
 *	unrolled loop.  
*/

/*
 * Indexed by LO_ALIGN_ETC
*/
char* lo_alignStrings[] = {
    "abscenter",		/* LO_ALIGN_CENTER */
    "left",				/* LO_ALIGN_LEFT */
    "right",			/* LO_ALIGN_RIGHT */
    "texttop",			/* LO_ALIGN_TOP */
    "absbottom",		/* LO_ALIGN_BOTTOM */
    "baseline",			/* LO_ALIGN_BASELINE */
    "middle",			/* LO_ALIGN_NCSA_CENTER */
    "bottom",			/* LO_ALIGN_NCSA_BOTTOM */
    "top",				/* LO_ALIGN_NCSA */
	0
};

intn
lo_EvalAlignParam(char *str, Bool *floating)
{
	intn alignment;

	*floating = FALSE;
	alignment = LO_ALIGN_BASELINE;
	if (pa_TagEqual("middle", str))
	{
		alignment = LO_ALIGN_NCSA_CENTER;
	}
	else if (pa_TagEqual("absmiddle", str))
	{
		alignment = LO_ALIGN_CENTER;
	}
	else 
	{
		intn i = 0;
		Bool bFound = FALSE;

		while( lo_alignStrings[i] != NULL  && bFound == FALSE )
		{
			if( pa_TagEqual( lo_alignStrings[i], str) )
			{
				bFound = TRUE;
				alignment = i;
			}
			i++;
		}	 
	}
	if( alignment == LO_ALIGN_LEFT || alignment == LO_ALIGN_RIGHT)
	{
		*floating = TRUE;
	}
	return alignment;
} 

#else

intn
lo_EvalAlignParam(char *str, Bool *floating)
{
	intn alignment;

	*floating = FALSE;
	alignment = LO_ALIGN_BASELINE;
	if (pa_TagEqual("top", str))
	{
		alignment = LO_ALIGN_NCSA_TOP;
	}
	else if (pa_TagEqual("texttop", str))
	{
		alignment = LO_ALIGN_TOP;
	}
	else if (pa_TagEqual("bottom", str))
	{
		alignment = LO_ALIGN_NCSA_BOTTOM;
	}
	else if (pa_TagEqual("absbottom", str))
	{
		alignment = LO_ALIGN_BOTTOM;
	}
	else if (pa_TagEqual("baseline", str))
	{
		alignment = LO_ALIGN_BASELINE;
	}
	else if ((pa_TagEqual("middle", str))||
		(pa_TagEqual("center", str)))
	{
		alignment = LO_ALIGN_NCSA_CENTER;
	}
	else if ((pa_TagEqual("absmiddle", str))||
		(pa_TagEqual("abscenter", str)))
	{
		alignment = LO_ALIGN_CENTER;
	}
	else if (pa_TagEqual("left", str))
	{
		alignment = LO_ALIGN_LEFT;
		*floating = TRUE;
	}
	else if (pa_TagEqual("right", str))
	{
		alignment = LO_ALIGN_RIGHT;
		*floating = TRUE;
	}
	return(alignment);
}
#endif

/* set *alignment and *floating iff there
 * is a valid stylesheet alignment property.
 */
MODULE_PRIVATE void
lo_EvalStyleSheetAlignment(StyleStruct *style_struct, 
							intn *alignment,
			   				Bool *floating)
{
	char *valign, *halign;

	if(!style_struct)
		return;

	valign = STYLESTRUCT_GetString(style_struct,VERTICAL_ALIGN_STYLE);
	halign = STYLESTRUCT_GetString(style_struct,HORIZONTAL_ALIGN_STYLE);

	if(valign)
	{
		if (pa_TagEqual("top", valign))
		{
			*alignment = LO_ALIGN_NCSA_TOP;
			*floating = FALSE;
		}
		else if (pa_TagEqual("texttop", valign) 
				 || pa_TagEqual("text-top", valign))
		{
			*alignment = LO_ALIGN_TOP;
			*floating = FALSE;
		}
		else if (pa_TagEqual("bottom", valign))
		{
			*alignment = LO_ALIGN_NCSA_BOTTOM;
			*floating = FALSE;
		}
		else if (pa_TagEqual("absbottom", valign)
				 || pa_TagEqual("text-bottom", valign))
		{
			*alignment = LO_ALIGN_BOTTOM;
			*floating = FALSE;
		}
		else if (pa_TagEqual("baseline", valign))
		{
			*alignment = LO_ALIGN_BASELINE;
			*floating = FALSE;
		}
		else if ((pa_TagEqual("middle", valign))||
			(pa_TagEqual("center", valign)))
		{
			*alignment = LO_ALIGN_NCSA_CENTER;
			*floating = FALSE;
		}
		else if ((pa_TagEqual("absmiddle", valign))||
			(pa_TagEqual("abscenter", valign)))
		{
			*alignment = LO_ALIGN_CENTER;
			*floating = FALSE;
		}
	}

	if(halign)
	{
		if (pa_TagEqual("left", halign))
		{
			*alignment = LO_ALIGN_LEFT;
			*floating = TRUE;
		}
		else if (pa_TagEqual("right", halign))
		{
			*alignment = LO_ALIGN_RIGHT;
			*floating = TRUE;
		}
	}

	XP_FREEIF(valign);
	XP_FREEIF(halign);

	return;
}

void
lo_CalcAlignOffsets(lo_DocState *state, LO_TextInfo *text_info, intn alignment,
	int32 width, int32 height, int16 *x_offset, int32 *y_offset,
	int32 *line_inc, int32 *baseline_inc)
{
	*line_inc = 0;
	*baseline_inc = 0;
	switch (alignment)
	{
		case LO_ALIGN_CENTER:
			*x_offset = 0;
			/*
			 * Center after current text.
			 */
			/*
			 * If the image is shorter than the height
			 * of this line, just increase y_offset
			 * to get it centered.
			 */
			if (height < state->line_height)
			{
				*y_offset += ((state->line_height - height)
						/ 2);
			}
			/*
			 * Else for images taller than the line
			 * we will need to move all their
			 * baselines down, plus increase the rest
			 * of their lineheights to reflect the
			 * big centered image.
			 */
			else
			{
				*y_offset = 0;
				*baseline_inc = (height - state->line_height)
						/ 2;
				*line_inc = height - state->line_height -
					*baseline_inc;
			}
			break;
		case LO_ALIGN_NCSA_CENTER:
			*x_offset = 0;
			/*
			 * Center on baseline of current text.
			 */
			/*
			 * If the image centered on the baseline will not
			 * extend below or above the current line,
			 * just increase y_offset to get it centered.
			 */
			if (((height / 2) <= state->baseline)&&
				((height / 2) <= (state->line_height - 
					state->baseline)))
			{
				*y_offset = state->baseline -
					(height / 2);
			}
			/*
			 * Else the image extends over the bottom, but
			 * not off the top.
			 */
			else if ((height / 2) <= state->baseline)
			{
				*y_offset = state->baseline -
					(height / 2);
				*line_inc = *y_offset + height -
					state->line_height;
			}
			/*
			 * Else for images taller than the line
			 * we will need to move all their
			 * baselines down, plus and maybe increase the rest
			 * of their lineheights to reflect the
			 * big centered image.
			 */
			else
			{
				*y_offset = 0;
				*baseline_inc = (height / 2) - state->baseline;
				if ((state->baseline + (height / 2)) >
					state->line_height)
				{
					*line_inc = state->baseline +
						(height / 2) -
						state->line_height;
				}
			}
			break;
		case LO_ALIGN_TOP:
			*x_offset = 0;
			/*
			 * Move the top of the image to the top of the
			 * last text placed.  On negative offsets
			 * (such as at the start of a line) just
			 * start the image at the top.
			 */
			*y_offset = state->baseline - text_info->ascent;
			if (*y_offset < 0)
			{
				*y_offset = 0;
			}

			/*
			 * Top aligned images can easily hang down and make
			 * all the rest of the line taller.  Set line_inc
			 * to properly increase the height of all previous
			 * elements.
			 */
			if ((*y_offset + height) > state->line_height)
			{
				*line_inc = *y_offset + height -
					state->line_height;
			}
			break;
		case LO_ALIGN_NCSA_TOP:
			*x_offset = 0;
			/*
			 * Move the top of the image to the top of the
			 * line.
			 */
			*y_offset = 0;

			/*
			 * Top aligned images can easily hang down and make
			 * all the rest of the line taller.  Set line_inc
			 * to properly increase the height of all previous
			 * elements.
			 */
			if ((*y_offset + height) > state->line_height)
			{
				*line_inc = *y_offset + height -
					state->line_height;
			}
			break;
		case LO_ALIGN_BOTTOM:
			*x_offset = 0;
			/*
			 * Like centered images, images shorter than
			 * the line just get move with y_offset.
			 */
			if (height < state->line_height)
			{
				*y_offset = state->line_height - height;
			}
			/*
			 * Else since they are bottom aligned.
			 * they move everyone's baselines and can't
			 * change the height below the baseline.
			 */
			else
			{
				*y_offset = 0;
				*baseline_inc = height - state->line_height;
			}
			break;
		case LO_ALIGN_NCSA_BOTTOM:
		case LO_ALIGN_BASELINE:
		default:
			*x_offset = 0;
			/*
			 * Like centered images, images shorter than
			 * the baseline just get move with y_offset.
			 */
			if (height < state->baseline)
			{
				*y_offset = state->baseline - height;
			}
			/*
			 * Else since they are baseline aligned.
			 * they move everyone's baselines and can't
			 * change the height below the baseline.
			 */
			else
			{
				*y_offset = 0;
				*baseline_inc = height - state->baseline;
			}
			break;
	}
}


int32
lo_ValueOrPercent(char *str, Bool *is_percent)
{
	int32 val;
	char *tptr;

	*is_percent = FALSE;

	if (str == NULL)
	{
		return(0);
	}

	tptr = str;
	while (*tptr != '\0')
	{
		if (*tptr == '%')
		{
			*is_percent = TRUE;
			*tptr = '\0';
			break;
		}
		tptr++;
	}
	val = XP_ATOI(str);
        if (*is_percent)
            *tptr = '%';            /* Restore original string */
	return(val);
}


void
lo_SetElementTextAttr(LO_Element *element, LO_TextAttr *attr)
{
	switch(element->type)
	{
	case LO_TEXT:
		element->lo_text.text_attr = attr;
		break;

	case LO_IMAGE:
		element->lo_image.text_attr = attr;
		break;

	case LO_SUBDOC:
		element->lo_subdoc.text_attr = attr;
		break;

	case LO_LINEFEED:
		element->lo_linefeed.text_attr = attr;
		break;

	case LO_FORM_ELE:
		element->lo_form.text_attr = attr;
		break;

	case LO_BULLET:
		element->lo_bullet.text_attr = attr;
		break;

	default:
		XP_ASSERT(0);
	}
}

LO_TextAttr *
lo_GetElementTextAttr(LO_Element *element)
{
	switch(element->type)
	{
	case LO_TEXT:
		return element->lo_text.text_attr;

	case LO_IMAGE:
		return element->lo_image.text_attr;

	case LO_SUBDOC:
		return element->lo_subdoc.text_attr;

	case LO_LINEFEED:
		return element->lo_linefeed.text_attr;

	case LO_FORM_ELE:
		return element->lo_form.text_attr;

	case LO_BULLET:
		return element->lo_bullet.text_attr;

	default:
		return NULL;
	}
}

void
lo_CopyTextAttr(LO_TextAttr *old_attr, LO_TextAttr *new_attr)
{
	if ((old_attr == NULL)||(new_attr == NULL))
	{
		return;
	}

	new_attr->size = old_attr->size;
	new_attr->fontmask = old_attr->fontmask;

	new_attr->fg.red = old_attr->fg.red;
	new_attr->fg.green = old_attr->fg.green;
	new_attr->fg.blue = old_attr->fg.blue;

	new_attr->bg.red = old_attr->bg.red;
	new_attr->bg.green = old_attr->bg.green;
	new_attr->bg.blue = old_attr->bg.blue;

	new_attr->no_background = old_attr->no_background;
	new_attr->attrmask = old_attr->attrmask;
	new_attr->font_face = old_attr->font_face;
	/*
	 * FE_Data is not copied, it belongs to the FE,
	 * And will need to be generated by the FE the first time this
	 * new TextAttr is used.
	 */
	new_attr->FE_Data = NULL;

	new_attr->charset = old_attr->charset;
	new_attr->point_size = old_attr->point_size;
	new_attr->font_weight = old_attr->font_weight;
}

LO_TextAttr *
lo_NewCopyTextAttr(lo_DocState *state, LO_TextAttr *old_attr)
{
  LO_TextAttr *new_attr;
  LO_TextAttr **text_attr_hash;
  int32 hash_index;
  
  hash_index = (old_attr->fontmask & old_attr->attrmask) % FONT_HASH_SIZE;
  
  XP_LOCK_BLOCK(text_attr_hash, LO_TextAttr **,
		state->top_state->text_attr_hash);
  new_attr = XP_NEW_ZAP(LO_TextAttr);
  if (new_attr != NULL)
    {
      lo_CopyTextAttr(old_attr, new_attr);
      new_attr->next = text_attr_hash[hash_index];
      text_attr_hash[hash_index] = new_attr;
      new_attr->refcnt = 1;
    }
  else
    {
      state->top_state->out_of_memory = TRUE;
    }
  XP_UNLOCK_BLOCK(state->top_state->text_attr_hash);
  return new_attr;
}

LO_TextAttr *
lo_FetchTextAttr(lo_DocState *state, LO_TextAttr *old_attr)
{
	LO_TextAttr **text_attr_hash;
	LO_TextAttr *attr_ptr;
	int32 hash_index;

	if (old_attr == NULL)
	{
		return(NULL);
	}

	hash_index = (old_attr->fontmask & old_attr->attrmask) % FONT_HASH_SIZE;

	XP_LOCK_BLOCK(text_attr_hash, LO_TextAttr **,
		state->top_state->text_attr_hash);
	attr_ptr = text_attr_hash[hash_index];

	while (attr_ptr != NULL)
	{
		if ((attr_ptr->size == old_attr->size)&&
			(attr_ptr->fontmask == old_attr->fontmask)&&
			(attr_ptr->attrmask == old_attr->attrmask)&&
			(attr_ptr->fg.red == old_attr->fg.red)&&
			(attr_ptr->fg.green == old_attr->fg.green)&&
			(attr_ptr->fg.blue == old_attr->fg.blue)&&
			(attr_ptr->bg.red == old_attr->bg.red)&&
			(attr_ptr->bg.green == old_attr->bg.green)&&
			(attr_ptr->bg.blue == old_attr->bg.blue)&&
			(attr_ptr->font_face == old_attr->font_face)&&
			(attr_ptr->charset == old_attr->charset)&&
			(attr_ptr->point_size == old_attr->point_size)&&
			(attr_ptr->font_weight == old_attr->font_weight) 
			)
		{
                  attr_ptr->refcnt++;
                  break;
		}
		attr_ptr = attr_ptr->next;
	}
	if (attr_ptr == NULL)
	{
		LO_TextAttr *new_attr;
                new_attr = lo_NewCopyTextAttr(state, old_attr);
		attr_ptr = new_attr;
	}

	XP_UNLOCK_BLOCK(state->top_state->text_attr_hash);
	return(attr_ptr);
}


void
lo_AddMarginStack(lo_DocState *state, int32 x, int32 y,
		int32 width, int32 height,
		int32 border_width,
		int32 border_vert_space, int32 border_horiz_space,
		intn alignment)
{
	lo_MarginStack *mptr;

	mptr = XP_NEW(lo_MarginStack);
	if (mptr == NULL)
	{
		state->top_state->out_of_memory = TRUE;
		return;
	}

	mptr->y_min = y;
	if (y >= 0)
	{
		mptr->y_max = y + height + (2 * border_width) +
			(2 * border_vert_space);
	}
	else
	{
		mptr->y_max = height + (2 * border_width) +
			(2 * border_vert_space);
	}

	if (alignment == LO_ALIGN_RIGHT)
	{
		if (state->right_margin_stack == NULL)
		{
			mptr->margin = state->right_margin - width -
				(2 * border_width) - (2 * border_horiz_space);
		}
		else
		{
			mptr->margin = state->right_margin_stack->margin -
				width - (2 * border_width) -
				(2 * border_horiz_space);
		}
		mptr->next = state->right_margin_stack;
		state->right_margin_stack = mptr;
	}
	else
	{
		mptr->margin = state->left_margin + width +
			(2 * border_width) + (2 * border_horiz_space);
		mptr->next = state->left_margin_stack;
		state->left_margin_stack = mptr;
	}
}


/*
 * When clipping lines we have essentially scrolled the document up.
 * Move the margin blocks up too.
 */
void
lo_ShiftMarginsUp(MWContext *context, lo_DocState *state, int32 dy)
{
	lo_MarginStack *mptr;
	int32 y;

	mptr = state->left_margin_stack;
	while (mptr != NULL)
	{
		y = mptr->y_min - dy;
		if (y < 0)
		{
			y = 0;
		}
		mptr->y_min = y;

		y = mptr->y_max - dy;
		if (y < 0)
		{
			y = 0;
		}
		mptr->y_max = y;
		mptr = mptr->next;
	}

	mptr = state->right_margin_stack;
	while (mptr != NULL)
	{
		y = mptr->y_min - dy;
		if (y < 0)
		{
			y = 0;
		}
		mptr->y_min = y;

		y = mptr->y_max - dy;
		if (y < 0)
		{
			y = 0;
		}
		mptr->y_max = y;
		mptr = mptr->next;
	}
}


void
lo_ClearToLeftMargin(MWContext *context, lo_DocState *state)
{
	lo_MarginStack *mptr;
	int32 y;

	mptr = state->left_margin_stack;
	if (mptr == NULL)
	{
		return;
	}
	y = state->y;

	if (mptr->y_max > y)
	{
		y = mptr->y_max;
	}
	while (mptr->next != NULL)
	{
		lo_MarginStack *margin;

		if (mptr->y_max > y)
		{
			y = mptr->y_max;
		}
		margin = mptr;
		mptr = mptr->next;
		XP_DELETE(margin);
	}
	XP_DELETE(mptr);
	state->y = y;
	state->left_margin_stack = NULL;
	state->left_margin = state->win_left;
	state->x = state->left_margin;

	/*
	 * Find where we hit the right margin, popping old
	 * obsolete elements as we go.
	 */
	mptr = state->right_margin_stack;
	while ((mptr != NULL)&&(state->y > mptr->y_max))
	{
		lo_MarginStack *margin;

		margin = mptr;
		mptr = mptr->next;
		XP_DELETE(margin);
	}
	if (mptr != NULL)
	{
		state->right_margin_stack = mptr;
		state->right_margin = mptr->margin;
	}
	else
	{
		state->right_margin_stack = NULL;
		state->right_margin = (state->list_stack != NULL)
							? state->list_stack->old_right_margin
							: 0;
	}
}


void
lo_ClearToRightMargin(MWContext *context, lo_DocState *state)
{
	lo_MarginStack *mptr;
	int32 y;

	mptr = state->right_margin_stack;
	if (mptr == NULL)
	{
		return;
	}
	y = state->y;

	if (mptr->y_max > y)
	{
		y = mptr->y_max;
	}
	while (mptr->next != NULL)
	{
		lo_MarginStack *margin;

		if (mptr->y_max > y)
		{
			y = mptr->y_max;
		}
		margin = mptr;
		mptr = mptr->next;
		XP_DELETE(margin);
	}
	XP_DELETE(mptr);
	state->y = y;
	state->right_margin_stack = NULL;
	state->right_margin = state->win_width - state->win_right;

	/*
	 * Find where we hit the left margin, popping old
	 * obsolete elements as we go.
	 */
	mptr = state->left_margin_stack;
	while ((mptr != NULL)&&(state->y > mptr->y_max))
	{
		lo_MarginStack *margin;

		margin = mptr;
		mptr = mptr->next;
		XP_DELETE(margin);
	}
	if (mptr != NULL)
	{
		state->left_margin_stack = mptr;
		state->left_margin = mptr->margin;
	}
	else
	{
		state->left_margin_stack = NULL;
		state->left_margin = (state->list_stack != NULL)
						   ? state->list_stack->old_left_margin
						   : 0;
	}
}


void
lo_ClearToBothMargins(MWContext *context, lo_DocState *state)
{
	lo_MarginStack *mptr;
	int32 y;

	y = state->y;

	mptr = state->right_margin_stack;
	if (mptr != NULL)
	{
		if (mptr->y_max > y)
		{
			y = mptr->y_max;
		}
		while (mptr->next != NULL)
		{
			lo_MarginStack *margin;

			if (mptr->y_max > y)
			{
				y = mptr->y_max;
			}
			margin = mptr;
			mptr = mptr->next;
			XP_DELETE(margin);
		}
		XP_DELETE(mptr);
		state->y = y;
		state->right_margin_stack = NULL;

		state->right_margin = state->win_width - state->win_right;
	}

	mptr = state->left_margin_stack;
	if (mptr != NULL)
	{
		if (mptr->y_max > y)
		{
			y = mptr->y_max;
		}
		while (mptr->next != NULL)
		{
			lo_MarginStack *margin;

			if (mptr->y_max > y)
			{
				y = mptr->y_max;
			}
			margin = mptr;
			mptr = mptr->next;
			XP_DELETE(margin);
		}
		XP_DELETE(mptr);
		if (y > state->y)
		{
			state->y = y;
		}
		state->left_margin_stack = NULL;

		state->left_margin = state->win_left;
		state->x = state->left_margin;
	}
}


void
lo_FindLineMargins(MWContext *context, lo_DocState *state, Bool updateFE)
{
	lo_MarginStack *mptr;
	LO_Element *eptr;

	eptr = state->float_list;
	/*
	while ((eptr != NULL)&&(eptr->lo_any.y < 0))
	*/
	while (eptr != NULL)
	{
		LO_Element *next_eptr = NULL;

		if (eptr->lo_any.y < 0) 
		{
			int32 expose_y;
			int32 expose_height;
			/* LO_Element *next_eptr; */

			next_eptr = NULL;
			/*
			 * Float the y to our current position.
			 */
			eptr->lo_any.y = state->y;

			/*
			 * These get coppied into special variables because they
			 * may get changed by a table in the floating list.
			 */
			expose_y = eptr->lo_any.y;
			expose_height = eptr->lo_any.height;

			/*
			 * Special case:  If we have just placed a TABLE element,
			 * we need to properly offset all the CELLs inside it.
			 */
			if (eptr->type == LO_TABLE)
			{
				int32 y2;
				int32 change_y;
				LO_Element *tptr;

				/*
				 * We need to know the bottom and top extents of
				 * the table to know big an area to refresh.
				 */
				y2 = expose_y + eptr->lo_any.y_offset + expose_height;

				/*
				 * This is how far to move the cells based on
				 * where the table thought it was placed.
				 */
				change_y = state->y - eptr->lo_table.expected_y;

				/*
				 * set tptr to the start of the cell list.
				 */
				tptr = eptr->lo_any.next;
				while ((tptr != NULL)&&(tptr->type == LO_CELL))
				{
					/*
					 * Only do this work if the table has moved.
					 */
					if (change_y != 0)
					{
						tptr->lo_any.y += change_y;
						lo_ShiftCell((LO_CellStruct *)tptr,
							0, change_y);
					}

					/*
					 * Find upper and lower bounds of the
					 * cells.
					 */
					if (tptr->lo_any.y < expose_y)
					{
						expose_y = tptr->lo_any.y;
					}
					if ((tptr->lo_any.y + tptr->lo_any.y_offset +
						tptr->lo_any.height) > y2)
					{
						y2 = tptr->lo_any.y +
							tptr->lo_any.y_offset +
							tptr->lo_any.height;
					}

					tptr = tptr->lo_any.next;
				}

				/*
				 * Whatever is after all the table cells will
				 * really be the next eptr.
				 */
				if (tptr != NULL)
				{
					next_eptr = tptr;
				}

				/*
				 * Adjust exposed area height for lower bound.
				 * Upper bound already possibly moved.
				 */
				if ((y2 - expose_y - eptr->lo_any.y_offset) >
					expose_height)
				{
					expose_height = y2 - expose_y -
						eptr->lo_any.y_offset;
				}
			}

			if (updateFE) 
			{
				/*
				 * We may have been blocking display on this floating image.
				 * If so deal with it here.
				 */
				if ((state->display_blocked != FALSE)&&
					(state->is_a_subdoc == SUBDOC_NOT)&&
					(state->display_blocking_element_y == 0)&&
					(state->display_blocking_element_id != -1)&&
					(eptr->lo_any.ele_id >=
					state->display_blocking_element_id))
				{
					state->display_blocking_element_y =
						state->y;
					/*
					 * Special case, if the blocking element
					 * is on the first line, no blocking
					 * at all needs to happen.
					 */
					if (state->y == state->win_top)
					{
						state->display_blocked = FALSE;
						FE_SetDocPosition(context,
							FE_VIEW, 0, state->base_y);

						if (context->compositor)
						{
							XP_Rect rect;
                    
							rect.left = 0;
							rect.top = 0;
							rect.right = state->win_width;
							rect.bottom = state->win_height;
							CL_UpdateDocumentRect(context->compositor,
												  &rect, (PRBool)FALSE);
						}
					}
				}

			}	/* end if (updateFE) */



			if (context->compositor)
			{
				XP_Rect rect;
           
				rect.left = eptr->lo_any.x + eptr->lo_any.x_offset;
				rect.top = expose_y + eptr->lo_any.y_offset;
				rect.right = rect.left + eptr->lo_any.width;
				rect.bottom = rect.top + expose_height;
				CL_UpdateDocumentRect(context->compositor,
										  &rect, (PRBool)FALSE);

			}			

			/*
			 * In case these floating elements are the only thing in the
			 * doc (or subdoc) we need to set the state min and max widths
			 * when we place them.
			 */
		{
			int32 width;
			XP_Rect rect;

			rect.left = 0;
			rect.right = 0;
			lo_GetElementBbox(eptr, &rect);
			width = rect.right - rect.left;
			if (width > 0)
			{
				if (width > state->min_width)
				{
					state->min_width = width;
				}

				/*
				 * Only do this if not in a table
				 */
				if (state->is_a_subdoc == SUBDOC_NOT)
				{
					width += rect.left;
				}
				if (width > state->max_width)
				{
					state->max_width = width;
				}
			}
		
		}
			/*
			eptr = eptr->lo_any.next;
			*/
			/*
			 * If we are skipping a table's cells, set eptr
			 * properly now.
			 */
			/*
			if (next_eptr != NULL)
			{
				eptr = next_eptr;
			}
			*/
		}  /* End if (eptr->lo_any.y < 0) */

		eptr = eptr->lo_any.next;

		/*
		 * If we are skipping a table's cells, set eptr
		 * properly now.
		 */
		if (next_eptr != NULL)
		{
			eptr = next_eptr;
		}
	}  /* End while */
	
	/*
	 * Find floating elements just added to the left margin stack
	 * from the last line, and set their absolute
	 * coordinates.
	 */
	mptr = state->left_margin_stack;
	while ((mptr != NULL)&&(mptr->y_min < 0))
	{
		mptr->y_min = state->y;
		mptr->y_max = mptr->y_min + mptr->y_max;
		mptr = mptr->next;
	}

	/*
	 * Find where we hit the left margin, popping old
	 * obsolete elements as we go.
	 */
	mptr = state->left_margin_stack;
	while ((mptr != NULL)&&(state->y > mptr->y_max))
	{
		lo_MarginStack *margin;

		margin = mptr;
		mptr = mptr->next;
		XP_DELETE(margin);
	}
	if (mptr != NULL)
	{
		state->left_margin_stack = mptr;
		state->left_margin = mptr->margin;
		/*
		 * For a list wrapped around a floating image we may
		 * need to be indented from the image edge.
		 */
		if (state->list_stack->old_left_margin > mptr->margin)
		{
			state->left_margin = state->list_stack->old_left_margin;
		}
	}
	else
	{
		state->left_margin_stack = NULL;
		state->left_margin = (state->list_stack != NULL)
						   ? state->list_stack->old_left_margin
						   : 0;
	}

	/*
	 * Find floating elements just added to the right margin stack
	 * from the last line, and set their absolute
	 * coordinates.
	 */
	mptr = state->right_margin_stack;
	while ((mptr != NULL)&&(mptr->y_min < 0))
	{
		mptr->y_min = state->y;
		mptr->y_max = mptr->y_min + mptr->y_max;
		mptr = mptr->next;
	}

	/*
	 * Find where we hit the right margin, popping old
	 * obsolete elements as we go.
	 */
	mptr = state->right_margin_stack;
	while ((mptr != NULL)&&(state->y > mptr->y_max))
	{
		lo_MarginStack *margin;

		margin = mptr;
		mptr = mptr->next;
		XP_DELETE(margin);
	}
	if (mptr != NULL)
	{
		state->right_margin_stack = mptr;
		state->right_margin = mptr->margin;
	}
	else
	{
		state->right_margin_stack = NULL;
		state->right_margin = (state->list_stack != NULL)
							? state->list_stack->old_right_margin
							: 0;
	}
}

void
lo_RecycleElements(MWContext *context, lo_DocState *state, LO_Element *elements)
{
	LO_Element *eptr;

	if (elements == NULL)
	{
		return;
	}

	eptr = elements;
	while(eptr->lo_any.next != NULL)
	{
		lo_ScrapeElement(context, eptr, TRUE);
		eptr = eptr->lo_any.next;
	}
	lo_ScrapeElement(context, eptr, TRUE);
#ifdef MEMORY_ARENAS
    if ( EDT_IS_EDITOR(context) ) {
	    eptr->lo_any.next = state->top_state->recycle_list;
	    state->top_state->recycle_list = elements;
    }
#else
	eptr->lo_any.next = state->top_state->recycle_list;
	state->top_state->recycle_list = elements;
#endif /* MEMORY_ARENAS */
}


LO_Element *
lo_NewElement(MWContext *context, lo_DocState *state, intn type, 
		ED_Element *edit_element, intn edit_offset)
{
	LO_Element *eptr;

#ifdef MEMORY_ARENAS
	int32 size;

	switch(type)
	{
		case LO_TEXT:
			size = sizeof(LO_TextStruct);
			break;
		case LO_LINEFEED:
			size = sizeof(LO_LinefeedStruct);
			break;
		case LO_HRULE:
			size = sizeof(LO_HorizRuleStruct);
			break;
		case LO_IMAGE:
			size = sizeof(LO_ImageStruct);
			break;
		case LO_BULLET:
			size = sizeof(LO_BulletStruct);
			break;
		case LO_FORM_ELE:
			size = sizeof(LO_FormElementStruct);
			break;
		case LO_SUBDOC:
			size = sizeof(LO_SubDocStruct);
			break;
		case LO_TABLE:
			size = sizeof(LO_TableStruct);
			break;
		case LO_BUILTIN:
			size = sizeof(LO_BuiltinStruct);
			break;
		case LO_CELL:
			size = sizeof(LO_CellStruct);
			break;
		case LO_EMBED:
			size = sizeof(LO_EmbedStruct);
			break;
#ifdef JAVA
		case LO_JAVA:
			size = sizeof(LO_JavaAppStruct);
			break;
#endif
		case LO_EDGE:
			size = sizeof(LO_EdgeStruct);
			break;
		case LO_OBJECT:
			size = sizeof(LO_ObjectStruct);
			break;
		case LO_PARAGRAPH:
			size = sizeof(LO_ParagraphStruct);
			break;
		case LO_CENTER:
			size = sizeof(LO_CenterStruct);
			break;
		case LO_MULTICOLUMN:
			size = sizeof(LO_MulticolumnStruct);
			break;
		case LO_TEXTBLOCK:
			size = sizeof(LO_TextBlock);
			break;
		case LO_LIST:
			size = sizeof(LO_ListStruct);
			break;
		case LO_DESCTITLE:
			size = sizeof(LO_DescTitleStruct);
			break;
		case LO_DESCTEXT:
			size = sizeof(LO_DescTextStruct);
			break;
		case LO_BLOCKQUOTE:
			size = sizeof(LO_BlockQuoteStruct);
			break;
		case LO_LAYER:
			size = sizeof(LO_LayerStruct);
			break;
		case LO_HEADING:
			size = sizeof(LO_HeadingStruct);
			break;
		case LO_SPAN:
			size = sizeof(LO_SpanStruct);
			break;
		case LO_DIV:
			size = sizeof(LO_DivStruct);
			break;
		case LO_SPACER:
			size = sizeof(LO_SpacerStruct);
			break;
		case LO_FLOAT:
			size = sizeof(LO_FloatStruct);
                        break;
		case LO_SUPER:
			size = sizeof(LO_SuperStruct);
                        break;
		case LO_SUB:
			size = sizeof(LO_SubStruct);
                        break;
		default:
			size = sizeof(LO_Any);
			break;
	}
    if ( ! EDT_IS_EDITOR(context) ) {
    	eptr = (LO_Element *)lo_MemoryArenaAllocate(state->top_state, size);
    }
    else {
	    if (state->top_state->recycle_list != NULL)
	    {
		    eptr = state->top_state->recycle_list;
		    state->top_state->recycle_list = eptr->lo_any.next;
	    }
	    else
	    {
            eptr = XP_NEW_ZAP(LO_Element);
        }
    }
#else

	/* sorry about all the asserts, in my debug version somehow state
	 * becomes nil after a malloc failure. */
#ifdef DEBUG
	assert (state);
#endif
	
	if (state->top_state->recycle_list != NULL)
	{
		eptr = state->top_state->recycle_list;
		state->top_state->recycle_list = eptr->lo_any.next;
	}
	else
	{
		eptr = XP_NEW(LO_Element);
#ifdef DEBUG
		assert (state);
#endif
	} 
#endif /* MEMORY_ARENAS */
	
	if (eptr == NULL)
	{
#ifdef DEBUG
		assert (state);
#endif
		state->top_state->out_of_memory = TRUE;
	}
	else
	{
#ifdef DOM
                eptr->lo_any.node = NULL;
#endif
		eptr->lo_any.width = 0;
		eptr->lo_any.height = 0;
		eptr->lo_any.x_offset = 0;
		eptr->lo_any.y_offset = 0;
		eptr->lo_any.x = 0;
		eptr->lo_any.y = 0;
		eptr->lo_any.line_height = 0;

		eptr->lo_any.next = NULL;
		eptr->lo_any.prev = NULL;
#ifdef EDITOR
		eptr->lo_any.edit_element = NULL;
		eptr->lo_any.edit_offset = 0;

		if( EDT_IS_EDITOR(context) )
        {
            /* if( lo_EditableElement( type ) ) Change from toshok: */
            if( lo_EditableElement( type ) && type != LO_LINEFEED )
		    {
			    if( edit_element == 0 ){
				    edit_element = state->edit_current_element;
				    edit_offset = state->edit_current_offset;
			    }
			    EDT_SetLayoutElement( edit_element, 
									    edit_offset,
									    type,
									    eptr );
            }
        }
		state->edit_force_offset = FALSE;
#endif
	}

	return(eptr);
}


/* Add a named anchor to the global list of named anchors.  This does not
   associate the anchor with a layout element.  lo_SetNamedAnchor should be
   followed by a call to lo_BindNamedAnchorToElement in order to associate
   the named anchor with a layout element. */
Bool
lo_SetNamedAnchor(lo_DocState *state, PA_Block name)
{
	lo_NameList *name_rec = NULL;
    lo_DocLists *doc_lists;

	/*
	 * No named anchors are allowed within a
	 * hacked scrolling content layout document.
	 */
	if (state->top_state->scrolling_doc != FALSE)
	{
		if (name != NULL)
		{
			PA_FREE(name);
		}
		return FALSE;
	}

    doc_lists = lo_GetCurrentDocLists(state);
    
    if (state->in_relayout) {
        /* Look for the old lo_NameList.  Its mocha_object is still valid. */
        lo_NameList *name_list = doc_lists->name_list;
        lo_NameList *prev;
        Bool no_match;
        char *s1, *s2;
        
        XP_ASSERT(name_list);   /* If in relayout, this cannot be empty. */
        
        prev = name_list;
        name_rec = name_list;
        while (name_rec != NULL) {
            PA_LOCK(s1, char*, name);
            PA_LOCK(s2, char*, name_rec->name);
            no_match = XP_STRCMP(s1, s2);
            PA_UNLOCK(name_rec->name);
            PA_UNLOCK(name);
            if (!no_match) {
                if (name_rec == name_list)
                    doc_lists->name_list = name_list->next;
                else
                    prev->next = name_rec->next;
                PA_FREE(name_rec->name); /* No need for this, use new one. */
                break;
            }
            prev = name_rec;
            name_rec = name_rec->next;
        }
    }
    if (!name_rec || !state->in_relayout) {
        name_rec = XP_NEW(lo_NameList);
        if (name_rec == NULL)
            {
                state->top_state->out_of_memory = TRUE;
                PA_FREE(name);
                return FALSE;
            }
        name_rec->mocha_object = NULL;
    }
    name_rec->x = 0;
    name_rec->y = 0;
    name_rec->name = name;
    name_rec->element = NULL;   /* Set by lo_BindNamedAnchorToElement. */

	name_rec->next = doc_lists->name_list;
	doc_lists->name_list = name_rec;
	return TRUE;
}

/* Associate a named anchor with a layout element.  The named anchor should
   be the first one in the list of named anchors.*/
Bool
lo_BindNamedAnchorToElement(lo_DocState *state, PA_Block name,
                           LO_Element *element)
{
    Bool no_match;
	LO_Element *eptr;
	lo_NameList *name_rec;
    char *s1, *s2;
    lo_DocLists *doc_lists;

    doc_lists = lo_GetCurrentDocLists(state);
    
	if (element == NULL)
	{
		if (state->line_list == NULL)
		{
			eptr = state->end_last_line;
		}
		else
		{
			eptr = state->line_list;
			while (eptr->lo_any.next != NULL)
			{
				eptr = eptr->lo_any.next;
			}
		}
	}
	else
	{
		eptr = element;
	}

    /* Find the matching name_rec in the name_list */
    name_rec = doc_lists->name_list;
    PA_LOCK(s1, char*, name);
    while (name_rec != NULL)
    {
	PA_LOCK(s2, char*, name_rec->name);
	no_match = XP_STRCMP(s1, s2);
	PA_UNLOCK(name_rec->name);
	if (!no_match)
	    break;
	name_rec = name_rec->next;
    }
    PA_UNLOCK(name);
    if (name_rec == NULL)
        return FALSE;

	if (eptr == NULL)
	{
		name_rec->x = 0;
		name_rec->y = 0;
	}
	else
	{
		name_rec->x = eptr->lo_any.x;
		name_rec->y = eptr->lo_any.y;
	}

	name_rec->element = eptr;
    return TRUE;
}


void
lo_AddNameList(lo_DocState *state, lo_DocState *old_state)
{
/*
 * Now named anchors are added directly to the
 * top_state (or layer's) name_list, so we don't have to push
 * them up. We do, however, need to update their positions, 
 * though it seems like this is done at the end of table 
 * processing. Hence this code is no longer necessary.
 */
#if 0
	lo_NameList *name_list;
	lo_NameList *nptr;

	name_list = old_state->name_list;
	while (name_list != NULL)
	{
		/*
		 * Extract the current record from the list.
		 */
		nptr = name_list;
		name_list = name_list->next;

		/*
		 * The element almost certainly has been moved
		 * from subdoc to main cell, correct its position.
		 */
		if (nptr->element != NULL)
		{
			nptr->x = nptr->element->lo_any.x;
			nptr->y = nptr->element->lo_any.y;
		}

		/*
		 * Stick it into the main name list.
		 */
		nptr->next = state->name_list;
		state->name_list = nptr;
	}
	old_state->name_list = name_list;
#endif /* 0 */
}


void
lo_CheckNameList(MWContext *context, lo_DocState *state, int32 min_id)
{
	lo_NameList *nptr;
    lo_DocLists *doc_lists;

	/*
	 * Positions of named elements are only accurate if
	 * we are not in a nested subdoc.
	 */
	if (state->is_a_subdoc != SUBDOC_NOT)
	{
		return;
	}

    doc_lists = lo_GetCurrentDocLists(state);
    
	nptr = doc_lists->name_list;
	while (nptr != NULL)
	{
		/*
		 * If the element's id is greater
		 * than the passed minimum, then
		 * the element almost certainly has been moved
		 * during table processing,
		 * correct its position.
		 */
		if ((nptr->element != NULL)&&
			(nptr->element->lo_any.ele_id > min_id))
		{
			nptr->x = nptr->element->lo_any.x;
			nptr->y = nptr->element->lo_any.y;
		}

		/*
		 * If we are blocked on a named element.
		 * Check if this name is one we are waiting on.
		 */
		if ((state->display_blocking_element_id == -1)&&
			(nptr->name != NULL))
		{
			char *name;

			PA_LOCK(name, char *, nptr->name);
			if (XP_STRCMP(name,
			    (char *)(state->top_state->name_target + 1)) == 0)
			{
				XP_FREE(state->top_state->name_target);
				state->top_state->name_target = NULL;
				if (nptr->element != NULL)
				{
					state->display_blocking_element_id =
						nptr->element->lo_any.ele_id;
				}
				else
				{
					state->display_blocking_element_id =
						state->top_state->element_id;
				}
				/*
				 * If the display is blocked for an element
				 * we havn't reached yet, check to see if
				 * it is in this line, and if so, save its
				 * y position.
				 */
				if ((state->display_blocked != FALSE)&&
				    (state->is_a_subdoc == SUBDOC_NOT)&&
				    (state->display_blocking_element_y == 0)&&
				    (state->display_blocking_element_id != -1))
				{
					state->display_blocking_element_y = nptr->y;
				}
				PA_UNLOCK(nptr->name);
			}
			else
			{
				PA_UNLOCK(nptr->name);
			}
		}

		nptr = nptr->next;
	}
}

#if DOM
extern char *element_names[];

/* Wire the element to the DOM Node data for DOM-driven feedback. */
void
lo_SetNodeElement(lo_DocState *state, LO_Element *element)
{
    LO_Element *eptr;
    DOM_Node *node = ACTIVE_NODE(state);

#ifdef DEBUG_shaver
    if (!node)
        fprintf(stderr, "NULL node\n");
    else if (node->type == NODE_TYPE_DOCUMENT)
        fprintf(stderr, "NODE_TYPE_DOCUMENT node\n");
#endif
    if (!node || node->type == NODE_TYPE_DOCUMENT)
        return;
    XP_ASSERT(!ELEMENT_PRIV(node)->ele_end);
#ifdef DEBUG_shaver
    if (ELEMENT_PRIV(node)->ele_end) {
        fprintf(stderr, "lo_SetNodeElement: node %s has end already!\n",
                node->type == NODE_TYPE_TEXT ? "text" :
                ((DOM_Element *)node)->tagName);
    }
#endif           
    eptr = ELEMENT_PRIV(node)->ele_start;
    if (!eptr) {
        /* this the first element for this node, so mark it */
        ELEMENT_PRIV(node)->ele_start = element;
    }
#ifdef DEBUG_shaver_verbose
    if (element->lo_any.node)
      fprintf(stderr, "element %p (type %d) already has node %x\n",
              element, element->lo_any.type, element->lo_any.node);
#endif
    element->lo_any.node = node;
}
#endif

void
lo_AppendToLineList(MWContext *context, lo_DocState *state,
	LO_Element *element, int32 baseline_inc)
{
	LO_Element *eptr;

#ifdef DOM
        lo_SetNodeElement(state, element);
#endif
	
	if (state->current_named_anchor != NULL) {
		if (!lo_BindNamedAnchorToElement(state, state->current_named_anchor,
                                         element)) {
            XP_ASSERT(FALSE);
        }
	state->current_named_anchor = NULL;
	}
    else if (state->current_anchor) {
        state->current_anchor->element = element;
    }

	element->lo_any.next = NULL;
	element->lo_any.prev = NULL;
	eptr = state->line_list;
	if (eptr == NULL)
	{
		state->line_list = element;
	}
	else
	{
		while (eptr->lo_any.next != NULL)
		{
			eptr->lo_any.y_offset += baseline_inc;
			eptr = eptr->lo_any.next;
		}
		eptr->lo_any.y_offset += baseline_inc;
		eptr->lo_any.next = element;
		element->lo_any.prev = eptr;
	}
}

void
lo_SetLineArrayEntry(lo_DocState *state, LO_Element *eptr, int32 line)
{
	LO_Element **line_array;

#ifdef XP_WIN16
        intn a_size;
        intn a_indx;
        intn a_line;
        XP_Block *larray_array;
#endif /* XP_WIN16 */

	if ((line < 0) || (line >= (state->line_num - 1)))
	{
		return;
	}

#ifdef XP_WIN16
        a_size = SIZE_LIMIT / sizeof(LO_Element *);
        a_indx = (intn)(line / a_size);
        a_line = (intn)(line - (a_indx * a_size));

        XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array);
        state->line_array = larray_array[a_indx];
        XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
	line_array[a_line] = eptr;

        XP_UNLOCK_BLOCK(state->line_array);
        XP_UNLOCK_BLOCK(state->larray_array);
#else
        XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
	line_array[line] = eptr;
        XP_UNLOCK_BLOCK(state->line_array);
#endif /* XP_WIN16 */
}

#define POSITIVE_SCALE_FACTOR 1.10 /* 10% */
#define NEGATIVE_SCALE_FACTOR .90  /* 10% */


/*
 * Return the scaling percentage given a font scaler
 *
 */
double
LO_GetScalingFactor(int32 scaler)
{
    double scale=1.0;
    double mult;
    int32 count;

    if(scaler < 0)
    {
        count = -scaler;
        mult = NEGATIVE_SCALE_FACTOR;
    }
    else
    {
       count = scaler;
       mult = POSITIVE_SCALE_FACTOR;
    }

    /* use the percentage scaling factor to the power of the pref */
    while(count--)
        scale *= mult;

    return scale;
}


/*
 * Return the width of the window for this context in chars in the default
 * fixed width font.  Return -1 on error.
 */
int16
LO_WindowWidthInFixedChars(MWContext *context)
{
	int32 doc_id;
	lo_TopState *top_state;
	lo_DocState *state;
	LO_TextInfo tmp_info;
	LO_TextAttr tmp_attr;
	LO_TextStruct tmp_text;
	PA_Block buff;
	char *str;
	int32 width;
	int16 char_cnt;

	/*
	 * Get the unique document ID, and retreive this
	 * documents layout state.
	 */
	doc_id = XP_DOCID(context);
	top_state = lo_FetchTopState(doc_id);
	if ((top_state == NULL)||(top_state->doc_state == NULL))
	{
		return((int16)-1);
	}
	state = top_state->doc_state;

	/*
	 * Create a fake text buffer to measure an 'M'.
	 */
	memset (&tmp_text, 0, sizeof (tmp_text));
	buff = PA_ALLOC(1);
	if (buff == NULL)
	{
		return((int16)-1);
	}
	PA_LOCK(str, char *, buff);
	str[0] = 'M';
	PA_UNLOCK(buff);
	tmp_text.text = buff;
	tmp_text.text_len = 1;

	/*
	 * Fill in default fixed font information.
	 */
	lo_SetDefaultFontAttr(state, &tmp_attr, context);
	tmp_attr.fontmask |= LO_FONT_FIXED;
	tmp_text.text_attr = &tmp_attr;

	/*
	 * Get the width of that 'M'
	 */
	FE_GetTextInfo(context, &tmp_text, &tmp_info);
	PA_FREE(buff);

	/*
	 * Error if bad character width
	 */
	if (tmp_info.max_width <= 0)
	{
		return((int16)-1);
	}

	width = state->win_width - state->win_left - state->win_right;
	char_cnt = (int16)(width / tmp_info.max_width);
	return(char_cnt);
}


LO_Element *
lo_FirstElementOfLine(MWContext *context, lo_DocState *state, int32 line)
{
	LO_Element *eptr;
	LO_Element **line_array;

	if ((line < 0)||(line > (state->line_num - 2)))
	{
		return(NULL);
	}

#ifdef XP_WIN16
	{
		intn a_size;
		intn a_indx;
		intn a_line;
		XP_Block *larray_array;

		a_size = SIZE_LIMIT / sizeof(LO_Element *);
		a_indx = (intn)(line / a_size);
		a_line = (intn)(line - (a_indx * a_size));
		XP_LOCK_BLOCK(larray_array, XP_Block *,
				state->larray_array);
		state->line_array = larray_array[a_indx];
		XP_LOCK_BLOCK(line_array, LO_Element **,
				state->line_array);
		eptr = line_array[a_line];
		XP_UNLOCK_BLOCK(state->line_array);
		XP_UNLOCK_BLOCK(state->larray_array);
	}
#else
	{
		XP_LOCK_BLOCK(line_array, LO_Element **,
				state->line_array);
		eptr = line_array[line];
		XP_UNLOCK_BLOCK(state->line_array);
	}
#endif /* XP_WIN16 */
	return(eptr);
}


Bool
lo_FindMochaExpr(char *str, char **expr_start, char **expr_end)
{
	char *tptr;
	char *start;
	char *end;

	if (str == NULL)
	{
		return(FALSE);
	}

	start = NULL;
	end = NULL;
	tptr = str;
	while (*tptr != '\0')
	{
		if ((*tptr == '&')&&(*(char *)(tptr + 1) == '{'))
		{
			start = tptr;
			break;
		}
		tptr++;
	}

	if (start == NULL)
	{
		return(FALSE);
	}

	tptr = (char *)(start + 2);
	while (*tptr != '\0')
	{
		if ((*tptr == '}')&&(*(char *)(tptr + 1) == ';'))
		{
			end = tptr;
			break;
		}
		tptr++;
	}

	if (end == NULL)
	{
		return(FALSE);
	}

	end = (char *)(end + 1);
	*expr_start = start;
	*expr_end = end;
	return(TRUE);
}


static char *
lo_add_string(char *base, char *add)
{
	char *new;
	int32 base_len, add_len;

	if (add == NULL)
	{
		return(base);
	}

	if (base == NULL)
	{
		new = XP_STRDUP(add);
		return(new);
	}

	base_len = XP_STRLEN(base);
	add_len = XP_STRLEN(add);
	new = (char *)XP_ALLOC(base_len + add_len + 1);
	if (new == NULL)
	{
		return(base);
	}

	XP_STRCPY(new, base);
	XP_STRCAT(new, add);
	XP_FREE(base);
	return(new);
}


static char *
lo_eval_javascript_entities(MWContext *context, char *orig_value,
							uint newline_count)
{
	char *tptr;
	char *str;
	char *new_str;
	int32 len;
	char tchar;
	Bool has_mocha;
	char *start, *end;

	if (orig_value == NULL)
	{
		return(NULL);
	}

	str = orig_value;
	len = XP_STRLEN(str);

	new_str = NULL;
	tptr = str;
	has_mocha = lo_FindMochaExpr(tptr, &start, &end);
	while (has_mocha != FALSE)
	{
		char *expr_start, *expr_end;

		if (start > tptr)
		{
			tchar = *start;
			*start = '\0';
			new_str = lo_add_string(new_str, tptr);
			*start = tchar;
		}

		expr_start = (char *)(start + 2);
		expr_end = (char *)(end - 1);
		if (expr_end > expr_start)
		{
			char *eval_str;

			tchar = *expr_end;
			*expr_end = '\0';
			eval_str = LM_EvaluateAttribute(context, expr_start,
											newline_count + 1);
			*expr_end = tchar;
			new_str = lo_add_string(new_str, eval_str);
			if (eval_str != NULL)
			{
				XP_FREE(eval_str);
			}
		}

		tptr = (char *)(end + 1);
		has_mocha = lo_FindMochaExpr(tptr, &start, &end);
	}
	if (tptr != str)
	{
		new_str = lo_add_string(new_str, tptr);
	}

	if (new_str == NULL)
	{
		new_str = str;
	}

	return(new_str);
}


void
lo_ConvertAllValues(MWContext *context, char **value_list, int32 list_len,
					uint newline_count)
{
	int32 i;

	if (LM_CanDoJS(context) == FALSE)
	{
		return;
	}

	for (i=0; i < list_len; i++)
	{
		char *str;
		char *new_str;

		str = value_list[i];
		if (str != NULL)
		{
			new_str = lo_eval_javascript_entities(context, str, newline_count);
			if (new_str != str)
			{
				XP_FREE(str);
				value_list[i] = new_str;
			}
		}
	}
}


PA_Block
lo_FetchParamValue(MWContext *context, PA_Tag *tag, char *param_name)
{
	PA_Block buff;
	INTL_CharSetInfo c = LO_GetDocumentCharacterSetInfo(context);
	buff = PA_FetchParamValue(tag, param_name, INTL_GetCSIWinCSID(c));
	return(buff);
}

#include "prthread.h"
#include "prmon.h"

static PRMonitor * layout_lock_monitor = NULL;
static PRThread  * layout_lock_owner = NULL;
static int layout_lock_count = 0;

/*
 * Grab the lock around layout so that we can delete things / manipulate
 *   layout owned data structures in a separate thread
 */
void
LO_LockLayout()
{
    if(!layout_lock_monitor)
	layout_lock_monitor = PR_NewNamedMonitor("layout-lock");

    PR_EnterMonitor(layout_lock_monitor);

    while(TRUE) {

	/* no current owner or owned by this thread */
	if(layout_lock_owner == NULL ||
	   layout_lock_owner == PR_CurrentThread()) {
	    layout_lock_owner = PR_CurrentThread();
	    layout_lock_count++;

	    PR_ExitMonitor(layout_lock_monitor);
	    return;
	}

	/* owned by someone else -- wait till we can get it */
	PR_Wait(layout_lock_monitor, PR_INTERVAL_NO_TIMEOUT);

    }
}

/*
 * Release the lock and wake up anyone who was waiting to get it if
 *   we are the last release of the lock from this thread
 */
void
LO_UnlockLayout()
{

    PR_EnterMonitor(layout_lock_monitor);

#ifdef DEBUG
    /* make sure someone doesn't try to free a lock they don't own */
    XP_ASSERT(layout_lock_owner == PR_CurrentThread());
#endif

    layout_lock_count--;

    if(layout_lock_count == 0) {
	layout_lock_owner = NULL;
	PR_Notify(layout_lock_monitor);
    }
    PR_ExitMonitor(layout_lock_monitor);

}


/*
 * A (debugging) way to make sure the current thread doesn't have the
 *   layout lock
 */
Bool
LO_VerifyUnlockedLayout()
{
#ifdef DEBUG
    Bool bHolding = TRUE;
    
    if (layout_lock_monitor) {
	PR_EnterMonitor(layout_lock_monitor);
	bHolding = (layout_lock_owner != PR_CurrentThread());
	PR_ExitMonitor(layout_lock_monitor);
    }

    return bHolding;

#else
    return TRUE;
#endif
}


/*
 * The mocha lock has been released, flush the blockage to see if
 *   we can get our blocked entities evaluated now.
 */
static void
lo_JSLockReleased(void * data)
{
    MWContext * context = (MWContext *) data;
    lo_TopState * top_state;

    top_state = lo_FetchTopState(XP_DOCID(context));
    if (!top_state)
	return;

    /* free the fake element we created earlier */
    lo_FreeElement(context, top_state->layout_blocking_element, FALSE);

    /* flush the blockage */
    lo_UnblockLayout(context, top_state);
}

/* 
 * see if there are any &{} constructs for this tag.  If so,
 *   convert them now, if we can't convert them (since we couldn't
 *   get the mocha lock, for example) return FALSE
 */
Bool
lo_ConvertMochaEntities(MWContext * context, lo_DocState *state, PA_Tag * tag)
{

    	char *tptr;
	char *str;
	char *new_str;
	int32 len;
	char tchar;
	Bool has_mocha;
	char *start, *end;
    int32 cur_layer_id;

	PA_LOCK(str, char *, tag->data);
	len = tag->data_len;

	if (LM_CanDoJS(context) == FALSE)
	    return TRUE;

	new_str = NULL;
	tptr = str;
	has_mocha = lo_FindMochaExpr(tptr, &start, &end);

	if (has_mocha == FALSE)
	    return TRUE;

	/* attempt to lock JS */
	if (!LM_AttemptLockJS(context, lo_JSLockReleased, context))
	    return FALSE;

    /* 
     * Make sure that the current layer and all its ancestors have
     * been reflected and that the current layer has been set as the 
     * active layer, since we want to ensure correct scoping and there's 
     * no way to know that the reflect event has reached Mocha yet. 
     * Note that reflecting the object multiple times is safe, since the 
     * reflection code is idempotent.
     */
    cur_layer_id = lo_CurrentLayerId(state);
    if (cur_layer_id != LO_DOCUMENT_LAYER_ID) {
        CL_Layer *layer, *parent;
	int32 child_layer_id = cur_layer_id;
        int32 parent_layer_id;
        
	do {
	    layer = LO_GetLayerFromId(context, child_layer_id);
	    parent = CL_GetLayerParent(layer);
	    parent_layer_id = LO_GetIdFromLayer(context, parent);
	    LM_ReflectLayer(context, cur_layer_id, parent_layer_id, NULL);
	    child_layer_id = parent_layer_id;
	} while (child_layer_id != LO_DOCUMENT_LAYER_ID);

    }
    LM_SetActiveLayer(context, cur_layer_id);
	while (has_mocha != FALSE)
	{
		char *expr_start, *expr_end;

		if (start > tptr)
		{
			tchar = *start;
			*start = '\0';
			new_str = lo_add_string(new_str, tptr);
			*start = tchar;
		}

		expr_start = (char *)(start + 2);
		expr_end = (char *)(end - 1);
		if (expr_end > expr_start)
		{
			char *eval_str;

			tchar = *expr_end;
			*expr_end = '\0';
            if (state->top_state && state->top_state->nurl) {
                LM_SetDecoderStream(context, NULL, 
                                    state->top_state->nurl,
                                    JS_FALSE);
            }
			eval_str = LM_EvaluateAttribute(context, expr_start,
							tag->newline_count + 1);
			*expr_end = tchar;
			new_str = lo_add_string(new_str, eval_str);
			if (eval_str != NULL)
			{
				XP_FREE(eval_str);
			}
		}

		tptr = (char *)(end + 1);
		has_mocha = lo_FindMochaExpr(tptr, &start, &end);
	}
	if (tptr != str)
	{
		new_str = lo_add_string(new_str, tptr);
	}

	PA_FREE(tag->data);
	tag->data = (PA_Block) new_str;
	tag->data_len = XP_STRLEN((char *) tag->data);
	PA_UNLOCK(tag->data);

	LM_UnlockJS(context);

	return TRUE;

}

/* Called from front ends as a threadsafe way to update values of text fields. */
void
LO_UpdateTextData(lo_FormElementTextData * textData, const char * text) {

    LO_LockLayout();

    if(textData->current_text)
	XP_FREE(textData->current_text);
	        
    textData->current_text = (PA_Block) XP_STRDUP(text);

    LO_UnlockLayout();
}

LO_TableStruct *lo_GetParentTable(MWContext *pContext, LO_Element *pElement)
{
    LO_Element *tptr;
    if( !pElement )
        return NULL;

    if( pElement->lo_any.type == LO_CELL )
    {
        /* Supplied element is already a cell, start table search with it */
        tptr = pElement;
    } else {
        if( !pContext )
            return NULL;

        /* First find the cell that contains the given element */
        tptr = (LO_Element*)lo_GetParentCell(pContext, pElement);
    }

    /* Simply search back from current cell to find table element */
    while( tptr )
    {
        if( tptr->lo_any.type == LO_TABLE )
        {
            return (LO_TableStruct*)tptr;
        }
        tptr = tptr->lo_any.prev;
    } 
    return NULL;
}


/* Recusively search for cell struct containing the given element 
 * If table is found, it searches into that as well
 */
LO_CellStruct *lo_GetCellContainingElement( LO_Element *pElement, LO_CellStruct *pFirstCell )
{
    LO_CellStruct *pNestedCell = NULL;
    LO_CellStruct *pFirstNestedCell;
    LO_Element    *cell_list_ptr;
    LO_CellStruct *pLoCell;

    pLoCell = pFirstCell;
    if( pLoCell == NULL )
        return NULL;

    do {
	    cell_list_ptr = pLoCell->cell_list;
        while( cell_list_ptr )
        {
            if( cell_list_ptr == pElement )
            {
                /* We found the element - return cell containing it */
                return pLoCell;
            }
            if( cell_list_ptr->type == LO_TABLE )
            {
                /* We found a nested table
                 * Get first cell in it and search through it
                */
                pFirstNestedCell = (LO_CellStruct*)cell_list_ptr->lo_any.next;
                XP_ASSERT(pFirstNestedCell->type == LO_CELL);
                pNestedCell = lo_GetCellContainingElement(pElement, pFirstNestedCell);
                if( pNestedCell )
                {
                   /* We found cell in nested table */
                   return pNestedCell;
                }
            }
            cell_list_ptr = cell_list_ptr->lo_any.next;
        }
        pLoCell = (LO_CellStruct*)pLoCell->next;
    }  /* End when there's no more cells or we hit linefeed at end of line (top-level table)*/
    while (pLoCell && pLoCell->type == LO_CELL);

    return NULL;
}

/* Search algorithm is very similar to CEditBuffer::GetTableHitRegion()
 *   (which is similar to lo_XYtoDocumentElement except it finds only cells)
 * Search for the Cell that contains pElement
*/
LO_CellStruct *lo_GetParentCell(MWContext * pContext, LO_Element *pElement)
{
    LO_Element *tptr;
	int32 doc_id;
	lo_TopState *top_state;
	lo_DocState *state;
	XP_Bool in_table;
	int32 line;
	LO_Element *end_ptr;
	LO_Element *tptrTable;
    int32 x, y, t_width, t_height;

	doc_id = XP_DOCID(pContext);
	top_state = lo_FetchTopState(doc_id);

    /* Supplied element is a cell - return it ??? */
    if( pElement && pElement->type == LO_CELL )
        return (LO_CellStruct*)pElement;

	if( pContext == NULL || pElement == NULL || top_state == NULL || top_state->doc_state == NULL )
		return NULL;
	
    state = top_state->doc_state;
	tptrTable = NULL;
	in_table = FALSE;
    
    /* Find the line that contains the supplied element
     * This defines the top-level table
    */
	x = pElement->lo_any.x+1;
    y = pElement->lo_any.y+1;

    line = lo_PointToLine(pContext, state, x, y);
    lo_GetLineEnds(pContext, state, line, &tptr, &end_ptr);

	while (tptr != end_ptr)
	{
   		t_width = tptr->lo_any.width;
   		t_height = tptr->lo_any.height;

		if (t_width <= 0)
		{
			t_width = 1;
		}

		if ((y >= tptr->lo_any.y) &&
            (y < tptr->lo_any.y + tptr->lo_any.y_offset + t_height) &&
			(x >= tptr->lo_any.x) &&
			(x < (tptr->lo_any.x + tptr->lo_any.x_offset + t_width)))
		{
            /* We are only interested in finding cells */
			if (tptr->type == LO_CELL)
            {
                /* Search through the cell's element list,
                 * Including all nested tables in that cell
                */
                LO_CellStruct * pLoCell = lo_GetCellContainingElement(pElement, (LO_CellStruct*)tptr);
                /* We found it - done */
                if( pLoCell )
                    return pLoCell;
            }
		}
		tptr = tptr->lo_any.next;
	}

    /* Failed to find element */
    return NULL;
}


static int lo_iColumnX = 0;
static int lo_iRowY = 0;

/* Find the first cell with with closest left border x-value <= than the given x
 * value or, if bGetColumn=FALSE, find the cell with closest top border 
 *   y-value <= than the given Y value. Also returns the pointer to the
 *    last LO element so we can search for other cells until pEndElement is reached.
*/
LO_Element* lo_GetFirstCellInColumnOrRow(MWContext *pContext, LO_Element *pElement, int32 x, int32 y, XP_Bool bGetColumn, LO_Element **ppLastCellInTable)
{
	LO_Element *pFirstCell = NULL;
	LO_Element *pLastCellInTable = NULL;
	LO_Element *tptr = NULL;
    int32 closest = 0;

    /* Save these values so future calls to lo_GetNextCellInColumnOrRow can use them */    
    if( bGetColumn )
        lo_iColumnX = x;
    else
        lo_iRowY = y;

    if( pElement->type == LO_TABLE )
    {
        /* Start at first element after the table */
        tptr = pElement->lo_any.next;
    } else {
    
        if( pElement->type == LO_CELL )
        {
            /* Element is a cell */
            tptr = pElement;
        } else {
            /* Get parent cell of supplied element */
            tptr = (LO_Element*)lo_GetParentCell(pContext, pElement);
        }
        if( !tptr )
            return NULL;
    
        /* Search back until we are at first cell in table */
        while ( (tptr->lo_any.prev)->type != LO_TABLE )
        {
            tptr = tptr->lo_any.prev;
        }
    }
    
    /* Scan all cells to find first and last */
    do {
        if( tptr->type == LO_CELL )
        {
            if( bGetColumn && tptr->lo_any.x <= x &&
                tptr->lo_any.x > closest  )
            {
                /* We found a cell candidate */
                closest = tptr->lo_any.x;
                pFirstCell = tptr;
            } else if( !bGetColumn && tptr->lo_any.y <= y &&
                       tptr->lo_any.y > closest )
            {
                closest = tptr->lo_any.y;
                pFirstCell = tptr;
            }
            pLastCellInTable = tptr;
        }
        tptr = tptr->lo_any.next;

       /* Table ends at linefeed (top level) or null element (nested table) */
    } while (tptr && tptr->type != LO_LINEFEED ); 

    /* Return last cell element encountered */
    if( ppLastCellInTable )
        *ppLastCellInTable = pLastCellInTable;

    return pFirstCell;    
}

LO_Element* lo_GetNextCellInColumnOrRow(MWContext *pContext, int32 x, int32 y, LO_Element *pElement, XP_Bool bGetColumn)
{
    LO_Element *tptr;

	if(!pElement)
        return NULL;

    /* Start with next element after the "current" one supplied */
    tptr = pElement->lo_any.next;

    /* Be sure we are a cell */
    /* (tptr = LO_LINEFEED if we were already on the last cell */
    while ( tptr && tptr->type != LO_LINEFEED && tptr->type != LO_CELL )
        tptr = tptr->lo_any.next;

    if(!tptr || tptr->type == LO_LINEFEED)
        return NULL;
    
    /* Set column X or row Y values that define a col or row respectively */
    if( bGetColumn )
    {
        if( x > 0 )
            lo_iColumnX = x;
    }
    else
    {
        if( y > 0 )
            lo_iRowY = y;
    }

    do {
        if( tptr->type == LO_CELL )
        {
            /* Note that we return cell SPANNED by given ColumnX or RowY */
            if( ( bGetColumn && tptr->lo_any.x <= lo_iColumnX &&
                  (tptr->lo_any.x + tptr->lo_any.width) > lo_iColumnX ) ||
                ( !bGetColumn && tptr->lo_any.y <= lo_iRowY &&
                  (tptr->lo_any.y + tptr->lo_any.height) > lo_iRowY ) )
            {
                return tptr;
            }
        }
        tptr = tptr->lo_any.next;

      /* Table ends at linefeed (top level) or null element (nested table) */
    } while (tptr && tptr->type != LO_LINEFEED ); 

    return NULL;
}

/* Assumptions;
 * Given a LO_CellStruct, the table element defines the begining of table
 *   and the last cell is that whose "next" pointer is NULL (nested table)
 *   or a linefeed element (top-level table)
*/
LO_Element *lo_GetFirstAndLastCellsInTable(MWContext *pContext, LO_Element *pElement, LO_Element **ppLastCell)
{
	LO_Element *tptr = NULL;
	LO_Element *pFirstCell = NULL;
	LO_Element *pLastCell = NULL;
	LO_Element *pCurrentCell = NULL;

    if(pContext == NULL || pElement == NULL )
        return NULL;

    if( pElement->type == LO_CELL )
    {
        pCurrentCell = pElement;
    }
    else if( pElement->type == LO_TABLE )
    {
        /* First cell SHOULD be next element, but let's be sure */
        pCurrentCell = pElement->lo_table.next;
        while(pCurrentCell->type != LO_CELL)
        {
            pCurrentCell = pCurrentCell->lo_any.next;
        }
    } else {
        pCurrentCell = (LO_Element*)lo_GetParentCell(pContext, pElement);
    }

    if( pCurrentCell == NULL )
        return NULL;

    /* Scan backwards until we hit the table element
     *  that's before all the cells
    */
    tptr = pCurrentCell;
    while (tptr && (tptr->lo_any.prev)->type != LO_TABLE )
    {
        tptr = tptr->lo_any.prev;
    }
    
	/* Scan forward to find last cell -- next is null or line-feed element */
    do {
        if( tptr->type == LO_CELL )
        {
            if( !pFirstCell )
                pFirstCell = tptr;

            pLastCell = tptr;
        }
        tptr = tptr->lo_any.next;
    } while (tptr && tptr->type != LO_LINEFEED); 

    /* Return last cell element encountered */
    if( ppLastCell )
        *ppLastCell = pLastCell;

    return pFirstCell;    
}

LO_Element *lo_GetFirstAndLastCellsInColumnOrRow(LO_Element *pCellElement, LO_Element **ppLastCell, XP_Bool bInColumn )
{
	LO_Element *tptr = NULL;
	LO_Element *pFirstCell = NULL;
	LO_Element *pLastCell = NULL;

    if(pCellElement == NULL || pCellElement->type != LO_CELL)
        return NULL;

    /* Scan backwards until we hit the table element
     *  that's before all the cells
    */
    tptr = pCellElement;
    while (tptr && (tptr->lo_any.prev)->type != LO_TABLE )
    {
        tptr = tptr->lo_any.prev;
    }
    
	/* Scan forward to find first and last cells,
     *   based on sharing left edge (column) or top (row)
     */
    do {
        if( tptr->type == LO_CELL )
        {
            if( (bInColumn && pCellElement->lo_any.x == tptr->lo_any.x) ||
                (!bInColumn && pCellElement->lo_any.y == tptr->lo_any.y) )
            {
                if( !pFirstCell )
                    pFirstCell = tptr;

                pLastCell = tptr;
            }
        }
        tptr = tptr->lo_any.next;
    } while (tptr && tptr->type != LO_LINEFEED); 

    /* Return last cell element encountered */
    if( ppLastCell )
        *ppLastCell = pLastCell;

    return pFirstCell;    
}

XP_Bool lo_AllCellsSelectedInColumnOrRow( LO_CellStruct *pCell, XP_Bool bInColumn )
{
	LO_Element *pFirstCell;
	LO_Element *pLastCell = NULL;
	LO_Element *tptr;

    /* Get first and last cells in row or column */
    pFirstCell = lo_GetFirstAndLastCellsInColumnOrRow( (LO_Element*)pCell, &pLastCell, bInColumn );
    if( !pFirstCell || !pLastCell )
        return FALSE;

    tptr = pFirstCell;

    while( TRUE )
    {
        if( tptr->type == LO_CELL )
        {
            if( (bInColumn && pCell->x == tptr->lo_any.x) ||
                (!bInColumn && pCell->y == tptr->lo_any.y) )
            {
                /* If any cell is not selected, return FALSE */
                if( (tptr->lo_cell.ele_attrmask & LO_ELE_SELECTED) ? FALSE : TRUE )
                    return FALSE;
            }
        }
        /* Done when we checked the last cell */
        if( tptr == pLastCell )
            break;

        tptr = tptr->lo_any.next;
        if( !tptr )
            break;
    }
    return TRUE;
}

int32 lo_GetNumberOfCellsInTable(LO_TableStruct *pTable )
{
    int32 iCount = 0;
    if( pTable )
    {
        LO_Element *tptr = (LO_Element*)pTable;
        while( tptr && tptr->type != LO_LINEFEED )
        {
            if( tptr->type == LO_CELL)
                iCount++;
            
            tptr = tptr->lo_any.next;
        }
    }
    return iCount;
}

/* Subtract borders and inter-cell spacing to get the available table width
 *   to use when cell width in HTML is "percent of table"
*/
int32 lo_CalcTableWidthForPercentMode(LO_Element *pCellElement)
{
    LO_Element     *pLastCell;
    LO_Element     *pFirstCell;
    LO_Element     *pCell;
    int32          iWidth;
    XP_Bool        bDone;

    /* Never return 0 to avoid divide by zero errors */
    if( !pCellElement || pCellElement->type != LO_CELL )
        return -1;
 
    iWidth = 0;

    /* We calculate the width by simply adding up widths of all cells in the row */
    pFirstCell = lo_GetFirstAndLastCellsInColumnOrRow(pCellElement, &pLastCell, FALSE );
    pCell = pFirstCell;

    if( pCell && pLastCell )
    {
        bDone = FALSE;
        while(!bDone) 
        {
            if( pCell == pLastCell )
                bDone = TRUE;

            /* Add widths of all cells in the row (must have same top) */
            if( pCell->type == LO_CELL && 
                (pCell->lo_any.y == pFirstCell->lo_any.y) )
            {
                iWidth += pCell->lo_cell.width;            
            }
            pCell = pCell->lo_any.next;
        }
    }    
    return (iWidth > 0) ? iWidth : -1;
}

XP_Bool LO_IsEmptyCell(LO_CellStruct *cell)
{
    if ( cell )
    {
        LO_Element *element = cell->cell_list;

        /* Unlikely, but if nothing inside cell, we're empty! */
        if(element)
        {
            while(element)
            {
                /* Any non-text element except linefeed is not "empty"
                 *  and check for text length
                 * Length of any element is 1. Length of text = real length,
                 * (but we don't want to consider linefeeds)
                */
                if( element->type != LO_LINEFEED && lo_GetElementLength(element) > 0 )
                {
                    return FALSE;
                }
                element = element->lo_any.next;
            }
        }
    }
    return TRUE;
}

/* The LO_CellStruct.width includes border, cell padding etc and is complicated
 * by Column Span as well. Calculate the value to use for <TD WIDTH> param that 
 * would result in current pCellElement->lo_cell.width during the next layout
*/ 
int32 lo_GetCellTagWidth(LO_Element *pCellElement)
{
    /* XP_ASSERT(pCellElement->type == LO_CELL); */ /* Why doesn't this compile! */
    int32 iColSpan = lo_GetColSpan(pCellElement);
    int32 iPadding = iColSpan * 2 * (pCellElement->lo_cell.border_width + 
                                     lo_GetCellPadding(pCellElement));
    
    /* Cells spanning across a border include the inter-cell space as well */
    if( iColSpan > 1 )
        iPadding += (iColSpan - 1) * pCellElement->lo_cell.inter_cell_space;

    return pCellElement->lo_cell.width - iPadding;
}

/* Similar calculation for height. Unfortunately, there are differences from width.
 * e.g., the cell border must be subtracted from width, but not height! (a bug???)
*/
int32 lo_GetCellTagHeight(LO_Element *pCellElement)
{
    /*XP_ASSERT(pCellElement->type == LO_CELL);*/

    int32 iRowSpan = lo_GetRowSpan(pCellElement);
    int32 iPadding = iRowSpan * 2 * (/*pCellElement->lo_cell.border_width + */
                                     lo_GetCellPadding(pCellElement));
    
    if( iRowSpan > 1 )
        iPadding += (iRowSpan - 1) * pCellElement->lo_cell.inter_cell_space;

    return pCellElement->lo_cell.height - iPadding;
}

/* Helpers to access the lo_TableCell members now accessible through the LO_CellStruct */
int32 lo_GetRowSpan(LO_Element *pCellElement)
{
    XP_ASSERT(pCellElement->type == LO_CELL);
    
    if( pCellElement && pCellElement->lo_any.type == LO_CELL &&
        pCellElement->lo_cell.table_cell )
    {
        return ((lo_TableCell*)pCellElement->lo_cell.table_cell)->rowspan;
    }
    /* Should never fail, but since default value is 1,
       this will tell caller we failed */
    return 0;
}

int32 lo_GetColSpan(LO_Element *pCellElement)
{
    XP_ASSERT(pCellElement && pCellElement->type == LO_CELL);
    if( pCellElement && pCellElement->lo_any.type == LO_CELL &&
        pCellElement->lo_cell.table_cell )
    {
        return ((lo_TableCell*)pCellElement->lo_cell.table_cell)->colspan;
    }
    return 0;
}

/* TODO: CHANGE THIS TO GET LEFT, TOP, RIGHT, OR BOTTOM SEPARATELY? */
int32 lo_GetCellPadding(LO_Element *pCellElement)
{
    XP_ASSERT(pCellElement && pCellElement->type == LO_CELL);
    
    if( pCellElement && pCellElement->type == LO_CELL &&
        pCellElement->lo_cell.table )
    {
        return ((lo_TableRec*)pCellElement->lo_cell.table)->inner_top_pad;
    }
    return 0;
}

LO_Element * lo_GetLastElementInList( LO_Element *eleList )
{
	LO_Element *retEle = NULL;

	if (eleList != NULL)
	{
		while (eleList->lo_any.next != NULL)
			eleList = eleList->lo_any.next;

		retEle = eleList;
	}

	return retEle;
		
}

#ifdef PROFILE
#pragma profile off
#endif