dlls/riched20/para.c

   1 /*
   2  * RichEdit - functions working on paragraphs of text (diParagraph).
   3  *
   4  * Copyright 2004 by Krzysztof Foltman
   5  * Copyright 2006 by Phil Krylov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "editor.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
  25
  26 void ME_MakeFirstParagraph(ME_TextEditor *editor)
  27 {
  28   ME_Context c;
  29   CHARFORMAT2W cf;
  30   LOGFONTW lf;
  31   HFONT hf;
  32   ME_TextBuffer *text = editor->pBuffer;
  33   ME_DisplayItem *para = ME_MakeDI(diParagraph);
  34   ME_DisplayItem *run;
  35   ME_Style *style;
  36   ME_String *eol_str;
  37   WCHAR cr_lf[] = {'\r','\n',0};
  38
  39   ME_InitContext(&c, editor, ITextHost_TxGetDC(editor->texthost));
  40
  41   hf = GetStockObject(SYSTEM_FONT);
  42   assert(hf);
  43   GetObjectW(hf, sizeof(LOGFONTW), &lf);
  44   ZeroMemory(&cf, sizeof(cf));
  45   cf.cbSize = sizeof(cf);
  46   cf.dwMask = CFM_BACKCOLOR|CFM_COLOR|CFM_FACE|CFM_SIZE|CFM_CHARSET;
  47   cf.dwMask |= CFM_ALLCAPS|CFM_BOLD|CFM_DISABLED|CFM_EMBOSS|CFM_HIDDEN;
  48   cf.dwMask |= CFM_IMPRINT|CFM_ITALIC|CFM_LINK|CFM_OUTLINE|CFM_PROTECTED;
  49   cf.dwMask |= CFM_REVISED|CFM_SHADOW|CFM_SMALLCAPS|CFM_STRIKEOUT;
  50   cf.dwMask |= CFM_SUBSCRIPT|CFM_UNDERLINETYPE|CFM_WEIGHT;
  51
  52   cf.dwEffects = CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR;
  53   lstrcpyW(cf.szFaceName, lf.lfFaceName);
  54   /* Convert system font height from logical units to twips for cf.yHeight */
  55   cf.yHeight = (lf.lfHeight * 72 * 1440) / (c.dpi.cy * c.dpi.cy);
  56   if (lf.lfWeight > FW_NORMAL) cf.dwEffects |= CFE_BOLD;
  57   cf.wWeight = lf.lfWeight;
  58   if (lf.lfItalic) cf.dwEffects |= CFE_ITALIC;
  59   cf.bUnderlineType = (lf.lfUnderline) ? CFU_CF1UNDERLINE : CFU_UNDERLINENONE;
  60   if (lf.lfStrikeOut) cf.dwEffects |= CFE_STRIKEOUT;
  61   cf.bPitchAndFamily = lf.lfPitchAndFamily;
  62   cf.bCharSet = lf.lfCharSet;
  63
  64   style = ME_MakeStyle(&cf);
  65   text->pDefaultStyle = style;
  66
  67   eol_str = ME_MakeStringN(cr_lf, editor->bEmulateVersion10 ? 2 : 1);
  68   run = ME_MakeRun(style, eol_str, MERF_ENDPARA);
  69   run->member.run.nCharOfs = 0;
  70
  71   ME_InsertBefore(text->pLast, para);
  72   ME_InsertBefore(text->pLast, run);
  73   para->member.para.prev_para = text->pFirst;
  74   para->member.para.next_para = text->pLast;
  75   text->pFirst->member.para.next_para = para;
  76   text->pLast->member.para.prev_para = para;
  77
  78   text->pLast->member.para.nCharOfs = editor->bEmulateVersion10 ? 2 : 1;
  79
  80   ME_DestroyContext(&c);
  81 }
  82
  83 static void ME_MarkForWrapping(ME_TextEditor *editor, ME_DisplayItem *first, const ME_DisplayItem *last)
  84 {
  85   while(first != last)
  86   {
  87     first->member.para.nFlags |= MEPF_REWRAP;
  88     first = first->member.para.next_para;
  89   }
  90 }
  91
  92 void ME_MarkAllForWrapping(ME_TextEditor *editor)
  93 {
  94   ME_MarkForWrapping(editor, editor->pBuffer->pFirst->member.para.next_para, editor->pBuffer->pLast);
  95 }
  96
  97 void ME_MarkForPainting(ME_TextEditor *editor, ME_DisplayItem *first, const ME_DisplayItem *last)
  98 {
  99   while(first != last && first)
 100   {
 101     first->member.para.nFlags |= MEPF_REPAINT;
 102     first = first->member.para.next_para;
 103   }
 104 }
 105
 106 static void ME_UpdateTableFlags(ME_DisplayItem *para)
 107 {
 108   para->member.para.pFmt->dwMask |= PFM_TABLE|PFM_TABLEROWDELIMITER;
 109   if (para->member.para.pCell) {
 110     para->member.para.nFlags |= MEPF_CELL;
 111   } else {
 112     para->member.para.nFlags &= ~MEPF_CELL;
 113   }
 114   if (para->member.para.nFlags & MEPF_ROWEND) {
 115     para->member.para.pFmt->wEffects |= PFE_TABLEROWDELIMITER;
 116   } else {
 117     para->member.para.pFmt->wEffects &= ~PFE_TABLEROWDELIMITER;
 118   }
 119   if (para->member.para.nFlags & (MEPF_ROWSTART|MEPF_CELL|MEPF_ROWEND))
 120     para->member.para.pFmt->wEffects |= PFE_TABLE;
 121   else
 122     para->member.para.pFmt->wEffects &= ~PFE_TABLE;
 123 }
 124
 125 static BOOL ME_SetParaFormat(ME_TextEditor *editor, ME_DisplayItem *para, const PARAFORMAT2 *pFmt)
 126 {
 127   PARAFORMAT2 copy;
 128   DWORD dwMask;
 129
 130   assert(para->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
 131   dwMask = pFmt->dwMask;
 132   if (pFmt->cbSize < sizeof(PARAFORMAT))
 133     return FALSE;
 134   else if (pFmt->cbSize < sizeof(PARAFORMAT2))
 135     dwMask &= PFM_ALL;
 136   else
 137     dwMask &= PFM_ALL2;
 138
 139   ME_AddUndoItem(editor, diUndoSetParagraphFormat, para);
 140
 141   copy = *para->member.para.pFmt;
 142
 143 #define COPY_FIELD(m, f) \
 144   if (dwMask & (m)) {                           \
 145     para->member.para.pFmt->dwMask |= m;        \
 146     para->member.para.pFmt->f = pFmt->f;        \
 147   }
 148
 149   COPY_FIELD(PFM_NUMBERING, wNumbering);
 150   COPY_FIELD(PFM_STARTINDENT, dxStartIndent);
 151   if (dwMask & PFM_OFFSETINDENT)
 152     para->member.para.pFmt->dxStartIndent += pFmt->dxStartIndent;
 153   COPY_FIELD(PFM_RIGHTINDENT, dxRightIndent);
 154   COPY_FIELD(PFM_OFFSET, dxOffset);
 155   COPY_FIELD(PFM_ALIGNMENT, wAlignment);
 156   if (dwMask & PFM_TABSTOPS)
 157   {
 158     para->member.para.pFmt->cTabCount = pFmt->cTabCount;
 159     memcpy(para->member.para.pFmt->rgxTabs, pFmt->rgxTabs, pFmt->cTabCount*sizeof(LONG));
 160   }
 161
 162   if (dwMask & (PFM_ALL2 & ~PFM_ALL))
 163   {
 164     /* PARAFORMAT2 fields */
 165
 166 #define EFFECTS_MASK (PFM_RTLPARA|PFM_KEEP|PFM_KEEPNEXT|PFM_PAGEBREAKBEFORE| \
 167                       PFM_NOLINENUMBER|PFM_NOWIDOWCONTROL|PFM_DONOTHYPHEN|PFM_SIDEBYSIDE| \
 168                       PFM_TABLE)
 169     /* we take for granted that PFE_xxx is the hiword of the corresponding PFM_xxx */
 170     if (dwMask & EFFECTS_MASK) {
 171       para->member.para.pFmt->dwMask |= dwMask & EFFECTS_MASK;
 172       para->member.para.pFmt->wEffects &= ~HIWORD(dwMask);
 173       para->member.para.pFmt->wEffects |= pFmt->wEffects & HIWORD(dwMask);
 174     }
 175 #undef EFFECTS_MASK
 176
 177     COPY_FIELD(PFM_SPACEBEFORE, dySpaceBefore);
 178     COPY_FIELD(PFM_SPACEAFTER, dySpaceAfter);
 179     COPY_FIELD(PFM_LINESPACING, dyLineSpacing);
 180     COPY_FIELD(PFM_STYLE, sStyle);
 181     COPY_FIELD(PFM_LINESPACING, bLineSpacingRule);
 182     COPY_FIELD(PFM_SHADING, wShadingWeight);
 183     COPY_FIELD(PFM_SHADING, wShadingStyle);
 184     COPY_FIELD(PFM_NUMBERINGSTART, wNumberingStart);
 185     COPY_FIELD(PFM_NUMBERINGSTYLE, wNumberingStyle);
 186     COPY_FIELD(PFM_NUMBERINGTAB, wNumberingTab);
 187     COPY_FIELD(PFM_BORDER, wBorderSpace);
 188     COPY_FIELD(PFM_BORDER, wBorderWidth);
 189     COPY_FIELD(PFM_BORDER, wBorders);
 190   }
 191
 192   para->member.para.pFmt->dwMask |= dwMask;
 193 #undef COPY_FIELD
 194
 195   if (memcmp(&copy, para->member.para.pFmt, sizeof(PARAFORMAT2)))
 196     para->member.para.nFlags |= MEPF_REWRAP;
 197
 198   return TRUE;
 199 }
 200
 201 /* split paragraph at the beginning of the run */
 202 ME_DisplayItem *ME_SplitParagraph(ME_TextEditor *editor, ME_DisplayItem *run,
 203                                   ME_Style *style, ME_String *eol_str,
 204                                   int paraFlags)
 205 {
 206   ME_DisplayItem *next_para = NULL;
 207   ME_DisplayItem *run_para = NULL;
 208   ME_DisplayItem *new_para = ME_MakeDI(diParagraph);
 209   ME_DisplayItem *end_run;
 210   ME_UndoItem *undo = NULL;
 211   int ofs, i;
 212   ME_DisplayItem *pp;
 213   int run_flags = MERF_ENDPARA;
 214
 215   if (!editor->bEmulateVersion10) { /* v4.1 */
 216     /* At most 1 of MEPF_CELL, MEPF_ROWSTART, or MEPF_ROWEND should be set. */
 217     assert(!(paraFlags & ~(MEPF_CELL|MEPF_ROWSTART|MEPF_ROWEND)));
 218     assert(!(paraFlags & (paraFlags-1)));
 219     if (paraFlags == MEPF_CELL)
 220       run_flags |= MERF_ENDCELL;
 221     else if (paraFlags == MEPF_ROWSTART)
 222       run_flags |= MERF_TABLESTART|MERF_HIDDEN;
 223   } else { /* v1.0 - v3.0 */
 224     assert(!(paraFlags & (MEPF_CELL|MEPF_ROWSTART|MEPF_ROWEND)));
 225   }
 226   end_run = ME_MakeRun(style, eol_str, run_flags);
 227
 228   assert(run->type == diRun);
 229   run_para = ME_GetParagraph(run);
 230   assert(run_para->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
 231
 232   ofs = end_run->member.run.nCharOfs = run->member.run.nCharOfs;
 233   next_para = run_para->member.para.next_para;
 234   assert(next_para == ME_FindItemFwd(run_para, diParagraphOrEnd));
 235
 236   undo = ME_AddUndoItem(editor, diUndoJoinParagraphs, NULL);
 237   if (undo)
 238     undo->nStart = run_para->member.para.nCharOfs + ofs;
 239
 240   /* Update selection cursors to point to the correct paragraph. */
 241   for (i = 0; i < editor->nCursors; i++) {
 242     if (editor->pCursors[i].pPara == run_para &&
 243         run->member.run.nCharOfs <= editor->pCursors[i].pRun->member.run.nCharOfs)
 244     {
 245       editor->pCursors[i].pPara = new_para;
 246     }
 247   }
 248
 249   /* the new paragraph will have a different starting offset, so let's update its runs */
 250   pp = run;
 251   while(pp->type == diRun) {
 252     pp->member.run.nCharOfs -= ofs;
 253     pp = ME_FindItemFwd(pp, diRunOrParagraphOrEnd);
 254   }
 255   new_para->member.para.nCharOfs = run_para->member.para.nCharOfs + ofs;
 256   new_para->member.para.nCharOfs += eol_str->nLen;
 257   new_para->member.para.nFlags = MEPF_REWRAP;
 258
 259   /* FIXME initialize format style and call ME_SetParaFormat blah blah */
 260   *new_para->member.para.pFmt = *run_para->member.para.pFmt;
 261   new_para->member.para.border = run_para->member.para.border;
 262
 263   /* insert paragraph into paragraph double linked list */
 264   new_para->member.para.prev_para = run_para;
 265   new_para->member.para.next_para = next_para;
 266   run_para->member.para.next_para = new_para;
 267   next_para->member.para.prev_para = new_para;
 268
 269   /* insert end run of the old paragraph, and new paragraph, into DI double linked list */
 270   ME_InsertBefore(run, new_para);
 271   ME_InsertBefore(new_para, end_run);
 272
 273   if (!editor->bEmulateVersion10) { /* v4.1 */
 274     if (paraFlags & (MEPF_ROWSTART|MEPF_CELL))
 275     {
 276       ME_DisplayItem *cell = ME_MakeDI(diCell);
 277       ME_InsertBefore(new_para, cell);
 278       new_para->member.para.pCell = cell;
 279       cell->member.cell.next_cell = NULL;
 280       if (paraFlags & MEPF_ROWSTART)
 281       {
 282         run_para->member.para.nFlags |= MEPF_ROWSTART;
 283         cell->member.cell.prev_cell = NULL;
 284         cell->member.cell.parent_cell = run_para->member.para.pCell;
 285         if (run_para->member.para.pCell)
 286           cell->member.cell.nNestingLevel = run_para->member.para.pCell->member.cell.nNestingLevel + 1;
 287         else
 288           cell->member.cell.nNestingLevel = 1;
 289       } else {
 290         cell->member.cell.prev_cell = run_para->member.para.pCell;
 291         assert(cell->member.cell.prev_cell);
 292         cell->member.cell.prev_cell->member.cell.next_cell = cell;
 293         assert(run_para->member.para.nFlags & MEPF_CELL);
 294         assert(!(run_para->member.para.nFlags & MEPF_ROWSTART));
 295         cell->member.cell.nNestingLevel = cell->member.cell.prev_cell->member.cell.nNestingLevel;
 296         cell->member.cell.parent_cell = cell->member.cell.prev_cell->member.cell.parent_cell;
 297       }
 298     } else if (paraFlags & MEPF_ROWEND) {
 299       run_para->member.para.nFlags |= MEPF_ROWEND;
 300       run_para->member.para.pCell = run_para->member.para.pCell->member.cell.parent_cell;
 301       new_para->member.para.pCell = run_para->member.para.pCell;
 302       assert(run_para->member.para.prev_para->member.para.nFlags & MEPF_CELL);
 303       assert(!(run_para->member.para.prev_para->member.para.nFlags & MEPF_ROWSTART));
 304       if (new_para->member.para.pCell != new_para->member.para.next_para->member.para.pCell
 305           && new_para->member.para.next_para->member.para.pCell
 306           && !new_para->member.para.next_para->member.para.pCell->member.cell.prev_cell)
 307       {
 308         /* Row starts just after the row that was ended. */
 309         new_para->member.para.nFlags |= MEPF_ROWSTART;
 310       }
 311     } else {
 312       new_para->member.para.pCell = run_para->member.para.pCell;
 313     }
 314     ME_UpdateTableFlags(run_para);
 315     ME_UpdateTableFlags(new_para);
 316   }
 317
 318   /* force rewrap of the */
 319   run_para->member.para.prev_para->member.para.nFlags |= MEPF_REWRAP;
 320   new_para->member.para.prev_para->member.para.nFlags |= MEPF_REWRAP;
 321
 322   /* we've added the end run, so we need to modify nCharOfs in the next paragraphs */
 323   ME_PropagateCharOffset(next_para, eol_str->nLen);
 324   editor->nParagraphs++;
 325
 326   return new_para;
 327 }
 328
 329 /* join tp with tp->member.para.next_para, keeping tp's style; this
 330  * is consistent with the original */
 331 ME_DisplayItem *ME_JoinParagraphs(ME_TextEditor *editor, ME_DisplayItem *tp,
 332                                   BOOL keepFirstParaFormat)
 333 {
 334   ME_DisplayItem *pNext, *pFirstRunInNext, *pRun, *pTmp;
 335   int i, shift;
 336   ME_UndoItem *undo = NULL;
 337   int end_len;
 338   CHARFORMAT2W fmt;
 339   ME_Cursor startCur, endCur;
 340
 341   assert(tp->type == diParagraph);
 342   assert(tp->member.para.next_para);
 343   assert(tp->member.para.next_para->type == diParagraph);
 344
 345   pNext = tp->member.para.next_para;
 346
 347   /* Need to locate end-of-paragraph run here, in order to know end_len */
 348   pRun = ME_FindItemBack(pNext, diRunOrParagraph);
 349
 350   assert(pRun);
 351   assert(pRun->type == diRun);
 352   assert(pRun->member.run.nFlags & MERF_ENDPARA);
 353
 354   end_len = pRun->member.run.strText->nLen;
 355
 356   /* null char format operation to store the original char format for the ENDPARA run */
 357   ME_InitCharFormat2W(&fmt);
 358   endCur.pPara = pNext;
 359   endCur.pRun = ME_FindItemFwd(pNext, diRun);
 360   endCur.nOffset = 0;
 361   startCur = endCur;
 362   ME_PrevRun(&startCur.pPara, &startCur.pRun);
 363   ME_SetCharFormat(editor, &startCur, &endCur, &fmt);
 364
 365   undo = ME_AddUndoItem(editor, diUndoSplitParagraph, pNext);
 366   if (undo)
 367   {
 368     undo->nStart = pNext->member.para.nCharOfs - end_len;
 369     undo->eol_str = pRun->member.run.strText;
 370     pRun->member.run.strText = NULL; /* Avoid freeing the string */
 371   }
 372   if (!keepFirstParaFormat)
 373   {
 374     ME_AddUndoItem(editor, diUndoSetParagraphFormat, tp);
 375     *tp->member.para.pFmt = *pNext->member.para.pFmt;
 376     tp->member.para.border = pNext->member.para.border;
 377   }
 378
 379   if (!editor->bEmulateVersion10) { /* v4.1 */
 380     /* Table cell/row properties are always moved over from the removed para. */
 381     tp->member.para.nFlags = pNext->member.para.nFlags;
 382     tp->member.para.pCell = pNext->member.para.pCell;
 383
 384     /* Remove cell boundary if it is between the end paragraph run and the next
 385      * paragraph display item. */
 386     pTmp = pRun->next;
 387     while (pTmp != pNext) {
 388       if (pTmp->type == diCell)
 389       {
 390         ME_Cell *pCell = &pTmp->member.cell;
 391         if (undo)
 392         {
 393           assert(!(undo->di.member.para.nFlags & MEPF_ROWEND));
 394           if (!(undo->di.member.para.nFlags & MEPF_ROWSTART))
 395             undo->di.member.para.nFlags |= MEPF_CELL;
 396           undo->di.member.para.pCell = ALLOC_OBJ(ME_DisplayItem);
 397           *undo->di.member.para.pCell = *pTmp;
 398           undo->di.member.para.pCell->next = NULL;
 399           undo->di.member.para.pCell->prev = NULL;
 400           undo->di.member.para.pCell->member.cell.next_cell = NULL;
 401           undo->di.member.para.pCell->member.cell.prev_cell = NULL;
 402         }
 403         ME_Remove(pTmp);
 404         if (pCell->prev_cell)
 405           pCell->prev_cell->member.cell.next_cell = pCell->next_cell;
 406         if (pCell->next_cell)
 407           pCell->next_cell->member.cell.prev_cell = pCell->prev_cell;
 408         ME_DestroyDisplayItem(pTmp);
 409         break;
 410       }
 411       pTmp = pTmp->next;
 412     }
 413   }
 414
 415   shift = pNext->member.para.nCharOfs - tp->member.para.nCharOfs - end_len;
 416
 417   pFirstRunInNext = ME_FindItemFwd(pNext, diRunOrParagraph);
 418
 419   assert(pFirstRunInNext->type == diRun);
 420
 421   /* Update selection cursors so they don't point to the removed end
 422    * paragraph run, and point to the correct paragraph. */
 423   for (i=0; i < editor->nCursors; i++) {
 424     if (editor->pCursors[i].pRun == pRun) {
 425       editor->pCursors[i].pRun = pFirstRunInNext;
 426       editor->pCursors[i].nOffset = 0;
 427     } else if (editor->pCursors[i].pPara == pNext) {
 428       editor->pCursors[i].pPara = tp;
 429     }
 430   }
 431
 432   pTmp = pNext;
 433   do {
 434     pTmp = ME_FindItemFwd(pTmp, diRunOrParagraphOrEnd);
 435     if (pTmp->type != diRun)
 436       break;
 437     TRACE("shifting \"%s\" by %d (previous %d)\n", debugstr_w(pTmp->member.run.strText->szData), shift, pTmp->member.run.nCharOfs);
 438     pTmp->member.run.nCharOfs += shift;
 439   } while(1);
 440
 441   ME_Remove(pRun);
 442   ME_DestroyDisplayItem(pRun);
 443
 444   if (editor->pLastSelStartPara == pNext)
 445     editor->pLastSelStartPara = tp;
 446   if (editor->pLastSelEndPara == pNext)
 447     editor->pLastSelEndPara = tp;
 448
 449   tp->member.para.next_para = pNext->member.para.next_para;
 450   pNext->member.para.next_para->member.para.prev_para = tp;
 451   ME_Remove(pNext);
 452   ME_DestroyDisplayItem(pNext);
 453
 454   ME_PropagateCharOffset(tp->member.para.next_para, -end_len);
 455
 456   ME_CheckCharOffsets(editor);
 457
 458   editor->nParagraphs--;
 459   tp->member.para.nFlags |= MEPF_REWRAP;
 460   return tp;
 461 }
 462
 463 ME_DisplayItem *ME_GetParagraph(ME_DisplayItem *item) {
 464   return ME_FindItemBackOrHere(item, diParagraph);
 465 }
 466
 467 void ME_DumpParaStyleToBuf(const PARAFORMAT2 *pFmt, char buf[2048])
 468 {
 469   char *p;
 470   p = buf;
 471
 472 #define DUMP(mask, name, fmt, field) \
 473   if (pFmt->dwMask & (mask)) p += sprintf(p, "%-22s" fmt "\n", name, pFmt->field); \
 474   else p += sprintf(p, "%-22sN/A\n", name);
 475
 476 /* we take for granted that PFE_xxx is the hiword of the corresponding PFM_xxx */
 477 #define DUMP_EFFECT(mask, name) \
 478   p += sprintf(p, "%-22s%s\n", name, (pFmt->dwMask & (mask)) ? ((pFmt->wEffects & ((mask) >> 8)) ? "yes" : "no") : "N/A");
 479
 480   DUMP(PFM_NUMBERING,      "Numbering:",         "%u", wNumbering);
 481   DUMP_EFFECT(PFM_DONOTHYPHEN,     "Disable auto-hyphen:");
 482   DUMP_EFFECT(PFM_KEEP,            "No page break in para:");
 483   DUMP_EFFECT(PFM_KEEPNEXT,        "No page break in para & next:");
 484   DUMP_EFFECT(PFM_NOLINENUMBER,    "No line number:");
 485   DUMP_EFFECT(PFM_NOWIDOWCONTROL,  "No widow & orphan:");
 486   DUMP_EFFECT(PFM_PAGEBREAKBEFORE, "Page break before:");
 487   DUMP_EFFECT(PFM_RTLPARA,         "RTL para:");
 488   DUMP_EFFECT(PFM_SIDEBYSIDE,      "Side by side:");
 489   DUMP_EFFECT(PFM_TABLE,           "Table:");
 490   DUMP(PFM_OFFSETINDENT,   "Offset indent:",     "%d", dxStartIndent);
 491   DUMP(PFM_STARTINDENT,    "Start indent:",      "%d", dxStartIndent);
 492   DUMP(PFM_RIGHTINDENT,    "Right indent:",      "%d", dxRightIndent);
 493   DUMP(PFM_OFFSET,         "Offset:",            "%d", dxOffset);
 494   if (pFmt->dwMask & PFM_ALIGNMENT) {
 495     switch (pFmt->wAlignment) {
 496     case PFA_LEFT   : p += sprintf(p, "Alignment:            left\n"); break;
 497     case PFA_RIGHT  : p += sprintf(p, "Alignment:            right\n"); break;
 498     case PFA_CENTER : p += sprintf(p, "Alignment:            center\n"); break;
 499     case PFA_JUSTIFY: p += sprintf(p, "Alignment:            justify\n"); break;
 500     default         : p += sprintf(p, "Alignment:            incorrect %d\n", pFmt->wAlignment); break;
 501     }
 502   }
 503   else p += sprintf(p, "Alignment:            N/A\n");
 504   DUMP(PFM_TABSTOPS,       "Tab Stops:",         "%d", cTabCount);
 505   if (pFmt->dwMask & PFM_TABSTOPS) {
 506     int i;
 507     p += sprintf(p, "\t");
 508     for (i = 0; i < pFmt->cTabCount; i++) p += sprintf(p, "%x ", pFmt->rgxTabs[i]);
 509     p += sprintf(p, "\n");
 510   }
 511   DUMP(PFM_SPACEBEFORE,    "Space Before:",      "%d", dySpaceBefore);
 512   DUMP(PFM_SPACEAFTER,     "Space After:",       "%d", dySpaceAfter);
 513   DUMP(PFM_LINESPACING,    "Line spacing:",      "%d", dyLineSpacing);
 514   DUMP(PFM_STYLE,          "Text style:",        "%d", sStyle);
 515   DUMP(PFM_LINESPACING,    "Line spacing rule:", "%u", bLineSpacingRule);
 516   /* bOutlineLevel should be 0 */
 517   DUMP(PFM_SHADING,        "Shading Weigth:",    "%u", wShadingWeight);
 518   DUMP(PFM_SHADING,        "Shading Style:",     "%u", wShadingStyle);
 519   DUMP(PFM_NUMBERINGSTART, "Numbering Start:",   "%u", wNumberingStart);
 520   DUMP(PFM_NUMBERINGSTYLE, "Numbering Style:",   "0x%x", wNumberingStyle);
 521   DUMP(PFM_NUMBERINGTAB,   "Numbering Tab:",     "%u", wNumberingStyle);
 522   DUMP(PFM_BORDER,         "Border Space:",      "%u", wBorderSpace);
 523   DUMP(PFM_BORDER,         "Border Width:",      "%u", wBorderWidth);
 524   DUMP(PFM_BORDER,         "Borders:",           "%u", wBorders);
 525
 526 #undef DUMP
 527 #undef DUMP_EFFECT
 528 }
 529
 530 void
 531 ME_GetSelectionParas(ME_TextEditor *editor, ME_DisplayItem **para, ME_DisplayItem **para_end)
 532 {
 533   ME_Cursor *pEndCursor = &editor->pCursors[1];
 534
 535   *para = editor->pCursors[0].pPara;
 536   *para_end = editor->pCursors[1].pPara;
 537   if (*para == *para_end)
 538     return;
 539
 540   if ((*para_end)->member.para.nCharOfs < (*para)->member.para.nCharOfs) {
 541     ME_DisplayItem *tmp = *para;
 542
 543     *para = *para_end;
 544     *para_end = tmp;
 545     pEndCursor = &editor->pCursors[0];
 546   }
 547
 548   /* The paragraph at the end of a non-empty selection isn't included
 549    * if the selection ends at the start of the paragraph. */
 550   if (!pEndCursor->pRun->member.run.nCharOfs && !pEndCursor->nOffset)
 551     *para_end = (*para_end)->member.para.prev_para;
 552 }
 553
 554
 555 BOOL ME_SetSelectionParaFormat(ME_TextEditor *editor, const PARAFORMAT2 *pFmt)
 556 {
 557   ME_DisplayItem *para, *para_end;
 558
 559   ME_GetSelectionParas(editor, &para, &para_end);
 560
 561   do {
 562     ME_SetParaFormat(editor, para, pFmt);
 563     if (para == para_end)
 564       break;
 565     para = para->member.para.next_para;
 566   } while(1);
 567
 568   return TRUE;
 569 }
 570
 571 static void ME_GetParaFormat(ME_TextEditor *editor,
 572                              const ME_DisplayItem *para,
 573                              PARAFORMAT2 *pFmt)
 574 {
 575   UINT cbSize = pFmt->cbSize;
 576   if (pFmt->cbSize >= sizeof(PARAFORMAT2)) {
 577     *pFmt = *para->member.para.pFmt;
 578   } else {
 579     CopyMemory(pFmt, para->member.para.pFmt, pFmt->cbSize);
 580     pFmt->dwMask &= PFM_ALL;
 581   }
 582   pFmt->cbSize = cbSize;
 583 }
 584
 585 void ME_GetSelectionParaFormat(ME_TextEditor *editor, PARAFORMAT2 *pFmt)
 586 {
 587   ME_DisplayItem *para, *para_end;
 588   PARAFORMAT2 *curFmt;
 589
 590   if (pFmt->cbSize < sizeof(PARAFORMAT)) {
 591     pFmt->dwMask = 0;
 592     return;
 593   }
 594
 595   ME_GetSelectionParas(editor, &para, &para_end);
 596
 597   ME_GetParaFormat(editor, para, pFmt);
 598
 599   /* Invalidate values that change across the selected paragraphs. */
 600   while (para != para_end)
 601   {
 602     para = para->member.para.next_para;
 603     curFmt = para->member.para.pFmt;
 604
 605 #define CHECK_FIELD(m, f) \
 606     if (pFmt->f != curFmt->f) pFmt->dwMask &= ~(m);
 607
 608     CHECK_FIELD(PFM_NUMBERING, wNumbering);
 609     CHECK_FIELD(PFM_STARTINDENT, dxStartIndent);
 610     CHECK_FIELD(PFM_RIGHTINDENT, dxRightIndent);
 611     CHECK_FIELD(PFM_OFFSET, dxOffset);
 612     CHECK_FIELD(PFM_ALIGNMENT, wAlignment);
 613     if (pFmt->dwMask & PFM_TABSTOPS) {
 614       if (pFmt->cTabCount != para->member.para.pFmt->cTabCount ||
 615           memcmp(pFmt->rgxTabs, curFmt->rgxTabs, curFmt->cTabCount*sizeof(int)))
 616         pFmt->dwMask &= ~PFM_TABSTOPS;
 617     }
 618
 619     if (pFmt->dwMask >= sizeof(PARAFORMAT2))
 620     {
 621       pFmt->dwMask &= ~((pFmt->wEffects ^ curFmt->wEffects) << 16);
 622       CHECK_FIELD(PFM_SPACEBEFORE, dySpaceBefore);
 623       CHECK_FIELD(PFM_SPACEAFTER, dySpaceAfter);
 624       CHECK_FIELD(PFM_LINESPACING, dyLineSpacing);
 625       CHECK_FIELD(PFM_STYLE, sStyle);
 626       CHECK_FIELD(PFM_SPACEAFTER, bLineSpacingRule);
 627       CHECK_FIELD(PFM_SHADING, wShadingWeight);
 628       CHECK_FIELD(PFM_SHADING, wShadingStyle);
 629       CHECK_FIELD(PFM_NUMBERINGSTART, wNumberingStart);
 630       CHECK_FIELD(PFM_NUMBERINGSTYLE, wNumberingStyle);
 631       CHECK_FIELD(PFM_NUMBERINGTAB, wNumberingTab);
 632       CHECK_FIELD(PFM_BORDER, wBorderSpace);
 633       CHECK_FIELD(PFM_BORDER, wBorderWidth);
 634       CHECK_FIELD(PFM_BORDER, wBorders);
 635     }
 636 #undef CHECK_FIELD
 637   }
 638 }
 639
 640 void ME_SetDefaultParaFormat(PARAFORMAT2 *pFmt)
 641 {
 642     ZeroMemory(pFmt, sizeof(PARAFORMAT2));
 643     pFmt->cbSize = sizeof(PARAFORMAT2);
 644     pFmt->dwMask = PFM_ALL2;
 645     pFmt->wAlignment = PFA_LEFT;
 646     pFmt->sStyle = -1;
 647     pFmt->bOutlineLevel = TRUE;
 648 }