1 /*
2 * RichEdit functions dealing with on tables
3 *
4 * Copyright 2008 by Dylan Smith
5 *
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.
10 *
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.
15 *
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
19 */
20
21 /*
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.
28 *
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 the the paragraph is a table row. Note that in this
33 * implementation there is one paragraph per table row.
34 *
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.
39 *
40 * There are 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.
45 *
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
51 * just a delimiter.
52 */
53
54 #include "editor.h"
55 #include "rtf.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
58 WINE_DECLARE_DEBUG_CHANNEL(richedit_lists);
59
60 static ME_DisplayItem* ME_InsertEndParaFromCursor(ME_TextEditor *editor,
61 int nCursor,
62 int numCR,
63 int numLF,
64 int paraFlags)
65 {
66 ME_Style *pStyle = ME_GetInsertStyle(editor, nCursor);
67 ME_DisplayItem *tp;
68 ME_Cursor* cursor = &editor->pCursors[nCursor];
69 if (cursor->nOffset) {
70 ME_SplitRunSimple(editor, cursor->pRun, cursor->nOffset);
71 cursor = &editor->pCursors[nCursor];
72 }
73
74 tp = ME_SplitParagraph(editor, cursor->pRun, pStyle, numCR, numLF, paraFlags);
75 cursor->pRun = ME_FindItemFwd(tp, diRun);
76 return tp;
77 }
78
79 ME_DisplayItem* ME_InsertTableRowStartFromCursor(ME_TextEditor *editor)
80 {
81 ME_DisplayItem *para;
82 para = ME_InsertEndParaFromCursor(editor, 0, 1, 1, MEPF_ROWSTART);
83 return para->member.para.prev_para;
84 }
85
86 ME_DisplayItem* ME_InsertTableRowStartAtParagraph(ME_TextEditor *editor,
87 ME_DisplayItem *para)
88 {
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];
98
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)
103 {
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;
110 prev_para = para;
111 para = para->member.para.next_para;
112 }
113 return startRowPara;
114 }
115
116 /* Inserts a diCell and starts a new paragraph for the next cell.
117 *
118 * Returns the first paragraph of the new cell. */
119 ME_DisplayItem* ME_InsertTableCellFromCursor(ME_TextEditor *editor)
120 {
121 ME_DisplayItem *para;
122 para = ME_InsertEndParaFromCursor(editor, 0, 1, 0, MEPF_CELL);
123 return para;
124 }
125
126 ME_DisplayItem* ME_InsertTableRowEndFromCursor(ME_TextEditor *editor)
127 {
128 ME_DisplayItem *para;
129 para = ME_InsertEndParaFromCursor(editor, 0, 1, 1, MEPF_ROWEND);
130 return para->member.para.prev_para;
131 }
132
133 ME_DisplayItem* ME_GetTableRowEnd(ME_DisplayItem *para)
134 {
135 ME_DisplayItem *cell;
136 assert(para);
137 if (para->member.para.nFlags & MEPF_ROWEND)
138 return para;
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;
145
146 para = ME_FindItemFwd(cell, diParagraph);
147 assert(para && para->member.para.nFlags & MEPF_ROWEND);
148 return para;
149 }
150
151 ME_DisplayItem* ME_GetTableRowStart(ME_DisplayItem *para)
152 {
153 ME_DisplayItem *cell;
154 assert(para);
155 if (para->member.para.nFlags & MEPF_ROWSTART)
156 return para;
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;
163
164 para = ME_FindItemBack(cell, diParagraph);
165 assert(para && para->member.para.nFlags & MEPF_ROWSTART);
166 return para;
167 }
168
169 /* Make a bunch of assertions to make sure tables haven't been corrupted.
170 *
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.
174 */
175 void ME_CheckTablesForCorruption(ME_TextEditor *editor)
176 {
177 if(TRACE_ON(richedit_lists))
178 {
179 TRACE_(richedit_lists)("---\n");
180 ME_DumpDocument(editor->pBuffer);
181 }
182 #ifndef NDEBUG
183 {
184 ME_DisplayItem *p, *pPrev;
185 pPrev = editor->pBuffer->pFirst;
186 p = pPrev->next;
187 if (!editor->bEmulateVersion10) /* v4.1 */
188 {
189 while (p->type == diParagraph)
190 {
191 assert(p->member.para.pFmt->dwMask & PFM_TABLE);
192 assert(p->member.para.pFmt->dwMask & PFM_TABLEROWDELIMITER);
193 if (p->member.para.pCell)
194 {
195 assert(p->member.para.nFlags & MEPF_CELL);
196 assert(p->member.para.pFmt->wEffects & PFE_TABLE);
197 }
198 if (p->member.para.pCell != pPrev->member.para.pCell)
199 {
200 /* There must be a diCell in between the paragraphs if pCell changes. */
201 ME_DisplayItem *pCell = ME_FindItemBack(p, diCell);
202 assert(pCell);
203 assert(ME_FindItemBack(p, diRun) == ME_FindItemBack(pCell, diRun));
204 }
205 if (p->member.para.nFlags & MEPF_ROWEND)
206 {
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);
212 }
213 else if (p->member.para.pCell)
214 {
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))
220 {
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);
226 }
227 }
228 else if (!(p->member.para.nFlags & MEPF_ROWSTART))
229 {
230 assert(!(p->member.para.pFmt->wEffects & (PFE_TABLE|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));
235 }
236 pPrev = p;
237 p = p->member.para.next_para;
238 }
239 } else { /* v1.0 - 3.0 */
240 while (p->type == diParagraph)
241 {
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;
247 }
248 return;
249 }
250 assert(p->type == diTextEnd);
251 assert(!pPrev->member.para.pCell);
252 }
253 #endif
254 }
255
256 BOOL ME_IsInTable(ME_DisplayItem *pItem)
257 {
258 PARAFORMAT2 *pFmt;
259 if (!pItem)
260 return FALSE;
261 if (pItem->type == diRun)
262 pItem = ME_GetParagraph(pItem);
263 if (pItem->type != diParagraph)
264 return FALSE;
265 pFmt = pItem->member.para.pFmt;
266 return pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE;
267 }
268
269 /* Table rows should either be deleted completely or not at all. */
270 void ME_ProtectPartialTableDeletion(ME_TextEditor *editor, int nOfs,int *nChars)
271 {
272 ME_Cursor c, c2;
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
281 * paragraphs.
282 */
283 int remaining = nOfs + *nChars - c2.pRun->member.run.nCharOfs
284 - end_para->member.para.nCharOfs;
285 if (remaining)
286 {
287 assert(remaining < c2.pRun->member.run.nCR + c2.pRun->member.run.nLF);
288 end_para = end_para->member.para.next_para;
289 }
290 }
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)))
295 {
296 while (this_para != end_para)
297 {
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
303 * of the row. */
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)
308 {
309 /* Start of the deletion from after the start of the table row. */
310 bTruancateDeletion = TRUE;
311 }
312 while (!bTruancateDeletion &&
313 next_para->member.para.nFlags & MEPF_ROWSTART)
314 {
315 next_para = ME_GetTableRowEnd(next_para)->member.para.next_para;
316 if (next_para->member.para.nCharOfs > nOfs + *nChars)
317 {
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)
323 {
324 next_para = next_para->member.para.next_para;
325 }
326 bTruancateDeletion = TRUE;
327 } else {
328 this_para = next_para->member.para.prev_para;
329 }
330 }
331 if (bTruancateDeletion)
332 {
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);
338 *nChars = nCharsNew;
339 break;
340 }
341 this_para = next_para;
342 }
343 }
344 } else { /* v1.0 - 3.0 */
345 ME_DisplayItem *pRun;
346 int nCharsToBoundary;
347
348 if (this_para->member.para.nCharOfs != nOfs &&
349 this_para->member.para.pFmt->dwMask & PFM_TABLE &&
350 this_para->member.para.pFmt->wEffects & PFE_TABLE)
351 {
352 pRun = c.pRun;
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
358 - c.nOffset;
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)
362 {
363 if (this_para == end_para)
364 {
365 pRun = c2.pRun;
366 /* Find the previous tab or end paragraph to use as a delete boundary */
367 while (pRun && !(pRun->member.run.nFlags & (MERF_TAB|MERF_ENDPARA)))
368 pRun = ME_FindItemBack(pRun, diRun);
369 if (pRun && pRun->member.run.nFlags & MERF_ENDPARA)
370 {
371 /* We are in the first cell, and have gone back to the previous
372 * paragraph, so nothing needs to be protected. */
373 pRun = NULL;
374 }
375 } else {
376 /* The deletion starts from before the row, so don't join it with
377 * previous non-empty paragraphs. */
378 pRun = NULL;
379 if (nOfs > this_para->member.para.nCharOfs)
380 pRun = ME_FindItemBack(end_para, diRun);
381 if (!pRun)
382 pRun = ME_FindItemFwd(end_para, diRun);
383 }
384 if (pRun)
385 {
386 nCharsToBoundary = ME_GetParagraph(pRun)->member.para.nCharOfs
387 + pRun->member.run.nCharOfs
388 - nOfs;
389 if (nCharsToBoundary >= 0)
390 *nChars = min(*nChars, nCharsToBoundary);
391 }
392 }
393 if (*nChars < 0)
394 nChars = 0;
395 }
396 }
397
398 static ME_DisplayItem* ME_AppendTableRow(ME_TextEditor *editor,
399 ME_DisplayItem *table_row)
400 {
401 WCHAR endl = '\r', tab = '\t';
402 ME_DisplayItem *run;
403 PARAFORMAT2 *pFmt;
404 int i;
405
406 assert(table_row);
407 if (!editor->bEmulateVersion10) { /* v4.1 */
408 ME_DisplayItem *insertedCell, *para, *cell;
409 cell = ME_FindItemFwd(table_row, diCell);
410 run = ME_GetTableRowEnd(table_row)->member.para.next_para;
411 run = ME_FindItemFwd(run, diRun);
412 editor->pCursors[0].pRun = run;
413 editor->pCursors[0].nOffset = 0;
414 editor->pCursors[1] = editor->pCursors[0];
415 para = ME_InsertTableRowStartFromCursor(editor);
416 insertedCell = ME_FindItemFwd(para, diCell);
417 /* Copy cell properties */
418 insertedCell->member.cell.nRightBoundary = cell->member.cell.nRightBoundary;
419 while (cell->member.cell.next_cell) {
420 cell = cell->member.cell.next_cell;
421 para = ME_InsertTableCellFromCursor(editor);
422 insertedCell = ME_FindItemBack(para, diCell);
423 /* Copy cell properties */
424 insertedCell->member.cell.nRightBoundary = cell->member.cell.nRightBoundary;
425 };
426 ME_InsertTableRowEndFromCursor(editor);
427 /* return the table row start for the inserted paragraph */
428 return ME_FindItemFwd(cell, diParagraph)->member.para.next_para;
429 } else { /* v1.0 - 3.0 */
430 run = ME_FindItemBack(table_row->member.para.next_para, diRun);
431 pFmt = table_row->member.para.pFmt;
432 assert(pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE);
433 editor->pCursors[0].pRun = run;
434 editor->pCursors[0].nOffset = 0;
435 editor->pCursors[1] = editor->pCursors[0];
436 ME_InsertTextFromCursor(editor, 0, &endl, 1, run->member.run.style);
437 run = editor->pCursors[0].pRun;
438 for (i = 0; i < pFmt->cTabCount; i++) {
439 ME_InsertTextFromCursor(editor, 0, &tab, 1, run->member.run.style);
440 }
441 return table_row->member.para.next_para;
442 }
443 }
444
445 /* Selects the next table cell or appends a new table row if at end of table */
446 static void ME_SelectOrInsertNextCell(ME_TextEditor *editor,
447 ME_DisplayItem *run)
448 {
449 ME_DisplayItem *para = ME_GetParagraph(run);
450 int i;
451
452 assert(run && run->type == diRun);
453 assert(ME_IsInTable(run));
454 if (!editor->bEmulateVersion10) { /* v4.1 */
455 ME_DisplayItem *cell;
456 /* Get the initial cell */
457 if (para->member.para.nFlags & MEPF_ROWSTART) {
458 cell = para->member.para.next_para->member.para.pCell;
459 } else if (para->member.para.nFlags & MEPF_ROWEND) {
460 cell = para->member.para.prev_para->member.para.pCell;
461 } else {
462 cell = para->member.para.pCell;
463 }
464 assert(cell);
465 /* Get the next cell. */
466 if (cell->member.cell.next_cell &&
467 cell->member.cell.next_cell->member.cell.next_cell)
468 {
469 cell = cell->member.cell.next_cell;
470 } else {
471 para = ME_GetTableRowEnd(ME_FindItemFwd(cell, diParagraph));
472 para = para->member.para.next_para;
473 assert(para);
474 if (para->member.para.nFlags & MEPF_ROWSTART) {
475 cell = para->member.para.next_para->member.para.pCell;
476 } else {
477 /* Insert row */
478 para = para->member.para.prev_para;
479 para = ME_AppendTableRow(editor, ME_GetTableRowStart(para));
480 /* Put cursor at the start of the new table row */
481 para = para->member.para.next_para;
482 editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
483 editor->pCursors[0].nOffset = 0;
484 editor->pCursors[1] = editor->pCursors[0];
485 ME_WrapMarkedParagraphs(editor);
486 return;
487 }
488 }
489 /* Select cell */
490 editor->pCursors[1].pRun = ME_FindItemFwd(cell, diRun);
491 editor->pCursors[1].nOffset = 0;
492 assert(editor->pCursors[0].pRun);
493 cell = cell->member.cell.next_cell;
494 editor->pCursors[0].pRun = ME_FindItemBack(cell, diRun);
495 editor->pCursors[0].nOffset = 0;
496 assert(editor->pCursors[1].pRun);
497 } else { /* v1.0 - 3.0 */
498 if (run->member.run.nFlags & MERF_ENDPARA &&
499 ME_IsInTable(ME_FindItemFwd(run, diParagraphOrEnd)))
500 {
501 run = ME_FindItemFwd(run, diRun);
502 assert(run);
503 }
504 for (i = 0; i < 2; i++)
505 {
506 while (!(run->member.run.nFlags & MERF_TAB))
507 {
508 run = ME_FindItemFwd(run, diRunOrParagraphOrEnd);
509 if (run->type != diRun)
510 {
511 para = run;
512 if (ME_IsInTable(para))
513 {
514 run = ME_FindItemFwd(para, diRun);
515 assert(run);
516 editor->pCursors[0].pRun = run;
517 editor->pCursors[0].nOffset = 0;
518 i = 1;
519 } else {
520 /* Insert table row */
521 para = ME_AppendTableRow(editor, para->member.para.prev_para);
522 /* Put cursor at the start of the new table row */
523 editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
524 editor->pCursors[0].nOffset = 0;
525 editor->pCursors[1] = editor->pCursors[0];
526 ME_WrapMarkedParagraphs(editor);
527 return;
528 }
529 }
530 }
531 if (i == 0)
532 run = ME_FindItemFwd(run, diRun);
533 editor->pCursors[i].pRun = run;
534 editor->pCursors[i].nOffset = 0;
535 }
536 }
537 }
538
539
540 void ME_TabPressedInTable(ME_TextEditor *editor, BOOL bSelectedRow)
541 {
542 /* FIXME: Shift tab should move to the previous cell. */
543 ME_Cursor fromCursor, toCursor;
544 ME_InvalidateSelection(editor);
545 {
546 int from, to;
547 from = ME_GetCursorOfs(editor, 0);
548 to = ME_GetCursorOfs(editor, 1);
549 if (from <= to)
550 {
551 fromCursor = editor->pCursors[0];
552 toCursor = editor->pCursors[1];
553 } else {
554 fromCursor = editor->pCursors[1];
555 toCursor = editor->pCursors[0];
556 }
557 }
558 if (!editor->bEmulateVersion10) /* v4.1 */
559 {
560 if (!ME_IsInTable(toCursor.pRun))
561 {
562 editor->pCursors[0] = toCursor;
563 editor->pCursors[1] = toCursor;
564 } else {
565 ME_SelectOrInsertNextCell(editor, toCursor.pRun);
566 }
567 } else { /* v1.0 - 3.0 */
568 if (!ME_IsInTable(fromCursor.pRun)) {
569 editor->pCursors[0] = fromCursor;
570 editor->pCursors[1] = fromCursor;
571 /* FIXME: For some reason the caret is shown at the start of the
572 * previous paragraph in v1.0 to v3.0, and bCaretAtEnd only works
573 * within the paragraph for wrapped lines. */
574 if (ME_FindItemBack(fromCursor.pRun, diRun))
575 editor->bCaretAtEnd = TRUE;
576 } else if ((bSelectedRow || !ME_IsInTable(toCursor.pRun))) {
577 ME_SelectOrInsertNextCell(editor, fromCursor.pRun);
578 } else {
579 if (ME_IsSelection(editor) && !toCursor.nOffset)
580 {
581 ME_DisplayItem *run;
582 run = ME_FindItemBack(toCursor.pRun, diRunOrParagraphOrEnd);
583 if (run->type == diRun && run->member.run.nFlags & MERF_TAB)
584 ME_SelectOrInsertNextCell(editor, run);
585 else
586 ME_SelectOrInsertNextCell(editor, toCursor.pRun);
587 } else {
588 ME_SelectOrInsertNextCell(editor, toCursor.pRun);
589 }
590 }
591 }
592 ME_InvalidateSelection(editor);
593 ME_Repaint(editor);
594 HideCaret(editor->hWnd);
595 ME_ShowCaret(editor);
596 ME_SendSelChange(editor);
597 }
598
599 struct RTFTable *ME_MakeTableDef(ME_TextEditor *editor)
600 {
601 RTFTable *tableDef = ALLOC_OBJ(RTFTable);
602 ZeroMemory(tableDef, sizeof(RTFTable));
603 if (!editor->bEmulateVersion10) /* v4.1 */
604 tableDef->gapH = 10;
605 return tableDef;
606 }
607
608 void ME_InitTableDef(ME_TextEditor *editor, struct RTFTable *tableDef)
609 {
610 ZeroMemory(tableDef->cells, sizeof(tableDef->cells));
611 ZeroMemory(tableDef->border, sizeof(tableDef->border));
612 tableDef->numCellsDefined = 0;
613 tableDef->leftEdge = 0;
614 if (!editor->bEmulateVersion10) /* v4.1 */
615 tableDef->gapH = 10;
616 else /* v1.0 - 3.0 */
617 tableDef->gapH = 0;
618 }
619
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.