git.oblomov.eu Git - wine/blob - dlls/riched20/table.c

   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 that 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 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_lists);
  58
  59 static ME_DisplayItem* ME_InsertEndParaFromCursor(ME_TextEditor *editor,
  60                                                   int nCursor,
  61                                                   ME_String *eol_str,
  62                                                   int paraFlags)
  63 {
  64   ME_Style *pStyle = ME_GetInsertStyle(editor, nCursor);
  65   ME_DisplayItem *tp;
  66   ME_Cursor* cursor = &editor->pCursors[nCursor];
  67   if (cursor->nOffset) {
  68     ME_SplitRunSimple(editor, cursor->pRun, cursor->nOffset);
  69     cursor = &editor->pCursors[nCursor];
  70   }
  71
  72   tp = ME_SplitParagraph(editor, cursor->pRun, pStyle, eol_str, paraFlags);
  73   cursor->pRun = ME_FindItemFwd(tp, diRun);
  74   return tp;
  75 }
  76
  77 ME_DisplayItem* ME_InsertTableRowStartFromCursor(ME_TextEditor *editor)
  78 {
  79   ME_DisplayItem *para;
  80   WCHAR cr_lf[] = {'\r', '\n', 0};
  81   ME_String *eol_str = ME_MakeStringN(cr_lf, 2);
  82   para = ME_InsertEndParaFromCursor(editor, 0, eol_str, 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   WCHAR cr = '\r';
 123   ME_String *eol_str = ME_MakeStringN(&cr, 1);
 124   para = ME_InsertEndParaFromCursor(editor, 0, eol_str, MEPF_CELL);
 125   return para;
 126 }
 127
 128 ME_DisplayItem* ME_InsertTableRowEndFromCursor(ME_TextEditor *editor)
 129 {
 130   ME_DisplayItem *para;
 131   WCHAR cr_lf[] = {'\r', '\n', 0};
 132   ME_String *eol_str = ME_MakeStringN(cr_lf, 2);
 133   para = ME_InsertEndParaFromCursor(editor, 0, eol_str, MEPF_ROWEND);
 134   return para->member.para.prev_para;
 135 }
 136
 137 ME_DisplayItem* ME_GetTableRowEnd(ME_DisplayItem *para)
 138 {
 139   ME_DisplayItem *cell;
 140   assert(para);
 141   if (para->member.para.nFlags & MEPF_ROWEND)
 142     return para;
 143   if (para->member.para.nFlags & MEPF_ROWSTART)
 144     para = para->member.para.next_para;
 145   cell = para->member.para.pCell;
 146   assert(cell && cell->type == diCell);
 147   while (cell->member.cell.next_cell)
 148     cell = cell->member.cell.next_cell;
 149
 150   para = ME_FindItemFwd(cell, diParagraph);
 151   assert(para && para->member.para.nFlags & MEPF_ROWEND);
 152   return para;
 153 }
 154
 155 ME_DisplayItem* ME_GetTableRowStart(ME_DisplayItem *para)
 156 {
 157   ME_DisplayItem *cell;
 158   assert(para);
 159   if (para->member.para.nFlags & MEPF_ROWSTART)
 160     return para;
 161   if (para->member.para.nFlags & MEPF_ROWEND)
 162     para = para->member.para.prev_para;
 163   cell = para->member.para.pCell;
 164   assert(cell && cell->type == diCell);
 165   while (cell->member.cell.prev_cell)
 166     cell = cell->member.cell.prev_cell;
 167
 168   para = ME_FindItemBack(cell, diParagraph);
 169   assert(para && para->member.para.nFlags & MEPF_ROWSTART);
 170   return para;
 171 }
 172
 173 /* Make a bunch of assertions to make sure tables haven't been corrupted.
 174  *
 175  * These invariants may not hold true in the middle of streaming in rich text
 176  * or during an undo and redo of streaming in rich text. It should be safe to
 177  * call this method after an event is processed.
 178  */
 179 void ME_CheckTablesForCorruption(ME_TextEditor *editor)
 180 {
 181   if(TRACE_ON(richedit_lists))
 182   {
 183     TRACE("---\n");
 184     ME_DumpDocument(editor->pBuffer);
 185   }
 186 #ifndef NDEBUG
 187   {
 188     ME_DisplayItem *p, *pPrev;
 189     pPrev = editor->pBuffer->pFirst;
 190     p = pPrev->next;
 191     if (!editor->bEmulateVersion10) /* v4.1 */
 192     {
 193       while (p->type == diParagraph)
 194       {
 195         assert(p->member.para.pFmt->dwMask & PFM_TABLE);
 196         assert(p->member.para.pFmt->dwMask & PFM_TABLEROWDELIMITER);
 197         if (p->member.para.pCell)
 198         {
 199           assert(p->member.para.nFlags & MEPF_CELL);
 200           assert(p->member.para.pFmt->wEffects & PFE_TABLE);
 201         }
 202         if (p->member.para.pCell != pPrev->member.para.pCell)
 203         {
 204           /* There must be a diCell in between the paragraphs if pCell changes. */
 205           ME_DisplayItem *pCell = ME_FindItemBack(p, diCell);
 206           assert(pCell);
 207           assert(ME_FindItemBack(p, diRun) == ME_FindItemBack(pCell, diRun));
 208         }
 209         if (p->member.para.nFlags & MEPF_ROWEND)
 210         {
 211           /* ROWEND must come after a cell. */
 212           assert(pPrev->member.para.pCell);
 213           assert(p->member.para.pCell
 214                  == pPrev->member.para.pCell->member.cell.parent_cell);
 215           assert(p->member.para.pFmt->wEffects & PFE_TABLEROWDELIMITER);
 216         }
 217         else if (p->member.para.pCell)
 218         {
 219           assert(!(p->member.para.pFmt->wEffects & PFE_TABLEROWDELIMITER));
 220           assert(pPrev->member.para.pCell ||
 221                  pPrev->member.para.nFlags & MEPF_ROWSTART);
 222           if (pPrev->member.para.pCell &&
 223               !(pPrev->member.para.nFlags & MEPF_ROWSTART))
 224           {
 225             assert(p->member.para.pCell->member.cell.parent_cell
 226                    == pPrev->member.para.pCell->member.cell.parent_cell);
 227             if (pPrev->member.para.pCell != p->member.para.pCell)
 228               assert(pPrev->member.para.pCell
 229                      == p->member.para.pCell->member.cell.prev_cell);
 230           }
 231         }
 232         else if (!(p->member.para.nFlags & MEPF_ROWSTART))
 233         {
 234           assert(!(p->member.para.pFmt->wEffects & PFE_TABLEROWDELIMITER));
 235           /* ROWSTART must be followed by a cell. */
 236           assert(!(p->member.para.nFlags & MEPF_CELL));
 237           /* ROWSTART must be followed by a cell. */
 238           assert(!(pPrev->member.para.nFlags & MEPF_ROWSTART));
 239         }
 240         pPrev = p;
 241         p = p->member.para.next_para;
 242       }
 243     } else { /* v1.0 - 3.0 */
 244       while (p->type == diParagraph)
 245       {
 246         assert(!(p->member.para.nFlags & (MEPF_ROWSTART|MEPF_ROWEND|MEPF_CELL)));
 247         assert(p->member.para.pFmt->dwMask & PFM_TABLE);
 248         assert(!(p->member.para.pFmt->wEffects & PFM_TABLEROWDELIMITER));
 249         assert(!p->member.para.pCell);
 250         p = p->member.para.next_para;
 251       }
 252       return;
 253     }
 254     assert(p->type == diTextEnd);
 255     assert(!pPrev->member.para.pCell);
 256   }
 257 #endif
 258 }
 259
 260 BOOL ME_IsInTable(ME_DisplayItem *pItem)
 261 {
 262   PARAFORMAT2 *pFmt;
 263   if (!pItem)
 264     return FALSE;
 265   if (pItem->type == diRun)
 266     pItem = ME_GetParagraph(pItem);
 267   if (pItem->type != diParagraph)
 268     return FALSE;
 269   pFmt = pItem->member.para.pFmt;
 270   return pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE;
 271 }
 272
 273 /* Table rows should either be deleted completely or not at all. */
 274 void ME_ProtectPartialTableDeletion(ME_TextEditor *editor, int nOfs,int *nChars)
 275 {
 276   ME_Cursor c, c2;
 277   ME_DisplayItem *this_para, *end_para;
 278   ME_CursorFromCharOfs(editor, nOfs, &c);
 279   this_para = ME_GetParagraph(c.pRun);
 280   ME_CursorFromCharOfs(editor, nOfs + *nChars, &c2);
 281   end_para = ME_GetParagraph(c2.pRun);
 282   if (c2.pRun->member.run.nFlags & MERF_ENDPARA) {
 283     /* End offset might be in the middle of the end paragraph run.
 284      * If this is the case, then we need to use the next paragraph as the last
 285      * paragraphs.
 286      */
 287     int remaining = nOfs + *nChars - c2.pRun->member.run.nCharOfs
 288                     - end_para->member.para.nCharOfs;
 289     if (remaining)
 290     {
 291       assert(remaining < c2.pRun->member.run.strText->nLen);
 292       end_para = end_para->member.para.next_para;
 293     }
 294   }
 295   if (!editor->bEmulateVersion10) { /* v4.1 */
 296     if (this_para->member.para.pCell != end_para->member.para.pCell ||
 297         ((this_para->member.para.nFlags|end_para->member.para.nFlags)
 298          & (MEPF_ROWSTART|MEPF_ROWEND)))
 299     {
 300       while (this_para != end_para)
 301       {
 302         ME_DisplayItem *next_para = this_para->member.para.next_para;
 303         BOOL bTruancateDeletion = FALSE;
 304         if (this_para->member.para.nFlags & MEPF_ROWSTART) {
 305           /* The following while loop assumes that next_para is MEPF_ROWSTART,
 306            * so moving back one paragraph let's it be processed as the start
 307            * of the row. */
 308           next_para = this_para;
 309           this_para = this_para->member.para.prev_para;
 310         } else if (next_para->member.para.pCell != this_para->member.para.pCell
 311                    || this_para->member.para.nFlags & MEPF_ROWEND)
 312         {
 313           /* Start of the deletion from after the start of the table row. */
 314           bTruancateDeletion = TRUE;
 315         }
 316         while (!bTruancateDeletion &&
 317                next_para->member.para.nFlags & MEPF_ROWSTART)
 318         {
 319           next_para = ME_GetTableRowEnd(next_para)->member.para.next_para;
 320           if (next_para->member.para.nCharOfs > nOfs + *nChars)
 321           {
 322             /* End of deletion is not past the end of the table row. */
 323             next_para = this_para->member.para.next_para;
 324             /* Delete the end paragraph preceding the table row if the
 325              * preceding table row will be empty. */
 326             if (this_para->member.para.nCharOfs >= nOfs)
 327             {
 328               next_para = next_para->member.para.next_para;
 329             }
 330             bTruancateDeletion = TRUE;
 331           } else {
 332             this_para = next_para->member.para.prev_para;
 333           }
 334         }
 335         if (bTruancateDeletion)
 336         {
 337           ME_Run *end_run = &ME_FindItemBack(next_para, diRun)->member.run;
 338           int nCharsNew = (next_para->member.para.nCharOfs - nOfs
 339                            - end_run->strText->nLen);
 340           nCharsNew = max(nCharsNew, 0);
 341           assert(nCharsNew <= *nChars);
 342           *nChars = nCharsNew;
 343           break;
 344         }
 345         this_para = next_para;
 346       }
 347     }
 348   } else { /* v1.0 - 3.0 */
 349     ME_DisplayItem *pRun;
 350     int nCharsToBoundary;
 351
 352     if ((this_para->member.para.nCharOfs != nOfs || this_para == end_para) &&
 353         this_para->member.para.pFmt->dwMask & PFM_TABLE &&
 354         this_para->member.para.pFmt->wEffects & PFE_TABLE)
 355     {
 356       pRun = c.pRun;
 357       /* Find the next tab or end paragraph to use as a delete boundary */
 358       while (!(pRun->member.run.nFlags & (MERF_TAB|MERF_ENDPARA)))
 359         pRun = ME_FindItemFwd(pRun, diRun);
 360       nCharsToBoundary = pRun->member.run.nCharOfs
 361                          - c.pRun->member.run.nCharOfs
 362                          - c.nOffset;
 363       *nChars = min(*nChars, nCharsToBoundary);
 364     } else if (end_para->member.para.pFmt->dwMask & PFM_TABLE &&
 365                end_para->member.para.pFmt->wEffects & PFE_TABLE)
 366     {
 367       /* The deletion starts from before the row, so don't join it with
 368        * previous non-empty paragraphs. */
 369       pRun = NULL;
 370       if (nOfs > this_para->member.para.nCharOfs)
 371         pRun = ME_FindItemBack(end_para, diRun);
 372       if (!pRun)
 373         pRun = ME_FindItemFwd(end_para, diRun);
 374       if (pRun)
 375       {
 376         nCharsToBoundary = ME_GetParagraph(pRun)->member.para.nCharOfs
 377                            + pRun->member.run.nCharOfs
 378                            - nOfs;
 379         if (nCharsToBoundary >= 0)
 380           *nChars = min(*nChars, nCharsToBoundary);
 381       }
 382     }
 383     if (*nChars < 0)
 384       nChars = 0;
 385   }
 386 }
 387
 388 ME_DisplayItem* ME_AppendTableRow(ME_TextEditor *editor,
 389                                   ME_DisplayItem *table_row)
 390 {
 391   WCHAR endl = '\r', tab = '\t';
 392   ME_DisplayItem *run;
 393   PARAFORMAT2 *pFmt;
 394   int i;
 395
 396   assert(table_row);
 397   assert(table_row->type == diParagraph);
 398   if (!editor->bEmulateVersion10) { /* v4.1 */
 399     ME_DisplayItem *insertedCell, *para, *cell, *prevTableEnd;
 400     cell = ME_FindItemFwd(ME_GetTableRowStart(table_row), diCell);
 401     prevTableEnd = ME_GetTableRowEnd(table_row);
 402     run = prevTableEnd->member.para.next_para;
 403     run = ME_FindItemFwd(run, diRun);
 404     editor->pCursors[0].pRun = run;
 405     editor->pCursors[0].nOffset = 0;
 406     editor->pCursors[1] = editor->pCursors[0];
 407     para = ME_InsertTableRowStartFromCursor(editor);
 408     insertedCell = ME_FindItemFwd(para, diCell);
 409       /* Copy cell properties */
 410     insertedCell->member.cell.nRightBoundary = cell->member.cell.nRightBoundary;
 411     insertedCell->member.cell.border = cell->member.cell.border;
 412     while (cell->member.cell.next_cell) {
 413       cell = cell->member.cell.next_cell;
 414       para = ME_InsertTableCellFromCursor(editor);
 415       insertedCell = ME_FindItemBack(para, diCell);
 416       /* Copy cell properties */
 417       insertedCell->member.cell.nRightBoundary = cell->member.cell.nRightBoundary;
 418       insertedCell->member.cell.border = cell->member.cell.border;
 419     };
 420     para = ME_InsertTableRowEndFromCursor(editor);
 421     *para->member.para.pFmt = *prevTableEnd->member.para.pFmt;
 422     /* return the table row start for the inserted paragraph */
 423     return ME_FindItemFwd(cell, diParagraph)->member.para.next_para;
 424   } else { /* v1.0 - 3.0 */
 425     run = ME_FindItemBack(table_row->member.para.next_para, diRun);
 426     pFmt = table_row->member.para.pFmt;
 427     assert(pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE);
 428     editor->pCursors[0].pRun = run;
 429     editor->pCursors[0].nOffset = 0;
 430     editor->pCursors[1] = editor->pCursors[0];
 431     ME_InsertTextFromCursor(editor, 0, &endl, 1, run->member.run.style);
 432     run = editor->pCursors[0].pRun;
 433     for (i = 0; i < pFmt->cTabCount; i++) {
 434       ME_InsertTextFromCursor(editor, 0, &tab, 1, run->member.run.style);
 435     }
 436     return table_row->member.para.next_para;
 437   }
 438 }
 439
 440 /* Selects the next table cell or appends a new table row if at end of table */
 441 static void ME_SelectOrInsertNextCell(ME_TextEditor *editor,
 442                                       ME_DisplayItem *run)
 443 {
 444   ME_DisplayItem *para = ME_GetParagraph(run);
 445   int i;
 446
 447   assert(run && run->type == diRun);
 448   assert(ME_IsInTable(run));
 449   if (!editor->bEmulateVersion10) { /* v4.1 */
 450     ME_DisplayItem *cell;
 451     /* Get the initial cell */
 452     if (para->member.para.nFlags & MEPF_ROWSTART) {
 453       cell = para->member.para.next_para->member.para.pCell;
 454     } else if (para->member.para.nFlags & MEPF_ROWEND) {
 455       cell = para->member.para.prev_para->member.para.pCell;
 456     } else {
 457       cell = para->member.para.pCell;
 458     }
 459     assert(cell);
 460     /* Get the next cell. */
 461     if (cell->member.cell.next_cell &&
 462         cell->member.cell.next_cell->member.cell.next_cell)
 463     {
 464       cell = cell->member.cell.next_cell;
 465     } else {
 466       para = ME_GetTableRowEnd(ME_FindItemFwd(cell, diParagraph));
 467       para = para->member.para.next_para;
 468       assert(para);
 469       if (para->member.para.nFlags & MEPF_ROWSTART) {
 470         cell = para->member.para.next_para->member.para.pCell;
 471       } else {
 472         /* Insert row */
 473         para = para->member.para.prev_para;
 474         para = ME_AppendTableRow(editor, ME_GetTableRowStart(para));
 475         /* Put cursor at the start of the new table row */
 476         para = para->member.para.next_para;
 477         editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
 478         editor->pCursors[0].nOffset = 0;
 479         editor->pCursors[1] = editor->pCursors[0];
 480         ME_WrapMarkedParagraphs(editor);
 481         return;
 482       }
 483     }
 484     /* Select cell */
 485     editor->pCursors[1].pRun = ME_FindItemFwd(cell, diRun);
 486     editor->pCursors[1].nOffset = 0;
 487     assert(editor->pCursors[0].pRun);
 488     cell = cell->member.cell.next_cell;
 489     editor->pCursors[0].pRun = ME_FindItemBack(cell, diRun);
 490     editor->pCursors[0].nOffset = 0;
 491     assert(editor->pCursors[1].pRun);
 492   } else { /* v1.0 - 3.0 */
 493     if (run->member.run.nFlags & MERF_ENDPARA &&
 494         ME_IsInTable(ME_FindItemFwd(run, diParagraphOrEnd)))
 495     {
 496       run = ME_FindItemFwd(run, diRun);
 497       assert(run);
 498     }
 499     for (i = 0; i < 2; i++)
 500     {
 501       while (!(run->member.run.nFlags & MERF_TAB))
 502       {
 503         run = ME_FindItemFwd(run, diRunOrParagraphOrEnd);
 504         if (run->type != diRun)
 505         {
 506           para = run;
 507           if (ME_IsInTable(para))
 508           {
 509             run = ME_FindItemFwd(para, diRun);
 510             assert(run);
 511             editor->pCursors[0].pRun = run;
 512             editor->pCursors[0].nOffset = 0;
 513             i = 1;
 514           } else {
 515             /* Insert table row */
 516             para = ME_AppendTableRow(editor, para->member.para.prev_para);
 517             /* Put cursor at the start of the new table row */
 518             editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
 519             editor->pCursors[0].nOffset = 0;
 520             editor->pCursors[1] = editor->pCursors[0];
 521             ME_WrapMarkedParagraphs(editor);
 522             return;
 523           }
 524         }
 525       }
 526       if (i == 0)
 527         run = ME_FindItemFwd(run, diRun);
 528       editor->pCursors[i].pRun = run;
 529       editor->pCursors[i].nOffset = 0;
 530     }
 531   }
 532 }
 533
 534
 535 void ME_TabPressedInTable(ME_TextEditor *editor, BOOL bSelectedRow)
 536 {
 537   /* FIXME: Shift tab should move to the previous cell. */
 538   ME_Cursor fromCursor, toCursor;
 539   ME_InvalidateSelection(editor);
 540   {
 541     int from, to;
 542     from = ME_GetCursorOfs(editor, 0);
 543     to = ME_GetCursorOfs(editor, 1);
 544     if (from <= to)
 545     {
 546       fromCursor = editor->pCursors[0];
 547       toCursor = editor->pCursors[1];
 548     } else {
 549       fromCursor = editor->pCursors[1];
 550       toCursor = editor->pCursors[0];
 551     }
 552   }
 553   if (!editor->bEmulateVersion10) /* v4.1 */
 554   {
 555     if (!ME_IsInTable(toCursor.pRun))
 556     {
 557       editor->pCursors[0] = toCursor;
 558       editor->pCursors[1] = toCursor;
 559     } else {
 560       ME_SelectOrInsertNextCell(editor, toCursor.pRun);
 561     }
 562   } else { /* v1.0 - 3.0 */
 563     if (!ME_IsInTable(fromCursor.pRun)) {
 564       editor->pCursors[0] = fromCursor;
 565       editor->pCursors[1] = fromCursor;
 566       /* FIXME: For some reason the caret is shown at the start of the
 567        *        previous paragraph in v1.0 to v3.0, and bCaretAtEnd only works
 568        *        within the paragraph for wrapped lines. */
 569       if (ME_FindItemBack(fromCursor.pRun, diRun))
 570         editor->bCaretAtEnd = TRUE;
 571     } else if ((bSelectedRow || !ME_IsInTable(toCursor.pRun))) {
 572       ME_SelectOrInsertNextCell(editor, fromCursor.pRun);
 573     } else {
 574       if (ME_IsSelection(editor) && !toCursor.nOffset)
 575       {
 576         ME_DisplayItem *run;
 577         run = ME_FindItemBack(toCursor.pRun, diRunOrParagraphOrEnd);
 578         if (run->type == diRun && run->member.run.nFlags & MERF_TAB)
 579           ME_SelectOrInsertNextCell(editor, run);
 580         else
 581           ME_SelectOrInsertNextCell(editor, toCursor.pRun);
 582       } else {
 583         ME_SelectOrInsertNextCell(editor, toCursor.pRun);
 584       }
 585     }
 586   }
 587   ME_InvalidateSelection(editor);
 588   ME_Repaint(editor);
 589   ITextHost_TxShowCaret(editor->texthost, FALSE);
 590   ME_ShowCaret(editor);
 591   ME_SendSelChange(editor);
 592 }
 593
 594 /* Make sure the cursor is not in the hidden table row start paragraph
 595  * without a selection. */
 596 void ME_MoveCursorFromTableRowStartParagraph(ME_TextEditor *editor)
 597 {
 598   ME_DisplayItem *para = ME_GetParagraph(editor->pCursors[0].pRun);
 599   if (para == ME_GetParagraph(editor->pCursors[1].pRun) &&
 600       para->member.para.nFlags & MEPF_ROWSTART) {
 601     /* The cursors should not be at the hidden start row paragraph without
 602      * a selection, so the cursor is moved into the first cell. */
 603     para = para->member.para.next_para;
 604     editor->pCursors[0].pRun = ME_FindItemFwd(para, diRun);
 605     editor->pCursors[0].nOffset = 0;
 606     editor->pCursors[1] = editor->pCursors[0];
 607   }
 608 }
 609
 610 struct RTFTable *ME_MakeTableDef(ME_TextEditor *editor)
 611 {
 612   RTFTable *tableDef = ALLOC_OBJ(RTFTable);
 613   ZeroMemory(tableDef, sizeof(RTFTable));
 614   if (!editor->bEmulateVersion10) /* v4.1 */
 615     tableDef->gapH = 10;
 616   return tableDef;
 617 }
 618
 619 void ME_InitTableDef(ME_TextEditor *editor, struct RTFTable *tableDef)
 620 {
 621   ZeroMemory(tableDef->cells, sizeof(tableDef->cells));
 622   ZeroMemory(tableDef->border, sizeof(tableDef->border));
 623   tableDef->numCellsDefined = 0;
 624   tableDef->leftEdge = 0;
 625   if (!editor->bEmulateVersion10) /* v4.1 */
 626     tableDef->gapH = 10;
 627   else /* v1.0 - 3.0 */
 628     tableDef->gapH = 0;
 629 }