dlls/riched20/writer.c

   1 /*
   2  * RichEdit - RTF writer module
   3  *
   4  * Copyright 2005 by Phil Krylov
   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 #include "editor.h"
  22 #include "rtf.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
  25
  26
  27 static BOOL
  28 ME_StreamOutRTFText(ME_OutStream *pStream, const WCHAR *text, LONG nChars);
  29
  30
  31 static ME_OutStream*
  32 ME_StreamOutInit(ME_TextEditor *editor, EDITSTREAM *stream)
  33 {
  34   ME_OutStream *pStream = ALLOC_OBJ(ME_OutStream);
  35   pStream->stream = stream;
  36   pStream->stream->dwError = 0;
  37   pStream->pos = 0;
  38   pStream->written = 0;
  39   pStream->nFontTblLen = 0;
  40   pStream->nColorTblLen = 1;
  41   return pStream;
  42 }
  43
  44
  45 static BOOL
  46 ME_StreamOutFlush(ME_OutStream *pStream)
  47 {
  48   LONG nStart = 0;
  49   LONG nWritten = 0;
  50   LONG nRemaining = 0;
  51   EDITSTREAM *stream = pStream->stream;
  52
  53   do {
  54     TRACE("sending %u bytes\n", pStream->pos - nStart);
  55     /* Some apps seem not to set *pcb unless a problem arises, relying
  56       on initial random nWritten value, which is usually >STREAMOUT_BUFFER_SIZE */
  57     nRemaining = pStream->pos - nStart;
  58     nWritten = 0xDEADBEEF;
  59     stream->dwError = stream->pfnCallback(stream->dwCookie, (LPBYTE)pStream->buffer + nStart,
  60                                           pStream->pos - nStart, &nWritten);
  61     TRACE("error=%u written=%u\n", stream->dwError, nWritten);
  62     if (nWritten > (pStream->pos - nStart) || nWritten<0) {
  63       FIXME("Invalid returned written size *pcb: 0x%x (%d) instead of %d\n",
  64             (unsigned)nWritten, nWritten, nRemaining);
  65       nWritten = nRemaining;
  66     }
  67     if (nWritten == 0 || stream->dwError)
  68       return FALSE;
  69     pStream->written += nWritten;
  70     nStart += nWritten;
  71   } while (nStart < pStream->pos);
  72   pStream->pos = 0;
  73   return TRUE;
  74 }
  75
  76
  77 static LONG
  78 ME_StreamOutFree(ME_OutStream *pStream)
  79 {
  80   LONG written = pStream->written;
  81   TRACE("total length = %u\n", written);
  82
  83   FREE_OBJ(pStream);
  84   return written;
  85 }
  86
  87
  88 static BOOL
  89 ME_StreamOutMove(ME_OutStream *pStream, const char *buffer, int len)
  90 {
  91   while (len) {
  92     int space = STREAMOUT_BUFFER_SIZE - pStream->pos;
  93     int fit = min(space, len);
  94
  95     TRACE("%u:%u:%s\n", pStream->pos, fit, debugstr_an(buffer,fit));
  96     memmove(pStream->buffer + pStream->pos, buffer, fit);
  97     len -= fit;
  98     buffer += fit;
  99     pStream->pos += fit;
 100     if (pStream->pos == STREAMOUT_BUFFER_SIZE) {
 101       if (!ME_StreamOutFlush(pStream))
 102         return FALSE;
 103     }
 104   }
 105   return TRUE;
 106 }
 107
 108
 109 static BOOL
 110 ME_StreamOutPrint(ME_OutStream *pStream, const char *format, ...)
 111 {
 112   char string[STREAMOUT_BUFFER_SIZE]; /* This is going to be enough */
 113   int len;
 114   va_list valist;
 115
 116   va_start(valist, format);
 117   len = vsnprintf(string, sizeof(string), format, valist);
 118   va_end(valist);
 119
 120   return ME_StreamOutMove(pStream, string, len);
 121 }
 122
 123
 124 static BOOL
 125 ME_StreamOutRTFHeader(ME_OutStream *pStream, int dwFormat)
 126 {
 127   const char *cCharSet = NULL;
 128   UINT nCodePage;
 129   LANGID language;
 130   BOOL success;
 131
 132   if (dwFormat & SF_USECODEPAGE) {
 133     CPINFOEXW info;
 134
 135     switch (HIWORD(dwFormat)) {
 136       case CP_ACP:
 137         cCharSet = "ansi";
 138         nCodePage = GetACP();
 139         break;
 140       case CP_OEMCP:
 141         nCodePage = GetOEMCP();
 142         if (nCodePage == 437)
 143           cCharSet = "pc";
 144         else if (nCodePage == 850)
 145           cCharSet = "pca";
 146         else
 147           cCharSet = "ansi";
 148         break;
 149       case CP_UTF8:
 150         nCodePage = CP_UTF8;
 151         break;
 152       default:
 153         if (HIWORD(dwFormat) == CP_MACCP) {
 154           cCharSet = "mac";
 155           nCodePage = 10000; /* MacRoman */
 156         } else {
 157           cCharSet = "ansi";
 158           nCodePage = 1252; /* Latin-1 */
 159         }
 160         if (GetCPInfoExW(HIWORD(dwFormat), 0, &info))
 161           nCodePage = info.CodePage;
 162     }
 163   } else {
 164     cCharSet = "ansi";
 165     /* TODO: If the original document contained an \ansicpg value, retain it.
 166      * Otherwise, M$ richedit emits a codepage number determined from the
 167      * charset of the default font here. Anyway, this value is not used by
 168      * the reader... */
 169     nCodePage = GetACP();
 170   }
 171   if (nCodePage == CP_UTF8)
 172     success = ME_StreamOutPrint(pStream, "{\\urtf");
 173   else
 174     success = ME_StreamOutPrint(pStream, "{\\rtf1\\%s\\ansicpg%u\\uc1", cCharSet, nCodePage);
 175
 176   if (!success)
 177     return FALSE;
 178
 179   pStream->nDefaultCodePage = nCodePage;
 180
 181   /* FIXME: This should be a document property */
 182   /* TODO: handle SFF_PLAINRTF */
 183   language = GetUserDefaultLangID();
 184   if (!ME_StreamOutPrint(pStream, "\\deff0\\deflang%u\\deflangfe%u", language, language))
 185     return FALSE;
 186
 187   /* FIXME: This should be a document property */
 188   pStream->nDefaultFont = 0;
 189
 190   return TRUE;
 191 }
 192
 193
 194 static BOOL
 195 ME_StreamOutRTFFontAndColorTbl(ME_OutStream *pStream, ME_DisplayItem *pFirstRun, const ME_DisplayItem *pLastRun)
 196 {
 197   ME_DisplayItem *item = pFirstRun;
 198   ME_FontTableItem *table = pStream->fonttbl;
 199   int i;
 200
 201   do {
 202     CHARFORMAT2W *fmt = &item->member.run.style->fmt;
 203     COLORREF crColor;
 204
 205     if (fmt->dwMask & CFM_FACE) {
 206       WCHAR *face = fmt->szFaceName;
 207       BYTE bCharSet = (fmt->dwMask & CFM_CHARSET) ? fmt->bCharSet : DEFAULT_CHARSET;
 208
 209       for (i = 0; i < pStream->nFontTblLen; i++)
 210         if (table[i].bCharSet == bCharSet
 211             && (table[i].szFaceName == face || !lstrcmpW(table[i].szFaceName, face)))
 212           break;
 213       if (i == pStream->nFontTblLen) {
 214         table[i].bCharSet = bCharSet;
 215         table[i].szFaceName = face;
 216         pStream->nFontTblLen++;
 217       }
 218     }
 219
 220     if (fmt->dwMask & CFM_COLOR && !(fmt->dwEffects & CFE_AUTOCOLOR)) {
 221       crColor = fmt->crTextColor;
 222       for (i = 1; i < pStream->nColorTblLen; i++)
 223         if (pStream->colortbl[i] == crColor)
 224           break;
 225       if (i == pStream->nColorTblLen) {
 226         pStream->colortbl[i] = crColor;
 227         pStream->nColorTblLen++;
 228       }
 229     }
 230     if (fmt->dwMask & CFM_BACKCOLOR && !(fmt->dwEffects & CFE_AUTOBACKCOLOR)) {
 231       crColor = fmt->crBackColor;
 232       for (i = 1; i < pStream->nColorTblLen; i++)
 233         if (pStream->colortbl[i] == crColor)
 234           break;
 235       if (i == pStream->nColorTblLen) {
 236         pStream->colortbl[i] = crColor;
 237         pStream->nColorTblLen++;
 238       }
 239     }
 240
 241     if (item == pLastRun)
 242       break;
 243     item = ME_FindItemFwd(item, diRun);
 244   } while (item);
 245
 246   if (!ME_StreamOutPrint(pStream, "{\\fonttbl"))
 247     return FALSE;
 248
 249   for (i = 0; i < pStream->nFontTblLen; i++) {
 250     if (table[i].bCharSet != DEFAULT_CHARSET) {
 251       if (!ME_StreamOutPrint(pStream, "{\\f%u\\fcharset%u ", i, table[i].bCharSet))
 252         return FALSE;
 253     } else {
 254       if (!ME_StreamOutPrint(pStream, "{\\f%u ", i))
 255         return FALSE;
 256     }
 257     if (!ME_StreamOutRTFText(pStream, table[i].szFaceName, -1))
 258       return FALSE;
 259     if (!ME_StreamOutPrint(pStream, ";}\r\n"))
 260       return FALSE;
 261   }
 262   if (!ME_StreamOutPrint(pStream, "}"))
 263     return FALSE;
 264
 265   /* Output colors table if not empty */
 266   if (pStream->nColorTblLen > 1) {
 267     if (!ME_StreamOutPrint(pStream, "{\\colortbl;"))
 268       return FALSE;
 269     for (i = 1; i < pStream->nColorTblLen; i++) {
 270       if (!ME_StreamOutPrint(pStream, "\\red%u\\green%u\\blue%u;",
 271                              pStream->colortbl[i] & 0xFF,
 272                              (pStream->colortbl[i] >> 8) & 0xFF,
 273                              (pStream->colortbl[i] >> 16) & 0xFF))
 274         return FALSE;
 275     }
 276     if (!ME_StreamOutPrint(pStream, "}"))
 277       return FALSE;
 278   }
 279
 280   return TRUE;
 281 }
 282
 283
 284 static BOOL
 285 ME_StreamOutRTFParaProps(ME_OutStream *pStream, const ME_DisplayItem *para)
 286 {
 287   PARAFORMAT2 *fmt = para->member.para.pFmt;
 288   char props[STREAMOUT_BUFFER_SIZE] = "";
 289   int i;
 290
 291   if (para->member.para.pCells)
 292   {
 293     ME_TableCell *cell = para->member.para.pCells;
 294
 295     if (!ME_StreamOutPrint(pStream, "\\trowd"))
 296       return FALSE;
 297     do {
 298       sprintf(props, "\\cellx%d", cell->nRightBoundary);
 299       if (!ME_StreamOutPrint(pStream, props))
 300         return FALSE;
 301       cell = cell->next;
 302     } while (cell);
 303     props[0] = '\0';
 304   }
 305
 306   /* TODO: Don't emit anything if the last PARAFORMAT2 is inherited */
 307   if (!ME_StreamOutPrint(pStream, "\\pard"))
 308     return FALSE;
 309
 310   if (para->member.para.bTable)
 311     strcat(props, "\\intbl");
 312
 313   /* TODO: PFM_BORDER. M$ does not emit any keywords for these properties, and
 314    * when streaming border keywords in, PFM_BORDER is set, but wBorder field is
 315    * set very different from the documentation.
 316    * (Tested with RichEdit 5.50.25.0601) */
 317
 318   if (fmt->dwMask & PFM_ALIGNMENT) {
 319     switch (fmt->wAlignment) {
 320       case PFA_LEFT:
 321         /* Default alignment: not emitted */
 322         break;
 323       case PFA_RIGHT:
 324         strcat(props, "\\qr");
 325         break;
 326       case PFA_CENTER:
 327         strcat(props, "\\qc");
 328         break;
 329       case PFA_JUSTIFY:
 330         strcat(props, "\\qj");
 331         break;
 332     }
 333   }
 334
 335   if (fmt->dwMask & PFM_LINESPACING) {
 336     /* FIXME: MSDN says that the bLineSpacingRule field is controlled by the
 337      * PFM_SPACEAFTER flag. Is that true? I don't believe so. */
 338     switch (fmt->bLineSpacingRule) {
 339       case 0: /* Single spacing */
 340         strcat(props, "\\sl-240\\slmult1");
 341         break;
 342       case 1: /* 1.5 spacing */
 343         strcat(props, "\\sl-360\\slmult1");
 344         break;
 345       case 2: /* Double spacing */
 346         strcat(props, "\\sl-480\\slmult1");
 347         break;
 348       case 3:
 349         sprintf(props + strlen(props), "\\sl%d\\slmult0", fmt->dyLineSpacing);
 350         break;
 351       case 4:
 352         sprintf(props + strlen(props), "\\sl-%d\\slmult0", fmt->dyLineSpacing);
 353         break;
 354       case 5:
 355         sprintf(props + strlen(props), "\\sl-%d\\slmult1", fmt->dyLineSpacing * 240 / 20);
 356         break;
 357     }
 358   }
 359
 360   if (fmt->dwMask & PFM_DONOTHYPHEN && fmt->wEffects & PFE_DONOTHYPHEN)
 361     strcat(props, "\\hyph0");
 362   if (fmt->dwMask & PFM_KEEP && fmt->wEffects & PFE_KEEP)
 363     strcat(props, "\\keep");
 364   if (fmt->dwMask & PFM_KEEPNEXT && fmt->wEffects & PFE_KEEPNEXT)
 365     strcat(props, "\\keepn");
 366   if (fmt->dwMask & PFM_NOLINENUMBER && fmt->wEffects & PFE_NOLINENUMBER)
 367     strcat(props, "\\noline");
 368   if (fmt->dwMask & PFM_NOWIDOWCONTROL && fmt->wEffects & PFE_NOWIDOWCONTROL)
 369     strcat(props, "\\nowidctlpar");
 370   if (fmt->dwMask & PFM_PAGEBREAKBEFORE && fmt->wEffects & PFE_PAGEBREAKBEFORE)
 371     strcat(props, "\\pagebb");
 372   if (fmt->dwMask & PFM_RTLPARA && fmt->wEffects & PFE_RTLPARA)
 373     strcat(props, "\\rtlpar");
 374   if (fmt->dwMask & PFM_SIDEBYSIDE && fmt->wEffects & PFE_SIDEBYSIDE)
 375     strcat(props, "\\sbys");
 376   if (fmt->dwMask & PFM_TABLE && fmt->dwMask & PFE_TABLE)
 377     strcat(props, "\\intbl");
 378
 379   if (fmt->dwMask & PFM_OFFSET)
 380     sprintf(props + strlen(props), "\\li%d", fmt->dxOffset);
 381   if (fmt->dwMask & PFM_OFFSETINDENT || fmt->dwMask & PFM_STARTINDENT)
 382     sprintf(props + strlen(props), "\\fi%d", fmt->dxStartIndent);
 383   if (fmt->dwMask & PFM_RIGHTINDENT)
 384     sprintf(props + strlen(props), "\\ri%d", fmt->dxRightIndent);
 385   if (fmt->dwMask & PFM_SPACEAFTER)
 386     sprintf(props + strlen(props), "\\sa%d", fmt->dySpaceAfter);
 387   if (fmt->dwMask & PFM_SPACEBEFORE)
 388     sprintf(props + strlen(props), "\\sb%d", fmt->dySpaceBefore);
 389   if (fmt->dwMask & PFM_STYLE)
 390     sprintf(props + strlen(props), "\\s%d", fmt->sStyle);
 391
 392   if (fmt->dwMask & PFM_TABSTOPS) {
 393     static const char * const leader[6] = { "", "\\tldot", "\\tlhyph", "\\tlul", "\\tlth", "\\tleq" };
 394
 395     for (i = 0; i < fmt->cTabCount; i++) {
 396       switch ((fmt->rgxTabs[i] >> 24) & 0xF) {
 397         case 1:
 398           strcat(props, "\\tqc");
 399           break;
 400         case 2:
 401           strcat(props, "\\tqr");
 402           break;
 403         case 3:
 404           strcat(props, "\\tqdec");
 405           break;
 406         case 4:
 407           /* Word bar tab (vertical bar). Handled below */
 408           break;
 409       }
 410       if (fmt->rgxTabs[i] >> 28 <= 5)
 411         strcat(props, leader[fmt->rgxTabs[i] >> 28]);
 412       sprintf(props+strlen(props), "\\tx%d", fmt->rgxTabs[i]&0x00FFFFFF);
 413     }
 414   }
 415
 416
 417   if (fmt->dwMask & PFM_SHADING) {
 418     static const char * const style[16] = { "", "\\bgdkhoriz", "\\bgdkvert", "\\bgdkfdiag",
 419                                      "\\bgdkbdiag", "\\bgdkcross", "\\bgdkdcross",
 420                                      "\\bghoriz", "\\bgvert", "\\bgfdiag",
 421                                      "\\bgbdiag", "\\bgcross", "\\bgdcross",
 422                                      "", "", "" };
 423     if (fmt->wShadingWeight)
 424       sprintf(props + strlen(props), "\\shading%d", fmt->wShadingWeight);
 425     if (fmt->wShadingStyle & 0xF)
 426       strcat(props, style[fmt->wShadingStyle & 0xF]);
 427     sprintf(props + strlen(props), "\\cfpat%d\\cbpat%d",
 428             (fmt->wShadingStyle >> 4) & 0xF, (fmt->wShadingStyle >> 8) & 0xF);
 429   }
 430
 431   if (*props && !ME_StreamOutPrint(pStream, props))
 432     return FALSE;
 433
 434   return TRUE;
 435 }
 436
 437
 438 static BOOL
 439 ME_StreamOutRTFCharProps(ME_OutStream *pStream, CHARFORMAT2W *fmt)
 440 {
 441   char props[STREAMOUT_BUFFER_SIZE] = "";
 442   int i;
 443
 444   if (fmt->dwMask & CFM_ALLCAPS && fmt->dwEffects & CFE_ALLCAPS)
 445     strcat(props, "\\caps");
 446   if (fmt->dwMask & CFM_ANIMATION)
 447     sprintf(props + strlen(props), "\\animtext%u", fmt->bAnimation);
 448   if (fmt->dwMask & CFM_BACKCOLOR) {
 449     if (!(fmt->dwEffects & CFE_AUTOBACKCOLOR)) {
 450       for (i = 1; i < pStream->nColorTblLen; i++)
 451         if (pStream->colortbl[i] == fmt->crBackColor) {
 452           sprintf(props + strlen(props), "\\cb%u", i);
 453           break;
 454         }
 455     }
 456   }
 457   if (fmt->dwMask & CFM_BOLD && fmt->dwEffects & CFE_BOLD)
 458     strcat(props, "\\b");
 459   if (fmt->dwMask & CFM_COLOR) {
 460     if (!(fmt->dwEffects & CFE_AUTOCOLOR)) {
 461       for (i = 1; i < pStream->nColorTblLen; i++)
 462         if (pStream->colortbl[i] == fmt->crTextColor) {
 463           sprintf(props + strlen(props), "\\cf%u", i);
 464           break;
 465         }
 466     }
 467   }
 468   /* TODO: CFM_DISABLED */
 469   if (fmt->dwMask & CFM_EMBOSS && fmt->dwEffects & CFE_EMBOSS)
 470     strcat(props, "\\embo");
 471   if (fmt->dwMask & CFM_HIDDEN && fmt->dwEffects & CFE_HIDDEN)
 472     strcat(props, "\\v");
 473   if (fmt->dwMask & CFM_IMPRINT && fmt->dwEffects & CFE_IMPRINT)
 474     strcat(props, "\\impr");
 475   if (fmt->dwMask & CFM_ITALIC && fmt->dwEffects & CFE_ITALIC)
 476     strcat(props, "\\i");
 477   if (fmt->dwMask & CFM_KERNING)
 478     sprintf(props + strlen(props), "\\kerning%u", fmt->wKerning);
 479   if (fmt->dwMask & CFM_LCID) {
 480     /* TODO: handle SFF_PLAINRTF */
 481     if (LOWORD(fmt->lcid) == 1024)
 482       strcat(props, "\\noproof\\lang1024\\langnp1024\\langfe1024\\langfenp1024");
 483     else
 484       sprintf(props + strlen(props), "\\lang%u", LOWORD(fmt->lcid));
 485   }
 486   /* CFM_LINK is not streamed out by M$ */
 487   if (fmt->dwMask & CFM_OFFSET) {
 488     if (fmt->yOffset >= 0)
 489       sprintf(props + strlen(props), "\\up%d", fmt->yOffset);
 490     else
 491       sprintf(props + strlen(props), "\\dn%d", -fmt->yOffset);
 492   }
 493   if (fmt->dwMask & CFM_OUTLINE && fmt->dwEffects & CFE_OUTLINE)
 494     strcat(props, "\\outl");
 495   if (fmt->dwMask & CFM_PROTECTED && fmt->dwEffects & CFE_PROTECTED)
 496     strcat(props, "\\protect");
 497   /* TODO: CFM_REVISED CFM_REVAUTHOR - probably using rsidtbl? */
 498   if (fmt->dwMask & CFM_SHADOW && fmt->dwEffects & CFE_SHADOW)
 499     strcat(props, "\\shad");
 500   if (fmt->dwMask & CFM_SIZE)
 501     sprintf(props + strlen(props), "\\fs%d", fmt->yHeight / 10);
 502   if (fmt->dwMask & CFM_SMALLCAPS && fmt->dwEffects & CFE_SMALLCAPS)
 503     strcat(props, "\\scaps");
 504   if (fmt->dwMask & CFM_SPACING)
 505     sprintf(props + strlen(props), "\\expnd%u\\expndtw%u", fmt->sSpacing / 5, fmt->sSpacing);
 506   if (fmt->dwMask & CFM_STRIKEOUT && fmt->dwEffects & CFE_STRIKEOUT)
 507     strcat(props, "\\strike");
 508   if (fmt->dwMask & CFM_STYLE) {
 509     sprintf(props + strlen(props), "\\cs%u", fmt->sStyle);
 510     /* TODO: emit style contents here */
 511   }
 512   if (fmt->dwMask & (CFM_SUBSCRIPT | CFM_SUPERSCRIPT)) {
 513     if (fmt->dwEffects & CFE_SUBSCRIPT)
 514       strcat(props, "\\sub");
 515     else if (fmt->dwEffects & CFE_SUPERSCRIPT)
 516       strcat(props, "\\super");
 517   }
 518   if (fmt->dwMask & CFM_UNDERLINE || fmt->dwMask & CFM_UNDERLINETYPE) {
 519     if (fmt->dwMask & CFM_UNDERLINETYPE)
 520       switch (fmt->bUnderlineType) {
 521         case CFU_CF1UNDERLINE:
 522         case CFU_UNDERLINE:
 523           strcat(props, "\\ul");
 524           break;
 525         case CFU_UNDERLINEDOTTED:
 526           strcat(props, "\\uld");
 527           break;
 528         case CFU_UNDERLINEDOUBLE:
 529           strcat(props, "\\uldb");
 530           break;
 531         case CFU_UNDERLINEWORD:
 532           strcat(props, "\\ulw");
 533           break;
 534         case CFU_UNDERLINENONE:
 535         default:
 536           strcat(props, "\\ul0");
 537           break;
 538       }
 539     else if (fmt->dwEffects & CFE_UNDERLINE)
 540       strcat(props, "\\ul");
 541   }
 542   /* FIXME: How to emit CFM_WEIGHT? */
 543
 544   if (fmt->dwMask & CFM_FACE || fmt->dwMask & CFM_CHARSET) {
 545     WCHAR *szFaceName;
 546
 547     if (fmt->dwMask & CFM_FACE)
 548       szFaceName = fmt->szFaceName;
 549     else
 550       szFaceName = pStream->fonttbl[0].szFaceName;
 551     for (i = 0; i < pStream->nFontTblLen; i++) {
 552       if (szFaceName == pStream->fonttbl[i].szFaceName
 553           || !lstrcmpW(szFaceName, pStream->fonttbl[i].szFaceName))
 554         if (!(fmt->dwMask & CFM_CHARSET)
 555             || fmt->bCharSet == pStream->fonttbl[i].bCharSet)
 556           break;
 557     }
 558     if (i < pStream->nFontTblLen)
 559     {
 560       if (i != pStream->nDefaultFont)
 561         sprintf(props + strlen(props), "\\f%u", i);
 562
 563       /* In UTF-8 mode, charsets/codepages are not used */
 564       if (pStream->nDefaultCodePage != CP_UTF8)
 565       {
 566         if (pStream->fonttbl[i].bCharSet == DEFAULT_CHARSET)
 567           pStream->nCodePage = pStream->nDefaultCodePage;
 568         else
 569           pStream->nCodePage = RTFCharSetToCodePage(NULL, pStream->fonttbl[i].bCharSet);
 570       }
 571     }
 572   }
 573   if (*props)
 574     strcat(props, " ");
 575   if (!ME_StreamOutPrint(pStream, props))
 576     return FALSE;
 577   return TRUE;
 578 }
 579
 580
 581 static BOOL
 582 ME_StreamOutRTFText(ME_OutStream *pStream, const WCHAR *text, LONG nChars)
 583 {
 584   char buffer[STREAMOUT_BUFFER_SIZE];
 585   int pos = 0;
 586   int fit, nBytes, i;
 587
 588   if (nChars == -1)
 589     nChars = lstrlenW(text);
 590
 591   while (nChars) {
 592     /* In UTF-8 mode, font charsets are not used. */
 593     if (pStream->nDefaultCodePage == CP_UTF8) {
 594       /* 6 is the maximum character length in UTF-8 */
 595       fit = min(nChars, STREAMOUT_BUFFER_SIZE / 6);
 596       nBytes = WideCharToMultiByte(CP_UTF8, 0, text, fit, buffer,
 597                                    STREAMOUT_BUFFER_SIZE, NULL, NULL);
 598       nChars -= fit;
 599       text += fit;
 600       for (i = 0; i < nBytes; i++)
 601         if (buffer[i] == '{' || buffer[i] == '}' || buffer[i] == '\\') {
 602           if (!ME_StreamOutPrint(pStream, "%.*s\\", i - pos, buffer + pos))
 603             return FALSE;
 604           pos = i;
 605         }
 606       if (pos < nBytes)
 607         if (!ME_StreamOutMove(pStream, buffer + pos, nBytes - pos))
 608           return FALSE;
 609       pos = 0;
 610     } else if (*text < 128) {
 611       if (*text == '{' || *text == '}' || *text == '\\')
 612         buffer[pos++] = '\\';
 613       buffer[pos++] = (char)(*text++);
 614       nChars--;
 615     } else {
 616       BOOL unknown = FALSE;
 617       char letter[3];
 618
 619       /* FIXME: In the MS docs for WideCharToMultiByte there is a big list of
 620        * codepages including CP_SYMBOL for which the last parameter must be set
 621        * to NULL for the function to succeed. But in Wine we need to care only
 622        * about CP_SYMBOL */
 623       nBytes = WideCharToMultiByte(pStream->nCodePage, 0, text, 1,
 624                                    letter, 3, NULL,
 625                                    (pStream->nCodePage == CP_SYMBOL) ? NULL : &unknown);
 626       if (unknown)
 627         pos += sprintf(buffer + pos, "\\u%d?", (short)*text);
 628       else if ((BYTE)*letter < 128) {
 629         if (*letter == '{' || *letter == '}' || *letter == '\\')
 630           buffer[pos++] = '\\';
 631         buffer[pos++] = *letter;
 632       } else {
 633          for (i = 0; i < nBytes; i++)
 634            pos += sprintf(buffer + pos, "\\'%02x", (BYTE)letter[i]);
 635       }
 636       text++;
 637       nChars--;
 638     }
 639     if (pos >= STREAMOUT_BUFFER_SIZE - 11) {
 640       if (!ME_StreamOutMove(pStream, buffer, pos))
 641         return FALSE;
 642       pos = 0;
 643     }
 644   }
 645   return ME_StreamOutMove(pStream, buffer, pos);
 646 }
 647
 648
 649 static BOOL
 650 ME_StreamOutRTF(ME_TextEditor *editor, ME_OutStream *pStream, int nStart, int nChars, int dwFormat)
 651 {
 652   ME_DisplayItem *p, *pEnd, *pPara;
 653   int nOffset, nEndLen;
 654
 655   ME_RunOfsFromCharOfs(editor, nStart, &p, &nOffset);
 656   ME_RunOfsFromCharOfs(editor, nStart+nChars, &pEnd, &nEndLen);
 657
 658   pPara = ME_GetParagraph(p);
 659
 660   if (!ME_StreamOutRTFHeader(pStream, dwFormat))
 661     return FALSE;
 662
 663   if (!ME_StreamOutRTFFontAndColorTbl(pStream, p, pEnd))
 664     return FALSE;
 665
 666   /* TODO: stylesheet table */
 667
 668   /* FIXME: maybe emit something smarter for the generator? */
 669   if (!ME_StreamOutPrint(pStream, "{\\*\\generator Wine Riched20 2.0.????;}"))
 670     return FALSE;
 671
 672   /* TODO: information group */
 673
 674   /* TODO: document formatting properties */
 675
 676   /* FIXME: We have only one document section */
 677
 678   /* TODO: section formatting properties */
 679
 680   if (!ME_StreamOutRTFParaProps(pStream, ME_GetParagraph(p)))
 681     return FALSE;
 682
 683   while(1)
 684   {
 685     switch(p->type)
 686     {
 687       case diParagraph:
 688         if (!ME_StreamOutRTFParaProps(pStream, p))
 689           return FALSE;
 690         pPara = p;
 691         break;
 692       case diRun:
 693         if (p == pEnd && !nEndLen)
 694           break;
 695         TRACE("flags %xh\n", p->member.run.nFlags);
 696         /* TODO: emit embedded objects */
 697         if (p->member.run.nFlags & MERF_GRAPHICS)
 698           FIXME("embedded objects are not handled\n");
 699         if (p->member.run.nFlags & MERF_CELL) {
 700           if (!ME_StreamOutPrint(pStream, "\\cell "))
 701             return FALSE;
 702           nChars--;
 703         } else if (p->member.run.nFlags & MERF_ENDPARA) {
 704           if (pPara->member.para.bTable) {
 705             if (!ME_StreamOutPrint(pStream, "\\row \r\n"))
 706               return FALSE;
 707           } else {
 708             if (!ME_StreamOutPrint(pStream, "\r\n\\par"))
 709               return FALSE;
 710           }
 711           nChars--;
 712           if (editor->bEmulateVersion10 && nChars)
 713             nChars--;
 714         } else {
 715           int nEnd;
 716
 717           if (!ME_StreamOutPrint(pStream, "{"))
 718             return FALSE;
 719           TRACE("style %p\n", p->member.run.style);
 720           if (!ME_StreamOutRTFCharProps(pStream, &p->member.run.style->fmt))
 721             return FALSE;
 722
 723           nEnd = (p == pEnd) ? nEndLen : ME_StrLen(p->member.run.strText);
 724           if (!ME_StreamOutRTFText(pStream, p->member.run.strText->szData + nOffset, nEnd - nOffset))
 725             return FALSE;
 726           nOffset = 0;
 727           if (!ME_StreamOutPrint(pStream, "}"))
 728             return FALSE;
 729         }
 730         break;
 731       default: /* we missed the last item */
 732         assert(0);
 733     }
 734     if (p == pEnd)
 735       break;
 736     p = ME_FindItemFwd(p, diRunOrParagraphOrEnd);
 737   }
 738   if (!ME_StreamOutPrint(pStream, "}"))
 739     return FALSE;
 740   return TRUE;
 741 }
 742
 743
 744 static BOOL
 745 ME_StreamOutText(ME_TextEditor *editor, ME_OutStream *pStream, int nStart, int nChars, DWORD dwFormat)
 746 {
 747   /* FIXME: use ME_RunOfsFromCharOfs */
 748   ME_DisplayItem *item = ME_FindItemAtOffset(editor, diRun, nStart, &nStart);
 749   int nLen;
 750   UINT nCodePage = CP_ACP;
 751   char *buffer = NULL;
 752   int nBufLen = 0;
 753   BOOL success = TRUE;
 754
 755   if (!item)
 756     return FALSE;
 757
 758   if (dwFormat & SF_USECODEPAGE)
 759     nCodePage = HIWORD(dwFormat);
 760
 761   /* TODO: Handle SF_TEXTIZED */
 762
 763   while (success && nChars && item) {
 764     nLen = ME_StrLen(item->member.run.strText) - nStart;
 765     if (nLen > nChars)
 766       nLen = nChars;
 767
 768     if (item->member.run.nFlags & MERF_ENDPARA) {
 769       static const WCHAR szEOL[2] = { '\r', '\n' };
 770
 771       if (dwFormat & SF_UNICODE)
 772         success = ME_StreamOutMove(pStream, (const char *)szEOL, sizeof(szEOL));
 773       else
 774         success = ME_StreamOutMove(pStream, "\r\n", 2);
 775     } else {
 776       if (dwFormat & SF_UNICODE)
 777         success = ME_StreamOutMove(pStream, (const char *)(item->member.run.strText->szData + nStart),
 778                                    sizeof(WCHAR) * nLen);
 779       else {
 780         int nSize;
 781
 782         nSize = WideCharToMultiByte(nCodePage, 0, item->member.run.strText->szData + nStart,
 783                                     nLen, NULL, 0, NULL, NULL);
 784         if (nSize > nBufLen) {
 785           FREE_OBJ(buffer);
 786           buffer = ALLOC_N_OBJ(char, nSize);
 787           nBufLen = nSize;
 788         }
 789         WideCharToMultiByte(nCodePage, 0, item->member.run.strText->szData + nStart,
 790                             nLen, buffer, nSize, NULL, NULL);
 791         success = ME_StreamOutMove(pStream, buffer, nSize);
 792       }
 793     }
 794
 795     nChars -= nLen;
 796     if (editor->bEmulateVersion10 && nChars && item->member.run.nFlags & MERF_ENDPARA)
 797       nChars--;
 798     nStart = 0;
 799     item = ME_FindItemFwd(item, diRun);
 800   }
 801
 802   FREE_OBJ(buffer);
 803   return success;
 804 }
 805
 806
 807 LRESULT
 808 ME_StreamOutRange(ME_TextEditor *editor, DWORD dwFormat, int nStart, int nTo, EDITSTREAM *stream)
 809 {
 810   ME_OutStream *pStream = ME_StreamOutInit(editor, stream);
 811
 812   if (nTo == -1)
 813   {
 814     nTo = ME_GetTextLength(editor);
 815     /* Generate an end-of-paragraph at the end of SCF_ALL RTF output */
 816     if (dwFormat & SF_RTF)
 817       nTo++;
 818   }
 819   TRACE("from %d to %d\n", nStart, nTo);
 820
 821   if (dwFormat & SF_RTF)
 822     ME_StreamOutRTF(editor, pStream, nStart, nTo - nStart, dwFormat);
 823   else if (dwFormat & SF_TEXT || dwFormat & SF_TEXTIZED)
 824     ME_StreamOutText(editor, pStream, nStart, nTo - nStart, dwFormat);
 825   if (!pStream->stream->dwError)
 826     ME_StreamOutFlush(pStream);
 827   return ME_StreamOutFree(pStream);
 828 }
 829
 830 LRESULT
 831 ME_StreamOut(ME_TextEditor *editor, DWORD dwFormat, EDITSTREAM *stream)
 832 {
 833   int nStart, nTo;
 834
 835   if (dwFormat & SFF_SELECTION)
 836     ME_GetSelection(editor, &nStart, &nTo);
 837   else {
 838     nStart = 0;
 839     nTo = -1;
 840   }
 841   return ME_StreamOutRange(editor, dwFormat, nStart, nTo, stream);
 842 }