2 * RichEdit functions dealing with on tables
4 * Copyright 2008 by Dylan Smith
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 * The implementation of tables differs greatly between version 3.0
23 * (in riched20.dll) and version 4.1 (in msftedit.dll) of richedit controls.
24 * Currently Wine is not distinguishing between version 3.0 and version 4.1,
25 * so v4.1 is assumed unless v1.0 is being emulated (i.e. riched32.dll is used).
26 * If this lack of distinction causes a bug in a Windows application, then Wine
27 * will need to start making this distinction.
29 * Richedit version 1.0 - 3.0:
30 * Tables are implemented in these versions using tabs at the end of cells,
31 * and tab stops to position the cells. The paragraph format flag PFE_TABLE
32 * will indicate that the paragraph is a table row. Note that in this
33 * implementation there is one paragraph per table row.
35 * Richedit version 4.1:
36 * Tables are implemented such that cells can contain multiple paragraphs,
37 * each with it's own paragraph format, and cells may even contain tables
38 * nested within the cell.
40 * There is also a paragraph at the start of each table row that contains
41 * the rows paragraph format (e.g. to change the row alignment to row), and a
42 * paragraph at the end of the table row with the PFE_TABLEROWDELIMITER flag
43 * set. The paragraphs at the start and end of the table row should always be
44 * empty, but should have a length of 2.
46 * Wine implements this using display items (ME_DisplayItem) with a type of
47 * diCell. These cell display items store the cell properties, and are
48 * inserted into the editors linked list before each cell, and at the end of
49 * the last cell. The cell display item for a cell comes before the paragraphs
50 * for the cell, but the last cell display item refers to no cell, so it is
57 WINE_DEFAULT_DEBUG_CHANNEL(richedit
);
58 WINE_DECLARE_DEBUG_CHANNEL(richedit_lists
);
60 static ME_DisplayItem
* ME_InsertEndParaFromCursor(ME_TextEditor
*editor
,
66 ME_Style
*pStyle
= ME_GetInsertStyle(editor
, nCursor
);
68 ME_Cursor
* cursor
= &editor
->pCursors
[nCursor
];
69 if (cursor
->nOffset
) {
70 ME_SplitRunSimple(editor
, cursor
->pRun
, cursor
->nOffset
);
71 cursor
= &editor
->pCursors
[nCursor
];
74 tp
= ME_SplitParagraph(editor
, cursor
->pRun
, pStyle
, numCR
, numLF
, paraFlags
);
75 cursor
->pRun
= ME_FindItemFwd(tp
, diRun
);
79 ME_DisplayItem
* ME_InsertTableRowStartFromCursor(ME_TextEditor
*editor
)
82 para
= ME_InsertEndParaFromCursor(editor
, 0, 1, 1, MEPF_ROWSTART
);
83 return para
->member
.para
.prev_para
;
86 ME_DisplayItem
* ME_InsertTableRowStartAtParagraph(ME_TextEditor
*editor
,
89 ME_DisplayItem
*prev_para
, *end_para
;
90 ME_Cursor savedCursor
= editor
->pCursors
[0];
91 ME_DisplayItem
*startRowPara
;
92 editor
->pCursors
[0].pRun
= ME_FindItemFwd(para
, diRun
);
93 editor
->pCursors
[0].nOffset
= 0;
94 editor
->pCursors
[1] = editor
->pCursors
[0];
95 startRowPara
= ME_InsertTableRowStartFromCursor(editor
);
96 editor
->pCursors
[0] = savedCursor
;
97 editor
->pCursors
[1] = editor
->pCursors
[0];
99 end_para
= ME_GetParagraph(editor
->pCursors
[0].pRun
)->member
.para
.next_para
;
100 prev_para
= startRowPara
->member
.para
.next_para
;
101 para
= prev_para
->member
.para
.next_para
;
102 while (para
!= end_para
)
104 para
->member
.para
.pCell
= prev_para
->member
.para
.pCell
;
105 para
->member
.para
.nFlags
|= MEPF_CELL
;
106 para
->member
.para
.nFlags
&= ~(MEPF_ROWSTART
|MEPF_ROWEND
);
107 para
->member
.para
.pFmt
->dwMask
|= PFM_TABLE
|PFM_TABLEROWDELIMITER
;
108 para
->member
.para
.pFmt
->wEffects
|= PFE_TABLE
;
109 para
->member
.para
.pFmt
->wEffects
&= ~PFE_TABLEROWDELIMITER
;
111 para
= para
->member
.para
.next_para
;
116 /* Inserts a diCell and starts a new paragraph for the next cell.
118 * Returns the first paragraph of the new cell. */
119 ME_DisplayItem
* ME_InsertTableCellFromCursor(ME_TextEditor
*editor
)
121 ME_DisplayItem
*para
;
122 para
= ME_InsertEndParaFromCursor(editor
, 0, 1, 0, MEPF_CELL
);
126 ME_DisplayItem
* ME_InsertTableRowEndFromCursor(ME_TextEditor
*editor
)
128 ME_DisplayItem
*para
;
129 para
= ME_InsertEndParaFromCursor(editor
, 0, 1, 1, MEPF_ROWEND
);
130 return para
->member
.para
.prev_para
;
133 ME_DisplayItem
* ME_GetTableRowEnd(ME_DisplayItem
*para
)
135 ME_DisplayItem
*cell
;
137 if (para
->member
.para
.nFlags
& MEPF_ROWEND
)
139 if (para
->member
.para
.nFlags
& MEPF_ROWSTART
)
140 para
= para
->member
.para
.next_para
;
141 cell
= para
->member
.para
.pCell
;
142 assert(cell
&& cell
->type
== diCell
);
143 while (cell
->member
.cell
.next_cell
)
144 cell
= cell
->member
.cell
.next_cell
;
146 para
= ME_FindItemFwd(cell
, diParagraph
);
147 assert(para
&& para
->member
.para
.nFlags
& MEPF_ROWEND
);
151 ME_DisplayItem
* ME_GetTableRowStart(ME_DisplayItem
*para
)
153 ME_DisplayItem
*cell
;
155 if (para
->member
.para
.nFlags
& MEPF_ROWSTART
)
157 if (para
->member
.para
.nFlags
& MEPF_ROWEND
)
158 para
= para
->member
.para
.prev_para
;
159 cell
= para
->member
.para
.pCell
;
160 assert(cell
&& cell
->type
== diCell
);
161 while (cell
->member
.cell
.prev_cell
)
162 cell
= cell
->member
.cell
.prev_cell
;
164 para
= ME_FindItemBack(cell
, diParagraph
);
165 assert(para
&& para
->member
.para
.nFlags
& MEPF_ROWSTART
);
169 /* Make a bunch of assertions to make sure tables haven't been corrupted.
171 * These invariants may not hold true in the middle of streaming in rich text
172 * or during an undo and redo of streaming in rich text. It should be safe to
173 * call this method after an event is processed.
175 void ME_CheckTablesForCorruption(ME_TextEditor
*editor
)
177 if(TRACE_ON(richedit_lists
))
179 TRACE_(richedit_lists
)("---\n");
180 ME_DumpDocument(editor
->pBuffer
);
184 ME_DisplayItem
*p
, *pPrev
;
185 pPrev
= editor
->pBuffer
->pFirst
;
187 if (!editor
->bEmulateVersion10
) /* v4.1 */
189 while (p
->type
== diParagraph
)
191 assert(p
->member
.para
.pFmt
->dwMask
& PFM_TABLE
);
192 assert(p
->member
.para
.pFmt
->dwMask
& PFM_TABLEROWDELIMITER
);
193 if (p
->member
.para
.pCell
)
195 assert(p
->member
.para
.nFlags
& MEPF_CELL
);
196 assert(p
->member
.para
.pFmt
->wEffects
& PFE_TABLE
);
198 if (p
->member
.para
.pCell
!= pPrev
->member
.para
.pCell
)
200 /* There must be a diCell in between the paragraphs if pCell changes. */
201 ME_DisplayItem
*pCell
= ME_FindItemBack(p
, diCell
);
203 assert(ME_FindItemBack(p
, diRun
) == ME_FindItemBack(pCell
, diRun
));
205 if (p
->member
.para
.nFlags
& MEPF_ROWEND
)
207 /* ROWEND must come after a cell. */
208 assert(pPrev
->member
.para
.pCell
);
209 assert(p
->member
.para
.pCell
210 == pPrev
->member
.para
.pCell
->member
.cell
.parent_cell
);
211 assert(p
->member
.para
.pFmt
->wEffects
& PFE_TABLEROWDELIMITER
);
213 else if (p
->member
.para
.pCell
)
215 assert(!(p
->member
.para
.pFmt
->wEffects
& PFE_TABLEROWDELIMITER
));
216 assert(pPrev
->member
.para
.pCell
||
217 pPrev
->member
.para
.nFlags
& MEPF_ROWSTART
);
218 if (pPrev
->member
.para
.pCell
&&
219 !(pPrev
->member
.para
.nFlags
& MEPF_ROWSTART
))
221 assert(p
->member
.para
.pCell
->member
.cell
.parent_cell
222 == pPrev
->member
.para
.pCell
->member
.cell
.parent_cell
);
223 if (pPrev
->member
.para
.pCell
!= p
->member
.para
.pCell
)
224 assert(pPrev
->member
.para
.pCell
225 == p
->member
.para
.pCell
->member
.cell
.prev_cell
);
228 else if (!(p
->member
.para
.nFlags
& MEPF_ROWSTART
))
230 assert(!(p
->member
.para
.pFmt
->wEffects
& PFE_TABLEROWDELIMITER
));
231 /* ROWSTART must be followed by a cell. */
232 assert(!(p
->member
.para
.nFlags
& MEPF_CELL
));
233 /* ROWSTART must be followed by a cell. */
234 assert(!(pPrev
->member
.para
.nFlags
& MEPF_ROWSTART
));
237 p
= p
->member
.para
.next_para
;
239 } else { /* v1.0 - 3.0 */
240 while (p
->type
== diParagraph
)
242 assert(!(p
->member
.para
.nFlags
& (MEPF_ROWSTART
|MEPF_ROWEND
|MEPF_CELL
)));
243 assert(p
->member
.para
.pFmt
->dwMask
& PFM_TABLE
);
244 assert(!(p
->member
.para
.pFmt
->wEffects
& PFM_TABLEROWDELIMITER
));
245 assert(!p
->member
.para
.pCell
);
246 p
= p
->member
.para
.next_para
;
250 assert(p
->type
== diTextEnd
);
251 assert(!pPrev
->member
.para
.pCell
);
256 BOOL
ME_IsInTable(ME_DisplayItem
*pItem
)
261 if (pItem
->type
== diRun
)
262 pItem
= ME_GetParagraph(pItem
);
263 if (pItem
->type
!= diParagraph
)
265 pFmt
= pItem
->member
.para
.pFmt
;
266 return pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
;
269 /* Table rows should either be deleted completely or not at all. */
270 void ME_ProtectPartialTableDeletion(ME_TextEditor
*editor
, int nOfs
,int *nChars
)
273 ME_DisplayItem
*this_para
, *end_para
;
274 ME_CursorFromCharOfs(editor
, nOfs
, &c
);
275 this_para
= ME_GetParagraph(c
.pRun
);
276 ME_CursorFromCharOfs(editor
, nOfs
+ *nChars
, &c2
);
277 end_para
= ME_GetParagraph(c2
.pRun
);
278 if (c2
.pRun
->member
.run
.nFlags
& MERF_ENDPARA
) {
279 /* End offset might be in the middle of the end paragraph run.
280 * If this is the case, then we need to use the next paragraph as the last
283 int remaining
= nOfs
+ *nChars
- c2
.pRun
->member
.run
.nCharOfs
284 - end_para
->member
.para
.nCharOfs
;
287 assert(remaining
< c2
.pRun
->member
.run
.nCR
+ c2
.pRun
->member
.run
.nLF
);
288 end_para
= end_para
->member
.para
.next_para
;
291 if (!editor
->bEmulateVersion10
) { /* v4.1 */
292 if (this_para
->member
.para
.pCell
!= end_para
->member
.para
.pCell
||
293 ((this_para
->member
.para
.nFlags
|end_para
->member
.para
.nFlags
)
294 & (MEPF_ROWSTART
|MEPF_ROWEND
)))
296 while (this_para
!= end_para
)
298 ME_DisplayItem
*next_para
= this_para
->member
.para
.next_para
;
299 BOOL bTruancateDeletion
= FALSE
;
300 if (this_para
->member
.para
.nFlags
& MEPF_ROWSTART
) {
301 /* The following while loop assumes that next_para is MEPF_ROWSTART,
302 * so moving back one paragraph let's it be processed as the start
304 next_para
= this_para
;
305 this_para
= this_para
->member
.para
.prev_para
;
306 } else if (next_para
->member
.para
.pCell
!= this_para
->member
.para
.pCell
307 || this_para
->member
.para
.nFlags
& MEPF_ROWEND
)
309 /* Start of the deletion from after the start of the table row. */
310 bTruancateDeletion
= TRUE
;
312 while (!bTruancateDeletion
&&
313 next_para
->member
.para
.nFlags
& MEPF_ROWSTART
)
315 next_para
= ME_GetTableRowEnd(next_para
)->member
.para
.next_para
;
316 if (next_para
->member
.para
.nCharOfs
> nOfs
+ *nChars
)
318 /* End of deletion is not past the end of the table row. */
319 next_para
= this_para
->member
.para
.next_para
;
320 /* Delete the end paragraph preceding the table row if the
321 * preceding table row will be empty. */
322 if (this_para
->member
.para
.nCharOfs
>= nOfs
)
324 next_para
= next_para
->member
.para
.next_para
;
326 bTruancateDeletion
= TRUE
;
328 this_para
= next_para
->member
.para
.prev_para
;
331 if (bTruancateDeletion
)
333 ME_Run
*end_run
= &ME_FindItemBack(next_para
, diRun
)->member
.run
;
334 int nCharsNew
= (next_para
->member
.para
.nCharOfs
- nOfs
335 - end_run
->nCR
- end_run
->nLF
);
336 nCharsNew
= max(nCharsNew
, 0);
337 assert(nCharsNew
<= *nChars
);
341 this_para
= next_para
;
344 } else { /* v1.0 - 3.0 */
345 ME_DisplayItem
*pRun
;
346 int nCharsToBoundary
;
348 if ((this_para
->member
.para
.nCharOfs
!= nOfs
|| this_para
== end_para
) &&
349 this_para
->member
.para
.pFmt
->dwMask
& PFM_TABLE
&&
350 this_para
->member
.para
.pFmt
->wEffects
& PFE_TABLE
)
353 /* Find the next tab or end paragraph to use as a delete boundary */
354 while (!(pRun
->member
.run
.nFlags
& (MERF_TAB
|MERF_ENDPARA
)))
355 pRun
= ME_FindItemFwd(pRun
, diRun
);
356 nCharsToBoundary
= pRun
->member
.run
.nCharOfs
357 - c
.pRun
->member
.run
.nCharOfs
359 *nChars
= min(*nChars
, nCharsToBoundary
);
360 } else if (end_para
->member
.para
.pFmt
->dwMask
& PFM_TABLE
&&
361 end_para
->member
.para
.pFmt
->wEffects
& PFE_TABLE
)
363 /* The deletion starts from before the row, so don't join it with
364 * previous non-empty paragraphs. */
366 if (nOfs
> this_para
->member
.para
.nCharOfs
)
367 pRun
= ME_FindItemBack(end_para
, diRun
);
369 pRun
= ME_FindItemFwd(end_para
, diRun
);
372 nCharsToBoundary
= ME_GetParagraph(pRun
)->member
.para
.nCharOfs
373 + pRun
->member
.run
.nCharOfs
375 if (nCharsToBoundary
>= 0)
376 *nChars
= min(*nChars
, nCharsToBoundary
);
384 ME_DisplayItem
* ME_AppendTableRow(ME_TextEditor
*editor
,
385 ME_DisplayItem
*table_row
)
387 WCHAR endl
= '\r', tab
= '\t';
393 assert(table_row
->type
== diParagraph
);
394 if (!editor
->bEmulateVersion10
) { /* v4.1 */
395 ME_DisplayItem
*insertedCell
, *para
, *cell
;
396 cell
= ME_FindItemFwd(ME_GetTableRowStart(table_row
), diCell
);
397 run
= ME_GetTableRowEnd(table_row
)->member
.para
.next_para
;
398 run
= ME_FindItemFwd(run
, diRun
);
399 editor
->pCursors
[0].pRun
= run
;
400 editor
->pCursors
[0].nOffset
= 0;
401 editor
->pCursors
[1] = editor
->pCursors
[0];
402 para
= ME_InsertTableRowStartFromCursor(editor
);
403 insertedCell
= ME_FindItemFwd(para
, diCell
);
404 /* Copy cell properties */
405 insertedCell
->member
.cell
.nRightBoundary
= cell
->member
.cell
.nRightBoundary
;
406 insertedCell
->member
.cell
.border
= cell
->member
.cell
.border
;
407 while (cell
->member
.cell
.next_cell
) {
408 cell
= cell
->member
.cell
.next_cell
;
409 para
= ME_InsertTableCellFromCursor(editor
);
410 insertedCell
= ME_FindItemBack(para
, diCell
);
411 /* Copy cell properties */
412 insertedCell
->member
.cell
.nRightBoundary
= cell
->member
.cell
.nRightBoundary
;
413 insertedCell
->member
.cell
.border
= cell
->member
.cell
.border
;
415 ME_InsertTableRowEndFromCursor(editor
);
416 /* return the table row start for the inserted paragraph */
417 return ME_FindItemFwd(cell
, diParagraph
)->member
.para
.next_para
;
418 } else { /* v1.0 - 3.0 */
419 run
= ME_FindItemBack(table_row
->member
.para
.next_para
, diRun
);
420 pFmt
= table_row
->member
.para
.pFmt
;
421 assert(pFmt
->dwMask
& PFM_TABLE
&& pFmt
->wEffects
& PFE_TABLE
);
422 editor
->pCursors
[0].pRun
= run
;
423 editor
->pCursors
[0].nOffset
= 0;
424 editor
->pCursors
[1] = editor
->pCursors
[0];
425 ME_InsertTextFromCursor(editor
, 0, &endl
, 1, run
->member
.run
.style
);
426 run
= editor
->pCursors
[0].pRun
;
427 for (i
= 0; i
< pFmt
->cTabCount
; i
++) {
428 ME_InsertTextFromCursor(editor
, 0, &tab
, 1, run
->member
.run
.style
);
430 return table_row
->member
.para
.next_para
;
434 /* Selects the next table cell or appends a new table row if at end of table */
435 static void ME_SelectOrInsertNextCell(ME_TextEditor
*editor
,
438 ME_DisplayItem
*para
= ME_GetParagraph(run
);
441 assert(run
&& run
->type
== diRun
);
442 assert(ME_IsInTable(run
));
443 if (!editor
->bEmulateVersion10
) { /* v4.1 */
444 ME_DisplayItem
*cell
;
445 /* Get the initial cell */
446 if (para
->member
.para
.nFlags
& MEPF_ROWSTART
) {
447 cell
= para
->member
.para
.next_para
->member
.para
.pCell
;
448 } else if (para
->member
.para
.nFlags
& MEPF_ROWEND
) {
449 cell
= para
->member
.para
.prev_para
->member
.para
.pCell
;
451 cell
= para
->member
.para
.pCell
;
454 /* Get the next cell. */
455 if (cell
->member
.cell
.next_cell
&&
456 cell
->member
.cell
.next_cell
->member
.cell
.next_cell
)
458 cell
= cell
->member
.cell
.next_cell
;
460 para
= ME_GetTableRowEnd(ME_FindItemFwd(cell
, diParagraph
));
461 para
= para
->member
.para
.next_para
;
463 if (para
->member
.para
.nFlags
& MEPF_ROWSTART
) {
464 cell
= para
->member
.para
.next_para
->member
.para
.pCell
;
467 para
= para
->member
.para
.prev_para
;
468 para
= ME_AppendTableRow(editor
, ME_GetTableRowStart(para
));
469 /* Put cursor at the start of the new table row */
470 para
= para
->member
.para
.next_para
;
471 editor
->pCursors
[0].pRun
= ME_FindItemFwd(para
, diRun
);
472 editor
->pCursors
[0].nOffset
= 0;
473 editor
->pCursors
[1] = editor
->pCursors
[0];
474 ME_WrapMarkedParagraphs(editor
);
479 editor
->pCursors
[1].pRun
= ME_FindItemFwd(cell
, diRun
);
480 editor
->pCursors
[1].nOffset
= 0;
481 assert(editor
->pCursors
[0].pRun
);
482 cell
= cell
->member
.cell
.next_cell
;
483 editor
->pCursors
[0].pRun
= ME_FindItemBack(cell
, diRun
);
484 editor
->pCursors
[0].nOffset
= 0;
485 assert(editor
->pCursors
[1].pRun
);
486 } else { /* v1.0 - 3.0 */
487 if (run
->member
.run
.nFlags
& MERF_ENDPARA
&&
488 ME_IsInTable(ME_FindItemFwd(run
, diParagraphOrEnd
)))
490 run
= ME_FindItemFwd(run
, diRun
);
493 for (i
= 0; i
< 2; i
++)
495 while (!(run
->member
.run
.nFlags
& MERF_TAB
))
497 run
= ME_FindItemFwd(run
, diRunOrParagraphOrEnd
);
498 if (run
->type
!= diRun
)
501 if (ME_IsInTable(para
))
503 run
= ME_FindItemFwd(para
, diRun
);
505 editor
->pCursors
[0].pRun
= run
;
506 editor
->pCursors
[0].nOffset
= 0;
509 /* Insert table row */
510 para
= ME_AppendTableRow(editor
, para
->member
.para
.prev_para
);
511 /* Put cursor at the start of the new table row */
512 editor
->pCursors
[0].pRun
= ME_FindItemFwd(para
, diRun
);
513 editor
->pCursors
[0].nOffset
= 0;
514 editor
->pCursors
[1] = editor
->pCursors
[0];
515 ME_WrapMarkedParagraphs(editor
);
521 run
= ME_FindItemFwd(run
, diRun
);
522 editor
->pCursors
[i
].pRun
= run
;
523 editor
->pCursors
[i
].nOffset
= 0;
529 void ME_TabPressedInTable(ME_TextEditor
*editor
, BOOL bSelectedRow
)
531 /* FIXME: Shift tab should move to the previous cell. */
532 ME_Cursor fromCursor
, toCursor
;
533 ME_InvalidateSelection(editor
);
536 from
= ME_GetCursorOfs(editor
, 0);
537 to
= ME_GetCursorOfs(editor
, 1);
540 fromCursor
= editor
->pCursors
[0];
541 toCursor
= editor
->pCursors
[1];
543 fromCursor
= editor
->pCursors
[1];
544 toCursor
= editor
->pCursors
[0];
547 if (!editor
->bEmulateVersion10
) /* v4.1 */
549 if (!ME_IsInTable(toCursor
.pRun
))
551 editor
->pCursors
[0] = toCursor
;
552 editor
->pCursors
[1] = toCursor
;
554 ME_SelectOrInsertNextCell(editor
, toCursor
.pRun
);
556 } else { /* v1.0 - 3.0 */
557 if (!ME_IsInTable(fromCursor
.pRun
)) {
558 editor
->pCursors
[0] = fromCursor
;
559 editor
->pCursors
[1] = fromCursor
;
560 /* FIXME: For some reason the caret is shown at the start of the
561 * previous paragraph in v1.0 to v3.0, and bCaretAtEnd only works
562 * within the paragraph for wrapped lines. */
563 if (ME_FindItemBack(fromCursor
.pRun
, diRun
))
564 editor
->bCaretAtEnd
= TRUE
;
565 } else if ((bSelectedRow
|| !ME_IsInTable(toCursor
.pRun
))) {
566 ME_SelectOrInsertNextCell(editor
, fromCursor
.pRun
);
568 if (ME_IsSelection(editor
) && !toCursor
.nOffset
)
571 run
= ME_FindItemBack(toCursor
.pRun
, diRunOrParagraphOrEnd
);
572 if (run
->type
== diRun
&& run
->member
.run
.nFlags
& MERF_TAB
)
573 ME_SelectOrInsertNextCell(editor
, run
);
575 ME_SelectOrInsertNextCell(editor
, toCursor
.pRun
);
577 ME_SelectOrInsertNextCell(editor
, toCursor
.pRun
);
581 ME_InvalidateSelection(editor
);
583 HideCaret(editor
->hWnd
);
584 ME_ShowCaret(editor
);
585 ME_SendSelChange(editor
);
588 /* Make sure the cursor is not in the hidden table row start paragraph
589 * without a selection. */
590 void ME_MoveCursorFromTableRowStartParagraph(ME_TextEditor
*editor
)
592 ME_DisplayItem
*para
= ME_GetParagraph(editor
->pCursors
[0].pRun
);
593 if (para
== ME_GetParagraph(editor
->pCursors
[1].pRun
) &&
594 para
->member
.para
.nFlags
& MEPF_ROWSTART
) {
595 /* The cursors should not be at the hidden start row paragraph without
596 * a selection, so the cursor is moved into the first cell. */
597 para
= para
->member
.para
.next_para
;
598 editor
->pCursors
[0].pRun
= ME_FindItemFwd(para
, diRun
);
599 editor
->pCursors
[0].nOffset
= 0;
600 editor
->pCursors
[1] = editor
->pCursors
[0];
604 struct RTFTable
*ME_MakeTableDef(ME_TextEditor
*editor
)
606 RTFTable
*tableDef
= ALLOC_OBJ(RTFTable
);
607 ZeroMemory(tableDef
, sizeof(RTFTable
));
608 if (!editor
->bEmulateVersion10
) /* v4.1 */
613 void ME_InitTableDef(ME_TextEditor
*editor
, struct RTFTable
*tableDef
)
615 ZeroMemory(tableDef
->cells
, sizeof(tableDef
->cells
));
616 ZeroMemory(tableDef
->border
, sizeof(tableDef
->border
));
617 tableDef
->numCellsDefined
= 0;
618 tableDef
->leftEdge
= 0;
619 if (!editor
->bEmulateVersion10
) /* v4.1 */
621 else /* v1.0 - 3.0 */