gecko-dev/lib/layout/clipline.c
1998-07-23 17:44:04 +00:00

531 lines
12 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 "layout.h"
#include "pa_parse.h"
static LO_Element *lo_duplicate_element(MWContext *context, lo_DocState *state,
int32 block_watch, LO_Element *eptr);
#ifdef XP_WIN16
#define SIZE_LIMIT 32000
#endif
static LO_Element *
lo_line_to_element(lo_DocState *state, int32 line)
{
LO_Element *eptr;
LO_Element **line_array;
#ifdef XP_WIN16
intn a_size;
intn a_indx;
intn a_line;
XP_Block *larray_array;
#endif /* XP_WIN16 */
if (line >= (state->line_num - 1))
{
return(NULL);
}
#ifdef XP_WIN16
a_size = SIZE_LIMIT / sizeof(LO_Element *);
a_indx = (intn)(line / a_size);
a_line = (intn)(line - (a_indx * a_size));
XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array);
state->line_array = larray_array[a_indx];
XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
eptr = line_array[a_line];
XP_UNLOCK_BLOCK(state->line_array);
XP_UNLOCK_BLOCK(state->larray_array);
#else
XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
eptr = line_array[line];
XP_UNLOCK_BLOCK(state->line_array);
#endif /* XP_WIN16 */
return(eptr);
}
static void
lo_set_element_to_line(lo_DocState *state, LO_Element *eptr, int32 line)
{
LO_Element **line_array;
#ifdef XP_WIN16
intn a_size;
intn a_indx;
intn a_line;
XP_Block *larray_array;
#endif /* XP_WIN16 */
if (line >= (state->line_num - 1))
{
return;
}
#ifdef XP_WIN16
a_size = SIZE_LIMIT / sizeof(LO_Element *);
a_indx = (intn)(line / a_size);
a_line = (intn)(line - (a_indx * a_size));
XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array);
state->line_array = larray_array[a_indx];
XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
line_array[a_line] = eptr;
XP_UNLOCK_BLOCK(state->line_array);
XP_UNLOCK_BLOCK(state->larray_array);
#else
XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
line_array[line] = eptr;
XP_UNLOCK_BLOCK(state->line_array);
#endif /* XP_WIN16 */
}
static void
lo_duplicate_cell(MWContext *context, lo_DocState *state, int32 block_watch,
LO_CellStruct *old_cell, LO_CellStruct *new_cell)
{
LO_Element *list_ptr;
LO_Element *tail_ptr;
LO_Element *eptr;
/*
* Duplicate the cells normal list of elements.
*/
list_ptr = NULL;
eptr = old_cell->cell_list;
if (eptr != NULL)
{
list_ptr = lo_duplicate_element(context, state,
block_watch, eptr);
eptr = eptr->lo_any.next;
}
tail_ptr = list_ptr;
while (eptr != NULL)
{
tail_ptr->lo_any.next = lo_duplicate_element(context, state,
block_watch, eptr);
tail_ptr = tail_ptr->lo_any.next;
eptr = eptr->lo_any.next;
}
if (tail_ptr != NULL)
{
tail_ptr->lo_any.next = NULL;
}
new_cell->cell_list = list_ptr;
new_cell->cell_list_end = tail_ptr;
/*
* Duplicate the cells floating list of elements.
*/
list_ptr = NULL;
eptr = old_cell->cell_float_list;
if (eptr != NULL)
{
list_ptr = lo_duplicate_element(context, state,
block_watch, eptr);
eptr = eptr->lo_any.next;
}
tail_ptr = list_ptr;
while (eptr != NULL)
{
tail_ptr->lo_any.next = lo_duplicate_element(context, state,
block_watch, eptr);
tail_ptr = tail_ptr->lo_any.next;
eptr = eptr->lo_any.next;
}
if (tail_ptr != NULL)
{
tail_ptr->lo_any.next = NULL;
}
new_cell->cell_float_list = list_ptr;
}
static LO_Element *
lo_duplicate_element(MWContext *context, lo_DocState *state,
int32 block_watch, LO_Element *eptr)
{
LO_Element *ret_eptr;
if (eptr == NULL)
{
return(NULL);
}
ret_eptr = lo_NewElement(context, state, eptr->type, NULL, 0);
if (ret_eptr == NULL)
{
return(NULL);
}
switch(eptr->type)
{
case LO_TEXT:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_TextStruct));
break;
case LO_LINEFEED:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_LinefeedStruct));
break;
case LO_HRULE:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_HorizRuleStruct));
break;
case LO_IMAGE:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_ImageStruct));
#ifndef M12N /* XXXM12N */
(void)IL_ReplaceImage(context,
(LO_ImageStruct *)ret_eptr,
(LO_ImageStruct *)eptr);
#else
((LO_ImageStruct *)ret_eptr)->image_req =
((LO_ImageStruct *)eptr)->image_req;
#endif /* M12N */
FE_ShiftImage(context, (LO_ImageStruct *)ret_eptr);
break;
case LO_BULLET:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_BulletStruct));
break;
case LO_FORM_ELE:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_FormElementStruct));
break;
case LO_SUBDOC:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_SubDocStruct));
break;
case LO_TABLE:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_TableStruct));
break;
case LO_CELL:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_CellStruct));
lo_duplicate_cell(context, state, block_watch,
(LO_CellStruct *)eptr,
(LO_CellStruct *)ret_eptr);
break;
case LO_EMBED:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_EmbedStruct));
break;
case LO_BUILTIN:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_BuiltinStruct));
break;
#ifdef JAVA
case LO_JAVA:
XP_BCOPY((char *)eptr, (char *)(ret_eptr),
sizeof(LO_JavaAppStruct));
break;
#endif
case LO_NONE:
case LO_UNKNOWN:
ret_eptr = NULL;
break;
}
/*
* If we have duplicated the blocking element, set its
* new pointer into state.
*/
if ((ret_eptr != NULL)&&(block_watch != -1))
{
if (ret_eptr->lo_any.ele_id == block_watch)
{
state->top_state->layout_blocking_element =
ret_eptr;
block_watch = -1;
}
}
return(ret_eptr);
}
void
lo_ClipLines(MWContext *context, lo_DocState *state, int32 line)
{
int32 i;
int32 dy;
int32 block_watch;
LO_Element *start_clipping;
LO_Element *end_clipping;
LO_Element *eptr;
LO_Element *end_ptr;
LO_Element *end_last_line;
LO_Element *float_list;
LO_Element *float_ptr;
#ifdef MEMORY_ARENAS
lo_arena *old_first_arena;
lo_arena *old_current_arena;
/*
* Save off the current memory arena, and make a new one.
*/
old_first_arena = state->top_state->first_arena;
old_current_arena = state->top_state->current_arena;
state->top_state->first_arena = NULL;
state->top_state->current_arena = NULL;
lo_InitializeMemoryArena(state->top_state);
if (state->top_state->first_arena == NULL)
{
state->top_state->out_of_memory = TRUE;
state->top_state->first_arena = old_first_arena;
state->top_state->current_arena = old_current_arena;
return;
}
#endif /* MEMORY_ARENAS */
/*
* Clear the selection (if any).
*/
LO_HighlightSelection(context, FALSE);
state->selection_start = NULL;
state->selection_start_pos = 0;
state->selection_end = NULL;
state->selection_end_pos = 0;
/*
* If there is a blocked element that changes, watch it and reset
* it properly.
*/
block_watch = -1;
if (state->top_state->layout_blocking_element != NULL)
{
block_watch =
state->top_state->layout_blocking_element->lo_any.ele_id;
}
dy = 0;
/*
* Delete all elements in the lines being clipped off.
*/
start_clipping = lo_line_to_element(state, 0);
end_clipping = lo_line_to_element(state, line);
if ((end_clipping != NULL)&&(start_clipping != NULL))
{
dy = end_clipping->lo_any.y - start_clipping->lo_any.y;
}
while ((start_clipping != NULL)&&(start_clipping != end_clipping))
{
lo_ScrapeElement(context, start_clipping, TRUE);
start_clipping = start_clipping->lo_any.next;
}
/*
* Loop through all the lines after the clipped line.
*/
end_last_line = NULL;
for (i=0; i < (state->line_num - line - 1); i++)
{
LO_Element *line_start;
LO_Element *lptr;
/*
* Find the start of this line, and the start of
* the next line.
*/
eptr = lo_line_to_element(state, (line + i));
end_ptr = lo_line_to_element(state, (line + 1 + i));
if (eptr != NULL)
{
line_start = lo_duplicate_element(context, state,
block_watch, eptr);
lptr = line_start;
eptr = eptr->lo_any.next;
}
else
{
line_start = NULL;
lptr = NULL;
}
/*
* Set the start of this new line into the line array.
*/
lo_set_element_to_line(state, line_start, i);
/*
* Copy all the elements in the line.
*/
while (eptr != end_ptr)
{
lptr->lo_any.y -= dy;
if (lptr->type == LO_CELL)
{
lo_ShiftCell((LO_CellStruct *)lptr, 0, -dy);
}
else if (lptr->type == LO_IMAGE)
{
FE_ShiftImage(context, (LO_ImageStruct *)lptr);
}
lptr->lo_any.next = lo_duplicate_element(context, state,
block_watch, eptr);
if (lptr->lo_any.next == NULL)
{
break;
}
lptr->lo_any.next->lo_any.prev = lptr;
lptr = lptr->lo_any.next;
eptr = eptr->lo_any.next;
}
if (lptr != NULL)
{
lptr->lo_any.y -= dy;
if (lptr->type == LO_CELL)
{
lo_ShiftCell((LO_CellStruct *)lptr, 0, -dy);
}
else if (lptr->type == LO_IMAGE)
{
FE_ShiftImage(context, (LO_ImageStruct *)lptr);
}
lptr->lo_any.next = NULL;
}
/*
* Link the beginning of the line we just copied to
* the end of the last line.
*/
line_start->lo_any.prev = end_last_line;
if (end_last_line != NULL)
{
end_last_line->lo_any.next = line_start;
}
end_last_line = lptr;
lptr->lo_any.next = NULL;
}
/*
* Clear the extra slots at the end.
*/
for (i = (state->line_num - line - 1); i < (state->line_num - 1); i++)
{
lo_set_element_to_line(state, NULL, i);
}
float_list = NULL;
float_ptr = NULL;
eptr = state->float_list;
while (eptr != NULL)
{
/*
* Floating elements that move up off the top are deleted.
*/
if ((eptr->lo_any.y - dy) < 0)
{
lo_ScrapeElement(context, eptr, TRUE);
eptr = eptr->lo_any.next;
continue;
}
if (float_list == NULL)
{
float_list = lo_duplicate_element(context, state,
block_watch, eptr);
float_ptr = float_list;
}
else
{
float_ptr->lo_any.next = lo_duplicate_element(context,
state, block_watch, eptr);
float_ptr = float_ptr->lo_any.next;
}
float_ptr->lo_any.y -= dy;
if (float_ptr->type == LO_CELL)
{
lo_ShiftCell((LO_CellStruct *)float_ptr, 0, -dy);
}
else if (float_ptr->type == LO_IMAGE)
{
FE_ShiftImage(context, (LO_ImageStruct *)float_ptr);
}
eptr = eptr->lo_any.next;
}
if (float_ptr != NULL)
{
float_ptr->lo_any.next = NULL;
}
/*
* If there are blocked tags, one of them may be holded
* a partially fetched blocked image element, duplicate it.
*/
if (state->top_state->tags != NULL)
{
PA_Tag *tag_ptr;
tag_ptr = state->top_state->tags;
while (tag_ptr != NULL)
{
if ((tag_ptr->type == P_IMAGE)&&
(tag_ptr->lo_data != NULL))
{
LO_Element *new_eptr;
LO_Element *eptr;
eptr = (LO_Element *)tag_ptr->lo_data;
new_eptr = lo_duplicate_element(context, state,
block_watch, eptr);
tag_ptr->lo_data = (void *)new_eptr;
}
tag_ptr = tag_ptr->next;
}
}
state->line_num -= line;
state->y -= dy;
state->end_last_line = end_last_line;
state->float_list = float_list;
state->current_ele = NULL;
lo_ShiftMarginsUp(context, state, dy);
/*
* If we had a blocking element that didn't get duplicated, we don't
* know what happened to it.
*/
if (block_watch != -1)
{
state->top_state->layout_blocking_element = NULL;
}
#ifdef MEMORY_ARENAS
(void)lo_FreeMemoryArena(old_first_arena);
#endif /* MEMORY_ARENAS */
}