mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-05 20:15:58 +00:00
8765 lines
218 KiB
C
8765 lines
218 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "xp.h"
|
|
#include "pa_tags.h"
|
|
#include "layout.h"
|
|
#include "laylayer.h"
|
|
#include "layers.h"
|
|
#include "libi18n.h"
|
|
#include "edt.h"
|
|
#include "laystyle.h"
|
|
#include "laytrav.h"
|
|
|
|
#ifdef DOM
|
|
#include "domstyle.h"
|
|
#include "lm_dom.h"
|
|
#include "laydom.h"
|
|
#endif
|
|
|
|
/*
|
|
* 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 );
|
|
|
|
typedef enum {
|
|
kSimpleSBTextParseAttribute = 0,
|
|
kMBTextParseAttribute,
|
|
kThaiTextParseAttribute
|
|
} loTextParseAttribute;
|
|
static loTextParseAttribute lo_GetTextParseAttributes (lo_DocState * state);
|
|
|
|
#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 )
|
|
{
|
|
/* TEXTATTR HERE */
|
|
#ifdef DOM
|
|
block->text_attr = lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
block->text_attr = state->font_stack->text_attr;
|
|
#endif
|
|
}
|
|
|
|
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->line_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;
|
|
}
|
|
|
|
/* Fix for bug#124552. Look at both the state structure and the
|
|
current text block for anchor information. */
|
|
text_ele->anchor_href = state->current_anchor;
|
|
if (state->current_anchor == NULL &&
|
|
state->cur_text_block != NULL &&
|
|
state->cur_text_block->anchor_href != NULL)
|
|
{
|
|
text_ele->anchor_href = state->cur_text_block->anchor_href;
|
|
}
|
|
|
|
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 )
|
|
{
|
|
/* TEXTATTR HERE */
|
|
#ifdef DOM
|
|
tmp_text.text_attr = lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
tmp_text.text_attr = state->font_stack->text_attr;
|
|
#endif
|
|
}
|
|
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->line_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;
|
|
|
|
/* TEXTATTR HERE */
|
|
if (state->font_stack == NULL)
|
|
{
|
|
text_ele->text_attr = NULL;
|
|
}
|
|
else
|
|
{
|
|
#ifdef DOM
|
|
text_ele->text_attr = lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
text_ele->text_attr = state->font_stack->text_attr;
|
|
#endif
|
|
}
|
|
|
|
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.objTag.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 = NULL;
|
|
Bool lineBufMeasured;
|
|
|
|
/* start at the current text position in this text block */
|
|
if (block->text_buffer)
|
|
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 = NULL;
|
|
|
|
#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
|
|
|
|
/* start at the current text position in this text block */
|
|
if (block->text_buffer)
|
|
text = (char *) &block->text_buffer[ block->buffer_read_index ];
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
|
|
/* Only the first call here actually changes the text color */
|
|
void
|
|
lo_ChangeBodyTextFGColor(MWContext *context, lo_DocState *state, LO_Color *color)
|
|
{
|
|
if( (state->top_state->body_attr & BODY_ATTR_TEXT) != 0)
|
|
return;
|
|
|
|
/* Set the flag so we don't change the color again
|
|
unless we relayout from the URL again.
|
|
*/
|
|
state->top_state->body_attr |= BODY_ATTR_TEXT;
|
|
|
|
lo_SetBodyTextFGColor(context, state, color);
|
|
}
|
|
|
|
|
|
/* This REALLY sets the color. "state" may be NULL and it will be figured out */
|
|
void
|
|
lo_SetBodyTextFGColor(MWContext *context, lo_DocState *state, LO_Color *color)
|
|
{
|
|
int32 doc_id;
|
|
lo_TopState *top_state;
|
|
lo_FontStack *fptr;
|
|
LO_TextAttr *attr;
|
|
|
|
if( !context )
|
|
return;
|
|
|
|
if( !state )
|
|
{
|
|
doc_id = XP_DOCID(context);
|
|
top_state = lo_FetchTopState(doc_id);
|
|
if (top_state != NULL && top_state->doc_state == NULL)
|
|
return;
|
|
|
|
state = top_state->doc_state;
|
|
|
|
if (color == NULL)
|
|
color = &lo_master_colors[LO_COLOR_FG];
|
|
}
|
|
|
|
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.
|
|
*************************************/
|
|
#ifndef DOM
|
|
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);
|
|
}
|
|
#endif
|
|
|
|
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;
|
|
}
|
|
|
|
/* TEXTATTR HERE */
|
|
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;
|
|
#ifndef DOM
|
|
LO_TextAttr tmp_attr;
|
|
#endif
|
|
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;
|
|
|
|
/* TEXTATTR HERE */
|
|
#ifdef DOM
|
|
tptr = lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
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);
|
|
#endif
|
|
|
|
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;
|
|
/* TEXTATTR HERE */
|
|
#ifdef DOM
|
|
bullet_text->text_attr = lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
bullet_text->text_attr = state->font_stack->text_attr;
|
|
#endif
|
|
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->line_height = 0;
|
|
bullet_text->y_offset = 0;
|
|
bullet_text->x_offset = 0;
|
|
|
|
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.
|
|
*/
|
|
/* TEXTATTR HERE -- why does this not use the font stack? */
|
|
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->line_height = 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);
|
|
}
|
|
|
|
/* TEXTATTR HERE -- why does this not use font/style info? */
|
|
lo_SetDefaultFontAttr(state, &tmp_attr, context);
|
|
tmp_attr.fg.red = 0;
|
|
tmp_attr.fg.green = 0;
|
|
tmp_attr.fg.blue = 255;
|
|
#ifdef DOM
|
|
tptr = lo_FillInTextStyleInfo(state, context, &tmp_attr, JS_TRUE);
|
|
#else
|
|
tptr = lo_FetchTextAttr(state, &tmp_attr);
|
|
#endif
|
|
|
|
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)
|
|
#ifndef DOM
|
|
&&(state->font_stack != NULL)&&
|
|
(state->font_stack->text_attr != NULL)
|
|
#endif
|
|
)
|
|
{
|
|
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 !defined(SMOOTH_PROGRESS)
|
|
if(!state->top_state->is_binary)
|
|
FE_SetProgressBarPercent(context, percent);
|
|
#endif /* !defined(SMOOTH_PROGRESS) */
|
|
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)
|
|
#ifndef DOM
|
|
&&(state->font_stack != NULL)&&
|
|
(state->font_stack->text_attr != NULL)
|
|
#endif
|
|
)
|
|
{
|
|
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;
|
|
|
|
#ifdef DOM
|
|
linefeed->text_attr = lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
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
|
|
{
|
|
/* TEXTATTR HERE */
|
|
linefeed->text_attr = state->font_stack->text_attr;
|
|
}
|
|
#endif
|
|
|
|
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 useBreakTable;
|
|
|
|
useBreakTable = TRUE;
|
|
|
|
#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 ( kMBTextParseAttribute == lo_GetTextParseAttributes(state) )
|
|
{
|
|
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 *)lo_tv_GetNextLayoutElement ( state, (LO_Element*)block, FALSE );
|
|
|
|
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 );
|
|
|
|
/* and then add a new linefeed */
|
|
lo_rl_AddSoftBreakAndFlushLine ( context, state );
|
|
|
|
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;
|
|
fastPreformat = ( block->format_mode == PRE_TEXT_YES ) || ( block->format_mode == PRE_TEXT_COLS );
|
|
|
|
while ( 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 );
|
|
|
|
/* Fix for bug 129639: Only add the new linefeed for preformatted text.
|
|
Calling lo_rl_AddSoftBreakAndFlushLine() causes extra line feeds to
|
|
be generated for regular text. */
|
|
if (fastPreformat)
|
|
lo_rl_AddSoftBreakAndFlushLine ( context, state );
|
|
|
|
break;
|
|
|
|
default:
|
|
element->lo_any.prev = NULL;
|
|
element->lo_any.next = NULL;
|
|
lo_RecycleElements( context, state, element );
|
|
break;
|
|
}
|
|
|
|
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_ParseThaiText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text );
|
|
static void lo_ParseDoubleText ( 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 )
|
|
{
|
|
/* TEXTATTR HERE */
|
|
#ifdef DOM
|
|
textBlock->text_attr = lo_GetCurrentTextAttr(state, context);
|
|
#else
|
|
textBlock->text_attr = state->font_stack->text_attr;
|
|
#endif
|
|
}
|
|
|
|
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;
|
|
|
|
/*
|
|
* 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
|
|
*/
|
|
|
|
switch( lo_GetTextParseAttributes ( state ))
|
|
{
|
|
case kSimpleSBTextParseAttribute:
|
|
lo_ParseSingleText ( state, block, parseAllText, text );
|
|
break;
|
|
|
|
case kMBTextParseAttribute:
|
|
lo_ParseDoubleText ( state, block, parseAllText, text );
|
|
break;
|
|
|
|
case kThaiTextParseAttribute:
|
|
lo_ParseThaiText ( state, block, parseAllText, text );
|
|
break;
|
|
|
|
default:
|
|
XP_ASSERT(0); /* wrong text parse attribute value */
|
|
break;
|
|
}
|
|
}
|
|
static loTextParseAttribute
|
|
lo_GetTextParseAttributes ( lo_DocState * state)
|
|
{
|
|
|
|
/* XP_ASSERT(NULL != state); */
|
|
if ( state != NULL )
|
|
{
|
|
uint16 charset = state->font_stack->text_attr->charset;
|
|
if ( charset == CS_TIS620 )
|
|
return kThaiTextParseAttribute;
|
|
|
|
if ( (INTL_CharSetType ( charset ) != SINGLEBYTE ) &&
|
|
!( INTL_CharSetType ( charset ) & CS_SPACE ) )
|
|
return kMBTextParseAttribute;
|
|
}
|
|
|
|
return kSimpleSBTextParseAttribute;
|
|
}
|
|
|
|
static void
|
|
lo_ParseThaiText ( lo_DocState * state, LO_TextBlock * block, Bool parseAllText, char * text )
|
|
{
|
|
|
|
XP_ASSERT(0); /* delete when we really have the code */
|
|
|
|
/* Call the single byte one untill we have the real lo_ParseThaiText ready */
|
|
|
|
lo_ParseSingleText(state, block, parseAllText, text);
|
|
}
|
|
|
|
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;
|
|
char * text_buf;
|
|
|
|
block = state->cur_text_block;
|
|
|
|
if ( block != NULL )
|
|
{
|
|
|
|
/* 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 ( kMBTextParseAttribute == lo_GetTextParseAttributes(state) )
|
|
{
|
|
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 */
|
|
/* XXX MATT XXX sometimes buffer_read_index may be larger then
|
|
* buffer_write_index, don't know why XXX
|
|
*/
|
|
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 && state->old_break_block != NULL )
|
|
{
|
|
#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->line_height = 0;
|
|
text_data->next = NULL;
|
|
text_data->prev = NULL;
|
|
|
|
text_data->text = (PA_Block) text;
|
|
/* HACK: The editor needs spaces to be included in the length of the last text element on a line.
|
|
If we do not do this, navigation between lines gets broken. So, for "1111 2222", if we break the
|
|
line after the first number, the text element should contain "1111 " rather than "1111". The fix is
|
|
to add 1 to the length of the text element once we have ensured that the extra character being added
|
|
is a space and that this text element is going to be followed by a linebreak. */
|
|
if (EDT_IS_EDITOR( context ) && !allTextFits && !justify && XP_IS_SPACE(((char *) text_data->text)[lineLength]))
|
|
text_data->text_len = lineLength + 1;
|
|
else
|
|
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 ( !allTextFits && XP_IS_SPACE ( *text ) )
|
|
{
|
|
/* 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=0;
|
|
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=0;
|
|
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->line_height = 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_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 DOM
|
|
LO_TextAttr *
|
|
lo_GetCurrentTextAttr(lo_DocState *state, MWContext *context)
|
|
{
|
|
LO_TextAttr tmp_attr, *tptr, *styleptr;
|
|
JSBool isMutable;
|
|
|
|
if (!state->font_stack) {
|
|
/*
|
|
* XXX we should keep a text_attr with the default values around so that
|
|
* we can just bump the refcount instead of copying all that data and
|
|
* stuff.
|
|
*/
|
|
lo_SetDefaultFontAttr(state, &tmp_attr, context);
|
|
tptr = &tmp_attr;
|
|
isMutable = JS_TRUE;
|
|
} else {
|
|
/*
|
|
* we can just dup the pointer, because lo_FillInTextStyleInfo will
|
|
* copy-on-write for us.
|
|
*/
|
|
tptr = state->font_stack->text_attr;
|
|
tptr->refcnt++;
|
|
isMutable = JS_FALSE;
|
|
}
|
|
|
|
styleptr = lo_FillInTextStyleInfo(state, context, tptr, isMutable);
|
|
if (styleptr != tptr)
|
|
isMutable = JS_FALSE; /* already fetched, so no need to refetch */
|
|
tptr = styleptr;
|
|
|
|
if (isMutable)
|
|
/* we're working on the stack-allocated text_attr, so get a heap copy */
|
|
tptr = lo_FetchTextAttr(state, tptr);
|
|
|
|
return tptr;
|
|
}
|
|
|
|
#ifdef DEBUG_shaver
|
|
/* #define DEBUG_shaver_textattr */
|
|
#endif
|
|
|
|
LO_TextAttr *
|
|
lo_FillInTextStyleInfo(lo_DocState *state, MWContext *context,
|
|
LO_TextAttr *tptr, JSBool isMutable)
|
|
{
|
|
JSContext *cx = context->mocha_context;
|
|
DOM_StyleDatabase *db = state->top_state->style_db;
|
|
DOM_AttributeEntry *entry;
|
|
DOM_Node *node = ACTIVE_NODE(state);
|
|
LO_TextAttr text_attr, *newptr = NULL;
|
|
JSBool copied = JS_FALSE;
|
|
LO_Color col;
|
|
|
|
if (!node)
|
|
return tptr;
|
|
|
|
if (node->type != NODE_TYPE_TEXT) {
|
|
if (node->type == NODE_TYPE_ELEMENT) {
|
|
DOM_HTMLElementPrivate *priv = node->data;
|
|
if (priv &&
|
|
(priv->tagtype == P_LIST_ITEM ||
|
|
priv->tagtype == P_IMAGE ||
|
|
priv->tagtype == P_HRULE /* layout NYI */)) {
|
|
#ifdef DEBUG_shaver_textattr
|
|
fprintf(stderr, "setting textattr on <%s>\n",
|
|
((DOM_Element *)node)->tagName);
|
|
#endif
|
|
} else {
|
|
#ifdef DEBUG_shaver_textattr
|
|
fprintf(stderr, "NOT setting textattr on <%s>\n",
|
|
((DOM_Element *)node)->tagName);
|
|
#endif
|
|
return tptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
#define COW() \
|
|
if (!isMutable && !copied) { \
|
|
lo_CopyTextAttr(tptr, &text_attr); \
|
|
copied = JS_TRUE; \
|
|
}
|
|
|
|
if (!isMutable) {
|
|
XP_BZERO(&text_attr, sizeof(text_attr));
|
|
newptr = &text_attr;
|
|
} else {
|
|
newptr = tptr;
|
|
}
|
|
|
|
if (!db) {
|
|
/* find enclosing link object, and set the appropriate default color */
|
|
DOM_StyleToken pseudo;
|
|
DOM_Element *link;
|
|
|
|
#ifdef DEBUG_shaver_textattr
|
|
fprintf(stderr, "no db, setting default attrs ");
|
|
#endif
|
|
|
|
if (!state->current_anchor) {
|
|
#ifdef DEBUG_shaver
|
|
fprintf(stderr, "no anchor, done\n");
|
|
#endif
|
|
goto done;
|
|
}
|
|
|
|
link = state->current_anchor->node;
|
|
XP_ASSERT(link && link->node.type == NODE_TYPE_ELEMENT);
|
|
pseudo = DOM_GetElementPseudo(cx, link);
|
|
if (pseudo) {
|
|
/* XXX assuming that we only set pseudo on links! */
|
|
LO_Color col;
|
|
#ifdef DEBUG_shaver_textattr
|
|
fprintf(stderr, "pseudo is %s", pseudo);
|
|
#endif
|
|
COW();
|
|
if (lo_underline_anchors())
|
|
newptr->attrmask |= LO_ATTR_UNDERLINE;
|
|
if (!XP_STRCMP(pseudo, "link")) {
|
|
col.red = STATE_UNVISITED_ANCHOR_RED(state);
|
|
col.blue = STATE_UNVISITED_ANCHOR_BLUE(state);
|
|
col.green = STATE_UNVISITED_ANCHOR_GREEN(state);
|
|
newptr->fg = col;
|
|
} else if (!XP_STRCMP(pseudo, "visited")) {
|
|
col.red = STATE_VISITED_ANCHOR_RED(state);
|
|
col.blue = STATE_VISITED_ANCHOR_BLUE(state);
|
|
col.green = STATE_VISITED_ANCHOR_GREEN(state);
|
|
newptr->fg = col;
|
|
}
|
|
}
|
|
#ifdef DEBUG_shaver_textattr
|
|
fputs("\n", stderr);
|
|
#endif
|
|
goto done;
|
|
}
|
|
|
|
/* check "color" property */
|
|
if (!DOM_StyleGetProperty(cx, db, node, COLOR_STYLE, &entry))
|
|
/* XXX report error? return NULL? */
|
|
goto done;
|
|
if (entry) {
|
|
if (!DOM_GetCleanEntryData(cx, entry, lo_ColorStringToData, NULL, (uint32*)&col,
|
|
NULL))
|
|
goto done;
|
|
if (*(uint32 *)&col != *(uint32 *)&tptr->fg) {
|
|
COW();
|
|
newptr->fg = col;
|
|
}
|
|
}
|
|
|
|
/* check bgcolor property, including transparent */
|
|
if (!DOM_StyleGetProperty(cx, db, node, BG_COLOR_STYLE, &entry))
|
|
goto done;
|
|
if (entry) {
|
|
COW();
|
|
if (!DOM_GetCleanEntryData(cx, entry, lo_ColorStringToData, NULL, (uint32*)&col,
|
|
NULL))
|
|
goto done;
|
|
newptr->bg = col;
|
|
if (!strcasecomp(entry->value, "transparent"))
|
|
newptr->no_background = TRUE;
|
|
else
|
|
newptr->no_background = FALSE;
|
|
}
|
|
|
|
/* check font-face */
|
|
if (lo_face_attribute()) {
|
|
if (!DOM_StyleGetProperty(cx, db, node, FONTFACE_STYLE, &entry))
|
|
goto done;
|
|
if (entry) {
|
|
COW();
|
|
/* XXXshaver use GetCleanEntryData when I figure out mem mgmt */
|
|
#if 0
|
|
if (newptr->font_face)
|
|
XP_FREE(newptr->font_face);
|
|
#endif
|
|
newptr->font_face = lo_FetchFontFace(context, state,
|
|
(char *)entry->value);
|
|
}
|
|
}
|
|
|
|
/* check font-size */
|
|
if (!DOM_StyleGetProperty(cx, db, node, FONTSIZE_STYLE, &entry))
|
|
return NULL;
|
|
if (entry) {
|
|
double *fontsize;
|
|
struct SSUnitContext arg;
|
|
arg.context = context;
|
|
|
|
if (!DOM_GetCleanEntryData(cx, entry, lo_ParseFontSizeToData, lo_DeleteFontSize,
|
|
(uint32*)&fontsize, (void *)&arg))
|
|
return NULL;
|
|
if (newptr->point_size != *fontsize) {
|
|
COW();
|
|
newptr->point_size = *fontsize;
|
|
}
|
|
}
|
|
|
|
/* check font-weight */
|
|
if (!DOM_StyleGetProperty(cx, db, node, FONTWEIGHT_STYLE, &entry))
|
|
goto done;
|
|
if (entry) {
|
|
uint32 weight;
|
|
/*
|
|
* For "bolder" and "lighter", we need to keep them dirty because they're
|
|
* dependent on the enclosing state.
|
|
*/
|
|
if (!DOM_GetCleanEntryData(cx, entry, FontWeightToData, NULL, &weight, NULL))
|
|
goto done;
|
|
if (weight) {
|
|
if (!newptr->font_weight) {
|
|
COW();
|
|
newptr->font_weight = 400;
|
|
}
|
|
if (weight == FONT_WEIGHT_BOLDER) {
|
|
weight = MAX(newptr->font_weight + 100, 100);
|
|
entry->dirty = JS_TRUE;
|
|
} else if (weight == FONT_WEIGHT_LIGHTER) {
|
|
weight = MIN(newptr->font_weight - 100, 900);
|
|
entry->dirty = JS_TRUE;
|
|
}
|
|
if (weight != (uint32)newptr->font_weight) {
|
|
COW();
|
|
newptr->font_weight = weight;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* font-style */
|
|
if (!DOM_StyleGetProperty(cx, db, node, FONTSTYLE_STYLE, &entry))
|
|
goto done;
|
|
if (entry) {
|
|
if (!strcasecomp(entry->value, NORMAL_STYLE)) {
|
|
/* { font-style:normal} */
|
|
if (newptr->fontmask & LO_FONT_ITALIC) {
|
|
COW();
|
|
newptr->fontmask &= ~LO_FONT_ITALIC;
|
|
}
|
|
} else if (!strcasecomp(entry->value, ITALIC_STYLE)) {
|
|
/* { font-style:italic} */
|
|
if (!(newptr->fontmask & LO_FONT_ITALIC)) {
|
|
COW();
|
|
newptr->fontmask |= LO_FONT_ITALIC;
|
|
}
|
|
}
|
|
/* XXX need LO_FONT_OBLIQUE */
|
|
}
|
|
|
|
/* text-decoration */
|
|
if (!DOM_StyleGetProperty(cx, db, node, TEXTDECORATION_STYLE, &entry))
|
|
goto done;
|
|
if (entry) {
|
|
uint32 attrs;
|
|
#define ATTRMASK (LO_ATTR_BLINK | LO_ATTR_STRIKEOUT | LO_ATTR_UNDERLINE)
|
|
if (!DOM_GetCleanEntryData(cx, entry, TextDecorationToData, NULL, &attrs, NULL))
|
|
goto done;
|
|
attrs = (tptr->attrmask & ~ATTRMASK) | (attrs & ATTRMASK);
|
|
if (attrs != tptr->attrmask) {
|
|
COW();
|
|
newptr->attrmask = attrs;
|
|
}
|
|
#undef ATTRMASK
|
|
}
|
|
|
|
#undef COW
|
|
done:
|
|
if (!isMutable && copied) {
|
|
tptr = lo_FetchTextAttr(state, &text_attr);
|
|
#ifdef DEBUG_shaver_textattr
|
|
fprintf(stderr, "returning new TextAttr: %p\n", tptr);
|
|
#endif
|
|
return tptr;
|
|
}
|
|
#ifdef DEBUG_shaver_textattr
|
|
fprintf(stderr, "returning unmodified TextAttr %p\n", tptr);
|
|
#endif
|
|
return tptr;
|
|
}
|
|
|
|
#define GET_UNSHARED_TEXT_ATTR(new, old) \
|
|
PR_BEGIN_MACRO \
|
|
if ((old)->refcnt != 1) { \
|
|
(new) = lo_NewCopyTextAttr(state, (old)); \
|
|
(old)->refcnt--; \
|
|
} else { \
|
|
(new) = (old); \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
void lo_SetColor( LO_Element *ele, LO_Color *color, lo_DocState *state,
|
|
Bool background)
|
|
{
|
|
LO_TextAttr *new_attr;
|
|
switch (ele->lo_any.type)
|
|
{
|
|
case LO_TEXTBLOCK:
|
|
GET_UNSHARED_TEXT_ATTR(new_attr, ele->lo_textBlock.text_attr);
|
|
ele->lo_textBlock.text_attr = new_attr;
|
|
break;
|
|
case LO_TEXT:
|
|
GET_UNSHARED_TEXT_ATTR(new_attr, ele->lo_text.text_attr);
|
|
ele->lo_text.text_attr = new_attr;
|
|
break;
|
|
case LO_BULLET:
|
|
GET_UNSHARED_TEXT_ATTR(new_attr, ele->lo_bullet.text_attr);
|
|
ele->lo_bullet.text_attr = new_attr;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
if (background)
|
|
{
|
|
new_attr->bg = *color;
|
|
new_attr->no_background = FALSE;
|
|
}
|
|
else
|
|
{
|
|
new_attr->fg = *color;
|
|
}
|
|
}
|
|
#endif /* DOM */
|
|
|
|
#ifdef TEST_16BIT
|
|
#undef XP_WIN16
|
|
#endif /* TEST_16BIT */
|
|
|
|
#ifdef PROFILE
|
|
#pragma profile off
|
|
#endif
|