reactos/dll/win32/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   int eol_len;
  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_len = editor->bEmulateVersion10 ? 2 : 1;
  68   para->member.para.text = ME_MakeStringN( cr_lf, eol_len );
  69
  70   run = ME_MakeRun(style, MERF_ENDPARA);
  71   run->member.run.nCharOfs = 0;
  72   run->member.run.len = eol_len;
  73   run->member.run.para = &para->member.para;
  74
  75   ME_InsertBefore(text->pLast, para);
  76   ME_InsertBefore(text->pLast, run);
  77   para->member.para.prev_para = text->pFirst;
  78   para->member.para.next_para = text->pLast;
  79   text->pFirst->member.para.next_para = para;
  80   text->pLast->member.para.prev_para = para;
  81
  82   text->pLast->member.para.nCharOfs = editor->bEmulateVersion10 ? 2 : 1;
  83
  84   ME_DestroyContext(&c);
  85 }
  86
  87 static void ME_MarkForWrapping(ME_TextEditor *editor, ME_DisplayItem *first, const ME_DisplayItem *last)
  88 {
  89   while(first != last)
  90   {
  91     first->member.para.nFlags |= MEPF_REWRAP;
  92     first = first->member.para.next_para;
  93   }
  94 }
  95
  96 void ME_MarkAllForWrapping(ME_TextEditor *editor)
  97 {
  98   ME_MarkForWrapping(editor, editor->pBuffer->pFirst->member.para.next_para, editor->pBuffer->pLast);
  99 }
 100
 101 static void ME_UpdateTableFlags(ME_DisplayItem *para)
 102 {
 103   para->member.para.pFmt->dwMask |= PFM_TABLE|PFM_TABLEROWDELIMITER;
 104   if (para->member.para.pCell) {
 105     para->member.para.nFlags |= MEPF_CELL;
 106   } else {
 107     para->member.para.nFlags &= ~MEPF_CELL;
 108   }
 109   if (para->member.para.nFlags & MEPF_ROWEND) {
 110     para->member.para.pFmt->wEffects |= PFE_TABLEROWDELIMITER;
 111   } else {
 112     para->member.para.pFmt->wEffects &= ~PFE_TABLEROWDELIMITER;
 113   }
 114   if (para->member.para.nFlags & (MEPF_ROWSTART|MEPF_CELL|MEPF_ROWEND))
 115     para->member.para.pFmt->wEffects |= PFE_TABLE;
 116   else
 117     para->member.para.pFmt->wEffects &= ~PFE_TABLE;
 118 }
 119
 120 static BOOL ME_SetParaFormat(ME_TextEditor *editor, ME_DisplayItem *para, const PARAFORMAT2 *pFmt)
 121 {
 122   PARAFORMAT2 copy;
 123   DWORD dwMask;
 124
 125   assert(para->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
 126   dwMask = pFmt->dwMask;
 127   if (pFmt->cbSize < sizeof(PARAFORMAT))
 128     return FALSE;
 129   else if (pFmt->cbSize < sizeof(PARAFORMAT2))
 130     dwMask &= PFM_ALL;
 131   else
 132     dwMask &= PFM_ALL2;
 133
 134   add_undo_set_para_fmt( editor, &para->member.para );
 135
 136   copy = *para->member.para.pFmt;
 137
 138 #define COPY_FIELD(m, f) \
 139   if (dwMask & (m)) {                           \
 140     para->member.para.pFmt->dwMask |= m;        \
 141     para->member.para.pFmt->f = pFmt->f;        \
 142   }
 143
 144   COPY_FIELD(PFM_NUMBERING, wNumbering);
 145   COPY_FIELD(PFM_STARTINDENT, dxStartIndent);
 146   if (dwMask & PFM_OFFSETINDENT)
 147     para->member.para.pFmt->dxStartIndent += pFmt->dxStartIndent;
 148   COPY_FIELD(PFM_RIGHTINDENT, dxRightIndent);
 149   COPY_FIELD(PFM_OFFSET, dxOffset);
 150   COPY_FIELD(PFM_ALIGNMENT, wAlignment);
 151   if (dwMask & PFM_TABSTOPS)
 152   {
 153     para->member.para.pFmt->cTabCount = pFmt->cTabCount;
 154     memcpy(para->member.para.pFmt->rgxTabs, pFmt->rgxTabs, pFmt->cTabCount*sizeof(LONG));
 155   }
 156
 157 #define EFFECTS_MASK (PFM_RTLPARA|PFM_KEEP|PFM_KEEPNEXT|PFM_PAGEBREAKBEFORE| \
 158                       PFM_NOLINENUMBER|PFM_NOWIDOWCONTROL|PFM_DONOTHYPHEN|PFM_SIDEBYSIDE| \
 159                       PFM_TABLE)
 160   /* we take for granted that PFE_xxx is the hiword of the corresponding PFM_xxx */
 161   if (dwMask & EFFECTS_MASK)
 162   {
 163     para->member.para.pFmt->dwMask |= dwMask & EFFECTS_MASK;
 164     para->member.para.pFmt->wEffects &= ~HIWORD(dwMask);
 165     para->member.para.pFmt->wEffects |= pFmt->wEffects & HIWORD(dwMask);
 166   }
 167 #undef EFFECTS_MASK
 168
 169   COPY_FIELD(PFM_SPACEBEFORE, dySpaceBefore);
 170   COPY_FIELD(PFM_SPACEAFTER, dySpaceAfter);
 171   COPY_FIELD(PFM_LINESPACING, dyLineSpacing);
 172   COPY_FIELD(PFM_STYLE, sStyle);
 173   COPY_FIELD(PFM_LINESPACING, bLineSpacingRule);
 174   COPY_FIELD(PFM_SHADING, wShadingWeight);
 175   COPY_FIELD(PFM_SHADING, wShadingStyle);
 176   COPY_FIELD(PFM_NUMBERINGSTART, wNumberingStart);
 177   COPY_FIELD(PFM_NUMBERINGSTYLE, wNumberingStyle);
 178   COPY_FIELD(PFM_NUMBERINGTAB, wNumberingTab);
 179   COPY_FIELD(PFM_BORDER, wBorderSpace);
 180   COPY_FIELD(PFM_BORDER, wBorderWidth);
 181   COPY_FIELD(PFM_BORDER, wBorders);
 182
 183   para->member.para.pFmt->dwMask |= dwMask;
 184 #undef COPY_FIELD
 185
 186   if (memcmp(&copy, para->member.para.pFmt, sizeof(PARAFORMAT2)))
 187     para->member.para.nFlags |= MEPF_REWRAP;
 188
 189   return TRUE;
 190 }
 191
 192 /* split paragraph at the beginning of the run */
 193 ME_DisplayItem *ME_SplitParagraph(ME_TextEditor *editor, ME_DisplayItem *run,
 194                                   ME_Style *style, const WCHAR *eol_str, int eol_len,
 195                                   int paraFlags)
 196 {
 197   ME_DisplayItem *next_para = NULL;
 198   ME_DisplayItem *run_para = NULL;
 199   ME_DisplayItem *new_para = ME_MakeDI(diParagraph);
 200   ME_DisplayItem *end_run;
 201   int ofs, i;
 202   ME_DisplayItem *pp;
 203   int run_flags = MERF_ENDPARA;
 204
 205   if (!editor->bEmulateVersion10) { /* v4.1 */
 206     /* At most 1 of MEPF_CELL, MEPF_ROWSTART, or MEPF_ROWEND should be set. */
 207     assert(!(paraFlags & ~(MEPF_CELL|MEPF_ROWSTART|MEPF_ROWEND)));
 208     assert(!(paraFlags & (paraFlags-1)));
 209     if (paraFlags == MEPF_CELL)
 210       run_flags |= MERF_ENDCELL;
 211     else if (paraFlags == MEPF_ROWSTART)
 212       run_flags |= MERF_TABLESTART|MERF_HIDDEN;
 213   } else { /* v1.0 - v3.0 */
 214     assert(!(paraFlags & (MEPF_CELL|MEPF_ROWSTART|MEPF_ROWEND)));
 215   }
 216   assert(run->type == diRun);
 217   run_para = ME_GetParagraph(run);
 218   assert(run_para->member.para.pFmt->cbSize == sizeof(PARAFORMAT2));
 219
 220   new_para->member.para.text = ME_VSplitString( run_para->member.para.text, run->member.run.nCharOfs );
 221
 222   end_run = ME_MakeRun(style, run_flags);
 223   ofs = end_run->member.run.nCharOfs = run->member.run.nCharOfs;
 224   end_run->member.run.len = eol_len;
 225   end_run->member.run.para = run->member.run.para;
 226   ME_AppendString( run_para->member.para.text, eol_str, eol_len );
 227   next_para = run_para->member.para.next_para;
 228   assert(next_para == ME_FindItemFwd(run_para, diParagraphOrEnd));
 229
 230   add_undo_join_paras( editor, run_para->member.para.nCharOfs + ofs );
 231
 232   /* Update selection cursors to point to the correct paragraph. */
 233   for (i = 0; i < editor->nCursors; i++) {
 234     if (editor->pCursors[i].pPara == run_para &&
 235         run->member.run.nCharOfs <= editor->pCursors[i].pRun->member.run.nCharOfs)
 236     {
 237       editor->pCursors[i].pPara = new_para;
 238     }
 239   }
 240
 241   /* the new paragraph will have a different starting offset, so let's update its runs */
 242   pp = run;
 243   while(pp->type == diRun) {
 244     pp->member.run.nCharOfs -= ofs;
 245     pp->member.run.para = &new_para->member.para;
 246     pp = ME_FindItemFwd(pp, diRunOrParagraphOrEnd);
 247   }
 248   new_para->member.para.nCharOfs = run_para->member.para.nCharOfs + ofs;
 249   new_para->member.para.nCharOfs += eol_len;
 250   new_para->member.para.nFlags = MEPF_REWRAP;
 251
 252   /* FIXME initialize format style and call ME_SetParaFormat blah blah */
 253   *new_para->member.para.pFmt = *run_para->member.para.pFmt;
 254   new_para->member.para.border = run_para->member.para.border;
 255
 256   /* insert paragraph into paragraph double linked list */
 257   new_para->member.para.prev_para = run_para;
 258   new_para->member.para.next_para = next_para;
 259   run_para->member.para.next_para = new_para;
 260   next_para->member.para.prev_para = new_para;
 261
 262   /* insert end run of the old paragraph, and new paragraph, into DI double linked list */
 263   ME_InsertBefore(run, new_para);
 264   ME_InsertBefore(new_para, end_run);
 265
 266   if (!editor->bEmulateVersion10) { /* v4.1 */
 267     if (paraFlags & (MEPF_ROWSTART|MEPF_CELL))
 268     {
 269       ME_DisplayItem *cell = ME_MakeDI(diCell);
 270       ME_InsertBefore(new_para, cell);
 271       new_para->member.para.pCell = cell;
 272       cell->member.cell.next_cell = NULL;
 273       if (paraFlags & MEPF_ROWSTART)
 274       {
 275         run_para->member.para.nFlags |= MEPF_ROWSTART;
 276         cell->member.cell.prev_cell = NULL;
 277         cell->member.cell.parent_cell = run_para->member.para.pCell;
 278         if (run_para->member.para.pCell)
 279           cell->member.cell.nNestingLevel = run_para->member.para.pCell->member.cell.nNestingLevel + 1;
 280         else
 281           cell->member.cell.nNestingLevel = 1;
 282       } else {
 283         cell->member.cell.prev_cell = run_para->member.para.pCell;
 284         assert(cell->member.cell.prev_cell);
 285         cell->member.cell.prev_cell->member.cell.next_cell = cell;
 286         assert(run_para->member.para.nFlags & MEPF_CELL);
 287         assert(!(run_para->member.para.nFlags & MEPF_ROWSTART));
 288         cell->member.cell.nNestingLevel = cell->member.cell.prev_cell->member.cell.nNestingLevel;
 289         cell->member.cell.parent_cell = cell->member.cell.prev_cell->member.cell.parent_cell;
 290       }
 291     } else if (paraFlags & MEPF_ROWEND) {
 292       run_para->member.para.nFlags |= MEPF_ROWEND;
 293       run_para->member.para.pCell = run_para->member.para.pCell->member.cell.parent_cell;
 294       new_para->member.para.pCell = run_para->member.para.pCell;
 295       assert(run_para->member.para.prev_para->member.para.nFlags & MEPF_CELL);
 296       assert(!(run_para->member.para.prev_para->member.para.nFlags & MEPF_ROWSTART));
 297       if (new_para->member.para.pCell != new_para->member.para.next_para->member.para.pCell
 298           && new_para->member.para.next_para->member.para.pCell
 299           && !new_para->member.para.next_para->member.para.pCell->member.cell.prev_cell)
 300       {
 301         /* Row starts just after the row that was ended. */
 302         new_para->member.para.nFlags |= MEPF_ROWSTART;
 303       }
 304     } else {
 305       new_para->member.para.pCell = run_para->member.para.pCell;
 306     }
 307     ME_UpdateTableFlags(run_para);
 308     ME_UpdateTableFlags(new_para);
 309   }
 310
 311   /* force rewrap of the */
 312   run_para->member.para.prev_para->member.para.nFlags |= MEPF_REWRAP;
 313   new_para->member.para.prev_para->member.para.nFlags |= MEPF_REWRAP;
 314
 315   /* we've added the end run, so we need to modify nCharOfs in the next paragraphs */
 316   ME_PropagateCharOffset(next_para, eol_len);
 317   editor->nParagraphs++;
 318
 319   return new_para;
 320 }
 321
 322 /* join tp with tp->member.para.next_para, keeping tp's style; this
 323  * is consistent with the original */
 324 ME_DisplayItem *ME_JoinParagraphs(ME_TextEditor *editor, ME_DisplayItem *tp,
 325                                   BOOL keepFirstParaFormat)
 326 {
 327   ME_DisplayItem *pNext, *pFirstRunInNext, *pRun, *pTmp, *pCell = NULL;
 328   int i, shift;
 329   int end_len;
 330   CHARFORMAT2W fmt;
 331   ME_Cursor startCur, endCur;
 332   ME_String *eol_str;
 333
 334   assert(tp->type == diParagraph);
 335   assert(tp->member.para.next_para);
 336   assert(tp->member.para.next_para->type == diParagraph);
 337
 338   pNext = tp->member.para.next_para;
 339
 340   /* Need to locate end-of-paragraph run here, in order to know end_len */
 341   pRun = ME_FindItemBack(pNext, diRunOrParagraph);
 342
 343   assert(pRun);
 344   assert(pRun->type == diRun);
 345   assert(pRun->member.run.nFlags & MERF_ENDPARA);
 346
 347   end_len = pRun->member.run.len;
 348   eol_str = ME_VSplitString( tp->member.para.text, pRun->member.run.nCharOfs );
 349   ME_AppendString( tp->member.para.text, pNext->member.para.text->szData, pNext->member.para.text->nLen );
 350
 351   /* null char format operation to store the original char format for the ENDPARA run */
 352   ME_InitCharFormat2W(&fmt);
 353   endCur.pPara = pNext;
 354   endCur.pRun = ME_FindItemFwd(pNext, diRun);
 355   endCur.nOffset = 0;
 356   startCur = endCur;
 357   ME_PrevRun(&startCur.pPara, &startCur.pRun);
 358   ME_SetCharFormat(editor, &startCur, &endCur, &fmt);
 359
 360   if (!editor->bEmulateVersion10) { /* v4.1 */
 361     /* Table cell/row properties are always moved over from the removed para. */
 362     tp->member.para.nFlags = pNext->member.para.nFlags;
 363     tp->member.para.pCell = pNext->member.para.pCell;
 364
 365     /* Remove cell boundary if it is between the end paragraph run and the next
 366      * paragraph display item. */
 367     for (pTmp = pRun->next; pTmp != pNext; pTmp = pTmp->next)
 368     {
 369       if (pTmp->type == diCell)
 370       {
 371         pCell = pTmp;
 372         break;
 373       }
 374     }
 375   }
 376
 377   add_undo_split_para( editor, &pNext->member.para, eol_str, pCell ? &pCell->member.cell : NULL );
 378
 379   if (pCell)
 380   {
 381     ME_Remove( pCell );
 382     if (pCell->member.cell.prev_cell)
 383       pCell->member.cell.prev_cell->member.cell.next_cell = pCell->member.cell.next_cell;
 384     if (pCell->member.cell.next_cell)
 385       pCell->member.cell.next_cell->member.cell.prev_cell = pCell->member.cell.prev_cell;
 386     ME_DestroyDisplayItem( pCell );
 387   }
 388
 389   if (!keepFirstParaFormat)
 390   {
 391     add_undo_set_para_fmt( editor, &tp->member.para );
 392     *tp->member.para.pFmt = *pNext->member.para.pFmt;
 393     tp->member.para.border = pNext->member.para.border;
 394   }
 395
 396   shift = pNext->member.para.nCharOfs - tp->member.para.nCharOfs - end_len;
 397
 398   pFirstRunInNext = ME_FindItemFwd(pNext, diRunOrParagraph);
 399
 400   assert(pFirstRunInNext->type == diRun);
 401
 402   /* Update selection cursors so they don't point to the removed end
 403    * paragraph run, and point to the correct paragraph. */
 404   for (i=0; i < editor->nCursors; i++) {
 405     if (editor->pCursors[i].pRun == pRun) {
 406       editor->pCursors[i].pRun = pFirstRunInNext;
 407       editor->pCursors[i].nOffset = 0;
 408     } else if (editor->pCursors[i].pPara == pNext) {
 409       editor->pCursors[i].pPara = tp;
 410     }
 411   }
 412
 413   pTmp = pNext;
 414   do {
 415     pTmp = ME_FindItemFwd(pTmp, diRunOrParagraphOrEnd);
 416     if (pTmp->type != diRun)
 417       break;
 418     TRACE("shifting %s by %d (previous %d)\n", debugstr_run( &pTmp->member.run ), shift, pTmp->member.run.nCharOfs);
 419     pTmp->member.run.nCharOfs += shift;
 420     pTmp->member.run.para = &tp->member.para;
 421   } while(1);
 422
 423   ME_Remove(pRun);
 424   ME_DestroyDisplayItem(pRun);
 425
 426   if (editor->pLastSelStartPara == pNext)
 427     editor->pLastSelStartPara = tp;
 428   if (editor->pLastSelEndPara == pNext)
 429     editor->pLastSelEndPara = tp;
 430
 431   tp->member.para.next_para = pNext->member.para.next_para;
 432   pNext->member.para.next_para->member.para.prev_para = tp;
 433   ME_Remove(pNext);
 434   ME_DestroyDisplayItem(pNext);
 435
 436   ME_PropagateCharOffset(tp->member.para.next_para, -end_len);
 437
 438   ME_CheckCharOffsets(editor);
 439
 440   editor->nParagraphs--;
 441   tp->member.para.nFlags |= MEPF_REWRAP;
 442   return tp;
 443 }
 444
 445 ME_DisplayItem *ME_GetParagraph(ME_DisplayItem *item) {
 446   return ME_FindItemBackOrHere(item, diParagraph);
 447 }
 448
 449 void ME_DumpParaStyleToBuf(const PARAFORMAT2 *pFmt, char buf[2048])
 450 {
 451   char *p;
 452   p = buf;
 453
 454 #define DUMP(mask, name, fmt, field) \
 455   if (pFmt->dwMask & (mask)) p += sprintf(p, "%-22s" fmt "\n", name, pFmt->field); \
 456   else p += sprintf(p, "%-22sN/A\n", name);
 457
 458 /* we take for granted that PFE_xxx is the hiword of the corresponding PFM_xxx */
 459 #define DUMP_EFFECT(mask, name) \
 460   p += sprintf(p, "%-22s%s\n", name, (pFmt->dwMask & (mask)) ? ((pFmt->wEffects & ((mask) >> 16)) ? "yes" : "no") : "N/A");
 461
 462   DUMP(PFM_NUMBERING,      "Numbering:",         "%u", wNumbering);
 463   DUMP_EFFECT(PFM_DONOTHYPHEN,     "Disable auto-hyphen:");
 464   DUMP_EFFECT(PFM_KEEP,            "No page break in para:");
 465   DUMP_EFFECT(PFM_KEEPNEXT,        "No page break in para & next:");
 466   DUMP_EFFECT(PFM_NOLINENUMBER,    "No line number:");
 467   DUMP_EFFECT(PFM_NOWIDOWCONTROL,  "No widow & orphan:");
 468   DUMP_EFFECT(PFM_PAGEBREAKBEFORE, "Page break before:");
 469   DUMP_EFFECT(PFM_RTLPARA,         "RTL para:");
 470   DUMP_EFFECT(PFM_SIDEBYSIDE,      "Side by side:");
 471   DUMP_EFFECT(PFM_TABLE,           "Table:");
 472   DUMP(PFM_OFFSETINDENT,   "Offset indent:",     "%d", dxStartIndent);
 473   DUMP(PFM_STARTINDENT,    "Start indent:",      "%d", dxStartIndent);
 474   DUMP(PFM_RIGHTINDENT,    "Right indent:",      "%d", dxRightIndent);
 475   DUMP(PFM_OFFSET,         "Offset:",            "%d", dxOffset);
 476   if (pFmt->dwMask & PFM_ALIGNMENT) {
 477     switch (pFmt->wAlignment) {
 478     case PFA_LEFT   : p += sprintf(p, "Alignment:            left\n"); break;
 479     case PFA_RIGHT  : p += sprintf(p, "Alignment:            right\n"); break;
 480     case PFA_CENTER : p += sprintf(p, "Alignment:            center\n"); break;
 481     case PFA_JUSTIFY: p += sprintf(p, "Alignment:            justify\n"); break;
 482     default         : p += sprintf(p, "Alignment:            incorrect %d\n", pFmt->wAlignment); break;
 483     }
 484   }
 485   else p += sprintf(p, "Alignment:            N/A\n");
 486   DUMP(PFM_TABSTOPS,       "Tab Stops:",         "%d", cTabCount);
 487   if (pFmt->dwMask & PFM_TABSTOPS) {
 488     int i;
 489     p += sprintf(p, "\t");
 490     for (i = 0; i < pFmt->cTabCount; i++) p += sprintf(p, "%x ", pFmt->rgxTabs[i]);
 491     p += sprintf(p, "\n");
 492   }
 493   DUMP(PFM_SPACEBEFORE,    "Space Before:",      "%d", dySpaceBefore);
 494   DUMP(PFM_SPACEAFTER,     "Space After:",       "%d", dySpaceAfter);
 495   DUMP(PFM_LINESPACING,    "Line spacing:",      "%d", dyLineSpacing);
 496   DUMP(PFM_STYLE,          "Text style:",        "%d", sStyle);
 497   DUMP(PFM_LINESPACING,    "Line spacing rule:", "%u", bLineSpacingRule);
 498   /* bOutlineLevel should be 0 */
 499   DUMP(PFM_SHADING,        "Shading Weigth:",    "%u", wShadingWeight);
 500   DUMP(PFM_SHADING,        "Shading Style:",     "%u", wShadingStyle);
 501   DUMP(PFM_NUMBERINGSTART, "Numbering Start:",   "%u", wNumberingStart);
 502   DUMP(PFM_NUMBERINGSTYLE, "Numbering Style:",   "0x%x", wNumberingStyle);
 503   DUMP(PFM_NUMBERINGTAB,   "Numbering Tab:",     "%u", wNumberingStyle);
 504   DUMP(PFM_BORDER,         "Border Space:",      "%u", wBorderSpace);
 505   DUMP(PFM_BORDER,         "Border Width:",      "%u", wBorderWidth);
 506   DUMP(PFM_BORDER,         "Borders:",           "%u", wBorders);
 507
 508 #undef DUMP
 509 #undef DUMP_EFFECT
 510 }
 511
 512 void
 513 ME_GetSelectionParas(ME_TextEditor *editor, ME_DisplayItem **para, ME_DisplayItem **para_end)
 514 {
 515   ME_Cursor *pEndCursor = &editor->pCursors[1];
 516
 517   *para = editor->pCursors[0].pPara;
 518   *para_end = editor->pCursors[1].pPara;
 519   if (*para == *para_end)
 520     return;
 521
 522   if ((*para_end)->member.para.nCharOfs < (*para)->member.para.nCharOfs) {
 523     ME_DisplayItem *tmp = *para;
 524
 525     *para = *para_end;
 526     *para_end = tmp;
 527     pEndCursor = &editor->pCursors[0];
 528   }
 529
 530   /* The paragraph at the end of a non-empty selection isn't included
 531    * if the selection ends at the start of the paragraph. */
 532   if (!pEndCursor->pRun->member.run.nCharOfs && !pEndCursor->nOffset)
 533     *para_end = (*para_end)->member.para.prev_para;
 534 }
 535
 536
 537 BOOL ME_SetSelectionParaFormat(ME_TextEditor *editor, const PARAFORMAT2 *pFmt)
 538 {
 539   ME_DisplayItem *para, *para_end;
 540
 541   ME_GetSelectionParas(editor, &para, &para_end);
 542
 543   do {
 544     ME_SetParaFormat(editor, para, pFmt);
 545     if (para == para_end)
 546       break;
 547     para = para->member.para.next_para;
 548   } while(1);
 549
 550   return TRUE;
 551 }
 552
 553 static void ME_GetParaFormat(ME_TextEditor *editor,
 554                              const ME_DisplayItem *para,
 555                              PARAFORMAT2 *pFmt)
 556 {
 557   UINT cbSize = pFmt->cbSize;
 558   if (pFmt->cbSize >= sizeof(PARAFORMAT2)) {
 559     *pFmt = *para->member.para.pFmt;
 560   } else {
 561     CopyMemory(pFmt, para->member.para.pFmt, pFmt->cbSize);
 562     pFmt->dwMask &= PFM_ALL;
 563   }
 564   pFmt->cbSize = cbSize;
 565 }
 566
 567 void ME_GetSelectionParaFormat(ME_TextEditor *editor, PARAFORMAT2 *pFmt)
 568 {
 569   ME_DisplayItem *para, *para_end;
 570   PARAFORMAT2 *curFmt;
 571
 572   if (pFmt->cbSize < sizeof(PARAFORMAT)) {
 573     pFmt->dwMask = 0;
 574     return;
 575   }
 576
 577   ME_GetSelectionParas(editor, &para, &para_end);
 578
 579   ME_GetParaFormat(editor, para, pFmt);
 580
 581   /* Invalidate values that change across the selected paragraphs. */
 582   while (para != para_end)
 583   {
 584     para = para->member.para.next_para;
 585     curFmt = para->member.para.pFmt;
 586
 587 #define CHECK_FIELD(m, f) \
 588     if (pFmt->f != curFmt->f) pFmt->dwMask &= ~(m);
 589
 590     CHECK_FIELD(PFM_NUMBERING, wNumbering);
 591     CHECK_FIELD(PFM_STARTINDENT, dxStartIndent);
 592     CHECK_FIELD(PFM_RIGHTINDENT, dxRightIndent);
 593     CHECK_FIELD(PFM_OFFSET, dxOffset);
 594     CHECK_FIELD(PFM_ALIGNMENT, wAlignment);
 595     if (pFmt->dwMask & PFM_TABSTOPS) {
 596       if (pFmt->cTabCount != para->member.para.pFmt->cTabCount ||
 597           memcmp(pFmt->rgxTabs, curFmt->rgxTabs, curFmt->cTabCount*sizeof(int)))
 598         pFmt->dwMask &= ~PFM_TABSTOPS;
 599     }
 600
 601     if (pFmt->dwMask >= sizeof(PARAFORMAT2))
 602     {
 603       pFmt->dwMask &= ~((pFmt->wEffects ^ curFmt->wEffects) << 16);
 604       CHECK_FIELD(PFM_SPACEBEFORE, dySpaceBefore);
 605       CHECK_FIELD(PFM_SPACEAFTER, dySpaceAfter);
 606       CHECK_FIELD(PFM_LINESPACING, dyLineSpacing);
 607       CHECK_FIELD(PFM_STYLE, sStyle);
 608       CHECK_FIELD(PFM_SPACEAFTER, bLineSpacingRule);
 609       CHECK_FIELD(PFM_SHADING, wShadingWeight);
 610       CHECK_FIELD(PFM_SHADING, wShadingStyle);
 611       CHECK_FIELD(PFM_NUMBERINGSTART, wNumberingStart);
 612       CHECK_FIELD(PFM_NUMBERINGSTYLE, wNumberingStyle);
 613       CHECK_FIELD(PFM_NUMBERINGTAB, wNumberingTab);
 614       CHECK_FIELD(PFM_BORDER, wBorderSpace);
 615       CHECK_FIELD(PFM_BORDER, wBorderWidth);
 616       CHECK_FIELD(PFM_BORDER, wBorders);
 617     }
 618 #undef CHECK_FIELD
 619   }
 620 }
 621
 622 void ME_SetDefaultParaFormat(PARAFORMAT2 *pFmt)
 623 {
 624     ZeroMemory(pFmt, sizeof(PARAFORMAT2));
 625     pFmt->cbSize = sizeof(PARAFORMAT2);
 626     pFmt->dwMask = PFM_ALL2;
 627     pFmt->wAlignment = PFA_LEFT;
 628     pFmt->sStyle = -1;
 629     pFmt->bOutlineLevel = TRUE;
 630 }