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