/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- * * The contents of this file are subject to the Netscape Public License * Version 1.0 (the "NPL"); you may not use this file except in * compliance with the NPL. You may obtain a copy of the NPL at * http://www.mozilla.org/NPL/ * * Software distributed under the NPL is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL * for the specific language governing rights and limitations under the * NPL. * * The Initial Developer of this code under the NPL is Netscape * Communications Corporation. Portions created by Netscape are * Copyright (C) 1998 Netscape Communications Corporation. All Rights * Reserved. */ #include "xp.h" #include "pa_parse.h" #include "layout.h" #include "laylayer.h" #include "np.h" #include "laystyle.h" #include "edt.h" #ifdef TEST_16BIT #define XP_WIN16 #endif /* TEST_16BIT */ #define TABLE_BORDERS_ON 1 #define TABLE_BORDERS_OFF 0 #define TABLE_BORDERS_GONE -1 #define TABLE_DEF_INNER_CELL_PAD 1 #define TABLE_DEF_INTER_CELL_PAD 2 #define TABLE_DEF_CELL_BORDER 1 #define TABLE_DEF_BORDER 0 #define TABLE_DEF_BORDER_STYLE BORDER_SOLID #define TABLE_DEF_VERTICAL_SPACE 0 #define TABLE_DEF_HORIZONTAL_SPACE 0 #define TABLE_MAX_COLSPAN 1000 #define TABLE_MAX_ROWSPAN 10000 typedef struct lo_cell_data_struct { #ifdef XP_WIN16 /* * This struct must be a power of 2 if we are going to allocate an * array of more than 128K */ unsigned width, height; #else int32 width, height; #endif lo_TableCell *cell; } lo_cell_data; LO_SubDocStruct * lo_EndCellSubDoc(MWContext *context, lo_DocState *state, lo_DocState *old_state, LO_Element *element, Bool relayout); LO_SubDocStruct * lo_RelayoutCaptionSubdoc(MWContext *context, lo_DocState *state, lo_TableCaption *caption, LO_SubDocStruct *subdoc, int32 width, Bool is_a_header); LO_CellStruct * lo_RelayoutCell(MWContext *context, lo_DocState *state, LO_SubDocStruct *subdoc, lo_TableCell *cell_ptr, LO_CellStruct *cell, int32 width, Bool is_a_header, Bool relayout); void lo_BeginCaptionSubDoc(MWContext *context, lo_DocState *state, lo_TableCaption *caption, PA_Tag *tag); void lo_BeginCellSubDoc(MWContext *context, lo_DocState *state, lo_TableRec *table, char *bgcolor_attr, char *background_attr, lo_TileMode tile_mode, char *valign_attr, char *halign_attr, char *width_attr, char *height_attr, Bool is_a_header, intn draw_borders, Bool relayout); Bool lo_subdoc_has_elements(lo_DocState *sub_state); Bool lo_cell_has_elements(LO_CellStruct *cell); int32 lo_align_subdoc(MWContext *context, lo_DocState *state, lo_DocState *old_state, LO_SubDocStruct *subdoc, lo_TableRec *table, lo_table_span *row_max); int32 lo_align_cell(MWContext *context, lo_DocState *state, lo_TableCell *cell_ptr, LO_CellStruct *cell, lo_TableRec *table, lo_table_span *row_max); static void lo_reuse_current_state(MWContext *context, lo_DocState *state, int32 width, int32 height, int32 margin_width, int32 margin_height, Bool destroyLineLists); static void lo_FreeAllExceptRows( MWContext *context, lo_DocState *state, lo_TableRec *table ); static void lo_FreeTableSpanArray( lo_table_span *spanArray ); /* ******************************************************************************** * Some Helper Functions */ static int32 lo_CalculateCellPercentWidth( lo_TableRec *table, int32 percent); static int32 lo_CalculateCellPercentHeight( lo_TableRec *table, lo_TableCell *table_cell); static int32 lo_ComputeCellEmptySpace(MWContext *context,lo_TableRec *table, LO_SubDocStruct *subdoc); static int32 lo_FindDefaultCellWidth(MWContext * context, lo_TableRec *table, lo_TableCell *table_cell, int32 desired_width, int32 cell_empty_space); static int32 lo_ComputeInternalTableWidth(MWContext *context, lo_TableRec *table, lo_DocState *state); static void lo_SetDefaultCellWidth(MWContext *context, lo_TableRec *table, LO_SubDocStruct *subdoc, lo_TableCell *table_cell, int32 cell_width); static void lo_ResetWidthSpans( lo_TableRec *table ); static void lo_UpdateCaptionCellFromSubDoc( MWContext *context, lo_DocState *state, LO_SubDocStruct *subdoc, LO_CellStruct *cell_ele); static void lo_FreeCaptionCell( MWContext *context, lo_DocState *state, LO_CellStruct *cell_ele); static void lo_FreeTableCaption( MWContext *context, lo_DocState *state, lo_TableRec *table ); static int32 lo_ComputeCellEmptySpace(MWContext *context, lo_TableRec *table, LO_SubDocStruct *subdoc) { int32 left_inner_pad; int32 right_inner_pad; int32 cell_empty_space; left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); cell_empty_space = (2 * subdoc->border_width) + (2 * subdoc->border_horiz_space) + (left_inner_pad + right_inner_pad); return cell_empty_space; } /* * Handle Fixed Table Layout. If the table has a COLS attribute * then the width of this cell may already be specified. The * trick is to know if this is the first row of the table. If * so, then this cell can choose it's width. */ static int32 lo_FindDefaultCellWidth(MWContext * context, lo_TableRec *table, lo_TableCell *table_cell, int32 desired_width, int32 cell_empty_space) { lo_TableRow * row_ptr; int32 cell_num; int32 cell_width; int32 count; int32 cell_pad; cell_pad = FEUNITS_X(table->inter_cell_pad, context); row_ptr = table->row_ptr; cell_num = row_ptr->cells; /* if we don't have a width table or we're out of bounds, bail */ if ( table->fixed_col_widths == NULL || ((cell_num+table_cell->colspan) > table->fixed_cols) ) { table->fixed_cols = 0; table->default_cell_width = 0; return desired_width; } /* does this cell already have a width defined? */ cell_width = table->fixed_col_widths[ cell_num ]; if ( cell_width == 0 ) { int32 col_width; /* use it's desired width or the default */ cell_width = desired_width; if ( cell_width == 0 ) { /* * Get our size from the default cell width. We * may need to clip it to the table width remaining. */ cell_width = table->default_cell_width * table_cell->colspan; /* * If this is bigger than the width remaining the the table, then * clip to the remaining space. If the table is already full, then * we're going for broke and the cell gets all of it. */ if ( ( table->fixed_width_remaining > 0 ) && ( cell_width > table->fixed_width_remaining ) ) { cell_width = table->fixed_width_remaining; } table->fixed_width_remaining -= cell_width; /* * Remove any cell spacing so the cell will internally * layout to the correct size. */ cell_width -= cell_empty_space * table_cell->colspan; } else { /* * The cell has a specified size. Allocate all of it. If we * don't have enough space, then we'll keep doing fixed layout, * but the table may end up larger than expected. */ table->fixed_width_remaining -= cell_width + cell_empty_space; } /* make sure this stays reasonable */ if ( table->fixed_width_remaining < 0 ) { table->fixed_width_remaining = 0; } /* fill out the apropriate number of col widths */ col_width = cell_width / table_cell->colspan; for ( count = table_cell->colspan; count > 0 ; --count ) { table->fixed_col_widths[ cell_num ] = col_width; cell_num++; } /* add any odd amount to the last column */ table->fixed_col_widths[ cell_num-1 ] += (cell_width- (col_width * table_cell->colspan)); } else { /* add up widths of each column our cell spans */ for ( count = 1; count < table_cell->colspan; ++count ) { cell_width += table->fixed_col_widths[ cell_num+count ]; } } /* * Add the empty space this cell spans */ cell_width += ( table_cell->colspan - 1 ) * ( cell_empty_space + cell_pad ); return cell_width; } /* * For fixed layout, set the cell width for a cell after layout. This is used * for cases where we don't know how wide a cell is until after it's been layed * out (for example, when NOWRAP is set). * * We will have already chosen a default width for this cell. If our new width * is larger, then we need to resize the column/s. */ static void lo_SetDefaultCellWidth(MWContext *context, lo_TableRec *table, LO_SubDocStruct *subdoc, lo_TableCell *table_cell, int32 cell_width) { lo_TableRow * row_ptr; int32 cell_num; int32 count; int32 cur_width; int32 add_width; int32 cell_empty_space; int32 cell_pad; row_ptr = table->row_ptr; cell_num = row_ptr->cells; /* if we don't have a width table or we're out of bounds, bail */ if ( table->fixed_col_widths == NULL || ((cell_num+table_cell->colspan) > table->fixed_cols) ) { table->fixed_cols = 0; table->default_cell_width = 0; return; } /* * Figure out the current width for these cells */ cur_width = 0; for ( count = table_cell->colspan-1; count >= 0 ; --count ) { cur_width += table->fixed_col_widths[ cell_num+count ]; } /* * Add space for the empty space that this cell spans */ cell_empty_space = lo_ComputeCellEmptySpace(context, table, subdoc ); cell_pad = FEUNITS_X(table->inter_cell_pad, context); cur_width += ( table_cell->colspan - 1 ) * ( cell_empty_space + cell_pad ); /* * If our new width is bigger, we need to grow the default width */ if ( cell_width > cur_width ) { cell_width -= cur_width; add_width = cell_width / table_cell->colspan; table->fixed_width_remaining -= add_width; if ( table->fixed_width_remaining < 0 ) { table->fixed_width_remaining = 0; } for ( count = table_cell->colspan; count > 0 ; --count ) { table->fixed_col_widths[ cell_num ] += add_width; cell_width -= add_width; cell_num++; } /* add any odd amount to the last column */ table->fixed_col_widths[ cell_num-1 ] += cell_width; } } static int32 lo_ComputeInternalTableWidth(MWContext *context,lo_TableRec *table, lo_DocState *state) { int32 table_width; int32 cell_pad; int32 table_pad; cell_pad = FEUNITS_X(table->inter_cell_pad, context); table_width = table->width; if ( table_width == 0 ) { /* Compute our starting width as the window width */ table_width = (state->win_width - state->win_left - state->win_right); } /* remove space for the table borders */ table_width -= ( table->table_ele->border_left_width + table->table_ele->border_right_width ); if (table->draw_borders == TABLE_BORDERS_OFF) { table_pad = FEUNITS_X(TABLE_DEF_CELL_BORDER, context); table_width -= 2 * table_pad; } if ( table->fixed_cols > 0 ) { table_width -= ( table->fixed_cols + 1 ) * cell_pad; } else { table_width -= ( table->cols + 1 ) * cell_pad; } return table_width; } /* ******************************************************************************** * Core Table Layout Code */ void lo_BeginCaptionSubDoc(MWContext *context, lo_DocState *state, lo_TableCaption *caption, PA_Tag *tag) { LO_SubDocStruct *subdoc; lo_DocState *new_state; int32 first_width, first_height; Bool allow_percent_width; Bool allow_percent_height; /* * Fill in the subdoc structure with default data */ subdoc = (LO_SubDocStruct *)lo_NewElement(context, state, LO_SUBDOC, NULL, 0); if (subdoc == NULL) { return; } subdoc->type = LO_SUBDOC; subdoc->ele_id = NEXT_ELEMENT; subdoc->x = state->x; subdoc->x_offset = 0; subdoc->y = state->y; subdoc->y_offset = 0; subdoc->width = 0; subdoc->height = 0; subdoc->next = NULL; subdoc->prev = NULL; subdoc->anchor_href = state->current_anchor; if (state->font_stack == NULL) { subdoc->text_attr = NULL; } else { subdoc->text_attr = state->font_stack->text_attr; } subdoc->FE_Data = NULL; subdoc->backdrop.bg_color = NULL; subdoc->backdrop.url = NULL; subdoc->backdrop.tile_mode = LO_TILE_BOTH; subdoc->state = NULL; subdoc->vert_alignment = LO_ALIGN_CENTER; subdoc->horiz_alignment = caption->horiz_alignment; subdoc->alignment = LO_ALIGN_BOTTOM; subdoc->border_width = 0; subdoc->border_vert_space = 0; subdoc->border_horiz_space = 0; subdoc->ele_attrmask = 0; subdoc->sel_start = -1; subdoc->sel_end = -1; subdoc->border_width = FEUNITS_X(subdoc->border_width, context); if (subdoc->width == 0) { first_width = FEUNITS_X(5000, context); allow_percent_width = FALSE; } else { first_width = subdoc->width; allow_percent_width = TRUE; } if (subdoc->height == 0) { first_height = FEUNITS_Y(10000, context); allow_percent_height = FALSE; } else { first_height = subdoc->height; allow_percent_height = TRUE; } new_state = lo_NewLayout(context, first_width, first_height, 0, 0, NULL); if (new_state == NULL) { lo_FreeElement(context, (LO_Element *)subdoc, FALSE); return; } new_state->is_a_subdoc = SUBDOC_CAPTION; lo_InheritParentState(context, new_state, state); new_state->allow_percent_width = allow_percent_width; new_state->allow_percent_height = allow_percent_height; new_state->base_x = 0; new_state->base_y = 0; new_state->display_blocked = TRUE; if (subdoc->width == 0) { new_state->delay_align = TRUE; } new_state->win_left = 0; new_state->win_right = 0; new_state->x = new_state->win_left; new_state->y = 0; new_state->max_width = new_state->x + 1; new_state->left_margin = new_state->win_left; new_state->right_margin = new_state->win_width - new_state->win_right; new_state->list_stack->old_left_margin = new_state->left_margin; new_state->list_stack->old_right_margin = new_state->right_margin; /* * Initialize the alignment stack for this state * to match the caption alignment. */ if (subdoc->horiz_alignment != LO_ALIGN_LEFT) { lo_PushAlignment(new_state, tag->type, subdoc->horiz_alignment); } state->sub_state = new_state; state->current_ele = (LO_Element *)subdoc; /* * We added a new state. */ lo_PushStateLevel ( context ); } static void lo_reuse_current_state(MWContext *context, lo_DocState *state, int32 width, int32 height, int32 margin_width, int32 margin_height, Bool destroyLineLists) { lo_TopState *top_state; int32 doc_id; lo_DocLists *doc_lists; doc_id = XP_DOCID(context); top_state = lo_FetchTopState(doc_id); if ((top_state == NULL)||(state == NULL)) { return; } state->subdoc_tags = NULL; state->subdoc_tags_end = NULL; state->text_fg.red = lo_master_colors[LO_COLOR_FG].red; state->text_fg.green = lo_master_colors[LO_COLOR_FG].green; state->text_fg.blue = lo_master_colors[LO_COLOR_FG].blue; state->text_bg.red = lo_master_colors[LO_COLOR_BG].red; state->text_bg.green = lo_master_colors[LO_COLOR_BG].green; state->text_bg.blue = lo_master_colors[LO_COLOR_BG].blue; state->anchor_color.red = lo_master_colors[LO_COLOR_LINK].red; state->anchor_color.green = lo_master_colors[LO_COLOR_LINK].green; state->anchor_color.blue = lo_master_colors[LO_COLOR_LINK].blue; state->visited_anchor_color.red = lo_master_colors[LO_COLOR_VLINK].red; state->visited_anchor_color.green = lo_master_colors[LO_COLOR_VLINK].green; state->visited_anchor_color.blue = lo_master_colors[LO_COLOR_VLINK].blue; state->active_anchor_color.red = lo_master_colors[LO_COLOR_ALINK].red; state->active_anchor_color.green = lo_master_colors[LO_COLOR_ALINK].green; state->active_anchor_color.blue = lo_master_colors[LO_COLOR_ALINK].blue; state->win_top = margin_height; state->win_bottom = margin_height; state->win_width = width; state->win_height = height; state->base_x = 0; state->base_y = 0; state->x = 0; state->y = 0; state->width = 0; state->line_num = 1; state->win_left = margin_width; state->win_right = margin_width; state->max_width = state->win_left + state->win_right; state->x = state->win_left; state->y = state->win_top; state->left_margin = state->win_left; state->right_margin = state->win_width - state->win_right; if (state->left_margin_stack != NULL) { lo_MarginStack *mptr; lo_MarginStack *margin; mptr = state->left_margin_stack; while (mptr != NULL) { margin = mptr; mptr = mptr->next; XP_DELETE(margin); } state->left_margin_stack = NULL; } if (state->right_margin_stack != NULL) { lo_MarginStack *mptr; lo_MarginStack *margin; mptr = state->right_margin_stack; while (mptr != NULL) { margin = mptr; mptr = mptr->next; XP_DELETE(margin); } state->right_margin_stack = NULL; } state->break_holder = state->x; state->min_width = 0; state->text_divert = P_UNKNOWN; state->linefeed_state = 2; state->delay_align = FALSE; state->breakable = TRUE; state->allow_amp_escapes = TRUE; state->preformatted = PRE_TEXT_NO; state->preformat_cols = 0; state->in_paragraph = FALSE; state->display_blocked = FALSE; state->display_blocking_element_id = 0; state->display_blocking_element_y = 0; if (destroyLineLists == TRUE) { if (state->line_list != NULL) { lo_FreeElementList(context, state->line_list); state->line_list = NULL; } state->end_last_line = NULL; if (state->float_list != NULL) { lo_FreeElementList(context, state->float_list); state->float_list = NULL; } } state->base_font_size = DEFAULT_BASE_FONT_SIZE; if (state->font_stack != NULL) { lo_FontStack *fstack; lo_FontStack *fptr; fptr = state->font_stack; while (fptr != NULL) { fstack = fptr; fptr = fptr->next; XP_DELETE(fstack); } state->font_stack = NULL; } state->font_stack = lo_DefaultFont(state, context); state->font_stack->text_attr->size = state->base_font_size; if (state->align_stack != NULL) { lo_AlignStack *aptr; lo_AlignStack *align; aptr = state->align_stack; while (aptr != NULL) { align = aptr; aptr = aptr->next; XP_DELETE(align); } state->align_stack = NULL; } if (state->list_stack != NULL) { lo_ListStack *lptr; lo_ListStack *list; lptr = state->list_stack; while (lptr != NULL) { list = lptr; lptr = lptr->next; XP_DELETE(list); } state->list_stack = NULL; } state->list_stack = lo_DefaultList(state); state->text_info.max_width = 0; state->text_info.ascent = 0; state->text_info.descent = 0; state->text_info.lbearing = 0; state->text_info.rbearing = 0; state->line_buf_len = 0; state->baseline = 0; state->line_height = 0; state->break_pos = -1; state->break_width = 0; state->last_char_CR = FALSE; state->trailing_space = FALSE; state->at_begin_line = TRUE; state->old_break = NULL; state->old_break_block = NULL; state->old_break_pos = -1; state->old_break_width = 0; #ifdef DOM state->current_span = NULL; state->in_span = FALSE; #endif state->current_named_anchor = NULL; state->current_anchor = NULL; state->cur_ele_type = LO_NONE; state->current_ele = NULL; state->current_java = NULL; state->current_table = NULL; state->current_grid = NULL; state->current_multicol = NULL; if (state->top_state->doc_state) doc_lists = lo_GetCurrentDocLists(state->top_state->doc_state); else doc_lists = lo_GetCurrentDocLists(state); /* * These values are saved into the (sub)doc here * so that if it gets Relayout() later, we know where * to reset the from counts to. */ if (doc_lists->form_list != NULL) { lo_FormData *form_list; form_list = doc_lists->form_list; state->form_ele_cnt = form_list->form_ele_cnt; state->form_id = form_list->id; } else { state->form_ele_cnt = 0; state->form_id = 0; } state->start_in_form = top_state->in_form; if (top_state->savedData.FormList != NULL) { lo_SavedFormListData *all_form_ele; all_form_ele = top_state->savedData.FormList; state->form_data_index = all_form_ele->data_index; } else { state->form_data_index = 0; } /* * Remember number of embeds we had before beginning this * (sub)doc. This information is used in laytable.c so * it can preserve embed indices across a relayout. */ state->embed_count_base = top_state->embed_count; /* * Ditto for anchors, images, applets and embeds */ state->url_count_base = doc_lists->url_list_len; state->image_list_count_base = doc_lists->image_list_count; state->applet_list_count_base = doc_lists->applet_list_count; state->embed_list_count_base = doc_lists->embed_list_count; state->current_layer_num_base = top_state->current_layer_num; state->current_layer_num_max = top_state->current_layer_num; state->must_relayout_subdoc = FALSE; state->allow_percent_width = TRUE; state->allow_percent_height = TRUE; state->is_a_subdoc = SUBDOC_NOT; state->current_subdoc = 0; state->sub_documents = NULL; state->sub_state = NULL; state->current_cell = NULL; state->extending_start = FALSE; state->selection_start = NULL; state->selection_start_pos = 0; state->selection_end = NULL; state->selection_end_pos = 0; state->selection_new = NULL; state->selection_new_pos = 0; #ifdef EDITOR state->edit_force_offset = FALSE; state->edit_current_element = 0; state->edit_current_offset = 0; state->edit_relayout_display_blocked = FALSE; #endif #ifdef MOCHA state->in_relayout = FALSE; #endif state->cur_text_block = NULL; /* we need min widths during the initial table layout pass */ state->need_min_width = TRUE; } static void lo_reuse_current_subdoc(MWContext *context, LO_SubDocStruct *subdoc) { if (subdoc == NULL) { return; } subdoc->type = LO_SUBDOC; subdoc->ele_id = 0; subdoc->x = 0; subdoc->x_offset = 0; subdoc->y = 0; subdoc->y_offset = 0; subdoc->width = 0; subdoc->height = 0; subdoc->next = NULL; subdoc->prev = NULL; subdoc->FE_Data = NULL; /* * We leave subdoc->state alone as it will get reused later. */ XP_FREEIF(subdoc->backdrop.bg_color); XP_FREEIF(subdoc->backdrop.url); /* * These two come from lists of shared pointers, so * we NULL them but don't free them. */ subdoc->anchor_href = NULL; subdoc->text_attr = NULL; subdoc->alignment = LO_ALIGN_LEFT; subdoc->vert_alignment = LO_ALIGN_TOP; subdoc->horiz_alignment = LO_ALIGN_LEFT; subdoc->border_width = 0; subdoc->border_vert_space = 0; subdoc->border_horiz_space = 0; subdoc->ele_attrmask = 0; subdoc->sel_start = -1; subdoc->sel_end = -1; } static void lo_cleanup_old_state(lo_DocState *state) { LO_Element **line_array; if (state == NULL) { return; } /* * Clear out the start of the line_list. */ #ifdef XP_WIN16 { XP_Block *larray_array; XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array); state->line_array = larray_array[0]; XP_UNLOCK_BLOCK(state->larray_array); } #endif /* XP_WIN16 */ XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array); line_array[0] = NULL; XP_UNLOCK_BLOCK(state->line_array); state->end_last_line = NULL; state->float_list = NULL; } static int32 lo_CalculateCellPercentWidth( lo_TableRec *table, int32 percent) { int32 val = percent; if ( table->table_width_fixed != FALSE ) { val = table->width * val / 100; } else { val = 0; } return val; } static int32 lo_CalculateCellPercentHeight( lo_TableRec *table, lo_TableCell *table_cell) { int32 val; if ((table->height > 0)&& (table_cell->percent_height > 0)) { val = table->height * table_cell->percent_height / 100; } else { val = 0; } return val; } void lo_BeginCellSubDoc(MWContext *context, lo_DocState *state, lo_TableRec *table, char *bgcolor_attr, char *background_attr, lo_TileMode tile_mode, char *valign_attr, char *halign_attr, char *width_attr, char *height_attr, Bool is_a_header, intn draw_borders, Bool relayout /* Is true during relayout without reload */) { LO_SubDocStruct *subdoc; lo_DocState *new_state; lo_TableRow *table_row; lo_TableCell *table_cell; int32 val; int32 first_width, first_height; Bool allow_percent_width; Bool allow_percent_height; StyleStruct *style_struct=0; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_BeginCellSubDoc called\n"); #endif /* LOCAL_DEBUG */ table_row = table->row_ptr; table_cell = table_row->cell_ptr; if (relayout == FALSE) { if(state->top_state && state->top_state->style_stack) style_struct = STYLESTACK_GetStyleByIndex( state->top_state->style_stack, 0); } /* * Fill in the subdoc structure with default data */ lo_reuse_current_subdoc(context, table->current_subdoc); subdoc = table->current_subdoc; if (subdoc == NULL) { return; } subdoc->type = LO_SUBDOC; subdoc->ele_id = NEXT_ELEMENT; subdoc->x = state->x; subdoc->x_offset = 0; subdoc->y = state->y; subdoc->y_offset = 0; subdoc->width = 0; subdoc->height = 0; subdoc->next = NULL; subdoc->prev = NULL; subdoc->anchor_href = state->current_anchor; if (state->font_stack == NULL) { subdoc->text_attr = NULL; } else { subdoc->text_attr = state->font_stack->text_attr; } subdoc->FE_Data = NULL; subdoc->vert_alignment = table_row->vert_alignment; if (subdoc->vert_alignment == LO_ALIGN_DEFAULT) { subdoc->vert_alignment = LO_ALIGN_CENTER; } subdoc->horiz_alignment = table_row->horiz_alignment; if (subdoc->horiz_alignment == LO_ALIGN_DEFAULT) { if (is_a_header == FALSE) { subdoc->horiz_alignment = LO_ALIGN_LEFT; } else { subdoc->horiz_alignment = LO_ALIGN_CENTER; } } subdoc->alignment = LO_ALIGN_BOTTOM; if (draw_borders == TABLE_BORDERS_OFF) { subdoc->border_width = 0; subdoc->border_vert_space = TABLE_DEF_CELL_BORDER; subdoc->border_horiz_space = TABLE_DEF_CELL_BORDER; } else if (draw_borders == TABLE_BORDERS_ON) { subdoc->border_width = TABLE_DEF_CELL_BORDER; subdoc->border_vert_space = 0; subdoc->border_horiz_space = 0; } else { subdoc->border_width = 0; subdoc->border_vert_space = 0; subdoc->border_horiz_space = 0; } subdoc->ele_attrmask = 0; subdoc->sel_start = -1; subdoc->sel_end = -1; subdoc->backdrop.bg_color = NULL; subdoc->backdrop.url = NULL; subdoc->backdrop.tile_mode = LO_TILE_BOTH; /* * May inherit a bg_color from your row. */ if (table_row->backdrop.bg_color != NULL) { subdoc->backdrop.bg_color = XP_NEW(LO_Color); if (subdoc->backdrop.bg_color != NULL) *subdoc->backdrop.bg_color = *table_row->backdrop.bg_color; } if (relayout == FALSE) { subdoc->backdrop.bg_color = NULL; subdoc->backdrop.url = NULL; subdoc->backdrop.tile_mode = LO_TILE_BOTH; /* * May inherit a bg_color from your row. */ if (table_row->backdrop.bg_color != NULL) { subdoc->backdrop.bg_color = XP_NEW(LO_Color); if (subdoc->backdrop.bg_color != NULL) *subdoc->backdrop.bg_color = *table_row->backdrop.bg_color; } /* * Else may inherit a bg_color from your table. */ else if (table->backdrop.bg_color != NULL) { subdoc->backdrop.bg_color = XP_NEW(LO_Color); if (subdoc->backdrop.bg_color != NULL) *subdoc->backdrop.bg_color = *table->backdrop.bg_color; } /* * Else possibly inherit the background color attribute * of a parent table cell. */ else if (state->is_a_subdoc == SUBDOC_CELL) { lo_DocState *up_state; /* * Find the parent subdoc's state. */ up_state = state->top_state->doc_state; while ((up_state->sub_state != NULL)&& (up_state->sub_state != state)) { up_state = up_state->sub_state; } if ((up_state->sub_state != NULL)&& (up_state->current_ele != NULL)&& (up_state->current_ele->type == LO_SUBDOC)&& (up_state->current_ele->lo_subdoc.backdrop.bg_color != NULL)) { LO_Color *old_bg; old_bg = up_state->current_ele->lo_subdoc.backdrop.bg_color; subdoc->backdrop.bg_color = XP_NEW(LO_Color); if (subdoc->backdrop.bg_color != NULL) *subdoc->backdrop.bg_color = *old_bg; } } /* Use backdrop URL, if supplied. */ if (background_attr) { subdoc->backdrop.url = XP_STRDUP(background_attr); subdoc->backdrop.tile_mode = tile_mode; } /* * May inherit a backdrop_url from parent row. */ else if (table_row->backdrop.url) { subdoc->backdrop.url = XP_STRDUP(table_row->backdrop.url); subdoc->backdrop.tile_mode = table_row->backdrop.tile_mode; } /* * Else may inherit a backdrop_url from parent table. */ else if (table->backdrop.url != NULL) { subdoc->backdrop.url = XP_STRDUP(table->backdrop.url); subdoc->backdrop.tile_mode = table->backdrop.tile_mode; } /* * Else possibly inherit the backdrop_url * of a parent table cell. */ else if (state->is_a_subdoc == SUBDOC_CELL) { lo_DocState *up_state; /* * Find the parent subdoc's state. */ up_state = state->top_state->doc_state; while ((up_state->sub_state != NULL)&& (up_state->sub_state != state)) { up_state = up_state->sub_state; } if ((up_state->sub_state != NULL)&& (up_state->current_ele != NULL)&& (up_state->current_ele->type == LO_SUBDOC)&& (up_state->current_ele->lo_subdoc.backdrop.url != NULL)) { lo_Backdrop *src_backdrop = &up_state->current_ele->lo_subdoc.backdrop; subdoc->backdrop.url = XP_STRDUP(src_backdrop->url); subdoc->backdrop.tile_mode = src_backdrop->tile_mode; } } /* * Check for a background color attribute */ if (bgcolor_attr) { uint8 red, green, blue; LO_ParseRGB(bgcolor_attr, &red, &green, &blue); XP_FREEIF(subdoc->backdrop.bg_color); subdoc->backdrop.bg_color = XP_NEW(LO_Color); if (subdoc->backdrop.bg_color != NULL) { subdoc->backdrop.bg_color->red = red; subdoc->backdrop.bg_color->green = green; subdoc->backdrop.bg_color->blue = blue; } } /* check for a style sheet directive for bgcolor */ if(style_struct) { char *property = STYLESTRUCT_GetString(style_struct, BG_COLOR_STYLE); if(property) { uint8 red, green, blue; LO_ParseStyleSheetRGB(property, &red, &green, &blue); XP_FREEIF(subdoc->backdrop.bg_color); subdoc->backdrop.bg_color = XP_NEW(LO_Color); if (subdoc->backdrop.bg_color != NULL) { subdoc->backdrop.bg_color->red = red; subdoc->backdrop.bg_color->green = green; subdoc->backdrop.bg_color->blue = blue; } XP_FREE(property); } property = STYLESTRUCT_GetString(style_struct, BG_IMAGE_STYLE); if(property) { if(subdoc->backdrop.url) XP_FREE(subdoc->backdrop.url); subdoc->backdrop.url = NULL; if(strcasecomp(property, "none")) { subdoc->backdrop.url = XP_STRDUP(lo_ParseStyleSheetURL(property)); } XP_FREE(property); } property = STYLESTRUCT_GetString(style_struct, BG_REPEAT_STYLE); if(property) { if(!strcasecomp(property, BG_REPEAT_NONE_STYLE)) subdoc->backdrop.tile_mode = LO_NO_TILE; else if(!strcasecomp(property, BG_REPEAT_X_STYLE)) subdoc->backdrop.tile_mode = LO_TILE_HORIZ; else if(!strcasecomp(property, BG_REPEAT_Y_STYLE)) subdoc->backdrop.tile_mode = LO_TILE_VERT; else subdoc->backdrop.tile_mode = LO_TILE_BOTH; } } } else /* If relayout is TRUE */ { /* subdoc->backdrop.tile_mode = table_cell->cell->backdrop.tile_mode; if (table_cell->cell->backdrop.bg_color != NULL) { subdoc->backdrop.bg_color = XP_NEW(LO_Color); subdoc->backdrop.bg_color->red = table_cell->cell->backdrop.bg_color->red; subdoc->backdrop.bg_color->green = table_cell->cell->backdrop.bg_color->green; subdoc->backdrop.bg_color->blue = table_cell->cell->backdrop.bg_color->blue; } if (table_cell->cell->backdrop.url != NULL) { subdoc->backdrop.url = XP_STRDUP(table_cell->cell->backdrop.url); } */ subdoc->backdrop = table_cell->cell->backdrop; } /* * Check for a vertical align parameter */ if (valign_attr) { subdoc->vert_alignment = lo_EvalVAlignParam(valign_attr); } if(style_struct) { char *property = STYLESTRUCT_GetString(style_struct, VERTICAL_ALIGN_STYLE); if(property) { subdoc->vert_alignment = lo_EvalVAlignParam(property); XP_FREE(property); } } if (relayout) { subdoc->vert_alignment = table_cell->vert_alignment; } /* * Check for a horizontal align parameter */ if (halign_attr) { subdoc->horiz_alignment = lo_EvalCellAlignParam(halign_attr); } if (relayout) { subdoc->horiz_alignment = table_cell->horiz_alignment; } subdoc->border_width = FEUNITS_X(subdoc->border_width, context); subdoc->border_vert_space = FEUNITS_Y(subdoc->border_vert_space, context); subdoc->border_horiz_space = FEUNITS_X(subdoc->border_horiz_space, context); /* * Allow individual setting of cell * width and height. */ if (width_attr) { Bool is_percent; val = lo_ValueOrPercent(width_attr, &is_percent); if (is_percent != FALSE) { /* * Percentage width cells must be handled * later after at least the whole row is * processed. */ table_cell->percent_width = val; table_row->has_percent_width_cells = TRUE; table->has_percent_width_cells = TRUE; val = lo_CalculateCellPercentWidth( table, val ); /* Copied to lo_CalculateCellPercentWidth() */ /* if ( table->table_width_fixed != FALSE ) { val = table->width * val / 100; } else { val = 0; } */ } else { table_cell->percent_width = 0; val = FEUNITS_X(val, context); } if (val < 0) { val = 0; } subdoc->width = val; table_cell->specified_width = subdoc->width; } /* During relayout without reload, recalculate width of subdoc */ if (relayout) { if (table_cell->percent_width > 0) { subdoc->width = lo_CalculateCellPercentWidth( table, table_cell->percent_width); table_cell->specified_width = subdoc->width; } else { subdoc->width = table_cell->specified_width; if (subdoc->width < 0) { subdoc->width = 0; } } } /* * If we're in the fixed layout case, figure out what our cell * width should be. */ if ( table->fixed_cols > 0 ) { int32 cell_empty_space; int32 def_cell_width; int32 desired_width; cell_empty_space = lo_ComputeCellEmptySpace ( context, table, subdoc); desired_width = subdoc->width; /* * Obey percentage cell width in fixed columns if we * already know table width. */ if ((table_cell->percent_width > 0)&&(table->width > 0)) { int32 avail_width; int32 cell_pad; /* * Percentage width is a percentage of the available * cell space. */ cell_pad = FEUNITS_X(table->inter_cell_pad, context); avail_width = table->width - ((table->fixed_cols + 1) * cell_pad); avail_width -= (table->table_ele->border_left_width + table->table_ele->border_right_width); desired_width = avail_width * table_cell->percent_width / 100; /* * Pecentage width takes into account the * cell padding/spacing already. */ desired_width -= cell_empty_space; } def_cell_width = lo_FindDefaultCellWidth (context, table, table_cell, desired_width, cell_empty_space); /* * If NOWRAP is off, we can go ahead and layout to this width. Otherwise * we want to layout to a dynamic width and then use the bigger of the * default or computed width for the cell. */ if ( table_cell->nowrap == FALSE ) { subdoc->width = def_cell_width; } } if (height_attr) { Bool is_percent; val = lo_ValueOrPercent(height_attr, &is_percent); if (is_percent != FALSE) { /* * We can process percentage heights here if * we have a known table height. */ table_cell->percent_height = val; table->has_percent_height_cells = TRUE; val = lo_CalculateCellPercentHeight(table, table_cell); /* Copied to lo_CalculateCellPercentHeight() */ /* if ((table->height > 0)&& (table_cell->percent_height > 0)) { val = table->height * table_cell->percent_height / 100; } else { val = 0; } */ } else { table_cell->percent_height = 0; val = FEUNITS_X(val, context); } subdoc->height = val; if (subdoc->height < 0) { subdoc->height = 0; } table_cell->specified_height = subdoc->height; } /* During relayout without reload, recalculate height of subdoc */ if (relayout) { if (table_cell->percent_height > 0) { subdoc->height = lo_CalculateCellPercentHeight( table, table_cell); table_cell->specified_height = subdoc->height; } else { subdoc->height = table_cell->specified_height; if (subdoc->height < 0) { subdoc->height = 0; } } } if (subdoc->width == 0) { /* * Choose a default size that will fit within the current table. If NOWRAP is * on, we just want to go ahead and choose a big width so that we're sure * to get the correct nonwrapping text layout. */ if ( table_cell->nowrap == FALSE ) { first_width = lo_ComputeInternalTableWidth ( context, table, state ); first_width -= lo_ComputeCellEmptySpace ( context, table, subdoc); } else { first_width = FEUNITS_X(5000, context); } allow_percent_width = FALSE; } else { first_width = subdoc->width; allow_percent_width = TRUE; } if (subdoc->height == 0) { first_height = FEUNITS_Y(10000, context); allow_percent_height = FALSE; } else { first_height = subdoc->height; allow_percent_height = TRUE; } lo_reuse_current_state(context, subdoc->state, first_width, first_height, 0, 0, TRUE); new_state = subdoc->state; subdoc->state = NULL; if (new_state == NULL) { lo_FreeElement(context, (LO_Element *)subdoc, FALSE); return; } new_state->is_a_subdoc = SUBDOC_CELL; lo_InheritParentState(context, new_state, state); new_state->allow_percent_width = allow_percent_width; new_state->allow_percent_height = allow_percent_height; new_state->base_x = 0; new_state->base_y = 0; new_state->display_blocked = TRUE; if (subdoc->width == 0) { new_state->delay_align = TRUE; } new_state->win_left = 0; new_state->win_right = 0; new_state->x = new_state->win_left; new_state->y = 0; new_state->max_width = new_state->x + 1; new_state->left_margin = new_state->win_left; new_state->right_margin = new_state->win_width - new_state->win_right; new_state->list_stack->old_left_margin = new_state->left_margin; new_state->list_stack->old_right_margin = new_state->right_margin; /* * Initialize the alignment stack for this state * to match the caption alignment. */ if (subdoc->horiz_alignment != LO_ALIGN_LEFT) { lo_PushAlignment(new_state, P_TABLE_DATA, subdoc->horiz_alignment); } state->sub_state = new_state; state->current_ele = (LO_Element *)subdoc; if (is_a_header != FALSE) { LO_TextAttr *old_attr; LO_TextAttr *attr; LO_TextAttr tmp_attr; old_attr = new_state->font_stack->text_attr; lo_CopyTextAttr(old_attr, &tmp_attr); tmp_attr.fontmask |= LO_FONT_BOLD; attr = lo_FetchTextAttr(new_state, &tmp_attr); lo_PushFont(new_state, P_TABLE_DATA, attr); } } Bool lo_subdoc_has_elements(lo_DocState *sub_state) { if (sub_state->end_last_line != NULL) { return(TRUE); } if (sub_state->float_list != NULL) { return(TRUE); } return(FALSE); } Bool lo_cell_has_elements(LO_CellStruct *cell) { if (cell->cell_list != NULL) { return(TRUE); } if (cell->cell_float_list != NULL) { return(TRUE); } return(FALSE); } int32 lo_align_subdoc(MWContext *context, lo_DocState *state, lo_DocState *old_state, LO_SubDocStruct *subdoc, lo_TableRec *table, lo_table_span *row_max) { int32 ele_cnt; LO_Element *eptr; int32 vert_inc; int32 top_inner_pad; int32 bottom_inner_pad; int32 left_inner_pad; int32 right_inner_pad; LO_Element **line_array; top_inner_pad = FEUNITS_X(table->inner_top_pad, context); bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context); left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); ele_cnt = 0; /* * Mess with vertical alignment. */ vert_inc = subdoc->height - (2 * subdoc->border_width) - (top_inner_pad + bottom_inner_pad) - old_state->y; if (vert_inc > 0) { if (subdoc->vert_alignment == LO_ALIGN_CENTER) { vert_inc = vert_inc / 2; } else if (subdoc->vert_alignment == LO_ALIGN_BOTTOM) { /* vert_inc unchanged */ } else if ((subdoc->vert_alignment == LO_ALIGN_BASELINE)&& (row_max != NULL)) { int32 baseline; int32 tmp_val; baseline = lo_GetSubDocBaseline(subdoc); tmp_val = row_max->min_dim - baseline; if (tmp_val > vert_inc) { tmp_val = vert_inc; } if (tmp_val > 0) { vert_inc = tmp_val; } else { vert_inc = 0; } } else { vert_inc = 0; } } else { vert_inc = 0; } /* * Make eptr point to the start of the element chain * for this subdoc. */ #ifdef XP_WIN16 { XP_Block *larray_array; XP_LOCK_BLOCK(larray_array, XP_Block *, old_state->larray_array); old_state->line_array = larray_array[0]; XP_UNLOCK_BLOCK(old_state->larray_array); } #endif /* XP_WIN16 */ XP_LOCK_BLOCK(line_array, LO_Element **, old_state->line_array); eptr = line_array[0]; XP_UNLOCK_BLOCK(old_state->line_array); while (eptr != NULL) { eptr->lo_any.x += left_inner_pad; switch (eptr->type) { case LO_LINEFEED: if (eptr->lo_linefeed.ele_attrmask & LO_ELE_DELAY_ALIGNED) { if (eptr->lo_linefeed.ele_attrmask & LO_ELE_DELAY_CENTER) { int32 side_inc; int32 inside_width; LO_Element *c_eptr; c_eptr = eptr; inside_width = subdoc->width - (2 * subdoc->border_width) - (2 * subdoc->border_horiz_space) - (left_inner_pad + right_inner_pad); side_inc = inside_width - (c_eptr->lo_linefeed.x + c_eptr->lo_linefeed.x_offset - left_inner_pad); side_inc = side_inc / 2; if (side_inc > 0) { c_eptr->lo_linefeed.width -= side_inc; if (c_eptr->lo_linefeed.width < 0) { c_eptr->lo_linefeed.width = 0; } while ((c_eptr->lo_any.prev != NULL)&& (c_eptr->lo_any.prev->type != LO_LINEFEED)) { c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } c_eptr = c_eptr->lo_any.prev; } c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } } } else if (eptr->lo_linefeed.ele_attrmask & LO_ELE_DELAY_RIGHT) { int32 side_inc; int32 inside_width; LO_Element *c_eptr; c_eptr = eptr; inside_width = subdoc->width - (2 * subdoc->border_width) - (2 * subdoc->border_horiz_space) - (left_inner_pad + right_inner_pad); side_inc = inside_width - (c_eptr->lo_linefeed.x + c_eptr->lo_linefeed.x_offset - left_inner_pad); if (side_inc > 0) { c_eptr->lo_linefeed.width -= side_inc; if (c_eptr->lo_linefeed.width < 0) { c_eptr->lo_linefeed.width = 0; } while ((c_eptr->lo_any.prev != NULL)&& (c_eptr->lo_any.prev->type != LO_LINEFEED)) { c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } c_eptr = c_eptr->lo_any.prev; } c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } } } eptr->lo_linefeed.ele_attrmask &= (~(LO_ELE_DELAY_ALIGNED)); } break; default: break; } eptr->lo_any.y += (vert_inc + top_inner_pad); if (eptr->type == LO_CELL) { lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad, (vert_inc + top_inner_pad)); } eptr = eptr->lo_any.next; ele_cnt++; } eptr = old_state->float_list; while (eptr != NULL) { eptr->lo_any.x += left_inner_pad; eptr->lo_any.y += (vert_inc + top_inner_pad); if (eptr->type == LO_CELL) { lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad, (vert_inc + top_inner_pad)); } eptr = eptr->lo_any.next; ele_cnt++; } return(ele_cnt); } int32 lo_align_cell(MWContext *context, lo_DocState *state, lo_TableCell *cell_ptr, LO_CellStruct *cell, lo_TableRec *table, lo_table_span *row_max) { int32 ele_cnt; LO_Element *eptr; int32 vert_inc; int32 top_inner_pad; int32 bottom_inner_pad; int32 left_inner_pad; int32 right_inner_pad; top_inner_pad = FEUNITS_X(table->inner_top_pad, context); bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context); left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); ele_cnt = 0; /* * Mess with vertical alignment. */ vert_inc = cell->height - (2 * cell->border_width) - (top_inner_pad + bottom_inner_pad) - cell_ptr->max_y; if (vert_inc > 0) { if (cell_ptr->vert_alignment == LO_ALIGN_CENTER) { vert_inc = vert_inc / 2; } else if (cell_ptr->vert_alignment == LO_ALIGN_BOTTOM) { /* vert_inc unchanged */ } else if ((cell_ptr->vert_alignment == LO_ALIGN_BASELINE)&& (row_max != NULL)) { int32 baseline; int32 tmp_val; baseline = lo_GetCellBaseline(cell); tmp_val = row_max->min_dim - baseline; if (tmp_val > vert_inc) { tmp_val = vert_inc; } if (tmp_val > 0) { vert_inc = tmp_val; } else { vert_inc = 0; } } else { vert_inc = 0; } } else { vert_inc = 0; } /* * Make eptr point to the start of the element chain * for this cell. */ eptr = cell->cell_list; while (eptr != NULL) { eptr->lo_any.x += left_inner_pad; switch (eptr->type) { case LO_LINEFEED: if (eptr->lo_linefeed.ele_attrmask & LO_ELE_DELAY_ALIGNED) { if (eptr->lo_linefeed.ele_attrmask & LO_ELE_DELAY_CENTER) { int32 side_inc; int32 inside_width; LO_Element *c_eptr; c_eptr = eptr; inside_width = cell->width - (2 * cell->border_width) - (2 * cell->border_horiz_space) - (left_inner_pad + right_inner_pad); side_inc = inside_width - (c_eptr->lo_linefeed.x + c_eptr->lo_linefeed.x_offset - left_inner_pad); side_inc = side_inc / 2; if (side_inc > 0) { c_eptr->lo_linefeed.width -= side_inc; if (c_eptr->lo_linefeed.width < 0) { c_eptr->lo_linefeed.width = 0; } while ((c_eptr->lo_any.prev != NULL)&& (c_eptr->lo_any.prev->type != LO_LINEFEED)) { c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } c_eptr = c_eptr->lo_any.prev; } c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } } } else if (eptr->lo_linefeed.ele_attrmask & LO_ELE_DELAY_RIGHT) { int32 side_inc; int32 inside_width; LO_Element *c_eptr; c_eptr = eptr; inside_width = cell->width - (2 * cell->border_width) - (2 * cell->border_horiz_space) - (left_inner_pad + right_inner_pad); side_inc = inside_width - (c_eptr->lo_linefeed.x + c_eptr->lo_linefeed.x_offset - left_inner_pad); if (side_inc > 0) { c_eptr->lo_linefeed.width -= side_inc; if (c_eptr->lo_linefeed.width < 0) { c_eptr->lo_linefeed.width = 0; } while ((c_eptr->lo_any.prev != NULL)&& (c_eptr->lo_any.prev->type != LO_LINEFEED)) { c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } c_eptr = c_eptr->lo_any.prev; } c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } } } eptr->lo_linefeed.ele_attrmask &= (~(LO_ELE_DELAY_ALIGNED)); } break; default: break; } eptr->lo_any.y += (vert_inc + top_inner_pad); if (eptr->type == LO_CELL) { lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad, (vert_inc + top_inner_pad)); } eptr = eptr->lo_any.next; ele_cnt++; } eptr = cell->cell_float_list; while (eptr != NULL) { eptr->lo_any.x += left_inner_pad; eptr->lo_any.y += (vert_inc + top_inner_pad); if (eptr->type == LO_CELL) { lo_ShiftCell((LO_CellStruct *)eptr, left_inner_pad, (vert_inc + top_inner_pad)); } eptr = eptr->lo_any.next; ele_cnt++; } return(ele_cnt); } LO_SubDocStruct * lo_EndCellSubDoc(MWContext *context, lo_DocState *state, lo_DocState *old_state, LO_Element *element, Bool relayout) { LO_Element *eptr; LO_SubDocStruct *subdoc; PA_Block buff; char *str; Bool line_break; int32 baseline_inc; int32 line_inc; int32 subdoc_height, subdoc_width; int32 doc_height; LO_TextStruct tmp_text; LO_TextInfo text_info; LO_Element **line_array; Bool dynamic_width; Bool dynamic_height; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_EndCellSubDoc called\n"); #endif /* LOCAL_DEBUG */ /* Close any layers (blocks) that were opened in this cell, in case the document author forgot to. */ while (old_state->layer_nest_level > 0) { lo_EndLayer(context, old_state, PR_TRUE); } subdoc = (LO_SubDocStruct *)element; subdoc->state = (void *)old_state; /* * All this work is to get the text_info filled in for the current * font in the font stack. Yuck, there must be a better way. */ memset (&tmp_text, 0, sizeof (tmp_text)); buff = PA_ALLOC(1); if (buff == NULL) { state->top_state->out_of_memory = TRUE; return(NULL); } PA_LOCK(str, char *, buff); str[0] = ' '; PA_UNLOCK(buff); tmp_text.text = buff; tmp_text.text_len = 1; tmp_text.text_attr = state->font_stack->text_attr; FE_GetTextInfo(context, &tmp_text, &text_info); PA_FREE(buff); if (relayout == FALSE) { /* * We don't want to leave any end paragraph linbreaks in the subdoc * as they give us a really ugly blank line at the bottom of a cell. So, * if the last element in the list is paragraph break linefeed, then * we kill it. */ eptr = old_state->end_last_line; if ( (eptr != NULL) && (eptr->type == LO_LINEFEED) && (eptr->lo_linefeed.break_type == LO_LINEFEED_BREAK_PARAGRAPH) ) { LO_Element *prev; prev = eptr->lo_any.prev; /* * Kill this layout element and reset the subdoc height */ if ( prev != NULL ) { prev->lo_any.next = NULL; old_state->end_last_line = prev; } else { old_state->line_list = NULL; old_state->end_last_line = NULL; } /* The if condition checks to make sure that the linefeed that we just killed * was sticking out of the bottom of the cell. This fixes bug 81282. */ if (eptr->lo_linefeed.y + eptr->lo_linefeed.line_height >= old_state->y) { /* shrink the document */ old_state->y -= eptr->lo_linefeed.line_height; } lo_RecycleElements ( context, old_state, eptr ); } } dynamic_width = FALSE; dynamic_height = FALSE; if (subdoc->width == 0) { dynamic_width = TRUE; /* * Subdocs that were dynamically widthed, and which * contained right aligned items, must be relaid out * once their width is determined. */ eptr = old_state->float_list; while (eptr != NULL) { if ((eptr->type == LO_IMAGE)&& (eptr->lo_image.image_attr->alignment == LO_ALIGN_RIGHT)) { old_state->must_relayout_subdoc = TRUE; break; } else if ((eptr->type == LO_SUBDOC)&& (eptr->lo_subdoc.alignment == LO_ALIGN_RIGHT)) { old_state->must_relayout_subdoc = TRUE; break; } eptr = eptr->lo_any.next; } subdoc->width = old_state->max_width; } /* * Add in the size of the subdoc's borders */ subdoc->width += (2 * subdoc->border_width); /* * Figure the height the subdoc laid out in. * Use this if we were passed no height, or if it is greater * than the passed height. */ doc_height = old_state->y + (2 * subdoc->border_width); if (subdoc->height == 0) { dynamic_height = TRUE; subdoc->height = doc_height; } else if (subdoc->height < doc_height) { subdoc->height = doc_height; } /* * Make eptr point to the start of the element chain * for this subdoc. */ #ifdef XP_WIN16 { XP_Block *larray_array; XP_LOCK_BLOCK(larray_array, XP_Block *, old_state->larray_array); old_state->line_array = larray_array[0]; XP_UNLOCK_BLOCK(old_state->larray_array); } #endif /* XP_WIN16 */ XP_LOCK_BLOCK(line_array, LO_Element **, old_state->line_array); eptr = line_array[0]; XP_UNLOCK_BLOCK(old_state->line_array); while (eptr != NULL) { switch (eptr->type) { case LO_LINEFEED: if ((eptr->lo_linefeed.x + eptr->lo_linefeed.x_offset + eptr->lo_linefeed.width) >= (subdoc->width - 1 - (2 * subdoc->border_width))) { eptr->lo_linefeed.width = (subdoc->width - 1 - (2 * subdoc->border_width)) - (eptr->lo_linefeed.x + eptr->lo_linefeed.x_offset); if (eptr->lo_linefeed.width < 0) { eptr->lo_linefeed.width = 0; } } #ifdef OLD_DELAY_CENTERED if (eptr->lo_linefeed.ele_attrmask & LO_ELE_DELAY_CENTERED) { int32 side_inc; LO_Element *c_eptr; c_eptr = eptr; side_inc = subdoc->width - 1 - (2 * subdoc->border_width) - (eptr->lo_linefeed.x + eptr->lo_linefeed.x_offset); side_inc = side_inc / 2; if (side_inc > 0) { c_eptr->lo_linefeed.width -= side_inc; if (c_eptr->lo_linefeed.width < 0) { c_eptr->lo_linefeed.width = 0; } while ((c_eptr->lo_any.prev != NULL)&& (c_eptr->lo_any.prev->type != LO_LINEFEED)) { c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } c_eptr = c_eptr->lo_any.prev; } c_eptr->lo_any.x += side_inc; if (c_eptr->type == LO_CELL) { lo_ShiftCell( (LO_CellStruct *)c_eptr, side_inc, 0); } } eptr->lo_linefeed.ele_attrmask &= (~(LO_ELE_DELAY_CENTERED)); } #endif /* OLD_DELAY_CENTERED */ break; /* * This is awful, but any dynamically dimenstioned * subdoc that contains one of these elements * must be relayed out to take care of window * width and height dependencies. */ /* case LO_HRULE: */ case LO_SUBDOC: case LO_TABLE: old_state->must_relayout_subdoc = TRUE; break; case LO_IMAGE: /* WILL NEED THIS LATER FOR PERCENT WIDTH IMAGES if ((old_state->allow_percent_width == FALSE)|| (old_state->allow_percent_height == FALSE)) { old_state->must_relayout_subdoc = TRUE; } */ break; default: break; } eptr = eptr->lo_any.next; } /* * Remember: (2 * subdoc->border_width) has already been added to the subdoc * width above... */ subdoc_width = subdoc->width + (2 * subdoc->border_horiz_space); subdoc_height = subdoc->height + (2 * subdoc->border_width) + (2 * subdoc->border_vert_space); if (old_state->display_blocked != FALSE) { old_state->display_blocked = FALSE; } /* * Will this subdoc make the line too wide. */ if ((state->x + subdoc_width) > state->right_margin) { line_break = TRUE; } else { line_break = FALSE; } /* * if we are at the beginning of the line. There is * no point in breaking, we are just too wide. * Also don't break in unwrappedpreformatted text. * Also can't break inside a NOBR section. */ if ((state->at_begin_line != FALSE)|| (state->preformatted == PRE_TEXT_YES)|| (state->breakable == FALSE)) { line_break = FALSE; } /* * break on the subdoc if we have * a break. */ /* DOn't break in cell if (line_break != FALSE) { lo_SoftLineBreak(context, state, TRUE); subdoc->x = state->x; subdoc->y = state->y; } */ /* * Figure out how to align this subdoc. * baseline_inc is how much to increase the baseline * of previous element of this line. line_inc is how * much to increase the line height below the baseline. */ baseline_inc = 0; line_inc = 0; /* * If we are at the beginning of a line, with no baseline, * we first set baseline and line_height based on the current * font, then place the subdoc. */ if (state->baseline == 0) { state->baseline = 0; } lo_CalcAlignOffsets(state, &text_info, (intn)subdoc->alignment, subdoc_width, subdoc_height, &subdoc->x_offset, &subdoc->y_offset, &line_inc, &baseline_inc); subdoc->x_offset += (int16)subdoc->border_horiz_space; subdoc->y_offset += (int32)subdoc->border_vert_space; old_state->base_x = subdoc->x + subdoc->x_offset + subdoc->border_width; old_state->base_y = subdoc->y + subdoc->y_offset + subdoc->border_width; /* * Clean up state state->x = state->x + subdoc->x_offset + subdoc_width - subdoc->border_horiz_space; state->linefeed_state = 0; state->at_begin_line = FALSE; state->trailing_space = FALSE; state->cur_ele_type = LO_SUBDOC; */ return(subdoc); } void lo_relayout_recycle(MWContext *context, lo_DocState *state, LO_Element *elist) { LO_LockLayout(); while (elist != NULL) { LO_Element *eptr; eptr = elist; elist = elist->lo_any.next; eptr->lo_any.next = NULL; if (eptr->type == LO_IMAGE) { eptr->lo_any.next = state->top_state->trash; state->top_state->trash = eptr; } else if (eptr->type == LO_CELL) { if (eptr->lo_cell.cell_list != NULL) { if (eptr->lo_cell.cell_list_end != NULL) { eptr->lo_cell.cell_list_end->lo_any.next = NULL; } lo_relayout_recycle(context, state, eptr->lo_cell.cell_list); eptr->lo_cell.cell_list = NULL; eptr->lo_cell.cell_list_end = NULL; } if (eptr->lo_cell.cell_float_list != NULL) { lo_relayout_recycle(context, state, eptr->lo_cell.cell_float_list); eptr->lo_cell.cell_float_list = NULL; } lo_RecycleElements(context, state, eptr); } else { /* * If this is an embed, tell it that it should * recycle rather than delete itself. */ if (eptr->type == LO_EMBED) { NPL_SameElement((LO_EmbedStruct*)eptr); } lo_RecycleElements(context, state, eptr); } } LO_UnlockLayout(); } static void lo_cleanup_state(MWContext *context, lo_DocState *state) { LO_Element **line_array; if (state == NULL) { return; } if (state->left_margin_stack != NULL) { lo_MarginStack *mptr; lo_MarginStack *margin; mptr = state->left_margin_stack; while (mptr != NULL) { margin = mptr; mptr = mptr->next; XP_DELETE(margin); } state->left_margin_stack = NULL; } if (state->right_margin_stack != NULL) { lo_MarginStack *mptr; lo_MarginStack *margin; mptr = state->right_margin_stack; while (mptr != NULL) { margin = mptr; mptr = mptr->next; XP_DELETE(margin); } state->right_margin_stack = NULL; } if (state->line_list != NULL) { lo_relayout_recycle(context, state, state->line_list); state->line_list = NULL; } if (state->font_stack != NULL) { lo_FontStack *fstack; lo_FontStack *fptr; fptr = state->font_stack; while (fptr != NULL) { fstack = fptr; fptr = fptr->next; XP_DELETE(fstack); } state->font_stack = NULL; } if (state->align_stack != NULL) { lo_AlignStack *aptr; lo_AlignStack *align; aptr = state->align_stack; while (aptr != NULL) { align = aptr; aptr = aptr->next; XP_DELETE(align); } state->align_stack = NULL; } if (state->list_stack != NULL) { lo_ListStack *lptr; lo_ListStack *list; lptr = state->list_stack; while (lptr != NULL) { list = lptr; lptr = lptr->next; XP_DELETE(list); } state->list_stack = NULL; } if (state->line_buf != NULL) { PA_FREE(state->line_buf); state->line_buf = NULL; } if (state->float_list != NULL) { lo_relayout_recycle(context, state, state->float_list); state->float_list = NULL; } if (state->line_array != NULL) { LO_Element *eptr; #ifdef XP_WIN16 { XP_Block *larray_array; intn cnt; XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array); cnt = state->larray_array_size - 1; while (cnt > 0) { XP_FREE_BLOCK(larray_array[cnt]); cnt--; } state->line_array = larray_array[0]; XP_UNLOCK_BLOCK(state->larray_array); XP_FREE_BLOCK(state->larray_array); } #endif /* XP_WIN16 */ eptr = NULL; XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array); eptr = line_array[0]; if (eptr != NULL) { lo_relayout_recycle(context, state, eptr); } XP_UNLOCK_BLOCK(state->line_array); XP_FREE_BLOCK(state->line_array); } XP_DELETE(state); } static lo_FormData * lo_merge_form_data(lo_FormData *new_form_list, lo_FormData *hold_form_list) { intn i; LO_FormElementStruct **new_ele_list; LO_FormElementStruct **hold_ele_list; PA_LOCK(new_ele_list, LO_FormElementStruct **, new_form_list->form_elements); PA_LOCK(hold_ele_list, LO_FormElementStruct **, hold_form_list->form_elements); for (i=0; iform_ele_cnt; i++) { if (hold_ele_list[i] != new_ele_list[i]) { #ifdef MOCHA if (new_ele_list[i]->mocha_object == NULL) { new_ele_list[i]->mocha_object = hold_ele_list[i]->mocha_object; } #endif hold_ele_list[i] = new_ele_list[i]; } } PA_UNLOCK(hold_form_list->form_elements); PA_UNLOCK(new_form_list->form_elements); #ifdef MOCHA /* XXX sometimes the second pass does not reflect a form object! */ if (new_form_list->mocha_object != NULL) { hold_form_list->mocha_object = new_form_list->mocha_object; } #endif return(hold_form_list); } /* * Serious table magic. Given a table cell subdoc, * redo the layout to the new width from the stored tag list, * and create a whole new subdoc, which is returned. */ LO_SubDocStruct * lo_RelayoutCaptionSubdoc(MWContext *context, lo_DocState *state, lo_TableCaption *caption, LO_SubDocStruct *subdoc, int32 width, Bool is_a_header) { int32 first_height; lo_TopState *top_state; lo_DocState *old_state; lo_DocState *new_state; /* ifdef-ed out of service: PA_Tag *tag_list; */ /* Commented and ifdef-ed out of service: PA_Tag *tag_ptr; */ /* Commented out of service: PA_Tag *tag_end_ptr; */ int32 doc_id; Bool allow_percent_width; Bool allow_percent_height; int32 hold_form_ele_cnt; int32 hold_form_data_index; intn hold_form_id; intn hold_current_form_num; Bool hold_in_form; lo_FormData *hold_form_list; int32 hold_embed_global_index; int32 original_tag_count; intn hold_url_list_len; NET_ReloadMethod save_force; /* ifdef-ed out of service: Bool save_diff_state; */ /* ifdef-ed out of service: int32 save_state_pushes; */ /* ifdef-ed out of service: int32 save_state_pops; */ lo_DocLists *doc_lists; int32 hold_image_list_count; int32 hold_applet_list_count; int32 hold_embed_list_count; int32 hold_current_layer_num; /* * Relayout is NOT allowed to block on images, so never * have the forced reload flag set. */ save_force = state->top_state->force_reload; state->top_state->force_reload = NET_CACHE_ONLY_RELOAD; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_RelayoutSubdoc called\n"); #endif /* LOCAL_DEBUG */ top_state = state->top_state; old_state = (lo_DocState *) subdoc->state; /* * We are going to reuse this subdoc element instead * of allocating a new one. */ /* subdoc->state = NULL; */ subdoc->width = width; subdoc->height = 0; doc_lists = lo_GetCurrentDocLists(state); /* * If this subdoc contained form elements. We want to reuse * them without messing up the order of later form elements in * other subdocs. * * We assume that relaying out the doc will create the exact * same number of form elements in the same order as the first time. * so we reset global form counters to before this subdoc * was ever laid out, saving the current counts to restore later. */ if (doc_lists->form_list != NULL) { lo_FormData *form_list; lo_FormData *tmp_fptr; hold_form_id = old_state->form_id; hold_current_form_num = doc_lists->current_form_num; form_list = doc_lists->form_list; hold_form_list = NULL; while ((form_list != NULL)&& (form_list->id > hold_form_id)) { tmp_fptr = form_list; form_list = form_list->next; tmp_fptr->next = hold_form_list; hold_form_list = tmp_fptr; } doc_lists->form_list = form_list; doc_lists->current_form_num = hold_form_id; if (form_list != NULL) { hold_form_ele_cnt = form_list->form_ele_cnt; form_list->form_ele_cnt = old_state->form_ele_cnt; } else { hold_form_ele_cnt = 0; } } else { hold_form_id = 0; hold_form_ele_cnt = 0; hold_form_list = NULL; hold_current_form_num = 0; } /* * We're going to be deleting and then recreating the contents * of this subdoc. We want the newly-created embeds to have * the same embed indices as their recycled counterparts, so * we reset the master embed index in the top_state to be the * value it held at the time the old subdoc was created. When * we're finished creating the new subdoc, the master index * should be back to its original value (but just in case we * save that value in a local variable here). */ hold_embed_global_index = top_state->embed_count; top_state->embed_count = old_state->embed_count_base; /* ditto here for the last comment. We are trying to keep * a tag count that reflects the order of tags coming in * on the stream. We need that count to be correct across * multiple relayout instances so we restore the top state * count with the saved state */ original_tag_count = top_state->tag_count; top_state->tag_count = state->beginning_tag_count; /* * Same goes for anchors and images */ hold_url_list_len = doc_lists->url_list_len; doc_lists->url_list_len = old_state->url_count_base; hold_image_list_count = doc_lists->image_list_count; doc_lists->image_list_count = old_state->image_list_count_base; hold_applet_list_count = doc_lists->applet_list_count; doc_lists->applet_list_count = old_state->applet_list_count_base; hold_embed_list_count = doc_lists->embed_list_count; doc_lists->embed_list_count = old_state->embed_list_count_base; hold_current_layer_num = top_state->current_layer_num; top_state->current_layer_num = old_state->current_layer_num_base; /* * Save whether we are in a form or not, and restore * to what we were when the subdoc was started. */ hold_in_form = top_state->in_form; top_state->in_form = old_state->start_in_form; if (top_state->savedData.FormList != NULL) { lo_SavedFormListData *all_form_ele; all_form_ele = top_state->savedData.FormList; hold_form_data_index = all_form_ele->data_index; all_form_ele->data_index = old_state->form_data_index; } else { hold_form_data_index = 0; } /* * Still variable height, but we know the width now. */ first_height = FEUNITS_Y(10000, context); allow_percent_height = FALSE; allow_percent_width = TRUE; /* * Get a new sub-state to create the new subdoc in. */ /* new_state = lo_NewLayout(context, width, first_height, 0, 0, NULL); */ lo_reuse_current_state(context, subdoc->state, width, first_height, 0, 0, FALSE); new_state = subdoc->state; subdoc->state = NULL; if (new_state == NULL) { state->top_state->force_reload = save_force; return(subdoc); } new_state->end_last_line = NULL; /* if (old_state->is_a_subdoc == SUBDOC_CAPTION) { new_state->is_a_subdoc = SUBDOC_CAPTION; } else { new_state->is_a_subdoc = SUBDOC_CELL; } */ new_state->is_a_subdoc = SUBDOC_CAPTION; lo_InheritParentColors(context, new_state, state); new_state->allow_percent_width = allow_percent_width; new_state->allow_percent_height = allow_percent_height; /* * In relaying out subdocs, we NEVER link back up subdoc tags */ new_state->subdoc_tags = NULL; new_state->subdoc_tags_end = NULL; /* * Initialize other new state sundries. */ new_state->base_x = 0; new_state->base_y = 0; new_state->display_blocked = TRUE; if (subdoc->width == 0) { new_state->delay_align = TRUE; } new_state->win_left = 0; new_state->win_right = 0; new_state->x = new_state->win_left; new_state->y = 0; new_state->max_width = new_state->x + 1; new_state->left_margin = new_state->win_left; new_state->right_margin = new_state->win_width - new_state->win_right; new_state->list_stack->old_left_margin = new_state->left_margin; new_state->list_stack->old_right_margin = new_state->right_margin; /* we don't need min widths during relayout */ new_state->need_min_width = FALSE; /* reset line_height stack */ while (new_state->line_height_stack) lo_PopLineHeight(new_state); /* * Initialize the alignment stack for this state * to match the caption alignment. */ if (subdoc->horiz_alignment != LO_ALIGN_LEFT) { lo_PushAlignment(new_state, P_TABLE_DATA, subdoc->horiz_alignment); } state->sub_state = new_state; state->current_ele = (LO_Element *)subdoc; if (is_a_header != FALSE) { LO_TextAttr *old_attr; LO_TextAttr *attr; LO_TextAttr tmp_attr; old_attr = new_state->font_stack->text_attr; lo_CopyTextAttr(old_attr, &tmp_attr); tmp_attr.fontmask |= LO_FONT_BOLD; attr = lo_FetchTextAttr(new_state, &tmp_attr); lo_PushFont(new_state, P_TABLE_HEADER, attr); } /* * Move our current state down into the new sub-state. * Fetch the tag list from the old subdoc's state in preparation * for relayout. */ state = new_state; lo_rl_ReflowDocState( context, state ); /* * makes sure we are at the bottom * of everything in the document. */ /* lo_CloseOutLayout(context, state); */ lo_EndLayoutDuringReflow( context, state ); old_state = state; /* * Get the unique document ID, and retreive this * documents layout state. */ doc_id = XP_DOCID(context); top_state = lo_FetchTopState(doc_id); state = top_state->doc_state; while ((state->sub_state != NULL)&& (state->sub_state != old_state)) { state = state->sub_state; } /* * Ok, now reset the global form element counters * to their original values. */ if ((doc_lists->form_list != NULL)||(hold_form_list != NULL)) { lo_FormData *form_list; lo_FormData *new_form_list; lo_FormData *tmp_fptr; /* * Remove any new forms created in this subdocs to a * separate list. */ form_list = doc_lists->form_list; new_form_list = NULL; while ((form_list != NULL)&& (form_list->id > hold_form_id)) { tmp_fptr = form_list; form_list = form_list->next; tmp_fptr->next = new_form_list; new_form_list = tmp_fptr; } /* * Restore the element count in the form we started in * because the subdoc may have left it half finished. */ if (form_list != NULL) { form_list->form_ele_cnt = hold_form_ele_cnt; } /* * Merge the newly created forms with the old ones * since the new ones may have partially complete * data. */ while ((new_form_list != NULL)&&(hold_form_list != NULL)) { tmp_fptr = lo_merge_form_data(new_form_list, hold_form_list); new_form_list = new_form_list->next; hold_form_list = hold_form_list->next; tmp_fptr->next = form_list; form_list = tmp_fptr; } /* * Add back on forms that are from later subdocs. */ while (hold_form_list != NULL) { tmp_fptr = hold_form_list; hold_form_list = hold_form_list->next; tmp_fptr->next = form_list; form_list = tmp_fptr; } doc_lists->form_list = form_list; doc_lists->current_form_num = hold_current_form_num; } /* * Restore in form status to what is * was before this relayout. */ top_state->in_form = hold_in_form; if (top_state->savedData.FormList != NULL) { lo_SavedFormListData *all_form_ele; all_form_ele = top_state->savedData.FormList; all_form_ele->data_index = hold_form_data_index; } /* * The master embed index is typically now be back * to its original value, but might not be if we * only had to relayout some (not all) of the embeds * in this subdoc. So, make sure it's set back to * its original value here. */ top_state->embed_count = hold_embed_global_index; /* verify that the tag count is still correct */ top_state->tag_count = original_tag_count; /* * Likewise for the anchor list. */ doc_lists->url_list_len = hold_url_list_len; doc_lists->image_list_count = hold_image_list_count; doc_lists->applet_list_count = hold_applet_list_count; doc_lists->embed_list_count = hold_embed_list_count; top_state->current_layer_num = hold_current_layer_num; subdoc = NULL; if ((state != old_state)&& (state->current_ele != NULL)) { subdoc = lo_EndCellSubDoc(context, state, old_state, state->current_ele, TRUE); state->sub_state = NULL; state->current_ele = NULL; /* if ((state->is_a_subdoc == SUBDOC_CELL)|| (state->is_a_subdoc == SUBDOC_CAPTION)) { if (old_state->subdoc_tags_end != NULL) { state->subdoc_tags_end = old_state->subdoc_tags_end; } } */ } old_state->must_relayout_subdoc = FALSE; state->top_state->force_reload = save_force; return(subdoc); } LO_CellStruct * lo_RelayoutCell(MWContext *context, lo_DocState *state, LO_SubDocStruct *subdoc, lo_TableCell *cell_ptr, LO_CellStruct *cell, int32 width, Bool is_a_header, Bool relayout) { LO_CellStruct *cell_ele; int32 first_height; lo_TopState *top_state; lo_DocState *old_state; lo_DocState *new_state; /* Unused: PA_Tag *tag_list; */ /* COmmented out of service: PA_Tag *tag_ptr; */ /* Commented out of service: PA_Tag *tag_end_ptr; */ int32 doc_id; Bool allow_percent_width; Bool allow_percent_height; int32 hold_form_ele_cnt; int32 hold_form_data_index; intn hold_form_id; intn hold_current_form_num; Bool hold_in_form; lo_FormData *hold_form_list; int32 hold_embed_global_index; int32 original_tag_count; intn hold_url_list_len; NET_ReloadMethod save_force; /* Unused: Bool save_diff_state; */ /* Unused: int32 save_state_pushes; */ /* Unused: ;int32 save_state_pops; */ lo_DocLists *doc_lists; int32 hold_image_list_count; int32 hold_applet_list_count; int32 hold_embed_list_count; int32 hold_current_layer_num; /* Commented out of service: LO_Element * elem_list; */ /* * Relayout is NOT allowed to block on images, so never * have the forced reload flag set. */ save_force = state->top_state->force_reload; state->top_state->force_reload = NET_CACHE_ONLY_RELOAD; top_state = state->top_state; /* * We are going to reuse this subdoc element instead * of allocating a new one. lo_reuse_current_subdoc(context, subdoc); subdoc->state = NULL; */ subdoc->width = width; subdoc->height = 0; subdoc->horiz_alignment = cell_ptr->horiz_alignment; doc_lists = lo_GetCurrentDocLists(state); /* * If this subdoc contained form elements. We want to reuse * them without messing up the order of later form elements in * other subdocs. * * We assume that relaying out the doc will create the exact * same number of form elements in the same order as the first time. * so we reset global form counters to before this subdoc * was ever laid out, saving the current counts to restore later. */ if (doc_lists->form_list != NULL) { lo_FormData *form_list; lo_FormData *tmp_fptr; hold_form_id = cell_ptr->form_id; hold_current_form_num = doc_lists->current_form_num; form_list = doc_lists->form_list; hold_form_list = NULL; while ((form_list != NULL)&& (form_list->id > hold_form_id)) { tmp_fptr = form_list; form_list = form_list->next; tmp_fptr->next = hold_form_list; hold_form_list = tmp_fptr; } doc_lists->form_list = form_list; doc_lists->current_form_num = hold_form_id; if (form_list != NULL) { hold_form_ele_cnt = form_list->form_ele_cnt; form_list->form_ele_cnt = cell_ptr->form_ele_cnt; } else { hold_form_ele_cnt = 0; } } else { hold_form_id = 0; hold_form_ele_cnt = 0; hold_form_list = NULL; hold_current_form_num = 0; } /* * We're going to be deleting and then recreating the contents * of this subdoc. We want the newly-created embeds to have * the same embed indices as their recycled counterparts, so * we reset the master embed index in the top_state to be the * value it held at the time the old subdoc was created. When * we're finished creating the new subdoc, the master index * should be back to its original value (but just in case we * save that value in a local variable here). */ hold_embed_global_index = top_state->embed_count; top_state->embed_count = cell_ptr->embed_count_base; /* same for tag count */ original_tag_count = top_state->tag_count; top_state->tag_count = cell_ptr->beginning_tag_count; /* * Same goes for anchors and images */ hold_url_list_len = doc_lists->url_list_len; doc_lists->url_list_len = cell_ptr->url_count_base; hold_image_list_count = doc_lists->image_list_count; doc_lists->image_list_count = cell_ptr->image_list_count_base; hold_applet_list_count = doc_lists->applet_list_count; doc_lists->applet_list_count = cell_ptr->applet_list_count_base; hold_embed_list_count = doc_lists->embed_list_count; doc_lists->embed_list_count = cell_ptr->embed_list_count_base; hold_current_layer_num = top_state->current_layer_num; top_state->current_layer_num = cell_ptr->current_layer_num_base; /* * Save whether we are in a form or not, and restore * to what we were when the subdoc was started. */ hold_in_form = top_state->in_form; top_state->in_form = cell_ptr->start_in_form; if (top_state->savedData.FormList != NULL) { lo_SavedFormListData *all_form_ele; all_form_ele = top_state->savedData.FormList; hold_form_data_index = all_form_ele->data_index; all_form_ele->data_index = cell_ptr->form_data_index; } else { hold_form_data_index = 0; } /* * Still variable height, but we know the width now. */ first_height = FEUNITS_Y(10000, context); allow_percent_height = FALSE; allow_percent_width = TRUE; /* * Get a new sub-state to create the new subdoc in. */ lo_reuse_current_state(context, subdoc->state, width, first_height, 0, 0, TRUE); new_state = subdoc->state; subdoc->state = NULL; if (new_state == NULL) { state->top_state->force_reload = save_force; return(cell); } if (cell_ptr->is_a_subdoc == SUBDOC_CAPTION) { new_state->is_a_subdoc = SUBDOC_CAPTION; } else { new_state->is_a_subdoc = SUBDOC_CELL; } lo_InheritParentState(context, new_state, state); new_state->allow_percent_width = allow_percent_width; new_state->allow_percent_height = allow_percent_height; /* * In relaying out subdocs, we NEVER link back up subdoc tags */ new_state->subdoc_tags = NULL; new_state->subdoc_tags_end = NULL; /* * Initialize other new state sundries. */ new_state->base_x = 0; new_state->base_y = 0; new_state->display_blocked = TRUE; if (subdoc->width == 0) { new_state->delay_align = TRUE; } new_state->win_left = 0; new_state->win_right = 0; new_state->x = new_state->win_left; new_state->y = 0; new_state->max_width = new_state->x + 1; new_state->left_margin = new_state->win_left; new_state->right_margin = new_state->win_width - new_state->win_right; new_state->list_stack->old_left_margin = new_state->left_margin; new_state->list_stack->old_right_margin = new_state->right_margin; /* we don't need min widths during relayout */ new_state->need_min_width = FALSE; /* reset line_height stack */ while(new_state->line_height_stack) lo_PopLineHeight(new_state); /* * Initialize the alignment stack for this state * to match the caption alignment. */ if (subdoc->horiz_alignment != LO_ALIGN_LEFT) { lo_PushAlignment(new_state, P_TABLE_DATA, subdoc->horiz_alignment); } state->sub_state = new_state; state->current_ele = (LO_Element *)subdoc; if (is_a_header != FALSE) { LO_TextAttr *old_attr; LO_TextAttr *attr; LO_TextAttr tmp_attr; old_attr = new_state->font_stack->text_attr; lo_CopyTextAttr(old_attr, &tmp_attr); tmp_attr.fontmask |= LO_FONT_BOLD; attr = lo_FetchTextAttr(new_state, &tmp_attr); lo_PushFont(new_state, P_TABLE_HEADER, attr); } /* * Move our current state down into the new sub-state. * Fetch the tag list from the old subdoc's state in preparation * for relayout. */ state = new_state; /* tag_ptr = cell_ptr->subdoc_tags; tag_end_ptr = cell_ptr->subdoc_tags_end; cell_ptr->subdoc_tags = NULL; cell_ptr->subdoc_tags_end = NULL; if (tag_end_ptr != NULL) { tag_end_ptr = tag_end_ptr->next; } */ /* * Copy some cell attribute state from the old cell to the subdoc * so that we retain the correct state. Make sure that the bg_color * doesn't get freed. */ subdoc->horiz_alignment = cell_ptr->horiz_alignment; subdoc->vert_alignment = cell_ptr->vert_alignment; subdoc->backdrop = cell->backdrop; /* cell->backdrop.bg_color = NULL; cell->backdrop.url = NULL; */ /* * Clean up memory used by old cell. */ /* elem_list = cell->cell_list; cell->next = NULL; cell->cell_list = NULL; cell->cell_list_end = NULL; lo_relayout_recycle(context, state, (LO_Element *)cell); */ /* * Relayout all the goodies */ /* lo_RelayoutTags(context, state, tag_ptr, tag_end_ptr, elem_list); */ /* * Link the end of this subdoc's tag chain back to * its parent. The beginning should have never been * unlinked from the parent. */ /* if (state->subdoc_tags_end != NULL) { state->subdoc_tags_end->next = tag_end_ptr; } */ /* * makes sure we are at the bottom * of everything in the document. */ lo_rl_ReflowCell( context, state, cell ); /* Replaced with lo_EndLayoutDuringReflow() lo_CloseOutLayout(context, state); */ lo_EndLayoutDuringReflow( context, state ); old_state = state; /* * Get the unique document ID, and retreive this * documents layout state. */ doc_id = XP_DOCID(context); top_state = lo_FetchTopState(doc_id); state = top_state->doc_state; while ((state->sub_state != NULL)&& (state->sub_state != old_state)) { state = state->sub_state; } /* * Ok, now reset the global form element counters * to their original values. */ if ((doc_lists->form_list != NULL)||(hold_form_list != NULL)) { lo_FormData *form_list; lo_FormData *new_form_list; lo_FormData *tmp_fptr; /* * Remove any new forms created in this subdocs to a * separate list. */ form_list = doc_lists->form_list; new_form_list = NULL; while ((form_list != NULL)&& (form_list->id > hold_form_id)) { tmp_fptr = form_list; form_list = form_list->next; tmp_fptr->next = new_form_list; new_form_list = tmp_fptr; } /* * Restore the element count in the form we started in * because the subdoc may have left it half finished. */ if (form_list != NULL) { form_list->form_ele_cnt = hold_form_ele_cnt; } /* * Merge the newly created forms with the old ones * since the new ones may have partially complete * data. */ while ((new_form_list != NULL)&&(hold_form_list != NULL)) { tmp_fptr = lo_merge_form_data(new_form_list, hold_form_list); new_form_list = new_form_list->next; hold_form_list = hold_form_list->next; tmp_fptr->next = form_list; form_list = tmp_fptr; } /* * Add back on forms that are from later subdocs. */ while (hold_form_list != NULL) { tmp_fptr = hold_form_list; hold_form_list = hold_form_list->next; tmp_fptr->next = form_list; form_list = tmp_fptr; } doc_lists->form_list = form_list; doc_lists->current_form_num = hold_current_form_num; } /* * Restore in form status to what is * was before this relayout. */ top_state->in_form = hold_in_form; if (top_state->savedData.FormList != NULL) { lo_SavedFormListData *all_form_ele; all_form_ele = top_state->savedData.FormList; all_form_ele->data_index = hold_form_data_index; } /* * The master embed index is typically now be back * to its original value, but might not be if we * only had to relayout some (not all) of the embeds * in this subdoc. So, make sure it's set back to * its original value here. */ top_state->embed_count = hold_embed_global_index; /* ditto for tag_count */ top_state->tag_count = original_tag_count; /* * Likewise for the anchor list and image list. */ doc_lists->url_list_len = hold_url_list_len; doc_lists->image_list_count = hold_image_list_count; doc_lists->applet_list_count = hold_applet_list_count; doc_lists->embed_list_count = hold_embed_list_count; top_state->current_layer_num = hold_current_layer_num; subdoc = NULL; cell_ele = NULL; if ((state != old_state)&& (state->current_ele != NULL)) { lo_DocState *subdoc_state; int32 dx, dy; int32 base_x, base_y; subdoc = lo_EndCellSubDoc(context, state, old_state, state->current_ele, TRUE); state->sub_state = NULL; state->current_ele = NULL; /* if ((state->is_a_subdoc == SUBDOC_CELL)|| (state->is_a_subdoc == SUBDOC_CAPTION)) { if (old_state->subdoc_tags_end != NULL) { state->subdoc_tags_end = old_state->subdoc_tags_end; } } */ subdoc_state = (lo_DocState *)(subdoc->state); cell_ptr->start_in_form = subdoc_state->start_in_form; cell_ptr->form_id = subdoc_state->form_id; cell_ptr->form_ele_cnt = subdoc_state->form_ele_cnt; cell_ptr->form_data_index = subdoc_state->form_data_index; cell_ptr->embed_count_base = subdoc_state->embed_count_base; cell_ptr->url_count_base = subdoc_state->url_count_base; cell_ptr->image_list_count_base = subdoc_state->image_list_count_base; cell_ptr->applet_list_count_base = subdoc_state->applet_list_count_base; cell_ptr->embed_list_count_base = subdoc_state->embed_list_count_base; cell_ptr->current_layer_num_base = subdoc_state->current_layer_num_base; cell_ptr->must_relayout = subdoc_state->must_relayout_subdoc; cell_ptr->is_a_subdoc = subdoc_state->is_a_subdoc; /* cell_ptr->subdoc_tags = subdoc_state->subdoc_tags; cell_ptr->subdoc_tags_end = subdoc_state->subdoc_tags_end; */ subdoc_state->subdoc_tags = NULL; subdoc_state->subdoc_tags_end = NULL; cell_ptr->max_y = subdoc_state->y; cell_ptr->horiz_alignment = subdoc->horiz_alignment; cell_ptr->vert_alignment = subdoc->vert_alignment; /* cell_ele = lo_SmallSquishSubDocToCell(context, state, subdoc, &dx, &dy); */ cell_ele = cell_ptr->cell; lo_CreateCellFromSubDoc(context, state, subdoc, cell_ele, &dx, &dy); lo_cleanup_old_state(subdoc->state); base_x = cell_ele->x + cell_ele->x_offset + cell_ele->border_width; base_y = cell_ele->y + cell_ele->y_offset + cell_ele->border_width; dx -= base_x; dy -= base_y; cell_ptr->cell_base_x = dx; cell_ptr->cell_base_y = dy; } XP_ASSERT ( cell_ele != NULL ); old_state->must_relayout_subdoc = FALSE; state->top_state->force_reload = save_force; /* pop the style stack once to get rid of the extra dummy tag * that we added to the stack to force styles on the begin * subdoc in relayout */ if (relayout == FALSE) { /* LO_PopStyleTagByIndex(context, &state, P_TABLE_DATA, 0); */ } return(cell_ele); } /* * if normal borders is TRUE draw cell borders if the rest of * the table has borders. If FALSE, never draw cell borders */ void lo_BeginTableCellAttributes(MWContext *context, lo_DocState *state, lo_TableRec *table, char * colspan_attr, char * rowspan_attr, char * nowrap_attr, char * bgcolor_attr, char * background_attr, lo_TileMode tile_mode, char * valign_attr, char * halign_attr, char * width_attr, char * height_attr, Bool is_a_header, Bool normal_borders) { lo_TableRow *table_row; lo_TableCell *table_cell; int32 val; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_BeginTableCell called\n"); #endif /* LOCAL_DEBUG */ table_row = table->row_ptr; table_cell = XP_NEW(lo_TableCell); if (table_cell == NULL) { return; } if (state->is_a_subdoc != SUBDOC_NOT) { table_cell->in_nested_table = TRUE; } else { table_cell->in_nested_table = FALSE; } /* Copied to lo_InitForBeginCell() table_cell->must_relayout = FALSE; */ table_cell->subdoc_tags = NULL; table_cell->subdoc_tags_end = NULL; /* Copied to lo_InitForBeginCell() table_cell->cell_done = FALSE; */ table_cell->nowrap = FALSE; table_cell->is_a_header = is_a_header; table_cell->percent_width = 0; table_cell->percent_height = 0; table_cell->specified_width = 0; table_cell->specified_height = 0; table_cell->min_width = 0; table_cell->max_width = 0; table_cell->height = 0; table_cell->baseline = 0; table_cell->rowspan = 1; table_cell->colspan = 1; table_cell->cell = NULL; table_cell->next = NULL; table_cell->beginning_tag_count = state->top_state->tag_count; lo_InitForBeginCell( table_row, table_cell ); if (table->current_subdoc == NULL) { XP_DELETE(table_cell); return; } if (colspan_attr) { val = XP_ATOI(colspan_attr); if (val < 1) { val = 1; } /* * Prevent huge colspan */ if (val > TABLE_MAX_COLSPAN) { val = TABLE_MAX_COLSPAN; } table_cell->colspan = val; } if (rowspan_attr) { val = XP_ATOI(rowspan_attr); if (val < 1) { val = 1; } /* * Prevent huge rowspan */ if (val > TABLE_MAX_ROWSPAN) { val = TABLE_MAX_ROWSPAN; } table_cell->rowspan = val; } if (nowrap_attr) { table_cell->nowrap = TRUE; } /* Copied to lo_InitForBeginCell() if (table_row->cell_list == NULL) { table_row->cell_list = table_cell; table_row->cell_ptr = table_cell; } else { table_row->cell_ptr->next = table_cell; table_row->cell_ptr = table_cell; } */ lo_BeginCellSubDoc(context, state, table, bgcolor_attr, background_attr, tile_mode, valign_attr, halign_attr, width_attr, height_attr, is_a_header, normal_borders ? table->draw_borders : 0, FALSE); /* * We added a new state. */ lo_PushStateLevel ( context ); } void lo_BeginTableCell(MWContext *context, lo_DocState *state, lo_TableRec *table, PA_Tag *tag, Bool is_a_header) { char *colspan_attr = (char*)lo_FetchParamValue(context, tag, PARAM_COLSPAN); char *rowspan_attr = (char*)lo_FetchParamValue(context, tag, PARAM_ROWSPAN); char *nowrap_attr = (char*)lo_FetchParamValue(context, tag, PARAM_NOWRAP); char *bgcolor_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BGCOLOR); char *background_attr= (char*)lo_FetchParamValue(context, tag, PARAM_BACKGROUND); char *valign_attr = (char*)lo_FetchParamValue(context, tag, PARAM_VALIGN); char *halign_attr = (char*)lo_FetchParamValue(context, tag, PARAM_ALIGN); char *width_attr = (char*)lo_FetchParamValue(context, tag, PARAM_WIDTH); char *height_attr = (char*)lo_FetchParamValue(context, tag, PARAM_HEIGHT); /* remove the PA_LOCK stuff */ lo_BeginTableCellAttributes(context, state, table, colspan_attr, rowspan_attr, nowrap_attr, bgcolor_attr, background_attr, LO_TILE_BOTH, /* Default backdrop tile mode */ valign_attr, halign_attr, width_attr, height_attr, is_a_header, TRUE); if(colspan_attr) PA_FREE(colspan_attr); if(rowspan_attr) PA_FREE(rowspan_attr); if(nowrap_attr) PA_FREE(nowrap_attr); if(bgcolor_attr) PA_FREE(bgcolor_attr); if(background_attr) PA_FREE(background_attr); if(valign_attr) PA_FREE(valign_attr); if(halign_attr) PA_FREE(halign_attr); if(width_attr) PA_FREE(width_attr); if(height_attr) PA_FREE(height_attr); } void lo_EndTableCell(MWContext *context, lo_DocState *state, Bool relayout ) { LO_SubDocStruct *subdoc; LO_CellStruct *cell_ele; lo_TableRec *table; lo_TableRow *table_row; lo_TableCell *table_cell; lo_table_span *span_rec; int32 top_inner_pad; int32 bottom_inner_pad; int32 left_inner_pad; int32 right_inner_pad; int32 i; lo_TopState *top_state; lo_DocState *old_state; int32 doc_id; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_EndTableCell called\n"); #endif /* LOCAL_DEBUG */ /* * makes sure we are at the bottom * of everything in the document. */ if (relayout == FALSE) { lo_CloseOutLayout(context, state); } else { lo_EndLayoutDuringReflow( context, state ); } old_state = state; /* * Get the unique document ID, and retrieve this * documents layout state. */ doc_id = XP_DOCID(context); top_state = lo_FetchTopState(doc_id); state = top_state->doc_state; while ((state->sub_state != NULL)&& (state->sub_state != old_state)) { state = state->sub_state; } subdoc = NULL; cell_ele = NULL; if ((state != old_state)&& (state->current_ele != NULL)) { subdoc = lo_EndCellSubDoc(context, state, old_state, state->current_ele, relayout); state->sub_state = NULL; state->current_ele = NULL; if ((state->is_a_subdoc == SUBDOC_CELL)|| (state->is_a_subdoc == SUBDOC_CAPTION)) { if (old_state->subdoc_tags_end != NULL) { state->subdoc_tags_end = old_state->subdoc_tags_end; } } else { } } /* * We popped a state level. */ lo_PopStateLevel ( context ); table = state->current_table; table_row = table->row_ptr; table_cell = table_row->cell_ptr; top_inner_pad = FEUNITS_X(table->inner_top_pad, context); bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context); left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); if (subdoc != NULL) { int32 subdoc_width; int32 subdoc_height; int32 min_cellwidth; int32 base_x, base_y; int32 dx, dy; int32 cell_internal_width; lo_DocState *subdoc_state; Bool reset_min_width; reset_min_width = FALSE; cell_internal_width = old_state->max_width; /* how big do we think this cell should be? */ min_cellwidth = old_state->min_width; /* * If the cell is smaller than this, we need to grow it so that * any internal elements don't overwrite the cell borders. */ if (subdoc->width < min_cellwidth) { /* * We need to lay things out again as we now have more space. * Do we want to be smart and see if we contain things that * will change? * Be sure to add in the width of the borders as later code expects it */ subdoc->width = min_cellwidth + (2 * subdoc->border_width); old_state->must_relayout_subdoc = TRUE; cell_internal_width = min_cellwidth; } subdoc_width = subdoc->width + (2 * subdoc->border_horiz_space) + (left_inner_pad + right_inner_pad); subdoc_height = subdoc->height + (2 * subdoc->border_vert_space) + (top_inner_pad + bottom_inner_pad); table_cell->max_width = subdoc_width; table_cell->min_width = old_state->min_width + (2 * subdoc->border_width) + (2 * subdoc->border_horiz_space) + (left_inner_pad + right_inner_pad); /* * This is some nasty logic. We need to reset the min_width * of the cell in cases where we're certain about how large * the cell is. */ if ( (table_cell->min_width < table_cell->max_width) ) { /* * If we're a fixed width cell and fixed layout (COLS) is on. * BRAIN DAMAGE: It's arguable that we should always do this - a width for * the cell was specified, we should respect it. However, certain popular * sites don't look too good if we do... */ if ( (table_cell->specified_width > 0) && (table_cell->percent_width == 0) && (table->fixed_cols > 0) ) { reset_min_width = TRUE; } else /* * If we're in a fixed width table who's width does not * depend on it's parent and are using fixed layout (COLS). */ if ( (table->fixed_cols > 0) && (table->table_width_fixed != FALSE) ) { reset_min_width = TRUE; } } /* * If nowrap is on or min_width ended up being bigger than * max_width */ if ((table_cell->nowrap != FALSE)|| (table_cell->min_width > table_cell->max_width)) { reset_min_width = TRUE; } if ( reset_min_width != FALSE ) { table_cell->min_width = table_cell->max_width; } /* * If we're in the fixed layout case, then we may need to grow this * column to fit this new cell width. This will allow any subsequent * columns to be layed out to the correct size and not have to be * relayed out. */ if ( table->fixed_cols > 0 ) { lo_SetDefaultCellWidth( context, table, subdoc, table_cell, cell_internal_width ); } table_cell->height = subdoc_height; table_cell->baseline = lo_GetSubDocBaseline(subdoc); subdoc_state = (lo_DocState *)(subdoc->state); table_cell->start_in_form = subdoc_state->start_in_form; table_cell->form_id = subdoc_state->form_id; table_cell->form_ele_cnt = subdoc_state->form_ele_cnt; table_cell->form_data_index = subdoc_state->form_data_index; table_cell->embed_count_base = subdoc_state->embed_count_base; table_cell->url_count_base = subdoc_state->url_count_base; table_cell->image_list_count_base = subdoc_state->image_list_count_base; table_cell->applet_list_count_base = subdoc_state->applet_list_count_base; table_cell->embed_list_count_base = subdoc_state->embed_list_count_base; table_cell->current_layer_num_base = subdoc_state->current_layer_num_base; table_cell->must_relayout = subdoc_state->must_relayout_subdoc; table_cell->is_a_subdoc = subdoc_state->is_a_subdoc; if (relayout == FALSE) { table_cell->subdoc_tags = subdoc_state->subdoc_tags; table_cell->subdoc_tags_end = subdoc_state->subdoc_tags_end; } subdoc_state->subdoc_tags = NULL; subdoc_state->subdoc_tags_end = NULL; table_cell->max_y = subdoc_state->y; table_cell->horiz_alignment = subdoc->horiz_alignment; table_cell->vert_alignment = subdoc->vert_alignment; if (relayout == FALSE) { cell_ele = lo_SmallSquishSubDocToCell(context, state, subdoc, &dx, &dy); /* Keep ptr. back to table state structs for relayout */ cell_ele->table_cell = table_cell; cell_ele->table_row = table_row; cell_ele->table = table; } else { cell_ele = table_cell->cell; lo_CreateCellFromSubDoc(context, state, subdoc, cell_ele, &dx, &dy); } lo_cleanup_old_state(subdoc->state); base_x = cell_ele->x + cell_ele->x_offset + cell_ele->border_width; base_y = cell_ele->y + cell_ele->y_offset + cell_ele->border_width; dx -= base_x; dy -= base_y; table_cell->cell_base_x = dx; table_cell->cell_base_y = dy; } table_cell->cell = cell_ele; table_cell->cell_done = TRUE; i = 0; while (i < table_cell->colspan) { if ((table->width_spans == NULL)|| ((table->width_span_ptr != NULL)&& (table->width_span_ptr->next == NULL))) { span_rec = XP_NEW(lo_table_span); if (span_rec == NULL) { return; } span_rec->dim = 1; span_rec->min_dim = 1; span_rec->span = 0; span_rec->next = NULL; if (table->width_spans == NULL) { table->width_spans = span_rec; table->width_span_ptr = span_rec; } else { table->width_span_ptr->next = span_rec; table->width_span_ptr = span_rec; } } else { if (table->width_span_ptr == NULL) { table->width_span_ptr = table->width_spans; } else { table->width_span_ptr = table->width_span_ptr->next; } span_rec = table->width_span_ptr; } if (span_rec->span > 0) { span_rec->span--; table_row->cells++; /* * This only happens if a colspan on this * row overlaps a rowspan from a previous row. */ if (i > 0) { int32 new_span; new_span = table_cell->rowspan - 1; if (new_span > span_rec->span) { span_rec->span = new_span; } i++; /* * Don't count this cell twice. */ table_row->cells--; } continue; } else { span_rec->span = table_cell->rowspan - 1; i++; if (table_cell->colspan == 1) { if (table_cell->max_width > span_rec->dim) { span_rec->dim = table_cell->max_width; } if (table_cell->min_width > span_rec->min_dim) { span_rec->min_dim = table_cell->min_width; } } } } span_rec = table->height_span_ptr; if (table_cell->rowspan == 1) { int32 tmp_val; /* * If the user specified a height for the cell, * that becomes our min height. */ if ((table_cell->specified_height > 0)&& (table_cell->specified_height > span_rec->min_dim)) { span_rec->min_dim = table_cell->specified_height; } tmp_val = table_cell->baseline - span_rec->min_dim; if (tmp_val > 0) { span_rec->min_dim += tmp_val; if (table_row->vert_alignment == LO_ALIGN_BASELINE) { span_rec->dim += tmp_val; } } if (table_row->vert_alignment == LO_ALIGN_BASELINE) { tmp_val = (table_cell->height - table_cell->baseline) - (span_rec->dim - span_rec->min_dim); if (tmp_val > 0) { span_rec->dim += tmp_val; } } else { if (table_cell->height > span_rec->dim) { span_rec->dim = table_cell->height; } } } table_row->cells += table_cell->colspan; } void lo_BeginTableCaption(MWContext *context, lo_DocState *state, lo_TableRec *table, PA_Tag *tag) { lo_TableCaption *caption; PA_Block buff; char *str; caption = XP_NEW_ZAP(lo_TableCaption); if (caption == NULL) { return; } caption->vert_alignment = LO_ALIGN_TOP; caption->horiz_alignment = LO_ALIGN_CENTER; caption->min_width = 0; caption->max_width = 0; caption->height = 0; caption->subdoc = NULL; caption->cell_ele = NULL; /* * Check for an align parameter */ buff = lo_FetchParamValue(context, tag, PARAM_ALIGN); if (buff != NULL) { PA_LOCK(str, char *, buff); if (pa_TagEqual("bottom", str)) { caption->vert_alignment = LO_ALIGN_BOTTOM; } PA_UNLOCK(buff); PA_FREE(buff); } table->caption = caption; lo_BeginCaptionSubDoc(context, state, caption, tag); } void lo_EndTableCaption(MWContext *context, lo_DocState *state) { LO_SubDocStruct *subdoc; lo_TableRec *table; lo_TableCaption *caption; lo_TopState *top_state; lo_DocState *old_state; int32 doc_id; int32 top_inner_pad; int32 bottom_inner_pad; int32 left_inner_pad; int32 right_inner_pad; /* * makes sure we are at the bottom * of everything in the document. */ lo_CloseOutLayout(context, state); old_state = state; /* * Get the unique document ID, and retreive this * documents layout state. */ doc_id = XP_DOCID(context); top_state = lo_FetchTopState(doc_id); state = top_state->doc_state; while ((state->sub_state != NULL)&& (state->sub_state != old_state)) { state = state->sub_state; } subdoc = NULL; if ((state != old_state)&& (state->current_ele != NULL)) { subdoc = lo_EndCellSubDoc(context, state, old_state, state->current_ele, FALSE); state->sub_state = NULL; state->current_ele = NULL; if ((state->is_a_subdoc == SUBDOC_CELL)|| (state->is_a_subdoc == SUBDOC_CAPTION)) { if (old_state->subdoc_tags_end != NULL) { state->subdoc_tags_end = old_state->subdoc_tags_end; } } } table = state->current_table; caption = table->caption; top_inner_pad = FEUNITS_X(table->inner_top_pad, context); bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context); left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); if (subdoc != NULL) { int32 subdoc_width; int32 subdoc_height; subdoc_width = subdoc->width + (2 * subdoc->border_horiz_space) + (left_inner_pad + right_inner_pad); subdoc_height = subdoc->height + (2 * subdoc->border_vert_space) + (top_inner_pad + bottom_inner_pad); caption->max_width = subdoc_width; caption->min_width = old_state->min_width + (2 * subdoc->border_width) + (2 * subdoc->border_horiz_space) + (left_inner_pad + right_inner_pad); if (caption->min_width > caption->max_width) { caption->min_width = caption->max_width; } caption->height = subdoc_height; } caption->subdoc = subdoc; /* If the caption is empty, free the memory used by it */ if (lo_subdoc_has_elements(caption->subdoc->state) == FALSE) { lo_FreeTableCaption( context, state, table ); } /* * We popped a state level. */ lo_PopStateLevel ( context ); } void lo_BeginTableRowAttributes(MWContext *context, lo_DocState *state, lo_TableRec *table, char *bgcolor_attr, char *background_attr, char *valign_attr, char *halign_attr) { lo_TableRow *table_row; lo_table_span *span_rec; char *bgcolor_from_style=NULL; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_BeginTableRow called\n"); #endif /* LOCAL_DEBUG */ table_row = XP_NEW(lo_TableRow); if (table_row == NULL) { return; } /* copied to lo_UpdateTableStateForBeginRow() table_row->row_done = FALSE; */ table_row->has_percent_width_cells = FALSE; table_row->backdrop.bg_color = NULL; table_row->backdrop.url = NULL; table_row->backdrop.tile_mode = LO_TILE_BOTH; /* copied to lo_UpdateTableStateForBeginRow() table_row->cells = 0; */ table_row->vert_alignment = LO_ALIGN_DEFAULT; table_row->horiz_alignment = LO_ALIGN_DEFAULT; /* copied to lo_UpdateTableStateForBeginRow() table_row->cell_list = NULL; table_row->cell_ptr = NULL; */ table_row->next = NULL; lo_UpdateTableStateForBeginRow( table, table_row ); /* check for style sheet color and override if necessary */ if(state->top_state && state->top_state->style_stack) { StyleStruct *style_struct; style_struct = STYLESTACK_GetStyleByIndex( state->top_state->style_stack, 0); if(style_struct) { bgcolor_from_style = STYLESTRUCT_GetString(style_struct, BG_COLOR_STYLE); if(bgcolor_from_style) { bgcolor_attr = bgcolor_from_style; } } } /* * Check for a background color attribute */ if (bgcolor_attr) { uint8 red, green, blue; XP_Bool rv; if(bgcolor_from_style) rv = LO_ParseStyleSheetRGB(bgcolor_attr, &red, &green, &blue); else rv = LO_ParseRGB(bgcolor_attr, &red, &green, &blue); if(rv) { table_row->backdrop.bg_color = XP_NEW(LO_Color); if (table_row->backdrop.bg_color != NULL) { table_row->backdrop.bg_color->red = red; table_row->backdrop.bg_color->green = green; table_row->backdrop.bg_color->blue = blue; } } } if (background_attr) table_row->backdrop.url = XP_STRDUP(background_attr); XP_FREEIF(bgcolor_from_style); /* * Check for a vertical align parameter */ if (valign_attr) { table_row->vert_alignment = lo_EvalVAlignParam(valign_attr); } /* * Check for a horizontal align parameter */ if (halign_attr) { table_row->horiz_alignment = lo_EvalCellAlignParam(halign_attr); } if (table->row_list == NULL) { table->row_list = table_row; table->row_ptr = table_row; } else { table->row_ptr->next = table_row; table->row_ptr = table_row; } /* copied to lo_UpdateTableStateForBeginRow() table->width_span_ptr = NULL; */ span_rec = XP_NEW(lo_table_span); if (span_rec == NULL) { return; } if (table->height_spans == NULL) { table->height_spans = span_rec; table->height_span_ptr = span_rec; } else { table->height_span_ptr->next = span_rec; table->height_span_ptr = span_rec; } span_rec->dim = 1; /* * Since min_dim on the heights is never used. * I am appropriating it to do baseline aligning. It will * start as 0, and eventually be the amount of baseline needed * to align all these cells in this row * by their baselines. */ span_rec->min_dim = 0; span_rec->span = 0; span_rec->next = NULL; } void lo_BeginTableRow(MWContext *context, lo_DocState *state, lo_TableRec *table, PA_Tag *tag) { char *bgcolor_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BGCOLOR); char *background_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BACKGROUND); char *valign_attr = (char*)lo_FetchParamValue(context, tag, PARAM_VALIGN); char *halign_attr = (char*)lo_FetchParamValue(context, tag, PARAM_ALIGN); /* remove the PA_LOCK stuff */ lo_BeginTableRowAttributes(context, state, table, bgcolor_attr, background_attr, valign_attr, halign_attr); if(bgcolor_attr) PA_FREE(bgcolor_attr); if(valign_attr) PA_FREE(valign_attr); if(halign_attr) PA_FREE(halign_attr); } void lo_EndTableRow(MWContext *context, lo_DocState *state, lo_TableRec *table) { lo_TableRow *table_row; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_EndTableRow called\n"); #endif /* LOCAL_DEBUG */ table_row = table->row_ptr; table_row->row_done = TRUE; table->rows++; while (table->width_span_ptr != NULL) { table->width_span_ptr = table->width_span_ptr->next; if (table->width_span_ptr != NULL) { table->width_span_ptr->span--; table_row->cells++; } } if (table_row->cells > table->cols) { table->cols = table_row->cells; } /* * We've hit the end of a row, if it's the first row and * we haven't allocated all columns yet and table width * is remaining, then set their size now. */ if ( table->fixed_width_remaining > 0 ) { if ( (table_row->cells < table->fixed_cols) && (table->fixed_col_widths != NULL) ) { int32 count; int32 colwidth; int32 cell_extra_space; int32 left_inner_pad; int32 right_inner_pad; /* how much border/pad space do we need per cell */ if (table->draw_borders == TABLE_BORDERS_OFF) { cell_extra_space = 2 * TABLE_DEF_CELL_BORDER; } else if (table->draw_borders == TABLE_BORDERS_ON) { cell_extra_space = 2 * TABLE_DEF_CELL_BORDER; } else { cell_extra_space = 0; } left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); cell_extra_space += left_inner_pad + right_inner_pad; /* divide space up to the remaining cols */ colwidth = ( table->fixed_width_remaining / ( table->fixed_cols - table_row->cells )) - cell_extra_space; if ( colwidth < 0 ) { colwidth = 0; } for ( count = table_row->cells; count < table->fixed_cols; ++count ) { table->fixed_col_widths[ count ] = colwidth; table->fixed_width_remaining -= colwidth; } /* add any leftover space to the last row */ table->fixed_col_widths[ table->fixed_cols - 1 ] += table->fixed_width_remaining; } table->fixed_width_remaining = 0; } } void lo_BeginTableAttributes(MWContext *context, lo_DocState *state, char *align_attr, char *border_attr, char *border_top_attr, char *border_bottom_attr, char *border_left_attr, char *border_right_attr, char *border_color_attr, char *border_style_attr, char *vspace_attr, char *hspace_attr, char *bgcolor_attr, char *background_attr, char *width_attr, char *height_attr, char *cellpad_attr, char *toppad_attr, char *bottompad_attr, char *leftpad_attr, char *rightpad_attr, char *cellspace_attr, char *cols_attr) { lo_TableRec *table; LO_TableStruct *table_ele; int32 val; char *bgcolor_from_style = NULL; Bool allow_percent_width; Bool allow_percent_height; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_BeginTable called\n"); #endif /* LOCAL_DEBUG */ if (state == NULL) { return; } /* Increment table nesting level (used for passing into lo_CreateCellBackGroundLayer() */ state->top_state->table_nesting_level++; table_ele = (LO_TableStruct *)lo_NewElement(context, state, LO_TABLE, NULL, 0); if (table_ele == NULL) { state->top_state->out_of_memory = TRUE; return; } table_ele->type = LO_TABLE; /* Copied into lo_PositionTableElement() */ /* table_ele->ele_id = NEXT_ELEMENT; table_ele->x = state->x; table_ele->x_offset = 0; table_ele->y = state->y; table_ele->y_offset = 0; table_ele->width = 0; table_ele->height = 0; table_ele->line_height = 0; */ table_ele->FE_Data = NULL; table_ele->anchor_href = state->current_anchor; /* * Default to the current alignment */ if ( state->align_stack != NULL ) { table_ele->alignment = state->align_stack->alignment; } else { table_ele->alignment = LO_ALIGN_LEFT; } table_ele->border_width = TABLE_DEF_BORDER; table_ele->border_top_width = TABLE_DEF_BORDER; table_ele->border_bottom_width = TABLE_DEF_BORDER; table_ele->border_left_width = TABLE_DEF_BORDER; table_ele->border_right_width = TABLE_DEF_BORDER; table_ele->border_style = TABLE_DEF_BORDER_STYLE; table_ele->border_vert_space = TABLE_DEF_VERTICAL_SPACE; table_ele->border_horiz_space = TABLE_DEF_HORIZONTAL_SPACE; table_ele->border_color.red = 0; table_ele->border_color.green = 0; table_ele->border_color.blue = 0; table_ele->ele_attrmask = 0; table_ele->sel_start = -1; table_ele->sel_end = -1; /* Copied into lo_PositionTableElement() */ /* table_ele->next = NULL; table_ele->prev = NULL; */ /* * Check for an align parameter */ if (align_attr) { Bool floating; floating = FALSE; table_ele->alignment = lo_EvalAlignParam(align_attr, &floating); /* * Only allow left and right (floating) and center. */ if (floating != FALSE) { table_ele->ele_attrmask |= LO_ELE_FLOATING; } else { /* * Tables can be left, center, right, justify or char alignment. * We only do left, center and right. True left and right will * hit the floating case above. So, we set all alignments to * be either center or left. */ switch ( table_ele->alignment ) { case LO_ALIGN_LEFT: case LO_ALIGN_RIGHT: case LO_ALIGN_CENTER: break; case LO_ALIGN_NCSA_CENTER: table_ele->alignment = LO_ALIGN_CENTER; break; default: table_ele->alignment = LO_ALIGN_LEFT; break; } } } lo_PositionTableElement(state, table_ele); /* * Push our alignment state if we're not floating */ /* Copied into lo_PositionTableElement() */ /* if ( !(table_ele->ele_attrmask & LO_ELE_FLOATING) ) { lo_PushAlignment(state, P_TABLE_DATA, table_ele->alignment); } */ /* * Get the border parameter. */ if (border_attr) { val = XP_ATOI(border_attr); if ((val == 0)&&(*border_attr == '0')) { val = -1; } else if (val < 1) { val = 1; } table_ele->border_width = val; table_ele->border_top_width = val; table_ele->border_bottom_width = val; table_ele->border_left_width = val; table_ele->border_right_width = val; } table_ele->border_width = FEUNITS_X(table_ele->border_width, context); /* * Get the top border parameter. */ if (border_top_attr) { val = XP_ATOI(border_top_attr); if ((val == 0)&&(*border_top_attr == '0')) { val = -1; } else if (val < 1) { val = 1; } table_ele->border_top_width = val; } table_ele->border_top_width = FEUNITS_Y(table_ele->border_top_width, context); /* * Get the bottom border parameter. */ if (border_bottom_attr) { val = XP_ATOI(border_bottom_attr); if ((val == 0)&&(*border_bottom_attr == '0')) { val = -1; } else if (val < 1) { val = 1; } table_ele->border_bottom_width = val; } table_ele->border_bottom_width = FEUNITS_Y(table_ele->border_bottom_width, context); /* * Get the left border parameter. */ if (border_left_attr) { val = XP_ATOI(border_left_attr); if ((val == 0)&&(*border_left_attr == '0')) { val = -1; } else if (val < 1) { val = 1; } table_ele->border_left_width = val; } table_ele->border_left_width = FEUNITS_X(table_ele->border_left_width, context); /* * Get the right border parameter. */ if (border_right_attr) { val = XP_ATOI(border_right_attr); if ((val == 0)&&(*border_right_attr == '0')) { val = -1; } else if (val < 1) { val = 1; } table_ele->border_right_width = val; } table_ele->border_right_width = FEUNITS_X(table_ele->border_right_width, context); /* * Get the border style parameter. */ if (border_style_attr) { int32 border_style; border_style = BORDER_OUTSET; if ( pa_TagEqual("none", border_style_attr) ) { border_style = BORDER_NONE; } else if ( pa_TagEqual("dotted", border_style_attr) ) { border_style = BORDER_DOTTED; } else if ( pa_TagEqual("dashed", border_style_attr) ) { border_style = BORDER_DASHED; } else if ( pa_TagEqual("solid", border_style_attr) ) { border_style = BORDER_SOLID; } else if ( pa_TagEqual("double", border_style_attr) ) { border_style = BORDER_DOUBLE; } else if ( pa_TagEqual("groove", border_style_attr) ) { border_style = BORDER_GROOVE; } else if ( pa_TagEqual("ridge", border_style_attr) ) { border_style = BORDER_RIDGE; } else if ( pa_TagEqual("inset", border_style_attr) ) { border_style = BORDER_INSET; } else if ( pa_TagEqual("outset", border_style_attr) ) { border_style = BORDER_OUTSET; } table_ele->border_style = border_style; } /* * Get the border color parameter. */ if (border_color_attr) { uint8 red, green, blue; LO_ParseStyleSheetRGB(border_color_attr, &red, &green, &blue); table_ele->border_color.red = red; table_ele->border_color.green = green; table_ele->border_color.blue = blue; } /* * Get the extra vertical space parameter. */ if (vspace_attr) { val = XP_ATOI(vspace_attr); if (val < 0) { val = 0; } table_ele->border_vert_space = val; } table_ele->border_vert_space = FEUNITS_Y(table_ele->border_vert_space, context); /* * Get the extra horizontal space parameter. */ if (hspace_attr) { val = XP_ATOI(hspace_attr); if (val < 0) { val = 0; } table_ele->border_horiz_space = val; } table_ele->border_horiz_space = FEUNITS_X(table_ele->border_horiz_space, context); table = XP_NEW(lo_TableRec); /* Keep ptr to table state structure. Will be needed during relayout */ table_ele->table = table; if (table == NULL) { return; } if(table_ele->border_top_width < 0) table_ele->border_top_width = 0; if(table_ele->border_bottom_width < 0) table_ele->border_bottom_width = 0; if(table_ele->border_right_width < 0) table_ele->border_right_width = 0; if(table_ele->border_left_width < 0) table_ele->border_left_width = 0; if(table_ele->border_width < 0) { /* backwards compatibility */ table->draw_borders = TABLE_BORDERS_GONE; table_ele->border_width = 0; table_ele->border_top_width = 0; table_ele->border_bottom_width = 0; table_ele->border_right_width = 0; table_ele->border_left_width = 0; } else if (table_ele->border_top_width == 0 && table_ele->border_bottom_width == 0 && table_ele->border_left_width == 0 && table_ele->border_right_width == 0) { table->draw_borders = TABLE_BORDERS_OFF; } else { table->draw_borders = TABLE_BORDERS_ON; } table->has_percent_width_cells = FALSE; table->has_percent_height_cells = FALSE; table->backdrop.bg_color = NULL; table->backdrop.url = NULL; table->backdrop.tile_mode = LO_TILE_BOTH; /* Copied to lo_InitTableRecord() */ /* table->rows = 0; table->cols = 0; */ table->width_spans = NULL; table->width_span_ptr = NULL; table->height_spans = NULL; /* Copied to lo_InitTableRecord() table->height_span_ptr = NULL; */ table->caption = NULL; table->table_ele = table_ele; table->current_subdoc = NULL; table->row_list = NULL; table->row_ptr = NULL; table->width = 0; table->height = 0; lo_InitTableRecord( table ); /* * Percent width, height added for relayout */ table->percent_width = 0; table->percent_height = 0; table->inner_top_pad = TABLE_DEF_INNER_CELL_PAD; table->inner_bottom_pad = TABLE_DEF_INNER_CELL_PAD; table->inner_left_pad = TABLE_DEF_INNER_CELL_PAD; table->inner_right_pad = TABLE_DEF_INNER_CELL_PAD; table->inter_cell_pad = TABLE_DEF_INTER_CELL_PAD; table->current_subdoc = (LO_SubDocStruct *)lo_NewElement(context, state, LO_SUBDOC, NULL, 0); table->current_subdoc->type = LO_SUBDOC; table->current_subdoc->backdrop.bg_color = NULL; table->current_subdoc->backdrop.url = NULL; table->current_subdoc->backdrop.tile_mode = LO_TILE_BOTH; table->current_subdoc->state = lo_NewLayout(context, state->win_width, state->win_height, 0, 0, NULL); table->default_cell_width = 0; table->fixed_width_remaining = 0; table->fixed_col_widths = NULL; table->table_width_fixed = FALSE; table->fixed_cols = 0; /* * You can't do percentage widths if the parent's * width is still undecided. */ allow_percent_width = TRUE; allow_percent_height = TRUE; if ((state->is_a_subdoc == SUBDOC_CELL)|| (state->is_a_subdoc == SUBDOC_CAPTION)) { lo_TopState *top_state; lo_DocState *new_state; int32 doc_id; /* * Get the unique document ID, and retreive this * documents layout state. */ doc_id = XP_DOCID(context); top_state = lo_FetchTopState(doc_id); new_state = top_state->doc_state; while ((new_state->sub_state != NULL)&& (new_state->sub_state != state)) { new_state = new_state->sub_state; } if ((new_state->sub_state == state)&& (new_state->current_ele != NULL)) { LO_SubDocStruct *subdoc; subdoc = (LO_SubDocStruct *)new_state->current_ele; if (subdoc->width == 0) { allow_percent_width = FALSE; #ifdef LOCAL_DEBUG fprintf(stderr, "Percent width not allowed in this subdoc!\n"); #endif /* LOCAL_DEBUG */ } else { #ifdef LOCAL_DEBUG fprintf(stderr, "Percent width IS allowed in this subdoc!\n"); #endif /* LOCAL_DEBUG */ } if (subdoc->height == 0) { allow_percent_height = FALSE; } } } /* check for style sheet color and override if necessary */ if(state->top_state && state->top_state->style_stack) { StyleStruct *style_struct; style_struct = STYLESTACK_GetStyleByIndex( state->top_state->style_stack, 0); if(style_struct) { bgcolor_from_style = STYLESTRUCT_GetString(style_struct, BG_COLOR_STYLE); if(bgcolor_from_style) { bgcolor_attr = bgcolor_from_style; } } } /* * Check for a background color attribute */ if (bgcolor_attr) { uint8 red, green, blue; XP_Bool rv; if(bgcolor_from_style) rv = LO_ParseStyleSheetRGB(bgcolor_attr, &red, &green, &blue); else rv = LO_ParseRGB(bgcolor_attr, &red, &green, &blue); if(rv) { table->backdrop.bg_color = XP_NEW(LO_Color); if (table->backdrop.bg_color != NULL) { table->backdrop.bg_color->red = red; table->backdrop.bg_color->green = green; table->backdrop.bg_color->blue = blue; } } } if (background_attr) table->backdrop.url = XP_STRDUP(background_attr); XP_FREEIF(bgcolor_from_style); /* * Get the width and height parameters, in absolute or percentage. * If percentage, make it absolute. */ if (width_attr) { Bool is_percent; val = lo_ValueOrPercent(width_attr, &is_percent); if (is_percent != FALSE) { table->percent_width = val; /* if (allow_percent_width == FALSE) { val = 0; } else { val = (state->win_width - state->win_left - state->win_right) * val / 100; } */ } else { table->percent_width = 0; table->table_width_fixed = TRUE; val = FEUNITS_X(val, context); } if (val < 0) { val = 0; } table->width = val; } if (height_attr) { Bool is_percent; val = lo_ValueOrPercent(height_attr, &is_percent); if (is_percent != FALSE) { table->percent_height = val; /* if (allow_percent_height == FALSE) { val = 0; } else { val = (state->win_height - state->win_top - state->win_bottom) * val / 100; } */ } else { table->percent_height = 0; val = FEUNITS_X(val, context); } if (val < 0) { val = 0; } table->height = val; } lo_SetTableDimensions(state, table, allow_percent_width, allow_percent_height); if (cellpad_attr) { val = XP_ATOI(cellpad_attr); if (val < 0) { val = 0; } /* set all our pads to this value */ table->inner_top_pad = val; table->inner_bottom_pad = val; table->inner_left_pad = val; table->inner_right_pad = val; } if (toppad_attr) { val = XP_ATOI(toppad_attr); if (val < 0) { val = 0; } table->inner_top_pad = val; } if (bottompad_attr) { val = XP_ATOI(bottompad_attr); if (val < 0) { val = 0; } table->inner_bottom_pad = val; } if (leftpad_attr) { val = XP_ATOI(leftpad_attr); if (val < 0) { val = 0; } table->inner_left_pad = val; } if (rightpad_attr) { val = XP_ATOI(rightpad_attr); if (val < 0) { val = 0; } table->inner_right_pad = val; } if (cellspace_attr) { val = XP_ATOI(cellspace_attr); if (val < 0) { val = 0; } table->inter_cell_pad = val; } /* * Get the COLS parameter. */ if (cols_attr) { val = XP_ATOI(cols_attr); if (val < 0) { val = 0; } table_ele->border_horiz_space = val; /* * If we have a specified number of columns, then * we first need to make sure we have a real table * width and then compute our default column width. */ table->fixed_cols = val; if ( val > 0 ) { /* Copied to lo_CalcFixedColWidths() */ /* int32 count; int32 table_width; table->fixed_cols = val; table_width = lo_ComputeInternalTableWidth ( context, table, state ); */ /* Split the space up evenly */ /* table->default_cell_width = table_width / val; */ /* and we have all the table width left to play with */ /* table->fixed_width_remaining = table_width; */ /* allocate and initialize our width array */ table->fixed_col_widths = XP_ALLOC(val * sizeof(int32)); if (table->fixed_col_widths == NULL) { state->top_state->out_of_memory = TRUE; table->fixed_cols = 0; table->default_cell_width = 0; return; } /* for ( count = 0; count < val; ++count ) { table->fixed_col_widths[ count ] = 0; } */ lo_CalcFixedColWidths( context, state, table ); } } /* Copied to lo_UpdateStateAfterBeginTable() */ /* state->current_table = table; */ lo_UpdateStateAfterBeginTable( state, table ); } /* * Preparse the tag attributes and call the real begin table */ void lo_BeginTable(MWContext *context, lo_DocState *state, PA_Tag *tag) { /* style sheets variables */ StyleStruct *style_struct=NULL; SS_Number *top_padding, *bottom_padding, *left_padding, *right_padding; char *align_attr = (char*)lo_FetchParamValue(context, tag, PARAM_ALIGN); char *border_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BORDER); char *border_top_attr = NULL; char *border_bottom_attr = NULL; char *border_left_attr = NULL; char *border_right_attr = NULL; char *border_color_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BORDERCOLOR); char *border_style_attr = NULL; char *vspace_attr = (char*)lo_FetchParamValue(context, tag, PARAM_VSPACE); char *hspace_attr = (char*)lo_FetchParamValue(context, tag, PARAM_HSPACE); char *bgcolor_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BGCOLOR); char *background_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BACKGROUND); char *width_attr = (char*)lo_FetchParamValue(context, tag, PARAM_WIDTH); char *height_attr = (char*)lo_FetchParamValue(context, tag, PARAM_HEIGHT); char *cellpad_attr = (char*)lo_FetchParamValue(context, tag, PARAM_CELLPAD); char *toppad_attr = (char*)lo_FetchParamValue(context, tag, PARAM_TOPPAD); char *bottompad_attr = (char*)lo_FetchParamValue(context, tag, PARAM_BOTTOMPAD); char *leftpad_attr = (char*)lo_FetchParamValue(context, tag, PARAM_LEFTPAD); char *rightpad_attr = (char*)lo_FetchParamValue(context, tag, PARAM_RIGHTPAD); char *cellspace_attr = (char*)lo_FetchParamValue(context, tag, PARAM_CELLSPACE); char *cols_attr = (char*)lo_FetchParamValue(context, tag, PARAM_COLS); if(!border_style_attr) { border_style_attr = XP_STRDUP("outset"); } if(!border_color_attr) { XP_ASSERT(state); if(state) border_color_attr = PR_smprintf("#%2x%2x%2x", state->text_bg.red, state->text_bg.green, state->text_bg.blue); } if(state->top_state->style_stack) style_struct = STYLESTACK_GetStyleByIndex(state->top_state->style_stack, 0); if(style_struct) { left_padding = STYLESTRUCT_GetNumber(style_struct, LEFTPADDING_STYLE); if(left_padding) { LO_AdjustSSUnits(left_padding, LEFTPADDING_STYLE, context, state); XP_FREEIF(leftpad_attr); leftpad_attr = PR_smprintf("%ld", (int32)left_padding->value); } right_padding = STYLESTRUCT_GetNumber(style_struct, RIGHTPADDING_STYLE); if(right_padding) { LO_AdjustSSUnits(right_padding, RIGHTPADDING_STYLE, context, state); XP_FREEIF(rightpad_attr); rightpad_attr = PR_smprintf("%ld", (int32)right_padding->value); } top_padding = STYLESTRUCT_GetNumber(style_struct, TOPPADDING_STYLE); if(top_padding) { LO_AdjustSSUnits(top_padding, TOPPADDING_STYLE, context, state); XP_FREEIF(toppad_attr); toppad_attr = PR_smprintf("%ld", (int32)top_padding->value); } bottom_padding = STYLESTRUCT_GetNumber(style_struct, BOTTOMPADDING_STYLE); if(bottom_padding) { LO_AdjustSSUnits(bottom_padding, BOTTOMPADDING_STYLE, context, state); XP_FREEIF(bottompad_attr); bottompad_attr = PR_smprintf("%ld", (int32)bottom_padding->value); } } /* remove the PA_LOCK stuff, it does nothing anyways */ lo_BeginTableAttributes(context, state, align_attr, border_attr, border_top_attr, border_bottom_attr, border_left_attr, border_right_attr, border_color_attr, border_style_attr, vspace_attr, hspace_attr, bgcolor_attr, background_attr, width_attr, height_attr, cellpad_attr, toppad_attr, bottompad_attr, leftpad_attr, rightpad_attr, cellspace_attr, cols_attr); if(align_attr) PA_FREE(align_attr); if(border_attr) PA_FREE(border_attr); if(border_top_attr) PA_FREE(border_top_attr); if(border_bottom_attr) PA_FREE(border_bottom_attr); if(border_left_attr) PA_FREE(border_left_attr); if(border_right_attr) PA_FREE(border_right_attr); if(border_color_attr) PA_FREE(border_color_attr); if(border_style_attr) PA_FREE(border_style_attr); if(vspace_attr) PA_FREE(vspace_attr); if(hspace_attr) PA_FREE(hspace_attr); if(bgcolor_attr) PA_FREE(bgcolor_attr); if(background_attr) PA_FREE(background_attr); if(width_attr) PA_FREE(width_attr); if(height_attr) PA_FREE(height_attr); if(cellpad_attr) PA_FREE(cellpad_attr); if(toppad_attr) PA_FREE(toppad_attr); if(bottompad_attr) PA_FREE(bottompad_attr); if(leftpad_attr) PA_FREE(leftpad_attr); if(rightpad_attr) PA_FREE(rightpad_attr); if(cellspace_attr) PA_FREE(cellspace_attr); if(cols_attr) PA_FREE(cols_attr); } static void lo_fill_cell_array(lo_TableRec *table, lo_cell_data XP_HUGE *cell_array, lo_TableCell *blank_cell, int32 cell_pad, Bool *relayout_pass) { int32 x, y; int32 indx; lo_table_span *row_max; lo_table_span *col_max; lo_TableRow *row_ptr; lo_TableCell *cell_ptr; row_max = table->height_spans; row_ptr = table->row_list; for (y = 0; y < table->rows; y++) { x = 0; col_max = table->width_spans; cell_ptr = row_ptr->cell_list; row_ptr->cells_in_row = 0; while (cell_ptr != NULL) { /* * Also on this pass check if any of the cells * NEED to be relaid out later. */ if (cell_ptr->must_relayout != FALSE) { *relayout_pass = TRUE; } /* * "fix" up badly specified row spans. */ if ((y + cell_ptr->rowspan) > table->rows) { cell_ptr->rowspan = table->rows - y; if (cell_ptr->rowspan == 1) { if (cell_ptr->height > row_max->dim) { row_max->dim = cell_ptr->height; } } } indx = (y * table->cols) + x; if (cell_array[indx].cell == blank_cell) { x++; col_max = col_max->next; continue; } /* * If the cell is not an empty cell, count it for this row */ /* if (cell_ptr->cell->cell_list != NULL || cell_ptr->cell->cell_float_list != NULL) */ row_ptr->cells_in_row++; cell_array[indx].cell = cell_ptr; cell_array[indx].width = cell_ptr->max_width; cell_array[indx].height = cell_ptr->height; if (cell_ptr->colspan > 1) { int32 i; int32 width, min_width; lo_table_span *max_ptr; max_ptr = col_max; width = max_ptr->dim; min_width = max_ptr->min_dim; for (i=1; i < cell_ptr->colspan; i++) { cell_array[indx + i].cell = blank_cell; max_ptr = max_ptr->next; width = width + cell_pad + max_ptr->dim; min_width = min_width + cell_pad + max_ptr->min_dim; } if (width < cell_ptr->max_width) { int32 add_width; int32 add; lo_table_span *add_ptr; add_ptr = col_max; add_width = cell_ptr->max_width - width; add = 0; while (add_ptr != max_ptr) { int32 newWidth; newWidth = add_width * add_ptr->dim / width; add_ptr->dim += newWidth; add += newWidth; add_ptr = add_ptr->next; } add_ptr->dim += (add_width - add); } if (min_width < cell_ptr->min_width) { int32 add_width; int32 add; lo_table_span *add_ptr; add_ptr = col_max; add_width = cell_ptr->min_width - min_width; add = 0; while (add_ptr != max_ptr) { int32 newWidth; newWidth = add_width * add_ptr->min_dim / min_width; /* * We are not allowed to add * enough to put min_dim > dim. */ if ((add_ptr->min_dim + newWidth) > add_ptr->dim) { newWidth = add_ptr->dim - add_ptr->min_dim; /* * don't let newWidth become * negative. */ if (newWidth < 0) { newWidth = 0; } } add_ptr->min_dim += newWidth; add += newWidth; add_ptr = add_ptr->next; } add_ptr->min_dim += (add_width - add); } col_max = max_ptr; } if (cell_ptr->rowspan > 1) { int32 i; int32 height; int32 tmp_val; lo_table_span *max_ptr; max_ptr = row_max; height = max_ptr->dim; for (i=1; i < cell_ptr->rowspan; i++) { cell_array[indx + (i * table->cols)].cell = blank_cell; if (cell_ptr->colspan > 1) { int32 j; for (j=1; j < cell_ptr->colspan; j++) { cell_array[indx + (i * table->cols) + j].cell = blank_cell; } } max_ptr = max_ptr->next; height = height + cell_pad + max_ptr->dim; } tmp_val = cell_ptr->baseline - row_max->min_dim; if (tmp_val > 0) { row_max->min_dim += tmp_val; if (row_ptr->vert_alignment == LO_ALIGN_BASELINE) { row_max->dim += tmp_val; height += tmp_val; } /* * Baseline spacing shouldn't grow the * max height, except for baseline * aligned rows as above. */ if (row_max->min_dim > row_max->dim) { row_max->min_dim = row_max->dim; } } if (height < cell_ptr->height) { int32 add_height; int32 add; lo_table_span *add_ptr; add_ptr = row_max; add_height = cell_ptr->height - height; add = 0; while (add_ptr != max_ptr) { int32 newHeight; newHeight = add_height * add_ptr->dim / height; add_ptr->dim += newHeight; add += newHeight; add_ptr = add_ptr->next; } add_ptr->dim += (add_height - add); } } x += cell_ptr->colspan; col_max = col_max->next; cell_ptr = cell_ptr->next; cell_array[indx].cell->next = NULL; } row_ptr = row_ptr->next; row_max = row_max->next; } } static void lo_percent_width_cells(lo_TableRec *table, lo_cell_data XP_HUGE *cell_array, lo_TableCell *blank_cell, int32 cell_pad, int32 table_pad, int32 *table_width, int32 *min_table_width, int32 *base_table_width, int32 *min_base_table_width) { int32 x, y; int32 indx; int32 new_table_width; int32 new_min_table_width; int32 new_base_table_width; int32 new_min_base_table_width; Bool need_pass_two; lo_table_span *row_max; lo_table_span *col_max; lo_TableRow *row_ptr; lo_TableCell *cell_ptr; new_table_width = 0; row_ptr = table->row_list; row_max = table->height_spans; for (y=0; y < table->rows; y++) { if (row_ptr->has_percent_width_cells != FALSE) { int32 reserve; int32 unknown, unknown_base; unknown = 0; unknown_base = 0; reserve = 100 - table->cols; col_max = table->width_spans; for (x=0; x < table->cols; x++) { indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == blank_cell)|| (cell_ptr == NULL)) { col_max = col_max->next; continue; } if (cell_ptr->percent_width > 0) { int32 width; reserve += cell_ptr->colspan; if (cell_ptr->percent_width > reserve) { cell_ptr->percent_width = reserve; reserve = 0; } else { reserve -= cell_ptr->percent_width; } width = cell_ptr->max_width * 100 / cell_ptr->percent_width; if (width > new_table_width) { new_table_width = width; } } else { unknown++; unknown_base += cell_ptr->max_width; } col_max = col_max->next; } if (unknown) { col_max = table->width_spans; for (x=0; x < table->cols; x++) { indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == blank_cell)|| (cell_ptr == NULL)) { col_max = col_max->next; continue; } if (cell_ptr->percent_width == 0) { int32 width; int32 percent; if (unknown == 1) { percent = reserve; } else { percent = reserve * cell_ptr->max_width / unknown_base; } reserve -= percent; if (reserve < 0) { reserve = 0; } percent += cell_ptr->colspan; cell_ptr->percent_width = percent; width = cell_ptr->max_width * 100 / cell_ptr->percent_width; if (width > new_table_width) { new_table_width = width; } unknown--; } col_max = col_max->next; } } } else { int32 width; width = 0; col_max = table->width_spans; for (x=0; x < table->cols; x++) { indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == blank_cell)|| (cell_ptr == NULL)) { col_max = col_max->next; continue; } width += cell_ptr->max_width; col_max = col_max->next; } if (width > new_table_width) { new_table_width = width; } } row_ptr = row_ptr->next; row_max = row_max->next; } if (*table_width > new_table_width) { new_table_width = *table_width; } /* * If we already know how wide this table must be * Use that width when calculate percentage cell widths. */ if ((table->width > 0)&&(table->width >= *min_table_width)) { new_table_width = table->width; } need_pass_two = FALSE; col_max = table->width_spans; for (x=0; x < table->cols; x++) { int32 current_max; current_max = col_max->dim; col_max->dim = 1; row_max = table->height_spans; for (y=0; y < table->rows; y++) { indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == blank_cell)|| (cell_ptr == NULL)) { row_max = row_max->next; continue; } if ((cell_ptr->percent_width > 0)&& (cell_ptr->colspan == 1)) { int32 p_width; p_width = new_table_width * cell_ptr->percent_width / 100; if (p_width < cell_ptr->min_width) { p_width = cell_ptr->min_width; } if (p_width > col_max->dim) { col_max->dim = p_width; } } else if (cell_ptr->colspan > 1) { need_pass_two = TRUE; } else { if (cell_ptr->max_width > col_max->dim) { col_max->dim = cell_ptr->max_width; } } row_max = row_max->next; } if (col_max->dim < col_max->min_dim) { col_max->dim = col_max->min_dim; } col_max = col_max->next; } /* * Take care of spanning columns if any */ if (need_pass_two != FALSE) { row_max = table->height_spans; for (y=0; y < table->rows; y++) { col_max = table->width_spans; for (x=0; x < table->cols; x++) { indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == blank_cell)|| (cell_ptr == NULL)) { col_max = col_max->next; continue; } if (cell_ptr->colspan > 1) { int32 i; int32 width; lo_table_span *max_ptr; int32 p_width; int32 new_width; new_width = cell_ptr->max_width; if (cell_ptr->percent_width > 0) { p_width = new_table_width * cell_ptr->percent_width / 100; if (p_width >= cell_ptr->min_width) { new_width = p_width; } } max_ptr = col_max; width = max_ptr->dim; for (i=1; i < cell_ptr->colspan; i++) { max_ptr = max_ptr->next; width = width + cell_pad + max_ptr->dim; } if (width < new_width) { int32 add_width; int32 add; lo_table_span *add_ptr; add_ptr = col_max; add_width = new_width - width; add = 0; while (add_ptr != max_ptr) { int32 newWidth; newWidth = add_width * add_ptr->dim / width; add_ptr->dim +=newWidth; add += newWidth; add_ptr = add_ptr->next; } add_ptr->dim += (add_width - add); } } col_max = col_max->next; } row_max = row_max->next; } } new_table_width = 0; new_min_table_width = 0; new_base_table_width = 0; new_min_base_table_width = 0; col_max = table->width_spans; while (col_max != NULL) { new_base_table_width += col_max->dim; new_min_base_table_width += col_max->min_dim; new_table_width = new_table_width + cell_pad + col_max->dim; new_min_table_width = new_min_table_width + cell_pad + col_max->min_dim; col_max = col_max->next; } new_table_width += cell_pad; new_table_width += (table->table_ele->border_left_width + table->table_ele->border_right_width); new_min_table_width += cell_pad; new_min_table_width += (table->table_ele->border_left_width + table->table_ele->border_right_width); if (table->draw_borders == TABLE_BORDERS_OFF) { new_table_width += (2 * table_pad); new_min_table_width += (2 * table_pad); } *table_width = new_table_width; *min_table_width = new_min_table_width; *base_table_width = new_base_table_width; *min_base_table_width = new_min_base_table_width; } static void lo_cell_relayout_pass(MWContext *context, lo_DocState *state, lo_TableRec *table, lo_cell_data XP_HUGE *cell_array, lo_TableCell *blank_cell, int32 cell_pad, Bool *rowspan_pass, Bool relayout) { int32 x, y; int32 indx; lo_table_span *row_max; lo_table_span *col_max; lo_TableRow *row_ptr; lo_TableCell *cell_ptr; int32 top_inner_pad; int32 bottom_inner_pad; int32 left_inner_pad; int32 right_inner_pad; top_inner_pad = FEUNITS_X(table->inner_top_pad, context); bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context); left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); row_ptr = table->row_list; row_max = table->height_spans; for (y=0; y < table->rows; y++) { Bool max_height_valid; Bool changed_row_height; int32 max_row_height; max_height_valid = FALSE; changed_row_height = FALSE; max_row_height = 0; col_max = table->width_spans; for (x=0; x < table->cols; x++) { LO_CellStruct *cell_struct; int32 width; int32 inside_width; Bool has_elements; indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == blank_cell)|| (cell_ptr == NULL)) { col_max = col_max->next; continue; } cell_struct = cell_ptr->cell; inside_width = col_max->dim; width = inside_width; if (cell_ptr->colspan > 1) { int32 i; lo_table_span *max_ptr; max_ptr = col_max; /* * We need to add some cellpads for the spanned cells * to our inside width */ inside_width += ( cell_ptr->colspan - 1 ) * cell_pad; for (i=1; i < cell_ptr->colspan; i++) { max_ptr = max_ptr->next; inside_width += max_ptr->dim; width += cell_pad + max_ptr->dim; } } /* * We want to relayout the cell if it's been tagged as * needing it or if it's been layed out to a different size. */ if ( (cell_ptr->must_relayout != FALSE) || ((width != cell_ptr->max_width)) ) { cell_ptr->must_relayout = FALSE; inside_width = inside_width - (2 * cell_struct->border_width) - (2 * cell_struct->border_horiz_space) - (left_inner_pad + right_inner_pad); /* * Don't relayout documents that have no * elements, it causes errors. */ has_elements = lo_cell_has_elements(cell_ptr->cell); if ( has_elements == FALSE ) { /* * Simply record our new width in this case. */ cell_struct->width = inside_width; } else { cell_struct = lo_RelayoutCell(context, state, table->current_subdoc, cell_ptr, cell_struct, inside_width, cell_ptr->is_a_header, relayout); if (!cell_struct) /* temporary fix for crash when cell_struct is null */ { break; } cell_ptr->cell = cell_struct; cell_ptr->baseline = lo_GetCellBaseline(cell_struct); if (cell_ptr->rowspan == 1) { int32 tmp_val; /* * We have changed the height of a single row cell, so we may need * to update the row height later. */ changed_row_height = TRUE; tmp_val = cell_ptr->baseline - row_max->min_dim; if (tmp_val > 0) { row_max->min_dim += tmp_val; if (row_ptr->vert_alignment == LO_ALIGN_BASELINE) { row_max->dim += tmp_val; } /* * Baseline spacing shouldn't grow the * max height, except for baseline * aligned rows as above. */ if (row_max->min_dim > row_max->dim) { row_max->min_dim = row_max->dim; } } } else { *rowspan_pass = TRUE; } } } else { if (cell_ptr->rowspan > 1) { *rowspan_pass = TRUE; } } /* * If this cell has anything inside it, see if it's height * is the biggest for the row. */ has_elements = lo_cell_has_elements(cell_ptr->cell); if ( has_elements != FALSE ) { int32 cell_row_height; /* * What row height does this cell want? */ cell_row_height = cell_struct->height + (top_inner_pad + bottom_inner_pad) + (2 * cell_struct->border_vert_space); /* * Munge the height if the row is vertically aligned along * the baseline and the cell only spans one row. */ if (cell_ptr->rowspan == 1) { if (row_ptr->vert_alignment == LO_ALIGN_BASELINE) { cell_row_height = (cell_row_height - cell_ptr->baseline) + row_max->min_dim; } if ( cell_row_height > max_row_height ) { /* * Update to our new maximum and flag that it * contains valid data. */ max_height_valid = TRUE; max_row_height = cell_row_height; } } } col_max = col_max->next; } /* * If we did relayout anything on that row which gave us a new * valid max row height which is different to what we currently * have, then use that. */ if ( max_height_valid != FALSE && changed_row_height != FALSE && max_row_height != row_max->dim ) { /* * Can't reset height to be smaller than * the minimum height. */ if (max_row_height >= row_max->min_dim) { row_max->dim = max_row_height; } else { row_max->dim = row_max->min_dim; } } row_max = row_max->next; row_ptr = row_ptr->next; } } static void lo_cell_rowspan_pass(MWContext *context, lo_TableRec *table, lo_cell_data XP_HUGE *cell_array, lo_TableCell *blank_cell, int32 cell_pad) { int32 x, y; int32 indx; lo_table_span *row_max; lo_table_span *col_max; lo_TableRow *row_ptr; lo_TableCell *cell_ptr; int32 top_inner_pad; int32 bottom_inner_pad; top_inner_pad = FEUNITS_X(table->inner_top_pad, context); bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context); row_max = table->height_spans; row_ptr = table->row_list; for (y=0; y < table->rows; y++) { col_max = table->width_spans; for (x=0; x < table->cols; x++) { LO_CellStruct *cell_struct; indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == blank_cell)|| (cell_ptr == NULL)) { col_max = col_max->next; continue; } cell_struct = cell_ptr->cell; if (cell_ptr->rowspan > 1) { int32 i; int32 height; int32 tmp_val; int32 cell_height; lo_table_span *max_ptr; max_ptr = row_max; height = max_ptr->dim; for (i=1; i < cell_ptr->rowspan; i++) { max_ptr = max_ptr->next; height = height + cell_pad + max_ptr->dim; } tmp_val = cell_ptr->baseline - row_max->min_dim; if (tmp_val > 0) { row_max->min_dim += tmp_val; if (row_ptr->vert_alignment == LO_ALIGN_BASELINE) { row_max->dim += tmp_val; height += tmp_val; } /* * Baseline spacing shouldn't grow the * max height, except for baseline * aligned rows as above. */ if (row_max->min_dim > row_max->dim) { row_max->min_dim = row_max->dim; } } cell_height = cell_struct->height + (top_inner_pad + bottom_inner_pad) + (2 * cell_struct->border_vert_space); if (height < cell_height) { int32 add_height; int32 add; lo_table_span *add_ptr; add_ptr = row_max; add_height = cell_height - height; add = 0; while (add_ptr != max_ptr) { int32 newHeight; newHeight = add_height * add_ptr->dim / height; add_ptr->dim += newHeight; add += newHeight; add_ptr->min_dim = add_ptr->dim; add_ptr = add_ptr->next; } add_ptr->dim += (add_height - add); add_ptr->min_dim = add_ptr->dim; } } col_max = col_max->next; } row_max = row_max->next; row_ptr = row_ptr->next; } } void lo_free_cell_record(MWContext *context, lo_DocState *state, lo_TableCell *cell) { if (cell == NULL) { return; } /* * If this table cell is not nested inside another table cell * or caption, free any re-parse tags stored on this cell. */ if ((cell->in_nested_table == FALSE) && (cell->subdoc_tags != NULL)&& (state->is_a_subdoc != SUBDOC_CELL)&& (state->is_a_subdoc != SUBDOC_CAPTION)) { PA_Tag *tptr; PA_Tag *tag; tptr = cell->subdoc_tags; while ((tptr != cell->subdoc_tags_end)&&(tptr != NULL)) { tag = tptr; tptr = tptr->next; tag->next = NULL; PA_FreeTag(tag); } if (tptr != NULL) { tptr->next = NULL; PA_FreeTag(tptr); } cell->subdoc_tags = NULL; cell->subdoc_tags_end = NULL; } if (cell->cell != NULL) { cell->cell->table = NULL; cell->cell->table_row = NULL; cell->cell->table_cell = NULL; } XP_DELETE(cell); } static void lo_free_row_record(MWContext *context, lo_DocState *state, lo_TableRow *row, Bool partial) { lo_TableCell *cell_ptr; lo_TableCell *cell; if (row->cell_list != NULL) { /* * These are already freed on a completed table, and * need to be freed on a partial table. */ if (partial != FALSE) { cell_ptr = row->cell_list; while (cell_ptr != NULL) { cell = cell_ptr; cell_ptr = cell_ptr->next; lo_free_cell_record(context, state, cell); } } row->cell_list = NULL; row->cell_ptr = NULL; } XP_FREEIF(row->backdrop.bg_color); XP_FREEIF(row->backdrop.url); XP_DELETE(row); } static void lo_FreeTableCaption( MWContext *context, lo_DocState *state, lo_TableRec *table ) { if (table->caption != NULL) { if (table->caption->cell_ele != NULL) { lo_FreeCaptionCell( context, state, table->caption->cell_ele ); table->caption->cell_ele = NULL; } if ( table->caption->subdoc != NULL ) { lo_FreePartialSubDoc ( context, state, table->caption->subdoc ); table->caption->subdoc = NULL; } XP_DELETE(table->caption); table->caption = NULL; } } void lo_free_table_record(MWContext *context, lo_DocState *state, lo_TableRec *table, Bool partial) { if (table->row_list != NULL) { lo_TableRow *row_ptr; lo_TableRow *row; row_ptr = table->row_list; while (row_ptr != NULL) { row = row_ptr; row_ptr = row_ptr->next; lo_free_row_record(context, state, row, partial); } table->row_list = NULL; table->row_ptr = NULL; } lo_FreeAllExceptRows( context, state, table ); } void lo_FreePartialTable(MWContext *context, lo_DocState *state, lo_TableRec *table) { lo_TableRow *row_ptr; lo_TableCell *cell_ptr; LO_SubDocStruct *subdoc; LO_CellStruct *cell_struct; if (table == NULL) { return; } row_ptr = table->row_list; while (row_ptr != NULL) { cell_ptr = row_ptr->cell_list; while (cell_ptr != NULL) { cell_struct = cell_ptr->cell; lo_FreePartialCell(context, state, cell_struct); cell_ptr->cell = NULL; cell_ptr = cell_ptr->next; } row_ptr = row_ptr->next; } if (table->caption != NULL) { subdoc = table->caption->subdoc; lo_FreePartialSubDoc(context, state, subdoc); table->caption->subdoc = NULL; } lo_free_table_record(context, state, table, TRUE); } void lo_EndTable(MWContext *context, lo_DocState *state, lo_TableRec *table, Bool relayout) { int32 save_doc_min_width; int32 x, y; int32 cell_x, cell_y; int32 indx; int32 cell_cnt; int32 ele_cnt; int32 table_width, min_table_width; int32 base_table_width, min_base_table_width; int32 table_height; int32 min_table_height; int32 width_limit; Bool relayout_pass; Bool rowspan_pass; Bool cut_to_window_width; lo_TableCell blank_cell; lo_cell_data XP_HUGE *cell_array; XP_Block cell_array_buff; lo_table_span *row_max; lo_table_span *col_max; lo_TableCell *cell_ptr; int32 cell_pad; int32 top_inner_pad; int32 bottom_inner_pad; int32 left_inner_pad; int32 right_inner_pad; int32 table_pad; Bool floating; int32 save_state_x, save_state_y; LO_Element *save_line_list; #ifdef LOCAL_DEBUG fprintf(stderr, "lo_EndTable called\n"); #endif /* LOCAL_DEBUG */ cell_pad = FEUNITS_X(table->inter_cell_pad, context); table_pad = FEUNITS_X(TABLE_DEF_CELL_BORDER, context); top_inner_pad = FEUNITS_X(table->inner_top_pad, context); bottom_inner_pad = FEUNITS_X(table->inner_bottom_pad, context); left_inner_pad = FEUNITS_X(table->inner_left_pad, context); right_inner_pad = FEUNITS_X(table->inner_right_pad, context); relayout_pass = FALSE; cut_to_window_width = TRUE; floating = FALSE; /* * So gcc won't complain */ save_state_x = 0; save_state_y = 0; save_line_list = NULL; /* state->current_table = NULL; */ cell_cnt = table->rows * table->cols; /* * Empty tables are completely ignored! */ if (cell_cnt <= 0) { /* * Clear table state, and free up this structure. */ state->current_table = NULL; /* * Don't wanna free table record any more because this information * is used during relayout. */ /* if (table != NULL) { lo_free_table_record(context, state, table, FALSE); } */ return; } #ifdef XP_WIN16 /* * It had better be the case that the size of the struct is a * power of 2 */ XP_ASSERT(sizeof(lo_cell_data) == 8); cell_array = (lo_cell_data XP_HUGE *)_halloc(cell_cnt, sizeof(lo_cell_data)); /* * There isn't a runtime routine that can initialize a huge array */ if (cell_cnt * sizeof(lo_cell_data) <= 0xFFFFL) memset(cell_array, 0, (cell_cnt * sizeof(lo_cell_data))); else { BYTE XP_HUGE *tmp = (BYTE XP_HUGE *)cell_array; for (indx = 0; indx < cell_cnt * sizeof(lo_cell_data); indx++) tmp[indx] = 0; } #else cell_array_buff = XP_ALLOC_BLOCK(cell_cnt * sizeof(lo_cell_data)); XP_LOCK_BLOCK(cell_array, lo_cell_data *, cell_array_buff); memset(cell_array, 0, (cell_cnt * sizeof(lo_cell_data))); #endif lo_fill_cell_array(table, cell_array, &blank_cell, cell_pad, &relayout_pass); table_width = 0; min_table_width = 0; base_table_width = 0; min_base_table_width = 0; col_max = table->width_spans; while (col_max != NULL) { base_table_width += col_max->dim; min_base_table_width += col_max->min_dim; table_width = table_width + cell_pad + col_max->dim; min_table_width = min_table_width + cell_pad + col_max->min_dim; col_max = col_max->next; } table_width += cell_pad; min_table_width += cell_pad; table_width += (table->table_ele->border_left_width + table->table_ele->border_right_width); min_table_width += (table->table_ele->border_left_width + table->table_ele->border_right_width); if (table->draw_borders == TABLE_BORDERS_OFF) { table_width += (2 * table_pad); min_table_width += (2 * table_pad); } /* * Take care of cells with percentage widths unless we're in * a fixed layout table (has the COLS attribute) in which case * the cell widths are already set. */ if ((table->has_percent_width_cells != FALSE) && (table->fixed_cols == 0)) { lo_percent_width_cells(table, cell_array, &blank_cell, cell_pad, table_pad, &table_width, &min_table_width, &base_table_width, &min_base_table_width); relayout_pass = TRUE; } /* * Use state->left_margin here instead of state->win_left to take * indent from lists into account. */ width_limit = (state->win_width - state->left_margin - state->win_right); if (table->width > 0) { width_limit = table->width; } /* * Else, if we are a nested table in an infinite width * layout space, we don't want to cut to "window width" */ else if (state->allow_percent_width == FALSE) { cut_to_window_width = FALSE; } /* * If we're in a fixed layout table, then we never * want to cut to "window width" */ if ( table->fixed_cols > 0 ) { cut_to_window_width = FALSE; } /* * If the table is too small, we always need to relayout. */ if ((min_table_width >= width_limit)) { lo_table_span *sub_ptr; relayout_pass = TRUE; sub_ptr = table->width_spans; while (sub_ptr != NULL) { sub_ptr->dim = sub_ptr->min_dim; sub_ptr = sub_ptr->next; } } else if ((table_width > width_limit)&&(cut_to_window_width != FALSE)) { intn pass; Bool expand_failed; int32 add_width; int32 div_width; int32 div_width_next; int32 add; int32 total_to_add; lo_table_span *add_ptr; relayout_pass = TRUE; expand_failed = TRUE; pass = 0; total_to_add = width_limit - min_table_width; div_width = table_width; while ((total_to_add > 0)&&(pass < 10)&&(expand_failed !=FALSE)) { int32 extra; int32 min_extra; expand_failed = FALSE; add_ptr = table->width_spans; add_width = total_to_add; total_to_add = 0; div_width_next = (table->cols + 1) * cell_pad; add = 0; while (add_ptr->next != NULL) { if ((pass > 0)&& (add_ptr->min_dim == add_ptr->dim)) { add_ptr = add_ptr->next; continue; } extra = add_width * add_ptr->dim / div_width; if ((add_ptr->min_dim + extra) > add_ptr->dim) { expand_failed = TRUE; min_extra = add_ptr->dim - add_ptr->min_dim; extra = min_extra; } add_ptr->min_dim += extra; if (add_ptr->min_dim < add_ptr->dim) { div_width_next += add_ptr->dim; } add += extra; add_ptr = add_ptr->next; } if ((pass == 0)||(add_ptr->min_dim < add_ptr->dim)) { if (expand_failed == FALSE) { extra = add_width - add; } else { extra = add_width * add_ptr->dim / div_width; } if ((add_ptr->min_dim + extra) > add_ptr->dim) { expand_failed = TRUE; min_extra = add_ptr->dim - add_ptr->min_dim; extra = min_extra; } add_ptr->min_dim += extra; if (add_ptr->min_dim < add_ptr->dim) { div_width_next += add_ptr->dim; } add += extra; } total_to_add = add_width - add; div_width = div_width_next; pass++; } if (total_to_add > 0) { add = 0; add_ptr = table->width_spans; while ((add_ptr->next != NULL)&&(total_to_add > 0)) { if ((add_ptr->min_dim + total_to_add) > add_ptr->dim) { add = add_ptr->dim - add_ptr->min_dim; total_to_add = total_to_add - add; add_ptr->min_dim += add; } else { add_ptr->min_dim += total_to_add; total_to_add = 0; } add_ptr = add_ptr->next; } add_ptr->min_dim += total_to_add; } add_ptr = table->width_spans; while (add_ptr != NULL) { add_ptr->dim = add_ptr->min_dim; add_ptr = add_ptr->next; } } /* * If the user specified a wider width than the minimum * width then we grow the sucker. */ if ((table->width > 0)&&(width_limit > table_width)) { int32 add_width; int32 add; int32 newWidth; int32 min_add_width; int32 min_add; lo_table_span *add_ptr; /* relayout to fill all the space we're adding */ relayout_pass = TRUE; add_ptr = table->width_spans; add_width = width_limit - table_width; if ( add_width < 0 ) { add_width = 0; } add = 0; min_add_width = width_limit - min_table_width; min_add = 0; while ((add_ptr != NULL)&&(add_ptr->next != NULL)) { newWidth = add_width * add_ptr->dim / base_table_width; add_ptr->dim += newWidth; add += newWidth; /* * We only want to resize the min_dim's of the spans * if we're a fixed width table. */ if ( table->table_width_fixed ) { newWidth = min_add_width * add_ptr->min_dim / min_base_table_width; add_ptr->min_dim += newWidth; min_add += newWidth; } add_ptr = add_ptr->next; } if ( table->table_width_fixed ) { add_ptr->min_dim += (min_add_width - min_add); } add_ptr->dim += (add_width - add); } rowspan_pass = FALSE; if ((state->top_state->doc_state == state) || (state->top_state->in_cell_relayout == TRUE)) { if (state->top_state->doc_state == state) { state->top_state->in_cell_relayout = TRUE; } if (relayout_pass != FALSE) { lo_cell_relayout_pass(context, state, table, cell_array, &blank_cell, cell_pad, &rowspan_pass, relayout); } if (rowspan_pass != FALSE) { lo_cell_rowspan_pass(context, table, cell_array, &blank_cell, cell_pad); } if (state->top_state->doc_state == state) { state->top_state->in_cell_relayout = FALSE; } } table_width = 0; min_table_width = 0; col_max = table->width_spans; while (col_max != NULL) { table_width = table_width + cell_pad + col_max->dim; min_table_width = min_table_width + cell_pad + col_max->min_dim; col_max = col_max->next; } table_width += cell_pad; table_width += (table->table_ele->border_left_width + table->table_ele->border_right_width); min_table_width += cell_pad; min_table_width += (table->table_ele->border_left_width + table->table_ele->border_right_width); table_height = 0; min_table_height = 0; row_max = table->height_spans; while (row_max != NULL) { table_height = table_height + cell_pad + row_max->dim; min_table_height = min_table_height + cell_pad + row_max->min_dim; row_max = row_max->next; } table_height += cell_pad; min_table_height += cell_pad; table_height += (table->table_ele->border_top_width + table->table_ele->border_bottom_width); min_table_height += (table->table_ele->border_top_width + table->table_ele->border_bottom_width); if (table->draw_borders == TABLE_BORDERS_OFF) { table_width += (2 * table_pad); min_table_width += (2 * table_pad); table_height += (2 * table_pad); min_table_height += (2 * table_pad); } /* * If the user specified a taller table than the min * height we need to adjust the heights of all the rows. */ if ((table->height > 0)&&(table->height > min_table_height)) { int32 add_height; int32 add; lo_table_span *add_ptr; int32 newHeight; int32 min_add_height; int32 min_add; add_ptr = table->height_spans; add_height = table->height - table_height; if ( add_height < 0 ) { add_height = 0; } min_add_height = table->height - min_table_height; add = 0; min_add = 0; while((add_ptr != NULL) && (add_ptr->next != NULL)) { newHeight = add_height * add_ptr->dim / table_height; add_ptr->dim += newHeight; add += newHeight; newHeight = min_add_height * add_ptr->min_dim / table_height; add_ptr->min_dim += newHeight; min_add += newHeight; add_ptr = add_ptr->next; } add_ptr->dim += (add_height - add); add_ptr->min_dim += (min_add_height - min_add); /* * We can't make the height be less than the sum * of the row heights. */ if (table_height < table->height) { table_height = table->height; } min_table_height = table->height; } table->table_ele->width = table_width; table->table_ele->height = table_height; /* * Here, if we are floating we don't do the linebreak. * We do save some state info and then "fake" a linebreak * so we can use common code to place the rest of the table. */ if (table->table_ele->ele_attrmask & LO_ELE_FLOATING) { save_line_list = state->line_list; save_state_x = state->x; save_state_y = state->y; floating = TRUE; state->x = state->left_margin; state->y = state->y + state->line_height; state->line_list = NULL; } else { /* lo_SetSoftLineBreakState(context, state, FALSE, 1); */ lo_SetLineBreakState ( context, state, FALSE, LO_LINEFEED_BREAK_SOFT, 1, relayout ); } table->table_ele->x = state->x; table->table_ele->y = state->y; /* Keep the element IDs in order */ table->table_ele->ele_id = NEXT_ELEMENT; /*cmanske - Save spacing param for drawing table selection in Composer */ table->table_ele->inter_cell_space = table->inter_cell_pad; lo_AppendToLineList(context, state, (LO_Element *)table->table_ele, 0); #ifdef EDITOR /*cmanske - build list of tables we are laying out * so Editor can readjust it's data after all is finished */ EDT_AddToRelayoutTables(context, table->table_ele); #endif state->x += (cell_pad + table->table_ele->border_left_width); state->y += (cell_pad + table->table_ele->border_top_width); if (table->draw_borders == TABLE_BORDERS_OFF) { state->x += table_pad; state->y += table_pad; } if (table->caption != NULL) { int32 new_width; LO_SubDocStruct *subdoc; Bool has_elements; subdoc = table->caption->subdoc; col_max = table->width_spans; new_width = col_max->dim; while (col_max->next != NULL) { col_max = col_max->next; new_width = new_width + cell_pad + col_max->dim; } /* * Don't relayout documents that have no * elements, it causes errors. */ has_elements = lo_subdoc_has_elements(subdoc->state); if ((new_width < table->caption->max_width)&& (has_elements == FALSE)) { int32 inside_width; inside_width = new_width - (2 * subdoc->border_width) - (2 * subdoc->border_horiz_space) - (left_inner_pad + right_inner_pad); subdoc->width = inside_width; } else /* if (new_width < table->caption->max_width) */ { int32 inside_width; inside_width = new_width - (2 * subdoc->border_width) - (2 * subdoc->border_horiz_space) - (left_inner_pad + right_inner_pad); table->caption->subdoc = lo_RelayoutCaptionSubdoc(context, state, table->caption, subdoc, inside_width, FALSE); subdoc = table->caption->subdoc; table->caption->height = subdoc->height + (2 * subdoc->border_vert_space) + (top_inner_pad + bottom_inner_pad); table->caption->max_width = new_width; } /* else { table->caption->max_width = new_width; } */ } state->current_table = NULL; cell_x = state->x; cell_y = state->y; if ((table->caption != NULL)&& (table->caption->vert_alignment == LO_ALIGN_TOP)) { LO_SubDocStruct *subdoc; cell_x = state->x; subdoc = table->caption->subdoc; subdoc->x = cell_x; subdoc->y = table->table_ele->y; subdoc->x_offset = (int16)subdoc->border_horiz_space; subdoc->y_offset = (int32)subdoc->border_vert_space; subdoc->width = table->caption->max_width - (2 * subdoc->border_horiz_space); subdoc->height = table->caption->height - (2 * subdoc->border_vert_space); ele_cnt = lo_align_subdoc(context, state, (lo_DocState *)subdoc->state, subdoc, table, NULL); if (ele_cnt > 0) { LO_CellStruct *cell_ele; if (relayout == FALSE) { /* cell_ele = lo_SquishSubDocToCell(context, state, subdoc, TRUE); */ cell_ele = lo_SquishSubDocToCell(context, state, subdoc, FALSE); cell_ele->isCaption = TRUE; table->caption->cell_ele = cell_ele; } else { cell_ele = table->caption->cell_ele; lo_UpdateCaptionCellFromSubDoc(context, state, subdoc, cell_ele); } /* table->caption->subdoc = NULL; */ if (cell_ele == NULL) { lo_AppendToLineList(context, state, (LO_Element *)subdoc, 0); } else { /*cmanske - Save spacing param for drawing cell selection by FEs */ /* should we use cell_pad (converted to FE units) instead? */ cell_ele->inter_cell_space = table->inter_cell_pad; lo_AppendToLineList(context, state, (LO_Element *)cell_ele, 0); } cell_x = state->x; cell_y = cell_y + table->caption->height + cell_pad; table->table_ele->y_offset = cell_y - table->table_ele->y; cell_y += (cell_pad + table->table_ele->border_top_width); if (table->draw_borders == TABLE_BORDERS_OFF) { cell_y += table_pad; } } else { LO_CellStruct *cell_ele; /* * Free up the useless subdoc */ cell_ele = lo_SquishSubDocToCell(context, state, subdoc, TRUE); table->caption->subdoc = NULL; if (cell_ele != NULL) { lo_FreeElement(context, (LO_Element *)cell_ele, TRUE); } } } row_max = table->height_spans; for (y=0; y < table->rows; y++) { cell_x = state->x; col_max = table->width_spans; for (x=0; x < table->cols; x++) { LO_CellStruct *cell_struct; int32 new_x, new_y; indx = (y * table->cols) + x; cell_ptr = cell_array[indx].cell; if ((cell_ptr == &blank_cell)||(cell_ptr == NULL)) { cell_x = cell_x + col_max->dim + cell_pad; col_max = col_max->next; continue; } cell_struct = cell_ptr->cell; /* cell_struct->x = cell_x; cell_struct->y = cell_y; cell_struct->x_offset = (int16)cell_struct->border_horiz_space; cell_struct->y_offset = (int32)cell_struct->border_vert_space; */ new_x = cell_x + (int16)cell_struct->border_horiz_space + cell_struct->border_width; new_y = cell_y + (int32)cell_struct->border_vert_space + cell_struct->border_width; cell_struct->width = col_max->dim; if (cell_ptr->colspan > 1) { int32 i; lo_table_span *max_ptr; max_ptr = col_max; for (i=1; i < cell_ptr->colspan; i++) { max_ptr = max_ptr->next; cell_struct->width = cell_struct->width + cell_pad + max_ptr->dim; } } cell_struct->width = cell_struct->width - (2 * cell_struct->border_horiz_space); cell_struct->height = row_max->dim; if (cell_ptr->rowspan > 1) { int32 i; lo_table_span *max_ptr; max_ptr = row_max; for (i=1; i < cell_ptr->rowspan; i++) { max_ptr = max_ptr->next; cell_struct->height = cell_struct->height + cell_pad + max_ptr->dim; } } cell_struct->height = cell_struct->height - (2 * cell_struct->border_vert_space); lo_ShiftCell(cell_struct, cell_ptr->cell_base_x, cell_ptr->cell_base_y); cell_ptr->cell_base_x = 0; cell_ptr->cell_base_y = 0; ele_cnt = lo_align_cell(context, state, cell_ptr, cell_struct, table, row_max); /* if (ele_cnt > 0) */ { LO_CellStruct *cell_ele; int32 shift_x, shift_y; shift_x = new_x - cell_struct->x - cell_struct->x_offset - cell_struct->border_width; shift_y = new_y - cell_struct->y - cell_struct->y_offset - cell_struct->border_width; cell_struct->x = cell_x; cell_struct->y = cell_y; cell_struct->x_offset = (int16)cell_struct->border_horiz_space; cell_struct->y_offset = (int32)cell_struct->border_vert_space; cell_ele = cell_struct; /* lo_ShiftCell(cell_ele, shift_x, shift_y); */ lo_ShiftCell(cell_ele, new_x, new_y); /* * Keep element ids sequential. */ if (cell_ele != NULL) { cell_ele->ele_id = NEXT_ELEMENT; lo_RenumberCell(state, cell_ele); } if (cell_ele == NULL) { lo_AppendToLineList(context, state, (LO_Element *)cell_struct, 0); } else { /*cmanske - Save spacing param for drawing cell selection by FEs */ cell_ele->inter_cell_space = table->inter_cell_pad; lo_AppendToLineList(context, state, (LO_Element *)cell_ele, 0); } if ( relayout == FALSE ) { /* * Cell backgrounds now sit in their own layer. This is needed * for selection to work correctly. * Cell backgrounds can exist in the main _BODY layer, * so we need to special case the parent layer of the * cell background, */ if (context->compositor && (cell_ele->backdrop.bg_color || cell_ele->backdrop.url)) { lo_TopState *top_state = state->top_state; CL_Layer *parent_layer = lo_CurrentLayer(state); if (parent_layer == top_state->doc_layer) parent_layer = top_state->body_layer; cell_ele->cell_bg_layer = lo_CreateCellBackgroundLayer(context, cell_ele, parent_layer, top_state->table_nesting_level); } else { cell_ele->cell_bg_layer = NULL; } } } /* else { */ /* LO_CellStruct *cell_ele; */ /* * Free up the useless cell */ /* cell_ele = cell_struct; if (cell_ele != NULL) { lo_FreeElement(context, (LO_Element *)cell_ele, TRUE); } } */ cell_x = cell_x + col_max->dim + cell_pad; col_max = col_max->next; } cell_y = cell_y + row_max->dim + cell_pad; row_max = row_max->next; } cell_x = cell_x + table->table_ele->border_left_width; cell_y = cell_y + table->table_ele->border_top_width; if (table->draw_borders == TABLE_BORDERS_OFF) { cell_x += table_pad; cell_y += table_pad; } if ((table->caption != NULL)&& (table->caption->vert_alignment != LO_ALIGN_TOP)) { LO_SubDocStruct *subdoc; subdoc = table->caption->subdoc; subdoc->x = state->x; subdoc->y = cell_y; subdoc->x_offset = (int16)subdoc->border_horiz_space; subdoc->y_offset = (int32)subdoc->border_vert_space; subdoc->width = table->caption->max_width - (2 * subdoc->border_horiz_space); subdoc->height = table->caption->height - (2 * subdoc->border_vert_space); ele_cnt = lo_align_subdoc(context, state, (lo_DocState *)subdoc->state, subdoc, table, NULL); if (ele_cnt > 0) { LO_CellStruct *cell_ele; if (relayout == FALSE) { /* cell_ele = lo_SquishSubDocToCell(context, state, subdoc, TRUE); */ cell_ele = lo_SquishSubDocToCell(context, state, subdoc, FALSE); cell_ele->isCaption = TRUE; table->caption->cell_ele = cell_ele; } else { cell_ele = table->caption->cell_ele; lo_UpdateCaptionCellFromSubDoc(context, state, subdoc, cell_ele); } /* table->caption->subdoc = NULL; */ if (cell_ele == NULL) { lo_AppendToLineList(context, state, (LO_Element *)subdoc, 0); } else { /*cmanske - Save spacing param for drawing cell selection by FEs */ cell_ele->inter_cell_space = table->inter_cell_pad; lo_AppendToLineList(context, state, (LO_Element *)cell_ele, 0); } cell_y = cell_y + table->caption->height + cell_pad; } else { LO_CellStruct *cell_ele; /* * Free up the useless subdoc */ cell_ele = lo_SquishSubDocToCell(context, state, subdoc, TRUE); table->caption->subdoc = NULL; if (cell_ele != NULL) { lo_FreeElement(context, (LO_Element *)cell_ele, TRUE); } } } /* * This table may have contained named anchors. * This will correct their positions in the name_list, * and unblock us if we were blocked on them. */ lo_CheckNameList(context, state, table->table_ele->ele_id); /* * The usual stuff for a table. */ if (floating == FALSE) { lo_AlignStack *aptr; int32 indent; state->x = cell_x; state->baseline = 0; state->line_height = cell_y - state->y; state->linefeed_state = 0; state->at_begin_line = FALSE; state->trailing_space = FALSE; state->cur_ele_type = LO_SUBDOC; table->table_ele->line_height = state->line_height; /* * Find how far the table might be indented from * being inside a list. */ indent = state->list_stack->old_left_margin - state->win_left; if (indent < 0) { indent = 0; } save_doc_min_width = state->min_width; if (relayout == FALSE) { lo_SoftLineBreak(context, state, FALSE); } else { lo_rl_AddBreakAndFlushLine( context, state, LO_LINEFEED_BREAK_SOFT, LO_CLEAR_NONE, FALSE ); } if ((min_table_width + indent) > save_doc_min_width) { save_doc_min_width = min_table_width + indent; } state->min_width = save_doc_min_width; /* * Pop the table's alignment. */ aptr = lo_PopAlignment(state); if (aptr != NULL) { XP_DELETE(aptr); } } /* * Else this is a floating table, rip it out of the "faked" * line list, stuff itin the margin, and restore our state * to where we left off. */ else { int32 push_right; int32 line_height; LO_Element *tptr; LO_Element *last; line_height = cell_y - state->y; push_right = 0; if (table->table_ele->alignment == LO_ALIGN_RIGHT) { push_right = state->right_margin - cell_x; } table->table_ele->x_offset += (int16)table->table_ele->border_horiz_space; table->table_ele->y_offset += (int32)table->table_ele->border_vert_space; last = NULL; tptr = state->line_list; while (tptr != NULL) { tptr->lo_any.x += push_right; if (tptr->type == LO_CELL) { tptr->lo_any.x += table->table_ele->border_horiz_space; tptr->lo_any.y += table->table_ele->border_vert_space; lo_ShiftCell((LO_CellStruct *)tptr, (push_right + table->table_ele->border_horiz_space), table->table_ele->border_vert_space); } last = tptr; tptr->lo_any.line_height = line_height; tptr = tptr->lo_any.next; } /* * Stuff the whole line list into the float list, and * restore the line list to its pre-table state. */ if (state->line_list != NULL) { last->lo_any.next = state->float_list; state->float_list = state->line_list; state->line_list = NULL; } if (relayout == FALSE) { lo_AppendFloatInLineList(state, (LO_Element *)table->table_ele, save_line_list ); } else { state->line_list = save_line_list; } table->table_ele->line_height = line_height; table->table_ele->expected_y = table->table_ele->y; table->table_ele->y = -1; lo_AddMarginStack(state, table->table_ele->x, table->table_ele->y, table->table_ele->width, table->table_ele->line_height, table->table_ele->border_left_width + table->table_ele->border_right_width, table->table_ele->border_vert_space, table->table_ele->border_horiz_space, (intn)table->table_ele->alignment); /* * Restore state to pre-table values. */ state->x = save_state_x; state->y = save_state_y; /* * All the doc_min_width stuff makes state->min_width * be correct for tables nested inside tables. */ save_doc_min_width = state->min_width; /* * Standard float stuff, if we happen to be at the start * of a line, place the table now. */ if (state->at_begin_line != FALSE) { lo_FindLineMargins(context, state, (! relayout)); state->x = state->left_margin; } if (min_table_width > save_doc_min_width) { save_doc_min_width = min_table_width; } state->min_width = save_doc_min_width; } /* Decrement table nesting level (used for passing into lo_CreateCellBackGroundLayer() */ if (!relayout) { state->top_state->table_nesting_level--; } #ifdef XP_WIN16 _hfree(cell_array); #else XP_UNLOCK_BLOCK(cell_array_buff); XP_FREE_BLOCK(cell_array_buff); #endif } /* * Functions separated out of lo_BeginTableAttributes */ void lo_PositionTableElement(lo_DocState *state, LO_TableStruct *table_ele) { table_ele->ele_id = NEXT_ELEMENT; table_ele->x = state->x; table_ele->x_offset = 0; table_ele->y = state->y; table_ele->y_offset = 0; table_ele->width = 0; table_ele->height = 0; table_ele->line_height = 0; table_ele->next = NULL; table_ele->prev = NULL; /* * Push our alignment state if we're not floating */ if ( !(table_ele->ele_attrmask & LO_ELE_FLOATING) ) { lo_PushAlignment(state, P_TABLE_DATA, table_ele->alignment); } } void lo_InitTableRecord( lo_TableRec *table ) { /* Reset row and col counters */ table->rows = 0; table->cols = 0; /* Reset width span array */ lo_ResetWidthSpans(table); table->height_span_ptr = NULL; } static void lo_ResetWidthSpans( lo_TableRec *table ) { lo_table_span *span = table->width_spans; while (span != NULL) { span->dim = 1; span->min_dim = 1; span->span = 0; span = span->next; } } void lo_SetTableDimensions( lo_DocState *state, lo_TableRec *table, int32 allow_percent_width, int32 allow_percent_height) { int32 val; if (table->percent_width > 0) { val = table->percent_width; if (allow_percent_width == FALSE) { val = 0; } else { val = (state->win_width - state->win_left - state->win_right) * val / 100; } if (val < 0) { val = 0; } table->width = val; } if (table->percent_height > 0) { val = table->percent_height; if (allow_percent_height == FALSE) { val = 0; } else { val = (state->win_height - state->win_top - state->win_bottom) * val / 100; } if (val < 0) { val = 0; } table->height = val; } } void lo_CalcFixedColWidths( MWContext *context, lo_DocState *state, lo_TableRec *table) { int32 cols = table->fixed_cols; if (cols > 0) { int32 count; int32 table_width; table_width = lo_ComputeInternalTableWidth ( context, table, state ); /* Split the space up evenly */ table->default_cell_width = table_width / cols; /* and we have all the table width left to play with */ table->fixed_width_remaining = table_width; /* Initialize our width array */ for ( count = 0; count < cols; ++count ) { table->fixed_col_widths[ count ] = 0; } } } void lo_UpdateStateAfterBeginTable( lo_DocState *state, lo_TableRec *table) { state->current_table = table; } /* Relayout version of lo_BeginTableRowAttributes() */ void lo_UpdateTableStateForBeginRow(lo_TableRec *table, lo_TableRow *table_row) { table_row->row_done = FALSE; table_row->cells = 0; table_row->cell_list = NULL; table_row->cell_ptr = NULL; /* table_row->next = NULL; if (table->row_list == NULL) { table->row_list = table_row; table->row_ptr = table_row; } else { table->row_ptr->next = table_row; table->row_ptr = table_row; } */ table->width_span_ptr = NULL; } /* * Functions for breaking up lo_BeginTableCellAttributes() */ void lo_InitForBeginCell(lo_TableRow *table_row, lo_TableCell *table_cell) { table_cell->must_relayout = FALSE; table_cell->cell_done = FALSE; if (table_row->cell_list == NULL) { table_row->cell_list = table_cell; table_row->cell_ptr = table_cell; } else { table_row->cell_ptr->next = table_cell; table_row->cell_ptr = table_cell; } } void lo_InitSubDocForBeginCell( MWContext *context, lo_DocState *state, lo_TableRec *table ) { lo_TableCell *table_cell = table->row_ptr->cell_ptr; lo_BeginCellSubDoc(context, state, table, NULL, NULL, LO_TILE_BOTH, NULL, NULL, NULL, NULL, table_cell->is_a_header, table->draw_borders, TRUE); /* * We added a new state. */ lo_PushStateLevel ( context ); } static void lo_UpdateCaptionCellFromSubDoc( MWContext *context, lo_DocState *state, LO_SubDocStruct *subdoc, LO_CellStruct *cell_ele) { int32 dx = 0; int32 dy = 0; lo_CreateCellFromSubDoc(context, state, subdoc, cell_ele, &dx, &dy); lo_ShiftCell(cell_ele, dx, dy); lo_RenumberCell(state, cell_ele); } /* Only deletes the cell itself. Assumes that stuff the cell points to will get deleted elsewhere */ static void lo_FreeCaptionCell( MWContext *context, lo_DocState *state, LO_CellStruct *cell_ele) { cell_ele->next = NULL; cell_ele->prev = NULL; cell_ele->cell_list = NULL; cell_ele->cell_list_end = NULL; cell_ele->cell_float_list = NULL; cell_ele->table_cell = NULL; cell_ele->table_row = NULL; cell_ele->table = NULL; lo_FreeElement(context, (LO_Element *)cell_ele, TRUE); } /* Delete the lo_TableRec data structure associated with the LO_TABLE element. Does not free the LO_TABLE element itself. */ void lo_ScrapeTableElement( MWContext *context, LO_TableStruct *table_ele ) { lo_TableRec *table = (lo_TableRec *) table_ele->table; lo_TopState *top_state = lo_FetchTopState(XP_DOCID(context)); lo_DocState *state = top_state->doc_state; if (table != NULL) { /* Free the table row list */ if (table->row_list != NULL) { lo_TableRow *row_ptr; lo_TableRow *row; row_ptr = table->row_list; while (row_ptr != NULL) { row = row_ptr; row_ptr = row_ptr->next; /* The lo_TableCell structures will get freed when their peer LO_CELL elements get recycled, so just null out the pointers to those structures. */ row->cell_list = NULL; row->cell_ptr = NULL; XP_FREEIF(row->backdrop.bg_color); XP_FREEIF(row->backdrop.url); XP_DELETE(row); } table->row_list = NULL; table->row_ptr = NULL; } /* Clean up the line array pointers to the elements contained inside the caption cell. Otherwise, the freeing of the caption frees those elements and a double free crash occurs when those elements are freed by their peer LO_CELL element */ if (table->caption && table->caption->subdoc && table->caption->subdoc->state) lo_cleanup_old_state( table->caption->subdoc->state ); lo_FreeAllExceptRows( context, state, table ); } } static void lo_FreeAllExceptRows( MWContext *context, lo_DocState *state, lo_TableRec *table ) { /* Free backdrop info */ XP_FREEIF(table->backdrop.bg_color); XP_FREEIF(table->backdrop.url); /* Free width and height span arrays */ lo_FreeTableSpanArray(table->width_spans); table->width_spans = NULL; table->width_span_ptr = NULL; lo_FreeTableSpanArray(table->height_spans); table->height_spans = NULL; table->height_span_ptr = NULL; /* Free caption information. */ if (table->caption != NULL) { /* The LO_CELL element associated with the caption will get freed when it gets recycled in the line list. So, just null out the pointer to it. */ table->caption->cell_ele = NULL; if ( table->caption->subdoc != NULL ) { lo_FreePartialSubDoc ( context, state, table->caption->subdoc ); table->caption->subdoc = NULL; } XP_DELETE(table->caption); table->caption = NULL; } /* Free the subdoc state */ if (table->current_subdoc != NULL) { lo_FreePartialSubDoc(context, state, table->current_subdoc); table->current_subdoc = NULL; } if ( table->fixed_col_widths != NULL ) { XP_FREE(table->fixed_col_widths); } /* Reset back pointer in table layout element */ if (table->table_ele != NULL) { table->table_ele->table = NULL; } XP_DELETE(table); } static void lo_FreeTableSpanArray( lo_table_span *spanArray ) { if (spanArray != NULL) { lo_table_span *span_ptr; lo_table_span *span; span_ptr = spanArray; while (span_ptr != NULL) { span = span_ptr; span_ptr = span_ptr->next; XP_DELETE(span); } } } #ifdef TEST_16BIT #undef XP_WIN16 #endif /* TEST_16BIT */