gecko-dev/lib/layout/laytext.c

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

#include "xp.h"
#include "pa_tags.h"
#include "layout.h"
#include "laylayer.h"
#include "layers.h"
#include "libi18n.h"
#include "edt.h"
#include "laystyle.h"
#include "laytrav.h"

/*
 * Turn this define on to get the new multibyte parsing code
#define	FAST_MULTI
*/

#define	FAST_EDITOR

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

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

#ifdef XP_UNIX
#define TEXT_CHUNK_LIMIT	500
#else
#define TEXT_CHUNK_LIMIT	1600
#endif

#ifdef XP_MAC
#define NON_BREAKING_SPACE	0x07
#else
#define NON_BREAKING_SPACE	160
#endif

#ifdef PROFILE
#pragma profile on
#endif

int32 lo_correct_text_element_width(LO_TextInfo *);

static void lo_insert_quote_characters(MWContext *context,
                                       lo_DocState *state);
static LO_TextStruct * lo_new_text_element(MWContext *context,
                                           lo_DocState *state,
                                           ED_Element *edit_element,
                                           intn edit_offset );

void lo_LayoutFormattedText(MWContext *context,
                            lo_DocState *state,
                            LO_TextBlock * block);
void lo_LayoutPreformattedText(MWContext *context,
                               lo_DocState *state,
                               LO_TextBlock * block);
LO_TextBlock * lo_NewTextBlock (MWContext * context,
                                lo_DocState * state,
                                char * text,
                                uint16 formatMode );
int32 lo_compute_text_basline_inc (lo_DocState * state,
                                   LO_TextBlock * block,
                                   LO_TextStruct * text_data );

uint32 lo_FindBlockOffset (LO_TextBlock * block,
                           LO_TextStruct * fromElement );
void lo_RelayoutTextElements (MWContext * context,
                              lo_DocState * state,
                              LO_TextBlock * block,
                              LO_TextStruct * fromElement );
Bool lo_CanUseBreakTable (lo_DocState * state );
Bool lo_UseBreakTable (LO_TextBlock * block );

void lo_AppendTextToBlock (MWContext *context,
                           lo_DocState *state,
                           LO_TextBlock * block,
                           char *text );
void lo_LayoutTextBlock (MWContext * context,
                         lo_DocState * state,
                         Bool flushLastLine );
static void lo_FlushText (MWContext * context,
                          lo_DocState * state );
static void lo_SetupBreakState (LO_TextBlock * block );

Bool lo_GrowTextBlock (LO_TextBlock * block,
                       uint32 length );
static void lo_GetTextParseAtributes (lo_DocState * state,
                                      Bool * multiByte );


#ifdef XP_MAC
#define	kStaticMeasureTextBufferSize	512
static uint16 gMeasureTextBuffer[ kStaticMeasureTextBufferSize ];

/* This needs to go in fe_proto.h - will move it there once we're out
   of the branch */
#define FE_MeasureText(context, text, charLocs) \
			(*context->funcs->MeasureText)(context, text, charLocs)
#endif

#ifdef XP_MAC
Bool gCallNewText = TRUE;
#endif

LO_TextBlock * lo_NewTextBlock ( MWContext * context,
                                 lo_DocState * state,
                                 char * text,
                                 uint16 formatMode )
{
	LO_TextBlock *	block;
	uint32			length;
	
	length = strlen ( text );
	
	block = (LO_TextBlock *)lo_NewElement ( context, state,
                                            LO_TEXTBLOCK, NULL, 0 );
	if ( block == NULL )
		{
		state->top_state->out_of_memory = TRUE;
		return NULL;
		}
		
	block->type = LO_TEXTBLOCK;
	block->x_offset = 0;
	block->ele_id = NEXT_ELEMENT;
	block->x = state->x;
	block->y = state->y;
	block->y_offset = 0;
	block->width = 0;
	block->height = 0;
	block->line_height = 0;
	block->next = NULL;
	block->prev = NULL;
	block->text_attr = NULL;
	block->anchor_href = NULL;
	block->ele_attrmask = 0;
	block->format_mode = 0;
	
	block->startTextElement = NULL;
	block->endTextElement = NULL;
	
	block->text_buffer = NULL;
	block->buffer_length = 0;
	block->buffer_write_index = 0;
	block->last_buffer_write_index = 0;
	block->buffer_read_index = 0;
	block->last_line_break = 0;
	
	block->break_table = NULL;
	block->break_length = 0;
	block->break_write_index = 0;
	block->break_read_index = 0;
	block->last_break_offset = 0;
	
	block->multibyte_index = 0;
	block->multibyte_length = 0;
	
	block->old_break = NULL;
	block->old_break_pos = 0;
	block->old_break_width = 0;
	
	block->totalWidth = 0;
	block->totalChars = 0;
	block->break_pending = 0;
	block->last_char_is_whitespace = 0;
	
	block->ascent = 0;
	block->descent = 0;
	
	block->text_buffer = XP_ALLOC ( length + 1 );
	if ( block->text_buffer == NULL )
		{
		XP_FREE ( block );
		state->top_state->out_of_memory = TRUE;
		return NULL;
		}
	
	block->buffer_length = length + 1;
	XP_BCOPY ( text, block->text_buffer, length );
	block->text_buffer[ length ] = '\0';
	block->buffer_write_index = length;
	
	/* default text does not have a break table */
	block->break_table = NULL;
	block->break_length = 0;
	
	block->format_mode = formatMode;
	
	/* 
     * Since we're creating a new text block, grab some of the text
	 * state out of the layout state.  
     */
	block->anchor_href = state->current_anchor;
	
	if ( state->font_stack != NULL )
		{
		block->text_attr = state->font_stack->text_attr;
		}
		
	if (state->breakable != FALSE)
		{
		block->ele_attrmask |= LO_ELE_BREAKABLE;
		}
	
	state->cur_text_block = block;

	lo_AppendToLineList ( context, state, (LO_Element *) block, 0 );
	
	return block;
}

void
lo_SetDefaultFontAttr(lo_DocState *state, LO_TextAttr *tptr,
	MWContext *context)
{
	tptr->size = DEFAULT_BASE_FONT_SIZE;
	tptr->fontmask = 0;
	tptr->no_background = TRUE;
	tptr->attrmask = 0;
	tptr->fg.red =   STATE_DEFAULT_FG_RED(state);
	tptr->fg.green = STATE_DEFAULT_FG_GREEN(state);
	tptr->fg.blue =  STATE_DEFAULT_FG_BLUE(state);
	tptr->bg.red =   STATE_DEFAULT_BG_RED(state);
	tptr->bg.green = STATE_DEFAULT_BG_GREEN(state);
	tptr->bg.blue =  STATE_DEFAULT_BG_BLUE(state);
	tptr->charset = INTL_DefaultTextAttributeCharSetID(context);
	tptr->font_face = NULL;
	tptr->FE_Data = NULL;
	tptr->point_size = 0;
	tptr->font_weight = 0;
}


/*************************************
 * Function: lo_DefaultFont
 *
 * Description: This function sets up the text attribute
 *      structure for the default text drawing font.
 *      This is the font that sits at the bottom of the font
 *	stack, and can never be popped off.
 *
 * Params: Document state
 *
 * Returns: A pointer to a lo_FontStack structure.
 *	Returns a NULL on error (such as out of memory);
 *************************************/
lo_FontStack *
lo_DefaultFont(lo_DocState *state, MWContext *context)
{
	LO_TextAttr tmp_attr;
	lo_FontStack *fptr;
	LO_TextAttr *tptr;

	/*
	 * Fill in default font information.
	 */
	lo_SetDefaultFontAttr(state, &tmp_attr, context);
	tptr = lo_FetchTextAttr(state, &tmp_attr);

	fptr = XP_NEW(lo_FontStack);
	if (fptr == NULL)
	{
		return(NULL);
	}
	fptr->tag_type = P_UNKNOWN;
	fptr->text_attr = tptr;
	fptr->next = NULL;

	return(fptr);
}

/*
** lo_PushAlignment
**
** Pushes a new alignment entry onto the alignment stack.  Alignment
** entries are tagged with both the actually alignment type (CENTER,
** LEFT, RIGHT, MIDDLE, etc.) as well as the tag that contained the
** alignment attribute.  The latter is so we can accurately lookup the
** alignment for a given tag type..
*/
void
lo_PushAlignment(lo_DocState *state, intn tag_type, int32 alignment)
{
	lo_AlignStack *aptr;

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

	aptr->type = tag_type;
	aptr->alignment = alignment;

	aptr->next = state->align_stack;
	state->align_stack = aptr;
}


/*
** lo_PopAlignment
**
** Pops off the top entry from the alignment stack.
*/
lo_AlignStack *
lo_PopAlignment(lo_DocState *state)
{
	lo_AlignStack *aptr;

	aptr = state->align_stack;
	if (aptr != NULL)
	{
		state->align_stack = aptr->next;
		aptr->next = NULL;
	}
	return(aptr);
}

void
lo_PushLineHeight(lo_DocState *state, int32 height)
{
	lo_LineHeightStack *aptr;

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

	aptr->height = height;

	aptr->next = state->line_height_stack;
	state->line_height_stack = aptr;
}

lo_LineHeightStack *
lo_PopLineHeight(lo_DocState *state)
{
	lo_LineHeightStack *aptr;

	aptr = state->line_height_stack;
	if (aptr != NULL)
	{
		state->line_height_stack = aptr->next;
		aptr->next = NULL;
	}
	return(aptr);
}

/*************************************
 * Function: lo_FreshText
 *
 * Description: This function clears out the information from the
 *	document state that refers to text in the midst of being
 *	laid out.  It is called to clear the layout state before
 *	Laying out new text potentially in a new font.
 *
 * Params: Document state structure.
 *
 * Returns: Nothing
 *************************************/
void
lo_FreshText(lo_DocState *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->break_pos = -1;
	state->break_width = 0;
	state->last_char_CR = FALSE;
#ifdef EDITOR
	if( !state->edit_force_offset )
	{
		state->edit_current_offset = 0;
	}
#endif
}


/*************************************
 * Function: lo_new_text_element
 *
 * Description: Create a new text element structure based
 *	on the current text information stored in the document
 *	state.
 *
 * Params: Document state
 *
 * Returns: A pointer to a LO_TextStruct structure.
 *	Returns a NULL on error (such as out of memory);
 *************************************/
static LO_TextStruct *
lo_new_text_element(MWContext *context,
                    lo_DocState *state,
                    ED_Element *edit_element,
                    intn edit_offset )
{
	LO_TextStruct *text_ele = NULL;
#ifdef DEBUG
	assert (state);
#endif

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

	text_ele = (LO_TextStruct *)lo_NewElement(context, state, LO_TEXT, 
			edit_element, edit_offset);
	if (text_ele == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		return(NULL);
	}

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

	if (state->line_buf_len > 0)
	{
		text_ele->text = PA_ALLOC((state->line_buf_len + 1) *
			sizeof(char));
		if (text_ele->text != NULL)
		{
			char *text_buf;
			char *line;

			PA_LOCK(line, char *, state->line_buf);
			PA_LOCK(text_buf, char *, text_ele->text);
			XP_BCOPY(line, text_buf, state->line_buf_len);
			text_buf[state->line_buf_len] = '\0';
			PA_UNLOCK(text_ele->text);
			PA_UNLOCK(state->line_buf);
			text_ele->text_len = (int16)state->line_buf_len;
		}
		else
		{
			state->top_state->out_of_memory = TRUE;
			/*
			 * free text element && return; it's no different
			 * than if we had run out of memory allocating
			 * the text element
			 */
			lo_FreeElement(context, (LO_Element *)text_ele, FALSE);
			return(NULL);
		}
	}
	else
	{
		text_ele->text = NULL;
		text_ele->text_len = 0;
	}

	text_ele->anchor_href = state->current_anchor;

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

	text_ele->ele_attrmask = 0;
	if (state->breakable != FALSE)
	{
		text_ele->ele_attrmask |= LO_ELE_BREAKABLE;
	}

	text_ele->sel_start = -1;
	text_ele->sel_end = -1;

	return(text_ele);
}


/*
 * A bogus an probably too expensive function to fill in the
 * textinfo for whatever font is now on the font stack.
 */
MODULE_PRIVATE void
lo_fillin_text_info(MWContext *context, lo_DocState *state)
{
	LO_TextStruct tmp_text;
	PA_Block buff;
	char *str;

	memset (&tmp_text, 0, sizeof (tmp_text));
	buff = PA_ALLOC(1);
	if (buff == NULL)
	{
		return;
	}
	PA_LOCK(str, char *, buff);
	str[0] = ' ';
	PA_UNLOCK(buff);
	tmp_text.text = buff;
	tmp_text.text_len = 1;
	
	/* if we have a text block, use it's font info, otherwise get it
       from the state */
	if ( state->cur_text_block == NULL )
		{
		tmp_text.text_attr = state->font_stack->text_attr;
		}
	else
		{
		tmp_text.text_attr = state->cur_text_block->text_attr;
		}
		
	FE_GetTextInfo(context, &tmp_text, &(state->text_info));
	PA_FREE(buff);
}


/*************************************
 * Function: lo_NewLinefeed
 *
 * Description: Create a new linefeed element structure based
 *	on the current information stored in the document
 *	state.
 *
 * Params: Document state, linefeed type
 *
 * Returns: A pointer to a LO_LinefeedStruct structure.
 *	Returns a NULL on error (such as out of memory);
 *************************************/
LO_LinefeedStruct *
lo_NewLinefeed(lo_DocState *state,
               MWContext * context,
               uint32 break_type,
               uint32 clear_type)
{	
	LO_LinefeedStruct *linefeed = NULL;

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

	linefeed = (LO_LinefeedStruct *)lo_NewElement(context, state, LO_LINEFEED, NULL, 0);
#ifdef DEBUG
	assert (state);
#endif
	if (linefeed == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		state->top_state->out_of_memory = TRUE;
		return(NULL);
	}

	lo_FillInLineFeed( context, state, break_type, clear_type, linefeed );

	return(linefeed);
}



/*************************************
 * Function: lo_InsertLineBreak
 *
 * Description: This function forces a linebreak at this time.
 *	Forcing the current text insetion point down one line
 *	and back to the left margin.
 *	It also maintains the linefeed state:
 *		0 - middle of a line.
 *		1 - at left margin below a line of text.
 *		2 - at left margin below a blank line.
 *
 * Params: Window context, Document state, break type and a boolean
 *	That describes whether this is a breaking linefeed or not.
 *	(Breaking linefeed is one inserted just to break a formatted
 *	 line to the current document width.)
 *
 * Returns: Nothing
 *************************************/
void
lo_InsertLineBreak(MWContext *context,
                   lo_DocState *state,
                   uint32 break_type,
                   uint32 clear_type,
                   Bool breaking)
{
	/* int32 line_width; */
	Bool scroll_at_bottom;

	scroll_at_bottom = FALSE;
	/*
	 * If this is an auto-scrolling doc, we will be scrolling
	 * later if we are at the bottom now.
	 */
	if ((state->is_a_subdoc == SUBDOC_NOT)&&
		(state->display_blocked == FALSE)&&
		(state->top_state->auto_scroll > 0))
	{
		int32 doc_x, doc_y;

		FE_GetDocPosition(context, FE_VIEW, &doc_x, &doc_y);
		if ((doc_y + state->win_height + state->win_bottom) >= state->y)
		{
			scroll_at_bottom = TRUE;
		}
	}

	/*
	 * This line is done, flush it into the line table and
	 * display it to the front end.
	 */
	lo_FlushLineList(context, state, break_type, clear_type, breaking);
	if (state->top_state->out_of_memory != FALSE)
	{
		return;
	}

	lo_UpdateStateAfterLineBreak( context, state, TRUE );

	lo_UpdateFEProgressBar(context, state);

	lo_UpdateFEDocSize( context, state );


	/*
	 * Tell the front end how big the document is right now.
	 * Only do this for the top level document.
	 */
	if ((state->display_blocked != FALSE)&&
#ifdef EDITOR
		(!state->edit_relayout_display_blocked)&&
#endif
	   (state->display_blocking_element_y > 0)&&
	   (state->y > (state->display_blocking_element_y + state->win_height)))
	{
		int32 y;

		state->display_blocked = FALSE;
		y = state->display_blocking_element_y;
		state->display_blocking_element_y = 0;
        if (!lo_InsideLayer(state))
		{
            LO_SetDocumentDimensions(context, state->max_width, state->y);
		}
		FE_SetDocPosition(context, FE_VIEW, 0, y);

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

	/*
	 * Reset the left and right margins
	 */
	/*
	lo_FindLineMargins(context, state, TRUE);
	state->x = state->left_margin;
	*/
	if ((state->is_a_subdoc == SUBDOC_NOT)&&
	    (state->top_state->auto_scroll > 0)&&
	    ((state->line_num - 1) > state->top_state->auto_scroll))
	{
		Bool redraw;
		int32 old_y, dy, new_y;
		int32 doc_x, doc_y;

		old_y = state->y;
		FE_GetDocPosition(context, FE_VIEW, &doc_x, &doc_y);
		lo_ClipLines(context, state, 1);
		/*
		 * Calculate how much of the top was clipped
		 * off, and if any of that area was in the users
		 * window we need to redraw their window.
		 */
		redraw = FALSE;
		dy = old_y - state->y;
		if (dy >= doc_y)
		{
			redraw = TRUE;
		}
		new_y = doc_y - dy;
		if (new_y < 0)
		{
			new_y = 0;
		}

		FE_SetDocPosition(context, FE_VIEW, doc_x, new_y);
        if (!lo_InsideLayer(state))
		{
            LO_SetDocumentDimensions(context, state->max_width, state->y);
		}

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

	if ((state->is_a_subdoc == SUBDOC_NOT)&&
		(state->display_blocked == FALSE)&&
		(state->top_state->auto_scroll > 0))
	{
		int32 doc_x, doc_y;

		FE_GetDocPosition(context, FE_VIEW, &doc_x, &doc_y);
		if (((doc_y + state->win_height) < state->y)&&
			(scroll_at_bottom != FALSE))
		{
			int32 y;

			y = state->y - state->win_height + state->win_bottom;
			if (y < 0)
			{
				y = 0;
			}
			else
			{
				FE_SetDocPosition(context, FE_VIEW, 0, y);
			}
		}
	}

	lo_insert_quote_characters(context, state);
}

/*************************************
 * Function: lo_HardLineBreak
 *
 * Description: This function forces a linebreak at this time.
 *	Forcing the current text insetion point down one line
 *	and back to the left margin.
 *
 * Params: Window context, Document state and a boolean
 *	That describes whether this is a breaking linefeed or not.
 *	(Breaking linefeed is one inserted just to break a formatted
 *	 line to the current document width.)
 *
 * Returns: Nothing
 *************************************/
void
lo_HardLineBreak(MWContext *context, lo_DocState *state, Bool breaking)
{
	lo_InsertLineBreak ( context, state, LO_LINEFEED_BREAK_HARD,
                         LO_CLEAR_NONE, breaking );
}

/*************************************
 * Function: lo_HardLineBreakWithBreak
 *
 * Returns: Nothing
 *************************************/
void
lo_HardLineBreakWithClearType(MWContext *context,
                              lo_DocState *state,
                              uint32 clear_type,
                              Bool breaking)
{
	lo_InsertLineBreak ( context, state, LO_LINEFEED_BREAK_HARD,
                         clear_type, breaking );
}

/*************************************
 * Function: lo_SoftLineBreak
 *
 * Description: This function adds a single soft line break.
 *
 * Params: Window context, Document state and a boolean that
 *	describes if this is a breaking linefeed.
 *
 * Returns: Nothing
 *************************************/
void
lo_SoftLineBreak(MWContext *context, lo_DocState *state, Bool breaking)
{
	lo_InsertLineBreak ( context, state, LO_LINEFEED_BREAK_SOFT,
                         LO_CLEAR_NONE, breaking);
}

/*************************************
 * Function: lo_SetSoftLineBreakState
 *
 * Description: Add soft linebreaks to bring the linefeed state to the
 *  specified level.
 *	Linefeed states:
 *		0 - middle of a line.
 *		1 - at left margin below a line of text.
 *		2 - at left margin below a blank line.
 *
 * Params: Window context, Document state, a boolean that
 *	describes if this is a breaking linefeed, and the desired
 *	linefeed state.
 *
 * Returns: Nothing
 *************************************/
void
lo_SetSoftLineBreakState(MWContext *context,
                         lo_DocState *state,
                         Bool breaking,
                         intn linefeed_state)
{
	lo_SetLineBreakState ( context, state, breaking, LO_LINEFEED_BREAK_SOFT,
                           linefeed_state, FALSE);
}

/*************************************
 * Function: lo_SetLineBreakState
 *
 * Description: Add linebreaks to bring the linefeed state to the
 *  specified level.
 * Linefeed states:
 *		0 - middle of a line.
 *		1 - at left margin below a line of text.
 *		2 - at left margin below a blank line.
 *
 * Params: Window context, Document state, a boolean that
 *	describes if this is a breaking linefeed, and the desired
 *	linefeed state.
 *
 * Returns: Nothing
 *************************************/
void
lo_SetLineBreakState(MWContext *context,
                     lo_DocState *state,
                     Bool breaking,
                     uint32 break_type,
                     intn linefeed_state,
                     Bool relayout)
{
	/*
	 * Linefeeds are partially disabled if we are placing
	 * preformatted text.
	 */
	if (state->preformatted != PRE_TEXT_NO)
	{
		if ((breaking == FALSE)&&(state->linefeed_state < 1)&&
			(state->top_state->out_of_memory == FALSE))
		{
			if (relayout == FALSE) 
			{
				lo_InsertLineBreak(context, state, break_type,
                                   LO_CLEAR_NONE, breaking);				
			}
			else 
			{
				lo_rl_AddBreakAndFlushLine( context, state,
                                            break_type, LO_CLEAR_NONE,
                                            breaking);
			}
		}
		return;
	}

	/* check for the style sheet display: inline property.
 	 * ignore newlines if it is set
	 */
	if(state->top_state && state->top_state->style_stack)
	{
		StyleStruct *style = STYLESTACK_GetStyleByIndex(
												state->top_state->style_stack,
                                                0);
		if(style)
		{
			char * property = STYLESTRUCT_GetString(style, DISPLAY_STYLE);
			if(property && !strcasecomp(property, INLINE_STYLE))
			{
				XP_FREE(property);
				return;
			}
			XP_FREEIF(property);
		}
	}

	if (linefeed_state > 2)
	{
		linefeed_state = 2;
	}

	while ((state->linefeed_state < linefeed_state)&&
		(state->top_state->out_of_memory == FALSE))
	{
		if (relayout == FALSE) 
		{
			lo_InsertLineBreak(context, state, break_type,
                               LO_CLEAR_NONE, breaking);
		}
		else 
		{
			lo_rl_AddBreakAndFlushLine( context, state, break_type,
                                        LO_CLEAR_NONE, breaking );
		}
	}
}

/*************************************
 * Function: lo_InsertWordBreak
 *
 * Description: This insert a word break into the laid out
 *	element chain for the current line.  A word break is
 *	basically an empty text element structure.  All
 *	word break elements should probably be removed
 *	from the layout chain once the line list for this
 *	line is flushed.
 *
 * Params: Window context and document state.
 *
 * Returns: Nothing
 *************************************/
void
lo_InsertWordBreak(MWContext *context, lo_DocState *state)
{
	LO_TextStruct *text_ele = NULL;

	if (state == NULL)
	{
		return;
	}

	text_ele = (LO_TextStruct *)lo_NewElement(context, state,
                                              LO_TEXT, NULL, 0);
	if (text_ele == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		return;
	}

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

	text_ele->block_offset = 0;
	text_ele->doc_width = 0;
	
#if 0
	text_ele->text = PA_ALLOC(sizeof(char));
	if (text_ele->text != NULL)
	{
		PA_LOCK(text_buf, char *, text_ele->text);
		text_buf[0] = '\0';
		PA_UNLOCK(text_ele->text);
	}
	else
	{
		state->top_state->out_of_memory = TRUE;
	}
#else
	text_ele->text = NULL;
#endif
	text_ele->text_len = 0;
	text_ele->anchor_href = state->current_anchor;

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

	text_ele->ele_attrmask = 0;
	if (state->breakable != FALSE)
	{
		text_ele->ele_attrmask |= LO_ELE_BREAKABLE;
	}

	text_ele->sel_start = -1;
	text_ele->sel_end = -1;
	text_ele->bullet_type = WORDBREAK;

	lo_AppendToLineList(context, state, (LO_Element *)text_ele, 0);

	state->old_break = text_ele;
	state->old_break_block = state->cur_text_block;
	state->old_break_pos = 0;
	state->old_break_width = 0;
}


int32
lo_baseline_adjust(MWContext *context,
                   lo_DocState * state,
                   LO_Element *ele_list,
                   int32 old_baseline,
                   int32 old_line_height)
{
	LO_Element *eptr;
	int32 baseline;
	int32 new_height;
	int32 baseline_adjust;
	LO_TextInfo text_info;

	baseline = 0;
	new_height = 0;
	eptr = ele_list;
	while (eptr != NULL)
	{
		switch (eptr->type)
		{
			case LO_TEXT:
				FE_GetTextInfo(context, (LO_TextStruct *)eptr,
					&text_info);
				if (text_info.ascent > baseline)
				{
					baseline = text_info.ascent;
				}
				if ((text_info.ascent + text_info.descent) >
					new_height)
				{
					new_height = text_info.ascent +
						text_info.descent;
				}
				break;
			case LO_FORM_ELE:
				if (eptr->lo_form.baseline > baseline)
				{
					baseline = eptr->lo_form.baseline;
				}
				if (eptr->lo_any.height > new_height)
				{
					new_height = eptr->lo_any.height;
				}
				break;
			case LO_IMAGE:
				if ((old_baseline - eptr->lo_any.y_offset) >
					baseline)
				{
					baseline = old_baseline -
						eptr->lo_any.y_offset;
				}
				if ((eptr->lo_image.height +
					(2 * eptr->lo_image.border_width) +
					(2 * eptr->lo_image.border_vert_space))
					> new_height)
				{
					new_height = eptr->lo_image.height +
					 (2 * eptr->lo_image.border_width) +
					 (2 * eptr->lo_image.border_vert_space);
				}
				break;
			case LO_HRULE:
			case LO_BULLET:
				if ((old_baseline - eptr->lo_any.y_offset) >
					baseline)
				{
					baseline = old_baseline -
						eptr->lo_any.y_offset;
				}
				if (eptr->lo_any.height > new_height)
				{
					new_height = eptr->lo_any.height;
				}
				break;
			default:
				break;
		}
		eptr = eptr->lo_any.next;
	}
	baseline_adjust = old_baseline - baseline;
	return(baseline_adjust);
}


/*************************************
 * Function: lo_BreakOldElement
 *
 * Description: This function goes back to a previous
 *	element in the element chain, that is still on the
 *	same line, and breaks the line there, putting the
 *	remaining elements (if any) on the next line.
 *
 * Params: Window context and document state.
 *
 * Returns: Nothing
 *************************************/
void
lo_BreakOldElement(MWContext *context, lo_DocState *state)
{
	char *text_buf;
	char *break_ptr;
	char *word_ptr;
	char *new_buf;
	PA_Block new_block;
	intn word_len;
	int32 save_width;
	int32 old_baseline;
	int32 old_line_height;
	int32 adjust;
	LO_TextStruct *text_data;
	LO_TextStruct *new_text_data;
	LO_Element *tptr;
	int16 charset;
	int multi_byte;
	LO_TextBlock * block;
#ifdef LOCAL_DEBUG
XP_TRACE(("lo_BreakOldElement, flush text.\n"));
#endif /* LOCAL_DEBUG */

	if (state == NULL)
	{
		return;
	}

	/* BRAIN DAMAGE: Make sure the correct element is at the end of
       the list for this block */
	block = state->old_break_block;
	
	if ( block == NULL )
	{
		return;
	}
	
	/* 
     * If this text block is using the new breaktable algorithm,
     * call that code 
     */
	if ( lo_UseBreakTable ( block ) )
		{
		lo_BreakOldTextBlockElement ( context, state );
		return;
		}
		
	charset = block->text_attr->charset;
	multi_byte = (INTL_CharSetType(charset) != SINGLEBYTE);

	/*
	 * Move to the element we will break
	 */
	text_data = state->old_break;

	/*
	 * If there is no text there to break
	 * it is an error.
	 */
	if ( text_data == NULL )
	{
		return;
	}

	/*
	 * Later operations will trash the width field.
	 * So save it now to restore later.
	 */
	save_width = state->width;

	/*
	 * If this buffer is just an empty string, then we are
	 * breaking at a previously inserted word break element.
	 * Knowing that, the breaking is easier, so it is special 
	 * cased here.
	 */
	if (text_data->text == NULL)
	{
		LO_Element *line_ptr;

		/*
		 * Back the state up to this element's
		 * location, break off the rest of the elements
		 * and save them for later.
		 * Flush this line, and insert a linebreak.
		 */
		state->x = text_data->x;
		state->y = text_data->y;
		tptr = text_data->next;
		text_data->next = NULL;
		PA_UNLOCK(text_data->text);
		state->width = text_data->width;
		state->x += state->width;
		lo_SoftLineBreak(context, state, TRUE);

		/*
		 * The remaining elements go on the next line.
		 * The nextline may already have special mail
		 * bullets on it.
		 */
		line_ptr = state->line_list;
		while ((line_ptr != NULL)&&(line_ptr->lo_any.next != NULL))
		{
			line_ptr = line_ptr->lo_any.next;
		}
		if (line_ptr == NULL)
		{
			state->line_list = tptr;
			if (tptr != NULL)
			{
				tptr->lo_any.prev = NULL;
			}
		}
		else
		{
			line_ptr->lo_any.next = tptr;
			if (tptr != NULL)
			{
				tptr->lo_any.prev = line_ptr;
			}
		}

		/*
		 * If there are no elements to place on the next
		 * line, and we have new text buffered,
		 * remove any spaces at the start of that new
		 * text since new lines are not allowed to begin
		 * with whitespace.
		 */
		if ((tptr == NULL)&&(state->line_buf_len != 0))
		{
			char *cptr;
			int32 wlen;

			PA_LOCK(text_buf, char *, state->line_buf);
			cptr = text_buf;
			wlen = 0;
			while ((XP_IS_SPACE(*cptr))&&(*cptr != '\0'))
			{
				cptr++;
				wlen++;
			}
			if (wlen)
			{
				LO_TextStruct tmp_text;

				memset (&tmp_text, 0, sizeof (tmp_text));

				/*
				 * We removed space, move the string up
				 * and recalculate its current width.
				 */
				XP_BCOPY(cptr, text_buf,
					(state->line_buf_len - wlen + 1));
				state->line_buf_len -= (intn) wlen;
				PA_UNLOCK(state->line_buf);
				tmp_text.text = state->line_buf;
				tmp_text.text_len = (int16)state->line_buf_len;
				tmp_text.text_attr =
					block->text_attr;
				FE_GetTextInfo(context, &tmp_text,
					&(state->text_info));

				/*
				 * Override the saved width since we did want
				 * to change the real width in this case.
				 */
				save_width = lo_correct_text_element_width(
					&(state->text_info));
			}
			else
			{
				PA_UNLOCK(state->line_buf);
			}
		}
	}
	/*
	 * We are breaking somewhere in the middle of an old
	 * text element, this will mean splitting it into 2 text
	 * elements, and putting a line break between them.
	 */
	else
	{
		LO_TextInfo text_info;
		int32 base_change;

		PA_LOCK(text_buf, char *, text_data->text);
		
		/*
		 * Locate our break location, and a pointer to
		 * the remaining word (with its preceeding space removed).
		 */
		break_ptr = (char *)(text_buf + state->old_break_pos);
		/*
		 * On multibyte, we often break on character which is 
		 * not space.
		 */ 
		if (multi_byte == FALSE || XP_IS_SPACE(*break_ptr))
		{
			*break_ptr = '\0';
			word_ptr = (char *)(break_ptr + 1);
		}
		else
		{
			word_ptr = (char *)break_ptr;
		}

		/*
		 * Copy the remaining word into its own block.
		 */
		word_len = XP_STRLEN(word_ptr);
		new_block = PA_ALLOC((word_len + 1));
		if (new_block == NULL)
		{
			state->top_state->out_of_memory = TRUE;
			return;
		}
		PA_LOCK(new_buf, char *, new_block);
		XP_BCOPY(word_ptr, new_buf, (word_len + 1));
		new_buf[word_len] = '\0';

		/*
		 * Back the state up to this element's
		 * location, break off the rest of the elements
		 * and save them for later.
		 * Flush this line, and insert a linebreak.
		 */
		state->x = text_data->x;
		state->y = text_data->y;
		tptr = text_data->next;
		text_data->next = NULL;
		if (word_ptr != break_ptr)
			text_data->text_len = text_data->text_len - word_len - 1;
		else
			text_data->text_len = text_data->text_len - word_len;
		FE_GetTextInfo(context, text_data, &text_info);
		state->width = lo_correct_text_element_width(&text_info);
		PA_UNLOCK(text_data->text);
		state->x += state->width;

		/*
		 * Make the split element know its new width.
		 */
		text_data->width = state->width;

		/*
		 * If the element that caused this break has a different
		 * baseline than the element we are breaking, we need to
		 * preserve that difference after the break.
		 */
		base_change = state->baseline -
			(text_data->y_offset + text_info.ascent);

		old_baseline = state->baseline;
		old_line_height = state->line_height;

		/*
		 * Reset element_id so they are still sequencial.
		 */
		state->top_state->element_id = text_data->ele_id + 1;

		/*
		 * If we are breaking an anchor, we need to make sure the
		 * linefeed gets its anchor href set properly.
		 */
		if (text_data->anchor_href != NULL)
		{
			LO_AnchorData *tmp_anchor;

			tmp_anchor = state->current_anchor;
			state->current_anchor = text_data->anchor_href;
			lo_SoftLineBreak(context, state, TRUE);
			state->current_anchor = tmp_anchor;
		}
		else
		{
			lo_SoftLineBreak(context, state, TRUE);
		}

		adjust = lo_baseline_adjust(context, state, tptr,
			old_baseline, old_line_height);
		state->baseline = old_baseline - adjust;
		state->line_height = (intn) old_line_height - adjust;

		/*
		 * If there was really no remaining word, free the
		 * unneeded buffer.
		 */
		if (word_len == 0)
		{
			LO_Element *eptr;
			LO_Element *line_ptr;

			PA_UNLOCK(new_block);
			PA_FREE(new_block);

			line_ptr = state->line_list;
			while ((line_ptr != NULL)&&
				(line_ptr->lo_any.next != NULL))
			{
				line_ptr = line_ptr->lo_any.next;
			}
			if (line_ptr == NULL)
			{
				state->line_list = tptr;
				if (tptr != NULL)
				{
					tptr->lo_any.prev = NULL;
				}
			}
			else
			{
				line_ptr->lo_any.next = tptr;
				if (tptr != NULL)
				{
					tptr->lo_any.prev = line_ptr;
				}
			}

			state->width = 0;

			eptr = tptr;
			while (eptr != NULL)
			{
				eptr->lo_any.ele_id = NEXT_ELEMENT;
				eptr->lo_any.y_offset -= adjust;
				eptr = eptr->lo_any.next;
			}
		}
		/*
		 * Else create a new text element for the remaining word.
		 * and stick it in the begining of the next line of
		 * text elements.
		 */
		else
		{
			LO_Element *line_ptr;
			LO_Element *eptr;
			int32 baseline_inc;
			LO_TextInfo text_info;
			baseline_inc = -1 * adjust;
			new_text_data = lo_new_text_element(context, state, 
					text_data->edit_element,
                    text_data->edit_offset+text_data->text_len+1 );
			if (new_text_data == NULL)
			{
				return;
			}
			if (new_text_data->text != NULL)
			{
				PA_FREE(new_text_data->text);
				new_text_data->text = NULL;
				new_text_data->text_len = 0;
			}
			new_text_data->anchor_href = text_data->anchor_href;
			new_text_data->text_attr = text_data->text_attr;
			new_text_data->x = state->x;
			new_text_data->y = state->y;
				
#ifdef LOCAL_DEBUG
XP_TRACE(("lo_BreakOldElement, left over word (%s)\n", new_buf));
#endif /* LOCAL_DEBUG */

			PA_UNLOCK(new_block);
			new_text_data->text = new_block;
			new_text_data->text_len = word_len;
			FE_GetTextInfo(context, new_text_data, &text_info);
			new_text_data->width =
				lo_correct_text_element_width(&text_info);

			/*
			 * Some fonts (particulatly italic ones with curly
			 * tails on letters like 'f') have a left bearing
			 * that extends back into the previous character.
			 * Since in this case the previous character is
			 * probably not in the same font, we move forward
			 * to avoid overlap.
			 */
			if (text_info.lbearing < 0)
			{
				new_text_data->x_offset =
					text_info.lbearing * -1;
			}

			/*
			 * The baseline of the text element just inserted in
			 * the line may be less than or greater than the
			 * baseline of the rest of the line due to font
			 * changes.  If the baseline is less, this is easy,
			 * we just increase y_offest to move the text down
			 * so the baselines line up.  For greater baselines,
			 * we can't move the text up to line up the baselines
			 * because we will overlay the previous line, so we
			 * have to move all rest of the elements in this line
			 * down.
			 *
			 * If the baseline is zero, we are the first element
			 * on the line, and we get to set the baseline.
			 */
			if (state->baseline == 0)
			{
				state->baseline = text_info.ascent;
			}
			else if (text_info.ascent < state->baseline)
			{
				new_text_data->y_offset = state->baseline -
						text_info.ascent;
			}
			else
			{
				baseline_inc = baseline_inc +
					(text_info.ascent - state->baseline);
				state->baseline =
					text_info.ascent;
			}

			/*
			 * Now that we have broken, and added the new
			 * element, we need to move it down to restore the
			 * baseline difference that previously existed.
			 */
			new_text_data->y_offset -= base_change;

			/*
			 * Calculate the height of this new
			 * text element.
			 */
			new_text_data->height = text_info.ascent +
				text_info.descent;
			state->x += new_text_data->width;

			/*
			 * Stick this new text element at the beginning
			 * of the remaining line elements
			 * There may be some special mail bullets already
			 * on the line that we have to insert after.
			 */
			line_ptr = state->line_list;
			while ((line_ptr != NULL)&&
				(line_ptr->lo_any.next != NULL))
			{
				line_ptr = line_ptr->lo_any.next;
			}
			if (line_ptr == NULL)
			{
				state->line_list = (LO_Element *)new_text_data;
				new_text_data->prev = NULL;
			}
			else
			{
				line_ptr->lo_any.next =
					(LO_Element *)new_text_data;
				new_text_data->prev = line_ptr;
			}
			new_text_data->next = tptr;
			if (tptr != NULL)
			{
				tptr->lo_any.prev = (LO_Element *)new_text_data;
			}

			eptr = tptr;

			while (eptr != NULL)
			{
				eptr->lo_any.ele_id = NEXT_ELEMENT;
				eptr->lo_any.y_offset += baseline_inc;
				eptr = eptr->lo_any.next;
			}

			if ((new_text_data->y_offset + new_text_data->height) > 
				state->line_height)
			{
				state->line_height = (intn) new_text_data->y_offset +
					new_text_data->height;
			}

			state->at_begin_line = FALSE;
		}
	}

	/*
	 * If we are at the beginning of a line, and there is
	 * remaining text to place here, remove leading space
	 * which is not allowed at the start of lines.
	 * ERIC, make a test case for this, I suspect right now
	 * this code is never being executed and may contain an error.
	 */
	if ((state->at_begin_line != FALSE)&&(tptr != NULL)&&
		(tptr->type == LO_TEXT))
	{
		char *cptr;
		int32 wlen;
		LO_TextStruct *tmp_text;
		LO_TextInfo text_info;

		tmp_text = (LO_TextStruct *)tptr;

		PA_LOCK(text_buf, char *, tmp_text->text);
		cptr = text_buf;
		wlen = 0;
		while ((XP_IS_SPACE(*cptr))&&(*cptr != '\0'))
		{
			cptr++;
			wlen++;
		}
		if (wlen)
		{
			XP_BCOPY(cptr, text_buf,
				(tmp_text->text_len - wlen + 1));
			tmp_text->text_len -= (intn) wlen;

			PA_UNLOCK(tmp_text->text);
			FE_GetTextInfo(context, tmp_text, &text_info);
			tmp_text->width = lo_correct_text_element_width(
				&text_info);
		}
		else
		{
			PA_UNLOCK(tmp_text->text);
		}
	}

	/*
	 * Upgrade forward the x and y text positions in the document
	 * state.
	 */
	while (tptr != NULL)
	{
		lo_UpdateElementPosition ( state, tptr );
		tptr = tptr->lo_any.next;
	}

	state->at_begin_line = FALSE;
	state->width = save_width;
}


void lo_UpdateElementPosition ( lo_DocState * state, LO_Element * element )
{
	element->lo_any.x = state->x;
	element->lo_any.y = state->y;
	state->x = state->x + element->lo_any.width;
	
	/* move any element specific items */
	switch ( element->lo_any.type )
		{
		case LO_IMAGE:
			CL_MoveLayer(element->lo_image.layer,
                         element->lo_any.x, element->lo_any.y);
			break;
			
		case LO_EMBED:
			CL_MoveLayer(element->lo_embed.layer,
                         element->lo_any.x, element->lo_any.y);
			break;
		}
}


/*************************************
 * Function: lo_correct_text_element_width
 *
 * Description: Calculate the correct width of this text element
 *	if it is a complete element surrounded by elements of potentially
 *	different fonts, so we have to take care not to truncate
 *	any slanted characters at either end of the element.
 *
 * Params: LO_TextInfo structure for this text element's text string.
 *
 * Returns: The width this element would have if it stood alone.
 *************************************/
int32
lo_correct_text_element_width(LO_TextInfo *text_info)
{
	int32 x_offset;
	int32 width;

	width = text_info->max_width;
	x_offset = 0;

	/*
	 * For text that leans into the previous character.
	 */
	if (text_info->lbearing < 0)
	{
		x_offset = text_info->lbearing * -1;
		width += x_offset;
	}

	/*
	 * For text that leans right into the following characters.
	 */
	if (text_info->rbearing > text_info->max_width)
	{
		width += (text_info->rbearing - text_info->max_width);
	}

	return(width);
}


PRIVATE
int32
lo_characters_in_line(lo_DocState *state)
{
	int32 cnt;
	LO_Element *eptr;

	cnt = 0;
	eptr = state->line_list;
	while (eptr != NULL)
	{
		if (eptr->type == LO_TEXT)
		{
			cnt += eptr->lo_text.text_len;
		}
		eptr = eptr->lo_any.next;
	}
	return(cnt);
}

void
lo_PreformatedText(MWContext *context, lo_DocState *state, char *text)
{
	LO_TextBlock *	block;
	
	block = lo_NewTextBlock ( context, state, text, state->preformatted );
	if ( !state->top_state->out_of_memory && ( block != NULL ) )
		{
		block->buffer_read_index = 0;
		lo_LayoutPreformattedText ( context, state, block );
		}
}


void
lo_LayoutPreformattedText(MWContext *context,
                          lo_DocState *state,
                          LO_TextBlock * block)
{
	char *tptr;
	char *w_start;
	char *w_end;
	char *text_buf;
	char tchar1;
	Bool have_CR;
	Bool line_break;
	Bool white_space;
	LO_TextStruct text_data;
	char *tmp_buf;
	PA_Block tmp_block;
	int32 tab_count, ignore_cnt, line_length;
	int16 charset;
	int multi_byte;
	int kinsoku_class, last_kinsoku_class;
	int i;
	int bytestocopy;
	char * text;
	Bool lineBufMeasured;
	
	/* start at the current text position in this text block */
	text = (char *) &block->text_buffer[ block->buffer_read_index ];
	
	kinsoku_class = PROHIBIT_NOWHERE;
	
	lineBufMeasured = FALSE;
	
	/*
	 * Initialize the structures to 0 (mark)
	 */
	memset (&text_data, 0, sizeof (LO_TextStruct));

	/*
	 * Error conditions
	 */
	if ((state == NULL)||(state->cur_ele_type != LO_TEXT)||(text == NULL))
	{
		return;
	}

	charset = block->text_attr->charset;
	multi_byte = (INTL_CharSetType(charset) != SINGLEBYTE);

	/*
	 * Move through this text fragment, expand tabs, honor LF/CR.
	 */
	have_CR = state->last_char_CR;
	tptr = text;
	while ((*tptr != '\0')&&(state->top_state->out_of_memory == FALSE))
	{
		Bool has_nbsp;
		Bool in_word;
		Bool wrap_break;
		Bool pre_wrap_break;

		/*
		 * white_space is a tag to tell us if the current word
		 * ends in whitespace.
		 */
		white_space = FALSE;
		line_break = FALSE;
		has_nbsp = FALSE;
		if (multi_byte)
			has_nbsp = TRUE;

		/*
		 * Find the end of the line, counting tabs.
		 */
		tab_count = 0;
		ignore_cnt = 0;
		line_length = 0;
		w_start = tptr;

		/*
		 * If the last character processed was a CR, and the next
		 * char is a LF, ignore it.  Otherwise we know we
		 * can break the line on the first CR or LF found.
		 */
		if ((have_CR != FALSE)&&(*tptr == LF))
		{
			ignore_cnt++;
			tptr++;
		}
		have_CR = FALSE;

		in_word = FALSE;
		wrap_break = FALSE;
		pre_wrap_break = FALSE;
		
#ifdef XP_WIN16
		while ((*tptr != CR)&&(*tptr != LF)&&(*tptr != '\0')&&
		    ((line_length + (tab_count * state->tab_stop)) < TEXT_CHUNK_LIMIT)&&
		    (((state->line_buf_len + line_length + (tab_count * state->tab_stop))) < SIZE_LIMIT))
#else
		while ((*tptr != CR)&&(*tptr != LF)&&(*tptr != '\0')
		    &&((line_length + (tab_count * state->tab_stop)) < TEXT_CHUNK_LIMIT)
			)
#endif /* XP_WIN16 */
		{
			/*
			 * In the special wrapping preformatted text
			 * we need to chunk by word instead of by
			 * line.
			 */
			if ((state->preformatted == PRE_TEXT_WRAP)||
			    (state->preformatted == PRE_TEXT_COLS))
			{
				if(multi_byte && (! (INTL_CharSetType(charset) & CS_SPACE)))
				{
					last_kinsoku_class = kinsoku_class;
					kinsoku_class = INTL_KinsokuClass(charset, (unsigned char *)tptr);
					/* We need to conser PROHIBIT_WORD_BREAK for UTF8 case */
					if(( PROHIBIT_WORD_BREAK == kinsoku_class) || (0x00 == (*tptr & 0x80)))
					{
						if ((in_word == FALSE)&&(!XP_IS_SPACE(*tptr)) )
						{
							in_word = TRUE;
						}
						else if ((in_word != FALSE)&&
							(XP_IS_SPACE(*tptr)))
						{
							wrap_break = TRUE;
							break;
						}
					}
					else
					{
						if( (line_length != 0) &&
							(PROHIBIT_END_OF_LINE != last_kinsoku_class) &&
							(PROHIBIT_BEGIN_OF_LINE != kinsoku_class)
						  )
						{
							wrap_break = TRUE;
							break;
						}
					}
				}
				else
				{
					if ((in_word == FALSE)&&(!XP_IS_SPACE(*tptr)))
					{
						in_word = TRUE;
					}
					else if ((in_word != FALSE)&&
						(XP_IS_SPACE(*tptr)))
					{
						wrap_break = TRUE;
						break;
					}
				}
			}

			if ((*tptr == FF)||(*tptr == VTAB))
			{
				/*
				 * Ignore the form feeds
				 * thrown in by some platforms.
				 * Ignore vertical tabs since we don't know
				 * what else to do with them.
				 */
				ignore_cnt++;
			}
			else if (*tptr == TAB)
			{
				tab_count++;
			}
			else if (!multi_byte && (unsigned char)*tptr == NON_BREAKING_SPACE)
			{
				/* *tptr = ' '; Replace this later */
				has_nbsp = TRUE;
				line_length++;
			}
			else
			{
				if(multi_byte)
					line_length += INTL_CharLen(charset, (unsigned char*)tptr);
				else
					line_length++;
			}

			if(multi_byte)
				tptr = INTL_NextChar(charset, tptr);
			else
				tptr++;
		}
		line_length = line_length + (state->tab_stop * tab_count);

		if ((state->line_buf_len + line_length) > TEXT_CHUNK_LIMIT)
		{
			lo_FlushLineBuffer(context, state);
			if (state->cur_ele_type != LO_TEXT)
			{
				lo_FreshText(state);
				state->cur_ele_type = LO_TEXT;
			}
		}

#ifdef XP_WIN16
		if ((state->line_buf_len + line_length) >= SIZE_LIMIT)
		{
			line_break = TRUE;
		}
#endif /* XP_WIN16 */

		/*
		 * Terminate the word, saving the char we replaced
		 * with the terminator so it can be restored later.
		 */
		w_end = tptr;
		tchar1 = *w_end;
		*w_end = '\0';

		tmp_block = PA_ALLOC(line_length + 1);
		if (tmp_block == NULL)
		{
			*w_end = tchar1;
			state->top_state->out_of_memory = TRUE;
			break;
		}
		PA_LOCK(tmp_buf, char *, tmp_block);

		if ((tab_count)||(ignore_cnt))
		{
			char *cptr;
			char *text_ptr;
			int32 cnt;

			text_ptr = tmp_buf;
			cptr = w_start;
			cnt = lo_characters_in_line(state);
			cnt += state->line_buf_len;
			while (*cptr != '\0')
			{
				if ((*cptr == LF)||(*cptr == FF)||
					(*cptr == VTAB))
				{
					/*
					 * Ignore any linefeeds that must have
					 * been after CR, and form feeds.
					 * Ignore vertical tabs since we
					 * don't know what else to do with them.
					 */
					cptr++;
				}
				else if (*cptr == TAB)
				{
					int32 i, tab_pos;

					tab_pos = ((cnt / state->tab_stop) +
						1) * state->tab_stop;
					for (i=0; i<(tab_pos - cnt); i++)
					{
						*text_ptr++ = ' ';
					}
					cnt = tab_pos;
					cptr++;
				}
				else
				{
					/*
					 * Bug #77467
					 * If multibyte, character != char by default, so copy 
					 * the CHARACTER, not the char
					 */
					if(multi_byte) 
					{
						bytestocopy = INTL_CharLen(charset, (unsigned char*)cptr);
						for (i=0; i<bytestocopy; i++)
						{
							*text_ptr++ = *cptr++;
							cnt++;
						}
					}
					else
					{
						*text_ptr++ = *cptr++;
						cnt++;
					}
				}
			}
			*text_ptr = *cptr;
		}
		else
		{
			XP_BCOPY(w_start, tmp_buf, line_length + 1);
		}

		/*
		 * Now we catch those nasty non-breaking space special
		 * characters and make them spaces.
		 */
		if (has_nbsp != FALSE)
		{
			char *tmp_ptr;

			tmp_ptr = tmp_buf;
			while (*tmp_ptr != '\0')
			{
				if (((unsigned char)*tmp_ptr == NON_BREAKING_SPACE)
					&& (CS_USER_DEFINED_ENCODING != charset))
				{
					*tmp_ptr = ' ';
				}
				if(multi_byte)
					tmp_ptr = INTL_NextChar(charset, tmp_ptr);
				else
					tmp_ptr++;
			}
		}

		/* don't need this any more since we're converting
		 * elsewhere -- erik
		tmp_buf = FE_TranslateISOText(context, charset, tmp_buf);
		 */
		line_length = XP_STRLEN(tmp_buf);

		if ((line_length > 0)&&(XP_IS_SPACE(tmp_buf[line_length - 1])))
		{
			state->trailing_space = TRUE;
		}
#ifdef LOCAL_DEBUG
XP_TRACE(("Found Preformatted text (%s)\n", tmp_buf));
#endif /* LOCAL_DEBUG */
		PA_UNLOCK(tmp_block);

#if WHAT
		/*
		 * If this is an empty string, just throw it out
		 * and move on
		 */
		if (*w_start == '\0')
		{
			*w_end = tchar1;
#ifdef LOCAL_DEBUG
XP_TRACE(("Throwing out empty string!\n"));
#endif /* LOCAL_DEBUG */
			continue;
		}
#endif

		/*
		 * If we have extra text, Append it to the line buffer.
		 * It may be necessary to expand the line
		 * buffer.
		 */
		if (*w_start != '\0')
		{
			int32 old_len;
			Bool old_begin_line;

			old_len = state->line_buf_len;
			old_begin_line = state->at_begin_line;

			if ((state->line_buf_len + line_length + 1) >
				state->line_buf_size)
			{
				state->line_buf = PA_REALLOC(
					state->line_buf, (state->line_buf_size +
					line_length + LINE_BUF_INC));
				if (state->line_buf == NULL)
				{
					*w_end = tchar1;
					state->top_state->out_of_memory = TRUE;
					break;
				}
				state->line_buf_size += (line_length +
					LINE_BUF_INC);
			}
			PA_LOCK(text_buf, char *, state->line_buf);
			PA_LOCK(tmp_buf, char *, tmp_block);

			XP_BCOPY(tmp_buf,
			    (char *)(text_buf + state->line_buf_len),
			    (line_length + 1));
			state->line_buf_len += (intn) line_length;
			PA_UNLOCK(state->line_buf);
			PA_UNLOCK(tmp_block);

			/* we have not measured this new text yet */
			lineBufMeasured = FALSE;
			
			/*
			 * Having added text, we cannot be at the start
			 * of a line
			 */
			state->cur_ele_type = LO_TEXT;
			state->at_begin_line = FALSE;

#ifdef OLD_WAY
			/*
			 * Most common case is appending to the same line.
			 * assume that is what we are doing here.
			 */
			text_data.text = state->line_buf;
			text_data.text_len = (int16)state->line_buf_len;
			text_data.text_attr = block->text_attr;
			FE_GetTextInfo(context, &text_data,
				&(state->text_info));
			state->width =
				lo_correct_text_element_width(
				&(state->text_info));

			/*
			 * If this is a special wrapping pre, and we would
			 * wrap here, break before this, and strip all
			 * following whitespace so there is none at
			 * the start of the next line.
			 * If we were at the beginning of the line before
			 * this, then obviously trying to wrap here will
			 * be pointless, and will in fact cause an
			 * infinite loop.
			 *
			 * Also wrap here is we are in fixed column wrapping
			 * pre text, and we would pass our set column.
			 */
			if (((state->preformatted == PRE_TEXT_WRAP)&&
			    (old_begin_line == FALSE)&&
			    ((state->x + state->width) > state->right_margin))||
			   ((state->preformatted == PRE_TEXT_COLS)&&
			    (old_begin_line == FALSE)&&
			    (state->preformat_cols > 0)&&
			    (state->line_buf_len > state->preformat_cols)))
			{
				PA_LOCK(text_buf, char *, state->line_buf);
				text_buf[old_len] = '\0';
				PA_UNLOCK(state->line_buf);
				state->line_buf_len = old_len;

				*w_end = tchar1;
				tptr = w_start;
				while ((XP_IS_SPACE(*tptr))&&(*tptr != '\0'))
				{
					tptr++;
				}
				line_break = TRUE;
				w_start = tptr;
				w_end = tptr;
				tchar1 = *w_end;
			}
#else

			text_data.text = state->line_buf;
			text_data.text_len = (int16)state->line_buf_len;
			text_data.text_attr = block->text_attr;
			FE_GetTextInfo ( context, &text_data, &(state->text_info) );

			/* update the block's font info cache */
			block->ascent = state->text_info.ascent;
			block->descent = state->text_info.descent;

			/*
			 * If this is a special wrapping pre, then we need to measure this line of text to see
			 * if we need to wrap.
			 */
			if ( ( state->preformatted == PRE_TEXT_WRAP ) && ( old_begin_line == FALSE ) )
			{
				state->width = lo_correct_text_element_width ( &(state->text_info) );
				
				lineBufMeasured = TRUE;
				
				/*
				 * If this line is now too long, wrap
				 */
				if ( ( state->x + state->width ) > state->right_margin )
				{
					pre_wrap_break = TRUE;
				}
			}
			
			/*
			 * Now check to see if we need to wrap based on being too long for the special pre modes
			 */
			if ( ( pre_wrap_break != FALSE ) ||
				(	( state->preformatted == PRE_TEXT_COLS ) &&
					( old_begin_line == FALSE ) &&
					( state->preformat_cols > 0 ) &&
					( state->line_buf_len > state->preformat_cols ) ))
			{
				PA_LOCK(text_buf, char *, state->line_buf);
				text_buf[old_len] = '\0';
				PA_UNLOCK(state->line_buf);
				state->line_buf_len = old_len;

				*w_end = tchar1;
				tptr = w_start;
				while ((XP_IS_SPACE(*tptr))&&(*tptr != '\0'))
				{
					tptr++;
				}
				line_break = TRUE;
				w_start = tptr;
				w_end = tptr;
				tchar1 = *w_end;
			}
#endif
		}

		if (tchar1 == LF)
		{
			line_break = TRUE;
		}
		else if (tchar1 == CR)
		{
			line_break = TRUE;
			have_CR = TRUE;
		}

		/* update the buffer position to refleft the new word */
		block->buffer_read_index = tptr - (char *) block->text_buffer;
		
		/*
		 * If we are breaking the line here, flush the
		 * line_buf, and then insert a linebreak.
		 */
		if (line_break != FALSE)
		{
#ifdef LOCAL_DEBUG
XP_TRACE(("LineBreak, flush text.\n"));
#endif /* LOCAL_DEBUG */

			/*
			 * Flush the line and insert the linebreak.
			 */
			PA_LOCK(text_buf, char *, state->line_buf);
			text_data.text = state->line_buf;
			text_data.text_len = (int16)state->line_buf_len;
			text_data.text_attr = block->text_attr;
			FE_GetTextInfo(context, &text_data,&(state->text_info));
			PA_UNLOCK(state->line_buf);
			state->width = lo_correct_text_element_width(
				&(state->text_info));

			lo_FlushLineBuffer(context, state);

			lineBufMeasured = TRUE;
#ifdef EDITOR
	/* LTNOTE: do something here like: */
			/*state->edit_current_offset += (word_ptr - text_buf);*/
#endif
			if (state->top_state->out_of_memory != FALSE)
			{
				PA_FREE(tmp_block);
				return;
			}
			/*
			 * Put on a linefeed element.
			 * This line is finished and will be added
			 * to the line array.
			 */
			lo_SoftLineBreak(context, state, TRUE);

			state->line_buf_len = 0;
			state->width = 0;

			/*
			 * having just broken the line, we have no break
			 * position.
			 */
			state->break_pos = -1;
			state->break_width = 0;
		}

		*w_end = tchar1;
		if ((*tptr == CR)||(*tptr == LF))
		{
			tptr++;
		}
		PA_FREE(tmp_block);
	}

#ifndef OLD_WAY
	/*
	 * If we haven't measured this line of text yet, do so now
	 */
	if ( !lineBufMeasured )
	{
		text_data.text = state->line_buf;
		text_data.text_len = (int16)state->line_buf_len;
		text_data.text_attr = block->text_attr;
		FE_GetTextInfo ( context, &text_data, &(state->text_info) );
		state->width = lo_correct_text_element_width ( &(state->text_info) );
	}
#endif

	/*
	 * Because we just might get passed text broken between the
	 * CR and the LF, we need to save this state.
	 */
	if ((tptr > text)&&(*(tptr - 1) == CR))
	{
		state->last_char_CR = TRUE;
	}
	
	if ( ( state->cur_ele_type != LO_TEXT ) || ( state->line_buf_len == 0 ) )
		{
		state->cur_text_block = NULL;
		}
}

#define CAPITALIZE 0
#define UPPERCASE  1
#define LOWERCASE  2

/* transform the text inline.
 * "capitalize" : uppercase first letter of each word.
 * "uppercase" : uppercase every letter
 * "lowercase" : lowercase every letter
 * else : do nothing
 */
PRIVATE void
lo_transform_text(char *ptr, int method)
{
	XP_Bool possible_first_letter = TRUE;

	for(; *ptr; ptr++)
	{
		switch(method)
		{
		case CAPITALIZE:
				if(!(XP_IS_SPACE(*ptr)))
				{
					if(possible_first_letter)
					{
						*ptr = XP_TO_UPPER(*ptr);
						possible_first_letter = FALSE;
					}
				}
				else /* is a space */
				{
					possible_first_letter = TRUE;
				}
				break;

			case UPPERCASE:
				*ptr = XP_TO_UPPER(*ptr);
				break;

			case LOWERCASE:
				*ptr = XP_TO_LOWER(*ptr);
				break;

			default:
				XP_ASSERT(0);

		}
	}
}

/* see lo_transform_text
 *
 * This function just maps the string method to an int
 */
PRIVATE void
lo_transform_text_from_string_method(char *ptr, char *method)
{
	if(!strcasecomp(method, "capitalize"))
		lo_transform_text(ptr, CAPITALIZE);
	else if(!strcasecomp(method, "lowercase"))
		lo_transform_text(ptr, LOWERCASE);
	else if(!strcasecomp(method, "uppercase"))
		lo_transform_text(ptr, UPPERCASE);
}

/*************************************
 * Function: lo_FormatText
 *
 * Description: This function creates a text block element and then calls the
 *  format text function for it.
 *
 * Params: Window context and document state., and the text to be formatted.
 *
 * Returns: Nothing
 *************************************/
void
lo_FormatText(MWContext *context, lo_DocState *state, char *text)
{
	LO_TextBlock *	block;
	
	/* can we use the new style layout? */
	if ( lo_CanUseBreakTable ( state ) )
		{
		block = state->cur_text_block;
		
		/* flush any existing text in a partial buffer */
		if ( ( block != NULL ) && lo_UseBreakTable ( block ) )
			{
			lo_LayoutTextBlock ( context, state, TRUE );
			}
		
		/* parse the new text and flush all but any stragglers */
		lo_AppendTextToBlock ( context, state, NULL, text );
		lo_LayoutTextBlock ( context, state, FALSE );
		}
	else
		{
		block = lo_NewTextBlock ( context, state, text, state->preformatted );
		if ( !state->top_state->out_of_memory && ( block != NULL ) )
			{
			block->buffer_read_index = 0;
			lo_LayoutFormattedText ( context, state, block );
			}
		}
}


/*************************************
 * Function: lo_FormatText
 *
 * Description: This function formats text by breaking it into lines
 *	at word boundries.  Word boundries are whitespace, or special
 *	word break tags.
 *
 * Params: Window context and document state., and the text to be formatted.
 *
 * Returns: Nothing
 *************************************/
void
lo_LayoutFormattedText(MWContext *context,
                       lo_DocState *state,
                       LO_TextBlock * block)
{
	char *tptr;
	char *w_start;
	char *w_end;
	char *text_buf;
	char tchar1;
	int32 word_len;
	Bool line_break;
	Bool word_break;
	Bool prev_word_breakable;
	Bool white_space;
	int16 charset;
	Bool multi_byte;
	LO_TextStruct text_data;
	char * text;
	
	/* start at the current text position in this text block */
	text = (char *) &block->text_buffer[ block->buffer_read_index ];
	

#ifdef XP_OS2                  /* performance                            */
   int32 maxw;            /* performance - max char width for font  */
   int32 estwidth;        /* performance - estimated width for line */
   int textsw;            /* performance                            */
   maxw  = 0;
   textsw = 0;            /* performance - need to mark no width taken */
#endif


	/*
	 * Initialize the structures to 0 (mark)
	 */
	memset (&text_data, 0, sizeof (LO_TextStruct));

	/*
	 * Error conditions
	 */
	if ((state == NULL)||(state->cur_ele_type != LO_TEXT)||(text == NULL))
	{
		return;
	}

	charset = block->text_attr->charset;
	if ((INTL_CharSetType(charset) == SINGLEBYTE) ||
		(INTL_CharSetType(charset) & CS_SPACE))
	{
		multi_byte = FALSE;
	}
	else
	{
		multi_byte = TRUE;
	}

	/*
	 * Move through this text fragment, breaking it up into
	 * words, and then grouping the words into lines.
	 */
	tptr = text;
	prev_word_breakable = FALSE;
	while ((*tptr != '\0')&&(state->top_state->out_of_memory == FALSE))
	{
		PA_Block nbsp_block;
		Bool has_nbsp;
		int32 w_char_cnt;
#ifdef XP_WIN16
		int32 ccnt;
#endif /* XP_WIN16 */
		Bool mb_sp;  /* Allow space between multibyte */
		
		/*
		 * white_space is a tag to tell us if the currenct word
		 * contains nothing but whitespace.
		 * word_break tells us if there was whitespace
		 * before this word so we know we can break it.
		 */
		white_space = FALSE;
		word_break = FALSE;
		line_break = FALSE;
		nbsp_block = NULL;
		has_nbsp = FALSE;
		mb_sp = FALSE;

		if (multi_byte == FALSE)
		{
			/* check for textTransform properties and apply them */
			if(state->top_state && state->top_state->style_stack)
			{
				char *property;
				StyleStruct *style_struct = STYLESTACK_GetStyleByIndex(
												state->top_state->style_stack, 
												0);

				if(style_struct)
				{
					property = STYLESTRUCT_GetString(style_struct, 
													 TEXT_TRANSFORM_STYLE);

					if(property)
					{
						lo_transform_text_from_string_method(tptr, property);
					}
				}
			}
		
			/*
			 * Find the start of the word, skipping whitespace.
			 */
			w_start = tptr;
			while ((XP_IS_SPACE(*tptr))&&(*tptr != '\0'))
			{
				tptr++;
			}

			/*
			 * if tptr has been moved at all, that means
			 * there was some whitespace to skip, which means
			 * we are allowed to put a linebreak before this
			 * word if we want to.
			 */
			if (tptr != w_start)
			{
				int32 new_break_holder;
				int32 min_width;
				int32 indent;

				w_start = tptr;
				word_break = TRUE;

				new_break_holder = state->x + state->width;
				min_width = new_break_holder - state->break_holder;
				indent = state->list_stack->old_left_margin -
						state->win_left;
				min_width += indent;
				if (min_width > state->min_width)
				{
					state->min_width = min_width;
				}
				/* If we are not within <NOBR> content, allow break_holder
				 * to be set to the new position where a line break can occur.
				 * This fixes BUG #70782
				 */
				if (state->breakable != FALSE) {
					state->break_holder = new_break_holder;
				}
			}

			/*
   	         * If we are in text that is supposed to be
             * justified, we want each word to be in a separate
             * text element, so if we just found a word break,
             * and there is already a word in the line buffer,
             * flush that word into its own element.
             */
			if ((state->align_stack != NULL)&&
			   (state->align_stack->alignment ==LO_ALIGN_JUSTIFY)&&
			   (word_break != FALSE)&&
			   (state->cur_ele_type == LO_TEXT)&&
			   (state->line_buf_len != 0))
			{
				/* set the current text offset for this new word */
				block->buffer_read_index = tptr - (char *) block->text_buffer;
				
				lo_FlushLineBuffer(context, state);
				if (state->top_state->out_of_memory != FALSE)
				{
					return;
				}
			}

			/*
			 * Find the end of the word.
			 * Terminate the word, saving the char we replaced
			 * with the terminator so it can be restored later.
			 */
			w_char_cnt = 0;
#ifdef XP_WIN16
			ccnt = state->line_buf_len;
			while ((!XP_IS_SPACE(*tptr))&&(*tptr != '\0')&&(ccnt < SIZE_LIMIT))
			{
				if ((unsigned char)*tptr == NON_BREAKING_SPACE)
				{
					has_nbsp = TRUE;
				}
				tptr++;
				w_char_cnt++;
				ccnt++;
			}
			if (ccnt >= SIZE_LIMIT)
			{
				line_break = TRUE;
			}
#else
			while ((!XP_IS_SPACE(*tptr))&&(*tptr != '\0'))
			{
				if ((unsigned char)*tptr == NON_BREAKING_SPACE)
				{
					/* *tptr = ' '; Replace this later */
					has_nbsp = TRUE;
				}
				tptr++;
				w_char_cnt++;
			}
#endif /* XP_WIN16 */
		}
		else
		{
			has_nbsp = TRUE;
			/*
			 * Find the start of the word, skipping whitespace.
			 */
			w_start = tptr;
			while ((XP_IS_SPACE(*tptr))&&(*tptr != '\0'))
			{
				tptr = INTL_NextChar(charset, tptr);
			}
			if (w_start != tptr)
				mb_sp = TRUE;

			/*
			 * if tptr has been moved at all, that means
			 * there was some whitespace to skip, which means
			 * we are allowed to put a linebreak before this
			 * word if we want to.
			 */
			/*
			 * If this char is a two-byte thing, we can break
			 * before it.
			 */
			if ((tptr != w_start)||((unsigned char)*tptr > 127))
			{
				int32 new_break_holder;
				int32 min_width;
				int32 indent;

				/* If it's multibyte character, it always be able to break */
				if (tptr == w_start)
					prev_word_breakable = TRUE;
				w_start = tptr;
				word_break = TRUE;

				new_break_holder = state->x + state->width;
				min_width = new_break_holder - state->break_holder;
				indent = state->list_stack->old_left_margin -
						state->win_left;
				min_width += indent;
				if (min_width > state->min_width)
				{
					state->min_width = min_width;
				}
				/* If we are not within <NOBR> content, allow break_holder
				 * to be set to the new position where a line break can occur.
				 * This fixes BUG #70782
				 */
				if (state->breakable != FALSE) {
					state->break_holder = new_break_holder;
				}
			}
			else if (prev_word_breakable)
			{
				int32 new_break_holder;
				int32 min_width;
				int32 indent;

				prev_word_breakable = FALSE;
				w_start = tptr;
				word_break = TRUE;

				new_break_holder = state->x + state->width;
				min_width = new_break_holder - state->break_holder;
				indent = state->list_stack->old_left_margin -
						state->win_left;
				min_width += indent;
				if (min_width > state->min_width)
				{
					state->min_width = min_width;
				}
				/* If we are not within <NOBR> content, allow break_holder
				 * to be set to the new position where a line break can occur.
				 * This fixes BUG #70782
				 */
				if (state->breakable != FALSE) {
					state->break_holder = new_break_holder;
				}
			}

			/*
			 * Find the end of the word.
			 * Terminate the word, saving the char we replaced
			 * with the terminator so it can be restored later.
			 */
			w_char_cnt = 0;
#ifdef XP_WIN16
			ccnt = state->line_buf_len;
			while ((  ((unsigned char)*tptr < 128) 
						|| (INTL_KinsokuClass(charset, (unsigned char *)tptr) == PROHIBIT_WORD_BREAK )
				   ) && (!XP_IS_SPACE(*tptr)) 
					 && (*tptr != '\0')
					 && (ccnt < SIZE_LIMIT))
			{
				intn c_len;
				char *tptr2;

				tptr2 = INTL_NextChar(charset, tptr);
				c_len = (intn)(tptr2 - tptr);
				tptr = tptr2;
				w_char_cnt += c_len;
				ccnt += c_len;
			}
			if (ccnt >= SIZE_LIMIT)
			{
				line_break = TRUE;
			}
#else

#if 0
			while ( /* Change the order so we have better performance */
					 (*tptr != '\0')
				     && (!XP_IS_SPACE(*tptr)) 
				     && (	((unsigned char)*tptr < 128)
						    || ((CS_UTF8 == charset) /* hack, since we know only CS_UTF8 have PROHIBIT_WORD_BREAK*/
						        && (INTL_KinsokuClass(charset, (unsigned char *)tptr) == PROHIBIT_WORD_BREAK ))
				        )
					 )
#else
			while (
					 (*tptr != '\0')
				     && (!XP_IS_SPACE(*tptr)) 
				     && (	((unsigned char)*tptr < 128)
						    || ((CS_UTF8 == charset) && (*(unsigned char *)tptr <= 0xE2))					
						    /* In case of CS_UTF8, some code range like CJK character baundary is breakable.
						     * While in range UCS2 < 0x2000 (roman), character baundary is not breakable. 
						     */
				        )
					 )
#endif
			{
				intn c_len;
				char *tptr2;

				tptr2 = INTL_NextChar(charset, tptr);
				c_len = (intn)(tptr2 - tptr);
				tptr = tptr2;
				w_char_cnt += c_len;
			}
#endif /* XP_WIN16 */
		}  /* multi byte */

		if (w_char_cnt > TEXT_CHUNK_LIMIT)
		{
			tptr = (char *)(tptr - (w_char_cnt - TEXT_CHUNK_LIMIT));
			w_char_cnt = TEXT_CHUNK_LIMIT;
		}

		if ((state->line_buf_len + w_char_cnt) > TEXT_CHUNK_LIMIT)
		{
			lo_FlushLineBuffer(context, state);
			if (state->top_state->out_of_memory != FALSE)
			{
				return;
			}
			
			if (state->cur_ele_type != LO_TEXT)
			{
				lo_FreshText(state);
				state->cur_ele_type = LO_TEXT;
			}
		}
		if (multi_byte != FALSE)
		{
			if ((w_start == tptr)&&((unsigned char)*tptr > 127))
			{
				tptr = INTL_NextChar(charset, tptr);
			}
		}
		w_end = tptr;
		tchar1 = *w_end;
		*w_end = '\0';

		/*
		 * If the "word" is just an empty string, this
		 * is just whitespace that we may wish to compress out.
		 */
		if (*w_start == '\0')
		{
			white_space = TRUE;
		}

		/*
		 * compress out whitespace if the last word added was also
		 * whitespace.
		 */
		if ((white_space != FALSE)&&(state->trailing_space != FALSE))
		{
			*w_end = tchar1;
#ifdef LOCAL_DEBUG
XP_TRACE(("Discarding(%s)\n", w_start));
#endif /* LOCAL_DEBUG */
			continue;
		}

		/*
		 * This places the preceeding space in front of
		 * separate words on a line.
		 * Unecessary if last item was trailng space.
		 *
		 * If there was a word break before this word, so we know it
		 * was supposed to be separate, and if we are not at the
		 * beginning of the line, and if the
		 * preceeding word is not already whitespace, then add
		 * a space before this word.
		 */
		if ((word_break != FALSE)&&
			(state->at_begin_line == FALSE)&&
			(state->trailing_space == FALSE))
		{
			/*
			 * Since word_break is true, we know
			 * we skipped some spaces previously
			 * so we know there is space to back up
			 * the word pointer inside the buffer.
			 */
		    if ((multi_byte == FALSE)||mb_sp)
		    {
				w_start--;
				*w_start = ' ';
		    }

			/*
			 * If we are formatting breakable text
			 * set break position to be just before this word.
			 * This is where we will break this line if the
			 * new word makes it too long.
			 */
			if (state->breakable != FALSE)
			{
				state->break_pos = state->line_buf_len;
				state->break_width = state->width;
			}
		}

#ifdef LOCAL_DEBUG
XP_TRACE(("Found Word (%s)\n", w_start));
#endif /* LOCAL_DEBUG */
		/*
		 * If this is an empty string, just throw it out
		 * and move on
		 */
		if (*w_start == '\0')
		{
			*w_end = tchar1;
#ifdef LOCAL_DEBUG
XP_TRACE(("Throwing out empty string!\n"));
#endif /* LOCAL_DEBUG */
			continue;
		}

		/*
		 * Now we catch those nasty non-breaking space special
		 * characters and make them spaces.  Yuck, so that 
		 * relayout in tables will still see the non-breaking
		 * spaces, we need to copy the buffer here.
		 */
		if (has_nbsp != FALSE)
		{
			char *tmp_ptr;
			char *to_ptr;
			char *tmp_buf;

			nbsp_block = PA_ALLOC(XP_STRLEN(w_start) + 1);
			if (nbsp_block == NULL)
			{
				*w_end = tchar1;
				state->top_state->out_of_memory = TRUE;
				break;
			}
			PA_LOCK(tmp_buf, char *, nbsp_block);

			tmp_ptr = w_start;
			to_ptr = tmp_buf;
			while (*tmp_ptr != '\0')
			{
				*to_ptr = *tmp_ptr;
				if (((unsigned char)*to_ptr == NON_BREAKING_SPACE)
					&& (CS_USER_DEFINED_ENCODING != charset))
				{
					*to_ptr = ' ';
				}
				if(multi_byte) {
					int i;
					int len = INTL_CharLen(charset,
                                           (unsigned char *)tmp_ptr);
					to_ptr++;
					tmp_ptr++;
					for (i=1; (i<len) && (*tmp_ptr != '\0'); i++) {
						*to_ptr++  = *tmp_ptr++;
					}
				}
				else {
					to_ptr++;
					tmp_ptr++;
				}
			}
			*w_end = tchar1;
			w_start = tmp_buf;
			w_end = to_ptr;
			*w_end = '\0';
		}

		/*
		 * Make this Front End specific text, and count
		 * the length of the word.
		 */
		/* don't need this any more since we're converting
		 * elsewhere -- erik
		w_start = FE_TranslateISOText(context, charset, w_start);
		 */
		word_len = XP_STRLEN(w_start);

		/*
		 * Append this word to the line buffer.
		 * It may be necessary to expand the line
		 * buffer.
		 */
		if ((state->line_buf_len + word_len + 1) >
			state->line_buf_size)
		{
			state->line_buf = PA_REALLOC( state->line_buf,
				(state->line_buf_size +
				word_len + LINE_BUF_INC));
			if (state->line_buf == NULL)
			{
				*w_end = tchar1;
				if ((has_nbsp != FALSE)&&(nbsp_block != NULL))
				{
					PA_UNLOCK(nbsp_block);
					PA_FREE(nbsp_block);
					nbsp_block = NULL;
				}
				state->top_state->out_of_memory = TRUE;
				break;
			}
			state->line_buf_size += (word_len + LINE_BUF_INC);
		}
		PA_LOCK(text_buf, char *, state->line_buf);
		XP_BCOPY(w_start,
		    (char *)(text_buf + state->line_buf_len),
		    (word_len + 1));
		state->line_buf_len += word_len;
		PA_UNLOCK(state->line_buf);

		/*
		 * Having added a word, we cannot be at the start of a line
		 */
		state->cur_ele_type = LO_TEXT;
		state->at_begin_line = FALSE;

		/*
		 * Most common case is appending to the same line.
		 * assume that is what we are doing here.
		 */
		text_data.text = state->line_buf;
		text_data.text_len = (int16)state->line_buf_len;
		text_data.text_attr = state->cur_text_block->text_attr;
		FE_GetTextInfo(context, &text_data, &(state->text_info));
		state->width =
			lo_correct_text_element_width(&(state->text_info));
		
		/* udpate the block's font info cache */
		block->ascent = state->text_info.ascent;
		block->descent = state->text_info.descent;
		
		/*
		 * Set line_break based on document window width
		 */
#ifdef XP_WIN16
		if (((state->x + state->width) > state->right_margin)||(line_break != FALSE))
#else
		if ((state->x + state->width) > state->right_margin)
#endif /* XP_WIN16 */
		{
			/*  
			 * INTL kinsoku line break, some of characters are not allowed to put 
			 * in the end of line or beginning of line
			 */
			if (multi_byte && (state->break_pos != -1))
			{
				int cur_wordtype, pre_wordtype, pre_break_pos;
				cur_wordtype = INTL_KinsokuClass(charset, (unsigned char *) w_start);

				PA_LOCK(text_buf, char *, state->line_buf);
				pre_break_pos = INTL_PrevCharIdx(charset, 
					(unsigned char *)text_buf, state->break_pos);
				pre_wordtype = INTL_KinsokuClass(charset, 
					(unsigned char *)(text_buf + pre_break_pos));

				if (pre_wordtype == PROHIBIT_END_OF_LINE ||
				    (cur_wordtype == PROHIBIT_BEGIN_OF_LINE && 
					 XP_IS_ALPHA(*(text_buf+pre_break_pos)) == FALSE))
					state->break_pos = pre_break_pos;

				PA_UNLOCK(state->line_buf);
			}
			line_break = TRUE;
		}
		else
		{
			line_break = FALSE;
		}

		/*
		 * We cannot break a line if we have no break positions.
		 * Usually happens with a single line of unbreakable text.
		 */
		if ((line_break != FALSE)&&(state->break_pos == -1))
		{
			/*
			 * It may be possible to break a previous
			 * text element on the same line.
			 */
			if (state->old_break_pos != -1)
			{
				lo_BreakOldElement(context, state);
				line_break = FALSE;
			}
#ifdef XP_WIN16
			else if (ccnt >= SIZE_LIMIT)
			{
				state->break_pos = state->line_buf_len - 1;
			}
			else
			{
				line_break = FALSE;
			}
#else
			else
			{
				line_break = FALSE;
			}
#endif /* XP_WIN16 */
		}

		/*
		 * If we are breaking the line here, flush the
		 * line_buf, and then insert a linebreak.
		 */
		if (line_break != FALSE)
		{
			char *break_ptr;
			char *word_ptr;
			char *new_buf;
			PA_Block new_block;
#ifdef LOCAL_DEBUG
XP_TRACE(("LineBreak, flush text.\n"));
#endif /* LOCAL_DEBUG */

			/*
			 * Find the breaking point, and the pointer
			 * to the remaining word without its leading
			 * space.
			 */
			PA_LOCK(text_buf, char *, state->line_buf);
			break_ptr = (char *)(text_buf + state->break_pos);
/*			word_ptr = (char *)(break_ptr + 1); */
			word_ptr = break_ptr;

		    if ((multi_byte == FALSE)||mb_sp)
		    {
				word_ptr++;
		    }

			/*
			 * Copy the remaining word into its
			 * own buffer.
			 */
			word_len = XP_STRLEN(word_ptr);
			new_block = PA_ALLOC((word_len + 1) *
				sizeof(char));
			if (new_block == NULL)
			{
				PA_UNLOCK(state->line_buf);
				*w_end = tchar1;
				if ((has_nbsp != FALSE)&&(nbsp_block != NULL))
				{
					PA_UNLOCK(nbsp_block);
					PA_FREE(nbsp_block);
					nbsp_block = NULL;
				}
				state->top_state->out_of_memory = TRUE;
				break;
			}
			PA_LOCK(new_buf, char *, new_block);
			XP_BCOPY(word_ptr, new_buf, (word_len + 1));

			*break_ptr = '\0';
			state->line_buf_len = state->line_buf_len -
				word_len;
			if ((multi_byte == FALSE)||(word_ptr != break_ptr))
		    {
				state->line_buf_len--;
		    }
			text_data.text = state->line_buf;
			text_data.text_len = (int16)state->line_buf_len;
			text_data.text_attr = state->cur_text_block->text_attr;
			FE_GetTextInfo(context, &text_data,&(state->text_info));
			PA_UNLOCK(state->line_buf);
			state->width = lo_correct_text_element_width(
				&(state->text_info));
			
			lo_FlushLineBuffer(context, state);
#ifdef EDITOR
			state->edit_current_offset += (word_ptr - text_buf);
#endif
			if (state->top_state->out_of_memory != FALSE)
			{
				PA_UNLOCK(new_block);
				PA_FREE(new_block);
				if ((has_nbsp != FALSE)&&(nbsp_block != NULL))
				{
					PA_UNLOCK(nbsp_block);
					PA_FREE(nbsp_block);
					nbsp_block = NULL;
				}
				return;
			}

			/*
			 * Put on a linefeed element.
			 * This line is finished and will be added
			 * to the line array.
			 */
			lo_SoftLineBreak(context, state, TRUE);

			/*
			 * If there was no remaining word, free up
			 * the unnecessary buffer, and empty out
			 * the line buffer.
			 */
			if (word_len == 0)
			{
				PA_UNLOCK(new_block);
				PA_FREE(new_block);
				state->line_buf_len = 0;
				state->width = 0;
			}
			else
			{
				PA_LOCK(text_buf, char *,state->line_buf);
				XP_BCOPY(new_buf, text_buf, (word_len + 1));
				PA_UNLOCK(state->line_buf);
				PA_UNLOCK(new_block);
				PA_FREE(new_block);
				state->line_buf_len = word_len;
				text_data.text = state->line_buf;
				text_data.text_len = (int16)state->line_buf_len;
				text_data.text_attr =
					state->cur_text_block->text_attr;
				FE_GetTextInfo(context, &text_data,
					&(state->text_info));
				state->width = lo_correct_text_element_width(
					&(state->text_info));

				/*
				 * Having added text, we are no longer at the
				 * start of the line.
				 */
				state->at_begin_line = FALSE;
				state->cur_ele_type = LO_TEXT;
			}


			/*
			 * having just broken the line, we have no break
			 * position.
			 */
			state->break_pos = -1;
			state->break_width = 0;
		}
		else
		{
			/* this word fits, so update the text buffer position */
			block->buffer_read_index = tptr - (char *) block->text_buffer;

			if (white_space != FALSE)
			{
				state->trailing_space = TRUE;
			}
			else
			{
				state->trailing_space = FALSE;
			}
		}

		*w_end = tchar1;
		/*
		 * Free up the extra block used for non-breaking
		 * spaces if we had to allocate one.
		 */
		if ((has_nbsp != FALSE)&&(nbsp_block != NULL))
		{
			PA_UNLOCK(nbsp_block);
			PA_FREE(nbsp_block);
			nbsp_block = NULL;
		}
	}
	/*   
     * if last char is multibyte, break position need to be set to
	 * end of string 
     */
	if (multi_byte != FALSE && *tptr == '\0' && prev_word_breakable != FALSE)
		state->break_pos = state->line_buf_len;
	
	if ( ( state->cur_ele_type != LO_TEXT ) || ( state->line_buf_len == 0 ) )
		{
		state->cur_text_block = NULL;
		}
}


/*************************************
 * Function: lo_FlushLineBuffer
 *
 * Description: Flush out the current line buffer of text
 *	into a new text element, and add that element to
 *	the end of the line list of elements.
 *
 * Params: Window context and document state.
 *
 * Returns: Nothing
 *************************************/
void
lo_FlushLineBuffer(MWContext *context, lo_DocState *state)
{
	LO_TextStruct *text_data;
	int32 baseline_inc;
	LO_TextBlock * block;
	
	baseline_inc = 0;
#ifdef DEBUG
	assert (state);
#endif
		
	block = state->cur_text_block;
	
	/* bail if we have nothing to do with text */
	if ( ( block == NULL ) || ( state->cur_ele_type != LO_TEXT ) )
		{
		return;
		}
	
	/*
	 * If we're currently using the new break table layout, then bail to it
	 */
	if ( lo_UseBreakTable ( block ) )
		{
		lo_FlushText ( context, state );
		return;
		}
	
	/*
	 * Make sure we have some text to flush
	 */
	if ( state->line_buf_len == 0 )
		{
		return;
		}
		
	/* 
	 * LTNOTE: probably should be grabbing state edit_element and offset from
	 * state.
	*/
    text_data = lo_new_text_element(context, state, NULL, 0);

	if (text_data == NULL)
	{
		state->top_state->out_of_memory = TRUE;
		return;
	}
	state->linefeed_state = 0;

	/*
	 * Some fonts (particulatly italic ones with curly tails
	 * on letters like 'f') have a left bearing that extends
	 * back into the previous character.  Since in this case the
	 * previous character is probably not in the same font, we
	 * move forward to avoid overlap.
	 *
	 * Those same funny fonts can extend past the last character,
	 * and we also have to catch that, and advance the following text
	 * to eliminate cutoff.
	 */
	if (state->text_info.lbearing < 0)
	{
		text_data->x_offset = state->text_info.lbearing * -1;
	}
	text_data->width = state->width;
	
	/* 
	 * record the current doc width and text buffer offset for use
	 * during relayout.
	 */
	text_data->doc_width = state->right_margin - state->x;
	text_data->block_offset = block->buffer_read_index;
	XP_ASSERT(block->buffer_read_index <= 65535);
	
	baseline_inc = lo_compute_text_basline_inc ( state, block, text_data );
	
	lo_AppendToLineList(context, state, (LO_Element *)text_data, baseline_inc);

	if ( block->startTextElement == NULL )
		{
		block->startTextElement = text_data;
		block->endTextElement = text_data;
		}
	else
		{
		block->endTextElement = text_data;
		}
		
	text_data->height = state->text_info.ascent +
		state->text_info.descent;

	/*
	 * If the element we just flushed had a breakable word
	 * position in it, save that position in case we have
	 * to go back and break this element before we finish
	 * the line.
	 */
	if (state->break_pos != -1)
	{
		state->old_break = text_data;
		state->old_break_block = block;
		state->old_break_pos = state->break_pos;
		state->old_break_width = state->break_width;
	}

	state->line_buf_len = 0;
	state->x += state->width;
	state->width = 0;
	state->cur_ele_type = LO_NONE;
}

void
lo_FlushTextBlock ( MWContext *context, lo_DocState *state )
{
	lo_FlushLineBuffer ( context, state );
	
	state->cur_text_block = NULL;
}

void
lo_ChangeBodyTextFGColor(MWContext *context, lo_DocState *state, 
                         LO_Color *color)
{
	lo_FontStack *fptr;
	LO_TextAttr *attr;

	if ((state->top_state->body_attr & BODY_ATTR_TEXT) != 0)
        return;
    
    state->top_state->body_attr |= BODY_ATTR_TEXT;

    state->text_fg = *color;
    fptr = state->font_stack;

    /* 
     * If we're inside a layer, then we want this color change
     * to only affect text in the layer. So, we push a font
     * (a copy of the top of the stack) onto the font stack
     * and change its color. This font will be popped in the
     * closing of the layer.
     */
    if (lo_InsideLayer(state)) {
        LO_TextAttr tmp_attr;
        
        if (fptr)
            lo_CopyTextAttr(fptr->text_attr, &tmp_attr);
        else
            lo_SetDefaultFontAttr(state, &tmp_attr, context);

        tmp_attr.fg.red =   STATE_DEFAULT_FG_RED(state);
		tmp_attr.fg.green = STATE_DEFAULT_FG_GREEN(state);
		tmp_attr.fg.blue =  STATE_DEFAULT_FG_BLUE(state);
        attr = lo_FetchTextAttr(state, &tmp_attr);
        lo_PushFont(state, P_BODY, attr);
    }
    else if (fptr != NULL)
	{
		attr = fptr->text_attr;
		attr->fg.red =   STATE_DEFAULT_FG_RED(state);
		attr->fg.green = STATE_DEFAULT_FG_GREEN(state);
		attr->fg.blue =  STATE_DEFAULT_FG_BLUE(state);
	}
}


/*
 * Something has changed (probably the default FG and BG colors)
 * since the font stack was initialized in this state.
 * We need to reinitialie it to the new default font.
 * WARNING: This function depends on the assumption that no
 *		elements have yet been placed in this state.
 */
void
lo_ResetFontStack(MWContext *context, lo_DocState *state)
{
	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);
}


/*************************************
 * Function: lo_PushFont
 *
 * Description: Push the text attribute information for a new
 *	font onto the font stack.  Also save the type of the
 *	tag that caused the change.
 *
 * Params: Document state, tag type, and the text attribute
 *	structure for the new font.
 *
 * Returns: Nothing
 *************************************/
void
lo_PushFont(lo_DocState *state, intn tag_type, LO_TextAttr *attr)
{
	lo_FontStack *fptr;

	fptr = XP_NEW(lo_FontStack);
	if (fptr == NULL)
	{
		return;
	}
	fptr->tag_type = tag_type;
	fptr->text_attr = attr;
	fptr->next = state->font_stack;
	state->font_stack = fptr;;
}


/*************************************
 * Function: lo_PopFontStack
 *
 * Description: This function pops the next font
 *	off the font stack, and return the text attribute of the
 *	previous font.
 *	The last font on the font stack cannot be popped off.
 *
 * Params: Document state, and the tag type that caused the change.
 *
 * Returns: The LO_TextAttr structure of the font just passed.
 *************************************/
PRIVATE
LO_TextAttr *
lo_PopFontStack(lo_DocState *state, intn tag_type)
{
	LO_TextAttr *attr;
	lo_FontStack *fptr;

	if (state->font_stack->next == NULL)
	{
#ifdef LOCAL_DEBUG
XP_TRACE(("Popped too many fonts!\n"));
#endif /* LOCAL_DEBUG */
		return(NULL);
	}

	fptr = state->font_stack;
	attr = fptr->text_attr;
	if (fptr->tag_type != tag_type)
	{
#ifdef LOCAL_DEBUG
XP_TRACE(("Warning:  Font popped by different TAG than pushed it %d != %d\n", fptr->tag_type, tag_type));
#endif /* LOCAL_DEBUG */
	}
	state->font_stack = fptr->next;
	XP_DELETE(fptr);

	return(attr);
}


LO_TextAttr *
lo_PopFont(lo_DocState *state, intn tag_type)
{
	LO_TextAttr *attr;
	lo_FontStack *fptr;

	/*
	 * This should never happen, but we are patching a
	 * more serious problem that causes us to be called
	 * here after the font stack has been freed.
	 */
	if ((state->font_stack == NULL)||(state->font_stack->next == NULL))
	{
#ifdef LOCAL_DEBUG
XP_TRACE(("Popped too many fonts!\n"));
#endif /* LOCAL_DEBUG */
		return(NULL);
	}

	fptr = state->font_stack;
	attr = NULL;

	if (fptr->tag_type != P_ANCHOR)
	{
		attr = fptr->text_attr;
		if (fptr->tag_type != tag_type)
		{
#ifdef LOCAL_DEBUG
XP_TRACE(("Warning:  Font popped by different TAG than pushed it %d != %d\n", fptr->tag_type, tag_type));
#endif /* LOCAL_DEBUG */
		}
		state->font_stack = fptr->next;
		XP_DELETE(fptr);
	}
	else
	{
		while ((fptr->next != NULL)&&(fptr->next->tag_type == P_ANCHOR))
		{
			fptr = fptr->next;
		}
		if (fptr->next->next != NULL)
		{
			lo_FontStack *f_tmp;

			f_tmp = fptr->next;
			fptr->next = fptr->next->next;
			attr = f_tmp->text_attr;
			XP_DELETE(f_tmp);
		}
	}

	return(attr);
}


void
lo_PopAllAnchors(lo_DocState *state)
{
	lo_FontStack *fptr;

	if (state->font_stack->next == NULL)
	{
#ifdef LOCAL_DEBUG
XP_TRACE(("Popped too many fonts!\n"));
#endif /* LOCAL_DEBUG */
		return;
	}

	/*
	 * Remove all anchors on top of the font stack
	 */
	fptr = state->font_stack;
	while ((fptr->tag_type == P_ANCHOR)&&(fptr->next != NULL))
	{
		lo_FontStack *f_tmp;

		f_tmp = fptr;
		fptr = fptr->next;
		XP_DELETE(f_tmp);
	}
	state->font_stack = fptr;

	/*
	 * Remove all anchors buried in the stack
	 */
	while (fptr->next != NULL)
	{
		/*
		 * Reset spurrious anchor color text entries
		 */
		if ((fptr->text_attr != NULL)&&
			(fptr->text_attr->attrmask & LO_ATTR_ANCHOR))
		{
			LO_TextAttr tmp_attr;

			lo_CopyTextAttr(fptr->text_attr, &tmp_attr);
			tmp_attr.attrmask =
				tmp_attr.attrmask & (~LO_ATTR_ANCHOR);
			tmp_attr.fg.red = STATE_DEFAULT_FG_RED(state);
			tmp_attr.fg.green = STATE_DEFAULT_FG_GREEN(state);
			tmp_attr.fg.blue = STATE_DEFAULT_FG_BLUE(state);
			tmp_attr.bg.red = STATE_DEFAULT_BG_RED(state);
			tmp_attr.bg.green = STATE_DEFAULT_BG_GREEN(state);
			tmp_attr.bg.blue = STATE_DEFAULT_BG_BLUE(state);
			fptr->text_attr = lo_FetchTextAttr(state, &tmp_attr);
		}

		if (fptr->next->tag_type == P_ANCHOR)
		{
			lo_FontStack *f_tmp;

			f_tmp = fptr->next;
			fptr->next = fptr->next->next;
			XP_DELETE(f_tmp);
		}
		else
		{
			fptr = fptr->next;
		}
	}
}

void
lo_FormatBullet(MWContext *context, lo_DocState *state,
				LO_BulletStruct *bullet,
				int32 *line_height,
				int32 *baseline)
{
	LO_TextStruct tmp_text;
	LO_TextInfo text_info;
	LO_TextAttr *tptr;
	PA_Block buff;
	char *str;

#define MIN_BULLET_SIZE 5

	bullet->ele_id = NEXT_ELEMENT;

	/* bullet = (LO_BulletStruct *)lo_NewElement(context, state, LO_BULLET, NULL, 0); */
	if (bullet == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		return;
	}

	tptr = bullet->text_attr;

	memset (&tmp_text, 0, sizeof (tmp_text));
	buff = PA_ALLOC(1);
	if (buff == NULL)
	{
		state->top_state->out_of_memory = TRUE;
		return;
	}
	PA_LOCK(str, char *, buff);
	str[0] = ' ';
	PA_UNLOCK(buff);
	tmp_text.text = buff;
	tmp_text.text_len = 1;
	tmp_text.text_attr = tptr;
	FE_GetTextInfo(context, &tmp_text, &text_info);
	PA_FREE(buff);

	/* contain the bullet size so that it doesn't extend off the
	 * left side of the page since we are using a negative offset
	 * to place the bullet
	 *
	 * also subtract one to avoid the header code at the bottom
	 * from triggering and messing up the alignment
	 */
	if(bullet->bullet_size*2 >= state->x-state->win_left)
	  bullet->bullet_size = ((state->x-state->win_left)/2)-1;

    /* enforce a minumum bullet size */
    if(bullet->bullet_size < 1)
	  bullet->bullet_size = MIN_BULLET_SIZE;

	bullet->x = state->x - (2 * bullet->bullet_size);
	if (bullet->x < state->win_left)
	{
		bullet->x = state->win_left;
	}
	bullet->x_offset = 0;
	bullet->y = state->y;
	bullet->y_offset =
		(text_info.ascent + text_info.descent - bullet->bullet_size) / 2;
	bullet->width = bullet->bullet_size;
	bullet->height = bullet->bullet_size;

	*line_height = text_info.ascent + text_info.descent;
	*baseline = text_info.ascent;
}

void
lo_UpdateStateAfterBullet(MWContext * context, lo_DocState *state,
						  LO_BulletStruct *bullet,
						  int32 line_height,
						  int32 baseline)
{
	state->baseline = baseline;
	state->line_height = line_height;

	/*
	 * Clean up state
	 */
/*
 * Supporting old mistakes made in some other browsers.
 * I will put the "correct code" here, but comment it out, since
 * some other browsers allowed headers inside lists, so we should to, sigh.
	state->linefeed_state = 0;
 */
	state->at_begin_line = TRUE;
	state->cur_ele_type = LO_BULLET;
	if (bullet->x == state->win_left)
	{
		state->x += (bullet->x_offset + (2 * bullet->width));
	}

	/*
	 * Make at_begin_line be accurate
	 * so we can detect the header
	 * linefeed state deception later.
	 */
	state->at_begin_line = FALSE;
	
	/*
	 * After much soul-searching (and brow-beating
	 * by Jamie, I've agreed that really whitespace
	 * should be compressed out at the start of a
	 * list item.  They can always add non-breaking
	 * spaces if they want them.
	 * Setting trailing space true means it won't
	 * let the users add whitespace because it
	 * thinks there already is some.
	 */
	state->trailing_space = TRUE;
}

void
lo_PlaceBullet(MWContext *context, lo_DocState *state)
{
	LO_BulletStruct *bullet = NULL;
	int32 line_height, baseline;
	LO_TextAttr tmp_attr;
	LO_TextStruct tmp_text;
	LO_TextInfo text_info;
	LO_TextAttr *tptr;
	PA_Block buff;
	char *str;

	bullet = (LO_BulletStruct *)lo_NewElement(context, state,
                                              LO_BULLET, NULL, 0);
	if (bullet == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		return;
	}

	bullet->type = LO_BULLET;
	bullet->next = NULL;
	bullet->prev = NULL;

	bullet->FE_Data = NULL;

	bullet->level = state->list_stack->level;

	bullet->bullet_type = state->list_stack->bullet_type;

    /* try and get a bullet type from style sheets */
    if(state && state->top_state && state->top_state->style_stack)
    {
        StyleStruct *style_struct = STYLESTACK_GetStyleByIndex(
                                            state->top_state->style_stack, 0);

        if(style_struct)
        {
            char *list_style_prop = STYLESTRUCT_GetString(
                                            style_struct,
                                            LIST_STYLE_TYPE_STYLE);
			if(list_style_prop)
			{
				bullet->bullet_type = lo_list_bullet_type(list_style_prop,
                                                          P_UNUM_LIST);
				XP_FREE(list_style_prop);
			}
        }
    }

	bullet->ele_attrmask = 0;

	bullet->sel_start = -1;
	bullet->sel_end = -1;

	if(state->font_stack)
    {
        lo_CopyTextAttr(state->font_stack->text_attr, &tmp_attr);
    }
    else
    {
		lo_SetDefaultFontAttr(state, &tmp_attr, context);
	}
	tptr = lo_FetchTextAttr(state, &tmp_attr);

	memset (&tmp_text, 0, sizeof (tmp_text));
	buff = PA_ALLOC(1);
	if (buff == NULL)
	{
		state->top_state->out_of_memory = TRUE;
		return;
	}
	PA_LOCK(str, char *, buff);
	str[0] = ' ';
	PA_UNLOCK(buff);
	tmp_text.text = buff;
	tmp_text.text_len = 1;
	tmp_text.text_attr = tptr;
	FE_GetTextInfo(context, &tmp_text, &text_info);
	PA_FREE(buff);

	bullet->bullet_size = (text_info.ascent + text_info.descent) / 2;
	bullet->text_attr = tptr;

	lo_FormatBullet(context, state, bullet, &line_height, &baseline);

	lo_AppendToLineList(context, state, (LO_Element *)bullet, 0);

	lo_UpdateStateAfterBullet(context, state, bullet,
							  line_height,
							  baseline);
}


void
lo_FormatBulletStr(MWContext *context, lo_DocState *state,
				   LO_TextStruct *bullet_text,
				   int32 *line_height,
				   int32 *baseline)
{
	LO_TextInfo text_info;

	FE_GetTextInfo(context, bullet_text, &text_info);

	bullet_text->x = state->x - (bullet_text->height / 2) -
		bullet_text->width;
	if (bullet_text->x < state->win_left)
	{
		bullet_text->x = state->win_left;
	}
	bullet_text->x_offset = 0;
	bullet_text->y = state->y;
	bullet_text->y_offset = 0;

	state->baseline = text_info.ascent;
	state->line_height = (intn) bullet_text->height;

	*baseline = text_info.ascent;
	*line_height = bullet_text->height;
}

void
lo_UpdateStateAfterBulletStr(MWContext *context,
							 lo_DocState *state,
							 LO_TextStruct *bullet_text,
							 int32 line_height,
							 int32 baseline)
{
	state->baseline = baseline;
	state->line_height = line_height;

	/*
	 * Clean up state
	 */
/*
 * Supporting old mistakes made in some other browsers.
 * I will put the "correct code" here, but comment it out, since
 * some other browsers allowed headers inside lists, so we should to, sigh.
	state->linefeed_state = 0;
	state->at_begin_line = FALSE;
 */
	state->at_begin_line = TRUE;
	state->cur_ele_type = LO_TEXT;
}

void
lo_PlaceBulletStr(MWContext *context, lo_DocState *state)
{
	intn len;
	char str2[22];
	char *str;
	char *str3;
	PA_Block buff;
	LO_TextStruct *bullet_text = NULL;
	LO_TextInfo text_info;
    int bullet_type;
	int32 line_height, baseline;

	bullet_text = (LO_TextStruct *)lo_NewElement(context, state,
                                                 LO_TEXT, NULL, 0);
	if (bullet_text == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		return;
	}

    bullet_type = state->list_stack->bullet_type;

    /* try and get a bullet type from style sheets */
    if(state && state->top_state && state->top_state->style_stack)
    {
        StyleStruct *style_struct = STYLESTACK_GetStyleByIndex(
                                            state->top_state->style_stack, 0);

        if(style_struct)
        {
            char *list_style_prop = STYLESTRUCT_GetString(
                                            style_struct,
                                            LIST_STYLE_TYPE_STYLE);
			if(list_style_prop)
			{
				bullet_type = lo_list_bullet_type(list_style_prop, P_NUM_LIST);
				XP_FREE(list_style_prop);
			}
        }
    }


	if( EDT_IS_EDITOR( context )) 
	{
		switch( bullet_type ){
		case BULLET_ALPHA_L:
			str = "A";
			break;
		case BULLET_ALPHA_S:
			str = "a";
			break;
		case BULLET_NUM_S_ROMAN:
			str = "x";
			break;
		case BULLET_NUM_L_ROMAN:
			str = "X";
			break;
		default:
			str = "#";
			break;
		}
		len = XP_STRLEN(str);
		buff = PA_ALLOC(len + 1);
		if (buff != NULL)
		{
			PA_LOCK(str3, char *, buff);
			XP_STRCPY(str3, str);
			PA_UNLOCK(buff);
		}
	}
	else {
		if (bullet_type == BULLET_ALPHA_S)
		{
			buff = lo_ValueToAlpha(state->list_stack->value, FALSE, &len);
		}
		else if (bullet_type == BULLET_ALPHA_L)
		{
			buff = lo_ValueToAlpha(state->list_stack->value, TRUE, &len);
		}
		else if (bullet_type == BULLET_NUM_S_ROMAN)
		{
			buff = lo_ValueToRoman(state->list_stack->value, FALSE, &len);
		}
		else if (bullet_type == BULLET_NUM_L_ROMAN)
		{
			buff = lo_ValueToRoman(state->list_stack->value, TRUE, &len);
		}
		else
		{
			XP_SPRINTF(str2, "%d.", (intn)state->list_stack->value);
			len = XP_STRLEN(str2);
			buff = PA_ALLOC(len + 1);
			if (buff != NULL)
			{
				PA_LOCK(str, char *, buff);
				XP_STRCPY(str, str2);
				PA_UNLOCK(buff);
			}
			else
			{
				state->top_state->out_of_memory = TRUE;
			}
		}
	}

	if (buff == NULL)
	{
		return;
	}

	bullet_text->bullet_type = bullet_type;
	bullet_text->text = buff;
	bullet_text->text_len = len;
	bullet_text->text_attr = state->font_stack->text_attr;
	FE_GetTextInfo(context, bullet_text, &text_info);
	bullet_text->width = lo_correct_text_element_width(&text_info);
	bullet_text->height = text_info.ascent + text_info.descent;

	bullet_text->type = LO_TEXT;
	bullet_text->ele_id = NEXT_ELEMENT;

	lo_FormatBulletStr(context, state, bullet_text, &line_height, &baseline);

	bullet_text->anchor_href = state->current_anchor;

	bullet_text->ele_attrmask = 0;
	if (state->breakable != FALSE)
	{
		bullet_text->ele_attrmask |= LO_ELE_BREAKABLE;
	}

	bullet_text->sel_start = -1;
	bullet_text->sel_end = -1;

	bullet_text->next = NULL;
	bullet_text->prev = NULL;

	bullet_text->FE_Data = NULL;

	lo_AppendToLineList(context, state, (LO_Element *)bullet_text, 0);

	state->baseline = text_info.ascent;
	state->line_height = (intn) bullet_text->height;

	lo_UpdateStateAfterBulletStr(context, state, bullet_text,
                                 line_height, baseline);
}


static LO_Element *
lo_make_quote_text(MWContext *context, lo_DocState *state, int32 margin)
{
	PA_Block buff;
	char *str;
	LO_TextStruct *quote_text;
	LO_TextAttr tmp_attr;
	LO_TextInfo text_info;

	quote_text = (LO_TextStruct *)lo_NewElement(context, state, LO_TEXT,
							NULL, 0);
	if (quote_text == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		return(NULL);
	}

	buff = PA_ALLOC(2);
	if (buff == NULL)
	{
		state->top_state->out_of_memory = TRUE;
		return(NULL);
	}
	PA_LOCK(str, char *, buff);
	str[0] = '>';
	str[1] = '\0';
	PA_UNLOCK(buff);

	quote_text->text = buff;
	quote_text->text_len = 1;
	/*
	 * Fill in default fixed font information.
	 */
	lo_SetDefaultFontAttr(state, &tmp_attr, context);
	tmp_attr.fontmask |= LO_FONT_FIXED;
	quote_text->text_attr = lo_FetchTextAttr(state, &tmp_attr);
	FE_GetTextInfo(context, quote_text, &text_info);
	quote_text->width = lo_correct_text_element_width(&text_info);
	quote_text->height = text_info.ascent + text_info.descent;

	quote_text->type = LO_TEXT;
	quote_text->ele_id = 0;
	quote_text->x = margin;
	if (quote_text->x < state->win_left)
	{
		quote_text->x = state->win_left;
	}
	quote_text->x_offset = 0;
	quote_text->y = state->y;
	quote_text->y_offset = 0;

	quote_text->anchor_href = state->current_anchor;

	quote_text->ele_attrmask = 0;
	if (state->breakable != FALSE)
	{
		quote_text->ele_attrmask |= LO_ELE_BREAKABLE;
	}

	quote_text->bullet_type = BULLET_MQUOTE;

	quote_text->sel_start = -1;
	quote_text->sel_end = -1;

	quote_text->next = NULL;
	quote_text->prev = NULL;

	quote_text->FE_Data = NULL;

	state->baseline = text_info.ascent;

	return((LO_Element *)quote_text);
}


static LO_Element *
lo_make_quote_bullet(MWContext *context, lo_DocState *state, int32 margin)
{
	PA_Block buff;
	char *str;
	LO_BulletStruct *bullet = NULL;
	LO_TextAttr tmp_attr;
	LO_TextInfo text_info;
	LO_TextStruct tmp_text;
	LO_TextAttr *tptr;
	int32 bullet_size;

	bullet = (LO_BulletStruct *)lo_NewElement(context, state,
                                              LO_BULLET, NULL, 0);
	if (bullet == NULL)
	{
#ifdef DEBUG
		assert (state->top_state->out_of_memory);
#endif
		return(NULL);
	}

	lo_SetDefaultFontAttr(state, &tmp_attr, context);
	tmp_attr.fg.red = 0;
	tmp_attr.fg.green = 0;
	tmp_attr.fg.blue = 255;
	tptr = lo_FetchTextAttr(state, &tmp_attr);

	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 = tptr;
	FE_GetTextInfo(context, &tmp_text, &text_info);
	PA_FREE(buff);

	bullet_size = text_info.ascent + text_info.descent;

	if (bullet_size < 5)
	{
		bullet_size = 5;
	}

	bullet->type = LO_BULLET;
	bullet->ele_id = 0;
	bullet->x = margin;
	if (bullet->x < state->win_left)
	{
		bullet->x = state->win_left;
	}
	bullet->x_offset = 0;
	bullet->y = state->y;
	bullet->y_offset = 0;
	bullet->width = 5;
	bullet->height = bullet_size;
	bullet->next = NULL;
	bullet->prev = NULL;

	bullet->FE_Data = NULL;

	bullet->level = state->list_stack->level;
	bullet->bullet_type = BULLET_MQUOTE;
	bullet->text_attr = tptr;

	bullet->ele_attrmask = 0;

	bullet->sel_start = -1;
	bullet->sel_end = -1;

	state->baseline = text_info.ascent;

	return((LO_Element *)bullet);
}


static void
lo_insert_quote_characters(MWContext *context, lo_DocState *state)
{
	LO_Element *eptr;
	LO_Element *elist;
	lo_ListStack *lptr;

	elist = NULL;
	lptr = state->list_stack;
	while (lptr != NULL)
	{
		eptr = NULL;
		if (lptr->quote_type == QUOTE_JWZ)
		{
			eptr = lo_make_quote_text(context, state,
					lptr->mquote_x);
		}
		else if (lptr->quote_type == QUOTE_CITE)
		{
			eptr = lo_make_quote_bullet(context, state,
					lptr->mquote_x);
		}
		if (eptr != NULL)
		{
			eptr->lo_any.next = elist;
			elist = eptr;
		}
		lptr = lptr->next;
	}

	eptr = elist;
	while (eptr != NULL)
	{
		LO_Element *tmp_ele;

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

		tmp_ele->lo_any.ele_id = NEXT_ELEMENT;
		lo_AppendToLineList(context, state, tmp_ele, 0);
		state->line_height = (intn)tmp_ele->lo_any.height;
		state->at_begin_line = TRUE;
		state->cur_ele_type = LO_TEXT;
	}
}


void
lo_PlaceQuoteMarker(MWContext *context, lo_DocState *state, lo_ListStack *lptr)
{
	LO_Element *eptr;

	if (lptr != NULL)
	{
		eptr = NULL;
		if (lptr->quote_type == QUOTE_JWZ)
		{
			eptr = lo_make_quote_text(context, state,
					lptr->mquote_x);
		}
		else if (lptr->quote_type == QUOTE_CITE)
		{
			eptr = lo_make_quote_bullet(context, state,
					lptr->mquote_x);
		}
		if (eptr != NULL)
		{
			eptr->lo_any.ele_id = NEXT_ELEMENT;
			lo_AppendToLineList(context, state, eptr, 0);
			state->line_height = (intn)eptr->lo_any.height;
			state->at_begin_line = TRUE;
			if (lptr->quote_type == QUOTE_JWZ)
			{
				state->cur_ele_type = LO_TEXT;
			}
			else if (lptr->quote_type == QUOTE_CITE)
			{
				state->cur_ele_type = LO_BULLET;
			}
		}
	}
}


void lo_UpdateStateAfterLineBreak( MWContext *context,
                                   lo_DocState *state,
                                   Bool updateFE )
{
	int32 line_width;

	/*
	 * if this linefeed has a zero height, make it the height
	 * of the current font.
	 */
	if (state->line_height == 0)
	{
		state->line_height = state->text_info.ascent +
			state->text_info.descent;
		if ((state->line_height <= 0)&&(state->font_stack != NULL)&&
			(state->font_stack->text_attr != NULL))
		{
			lo_fillin_text_info(context, state);
			state->line_height = state->text_info.ascent +
				state->text_info.descent;
		}
		/*
		 * This should never happen, but we have it
		 * covered just in case it does :-)
		 */
		if (state->line_height <= 0)
		{
			state->line_height = state->default_line_height;
		}
	}

	if (state->end_last_line != NULL)
	{
		line_width = state->end_last_line->lo_any.x + state->win_right;
	}
	else
	{
		line_width = state->x + state->win_right;
	}

	if (line_width > state->max_width)
	{
		state->max_width = line_width;
	}

	/* if LineHeightStack exists use it to offset the new Y value */
    if(state->cur_ele_type != LO_SUBDOC && state->line_height_stack)
	{
		state->y += state->line_height_stack->height;
	}
	else
	{
		state->y = state->y + state->line_height;
	}

	state->x = state->left_margin;
	state->width = 0;
	state->at_begin_line = TRUE;
	state->trailing_space = FALSE;
	state->line_height = 0;
	state->break_holder = state->x;

	state->linefeed_state++;
	if (state->linefeed_state > 2)
	{
		state->linefeed_state = 2;
	}

	/*
	 * Reset the left and right margins
	 */
	lo_FindLineMargins(context, state, updateFE);
	state->x = state->left_margin;

}

void lo_UpdateFEProgressBar( MWContext *context, lo_DocState *state )
{
	if (state->is_a_subdoc == SUBDOC_NOT)
	{
		int32 percent;

		if (state->top_state->total_bytes < 1)
		{
			percent = -1;
		}
		else
		{
			percent = (100 * state->top_state->layout_bytes) /
				state->top_state->total_bytes;
			if (percent > 100)
			{
				percent = 100;
			}
		}
		if ((percent == 100)||(percent < 0)||
			(percent > (state->top_state->layout_percent + 1)))
		{
			if(!state->top_state->is_binary)
				FE_SetProgressBarPercent(context, percent);
			state->top_state->layout_percent = (intn)percent;
		}
	}
}

void lo_UpdateFEDocSize( MWContext *context, lo_DocState *state )
{	
	/*
	 * Tell the front end how big the document is right now.
	 * Only do this for the top level document.
	 */
	if ((state->is_a_subdoc == SUBDOC_NOT)
        &&(state->display_blocked == FALSE)
#ifdef EDITOR
		&&(!state->edit_relayout_display_blocked)
#endif
        )
	{

        /* 
         * Don't resize the layer if we're laying out a block. This
         * will be done when the line is added to the block.
         */
        if (!lo_InsideLayer(state))
		{
            LO_SetDocumentDimensions(context, state->max_width, state->y);
		}
	}
}


void lo_FillInLineFeed( MWContext *context,
                        lo_DocState *state,
                        int32 break_type,
                        uint32 clear_type,
                        LO_LinefeedStruct *linefeed )
{
	linefeed->type = LO_LINEFEED;
	linefeed->ele_id = NEXT_ELEMENT;
	linefeed->x = state->x;
	linefeed->x_offset = 0;
	linefeed->y = state->y;
	linefeed->y_offset = 0;
    /* 
     * If we're laying out a block, we want the contents of the block
     * to determine the size of the block. The right margin is nothing
     * more than a hint for where to wrap the contents. We don't want 
     * the linefeed to extend out to the right margin, because it 
     * unnecessarily extends the block contents.
     */
	if (state->layer_nest_level > 0) {
        linefeed->width = 0;
    }
    else
	linefeed->width = state->right_margin - state->x;
	if (linefeed->width < 0)
	{
		linefeed->width = 0;
	}
	linefeed->height = state->line_height;
	/*
	 * if this linefeed has a zero height, make it the height
	 * of the current font.
	 */
	if (linefeed->height == 0)
	{
		linefeed->height = state->text_info.ascent +
			state->text_info.descent;
		if ((linefeed->height <= 0)&&(state->font_stack != NULL)&&
			(state->font_stack->text_attr != NULL))
		{
			lo_fillin_text_info(context, state);
			linefeed->height = state->text_info.ascent +
				state->text_info.descent;
		}
		/*
		 * This should never happen, but we have it
		 * covered just in case it does :-)
		 */
		if (linefeed->height <= 0)
		{
			linefeed->height = state->default_line_height;
		}
	}
	linefeed->line_height = linefeed->height;

	linefeed->FE_Data = NULL;
	linefeed->anchor_href = state->current_anchor;

	if (state->font_stack == NULL)
	{
		LO_TextAttr tmp_attr;
		LO_TextAttr *tptr;

		/*
		 * Fill in default font information.
		 */
		lo_SetDefaultFontAttr(state, &tmp_attr, context);
		tptr = lo_FetchTextAttr(state, &tmp_attr);
		linefeed->text_attr = tptr;
	}
	else
	{
		linefeed->text_attr = state->font_stack->text_attr;
	}

	linefeed->baseline = state->baseline;

	linefeed->ele_attrmask = 0;

	linefeed->sel_start = -1;
	linefeed->sel_end = -1;

	linefeed->next = NULL;
	linefeed->prev = NULL;
	linefeed->break_type = (uint8) break_type;
	linefeed->clear_type = (uint8) clear_type;
}

Bool lo_CanUseBreakTable ( lo_DocState * state )
{
	Bool	multiByte;
	Bool	useBreakTable;
	
	useBreakTable = TRUE;
	
	lo_GetTextParseAtributes ( state, &multiByte );

#ifndef FAST_MULTI	
	/* 
     * We also need some sort of check for the script - for example
	 * Arabic should go through the old algorithm for now.  
     */
	if ( multiByte )
		{
		useBreakTable = FALSE;
		}
#endif
	
	/*
	 * Justified text is currently broken, route it through old layout for now
	 */
	if ( ( state->align_stack != NULL ) && 
         ( state->align_stack->alignment == LO_ALIGN_JUSTIFY ) )
		{
		useBreakTable = FALSE;
		}
		
#ifndef FAST_EDITOR
	if ( EDT_IS_EDITOR( context ) )
		{
		useBreakTable = FALSE;
		}
#endif
		
#ifdef XP_MAC
	if ( !gCallNewText )
		{
		useBreakTable = FALSE;
		}
#endif

	return useBreakTable;
}

/*
 * Is the current text that's being layed out using the break table
 * layout algorithm?  
 */
Bool lo_UseBreakTable ( LO_TextBlock * block )
{
	Bool			useBreakTable;
	
	useBreakTable = FALSE;
	
	if ( block != NULL )
		{
		if ( block->break_table != NULL )
			{
			useBreakTable = TRUE;
			}
		}
	
	return useBreakTable;
}

int32 lo_compute_text_basline_inc ( lo_DocState * state,
                                    LO_TextBlock * block,
                                    LO_TextStruct * text_data )
{
	int32	line_inc;
	int32	baseline_inc;
	
	/*
	 * The baseline of the text element just added to the line may be
	 * less than or greater than the baseline of the rest of the line
	 * due to font changes.  If the baseline is less, this is easy,
	 * we just increase y_offest to move the text down so the baselines
	 * line up.  For greater baselines, we can't move the text up to
	 * line up the baselines because we will overlay the previous line,
	 * so we have to move all the previous elements in this line down.
	 *
	 * If the baseline is zero, we are the first element on the line,
	 * and we get to set the baseline.
	 */
	
	line_inc = 0;
	baseline_inc = 0;
	
	if (state->baseline == 0)
	{
		state->baseline = block->ascent;
		if (state->line_height < (state->baseline + block->descent))
		{
			state->line_height = state->baseline + block->descent;
		}
	}
	else if (block->ascent < state->baseline)
	{
		text_data->y_offset = state->baseline - block->ascent;
		if ((text_data->y_offset + block->ascent + block->descent) > state->line_height)
		{
			line_inc = text_data->y_offset +
				block->ascent +
				block->descent -
				state->line_height;
		}
	}
	else
	{
		baseline_inc = block->ascent - state->baseline;
		if ((text_data->y_offset + block->ascent + block->descent - baseline_inc) > state->line_height)
		{
			line_inc = text_data->y_offset +
				block->ascent +
				block->descent -
				state->line_height - baseline_inc;
		}
	}

	state->baseline += (intn) baseline_inc;
	state->line_height += (intn) (baseline_inc + line_inc);
	
	return baseline_inc;
}


void lo_FlushTextElement ( MWContext * context,
                           lo_DocState * state,
                           LO_TextBlock * block,
                           LO_TextStruct * element )
{
	int32	baseline_inc;
	
	/* update the text layout state as if we had just layed this element out */
	block->buffer_read_index = element->block_offset;

	state->width = element->width;

	element->ele_id = NEXT_ELEMENT;
	element->x = state->x;
	element->y = state->y;
	element->y_offset = 0;

	element->sel_start = -1;
	element->sel_end = -1;

	baseline_inc = lo_compute_text_basline_inc ( state, block, element );
		
	element->prev = NULL;
	element->next = NULL;
	lo_AppendToLineList ( context, state, (LO_Element *) element,
                          baseline_inc );

	state->line_buf_len = 0;
	state->x += state->width;
	state->width = 0;
	state->cur_ele_type = LO_NONE;

	/* update the element list for this block */
	if ( block->startTextElement == NULL )
		{
		block->startTextElement = element;
		}

	block->endTextElement = element;
}

uint32 lo_FindBlockOffset ( LO_TextBlock * block, LO_TextStruct * fromElement )
{
	uint32			blockOffset;
	LO_Element *	endElement;
	LO_Element *	element;
	
	blockOffset = 0;
		
	if ( fromElement != NULL )
		{
		/* run through all elements in this text block. the correct
           block offset is belongs to */
		/* the previous element in this list */
		element = (LO_Element *) block->startTextElement;
		endElement = (LO_Element *) block->endTextElement;
		
		while ( element != NULL )
			{
			if ( element == endElement )
				{
				break;
				}
			
			/* is it the one we're looking for? */
			if ( element == (LO_Element *) fromElement )
				{
				break;
				}
				
			if ( element->type == LO_TEXT )
				{
				blockOffset = element->lo_text.block_offset;
				}
			
			element = element->lo_any.next;
			}
		}
		
	return blockOffset;
}

void lo_RelayoutTextElements ( MWContext * context,
                               lo_DocState * state,
                               LO_TextBlock * block,
                               LO_TextStruct * fromElement )
{
	LO_Element *	next;
	LO_Element *	element;
	LO_Element *	startElement;
	LO_Element *	endElement;
	uint32			lineWidth;
	Bool			done;
	Bool			fastPreformat;
	
	/* start at the beginning of this text block */
	block->buffer_read_index = 0;
	block->break_read_index = 0;
	
	/* we will rebuild the element list for this block as we go */
	startElement = (LO_Element *) block->startTextElement;
	endElement = (LO_Element *) block->endTextElement;

	block->startTextElement = NULL;
	block->endTextElement = NULL;
	
	if ( fromElement == NULL )
		{
		fromElement = (LO_TextStruct *) startElement;
		}
	
	/* sanity check */
	if ( fromElement == NULL )
		{
		return;
		}
	
	/*
	 * We need to run through all elements up to start element and place them
	 * back in the line list. We also need to recycle anything that's not text
	 * (linefeeds and bullets)
	 */
	element = startElement;
	
	while ( element != (LO_Element *) fromElement )
		{
		next = lo_tv_GetNextLayoutElement ( state, element, FALSE );
		
		/* if this element is text, put it on the line list */
		switch ( element->lo_any.type )
			{
			case LO_TEXT:
				lo_PrepareElementForReuse ( context, state, element,
                                            element->lo_any.edit_element,
                                            element->lo_any.edit_offset );
				lo_FlushTextElement ( context, state, block,
                                      (LO_TextStruct *) element );
				break;
			
			case LO_LINEFEED:
				/* recycle this element */
				element->lo_any.prev = NULL;
				element->lo_any.next = NULL;
				lo_RecycleElements( context, state, element );
				
				break;
			
			default:
				element->lo_any.prev = NULL;
				element->lo_any.next = NULL;
				lo_RecycleElements( context, state, element );
				break;
			}
		
		element = next;
		}
	
	/*
	 * Now, we may not need to lay any of the following elements out as out
	 * layout environment may not have changed. So, run through the remaining
	 * elements until we find the first one that's changed.
	 *
	 * We have to layout the last element using the proper code path
	 * so that we can correctly update the state record with the last
	 * break position and other flags.
	 *
	 * Column and line wrapped preformatted text can always reuse the
	 * elements as it's wrapping will never change. Word wrapped
	 * preformatted text may change if the document width changes.  
     */
	
	element = (LO_Element *) fromElement;
	done = element == endElement;
	fastPreformat = ( block->format_mode == PRE_TEXT_YES ) || ( block->format_mode == PRE_TEXT_COLS );
	
	while ( ( !done ) && ( element != NULL ) )
		{
		next = lo_tv_GetNextLayoutElement ( state, element, FALSE );
		
		/* if this element is text, see if it will fit. otherwise recycle it */
		switch ( element->lo_any.type )
			{
			case LO_TEXT:
				/* 
                 * We only assume this element can be reused if the
				 * line width is exactly the same as last time. If the
				 * line is longer, we could potentially reuse this
				 * element (the next one may appear on this line as
				 * well) but we won't be able to set the state's
				 * old_break_position, which may be needed!
				 *
				 * We can also always flush column or line wrapped
				 * preformatted text (word wrapped preformatted text
				 * may need to be layed out again as it's wrapping may
				 * change).  
                 */
				lineWidth = state->right_margin - state->x;
				
				if ( fastPreformat || ( element->lo_text.doc_width == lineWidth ) )
					{
					lo_PrepareElementForReuse ( context, state, element, element->lo_any.edit_element,
							element->lo_any.edit_offset );
					lo_FlushTextElement ( context, state, block, (LO_TextStruct *) element );
					}
				else
					{
					/* the size has changed, we must relayout this element */
					done = TRUE;
					}
				
				break;
			
			case LO_LINEFEED:
				/* recycle this element */
				element->lo_any.prev = NULL;
				element->lo_any.next = NULL;
				lo_RecycleElements( context, state, element );

				break;
			
			default:
				element->lo_any.prev = NULL;
				element->lo_any.next = NULL;
				lo_RecycleElements( context, state, element );
				break;
			}
			
		element = next;
		
		/*
		 * if we're at the last element, bail as we always need to layout this
		 * one so that the state record is updated properly
		 */
		if ( element == endElement )
			{
			break;
			}
		}
	
	/* 
     * now run through and delete all the remaining elements in this
	 * text block.  
     */
	while ( element != NULL )
		{
		next = lo_tv_GetNextLayoutElement ( state, element, FALSE );

		element->lo_any.prev = NULL;
		element->lo_any.next = NULL;
		lo_RecycleElements( context, state, element );
		
		if ( element == endElement )
			{
			break;
			}
			
		element = next;
		}
}

LO_Element * lo_RelayoutTextBlock ( MWContext * context, lo_DocState * state, LO_TextBlock * block, LO_TextStruct * fromElement )
{
	LO_Element *	next;
	LO_Element *	endElement;
	LO_Element *	lo_ele;

	state->cur_text_block = block;
	
	/*
	 * Update some of the global state information
	 */
	state->breakable = block->ele_attrmask & LO_ELE_BREAKABLE;
	
	/* get the next element for the overall relayout process */
	if ( block->endTextElement != NULL )
		{
		next = lo_tv_GetNextLayoutElement ( state, (LO_Element *) block->endTextElement, FALSE );
		}
	else
		{
		next = lo_tv_GetNextLayoutElement ( state, (LO_Element *) block, FALSE );
		}

	/* 
     * In the relayout case we might be able to skip layout for some
	 * elements that have not changed.  This happens frequenty for
	 * typing in the editor and occasionaly in table layout (very
	 * occasionally on resizes).
	 *
	 * To do this, we run through the text elements until we come
	 * across one whose width does not match the layout width or whose
	 * text has changed. That element and all others are then
	 * recycled.  
     */
	
	if ( EDT_IS_EDITOR( context ) )
		{
		/* 
         * for the editor we don't want to relayout the text elements
		 * that precede the current one. we just want to start laying
		 * out afresh from this specified element to the end of the
		 * text block. the editor will take care of merging the
		 * elements back in 
         */
		block->buffer_read_index = lo_FindBlockOffset ( block, fromElement );

		state->edit_current_element = block->edit_element;
		state->edit_current_offset = 0;
		
		/* if we're laying this element out, then we need to reinsert
           it on the line list */
		if ( ( block->startTextElement == fromElement ) || ( fromElement == NULL ) )
			{
			/* record the current edit element for later use */
			lo_PrepareElementForReuse ( context, state, (LO_Element *) block, block->edit_element,
					block->edit_offset );
			
			block->ele_id = NEXT_ELEMENT;
			block->x = state->x;
			block->y = state->y;
			block->x_offset = 0;
			block->y_offset = 0;
			
			/* free all the text elements that we're going to reflow */
			endElement = (LO_Element *) block->endTextElement;
			lo_ele = (LO_Element *) block->startTextElement;
			while ( lo_ele != NULL )
				{
				LO_Element * next_ele;
				
				next_ele = lo_ele->lo_any.next;
				
				lo_ele->lo_any.next = NULL;
				lo_ele->lo_any.prev = NULL;
				lo_RecycleElements( context, state, lo_ele );
				
				if ( lo_ele == endElement )
					{
					break;
					}
				
				lo_ele = next_ele;
				}

			block->startTextElement = NULL;
			block->endTextElement = NULL;
			
			block->prev = NULL;
			block->next = NULL;
			lo_AppendToLineList ( context, state, (LO_Element *) block, 0 );
			}
		else
			{
			LO_TextStruct * lastText;
			Bool			hitFromElement;
			
			/* We're reflowing from somewhere within the text block
			 * (past the first element). We need to reset the
			 * endTextElement as well as recycle from the fromElement
			 * to the end of the text block */
			
			hitFromElement = FALSE;
			endElement = (LO_Element *) block->endTextElement;
			lo_ele = (LO_Element *) block->startTextElement;
			lastText = block->startTextElement;

			while ( lo_ele != NULL )
				{
				LO_Element * next_ele;
				
				next_ele = lo_ele->lo_any.next;
				
				if ( lo_ele == (LO_Element *) fromElement )
					{
					hitFromElement = TRUE;
					}
					
				/* if we've found the fromElement, we need to start
                   recycling */
				if ( hitFromElement )
					{
					lo_ele->lo_any.next = NULL;
					lo_ele->lo_any.prev = NULL;
					lo_RecycleElements( context, state, lo_ele );
					}
				
				if ( lo_ele == endElement )
					{
					break;
					}
				
				/* if we haven't hit the from element and this is a
                   text element, it may be the new end */
				/* element for the block */
				if ( !hitFromElement && ( lo_ele->type == LO_TEXT ) )
					{
					lastText = &lo_ele->lo_text;
					}
				
				lo_ele = next_ele;
				}
			
			/* reset the endElement for the block */
			block->endTextElement = lastText;
			}
		}
	else
		{
		/* put the text block back in the line list and then add any
           existing elements that we can */
		block->prev = NULL;
		block->next = NULL;
		block->ele_id = NEXT_ELEMENT;
		block->x = state->x;
		block->y = state->y;
		lo_AppendToLineList ( context, state, (LO_Element *) block, 0 );

		lo_RelayoutTextElements ( context, state, block, fromElement );
		}
		
	/* Because we're lame for now we just delete all the old linefeeds
	 * and lay the text out afresh */
	
	/* Tell everybody we're laying out text */
	if (state->cur_ele_type != LO_TEXT)
		{
		lo_FreshText(state);
		state->cur_ele_type = LO_TEXT;
		}

	/* actually layout the text */
	state->preformatted = block->format_mode;
	
	if ( lo_UseBreakTable ( block ) )
		{
		lo_SetupBreakState ( block );
		
		/* be sure to set up the editor offset */
		if ( EDT_IS_EDITOR( context ) )
			{
			state->edit_force_offset = TRUE;
			state->edit_current_offset = block->buffer_read_index;
			}
			
		lo_LayoutTextBlock ( context, state, TRUE );
		}
	else
	if ( block->format_mode == PRE_TEXT_NO )
		{
		lo_LayoutFormattedText ( context, state, block );
		}
	else
		{
		lo_LayoutPreformattedText ( context, state, block );
		}
	
	/*
	 * If there's text left in the line buffer, then flush it.
	 *
	 * BRAIN DAMAGE: We don't want to do that here - there may be a
	 * following text block that continues this same text buffer.  
     */
	lo_FlushLineBuffer(context, state);
		
	return next;
}

Bool lo_ChangeText ( LO_TextBlock * block, char * text )
{
	uint32	length;
	/*
	 * Reset the text contents for this text block. If we have a break table,
	 * then we need to rebuild it.
	 */
	
#ifdef LOCAL_DEBUG
	XP_TRACE( ("Setting text for text block %lx to %s", block, text) );
#endif
	
	length = XP_STRLEN ( text ) + 1;
	if ( length > block->buffer_write_index )
		{
		if ( !lo_GrowTextBlock ( block, length - block->buffer_write_index ) )
			{
			return FALSE;
			}
		}
		
	if ( lo_UseBreakTable ( block ) )
		{
		block->buffer_write_index = 0;
		block->last_buffer_write_index = 0;
		block->break_write_index = 0;
		block->last_break_offset = 0;
		
		lo_AppendTextToBlock ( NULL, NULL, block, text );
		}
	else
		{
		/* for old style text we just want to replace the buffer */
		XP_BCOPY ( text, (char *) block->text_buffer, length );
		block->buffer_write_index = length;
		}
	
	return TRUE;
}

/*
 *
 * ===========================================================================
 * 
 *											New text layout
 *
 *  ==========================================================================
 */

/*
 * Break Table constants
 */

#define	MAX_NATURAL_LENGTH		0xAL
#define	LINE_FEED				0xBL
#define	BYTE_LENGTH				0xCL
#define	WORD_LENGTH				0xDL
#define	LONG_LENGTH				0xEL
#define	MULTI_BYTE				0xFL

#define	MULTI_BYTE_DATA_SIZE	16

/*
 * Break Position Magic Constants
 */
#define	OVERRAN_BREAK_TABLE	-1
#define	BREAK_LINEFEED		-2

#define	TEXT_BUFFER_INC		256
#define	BREAK_TABLE_INC		64

typedef struct BreakState
{
	uint32		buffer_read_index;
	uint32		break_read_index;
	uint32		multibyte_index;
	uint32		multibyte_length;
	uint32		last_line_break;
	uint32		lineLength;
} BreakState;

static LO_TextBlock * lo_CurrentTextBlock ( MWContext * context, lo_DocState * state );

/* routines to walk through our break table */
static uint8 * lo_GetNextTextPosition ( LO_TextBlock * block, uint32 * outWordLength, uint32 * outLineLength, Bool * canBreak );
static uint8 * lo_GetPrevTextPosition ( LO_TextBlock * block, uint32 * outWordLength, uint32 * outLineLength, Bool * canBreak );
static uint8 * lo_RestoreBreakState ( LO_TextBlock * block, BreakState * state, uint32 * lineLength );
static void lo_SetLineBreak ( LO_TextBlock * block, Bool skipSpace );
static uint8 * lo_GetLineStart ( LO_TextBlock * block );
static void lo_SkipCharacter ( LO_TextBlock * block );
static Bool lo_SkipInitialSpace ( LO_TextBlock * block );

static Bool lo_SetBreakPosition ( LO_TextBlock * block );
static Bool lo_SetMultiByteRun ( LO_TextBlock * block, int32 charSize, Bool breakable, Bool eachCharBreakable );
static Bool lo_SetBreakCommand ( LO_TextBlock * block, uint32 command, uint32 commandLength );
static void lo_CopyText ( uint8 * src, uint8 * dst, uint32 length );
static void lo_CopyTextToLineBuffer ( lo_DocState * state, uint8 * src, uint32 length );

static uint32  lo_FindLineBreak ( MWContext * context, lo_DocState * state, LO_TextBlock * block, uint8 * text,
	uint16 * widthTable, uint32 * width, int32 * minWidth, Bool * allTextFits );

/* the parsers */
static void lo_ParseSingleText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text );
static void lo_ParseSinglePreformattedText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text );
static void lo_ParseDoubleText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text );
static void lo_ParseDoublePreformattedText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text );

extern int32 lo_correct_text_element_width(LO_TextInfo *text_info);

#ifdef LOG
static Bool gHaveLog = FALSE;
#endif


/*
 * Some helpful macros for code inlining
 */

#define	SAVE_BREAK_STATE(block,state,line_length)				\
	(state)->buffer_read_index = (block)->buffer_read_index;	\
	(state)->break_read_index = (block)->break_read_index;		\
	(state)->multibyte_index = (block)->multibyte_index;		\
	(state)->multibyte_length = (block)->multibyte_length;		\
	(state)->last_line_break = (block)->last_line_break;		\
	(state)->lineLength = line_length;
	

static LO_TextBlock *
lo_CurrentTextBlock ( MWContext * context, lo_DocState * state )
{
	LO_TextBlock * textBlock;
	
	textBlock = state->cur_text_block;
	if ( textBlock == NULL )
		{
		textBlock = (LO_TextBlock *)lo_NewElement ( context, state, LO_TEXTBLOCK, NULL, 0 );

		textBlock->type = LO_TEXTBLOCK;
		textBlock->x_offset = 0;
		textBlock->ele_id = NEXT_ELEMENT;
		textBlock->x = state->x;
		textBlock->y = state->y;
		textBlock->y_offset = 0;
		textBlock->width = 0;
		textBlock->height = 0;
		textBlock->line_height = 0;
		textBlock->next = NULL;
		textBlock->prev = NULL;
		textBlock->text_attr = NULL;
		textBlock->anchor_href = NULL;
		textBlock->ele_attrmask = 0;
		textBlock->format_mode = 0;
		
		textBlock->startTextElement = NULL;
		textBlock->endTextElement = NULL;
		
		textBlock->text_buffer = NULL;
		textBlock->buffer_length = 0;
		textBlock->buffer_write_index = 0;
		textBlock->last_buffer_write_index = 0;
		textBlock->buffer_read_index = 0;
		textBlock->last_line_break = 0;
		
		textBlock->break_table = NULL;
		textBlock->break_length = 0;
		textBlock->break_write_index = 0;
		textBlock->break_read_index = 0;
		textBlock->last_break_offset = 0;
		textBlock->multibyte_index = 0;
		textBlock->multibyte_length = 0;
		
		textBlock->old_break = NULL;
		textBlock->old_break_pos = 0;
		textBlock->old_break_width = 0;
		
		textBlock->totalWidth = 0;
		textBlock->totalChars = 0;
		textBlock->break_pending = 0;
		textBlock->last_char_is_whitespace = 0;
		
		textBlock->ascent = 0;
		textBlock->descent = 0;
		
		/* BRAIN DAMAGE: Add this enum to lo_ele.h! */
		textBlock->text_buffer = XP_ALLOC ( TEXT_BUFFER_INC );
		textBlock->buffer_length = TEXT_BUFFER_INC;
		
		textBlock->break_table = XP_ALLOC ( BREAK_TABLE_INC );
		textBlock->break_length = BREAK_TABLE_INC * 2;
		
		/* Since we're creating a new text block, grab some of the
		 * text state out of the layout state.  */
		textBlock->anchor_href = state->current_anchor;
		
		if ( state->font_stack != NULL )
			{
			textBlock->text_attr = state->font_stack->text_attr;
			}
			
		if (state->breakable != FALSE)
			{
			textBlock->ele_attrmask |= LO_ELE_BREAKABLE;
			}
		
		state->cur_text_block = textBlock;		
		
		lo_AppendToLineList ( context, state, (LO_Element *) textBlock, 0 );
		}
	
	return textBlock;
}

void lo_AppendTextToBlock ( MWContext *context, lo_DocState *state, LO_TextBlock * block, char *text )
{
	Bool	parseAllText;
	Bool	multiByte;
	
	/*
	 * We have several cases in which we can just bail:
	 *	1. The text string and the line buffer is empty.
	 *	2. The text string is all whitespace and we already have a trailing 
     *     space.
	 */
	
	if ( ( state != NULL ) && ( state->line_buf_len == 0 ) )
		{
		char *	t_ptr;

		/* if this string is empty, bail */
		if ( *text == '\0' )
			{
			return;
			}
		
		/* if it's only whitespace and we have a trailing space, then bail */
		if ( state->trailing_space )
			{
			t_ptr = text;
			
			while ( *t_ptr != '\0' )
				{
				if ( !XP_IS_SPACE( *t_ptr ) )
					{
					break;
					}
				
				++t_ptr;
				}
			
			if ( ( *t_ptr == '\0' ) && ( t_ptr != text ) )
				{
				return;
				}
			}
		}
	
	/* If we don't have a block, create one if we have a valid state
	 * record. Otherwise we have an error */
	
	if ( block == NULL )
		{
		/* the editor may call us with a NULL state and context
           record, in this case we must always have a block */
		XP_ASSERT(( state != NULL ) && ( context != NULL ));
		if ( ( state != NULL ) && ( context != NULL ) )
			{
			block = lo_CurrentTextBlock ( context, state );
			}
		}
	
	/* OPTIMIZATION: If the parser could tell us if we have a split
	 * buffer then we could intelligently set parseAllText here and
	 * not buffer words that we think may be split across a buffer but
	 * in reality are whole.  */
	 
	/* If we're in an editor context, then we can always parse the
	 * whole buffer of text, we never need to worry about partial
	 * buffers being passed to us.  */
	parseAllText = EDT_IS_EDITOR( context );
		
	/* Scan through the text, removing whitespace and adding words to
	 * the text buffer as we come across them.
	 *
	 * Particular things we have to deal with:
	 *		- Preformatted text (normal, word wrapped and column wrapped)
	 *		- Normal single byte text
	 *		- Multibyte text
	 *      - non-breaking spaces 
     */
	
	lo_GetTextParseAtributes ( state, &multiByte );

	if ( FALSE || multiByte )
		{
		lo_ParseDoubleText ( state, block, parseAllText, text );
		}
	else
		{
		lo_ParseSingleText ( state, block, parseAllText, text );
		}
}

static void
lo_GetTextParseAtributes ( lo_DocState * state, Bool * multiByte )
{
	int16	charset;
	
	*multiByte = FALSE;
	
	if ( state != NULL )
		{
		charset = state->font_stack->text_attr->charset;
		if ( (INTL_CharSetType ( charset ) != SINGLEBYTE ) && !( INTL_CharSetType ( charset ) & CS_SPACE ) )
			{
			*multiByte = TRUE;
			}
		}
}

static void
lo_ParseSingleText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text )
{
	uint8 *			t_ptr;
	uint8 *			w_start;
	uint8 *			w_end;
	uint8 *			line_buff;
	uint32			w_length;
	Bool			skipped_space;
	uint32			textLength;
	
	/* check for textTransform properties and aply them */
	if( ( state != NULL ) && ( state->top_state && state->top_state->style_stack ) )
		{
		char * property;
		
		StyleStruct *style_struct = STYLESTACK_GetStyleByIndex( state->top_state->style_stack, 0);

		if( style_struct )
			{
			property = STYLESTRUCT_GetString(style_struct, TEXT_TRANSFORM_STYLE);
			if(property)
				{
				lo_transform_text_from_string_method(text, property);
				}
			}
		}

	t_ptr = (uint8 *) text;
	skipped_space = FALSE;	
	
	if ( ( state != NULL ) && ( state->line_buf_len > 0 ) )
		{
		PA_LOCK(line_buff, uint8 *, state->line_buf);
		textLength = state->line_buf_len;
		
		if ( *line_buff == '\0' )
			{
			line_buff = NULL;
			textLength = 0;
			state->line_buf_len = 0;
			}
		}
	else
		{
		line_buff = NULL;
		textLength = 0;
		}
		
	/* Make sure the text block has enough space to hold this block of text */
	textLength += XP_STRLEN ( text );
	lo_GrowTextBlock ( block, textLength + 1 );
	
	/*
	 * If there's anything in the line buffer, then pull that out now
	 */
	if ( line_buff != NULL )
		{
		/* was there any trailing space left for us? */
		skipped_space = state->trailing_space;
			
		/* skip any white space at the head of our text */
		while ( ( *line_buff != '\0' ) && XP_IS_SPACE ( *line_buff ) )
			{
			line_buff++;
			state->line_buf_len--;
			skipped_space = TRUE;
			}
		
		/*
		 * if we skipped any space and we're not at the end of the buffer, 
		 * then insert a break position
		 */
		if ( *line_buff != '\0' )
			{
			if ( skipped_space )
				{
				if ( !lo_SetBreakPosition ( block ) )
					{
					state->top_state->out_of_memory = TRUE;
					return;
					}
				
				/* If the space was real whitespace and not a trailing
				 * space from a previous layout, then copy the space
				 * to the text block.  */
				if ( !state->trailing_space )
					{
					block->text_buffer[ block->buffer_write_index ] = ' ';
					block->buffer_write_index++;
					block->last_buffer_write_index++;
					skipped_space = TRUE;
					}

				skipped_space = FALSE;
				}
			
			/* copy in the line buffer. it is only allowed to be one word */
			lo_CopyText ( line_buff, &block->text_buffer[ block->buffer_write_index ], state->line_buf_len );
			block->buffer_write_index += state->line_buf_len;
			state->line_buf_len = 0;
			}
		}
	
	/* The last chunk of text may have left a single piece of
	 * whitespace at the end of the buffer. If so, we need to skip any
	 * whitespace at the front of the buffer so we don't have to worry
	 * about this inside the main loop.
	 *
	 * When called from the editor, we may not have a state
	 * record. However, we also won't need to worry about this case as
	 * it will have taken care of it for us.  */
	if ( ( state != NULL ) && ( state->trailing_space ) && ( *t_ptr != '\0' ) )
		{
		skipped_space = TRUE;
		
		while ( ( *t_ptr != '\0' ) && XP_IS_SPACE ( *t_ptr ) )
			{
			t_ptr++;
			}
		}
	
	while ( *t_ptr != '\0' )
		{
		w_start = t_ptr;
		
		/* skip past any whitespace before this word. */
		while ( ( *w_start != '\0' ) && XP_IS_SPACE ( *w_start ) )
			{
			w_start++;
			}
						
		/* run through the text and find the end of the word */
		w_end = w_start;
		w_length = 0;
		
		while ( ( *w_end != '\0' ) && !XP_IS_SPACE ( *w_end ) )
			{
			w_end++;
			w_length++;
			}

		/* If we hit the end of the buffer then we may be inside a
		 * partial word. This can cause problems with interword
		 * kerning, multibyte characters and other contextually
		 * sensitive script systems.
		 *
		 * We buffer this word in the line_buff. If this is truly the
		 * end of the text, then we'll be called to flush the last
		 * line. We'll do this by appending this word to our text
		 * block and then laying out the last of the text.
		 *
		 * If this word is just split across a buffer, then it will be
		 * inserted to the beginning of the next text block.
		 *
		 * If the caller tells us to parse the whole buffer, then we
		 * don't care.  */
		
		if ( !parseAllText && ( *w_end == '\0' ) && ( w_length > 0 ) && ( state != NULL ) )
			{
			if ( w_start != t_ptr )
				{
				/* put a space in the line buffer */
				lo_CopyTextToLineBuffer ( state, (uint8 *) " ", 1 );
				if ( state->top_state->out_of_memory )
					{
					return;
					}
				}
				
			/* put this text in the line buffer */
			lo_CopyTextToLineBuffer ( state, w_start, w_length );
			if ( state->top_state->out_of_memory )
				{
				return;
				}
				
			/* we now have text after the whitespace */
			skipped_space = FALSE;
			
			break;
			}
					
		/* If we skipped some white space, then we know that we can
		 * put a break here.  */
		if ( w_start != t_ptr )
			{
			skipped_space = TRUE;
			
			/* add the break position */
			if ( !lo_SetBreakPosition ( block ) )
				{
				if ( state != NULL )
					{
					state->top_state->out_of_memory = TRUE;
					}
				return;
				}

			if ( block->buffer_length < ( block->buffer_write_index + 1 ) )
				{
				if ( !lo_GrowTextBlock ( block, 1 ) )
					{
					if ( state != NULL )
						{
						state->top_state->out_of_memory = TRUE;
						}
					return;
					}
				}
			
			block->text_buffer[ block->buffer_write_index ] = ' ';
			block->buffer_write_index++;
			
			/* BRAIN DAMAGE: Add a new field to the text block struct
			 * to indicate how many chars to skip when calculating the
			 * length of the next run.  */
			block->last_buffer_write_index++;
			}
		else
			{
			skipped_space = FALSE;
			}
		
		/* if we found anything, add it to the buffer */
		if ( w_length > 0 )
			{
			if ( block->buffer_length < ( block->buffer_write_index + w_length ) )
				{
				if ( !lo_GrowTextBlock ( block, w_length ) )
					{
					if ( state != NULL )
						{
						state->top_state->out_of_memory = TRUE;
						}
					return;
					}
				}
			
			lo_CopyText ( w_start, &block->text_buffer[ block->buffer_write_index ], w_length );
			block->buffer_write_index += w_length;
			
			/* we now have text after the whitespace */
			skipped_space = FALSE;
			}
		
		t_ptr = w_end;
		}
		
		/*
		 * Remember whether the last thing we added was whitespace
		 */
		block->last_char_is_whitespace = skipped_space;
}


/*
 * Parse State Table for two byte text
 */

typedef enum {
	kUnprohibited = PROHIBIT_NOWHERE,
	kBeginProhibited = PROHIBIT_BEGIN_OF_LINE,
	kEndProhibited = PROHIBIT_END_OF_LINE,
	kWordBreakProhibited = PROHIBIT_WORD_BREAK,
	kSingleByte,
	kBreakableSpace,
	kFlushFinalRun,
	kNumCharTypes
} ParseState;

/*
 * Flags for the state table command
 */

#define	SET_BREAKABLE			0x01		/* dump the current run as a single breakable run */
#define	SET_MULTI_BREAKABLE		0x02		/* dump the current run as a mutibyte breakable run */
#define	DUMP_TEXT_AND_BREAK		0x04		/* dump the text to the buffer with no break point and then stop processing */
#define	CARRY_LAST_CHAR			0x08		/* move the last char of this run into the next state */
#define	INC_RUN_LENGTH			0x10		/* inc the length of this run (we could do without this one) */
#define	INSERT_WHITESPACE		0x20		/* insert a single whitespace into the text buffer */
#define	SKIP_CHAR				0x40		/* skip the current char */
#define	MAINTAIN_CHAR_TYPE		0x80		/* don't change the curCharType */

/*
 * Things to Note:
 *
 * 1. SET_BREAKABLE means to insert a normal break command. This run can 
 *    be broken at the end of the run.
 * 2. SET_MULTI_BREAKABLE means that we have a run which can be broken at 
 *    the end of every character.
 *
 */

/*
 * The mutibyte breakable run data word is 16 bits big. It is organized as:
 *
 *	BIT:	15	14	13			12	11	10	9	8	7	6	5	4	3	2	1	0
 *	FIELD:	CHAR SIZE			RUN LENGTH
 */

#define	MULTI_CHAR_SIZE_MASK	0xE000
#define	MULTI_CHAR_SIZE_SHIFT	12

#define	MULTI_LENGTH_MASK		0x1FFF

/*
 * The state table
 */

static uint8 gParseTable[ kNumCharTypes ][ kNumCharTypes ] = 
{
	/*	current char			next char					operations */
	
/* Unprohibited two byte text */
	/*	kUnprohibited,			kUnprohibited,			*/	INC_RUN_LENGTH,
	/*	kUnprohibited,			kBeginProhibited,		*/	SET_MULTI_BREAKABLE + CARRY_LAST_CHAR,
	/*	kUnprohibited,			kEndProhibited,			*/	SET_MULTI_BREAKABLE,
	/*	kUnprohibited,			kWordBreakProhibited,	*/	SET_MULTI_BREAKABLE,
	/*	kUnprohibited,			kSingleByte,			*/	SET_MULTI_BREAKABLE,
	/*	kUnprohibited,			kBreakableSpace,		*/	SET_MULTI_BREAKABLE + INSERT_WHITESPACE + SKIP_CHAR,
	/*	kUnprohibited,			kFlushFinalRun,			*/	SET_MULTI_BREAKABLE,
	
/* Begin Line Prohibited two byte text */
	/*	kBeginProhibited,		kUnprohibited,			*/	SET_BREAKABLE,
	/*	kBeginProhibited,		kBeginProhibited,		*/	INC_RUN_LENGTH,
	/*	kBeginProhibited,		kEndProhibited,			*/	SET_BREAKABLE,
	/*	kBeginProhibited,		kWordBreakProhibited,	*/	SET_BREAKABLE,
	/*	kBeginProhibited,		kSingleByte,			*/	SET_BREAKABLE,
	/*	kBeginProhibited,		kBreakableSpace,		*/	SET_BREAKABLE + INSERT_WHITESPACE + SKIP_CHAR,
	/*	kBeginProhibited,		kFlushFinalRun,			*/	DUMP_TEXT_AND_BREAK,
	
/* End Line Prohibited two byte text */
	/*	kEndProhibited,			kUnprohibited,			*/	INC_RUN_LENGTH + SET_BREAKABLE,
	/*	kEndProhibited,			kBeginProhibited,		*/	INC_RUN_LENGTH + SET_BREAKABLE,
	/*	kEndProhibited,			kEndProhibited,			*/	INC_RUN_LENGTH,
	/*	kEndProhibited,			kWordBreakProhibited,	*/	INC_RUN_LENGTH,
	/*	kEndProhibited,			kSingleByte,			*/	INC_RUN_LENGTH,
	/*	kEndProhibited,			kBreakableSpace,		*/	INC_RUN_LENGTH + MAINTAIN_CHAR_TYPE,	/* BIZZARE CASE! */
	/*	kEndProhibited,			kFlushFinalRun,			*/	DUMP_TEXT_AND_BREAK,					/* not much we can do here */
	
/* Word Break Prohibited two byte text */
	/*	kWordBreakProhibited,	kUnprohibited,			*/	SET_BREAKABLE,
	/*	kWordBreakProhibited,	kBeginProhibited,		*/	INC_RUN_LENGTH,
	/*	kWordBreakProhibited,	kEndProhibited,			*/	SET_BREAKABLE,
	/*	kWordBreakProhibited,	kWordBreakProhibited,	*/	INC_RUN_LENGTH,
	/*	kWordBreakProhibited,	kSingleByte,			*/	INC_RUN_LENGTH,
	/*	kWordBreakProhibited,	kBreakableSpace,		*/	SET_BREAKABLE + INSERT_WHITESPACE + SKIP_CHAR,
	/*	kWordBreakProhibited,	kFlushFinalRun,			*/	DUMP_TEXT_AND_BREAK,
	
/* Single byte text */
	/*	kSingleByte,			kUnprohibited,			*/	SET_BREAKABLE,
	/*	kSingleByte,			kBeginProhibited,		*/	INC_RUN_LENGTH,
	/*	kSingleByte,			kEndProhibited,			*/	SET_BREAKABLE,
	/*	kSingleByte,			kWordBreakProhibited,	*/	SET_BREAKABLE,
	/*	kSingleByte,			kSingleByte,			*/	INC_RUN_LENGTH,
	/*	kSingleByte,			kBreakableSpace,		*/	SET_BREAKABLE + INSERT_WHITESPACE + SKIP_CHAR,
	/*	kSingleByte,			kFlushFinalRun,			*/	DUMP_TEXT_AND_BREAK,
	
/* Single byte breakable space */
	/*	kBreakableSpace,		kUnprohibited,			*/	0,
	/*	kBreakableSpace,		kBeginProhibited,		*/	0,
	/*	kBreakableSpace,		kEndProhibited,			*/	0,
	/*	kBreakableSpace,		kWordBreakProhibited,	*/	0,
	/*	kBreakableSpace,		kSingleByte,			*/	0,
	/*	kBreakableSpace,		kBreakableSpace,		*/	SKIP_CHAR,
	/*	kBreakableSpace,		kFlushFinalRun,			*/	0,
	
/* These are never hit */
	/*	kFlushFinalRun,			kUnprohibited,			*/	0,
	/*	kFlushFinalRun,			kBeginProhibited,		*/	0,
	/*	kFlushFinalRun,			kEndProhibited,			*/	0,
	/*	kFlushFinalRun,			kWordBreakProhibited,	*/	0,
	/*	kFlushFinalRun,			kSingleByte,			*/	0,
	/*	kFlushFinalRun,			kBreakableSpace,		*/	0,
	/*	kFlushFinalRun,			kFlushFinalRun,			*/	0,
};

static void
lo_ParseDoubleText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text )
{
	char *			tptr;
	char *			wordStart;
	char *			nextWordStart;
	int32			runLength;
	int32			nextRunLength;
	int32			curCharBytes;
	int32			nextCharBytes;
	int16			charset;
	ParseState		curCharType;
	ParseState		nextCharType;
	uint8			parseCommand;
	uint32			textLength;
	Bool			startNewRun;
	Bool			eachCharBreakable;
	Bool			processLastRun;
	
	tptr = text;
	wordStart = text;
	runLength = 0;
	
	textLength = 0;
	
	processLastRun = FALSE;
	
	/* BRAIN DAMAGE: We need to see if there's anything in the line
       buffer for us */
	
	/* Make sure the text block has enough space to hold this block of text */
	textLength += XP_STRLEN ( text );
	lo_GrowTextBlock ( block, textLength + 1 );

	charset = block->text_attr->charset;
	curCharType = kSingleByte;
	curCharBytes = 1;
	
	eachCharBreakable = FALSE;
	
	/* if we have a trailing space, then set our state to be a space */
	if ( state->trailing_space )
		{
		curCharType = kBreakableSpace;
		runLength = curCharBytes;
		}
	
	startNewRun = FALSE;
		
	while ( ( *tptr != '\0' ) || processLastRun )
		{
		if ( processLastRun )
			{
			/* force the last run to be flushed */
			nextCharType = kFlushFinalRun;
			nextCharBytes = 0;
			}
		else
			{		
			/* do we have an ascii char? */
			if ( ( (unsigned char) *tptr ) <= 0x7F )
				{
				nextCharBytes = 1;
				
				/* is the next char a breakable space? */
				if ( XP_IS_SPACE( *tptr ) )
					{
					nextCharType = kBreakableSpace;
					}
				else
				/* it's a normal char */
					{
					nextCharType = kSingleByte;
					}
				}
			else
				{
				/* multibyte, do that international thing */
				nextCharBytes = INTL_CharLen( charset, (unsigned char *) tptr);
				nextCharType = (ParseState) INTL_KinsokuClass( charset, (unsigned char *) tptr );
				}
			}
		
		/* now get our parse command */
		parseCommand = gParseTable[ curCharType ][ nextCharType ];
		nextRunLength = nextCharBytes;
		nextWordStart = tptr;
		
		/* Unprohibited multibyte check - we need to catch cases where
		 * our byte size changes. We might want to add a command bit
		 * for this check, for now I shall do it this way.  */
		
		if ( ( curCharType == kUnprohibited ) && ( nextCharType == kUnprohibited ) )
			{
			if ( nextCharBytes != curCharBytes )
				{
				/* ok, our char size changed. we need to dump this run */
				parseCommand |= SET_BREAKABLE;
				}
			}
			
		/* process the command */
		if ( parseCommand & CARRY_LAST_CHAR )
			{
			/* move the last char of this run into the next run */
			runLength -= curCharBytes;
			nextWordStart -= curCharBytes;
			
			/* and move the carried char of the previous run to the next one */
			nextRunLength = curCharBytes + nextCharBytes;
			
			/* if the old run is empty, we don't want to do anything else  */
			if ( runLength == 0 )
				{
				parseCommand = 0;
				startNewRun = TRUE;
				}
			}
			
		if ( parseCommand & INC_RUN_LENGTH )
			{
			runLength += nextCharBytes;
			}

		if ( parseCommand & SET_BREAKABLE )
			{
			lo_CopyText ( (uint8 *) wordStart, &block->text_buffer[ block->buffer_write_index ], runLength );
			block->buffer_write_index += runLength;
			
			/* set a breakable run */
			lo_SetBreakPosition ( block );
				
			startNewRun = TRUE;
			}

		if ( parseCommand & SET_MULTI_BREAKABLE )
			{
			lo_CopyText ( (uint8 *) wordStart, &block->text_buffer[ block->buffer_write_index ], runLength );
			block->buffer_write_index += runLength;
			
			/* set an unbreakable run */
			lo_SetMultiByteRun ( block, curCharBytes, TRUE, eachCharBreakable );
			startNewRun = TRUE;
			}
		
		if ( parseCommand & DUMP_TEXT_AND_BREAK )
			{
			/* copy the text out but don't set a break (only happens
               when flushing at the end) */
			lo_CopyText ( (uint8 *) wordStart, &block->text_buffer[ block->buffer_write_index ], runLength );
			block->buffer_write_index += runLength;
			
			/* now break out of the loop - we're done */
			break;
			}
			
		if ( startNewRun )
			{
			wordStart = nextWordStart;
			runLength = nextRunLength;
			startNewRun = FALSE;
			}
		
		if ( parseCommand & SKIP_CHAR )
			{
			wordStart++;
			}
		
		if ( parseCommand & INSERT_WHITESPACE )
			{
			block->text_buffer[ block->buffer_write_index ] = ' ';
			block->buffer_write_index++;
			block->last_buffer_write_index++;
			}
		
		curCharBytes = nextCharBytes;
		
		if ( !( parseCommand & MAINTAIN_CHAR_TYPE ) )
			{
			curCharType = nextCharType;
			}
			
		eachCharBreakable = curCharType == kUnprohibited;
		
		tptr += nextCharBytes;
		
		/* if we got here with processLastRun, then we need to bail */
		if ( processLastRun )
			{
			break;
			}
			
		/* if we're on the last character, then we may have a partial
		 * run left over. if we're parsing all text then we need to
		 * dump it.  */
		if ( parseAllText && ( *tptr == 0 ) && ( runLength > 0 ) )
			{
			processLastRun = TRUE;
			}
		}
	
	/* if we've ended and we have a run, then we need to save it in
       the line buffer */
	if ( ( runLength > 0 ) && ( *wordStart != 0 ) )
		{
		lo_CopyTextToLineBuffer ( state,(uint8 *)  wordStart, runLength );
		}
}

static void
lo_FlushText ( MWContext * context, lo_DocState * state )
{
	LO_TextBlock *	block;
	Bool			multiByte;
	char *			text_buf;
	
	block = state->cur_text_block;
	
	if ( block != NULL )
		{
		lo_GetTextParseAtributes ( state, &multiByte );
		
		/* add any text to the text block that may be sitting in the
           line buffer */
		/* BRAIN DAMAGE: These should both be handled the same way */
		if ( multiByte )
			{
			if ( state->line_buf_len > 0 )
				{
				PA_LOCK(text_buf, char *, state->line_buf);
				lo_ParseDoubleText ( state, block, TRUE, text_buf );
				PA_UNLOCK(state->line_buf);
				}
			}
		else
			{
			lo_AppendTextToBlock ( context, state, block, "" );
			}
			
		lo_LayoutTextBlock ( context, state, TRUE );
		}
}

static void
lo_SetupBreakState ( LO_TextBlock * block )
{
	Bool			canBreak;
	uint32			wordLength;
	uint32			lineLength;
	uint8 *			runEnd;
	uint32			searchReadIndex;
	BreakState		breakState;
	
	searchReadIndex = block->buffer_read_index;
	
	block->buffer_read_index = 0;
	block->break_read_index = 0;
	block->last_line_break = 0;

	/* We need to update our state to be at the current text position
	 * (specified by buffer_read_index) */
	
	lineLength = 0;

	/* run through the break table until we get to the correct read index */
	while ( block->buffer_read_index < searchReadIndex )
		{
		SAVE_BREAK_STATE ( block, &breakState, lineLength );			
				
		runEnd = lo_GetNextTextPosition ( block, &wordLength, &lineLength, &canBreak );
		if ( runEnd == NULL )
			{
			/* this should not happen, but just in case, let's do
               something kinda reasonable */
			lo_RestoreBreakState ( block, &breakState, NULL );
			break;
			}
		}

	/* If we're not at the beginning of the text buffer, then we need
	 * to increment buffer_read_index so that we skip the breakable
	 * space we're currently at.  */
	if ( ( block->buffer_read_index > 0 ) && XP_IS_SPACE ( block->text_buffer[ block->buffer_read_index ] ) )
		{
		block->buffer_read_index++;
		}
		
	block->last_line_break = block->buffer_read_index;
}

void lo_LayoutTextBlock ( MWContext * context, lo_DocState * state, Bool flushLastLine )
{
	LO_TextBlock *	block;
	Bool			allTextFits;
	Bool			canBreakAtStart;
	LO_TextStruct *	text_data;
	LO_TextStruct	msTextData;
	uint32			width;
	uint32			lineLength;
	uint8 *			text;
	int32			baseline_inc;
	int32			line_inc;
	int32			minWidth;
	int32 *			minWidthPtr;
	BreakState		breakState;
	uint16 *		charLocs;
	Bool			freeMeasureBuffer;
	Bool			justify;
	
	block = state->cur_text_block;
	if ( block == NULL )
		{
		return;
		}
	
	justify = ( state->align_stack != NULL ) && ( state->align_stack->alignment == LO_ALIGN_JUSTIFY );
		
	/* bail if we're at the end of this block */
	if ( block->buffer_read_index == block->buffer_write_index )
		{
		/* if there's also no text in the line buffer, clear this block */
		if ( state->line_buf_len == 0 )
			{
			state->cur_ele_type = LO_NONE;
			state->cur_text_block = NULL;
			state->trailing_space = block->last_char_is_whitespace;
			}
		return;
		}
	
	lineLength = 0;
	
	charLocs = NULL;
	freeMeasureBuffer = FALSE;
	
	/* find the width of an average character */
	if ( block->totalWidth == 0 )
		{
		memset (&msTextData, 0, sizeof (LO_TextStruct));
		msTextData.text = (PA_Block) "aeiou";
		msTextData.text_attr = block->text_attr;
		msTextData.text_len = 5;
		
		FE_GetTextInfo ( context, &msTextData, &state->text_info );
		block->totalWidth = state->text_info.max_width;
		block->totalChars = msTextData.text_len;
		}

#ifdef XP_MAC
	/* do a quick test to see if we could overflow a UInt16 */
	if ( ( block->buffer_write_index * block->totalWidth / block->totalChars ) < 65535 )
		{
		/* measure the text using the fast measure text */
		if ( ( block->buffer_write_index + 1 ) < kStaticMeasureTextBufferSize )
			{
			charLocs = gMeasureTextBuffer;
			}
		else
			{
			charLocs = XP_ALLOC( ( block->buffer_write_index + 1 ) * sizeof(uint16) );
			freeMeasureBuffer = TRUE;
			}
			
		if ( charLocs != NULL )
			{
			memset (&msTextData, 0, sizeof (LO_TextStruct));
			msTextData.text = (PA_Block) block->text_buffer;
			msTextData.text_attr = block->text_attr;
			msTextData.text_len = block->buffer_write_index;
			FE_MeasureText ( context, &msTextData, (int16 *) charLocs );
			
			/* BRAIN DAMAGE: We need to figure out for sure if the
               width has ever exceeded a uint16! */
			/* the actual interface for MeasureText says it takes an
               array of signed ints, however */
			/* the data stuffed in there is unsigned (we quickly
               overflow a int16 with an 8Kb buffer) */
			}
		}
#endif
	
	/* Given the current layout state, run through this text block and
	 * convert all that we can into text elements.  If flushLastLine
	 * is set, we want to flush all the text, rather than keeping the
	 * last bit in case more text comes.  */
	
	allTextFits = FALSE;
	
	/* if we're laying out a table, then we need to calculate min widths */
	minWidthPtr = state->need_min_width ? &minWidth : NULL;
	
	while ( !allTextFits )
		{
		canBreakAtStart = FALSE;

		/* Save the current break state in case we need to delay on
           the last line */
		SAVE_BREAK_STATE ( block, &breakState, lineLength );
				
		/* We need to handle the case where we're at the beginning of
		 * the line and the first character is a breakable space.  */
		if ( state->at_begin_line )
			{
			canBreakAtStart = lo_SkipInitialSpace ( block );
#ifdef LOG
			PR_LogPrint ( "canBreakAtStart: %d\n", canBreakAtStart );
			PR_LogFlush();
#endif
			}
		
		/* we're looking for a new break position */
		state->break_pos = -1;
		state->break_width = -1;

		text = lo_GetLineStart ( block );
				
		lineLength = lo_FindLineBreak ( context, state, block, text, charLocs, &width, minWidthPtr, &allTextFits );

		/* update the state's min_width if we need to - this will be
           constant even if we don't flush this line */
		if ( minWidthPtr != NULL )
			{
			if ( minWidth > state->min_width )
				{
				state->min_width = minWidth;
				}
			}
		
		/* if this line is too long, we either need to break at the
		 * beginning of the run (if we can) or break at an old
		 * element. If we can't do either of those then we just have
		 * to make the line too big */
		
		if ( ( width > ( state->right_margin - state->x ) ) && ( state->x > state->left_margin ) )
			{
			/* could we have broken at the start of this line? */
			if ( canBreakAtStart )
				{
#ifdef LOG
				PR_LogPrint ( "Too long - Breaking at the start of the line\n" );
				PR_LogFlush();
#endif

				/* break the line here */
				lo_SoftLineBreak( context, state, TRUE );
				
				/* BUG BUG: We're restoring the break state to the
				 * beginning of the buffer - ie to before the space we
				 * skipped above. We need to fix the space skipping
				 * mechanism to remove this case (we can go into an
				 * infinite loop here if there's not enough space for
				 * the first word).
				 *
				 * Should be able to have a new flag "canSkipSpace"
				 * but then actually don't skip it. Then if the line
				 * does fit and it's at the beginning, we can skip the
				 * space. lo_FindLineBreak should probably be the one
				 * to do this work so that the width we get back is
				 * correct.  */
				lo_RestoreBreakState ( block, &breakState, NULL );
				
				/* if all the text fits (ie there was only an
				 * unbreakable run left in this block), then we need
				 * to stick with this break position. Otherwise we can
				 * go find a new one */
				if ( !allTextFits )
					{
					continue;
					}
				}
			else
			/* do we have an old break position we can use? */
			if ( state->old_break_pos != -1 )
				{
#ifdef LOG
				PR_LogPrint ( "Too long - Breaking at the old_break_pos: %ld, width %ld\n"
					state->old_break_pos, state->old_break_width );
				PR_LogFlush();
#endif
				lo_BreakOldElement ( context, state );
				lo_RestoreBreakState ( block, &breakState, NULL );
				
				/* if all the text fits (ie there was only an
				 * unbreakable run left in this block), then we need
				 * to stick with this break position. Otherwise we can
				 * go find a new one */
				if ( !allTextFits )
					{
					continue;
					}
				}
			
			/* we're screwed, we just have to make this line too long */
			}
						
		/* We may not necessarily want to flush the whole buffer out
		 * to layout elements (the case where were processing part of
		 * a text chunk based on what netlib has streamed to us).
		 *
		 * We know we do want to flush this next line out if we still
		 * have more text in this buffer to process or layout really
		 * does want us to flush this whole buffer (because some other
		 * element is after us).  */
		if ( !allTextFits || flushLastLine )
			{
			state->width = width;

			if ( lineLength > 0 )
				{
				text_data = (LO_TextStruct *)lo_NewElement ( context, state, LO_TEXT, NULL, 0 );
				if (text_data == NULL)
					{
#ifdef DEBUG
					assert (state->top_state->out_of_memory);
#endif
					break;
					}

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

				text_data->text = (PA_Block) text;
				text_data->text_len = lineLength;

				text_data->anchor_href = block->anchor_href;
				text_data->text_attr = block->text_attr;
				text_data->ele_attrmask = block->ele_attrmask;
				
				/* BRAIN DAMAGE: Set LO_ELE_INVISIBLE to mark the
                   element as not having a valid text ptr */
				XP_ASSERT ( !(text_data->ele_attrmask & LO_ELE_INVISIBLE ) );
				text_data->ele_attrmask |= LO_ELE_INVISIBLE;
				
				text_data->sel_start = -1;
				text_data->sel_end = -1;

				text_data->doc_width = state->right_margin - state->x;
				text_data->doc_width = 0;
				text_data->block_offset = block->buffer_read_index;
				XP_ASSERT(block->buffer_read_index <= 65535);
					
				/*
				 * Some fonts (particulatly italic ones with curly tails
				 * on letters like 'f') have a left bearing that extends
				 * back into the previous character.  Since in this case the
				 * previous character is probably not in the same font, we
				 * move forward to avoid overlap.
				 *
				 * Those same funny fonts can extend past the last
				 * character, and we also have to catch that, and
				 * advance the following text to eliminate cutoff.  */
				if ( state->text_info.lbearing < 0 )
					{
					text_data->x_offset = state->text_info.lbearing * -1;
					}
					
				baseline_inc = 0;
				line_inc = 0;
				
				/* The baseline of the text element just added to the
				 * line may be less than or greater than the baseline
				 * of the rest of the line due to font changes.  If
				 * the baseline is less, this is easy, we just
				 * increase y_offest to move the text down so the
				 * baselines line up.  For greater baselines, we can't
				 * move the text up to line up the baselines because
				 * we will overlay the previous line, so we have to
				 * move all the previous elements in this line down.
				 *
				 * If the baseline is zero, we are the first element
				 * on the line, and we get to set the baseline.  */
				if ( state->baseline == 0 )
					{
					state->baseline = state->text_info.ascent;
					if (state->line_height < 
						(state->baseline + state->text_info.descent))
						{
						state->line_height = state->baseline +
							state->text_info.descent;
						}
					}
				else if ( state->text_info.ascent < state->baseline )
					{
					text_data->y_offset = state->baseline - state->text_info.ascent;
					if ( ( text_data->y_offset + state->text_info.ascent + state->text_info.descent ) > state->line_height )
						{
						line_inc = text_data->y_offset + state->text_info.ascent + state->text_info.descent -
									state->line_height;
						}
					}
				else
					{
					baseline_inc = state->text_info.ascent - state->baseline;
					if ( ( text_data->y_offset + state->text_info.ascent + state->text_info.descent - baseline_inc ) >
							state->line_height)
						{
						line_inc = text_data->y_offset + state->text_info.ascent + state->text_info.descent -
									state->line_height - baseline_inc;
						}
					}
				
				/* Append this element to layout's linelist and our
				 * own list of text elements belonging to this block */
				lo_AppendToLineList ( context, state, (LO_Element *) text_data, baseline_inc );
				if ( block->startTextElement == NULL )
					{
					block->startTextElement = text_data;
					block->endTextElement = text_data;
					}
				else
					{
					block->endTextElement = text_data;
					}
				
				/* we know we're not at the beginning of the line anymore */
				state->at_begin_line = FALSE;
				
				state->baseline += (intn) baseline_inc;
				state->line_height += (intn) (baseline_inc + line_inc);
				text_data->height = state->text_info.ascent + state->text_info.descent;

				/*
				 * If the element we just flushed had a breakable word
				 * position in it, save that position in case we have
				 * to go back and break this element before we finish
				 * the line.
				 */
				if ( state->break_pos != -1 )
					{
					state->old_break = text_data;
					state->old_break_block = block;
					state->old_break_pos = state->break_pos;
					state->old_break_width = state->break_width;
					}

				state->linefeed_state = 0;
				state->x += state->width;
				state->width = 0;
				}
				
			/* If we're still processing text in this buffer, put a
			 * linebreak out there */
			if ( !allTextFits && !justify )
				{
				lo_SoftLineBreak(context, state, TRUE);
				}
			
			/* tell the break engine that we broke the line here */
			lo_SetLineBreak ( block, !justify );


#ifdef EDITOR
			/* tell the editor where we are */
			state->edit_current_offset = block->last_line_break;
#endif
				
			if ( !( allTextFits && !flushLastLine ) )
				{
				/* Skip the break character if it's whitespace. We
				 * don't need to worry about non-breaking spaces here
				 * as if the space was non-breaking, we would not have
				 * broken the line here */

				if ( XP_IS_SPACE ( *text ) && !allTextFits )
					{
					/* BRAIN DAMAGE: We should be able to do this at
                       the start of the line */
/*					lo_SkipCharacter ( block ); */
					}
				}
			
			}
		}
	
	if ( flushLastLine )
		{
		state->cur_ele_type = LO_NONE;
		state->cur_text_block = NULL;
		state->trailing_space = block->last_char_is_whitespace;
		}
	else
	if ( allTextFits )
		{
		/* we're still inside a group of text elements */
		state->cur_ele_type = LO_TEXT;
		state->trailing_space = block->last_char_is_whitespace;
		
		/* We're not going to flush the last line, so restore our
           break state to the start of the line */
		lo_RestoreBreakState ( block, &breakState, NULL );
		}
	
	if ( freeMeasureBuffer )
		{
		XP_FREE( charLocs );
		}
}

int32 lo_ComputeTextMinWidth ( lo_DocState * state, int32 wordWidth, Bool canBreak );
int32 lo_ComputeTextMinWidth ( lo_DocState * state, int32 wordWidth, Bool canBreak )
{
	int32 new_break_holder;
	int32 min_width;
	int32 indent;

	new_break_holder = state->x + wordWidth;
	min_width = new_break_holder - state->break_holder;
	indent = state->list_stack->old_left_margin - state->win_left;
	min_width += indent;

	/* If we are not within <NOBR> content, allow break_holder
	 * to be set to the new position where a line break can occur.
	 * This fixes BUG #70782
	 */
	if ( ( state->breakable != FALSE ) && canBreak) {
		state->break_holder = new_break_holder;
	}
	
	return min_width;
}

static uint32
lo_FindLineBreak ( MWContext * context, lo_DocState * state, LO_TextBlock * block, uint8 * text,
	uint16 * widthTable, uint32 * width, int32 * minWidth, Bool * allTextFits )
{
	LO_TextStruct	text_data;
	uint32			breakCount;
	Bool			skipEndSpace;
	Bool			haveTooShort;
	Bool			canBreak;
	BreakState		tooShortBreak;
	Bool			haveTooLong;
	uint32			wordLength;
	uint32			breakChar;
	uint32			lineLength;
	uint32			prevLineLength;
	uint8 *			wordStart;
	LO_TextInfo		text_info;
	uint32			runLength;
	int32			docWidth;
	BreakState		breakState;
	uint8 *			runEnd;
	int32			oldBreakPos;
	int32			oldBreakWidth;
	int32			lineWidth;
	Bool			justify;
#ifdef BREAK_GUESS_TRACK
	uint32			numForwardMoves;
	uint32			numBackwardMoves;
	
	numForwardMoves = 0;
	numBackwardMoves = 0;
#endif
	
	*allTextFits = FALSE;
	
	memset (&text_data, 0, sizeof (LO_TextStruct));
	text_data.text = (PA_Block) text;
	text_data.text_attr = block->text_attr;
	
	if ( minWidth != NULL )
		{
		*minWidth = 0;
		}

	justify = ( state->align_stack != NULL ) && ( state->align_stack->alignment == LO_ALIGN_JUSTIFY );
	
	/* guess where we want to break this line */
	docWidth = state->right_margin - state->x;
	if ( docWidth < 0 )
		{
		/* we should never get here - the line before us needs to have been broken */
		docWidth = 0;
		}
	
	lineLength = block->buffer_write_index - block->buffer_read_index;
	if ( state->breakable )
		{
		breakChar = docWidth * block->totalChars / block->totalWidth;
		if ( breakChar > lineLength )
			{
			breakChar = lineLength;
			}
		}
	else
		{
		breakChar = lineLength;
		}
	
	/* We first need to walk through the word runs until we get to the
	 * first one before our break character.
	 *
	 * OPTIMIZATION: Make lo_GetNextTextPosition take a breakChar and
	 * have it walk forward to that position in an inner loop. This
	 * will save us a ton of calls (we currently spend about 5% if our
	 * time in lo_GetNextTextPosition - not huge but significant).  */

	lineLength = 0;
	
	breakCount = 0;
	skipEndSpace = FALSE;
	
	wordStart = text;
	
	haveTooShort = FALSE;
	haveTooLong = FALSE;

	oldBreakPos = -1;
	oldBreakWidth = -1;
	
	lineWidth = 0;
#ifdef LOG
	if ( !gHaveLog )
		{
		PR_SetLogFile ( "TextLog" );
		gHaveLog = true;
		}

	PR_LogPrint ( "Finding initial break position\n" );
#endif

	/* get the next break position */
	while ( TRUE )
		{
		prevLineLength = lineLength;
		
#ifdef LOG
		PR_LogPrint ( "Get next break position\n" );
		PR_LogFlush();
#endif
		/* Save the current break position in case it ends up being
           the one we need */
		if ( breakCount > 0 && canBreak )
			{
			oldBreakPos = lineLength;
			}
		
		SAVE_BREAK_STATE ( block, &breakState, lineLength );			
		runEnd = lo_GetNextTextPosition ( block, &wordLength, &lineLength, &canBreak );
		if ( runEnd == NULL )
			{
#ifdef LOG
			PR_LogPrint ( "End of break table\n" );
			PR_LogFlush();
#endif
			
			/* we hit the end of the break table */
			runEnd = lo_RestoreBreakState ( block, &breakState, &lineLength );
			break;
			}

		/* do we need to calculate min_width's? */
		if ( minWidth != NULL )
			{
			int32 min_width;
			
			if ( widthTable != NULL )
				{
				uint32	startWordWidth;
				uint32	endWordWidth;
				
				startWordWidth = widthTable[ block->last_line_break + prevLineLength ];
				endWordWidth = widthTable[ block->last_line_break + lineLength ];
				
				runLength = endWordWidth - startWordWidth;
				}
			else
				{
				text_data.text = (PA_Block) wordStart;
				text_data.text_len = lineLength - prevLineLength;
				FE_GetTextInfo ( context, &text_data, &text_info );
				
				runLength = text_info.max_width;
				}
			
			/* add the width of this word into our line width */
			lineWidth += runLength;
			
			/* compute the real min width based on the last break position */
			min_width = lo_ComputeTextMinWidth ( state, lineWidth, canBreak );
			if ( min_width > *minWidth )
				{
				*minWidth = min_width;
				}
			
			wordStart = runEnd;
			}

#ifdef LOG
		PR_LogPrint ( "wordlen: %lu, lineLength: %lu, canBreak: %d, runEnd: %s\n", wordLength, lineLength, canBreak, runEnd );
		PR_LogFlush();
#endif
		
		/* Are we where we want to be yet? */
		if ( lineLength >= breakChar )
			{
#ifdef LOG
			PR_LogPrint ( "Moved past, back up\n" );
			PR_LogFlush();
#endif
			
			/* if we moved past it then back up if we can */
			if ( ( lineLength > breakChar ) && ( breakCount > 0 ) )
				{
				runEnd = lo_RestoreBreakState ( block, &breakState, &lineLength );			
				--breakCount;
				}
				
			break;
			}
		
		/* if we're justifying text, then we just dump the next break
           position */
		if ( justify )
			{
			break;
			}
			
		/* we can now back up to something */
		++breakCount;
		}

	/* So now we're looking at the nearest break position to where we
	 * guessed we'd want to be.  Now we loop measuring this line of
	 * text until we find the best break position */
	
#ifdef LOG
	PR_LogPrint ( "Finding actual break position\n" );
	PR_LogFlush();
#endif
	
	while ( TRUE )
		{
		if ( widthTable != NULL )
			{
			uint32	startLineWidth;
			uint32	endLineWidth;
			
			startLineWidth = widthTable[ block->last_line_break ];
			endLineWidth = widthTable[ block->last_line_break + lineLength ];
			
			runLength = endLineWidth - startLineWidth;
			}
		else
			{
			text_data.text = (PA_Block) text;
			text_data.text_len = lineLength;
			FE_GetTextInfo ( context, &text_data, &text_info );
				
			runLength = text_info.max_width;
			}

#ifdef LOG
		PR_LogPrint ( "lineLength: %lu, width: %lu, docWidth: %lu, text: %s\n", lineLength, runLength, docWidth, text );
		PR_LogFlush();
#endif
		/* if we're justified text, then we just dump the word we have now */
		if ( justify )
			{
			/* save this break position */
			if ( canBreak )
				{
				oldBreakPos = lineLength;
				oldBreakWidth = runLength;
				
				/* if the next char along is a space, then we need to include it */
				if ( ( runEnd != NULL ) && XP_IS_SPACE ( *runEnd )  )
					{
					++lineLength;
					}
				}
				
			break;
			}
		else
		/* are we non-breakable text? */
		if ( !state->breakable )
			{
			/* We always want to move to the end of the text block. We
			 * should already be there from the loop above.  */
#ifdef LOG
			PR_LogPrint ( "Non-breakable, always get next break point\n" );
			PR_LogFlush();
#endif
			
			/* go forward one break position and measure again
               (including min width) */
			SAVE_BREAK_STATE ( block, &tooShortBreak, lineLength );
			haveTooShort = TRUE;
			
#ifdef BREAK_GUESS_TRACK
			++numForwardMoves;
#endif			
			wordStart = runEnd;
			runEnd = lo_GetNextTextPosition ( block, &wordLength, &lineLength, &canBreak );
			if ( runEnd == NULL )
				{				
				/* we've already at the end of the line */
				runEnd = lo_RestoreBreakState ( block, &tooShortBreak, &lineLength );
#ifdef LOG
				PR_LogPrint ( "Non-breakable text, hit end of block: %lu, runEnd: %s\n", lineLength, runEnd );
				PR_LogFlush();
#endif
				/* update min_width */
				if ( minWidth != NULL )
					{
					int32 min_width;
										
					/* compute the real min width based on the last
                       break position - we cannot break here */
					min_width = lo_ComputeTextMinWidth ( state, runLength, FALSE );
					if ( min_width > *minWidth )
						{
						*minWidth = min_width;
						}
					}
				break;
				}
			}
		else
		/* have we gone too far? */
		if ( runLength > docWidth )
			{
#ifdef LOG
			PR_LogPrint ( "Too long\n" );
			PR_LogFlush();
#endif
			
			/* if we found a break position before this one that was
               too short, choose the too short one */
			if ( haveTooShort )
				{
#ifdef LOG
				PR_LogPrint ( "Using too short\n" );
				PR_LogFlush();
#endif
				runEnd = lo_RestoreBreakState ( block, &tooShortBreak, &lineLength );
				break;
				}
			
			/* if we have something to back up to, then do
               so. Otherwise we have to break here */
			if ( breakCount > 0 )
				{
#ifdef LOG
				PR_LogPrint ( "Backing up to previous break position\n" );
				PR_LogFlush();
#endif
#ifdef BREAK_GUESS_TRACK
				++numBackwardMoves;
#endif			

				/* mark that we've been to far and back up one */
				haveTooLong = TRUE;
				runEnd = lo_GetPrevTextPosition ( block, &wordLength, &lineLength, &canBreak );
				if ( runEnd == NULL )
					{
					/* we need to break at a previous break position
                       on this line... */
					break;
					}
					
				wordStart = runEnd;
				--breakCount;
				continue;
				}
			else
				{
#ifdef LOG
				PR_LogPrint ( "Nothing to back up to, bailing\n" );
				PR_LogFlush();
#endif
				break;
				}
			}
		else
		/* have we not gone far enough? */
		if ( runLength < docWidth )
			{
#ifdef LOG
			PR_LogPrint ( "Too short\n" );
			PR_LogFlush();
#endif
			/* if we have a too long break position, then we know
               we're straddling the break point, choose */
			/* this one */
			if ( haveTooLong )
				{
#ifdef LOG
				PR_LogPrint ( "Using this break, next is too long\n" );
				PR_LogFlush();
#endif
				break;
				}

			/* save this break position */
			if ( canBreak )
				{
				oldBreakPos = lineLength;
				oldBreakWidth = runLength;
				}
			
			/* go forward one break position and measure again
               (including min width) */
			SAVE_BREAK_STATE ( block, &tooShortBreak, lineLength );
			haveTooShort = TRUE;
			
#ifdef BREAK_GUESS_TRACK
			++numForwardMoves;
#endif			
			
			wordStart = runEnd;
			runEnd = lo_GetNextTextPosition ( block, &wordLength, &lineLength, &canBreak );
			if ( runEnd == NULL )
				{				
				/* we've already at the end of the line */
				runEnd = lo_RestoreBreakState ( block, &tooShortBreak, &lineLength );
#ifdef LOG
				PR_LogPrint ( "No next break position, use this one. length: %lu, runEnd: %s\n", lineLength, runEnd );
				PR_LogFlush();
#endif
				break;
				}
			
			/*
			 * Update min width.
			 */
			if ( minWidth != NULL )
				{
				int32 min_width;

				if ( widthTable != NULL )
					{
					uint32	startLineWidth;
					uint32	endLineWidth;
					
					startLineWidth = widthTable[ block->last_line_break ];
					endLineWidth = widthTable[ block->last_line_break + lineLength ];
					
					runLength = endLineWidth - startLineWidth;
					}
				else
					{
					text_data.text = (PA_Block) wordStart;
					text_data.text_len = wordLength;
					FE_GetTextInfo ( context, &text_data, &text_info );
					
					/* add the length of this word into the length of
                       the line */
					runLength += text_info.max_width;
					}
									
				/* compute the real min width based on the last break
                   position */
				min_width = lo_ComputeTextMinWidth ( state, runLength, canBreak );
				if ( min_width > *minWidth )
					{
					*minWidth = min_width;
					}
				}
				
			++breakCount;
			continue;
			}
		else
			{
			/* we're spot on! */
			break;
			}
		}
	
	/* We may be in a nasty case where our current break position is
	 * before our last saved one in oldBreakPos. This can happen when
	 * we move backwards from our initial break guess. To correct
	 * this, we need to back up from our current break point, get the
	 * new position and then move forward again.  */
	if ( ( oldBreakPos != -1 ) && ( oldBreakPos >= lineLength ) )
		{
		uint32	dummyWordLength;
		uint32	prevBreakPos;
		Bool	dummyCanBreak;
		uint8 *	prevRunEnd;
			
#ifdef BREAK_GUESS_TRACK
			++numBackwardMoves;
#endif			
		prevBreakPos = lineLength;
		
		SAVE_BREAK_STATE ( block, &breakState, prevBreakPos );
		prevRunEnd = lo_GetPrevTextPosition ( block, &dummyWordLength, &prevBreakPos, &dummyCanBreak );
		if ( prevRunEnd != NULL )
			{
			/* we found a valid previous break, so use it */
			oldBreakPos = prevBreakPos;
			oldBreakWidth = -1;
			}
		else
			{
			/* nothing to back up to, so don't record any old break */
			oldBreakPos = -1;
			oldBreakWidth = -1;
			}
		
		/* restore the current break state */
		lo_RestoreBreakState ( block, &breakState, &prevBreakPos );
		}
			
	text_data.text = (PA_Block) text;

	/* If we don't have a width for the oldBreakPos, measure one now */
	if ( ( oldBreakPos != -1 ) && ( oldBreakWidth == -1 ) )
		{
		if ( widthTable != NULL )
			{
			uint32	startLineWidth;
			uint32	endLineWidth;
			
			startLineWidth = widthTable[ block->last_line_break ];
			endLineWidth = widthTable[ block->last_line_break + oldBreakPos ];
			
			oldBreakWidth = endLineWidth - startLineWidth;
			}
		else
			{
			text_data.text_len = oldBreakPos;
			FE_GetTextInfo ( context, &text_data, &text_info );
			oldBreakWidth = text_info.max_width;
			}
		}
	
	text_data.text_len = lineLength;
	
	/* if we're breaking at a space at the end of this line, don't
       measure it */
	if ( skipEndSpace )
		{
		--text_data.text_len;
		}
	
	/* BRAIN DAMAGE: We don't need this - already got all the info */
	if ( widthTable != NULL )
		{
		uint32	startLineWidth;
		uint32	endLineWidth;
		
		/* this is really lame */
		text_data.text = (PA_Block) text;
		text_data.text_len = 1;
		FE_GetTextInfo ( context, &text_data, &text_info );
		
		startLineWidth = widthTable[ block->last_line_break ];
		endLineWidth = widthTable[ block->last_line_break + lineLength ];
		
		text_info.max_width = endLineWidth - startLineWidth;
		}
	else
		{
		text_data.text = (PA_Block) text;
		text_data.text_len = lineLength;
		FE_GetTextInfo ( context, &text_data, &text_info );
		}
	
	/* update our char width average */
	block->totalWidth += text_info.max_width;
	block->totalChars += lineLength;
	
	*width = lo_correct_text_element_width( &text_info );
	
	/* BRAIN DAMAGE: Pass this into the FE call */
	state->text_info = text_info;
	
	/* check to see if we're at the end of the buffer */
	if ( block->buffer_read_index == block->buffer_write_index )
		{
		*allTextFits = TRUE;
		}
	
	/* save the last break position */
	if ( oldBreakPos != -1 )
		{
		state->break_pos = oldBreakPos;
		state->break_width = oldBreakWidth;
		}
	
#ifdef LOG
	PR_LogPrint ( "Final lineLength: %lu, allTextFits: %d, text: %s\n", text_data.text_len, *allTextFits, text );
	PR_LogFlush();
#endif

#ifdef BREAK_GUESS_TRACK
	XP_TRACE(("Num forward, backward break moves after initial guess: %ld, %ld", numForwardMoves, numBackwardMoves ));
#endif			

	return lineLength;
}


static uint8 *
lo_GetNextTextPosition ( LO_TextBlock * block, uint32 * outWordLength, uint32 * outLineLength, Bool * canBreak )
{
	uint32		breakCommand;
	uint32		breakLong;
	uint32		breakIndex;
	uint32		lineLength;
	uint32		nibbleCount;
	uint32		dataNibbles;
	int32		wordLength;
	uint32 *	breakTable;
	uint8 *		endTextRun;
	
	/*
	 * Sanity check for already being at the end of the buffer
	 */
	
	if ( block->buffer_read_index == block->buffer_write_index )
		{
		*outWordLength = 0;
		*canBreak = FALSE;
		return NULL;
		}
	
	/* are we in a run of breakable multibyte characters? */
	if ( block->multibyte_length > 0 )
		{
		uint16	charSize;
		
		/* BRAIN DAMAGE */
		/* turn this next line on when the uint16 multibyte_char_size
           field is added to LO_TextBlock */
#if 0
		charSize = block->multibyte_char_size;
#else
		charSize = 2;
#endif
		block->multibyte_index += charSize;
		
		/* are we at the end of this run? */
		if ( block->multibyte_index == block->multibyte_length )
			{
			block->multibyte_length = 0;
			block->multibyte_index = 0;
			}
		
		/* bump by one character */
		*outWordLength = charSize;
		(*outLineLength) += charSize;
		*canBreak = TRUE;

		block->buffer_read_index += 2;
		endTextRun = &block->text_buffer[ block->buffer_read_index ];
	
		return endTextRun;
		}
		
	/* assume we will be able to break */
	*canBreak = TRUE;
	
	lineLength = block->buffer_read_index;
	breakIndex = block->break_read_index;
	
	/* are we at the end of the break table? */
	if ( breakIndex < block->break_write_index )
		{
		/* nope, so grab the next break position */
		breakTable = &block->break_table[ breakIndex >> 3 ];
		
		/* cache this in the TextBlock */
		breakLong = ( *breakTable++ ) << ( ( breakIndex & 0x7 ) << 2 );
		wordLength = 0;
		
		/* get the next break command */
		breakCommand = breakLong >> 28;
		breakLong <<= 4;
		if ( ( ++breakIndex & 0x7 ) == 0 )
			{
			breakLong = *breakTable++;
			}
		
		if ( breakCommand <= MAX_NATURAL_LENGTH )
			{
			/* a nibble of length data, we already have all the info we need */
			wordLength = breakCommand;
			dataNibbles = 0;
			}
		else
		if ( breakCommand == LINE_FEED )
			{
			/* we should only get this when parsing preformatted text */
			wordLength = BREAK_LINEFEED;
			dataNibbles = 0;
			}
		else
		if ( breakCommand == BYTE_LENGTH )
			{
			dataNibbles = 2;
			}
		else
		if ( breakCommand == WORD_LENGTH )
			{
			dataNibbles = 4;
			}
		else
		if ( breakCommand == MULTI_BYTE )
			{
			dataNibbles = 4;
			}
		else
			{
			/* a 24 bits of data */
			dataNibbles = 6;
			}
		
		if ( dataNibbles > 0 )
			{
			/* read in the actual count and the tail command header */
			for ( nibbleCount = dataNibbles; nibbleCount > 0; --nibbleCount )
				{
				wordLength <<= 4;
				wordLength |= breakLong >> 28;
				
				breakLong <<= 4;
				if ( ( ++breakIndex & 0x7 ) == 0 )
					{
					breakLong = *breakTable++;
					}
				}
			
			/* now skip the tail end of the command */
			++breakIndex;
			}

		/* if multi byte, then extract the real data */
		if ( breakCommand == MULTI_BYTE )
			{
			int32	runLength;
			
			*canBreak = TRUE;

			runLength = wordLength & MULTI_LENGTH_MASK;
							
			block->multibyte_length = runLength;
			block->multibyte_index = 2;
				
			/* make sure we're not already at the end of the run */
			if ( block->multibyte_index == block->multibyte_length )
				{
				block->multibyte_index = 0;
				block->multibyte_length = 0;
				}
				
			/* extract the real word length from the command */
			wordLength = ( wordLength & MULTI_CHAR_SIZE_MASK ) >> MULTI_CHAR_SIZE_SHIFT;
				
			/* MAJOR BRAIN DAMAGE: WE NEED TO STORE THIS IN THE TEXT BLOCK AS IT WILL NOT */
			/* ALWAYS BE TWO BYTE!!!! */
			XP_ASSERT( wordLength == 2 );
			}

		lineLength += wordLength;

		/* if we actually have a word here and are not the first word
		 * on the line, then add one to the length to account for the
		 * interword space. We know we're not the first word on the
		 * line if we're not at the linebreak or if we're at the start
		 * of the buffer but have already skipped a break position
		 * (this happens when the first character of the buffer is a
		 * breaking space).  */
		if ( ( wordLength > 0 ) && ( ( block->last_line_break != block->buffer_read_index ) ||
				( ( block->buffer_read_index == 0 ) && ( block->break_read_index > 0 ) ) ) )
			{
			/* only true if there's a space here */
			if ( XP_IS_SPACE ( block->text_buffer[ block->buffer_read_index ] ) )
				{
				lineLength++;
				(*outLineLength)++;
				}
			}
		}
	else
		{
		/* We're at the end of the break table. We may have some text
		 * after this last break.  Either way, we cannot break here */
		
		*canBreak = FALSE;
		
		if ( lineLength < block->buffer_write_index )
			{
			lineLength = block->buffer_write_index;
			wordLength = lineLength - block->buffer_read_index;
			}
		}
		
	block->break_read_index = breakIndex;
	block->buffer_read_index = lineLength;

	endTextRun = &block->text_buffer[ lineLength ];
	
	*outLineLength += wordLength;
	*outWordLength = wordLength;
	
	return endTextRun;
}


static Bool
lo_ExtractPrevBreakCommand ( LO_TextBlock * block, Bool * multiByte, uint32 * command )
{
	Bool		hasPrev;
	uint32		breakCommand;
	uint32		commandData;
	uint32		breakLong;
	uint32		breakIndex;
	uint32 *	breakTable;
	uint32		nibbleCount;
	uint32		dataNibbles;
	Bool		readPrevCommand;
	
	commandData = 0;
	*multiByte = FALSE;
	
	breakIndex = block->break_read_index;

	hasPrev = block->break_read_index > 0;
	if ( hasPrev )
		{
		readPrevCommand = TRUE;
		
		/* are we at the absolute end of the buffer? */
		if ( block->buffer_read_index == block->buffer_write_index )
			{
			/* Yup, so back up to the last break offset. */
			commandData = block->buffer_read_index - block->last_break_offset;
			
			/* was there really a true ending break command? */
			if ( commandData > 0 )
				{
				readPrevCommand = FALSE;

				/* this length was before the breaking space, add it back in */
				--commandData;
				}
			}
		
		/* extract the previous command from the table if we need to */
		if ( readPrevCommand )
			{
			/* nope, so back up within the break table */
			--breakIndex;
			breakTable = &block->break_table[ breakIndex >> 3 ];
			
			breakLong = *breakTable;
			
			/* shift the command down and extract the data */
			breakCommand = ( breakLong >> ( ( 7 - ( breakIndex & 0x7 ) ) << 2 ) ) & 0xF;	
			if ( breakCommand <= MAX_NATURAL_LENGTH )
				{
				/* a nibble of length data, we already have all the
                   info we need */
				dataNibbles = 0;
				commandData = breakCommand;
				}
			else
			if ( breakCommand == LINE_FEED )
				{
				/* we should only get this when parsing preformatted text */
				dataNibbles = 0;
				commandData = breakCommand;
				}
			else
			if ( breakCommand == BYTE_LENGTH )
				{
				/* a byte of length data */
				dataNibbles = 2;
				}
			else
			if ( breakCommand == WORD_LENGTH )
				{
				/* a short of length data */
				dataNibbles = 4;
				}
			else
			if ( breakCommand == MULTI_BYTE )
				{
				/* 16 bits of data */
				dataNibbles = 4;
				*multiByte = TRUE;
				}
			else
				{
				/* a 24 bits of data */
				dataNibbles = 6;
				}

			if ( dataNibbles > 0 )
				{
				/* skip the command tail */
				if ( ( --breakIndex & 0x7 ) == 7 )
					{
					breakLong = *--breakTable;
					}
				
				/* read in the actual count and the tail command header */
				for ( nibbleCount = 0; nibbleCount < dataNibbles; ++nibbleCount )
					{
					uint32	nibble;
					
					/* grab the next nibble */
					nibble = ( breakLong >> ( ( 7 - ( breakIndex & 0x7 ) ) << 2 ) ) & 0xF;
					commandData |= nibble << ( nibbleCount << 2 );
					
					if ( ( --breakIndex & 0x7 ) == 7 )
						{
						breakLong = *--breakTable;
						}
					}
				}
			}
		}
	
	block->break_read_index = breakIndex;

	*command = commandData;
	
	return hasPrev;
}

static uint8 *
lo_GetPrevTextPosition ( LO_TextBlock * block, uint32 * outWordLength, uint32 * outLineLength, Bool * canBreak )
{
	uint32		wordLength;
	uint32		breakCommand;
	uint32		lineLength;
	uint8 *		endTextRun;
	uint32		totalSkip;
	Bool		havePrevCommand;
	Bool		multiByte;
	
	*canBreak = FALSE;
	totalSkip = 0;
	
	/*
	 * Sanity check for already being at the beginning of the line
	 */
	if ( block->buffer_read_index == block->last_line_break )
		{
		*outWordLength = 0;
		return NULL;
		}
	
	/* are we in a run of breakable multibyte characters? */
	if ( block->multibyte_length > 0 )
		{
		uint16	charSize;
		
		/* BRAIN DAMAGE */
		/* turn this next line on when the uint16 multibyte_char_size
           field is added to LO_TextBlock */
#if 0
		charSize = block->multibyte_char_size;
#else
		charSize = 2;
#endif
		block->multibyte_index -= charSize;
		
		/* are we at the end of this run? */
		if ( block->multibyte_index == 0 )
			{
			block->multibyte_length = 0;
			}
		
		/* bump by one character */
		*outWordLength = charSize;
		(*outLineLength) -= charSize;
		*canBreak = TRUE;

		block->buffer_read_index -= 2;
		endTextRun = &block->text_buffer[ block->buffer_read_index ];
	
		return endTextRun;
		}
	
	/* back up to the previous command */
	havePrevCommand = lo_ExtractPrevBreakCommand ( block, &multiByte, &breakCommand );
	if ( !havePrevCommand )
		{
		*outWordLength = 0;
		return NULL;
		}
	
	/* back ourselves up in the buffer */
	if ( multiByte )
		{
		uint32	charSize;
		
		*canBreak = TRUE;
			
		/* extract the real word length from the command */
		charSize = ( breakCommand & MULTI_CHAR_SIZE_MASK ) >> MULTI_CHAR_SIZE_SHIFT;
						
		block->multibyte_length = breakCommand & MULTI_LENGTH_MASK;
		block->multibyte_index = block->multibyte_length - charSize;
			
		/* make sure we're not already at the beginning of the run */
		if ( block->multibyte_index == 0 )
			{
			block->multibyte_length = 0;
			}
			
		/* MAJOR BRAIN DAMAGE: WE NEED TO STORE THIS IN THE TEXT BLOCK
           AS IT WILL NOT */
		/* ALWAYS BE TWO BYTE!!!! */
		XP_ASSERT( charSize == 2 );
		
		/* the length of this run is the char size */
		wordLength = charSize;
		}
	else
		{
		wordLength = breakCommand;
		}
	
	lineLength = block->buffer_read_index;
	
	/* if we actually have a word here and are not the first word on
	 * the line, then subtract one to the length to account for the
	 * interword space.  */
	if ( ( wordLength > 0 ) && ( block->last_line_break != ( lineLength - wordLength )) )
		{
		/* only true if there's a space here */
		if ( XP_IS_SPACE ( block->text_buffer[ lineLength - wordLength - 1 ] ) )
			{
			lineLength--;
			(*outLineLength)--;
			}
		}

	lineLength -= wordLength;
	
	block->buffer_read_index = lineLength;

	endTextRun = &block->text_buffer[ lineLength ];
	
	*outLineLength -= wordLength;
	*outWordLength = wordLength;

	/* We can't break if we've backed up all the way to the start of
       the buffer and there is */
	/* no break position there */
	if ( ( block->break_read_index == 0 ) && ( wordLength == 0 ) )
		{
		*canBreak = FALSE;
		}
	else
		{
		*canBreak = TRUE;
		}
				
	return endTextRun;
}

static Bool
lo_SetBreakCommand ( LO_TextBlock * block, uint32 command, uint32 commandLength )
{
	uint32		break_write_index;
	uint32 *	break_table;
	
	/* record the current break position as it may be the last entry
       in the break table */
	block->last_break_offset = block->buffer_write_index;
	block->last_buffer_write_index = block->buffer_write_index;
	
	break_write_index = block->break_write_index;
	
	/* grow the break table if we need to - always have space for one
       long of data */
	if ( ( break_write_index + 8 ) > block->break_length )
		{
		/* allocate in bytes, count in nibbles */
		block->break_length += BREAK_TABLE_INC * 2;
		block->break_table = XP_REALLOC ( block->break_table, block->break_length / 2 );
		}
	
	break_table = block->break_table;
	
	if ( break_table != NULL )
		{
		uint32	nibble_index;
		
		nibble_index = break_write_index & 0x7;		
		
		/* write the command */
		if ( nibble_index == 0 )
			{
			/* we're long aligned, write the sucker */
			break_table[ break_write_index >> 3 ] = command;
			}
		else
			{
			uint32	table_long;
			uint32	table_index;
			
			table_index = break_write_index >> 3;
			table_long = break_table[ table_index ];
			
			table_long |= command >> ( nibble_index << 2 );
			break_table[ table_index ] = table_long;
			
			/* how many nibbles did we write, and were they enough? */
			nibble_index = 0x8 - nibble_index;
			if ( commandLength > nibble_index )
				{
				/* need to write out some more data */
				break_table[ table_index + 1 ] = command << ( nibble_index << 2 );
				}
			}
		
		break_write_index += commandLength;
		}
	
	block->break_write_index = break_write_index;
	
	return break_table != NULL;
}

static Bool
lo_SetBreakPosition ( LO_TextBlock * block )
{
	uint32		w_length;
	uint32		data_long;
	uint32		command_size;
	Bool		success;
	
	/* how many characters were added for this run */
	w_length = block->buffer_write_index - block->last_buffer_write_index;
	XP_ASSERT ( w_length >= 0 );
	
	if ( w_length <= MAX_NATURAL_LENGTH )
		{
		/* one data nibble */
		command_size = 1;
		data_long = w_length << 28;
		}
	else
	if ( w_length <= 255 )
		{
		/* a command nibble, two data nibbles and then a terminator nibble */
		command_size = 4;
		data_long = ( BYTE_LENGTH << 28 ) | ( w_length << 20 ) | ( BYTE_LENGTH << 16 );
		}
	else
	if ( w_length <= 65535 )
		{
		/* a command nibble, four data nibbles and then a terminator nibble */
		command_size = 6;
		data_long = ( WORD_LENGTH << 28 ) | ( w_length << 12 ) | ( WORD_LENGTH << 8 );
		}
	else
		{
		/* we can have 24 bits of data at most... */
		XP_ASSERT ( w_length <= ( ( 1 << 24 ) - 1 ) );
		
		/* a command nibble, six data nibbles and then a terminator nibble */
		command_size = 8;
		data_long = ( LONG_LENGTH << 28 ) | ( w_length << 4 ) | ( LONG_LENGTH );
		}
	
	success = lo_SetBreakCommand ( block, data_long, command_size );

	return success;
}

static Bool
lo_SetMultiByteRun ( LO_TextBlock * block, int32 charSize, Bool breakable, Bool eachCharBreakable )
{
	uint32		w_length;
	uint32		data_long;
	uint32		command_size;
	Bool		success;
	
	/* how many characters were added for this run */
	w_length = block->buffer_write_index - block->last_buffer_write_index;
	XP_ASSERT ( w_length >= 0 );
	
	/* * There are two cases where we can use a normal simple break
	 *	entry: 1. We are not breakable on every char and the text is
	 *	breakable (the normal break table case).  2. We can break on
	 *	every char, but we only have one char in the run */
	if ( breakable )
		{
		if ( !eachCharBreakable || ( charSize == w_length ) )
			{
			return lo_SetBreakPosition ( block );
			}
		}
		
	/* BRAIN DAMAGE: We need to handle overflow of our data word */
	
	/* this break command always has 16 bits of data and so it is 24
       bits big */
	command_size = 6;
	
	data_long = w_length;
	
	data_long |= ( charSize << MULTI_CHAR_SIZE_SHIFT ) & MULTI_CHAR_SIZE_MASK;

	XP_ASSERT( w_length <= MULTI_LENGTH_MASK );
	data_long |= ( w_length & MULTI_LENGTH_MASK );
	
	/* set the command nibbles */
	data_long = ( (uint32) MULTI_BYTE << ( MULTI_BYTE_DATA_SIZE + 4 ) ) | (uint32) ( data_long << 4 ) | (uint32) MULTI_BYTE;
	data_long <<= 8;
	
	success = lo_SetBreakCommand ( block, data_long, command_size );

	return success;
}

void lo_BreakOldTextBlockElement(MWContext *context, lo_DocState *state)
{
	LO_TextBlock *	block;
	LO_TextStruct *	text_data;
	LO_TextStruct *	new_text_data;
	char *			text;
	char *			breakPtr;
	int32			save_width;
	uint32			newTextlength;
	LO_TextInfo		text_info;
	int32			base_change;
	int32			old_baseline;
	int32			old_line_height;
	int32			adjust;
	int32			baseline_inc;
	LO_Element *	tptr;
	LO_Element *	eptr;
	LO_Element *	line_ptr;
	
	/* note that the block can be null for a word break element */
	block = state->old_break_block;
		
	/* Move to the element we will break */
	text_data = state->old_break;

	/* If there is no text there to break it is an error. */
	if ( text_data == NULL )
		{
		return;
		}
	
	new_text_data = NULL;
	
	/*
	 * Later operations will trash the width field.
	 * So save it now to restore later.
	 */
	save_width = state->width;
	
	/*
	 * If this element has no text, then it's a special word break
	 * element. We can simply remove it and then add a linefeed and then
	 * insert the remaining text on the line buffer
	 */
	if ( text_data->text == NULL )
		{
		/*
		 * Back up the state to this element's location
		 */
		state->x = text_data->x;
		state->y = text_data->y;

		tptr = text_data->next;
		text_data->next = NULL;

		state->width = text_data->width;
		state->x += state->width;
				
		/* add a line feed */
		lo_SoftLineBreak(context, state, TRUE);
		}
	else
		{
		/* We're trying to break inside an actual text element. We
		 * need to shorten this element to point up to this break
		 * position, then add a linefeed, then create a new element
		 * that contains the remaining text and place it on the line
		 * buffer */
		 
		 /* if we're breaking an element, we must have a text block */
		if ( block == NULL )
			{
			return;
			}

		PA_LOCK(text, char *, text_data->text);
		
		/*
		 * Back the state up to this element's
		 * location, break off the rest of the elements
		 * and save them for later.
		 * Flush this line, and insert a linebreak.
		 */
		state->x = text_data->x;
		state->y = text_data->y;
		tptr = text_data->next;
		text_data->next = NULL;
		
		breakPtr = &text[ state->old_break_pos ];
		newTextlength = text_data->text_len - state->old_break_pos;

		text_data->block_offset = text_data->block_offset - text_data->text_len + state->old_break_pos;
		text_data->text_len = state->old_break_pos;

		FE_GetTextInfo(context, text_data, &text_info);
		state->width = lo_correct_text_element_width( &text_info );
		
		text_data->width = state->width;
		PA_UNLOCK(text_data->text);
		state->x += state->width;
		
		/* this element should point at the space before the next
           word, so skip it */
		if ( XP_IS_SPACE ( *breakPtr ) )
			{
			++breakPtr;
			--newTextlength;
			}

		/*
		 * If the element that caused this break has a different
		 * baseline than the element we are breaking, we need to
		 * preserve that difference after the break.
		 */
		base_change = state->baseline - (text_data->y_offset + text_info.ascent);

		old_baseline = state->baseline;
		old_line_height = state->line_height;

		/*
		 * Reset element_id so they are still sequencial.
		 */
		state->top_state->element_id = text_data->ele_id + 1;

		/*
		 * If we are breaking an anchor, we need to make sure the
		 * linefeed gets its anchor href set properly.
		 */
		if (text_data->anchor_href != NULL)
			{
			LO_AnchorData *tmp_anchor;

			tmp_anchor = state->current_anchor;
			state->current_anchor = text_data->anchor_href;
			lo_SoftLineBreak(context, state, TRUE);
			state->current_anchor = tmp_anchor;
			}
		else
			{
			lo_SoftLineBreak(context, state, TRUE);
			}

		adjust = lo_baseline_adjust( context, state, tptr, old_baseline, old_line_height );
		state->baseline = old_baseline - adjust;
		state->line_height = (intn) old_line_height - adjust;
		
		/* now create a new text element */
		baseline_inc = -1 * adjust;
		
		new_text_data = (LO_TextStruct *)lo_NewElement ( context, state, LO_TEXT, text_data->edit_element, text_data->edit_offset+text_data->text_len+1 );
		if (text_data == NULL)
			{
#ifdef DEBUG
			assert (state->top_state->out_of_memory);
#endif
			return;
			}

		new_text_data->type = LO_TEXT;
		new_text_data->ele_id = NEXT_ELEMENT;
		new_text_data->x = state->x;
		new_text_data->x_offset = 0;
		new_text_data->y = state->y;
		new_text_data->y_offset = 0;
		new_text_data->height = 0;
		new_text_data->next = NULL;
		new_text_data->prev = NULL;

		new_text_data->anchor_href = block->anchor_href;
		new_text_data->text_attr = block->text_attr;
		new_text_data->ele_attrmask = block->ele_attrmask;
		
		/* BRAIN DAMAGE: Set LO_ELE_INVISIBLE to mark the element as
           not having a valid text ptr */
		XP_ASSERT ( !(new_text_data->ele_attrmask & LO_ELE_INVISIBLE ) );
		new_text_data->ele_attrmask |= LO_ELE_INVISIBLE;
		
		new_text_data->sel_start = -1;
		new_text_data->sel_end = -1;

		new_text_data->doc_width = state->right_margin - state->x;
		new_text_data->doc_width = 0;
		new_text_data->block_offset = text_data->block_offset + text_data->text_len;
		XP_ASSERT(new_text_data->block_offset <= 65535);
			
		new_text_data->text = (PA_Block) breakPtr;
		new_text_data->text_len = newTextlength;
		FE_GetTextInfo(context, new_text_data, &text_info);
		new_text_data->width = lo_correct_text_element_width(&text_info);

		/*
		 * Some fonts (particulatly italic ones with curly
		 * tails on letters like 'f') have a left bearing
		 * that extends back into the previous character.
		 * Since in this case the previous character is
		 * probably not in the same font, we move forward
		 * to avoid overlap.
		 */
		if (text_info.lbearing < 0)
			{
			new_text_data->x_offset = text_info.lbearing * -1;
			}

		/*
		 * The baseline of the text element just inserted in
		 * the line may be less than or greater than the
		 * baseline of the rest of the line due to font
		 * changes.  If the baseline is less, this is easy,
		 * we just increase y_offest to move the text down
		 * so the baselines line up.  For greater baselines,
		 * we can't move the text up to line up the baselines
		 * because we will overlay the previous line, so we
		 * have to move all rest of the elements in this line
		 * down.
		 *
		 * If the baseline is zero, we are the first element
		 * on the line, and we get to set the baseline.
		 */
		if (state->baseline == 0)
			{
			state->baseline = text_info.ascent;
			}
		else
		if (text_info.ascent < state->baseline)
			{
			new_text_data->y_offset = state->baseline - text_info.ascent;
			}
		else
			{
			baseline_inc = baseline_inc + (text_info.ascent - state->baseline);
			state->baseline = text_info.ascent;
			}

		/*
		 * Now that we have broken, and added the new
		 * element, we need to move it down to restore the
		 * baseline difference that previously existed.
		 */
		new_text_data->y_offset -= base_change;

		/*
		 * Calculate the height of this new
		 * text element.
		 */
		new_text_data->height = text_info.ascent + text_info.descent;
		state->x += new_text_data->width;
		}
	
	/* if our previous element was the last text element for this
	 * block, then our new element is the new end */
	if ( block->endTextElement == text_data )
		{
		block->endTextElement = new_text_data;
		}
		
	/*
	 * Now add the remaining elements to the line list
	 */
	 
	/* first find the end of the line list */
	line_ptr = state->line_list;
	while ((line_ptr != NULL)&&(line_ptr->lo_any.next != NULL))
		{
		line_ptr = line_ptr->lo_any.next;
		}
	
	/* now add the new_text_data if there is one */
	if ( new_text_data != NULL )
		{
		if (line_ptr == NULL)
			{
			state->line_list = (LO_Element *) new_text_data;
			new_text_data->prev = NULL;
			line_ptr = (LO_Element *) new_text_data;
			}
		else
			{
			line_ptr->lo_any.next = (LO_Element *) new_text_data;
			new_text_data->prev = line_ptr;
			line_ptr = (LO_Element *) new_text_data;
			}
		}
	
	/* and then add tptr */
	if ( tptr != NULL )
		{
		if (line_ptr == NULL)
			{
			state->line_list = tptr;
			tptr->lo_any.prev = NULL;
			line_ptr = tptr;
			}
		else
			{
			line_ptr->lo_any.next = tptr;
			tptr->lo_any.prev = line_ptr;
			line_ptr = tptr;
			}
		}
	
	/* if we've added a new element then increment the element id's of
       the following elements */
	if ( new_text_data != NULL )
		{
		eptr = tptr;

		while (eptr != NULL)
			{
			eptr->lo_any.ele_id = NEXT_ELEMENT;
			eptr->lo_any.y_offset += baseline_inc;
			eptr = eptr->lo_any.next;
			}
		
		/* and bump the line height if we need to */
		if ( ( new_text_data->y_offset + new_text_data->height ) > state->line_height )
			{
			state->line_height = (intn) new_text_data->y_offset + new_text_data->height;
			}
		}

	/*
	 * Upgrade forward the x and y text positions in the document
	 * state.
	 */
	while ( tptr != NULL )
		{
		lo_UpdateElementPosition ( state, tptr );
		tptr = tptr->lo_any.next;
		}

	state->at_begin_line = FALSE;
	state->width = save_width;
}

static uint8 *
lo_GetLineStart ( LO_TextBlock * block )
{
	return &block->text_buffer[ block->last_line_break ];
}


static void
lo_SkipCharacter ( LO_TextBlock * block )
{
	++block->buffer_read_index;
}


static void
lo_SetLineBreak ( LO_TextBlock * block, Bool skipSpace )
{
	/* if the current character is a space, we can skip it as we're
       breaking here */
	/* NOT FOR PREFORMATTED TEXT THOUGH */
	if ( skipSpace && ( XP_IS_SPACE ( block->text_buffer[ block->buffer_read_index ] ) ) )
		{
		++block->buffer_read_index;
		}

	block->last_line_break = block->buffer_read_index;
}

static uint8 *
lo_RestoreBreakState ( LO_TextBlock * block, BreakState * state, uint32 * lineLength )
{
	uint8 *	runEnd;
	
	block->buffer_read_index = state->buffer_read_index;
	block->break_read_index = state->break_read_index;
	block->multibyte_index = state->multibyte_index;
	block->multibyte_length = state->multibyte_length;
	block->last_line_break = state->last_line_break;
	
	if ( lineLength != NULL )
		{
		*lineLength = state->lineLength;
		}
	
	runEnd = &block->text_buffer[ block->buffer_read_index ];
	
	return runEnd;
}


static Bool
lo_SkipInitialSpace ( LO_TextBlock * block )
{
	Bool	canBreak;
	uint32	breakLong;
	uint32	breakIndex;
	
	canBreak = FALSE;
	breakIndex = block->break_read_index;
	
	/* do we have a break point at the current text offset */
	if ( ( breakIndex == 0 ) && ( breakIndex < block->break_write_index ) && XP_IS_SPACE ( block->text_buffer[ 0 ] ) )
		{
		breakLong = block->break_table[ breakIndex >> 3 ];
		breakLong >>= ( 7 - ( breakIndex & 0x7 ) ) << 2;
		
		if ( breakLong == 0 )
			{
			block->buffer_read_index++;
			block->break_read_index++;
			block->last_line_break++;
			canBreak = TRUE;
			}
		}
	
	return canBreak;
}


Bool lo_GrowTextBlock ( LO_TextBlock * block, uint32 length )
{
	Bool			success = TRUE;
	uint32			growBy;
	uint32			oldTextBase;
	uint32			offset;
	LO_TextStruct *	textElement;
	LO_TextStruct *	endElement;
	
	if ( block->buffer_length < ( block->buffer_write_index + length ) )
		{
		/* need to make sure that the new size is enough to contain
           the new data */
		growBy = TEXT_BUFFER_INC;
		if ( growBy < length )
			{
			growBy = length;
			}
		
		oldTextBase = (uint32) block->text_buffer;
		
		growBy += block->buffer_length;
		block->text_buffer = XP_REALLOC ( block->text_buffer, growBy );
		
		block->buffer_length = growBy;
		success = block->text_buffer != NULL;
		
		/* update any break table related information */
		if ( success && ( block->break_table != NULL ) )
			{
			/* Run through all the text elements and adjust their text
			 * addresses to point to the newly relocated block */
			
			textElement = block->startTextElement;
			endElement = block->endTextElement;
			
			while ( textElement != NULL )
				{
				if ( textElement->type == LO_TEXT )
					{
					offset = (uint32) textElement->text - oldTextBase;
					textElement->text = (PA_Block) ( (uint32) block->text_buffer + offset );
					}
				
				if ( textElement == endElement )
					{
					break;
					}
				
				textElement = (LO_TextStruct *) textElement->next;
				}
			}
		}
	
	return success;
}

static void
lo_CopyText ( uint8 * src, uint8 * dst, uint32 length )
{
	uint8	c;
	
	/* copy a text string, converting non breaking spaces to normal
       spaces as we go */
	while ( length-- )
		{
		c = *src++;
		
		if ( c == NON_BREAKING_SPACE )
			{
			c = ' ';
			}
		
		*dst++ = c;
		}
}

static void
lo_CopyTextToLineBuffer ( lo_DocState * state, uint8 * src, uint32 length )
{
	char *	text_buf;

	/* do we need to grow the buffer? */
	if ( ( state->line_buf_len + length + 1 ) > state->line_buf_size )
		{
		state->line_buf = PA_REALLOC ( state->line_buf, ( state->line_buf_size + length + LINE_BUF_INC ) );
		if ( state->line_buf == NULL )
			{
			state->top_state->out_of_memory = TRUE;
			return;
			}
		}
	
	PA_LOCK(text_buf, char *, state->line_buf);
	
	XP_BCOPY ( (char *) src, (char *) ( text_buf + state->line_buf_len ), ( length + 1 ) );
	state->line_buf_len += length;
	
	text_buf[ state->line_buf_len ] = 0;
	
	PA_UNLOCK(state->line_buf);
}

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

#ifdef PROFILE
#pragma profile off
#endif