ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/riched20/table.c

579 lines
19 KiB
C
Raw Blame History

/*
* RichEdit functions dealing with on tables
*
* Copyright 2008 by Dylan Smith
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
/*
* The implementation of tables differs greatly between version 3.0
* (in riched20.dll) and version 4.1 (in msftedit.dll) of richedit controls.
* Currently Wine is not distinguishing between version 3.0 and version 4.1,
* so v4.1 is assumed unless v1.0 is being emulated (i.e. riched32.dll is used).
* If this lack of distinction causes a bug in a Windows application, then Wine
* will need to start making this distinction.
*
* Richedit version 1.0 - 3.0:
* Tables are implemented in these versions using tabs at the end of cells,
* and tab stops to position the cells. The paragraph format flag PFE_TABLE
* will indicate that the paragraph is a table row. Note that in this
* implementation there is one paragraph per table row.
*
* Richedit version 4.1:
* Tables are implemented such that cells can contain multiple paragraphs,
* each with its own paragraph format, and cells may even contain tables
* nested within the cell.
*
* There is also a paragraph at the start of each table row that contains
* the rows paragraph format (e.g. to change the row alignment to row), and a
* paragraph at the end of the table row with the PFE_TABLEROWDELIMITER flag
* set. The paragraphs at the start and end of the table row should always be
* empty, but should have a length of 2.
*
* Wine implements this using display items (ME_DisplayItem) with a type of
* diCell. These cell display items store the cell properties, and are
* inserted into the editors linked list before each cell, and at the end of
* the last cell. The cell display item for a cell comes before the paragraphs
* for the cell, but the last cell display item refers to no cell, so it is
* just a delimiter.
*/
#include "editor.h"
#include "rtf.h"
static const WCHAR cr_lf[] = {'\r', '\n', 0};
static ME_Paragraph* table_insert_end_para( ME_TextEditor *editor, ME_Cursor *cursor,
const WCHAR *eol_str, int eol_len, int para_flags )
{
ME_Style *style = style_get_insert_style( editor, cursor );
ME_Paragraph *para;
if (cursor->nOffset) run_split( editor, cursor );
para = para_split( editor, &cursor->pRun->member.run, style, eol_str, eol_len, para_flags );
ME_ReleaseStyle( style );
cursor->pPara = para_get_di( para );
cursor->pRun = run_get_di( para_first_run( para ) );
return para;
}
ME_Paragraph* table_insert_row_start( ME_TextEditor *editor, ME_Cursor *cursor )
{
ME_Paragraph *para;
para = table_insert_end_para( editor, cursor, cr_lf, 2, MEPF_ROWSTART );
return para_prev( para );
}
ME_Paragraph* table_insert_row_start_at_para( ME_TextEditor *editor, ME_Paragraph *para )
{
ME_Paragraph *prev_para, *end_para, *start_row;
ME_Cursor cursor;
cursor.pPara = para_get_di( para );
cursor.pRun = run_get_di( para_first_run( para ) );
cursor.nOffset = 0;
start_row = table_insert_row_start( editor, &cursor );
end_para = para_next( &editor->pCursors[0].pPara->member.para );
prev_para = para_next( start_row );
para = para_next( prev_para );
while (para != end_para)
{
para->pCell = prev_para->pCell;
para->nFlags |= MEPF_CELL;
para->nFlags &= ~(MEPF_ROWSTART | MEPF_ROWEND);
para->fmt.dwMask |= PFM_TABLE | PFM_TABLEROWDELIMITER;
para->fmt.wEffects |= PFE_TABLE;
para->fmt.wEffects &= ~PFE_TABLEROWDELIMITER;
prev_para = para;
para = para_next( para );
}
return start_row;
}
/* Inserts a diCell and starts a new paragraph for the next cell.
*
* Returns the first paragraph of the new cell. */
ME_Paragraph* table_insert_cell( ME_TextEditor *editor, ME_Cursor *cursor )
{
WCHAR tab = '\t';
return table_insert_end_para( editor, editor->pCursors, &tab, 1, MEPF_CELL );
}
ME_Paragraph* table_insert_row_end( ME_TextEditor *editor, ME_Cursor *cursor )
{
ME_Paragraph *para;
para = table_insert_end_para( editor, cursor, cr_lf, 2, MEPF_ROWEND );
return para_prev( para );
}
ME_Paragraph* table_row_end( ME_Paragraph *para )
{
ME_DisplayItem *cell;
assert( para );
if (para->nFlags & MEPF_ROWEND) return para;
if (para->nFlags & MEPF_ROWSTART) para = para_next( para );
cell = para->pCell;
assert(cell && cell->type == diCell);
while (cell->member.cell.next_cell)
cell = cell->member.cell.next_cell;
para = &ME_FindItemFwd( cell, diParagraph )->member.para;
assert( para && para->nFlags & MEPF_ROWEND );
return para;
}
ME_Paragraph* table_row_start( ME_Paragraph *para )
{
ME_DisplayItem *cell;
assert( para );
if (para->nFlags & MEPF_ROWSTART) return para;
if (para->nFlags & MEPF_ROWEND) para = para_prev( para );
cell = para->pCell;
assert(cell && cell->type == diCell);
while (cell->member.cell.prev_cell)
cell = cell->member.cell.prev_cell;
para = &ME_FindItemBack( cell, diParagraph )->member.para;
assert( para && para->nFlags & MEPF_ROWSTART );
return para;
}
ME_Paragraph* table_outer_para( ME_Paragraph *para )
{
if (para->nFlags & MEPF_ROWEND) para = para_prev( para );
while (para->pCell)
{
para = table_row_start( para );
if (!para->pCell) break;
para = &ME_FindItemBack( para->pCell, diParagraph )->member.para;
}
return para;
}
ME_Cell *table_row_first_cell( ME_Paragraph *para )
{
if (!para_in_table( para )) return NULL;
para = para_next( table_row_start( para ) );
return para_cell( para );
}
ME_Cell *table_row_end_cell( ME_Paragraph *para )
{
if (!para_in_table( para )) return NULL;
para = para_prev( table_row_end( para ));
return cell_next( para_cell( para ) );
}
ME_Cell *cell_next( ME_Cell *cell )
{
if (!cell->next_cell) return NULL;
return &cell->next_cell->member.cell;
}
ME_Cell *cell_prev( ME_Cell *cell )
{
if (!cell->prev_cell) return NULL;
return &cell->prev_cell->member.cell;
}
ME_Paragraph *cell_first_para( ME_Cell *cell )
{
return &ME_FindItemFwd( cell_get_di( cell ), diParagraph )->member.para;
}
ME_Paragraph *cell_end_para( ME_Cell *cell )
{
ME_Cell *next = cell_next( cell );
if (!next) return cell_first_para( cell ); /* End of row */
return &ME_FindItemBack( cell_get_di( next ), diParagraph )->member.para;
}
BOOL ME_IsInTable(ME_DisplayItem *pItem)
{
PARAFORMAT2 *pFmt;
if (!pItem)
return FALSE;
if (pItem->type == diRun)
pItem = ME_GetParagraph(pItem);
if (pItem->type != diParagraph)
return FALSE;
pFmt = &pItem->member.para.fmt;
return pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE;
}
/* Table rows should either be deleted completely or not at all. */
void table_protect_partial_deletion( ME_TextEditor *editor, ME_Cursor *c, int *num_chars )
{
int start_ofs = ME_GetCursorOfs( c );
ME_Cursor c2 = *c;
ME_Paragraph *this_para = &c->pPara->member.para, *end_para;
ME_MoveCursorChars( editor, &c2, *num_chars, FALSE );
end_para = &c2.pPara->member.para;
if (c2.pRun->member.run.nFlags & MERF_ENDPARA)
{
/* End offset might be in the middle of the end paragraph run.
* If this is the case, then we need to use the next paragraph as the last
* paragraphs.
*/
int remaining = start_ofs + *num_chars - c2.pRun->member.run.nCharOfs - end_para->nCharOfs;
if (remaining)
{
assert( remaining < c2.pRun->member.run.len );
end_para = para_next( end_para );
}
}
if (!editor->bEmulateVersion10) /* v4.1 */
{
if (para_cell( this_para ) != para_cell( end_para ) ||
((this_para->nFlags | end_para->nFlags) & (MEPF_ROWSTART | MEPF_ROWEND)))
{
while (this_para != end_para)
{
ME_Paragraph *next_para = para_next( this_para );
BOOL truancate_del = FALSE;
if (this_para->nFlags & MEPF_ROWSTART)
{
/* The following while loop assumes that next_para is MEPF_ROWSTART,
* so moving back one paragraph lets it be processed as the start
* of the row. */
next_para = this_para;
this_para = para_prev( this_para );
}
else if (para_cell( next_para) != para_cell( this_para ) || this_para->nFlags & MEPF_ROWEND)
{
/* Start of the deletion from after the start of the table row. */
truancate_del = TRUE;
}
while (!truancate_del && next_para->nFlags & MEPF_ROWSTART)
{
next_para = para_next( table_row_end( next_para ) );
if (next_para->nCharOfs > start_ofs + *num_chars)
{
/* End of deletion is not past the end of the table row. */
next_para = para_next( this_para );
/* Delete the end paragraph preceding the table row if the
* preceding table row will be empty. */
if (this_para->nCharOfs >= start_ofs) next_para = para_next( next_para );
truancate_del = TRUE;
}
else this_para = para_prev( next_para );
}
if (truancate_del)
{
ME_Run *end_run = para_end_run( para_prev( next_para ) );
int new_chars = next_para->nCharOfs - start_ofs - end_run->len;
new_chars = max( new_chars, 0 );
assert( new_chars <= *num_chars);
*num_chars = new_chars;
break;
}
this_para = next_para;
}
}
}
else /* v1.0 - 3.0 */
{
ME_Run *run;
int chars_to_boundary;
if ((this_para->nCharOfs != start_ofs || this_para == end_para) && para_in_table( this_para ))
{
run = &c->pRun->member.run;
/* Find the next tab or end paragraph to use as a delete boundary */
while (!(run->nFlags & (MERF_TAB | MERF_ENDPARA)))
run = run_next( run );
chars_to_boundary = run->nCharOfs - c->pRun->member.run.nCharOfs - c->nOffset;
*num_chars = min( *num_chars, chars_to_boundary );
}
else if (para_in_table( end_para ))
{
/* The deletion starts from before the row, so don't join it with
* previous non-empty paragraphs. */
ME_Paragraph *cur_para;
run = NULL;
if (start_ofs > this_para->nCharOfs)
{
cur_para = para_prev( end_para );
run = para_end_run( cur_para );
}
if (!run)
{
cur_para = end_para;
run = para_first_run( end_para );
}
if (run)
{
chars_to_boundary = cur_para->nCharOfs + run->nCharOfs - start_ofs;
if (chars_to_boundary >= 0) *num_chars = min( *num_chars, chars_to_boundary );
}
}
if (*num_chars < 0) *num_chars = 0;
}
}
ME_Paragraph* table_append_row( ME_TextEditor *editor, ME_Paragraph *table_row )
{
WCHAR endl = '\r', tab = '\t';
ME_Run *run;
int i;
if (!editor->bEmulateVersion10) /* v4.1 */
{
ME_Cell *new_cell, *cell;
ME_Paragraph *para, *prev_table_end, *new_row_start;
cell = table_row_first_cell( table_row );
prev_table_end = table_row_end( table_row );
para = para_next( prev_table_end );
run = para_first_run( para );
editor->pCursors[0].pPara = para_get_di( para );
editor->pCursors[0].pRun = run_get_di( run );
editor->pCursors[0].nOffset = 0;
editor->pCursors[1] = editor->pCursors[0];
new_row_start = table_insert_row_start( editor, editor->pCursors );
new_cell = table_row_first_cell( new_row_start );
/* Copy cell properties */
new_cell->nRightBoundary = cell->nRightBoundary;
new_cell->border = cell->border;
while (cell_next( cell ))
{
cell = cell_next( cell );
para = table_insert_cell( editor, editor->pCursors );
new_cell = para_cell( para );
/* Copy cell properties */
new_cell->nRightBoundary = cell->nRightBoundary;
new_cell->border = cell->border;
};
para = table_insert_row_end( editor, editor->pCursors );
para->fmt = prev_table_end->fmt;
/* return the table row start for the inserted paragraph */
return new_row_start;
}
else /* v1.0 - 3.0 */
{
run = para_end_run( table_row );
assert( para_in_table( table_row ) );
editor->pCursors[0].pPara = para_get_di( table_row );
editor->pCursors[0].pRun = run_get_di( run );
editor->pCursors[0].nOffset = 0;
editor->pCursors[1] = editor->pCursors[0];
ME_InsertTextFromCursor( editor, 0, &endl, 1, run->style );
run = &editor->pCursors[0].pRun->member.run;
for (i = 0; i < table_row->fmt.cTabCount; i++)
ME_InsertTextFromCursor( editor, 0, &tab, 1, run->style );
return para_next( table_row );
}
}
/* Selects the next table cell or appends a new table row if at end of table */
static void table_select_next_cell_or_append( ME_TextEditor *editor, ME_Run *run )
{
ME_Paragraph *para = run->para;
ME_Cell *cell;
int i;
assert( para_in_table( para ) );
if (!editor->bEmulateVersion10) /* v4.1 */
{
/* Get the initial cell */
if (para->nFlags & MEPF_ROWSTART) cell = para_cell( para_next( para ) );
else if (para->nFlags & MEPF_ROWEND) cell = para_cell( para_prev( para ) );
else cell = para_cell( para );
/* Get the next cell. */
if (cell_next( cell ) && cell_next( cell_next( cell ) ))
cell = cell_next( cell );
else
{
para = para_next( table_row_end( para ) );
if (para->nFlags & MEPF_ROWSTART) cell = para_cell( para_next( para ) );
else
{
/* Insert row */
para = para_prev( para );
para = table_append_row( editor, table_row_start( para ) );
/* Put cursor at the start of the new table row */
para = para_next( para );
editor->pCursors[0].pPara = para_get_di( para );
editor->pCursors[0].pRun = run_get_di( para_first_run( para ) );
editor->pCursors[0].nOffset = 0;
editor->pCursors[1] = editor->pCursors[0];
ME_WrapMarkedParagraphs(editor);
return;
}
}
/* Select cell */
editor->pCursors[1].pPara = para_get_di( cell_first_para( cell ) );
editor->pCursors[1].pRun = run_get_di( para_first_run( &editor->pCursors[1].pPara->member.para ) );
editor->pCursors[1].nOffset = 0;
editor->pCursors[0].pPara = para_get_di( cell_end_para( cell ) );
editor->pCursors[0].pRun = run_get_di( para_end_run( &editor->pCursors[0].pPara->member.para ) );
editor->pCursors[0].nOffset = 0;
}
else /* v1.0 - 3.0 */
{
if (run->nFlags & MERF_ENDPARA && para_in_table( para_next( para ) ))
{
run = run_next_all_paras( run );
assert(run);
}
for (i = 0; i < 2; i++)
{
while (!(run->nFlags & MERF_TAB))
{
if (!run_next( run ))
{
para = para_next( run->para );
if (para_in_table( para ))
{
run = para_first_run( para );
editor->pCursors[0].pPara = para_get_di( para );
editor->pCursors[0].pRun = run_get_di( run );
editor->pCursors[0].nOffset = 0;
i = 1;
}
else
{
/* Insert table row */
para = table_append_row( editor, para_prev( para ) );
/* Put cursor at the start of the new table row */
editor->pCursors[0].pPara = para_get_di( para );
editor->pCursors[0].pRun = run_get_di( para_first_run( para ) );
editor->pCursors[0].nOffset = 0;
editor->pCursors[1] = editor->pCursors[0];
ME_WrapMarkedParagraphs(editor);
return;
}
}
else run = run_next( run );
}
if (i == 0) run = run_next_all_paras( run );
editor->pCursors[i].pRun = run_get_di( run );
editor->pCursors[i].pPara = para_get_di( run->para );
editor->pCursors[i].nOffset = 0;
}
}
}
void table_handle_tab( ME_TextEditor *editor, BOOL selected_row )
{
/* FIXME: Shift tab should move to the previous cell. */
ME_Cursor fromCursor, toCursor;
ME_InvalidateSelection(editor);
{
int from, to;
from = ME_GetCursorOfs(&editor->pCursors[0]);
to = ME_GetCursorOfs(&editor->pCursors[1]);
if (from <= to)
{
fromCursor = editor->pCursors[0];
toCursor = editor->pCursors[1];
}
else
{
fromCursor = editor->pCursors[1];
toCursor = editor->pCursors[0];
}
}
if (!editor->bEmulateVersion10) /* v4.1 */
{
if (!ME_IsInTable(toCursor.pRun))
{
editor->pCursors[0] = toCursor;
editor->pCursors[1] = toCursor;
}
else table_select_next_cell_or_append( editor, &toCursor.pRun->member.run );
}
else /* v1.0 - 3.0 */
{
if (!ME_IsInTable(fromCursor.pRun))
{
editor->pCursors[0] = fromCursor;
editor->pCursors[1] = fromCursor;
/* FIXME: For some reason the caret is shown at the start of the
* previous paragraph in v1.0 to v3.0 */
}
else if ((selected_row || !para_in_table( &toCursor.pPara->member.para )))
table_select_next_cell_or_append( editor, &fromCursor.pRun->member.run );
else
{
ME_Run *run = run_prev( &toCursor.pRun->member.run );
if (ME_IsSelection(editor) && !toCursor.nOffset && run && run->nFlags & MERF_TAB)
table_select_next_cell_or_append( editor, run );
else
table_select_next_cell_or_append( editor, &toCursor.pRun->member.run );
}
}
ME_InvalidateSelection(editor);
ME_Repaint(editor);
update_caret(editor);
ME_SendSelChange(editor);
}
/* Make sure the cursor is not in the hidden table row start paragraph
* without a selection. */
void table_move_from_row_start( ME_TextEditor *editor )
{
ME_Paragraph *para = &editor->pCursors[0].pPara->member.para;
if (para == &editor->pCursors[1].pPara->member.para && para->nFlags & MEPF_ROWSTART)
{
/* The cursors should not be at the hidden start row paragraph without
* a selection, so the cursor is moved into the first cell. */
para = para_next( para );
editor->pCursors[0].pPara = para_get_di( para );
editor->pCursors[0].pRun = run_get_di( para_first_run( para ) );
editor->pCursors[0].nOffset = 0;
editor->pCursors[1] = editor->pCursors[0];
}
}
struct RTFTable *ME_MakeTableDef(ME_TextEditor *editor)
{
RTFTable *tableDef = heap_alloc_zero(sizeof(*tableDef));
if (!editor->bEmulateVersion10) /* v4.1 */
tableDef->gapH = 10;
return tableDef;
}
void ME_InitTableDef(ME_TextEditor *editor, struct RTFTable *tableDef)
{
ZeroMemory(tableDef->cells, sizeof(tableDef->cells));
ZeroMemory(tableDef->border, sizeof(tableDef->border));
tableDef->numCellsDefined = 0;
tableDef->leftEdge = 0;
if (!editor->bEmulateVersion10) /* v4.1 */
tableDef->gapH = 10;
else /* v1.0 - 3.0 */
tableDef->gapH = 0;
}
Reference in New Issue View Git Blame Copy Permalink