ReactOS 0.4.15-dev-8227-g32d615f
reader.c
Go to the documentation of this file.
1/*
2 * WINE RTF file reader
3 *
4 * Portions Copyright 2004 Mike McCormack for CodeWeavers
5 * Portions 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/*
23 * Derived from RTF Tools by Paul DuBois (dubois@primate.wisc.edu)
24 * Homepage: http://www.snake.net/software/RTF/
25 * Original license follows:
26 */
27
28/*
29 * reader.c - RTF file reader. Release 1.10.
30 *
31 * ....
32 *
33 * Author: Paul DuBois dubois@primate.wisc.edu
34 *
35 * This software may be redistributed without restriction and used for
36 * any purpose whatsoever.
37 */
38
39#include <stdio.h>
40#include <ctype.h>
41#include <string.h>
42#include <stdarg.h>
43#include <stdlib.h>
44#include <assert.h>
45
46#include "windef.h"
47#include "winbase.h"
48#include "wine/debug.h"
49
50#include "editor.h"
51#include "rtf.h"
52
54
55static int _RTFGetChar(RTF_Info *);
56static void _RTFGetToken (RTF_Info *);
57static void _RTFGetToken2 (RTF_Info *);
58static int GetChar (RTF_Info *);
59static void ReadFontTbl (RTF_Info *);
60static void ReadColorTbl (RTF_Info *);
61static void ReadStyleSheet (RTF_Info *);
62static void ReadInfoGroup (RTF_Info *);
63static void ReadPictGroup (RTF_Info *);
64static void ReadObjGroup (RTF_Info *);
65static void Lookup (RTF_Info *, char *);
66static int Hash (const char *);
67
68static void CharAttr(RTF_Info *info);
69static void CharSet(RTF_Info *info);
70static void DocAttr(RTF_Info *info);
71
73static void RTFPutCodePageChar(RTF_Info *info, int c);
74
75/* ---------------------------------------------------------------------- */
76
77
78/*
79 * Saves a string on the heap and returns a pointer to it.
80 */
81static inline char *RTFStrSave(const char *s)
82{
83 char *p;
84
85 p = heap_alloc (lstrlenA(s) + 1);
86 if (p == NULL)
87 return NULL;
88 return lstrcpyA (p, s);
89}
90
91
92/* ---------------------------------------------------------------------- */
93
94
96{
97 int ch;
98 ME_InStream *stream = info->stream;
99
100 if (stream->dwSize <= stream->dwUsed)
101 {
103 /* if error, it's EOF */
104 if (stream->editstream->dwError)
105 return EOF;
106 /* if no bytes read, it's EOF */
107 if (stream->dwSize == 0)
108 return EOF;
109 }
110 ch = (unsigned char)stream->buffer[stream->dwUsed++];
111 if (!ch)
112 return ' ';
113 return ch;
114}
115
117{
118 info->stream = stream;
119}
120
121static void
123{
124 RTFColor *cp;
125 RTFFont *fp;
126 RTFStyle *sp;
127 RTFStyleElt *eltList, *ep;
128
129 while (info->fontList)
130 {
131 fp = info->fontList->rtfNextFont;
132 heap_free (info->fontList->rtfFName);
133 heap_free (info->fontList);
134 info->fontList = fp;
135 }
136 while (info->colorList)
137 {
138 cp = info->colorList->rtfNextColor;
139 heap_free (info->colorList);
140 info->colorList = cp;
141 }
142 while (info->styleList)
143 {
144 sp = info->styleList->rtfNextStyle;
145 eltList = info->styleList->rtfSSEList;
146 while (eltList)
147 {
148 ep = eltList->rtfNextSE;
149 heap_free (eltList->rtfSEText);
150 heap_free (eltList);
151 eltList = ep;
152 }
153 heap_free (info->styleList->rtfSName);
154 heap_free (info->styleList);
155 info->styleList = sp;
156 }
157}
158
159
160void
162{
163 if (info->rtfTextBuf)
164 {
165 heap_free(info->rtfTextBuf);
166 heap_free(info->pushedTextBuf);
167 }
169 heap_free(info->cpOutputBuffer);
170 while (info->tableDef)
171 {
172 RTFTable *tableDef = info->tableDef;
173 info->tableDef = tableDef->parent;
174 heap_free(tableDef);
175 }
176}
177
178
179
180/* ---------------------------------------------------------------------- */
181
182/*
183 * Callback table manipulation routines
184 */
185
186
187/*
188 * Install or return a writer callback for a token class
189 */
190
192{
193 if (class >= 0 && class < rtfMaxClass)
194 info->ccb[class] = callback;
195}
196
197
199{
200 if (class >= 0 && class < rtfMaxClass)
201 return info->ccb[class];
202 return NULL;
203}
204
205
206/*
207 * Initialize the reader. This may be called multiple times,
208 * to read multiple files. The only thing not reset is the input
209 * stream; that must be done with RTFSetStream().
210 */
211
213{
214 int i;
215
216 if (info->rtfTextBuf == NULL) /* initialize the text buffers */
217 {
218 info->rtfTextBuf = heap_alloc (rtfBufSiz);
219 info->pushedTextBuf = heap_alloc (rtfBufSiz);
220 if (info->rtfTextBuf == NULL || info->pushedTextBuf == NULL) {
221 ERR ("Cannot allocate text buffers.\n");
222 return;
223 }
224 info->rtfTextBuf[0] = info->pushedTextBuf[0] = '\0';
225 }
226
227 for (i = 0; i < rtfMaxClass; i++)
229 for (i = 0; i < rtfMaxDestination; i++)
231
232 /* install built-in destination readers */
239
240
242
243 /* dump old lists if necessary */
244
246
247 info->ansiCodePage = 1252; /* Latin-1; actually unused */
248 info->unicodeLength = 1; /* \uc1 is the default */
249 info->codePage = info->ansiCodePage;
250 info->defFont = 0;
251
252 info->rtfClass = -1;
253 info->pushedClass = -1;
254 info->pushedChar = EOF;
255
256 info->rtfLineNum = 0;
257 info->rtfLinePos = 0;
258 info->prevChar = EOF;
259 info->bumpLine = FALSE;
260
261 info->dwCPOutputCount = 0;
262 if (!info->cpOutputBuffer)
263 {
264 info->dwMaxCPOutputCount = 0x1000;
265 info->cpOutputBuffer = heap_alloc(info->dwMaxCPOutputCount);
266 }
267
268 info->tableDef = NULL;
269 info->nestingLevel = 0;
270 info->canInheritInTbl = FALSE;
271 info->borderType = 0;
272
273 memset(&info->fmt, 0, sizeof(info->fmt));
274 info->fmt.cbSize = sizeof(info->fmt);
275}
276
277/*
278 * Install or return a writer callback for a destination type
279 */
280
282{
283 if (dest >= 0 && dest < rtfMaxDestination)
284 info->dcb[dest] = callback;
285}
286
287
289{
290 if (dest >= 0 && dest < rtfMaxDestination)
291 return info->dcb[dest];
292 return NULL;
293}
294
295
296/* ---------------------------------------------------------------------- */
297
298/*
299 * Token reading routines
300 */
301
302
303/*
304 * Read the input stream, invoking the writer's callbacks
305 * where appropriate.
306 */
307
309{
310 while (RTFGetToken (info) != rtfEOF)
312}
313
314
315/*
316 * Route a token. If it's a destination for which a reader is
317 * installed, process the destination internally, otherwise
318 * pass the token to the writer's class callback.
319 */
320
322{
324
325 if (info->rtfClass < 0 || info->rtfClass >= rtfMaxClass) /* watchdog */
326 {
327 ERR( "Unknown class %d: %s (reader malfunction)\n",
328 info->rtfClass, info->rtfTextBuf);
329 }
331 {
332 /* invoke destination-specific callback if there is one */
333 p = RTFGetDestinationCallback (info, info->rtfMinor);
334 if (p != NULL)
335 {
336 (*p) (info);
337 return;
338 }
339 }
340 /* invoke class callback if there is one */
341 p = RTFGetClassCallback (info, info->rtfClass);
342 if (p != NULL)
343 (*p) (info);
344}
345
346
347/*
348 * Skip to the end of the current group. When this returns,
349 * writers that maintain a state stack may want to call their
350 * state unstacker; global vars will still be set to the group's
351 * closing brace.
352 */
353
355{
356 int level = 1;
357
358 while (RTFGetToken (info) != rtfEOF)
359 {
360 if (info->rtfClass == rtfGroup)
361 {
362 if (info->rtfMajor == rtfBeginGroup)
363 ++level;
364 else if (info->rtfMajor == rtfEndGroup)
365 {
366 if (--level < 1)
367 break; /* end of initial group */
368 }
369 }
370 }
371}
372
373/*
374 * Do no special processing on the group.
375 *
376 * This acts as a placeholder for a callback in order to indicate that it
377 * shouldn't be ignored. Instead it will fallback on the loop in RTFRead.
378 */
380{
381}
382
383
384/*
385 * Install or return a token reader hook.
386 */
387
389{
390 info->readHook = f;
391}
392
393
395{
396 return (info->readHook);
397}
398
399
400/*
401 * Read one token. Call the read hook if there is one. The
402 * token class is the return value. Returns rtfEOF when there
403 * are no more tokens.
404 */
405
407{
409
410 /* don't try to return anything once EOF is reached */
411 if (info->rtfClass == rtfEOF) {
412 return rtfEOF;
413 }
414
415 for (;;)
416 {
419 if (p != NULL)
420 (*p) (info); /* give read hook a look at token */
421
422 /* Silently discard newlines, carriage returns, nulls. */
423 if (!(info->rtfClass == rtfText && info->rtfFormat != SF_TEXT
424 && (info->rtfMajor == '\r' || info->rtfMajor == '\n' || info->rtfMajor == '\0')))
425 break;
426 }
427 return (info->rtfClass);
428}
429
430
432{
433 if (info->pushedClass >= 0) /* there's already an ungotten token */
434 ERR ("cannot unget two tokens\n");
435 if (info->rtfClass < 0)
436 ERR ("no token to unget\n");
437 info->pushedClass = info->rtfClass;
438 info->pushedMajor = info->rtfMajor;
439 info->pushedMinor = info->rtfMinor;
440 info->pushedParam = info->rtfParam;
441 lstrcpyA (info->pushedTextBuf, info->rtfTextBuf);
442 /* The read hook decrements stackTop on rtfEndGroup, so
443 * increment the value to compensate for it being decremented
444 * twice due to the RTFUngetToken. */
446 {
447 info->stack[info->stackTop].style = info->style;
448 ME_AddRefStyle(info->style);
449 info->stackTop++;
450 }
451}
452
453
455{
456 if (info->rtfFormat == SF_TEXT)
457 {
458 info->rtfMajor = GetChar (info);
459 info->rtfMinor = 0;
460 info->rtfParam = rtfNoParam;
461 info->rtfTextBuf[info->rtfTextLen = 0] = '\0';
462 if (info->rtfMajor == EOF)
463 info->rtfClass = rtfEOF;
464 else
465 info->rtfClass = rtfText;
466 return;
467 }
468
469 /* first check for pushed token from RTFUngetToken() */
470
471 if (info->pushedClass >= 0)
472 {
473 info->rtfClass = info->pushedClass;
474 info->rtfMajor = info->pushedMajor;
475 info->rtfMinor = info->pushedMinor;
476 info->rtfParam = info->pushedParam;
477 lstrcpyA (info->rtfTextBuf, info->pushedTextBuf);
478 info->rtfTextLen = lstrlenA(info->rtfTextBuf);
479 info->pushedClass = -1;
480 return;
481 }
482
483 /*
484 * Beyond this point, no token is ever seen twice, which is
485 * important, e.g., for making sure no "}" pops the font stack twice.
486 */
487
489}
490
491
492int
494{
495 switch (charset)
496 {
497 case ANSI_CHARSET:
498 return 1252;
499 case DEFAULT_CHARSET:
500 return CP_ACP;
501 case SYMBOL_CHARSET:
502 return CP_SYMBOL;
503 case MAC_CHARSET:
504 return CP_MACCP;
505 case SHIFTJIS_CHARSET:
506 return 932;
507 case HANGEUL_CHARSET:
508 return 949;
509 case JOHAB_CHARSET:
510 return 1361;
511 case GB2312_CHARSET:
512 return 936;
514 return 950;
515 case GREEK_CHARSET:
516 return 1253;
517 case TURKISH_CHARSET:
518 return 1254;
520 return 1258;
521 case HEBREW_CHARSET:
522 return 1255;
523 case ARABIC_CHARSET:
524 return 1256;
525 case BALTIC_CHARSET:
526 return 1257;
527 case RUSSIAN_CHARSET:
528 return 1251;
529 case THAI_CHARSET:
530 return 874;
532 return 1250;
533 case OEM_CHARSET:
534 return CP_OEMCP;
535 default:
536 {
537 CHARSETINFO csi;
538 DWORD n = charset;
539
540 /* FIXME: TranslateCharsetInfo does not work as good as it
541 * should, so let's use it only when all else fails */
543 ERR("unknown charset %d\n", charset);
544 else
545 return csi.ciACP;
546 }
547 }
548 return 0;
549}
550
551
552/* this shouldn't be called anywhere but from _RTFGetToken() */
553
555{
556 int sign;
557 int c;
558
559 /* initialize token vars */
560
561 info->rtfClass = rtfUnknown;
562 info->rtfParam = rtfNoParam;
563 info->rtfTextBuf[info->rtfTextLen = 0] = '\0';
564
565 /* get first character, which may be a pushback from previous token */
566
567 if (info->pushedChar != EOF)
568 {
569 c = info->pushedChar;
570 info->rtfTextBuf[info->rtfTextLen++] = c;
571 info->rtfTextBuf[info->rtfTextLen] = '\0';
572 info->pushedChar = EOF;
573 }
574 else if ((c = GetChar (info)) == EOF)
575 {
576 info->rtfClass = rtfEOF;
577 return;
578 }
579
580 if (c == '{')
581 {
582 info->rtfClass = rtfGroup;
583 info->rtfMajor = rtfBeginGroup;
584 return;
585 }
586 if (c == '}')
587 {
588 info->rtfClass = rtfGroup;
589 info->rtfMajor = rtfEndGroup;
590 return;
591 }
592 if (c != '\\')
593 {
594 /*
595 * Two possibilities here:
596 * 1) ASCII 9, effectively like \tab control symbol
597 * 2) literal text char
598 */
599 if (c == '\t') /* ASCII 9 */
600 {
601 info->rtfClass = rtfControl;
602 info->rtfMajor = rtfSpecialChar;
603 info->rtfMinor = rtfTab;
604 }
605 else
606 {
607 info->rtfClass = rtfText;
608 info->rtfMajor = c;
609 }
610 return;
611 }
612 if ((c = GetChar (info)) == EOF)
613 {
614 /* early eof, whoops (class is rtfUnknown) */
615 return;
616 }
617 if (!isalpha (c))
618 {
619 /*
620 * Three possibilities here:
621 * 1) hex encoded text char, e.g., \'d5, \'d3
622 * 2) special escaped text char, e.g., \{, \}
623 * 3) control symbol, e.g., \_, \-, \|, <10>
624 */
625 if (c == '\'') /* hex char */
626 {
627 int c2;
628
629 if ((c = GetChar (info)) != EOF && (c2 = GetChar (info)) != EOF
630 && isxdigit(c) && isxdigit(c2))
631 {
632 info->rtfClass = rtfText;
633 info->rtfMajor = RTFCharToHex (c) * 16 + RTFCharToHex (c2);
634 return;
635 }
636 /* early eof, whoops */
637 info->rtfClass = rtfEOF;
638 info->stream->editstream->dwError = -14;
639 return;
640 }
641
642 /* escaped char */
643 /*if (index (":{}\\", c) != NULL)*/ /* escaped char */
644 if (c == ':' || c == '{' || c == '}' || c == '\\')
645 {
646 info->rtfClass = rtfText;
647 info->rtfMajor = c;
648 return;
649 }
650
651 /* control symbol */
652 Lookup (info, info->rtfTextBuf); /* sets class, major, minor */
653 return;
654 }
655 /* control word */
656 while (isalpha (c))
657 {
658 if ((c = GetChar (info)) == EOF)
659 break;
660 }
661
662 /*
663 * At this point, the control word is all collected, so the
664 * major/minor numbers are determined before the parameter
665 * (if any) is scanned. There will be one too many characters
666 * in the buffer, though, so fix up before and restore after
667 * looking up.
668 */
669
670 if (c != EOF)
671 info->rtfTextBuf[info->rtfTextLen-1] = '\0';
672 Lookup (info, info->rtfTextBuf); /* sets class, major, minor */
673 if (c != EOF)
674 info->rtfTextBuf[info->rtfTextLen-1] = c;
675
676 /*
677 * Should be looking at first digit of parameter if there
678 * is one, unless it's negative. In that case, next char
679 * is '-', so need to gobble next char, and remember sign.
680 */
681
682 sign = 1;
683 if (c == '-')
684 {
685 sign = -1;
686 c = GetChar (info);
687 }
688 if (c != EOF && isdigit (c))
689 {
690 info->rtfParam = 0;
691 while (isdigit (c)) /* gobble parameter */
692 {
693 info->rtfParam = info->rtfParam * 10 + c - '0';
694 if ((c = GetChar (info)) == EOF)
695 break;
696 }
697 info->rtfParam *= sign;
698 }
699 /*
700 * If control symbol delimiter was a blank, gobble it.
701 * Otherwise the character is first char of next token, so
702 * push it back for next call. In either case, delete the
703 * delimiter from the token buffer.
704 */
705 if (c != EOF)
706 {
707 if (c != ' ')
708 info->pushedChar = c;
709 info->rtfTextBuf[--info->rtfTextLen] = '\0';
710 }
711}
712
713
714/*
715 * Read the next character from the input. This handles setting the
716 * current line and position-within-line variables. Those variables are
717 * set correctly whether lines end with CR, LF, or CRLF (the last being
718 * the tricky case).
719 *
720 * bumpLine indicates whether the line number should be incremented on
721 * the *next* input character.
722 */
723
724
726{
727 int c;
728 BOOL oldBumpLine;
729
730 if ((c = _RTFGetChar(info)) != EOF)
731 {
732 info->rtfTextBuf[info->rtfTextLen++] = c;
733 info->rtfTextBuf[info->rtfTextLen] = '\0';
734 }
735 if (info->prevChar == EOF)
736 info->bumpLine = TRUE;
737 oldBumpLine = info->bumpLine; /* TRUE if prev char was line ending */
738 info->bumpLine = FALSE;
739 if (c == '\r')
740 info->bumpLine = TRUE;
741 else if (c == '\n')
742 {
743 info->bumpLine = TRUE;
744 if (info->prevChar == '\r') /* oops, previous \r wasn't */
745 oldBumpLine = FALSE; /* really a line ending */
746 }
747 ++info->rtfLinePos;
748 if (oldBumpLine) /* were we supposed to increment the */
749 { /* line count on this char? */
750 ++info->rtfLineNum;
751 info->rtfLinePos = 1;
752 }
753 info->prevChar = c;
754 return (c);
755}
756
757
758/* ---------------------------------------------------------------------- */
759
760/*
761 * Special destination readers. They gobble the destination so the
762 * writer doesn't have to deal with them. That's wrong for any
763 * translator that wants to process any of these itself. In that
764 * case, these readers should be overridden by installing a different
765 * destination callback.
766 *
767 * NOTE: The last token read by each of these reader will be the
768 * destination's terminating '}', which will then be the current token.
769 * That '}' token is passed to RTFRouteToken() - the writer has already
770 * seen the '{' that began the destination group, and may have pushed a
771 * state; it also needs to know at the end of the group that a state
772 * should be popped.
773 *
774 * It's important that rtf.h and the control token lookup table list
775 * as many symbols as possible, because these destination readers
776 * unfortunately make strict assumptions about the input they expect,
777 * and a token of class rtfUnknown will throw them off easily.
778 */
779
780
781/*
782 * Read { \fonttbl ... } destination. Old font tables don't have
783 * braces around each table entry; try to adjust for that.
784 */
785
787{
788 RTFFont *fp = NULL;
789 char buf[rtfBufSiz], *bp;
790 int old = -1;
791
792 for (;;)
793 {
795 if (info->rtfClass == rtfEOF)
796 break;
798 break;
799 if (old < 0) /* first entry - determine tbl type */
800 {
802 old = 1; /* no brace */
804 old = 0; /* brace */
805 else /* can't tell! */
806 ERR ("cannot determine format\n");
807 }
808 if (old == 0) /* need to find "{" here */
809 {
811 ERR ("missing \"{\"\n");
812 RTFGetToken (info); /* yes, skip to next token */
813 if (info->rtfClass == rtfEOF)
814 break;
815 }
816 fp = New (RTFFont);
817 if (fp == NULL) {
818 ERR ("cannot allocate font entry\n");
819 break;
820 }
821
822 fp->rtfNextFont = info->fontList;
823 info->fontList = fp;
824
825 fp->rtfFName = NULL;
826 fp->rtfFAltName = NULL;
827 fp->rtfFNum = -1;
829 fp->rtfFCharSet = DEFAULT_CHARSET; /* 1 */
831 fp->rtfFType = 0;
832 fp->rtfFCodePage = CP_ACP;
833
834 while (info->rtfClass != rtfEOF
835 && !RTFCheckCM (info, rtfText, ';')
837 {
838 if (info->rtfClass == rtfControl)
839 {
840 switch (info->rtfMajor)
841 {
842 default:
843 /* ignore token but announce it */
844 WARN ("unknown token \"%s\"\n",
845 info->rtfTextBuf);
846 break;
847 case rtfFontFamily:
848 fp->rtfFFamily = info->rtfMinor;
849 break;
850 case rtfCharAttr:
851 switch (info->rtfMinor)
852 {
853 default:
854 break; /* ignore unknown? */
855 case rtfFontNum:
856 fp->rtfFNum = info->rtfParam;
857 break;
858 }
859 break;
860 case rtfFontAttr:
861 switch (info->rtfMinor)
862 {
863 default:
864 break; /* ignore unknown? */
865 case rtfFontCharSet:
866 fp->rtfFCharSet = info->rtfParam;
867 if (!fp->rtfFCodePage)
868 fp->rtfFCodePage = RTFCharSetToCodePage(info, info->rtfParam);
869 break;
870 case rtfFontPitch:
871 fp->rtfFPitch = info->rtfParam;
872 break;
873 case rtfFontCodePage:
874 fp->rtfFCodePage = info->rtfParam;
875 break;
876 case rtfFTypeNil:
877 case rtfFTypeTrueType:
878 fp->rtfFType = info->rtfParam;
879 break;
880 }
881 break;
882 }
883 }
884 else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup)) /* dest */
885 {
886 RTFSkipGroup (info); /* ignore for now */
887 }
888 else if (info->rtfClass == rtfText) /* font name */
889 {
890 bp = buf;
891 while (info->rtfClass == rtfText
892 && !RTFCheckCM (info, rtfText, ';'))
893 {
894 *bp++ = info->rtfMajor;
896 }
897
898 /* FIX: in some cases the <fontinfo> isn't finished with a semi-column */
900 {
902 }
903 *bp = '\0';
904 fp->rtfFName = RTFStrSave (buf);
905 if (fp->rtfFName == NULL)
906 ERR ("cannot allocate font name\n");
907 /* already have next token; don't read one */
908 /* at bottom of loop */
909 continue;
910 }
911 else
912 {
913 /* ignore token but announce it */
914 WARN ("unknown token \"%s\"\n", info->rtfTextBuf);
915 }
917 if (info->rtfClass == rtfEOF)
918 break;
919 }
920 if (info->rtfClass == rtfEOF)
921 break;
922 if (old == 0) /* need to see "}" here */
923 {
926 ERR ("missing \"}\"\n");
927 if (info->rtfClass == rtfEOF)
928 break;
929 }
930
931 /* Apply the real properties of the default font */
932 if (fp->rtfFNum == info->defFont)
933 {
934 if (info->ansiCodePage != CP_UTF8)
935 info->codePage = fp->rtfFCodePage;
936 TRACE("default font codepage %d\n", info->codePage);
937 }
938 }
939 if (!fp || (fp->rtfFNum == -1))
940 ERR("missing font number\n");
941/*
942 * Could check other pieces of structure here, too, I suppose.
943 */
944 RTFRouteToken (info); /* feed "}" back to router */
945
946 /* Set default font */
947 info->rtfClass = rtfControl;
948 info->rtfMajor = rtfCharAttr;
949 info->rtfMinor = rtfFontNum;
950 info->rtfParam = info->defFont;
951 lstrcpyA(info->rtfTextBuf, "f");
953}
954
955
956/*
957 * The color table entries have color values of -1 if
958 * the default color should be used for the entry (only
959 * a semi-colon is given in the definition, no color values).
960 * There will be a problem if a partial entry (1 or 2 but
961 * not 3 color values) is given. The possibility is ignored
962 * here.
963 */
964
966{
967 RTFColor *cp;
968 int cnum = 0;
969 int group_level = 1;
970
971 for (;;)
972 {
974 if (info->rtfClass == rtfEOF)
975 break;
977 {
978 group_level--;
979 if (!group_level)
980 break;
981 continue;
982 }
984 {
985 group_level++;
986 continue;
987 }
988
989 cp = New (RTFColor);
990 if (cp == NULL) {
991 ERR ("cannot allocate color entry\n");
992 break;
993 }
994 cp->rtfCNum = cnum++;
995 cp->rtfNextColor = info->colorList;
996 info->colorList = cp;
998 cp->rtfCRed = cp->rtfCGreen = cp->rtfCBlue = -1;
999 else {
1000 cp->rtfCRed = cp->rtfCGreen = cp->rtfCBlue = 0;
1001 do {
1002 switch (info->rtfMinor)
1003 {
1004 case rtfRed: cp->rtfCRed = info->rtfParam & 0xFF; break;
1005 case rtfGreen: cp->rtfCGreen = info->rtfParam & 0xFF; break;
1006 case rtfBlue: cp->rtfCBlue = info->rtfParam & 0xFF; break;
1007 }
1008 RTFGetToken (info);
1009 } while (RTFCheckCM (info, rtfControl, rtfColorName));
1010 }
1011 if (info->rtfClass == rtfEOF)
1012 break;
1013 if (!RTFCheckCM (info, rtfText, ';'))
1014 ERR ("malformed entry\n");
1015 }
1016 RTFRouteToken (info); /* feed "}" back to router */
1017}
1018
1019
1020/*
1021 * The "Normal" style definition doesn't contain any style number,
1022 * all others do. Normal style is given style rtfNormalStyleNum.
1023 */
1024
1026{
1027 RTFStyle *sp;
1028 RTFStyleElt *sep, *sepLast;
1029 char buf[rtfBufSiz], *bp;
1030 int real_style;
1031
1032 for (;;)
1033 {
1034 RTFGetToken (info);
1035 if (info->rtfClass == rtfEOF)
1036 break;
1038 break;
1039 sp = New (RTFStyle);
1040 if (sp == NULL) {
1041 ERR ("cannot allocate stylesheet entry\n");
1042 break;
1043 }
1044 sp->rtfSName = NULL;
1045 sp->rtfSNum = -1;
1046 sp->rtfSType = rtfParStyle;
1047 sp->rtfSAdditive = 0;
1048 sp->rtfSBasedOn = rtfNoStyleNum;
1049 sp->rtfSNextPar = -1;
1050 sp->rtfSSEList = sepLast = NULL;
1051 sp->rtfNextStyle = info->styleList;
1052 sp->rtfExpanding = 0;
1053 info->styleList = sp;
1055 ERR ("missing \"{\"\n");
1056 real_style = TRUE;
1057 for (;;)
1058 {
1059 RTFGetToken (info);
1060 if (info->rtfClass == rtfEOF
1061 || RTFCheckCM (info, rtfText, ';'))
1062 break;
1063 if (info->rtfClass == rtfControl)
1064 {
1067 ERR("skipping optional destination\n");
1069 info->rtfClass = rtfGroup;
1070 info->rtfMajor = rtfEndGroup;
1071 real_style = FALSE;
1072 break; /* ignore "\*" */
1073 }
1075 {
1076 sp->rtfSNum = info->rtfParam;
1077 sp->rtfSType = rtfParStyle;
1078 continue;
1079 }
1081 {
1082 sp->rtfSNum = info->rtfParam;
1083 sp->rtfSType = rtfCharStyle;
1084 continue;
1085 }
1087 {
1088 sp->rtfSNum = info->rtfParam;
1089 sp->rtfSType = rtfSectStyle;
1090 continue;
1091 }
1093 {
1094 sp->rtfSBasedOn = info->rtfParam;
1095 continue;
1096 }
1098 {
1099 sp->rtfSAdditive = 1;
1100 continue;
1101 }
1103 {
1104 sp->rtfSNextPar = info->rtfParam;
1105 continue;
1106 }
1107 sep = New (RTFStyleElt);
1108 if (sep == NULL)
1109 {
1110 ERR ("cannot allocate style element\n");
1111 break;
1112 }
1113 sep->rtfSEClass = info->rtfClass;
1114 sep->rtfSEMajor = info->rtfMajor;
1115 sep->rtfSEMinor = info->rtfMinor;
1116 sep->rtfSEParam = info->rtfParam;
1117 sep->rtfSEText = RTFStrSave (info->rtfTextBuf);
1118 if (sep->rtfSEText == NULL)
1119 ERR ("cannot allocate style element text\n");
1120 if (sepLast == NULL)
1121 sp->rtfSSEList = sep; /* first element */
1122 else /* add to end */
1123 sepLast->rtfNextSE = sep;
1124 sep->rtfNextSE = NULL;
1125 sepLast = sep;
1126 }
1128 {
1129 /*
1130 * This passes over "{\*\keycode ... }, among
1131 * other things. A temporary (perhaps) hack.
1132 */
1133 ERR("skipping begin\n");
1135 continue;
1136 }
1137 else if (info->rtfClass == rtfText) /* style name */
1138 {
1139 bp = buf;
1140 while (info->rtfClass == rtfText)
1141 {
1142 if (info->rtfMajor == ';')
1143 {
1144 /* put back for "for" loop */
1146 break;
1147 }
1148 *bp++ = info->rtfMajor;
1149 RTFGetToken (info);
1150 }
1151 *bp = '\0';
1152 sp->rtfSName = RTFStrSave (buf);
1153 if (sp->rtfSName == NULL)
1154 ERR ("cannot allocate style name\n");
1155 }
1156 else /* unrecognized */
1157 {
1158 /* ignore token but announce it */
1159 WARN ("unknown token \"%s\"\n", info->rtfTextBuf);
1160 }
1161 }
1162 if (real_style) {
1163 RTFGetToken (info);
1165 ERR ("missing \"}\"\n");
1166 /*
1167 * Check over the style structure. A name is a must.
1168 * If no style number was specified, check whether it's the
1169 * Normal style (in which case it's given style number
1170 * rtfNormalStyleNum). Note that some "normal" style names
1171 * just begin with "Normal" and can have other stuff following,
1172 * e.g., "Normal,Times 10 point". Ugh.
1173 *
1174 * Some German RTF writers use "Standard" instead of "Normal".
1175 */
1176 if (sp->rtfSName == NULL)
1177 ERR ("missing style name\n");
1178 if (sp->rtfSNum < 0)
1179 {
1180 if (strncmp (buf, "Normal", 6) != 0
1181 && strncmp (buf, "Standard", 8) != 0)
1182 ERR ("missing style number\n");
1183 sp->rtfSNum = rtfNormalStyleNum;
1184 }
1185 if (sp->rtfSNextPar == -1) /* if \snext not given, */
1186 sp->rtfSNextPar = sp->rtfSNum; /* next is itself */
1187 }
1188 /* otherwise we're just dealing with fake end group from skipped group */
1189 }
1190 RTFRouteToken (info); /* feed "}" back to router */
1191}
1192
1193
1195{
1197 RTFRouteToken (info); /* feed "}" back to router */
1198}
1199
1200
1202{
1204 RTFRouteToken (info); /* feed "}" back to router */
1205}
1206
1207
1209{
1211 RTFRouteToken (info); /* feed "}" back to router */
1212}
1213
1214
1215/* ---------------------------------------------------------------------- */
1216
1217/*
1218 * Routines to return pieces of stylesheet, or font or color tables.
1219 * References to style 0 are mapped onto the Normal style.
1220 */
1221
1223{
1224 RTFFont *f;
1225
1226 if (num == -1)
1227 return (info->fontList);
1228 for (f = info->fontList; f != NULL; f = f->rtfNextFont)
1229 {
1230 if (f->rtfFNum == num)
1231 break;
1232 }
1233 return (f); /* NULL if not found */
1234}
1235
1236
1238{
1239 RTFColor *c;
1240
1241 if (num == -1)
1242 return (info->colorList);
1243 for (c = info->colorList; c != NULL; c = c->rtfNextColor)
1244 {
1245 if (c->rtfCNum == num)
1246 break;
1247 }
1248 return (c); /* NULL if not found */
1249}
1250
1251
1252/* ---------------------------------------------------------------------- */
1253
1254/*
1255 * Control symbol lookup routines
1256 */
1257
1258
1259typedef struct RTFKey RTFKey;
1260
1262{
1263 int rtfKMajor; /* major number */
1264 int rtfKMinor; /* minor number */
1265 const char *rtfKStr; /* symbol name */
1266 int rtfKHash; /* symbol name hash value */
1267};
1268
1269/*
1270 * A minor number of -1 means the token has no minor number
1271 * (all valid minor numbers are >= 0).
1272 */
1273
1274static RTFKey rtfKey[] =
1275{
1276 /*
1277 * Special characters
1278 */
1279
1280 { rtfSpecialChar, rtfIIntVersion, "vern", 0 },
1281 { rtfSpecialChar, rtfICreateTime, "creatim", 0 },
1282 { rtfSpecialChar, rtfIRevisionTime, "revtim", 0 },
1283 { rtfSpecialChar, rtfIPrintTime, "printim", 0 },
1284 { rtfSpecialChar, rtfIBackupTime, "buptim", 0 },
1285 { rtfSpecialChar, rtfIEditTime, "edmins", 0 },
1286 { rtfSpecialChar, rtfIYear, "yr", 0 },
1287 { rtfSpecialChar, rtfIMonth, "mo", 0 },
1288 { rtfSpecialChar, rtfIDay, "dy", 0 },
1289 { rtfSpecialChar, rtfIHour, "hr", 0 },
1290 { rtfSpecialChar, rtfIMinute, "min", 0 },
1291 { rtfSpecialChar, rtfISecond, "sec", 0 },
1292 { rtfSpecialChar, rtfINPages, "nofpages", 0 },
1293 { rtfSpecialChar, rtfINWords, "nofwords", 0 },
1294 { rtfSpecialChar, rtfINChars, "nofchars", 0 },
1295 { rtfSpecialChar, rtfIIntID, "id", 0 },
1296
1297 { rtfSpecialChar, rtfCurHeadDate, "chdate", 0 },
1298 { rtfSpecialChar, rtfCurHeadDateLong, "chdpl", 0 },
1299 { rtfSpecialChar, rtfCurHeadDateAbbrev, "chdpa", 0 },
1300 { rtfSpecialChar, rtfCurHeadTime, "chtime", 0 },
1301 { rtfSpecialChar, rtfCurHeadPage, "chpgn", 0 },
1302 { rtfSpecialChar, rtfSectNum, "sectnum", 0 },
1303 { rtfSpecialChar, rtfCurFNote, "chftn", 0 },
1304 { rtfSpecialChar, rtfCurAnnotRef, "chatn", 0 },
1305 { rtfSpecialChar, rtfFNoteSep, "chftnsep", 0 },
1306 { rtfSpecialChar, rtfFNoteCont, "chftnsepc", 0 },
1307 { rtfSpecialChar, rtfCell, "cell", 0 },
1308 { rtfSpecialChar, rtfRow, "row", 0 },
1309 { rtfSpecialChar, rtfPar, "par", 0 },
1310 /* newline and carriage return are synonyms for */
1311 /* \par when they are preceded by a \ character */
1312 { rtfSpecialChar, rtfPar, "\n", 0 },
1313 { rtfSpecialChar, rtfPar, "\r", 0 },
1314 { rtfSpecialChar, rtfSect, "sect", 0 },
1315 { rtfSpecialChar, rtfPage, "page", 0 },
1316 { rtfSpecialChar, rtfColumn, "column", 0 },
1317 { rtfSpecialChar, rtfLine, "line", 0 },
1318 { rtfSpecialChar, rtfSoftPage, "softpage", 0 },
1319 { rtfSpecialChar, rtfSoftColumn, "softcol", 0 },
1320 { rtfSpecialChar, rtfSoftLine, "softline", 0 },
1321 { rtfSpecialChar, rtfSoftLineHt, "softlheight", 0 },
1322 { rtfSpecialChar, rtfTab, "tab", 0 },
1323 { rtfSpecialChar, rtfEmDash, "emdash", 0 },
1324 { rtfSpecialChar, rtfEnDash, "endash", 0 },
1325 { rtfSpecialChar, rtfEmSpace, "emspace", 0 },
1326 { rtfSpecialChar, rtfEnSpace, "enspace", 0 },
1327 { rtfSpecialChar, rtfBullet, "bullet", 0 },
1328 { rtfSpecialChar, rtfLQuote, "lquote", 0 },
1329 { rtfSpecialChar, rtfRQuote, "rquote", 0 },
1330 { rtfSpecialChar, rtfLDblQuote, "ldblquote", 0 },
1331 { rtfSpecialChar, rtfRDblQuote, "rdblquote", 0 },
1332 { rtfSpecialChar, rtfFormula, "|", 0 },
1333 { rtfSpecialChar, rtfNoBrkSpace, "~", 0 },
1334 { rtfSpecialChar, rtfNoReqHyphen, "-", 0 },
1335 { rtfSpecialChar, rtfNoBrkHyphen, "_", 0 },
1336 { rtfSpecialChar, rtfOptDest, "*", 0 },
1337 { rtfSpecialChar, rtfLTRMark, "ltrmark", 0 },
1338 { rtfSpecialChar, rtfRTLMark, "rtlmark", 0 },
1339 { rtfSpecialChar, rtfNoWidthJoiner, "zwj", 0 },
1340 { rtfSpecialChar, rtfNoWidthNonJoiner, "zwnj", 0 },
1341 /* is this valid? */
1342 { rtfSpecialChar, rtfCurHeadPict, "chpict", 0 },
1343 { rtfSpecialChar, rtfUnicode, "u", 0 },
1344 { rtfSpecialChar, rtfNestCell, "nestcell", 0 },
1345 { rtfSpecialChar, rtfNestRow, "nestrow", 0 },
1346
1347 /*
1348 * Character formatting attributes
1349 */
1350
1351 { rtfCharAttr, rtfPlain, "plain", 0 },
1352 { rtfCharAttr, rtfBold, "b", 0 },
1353 { rtfCharAttr, rtfAllCaps, "caps", 0 },
1354 { rtfCharAttr, rtfDeleted, "deleted", 0 },
1355 { rtfCharAttr, rtfSubScript, "dn", 0 },
1356 { rtfCharAttr, rtfSubScrShrink, "sub", 0 },
1357 { rtfCharAttr, rtfNoSuperSub, "nosupersub", 0 },
1358 { rtfCharAttr, rtfExpand, "expnd", 0 },
1359 { rtfCharAttr, rtfExpandTwips, "expndtw", 0 },
1360 { rtfCharAttr, rtfKerning, "kerning", 0 },
1361 { rtfCharAttr, rtfFontNum, "f", 0 },
1362 { rtfCharAttr, rtfFontSize, "fs", 0 },
1363 { rtfCharAttr, rtfItalic, "i", 0 },
1364 { rtfCharAttr, rtfOutline, "outl", 0 },
1365 { rtfCharAttr, rtfRevised, "revised", 0 },
1366 { rtfCharAttr, rtfRevAuthor, "revauth", 0 },
1367 { rtfCharAttr, rtfRevDTTM, "revdttm", 0 },
1368 { rtfCharAttr, rtfSmallCaps, "scaps", 0 },
1369 { rtfCharAttr, rtfShadow, "shad", 0 },
1370 { rtfCharAttr, rtfStrikeThru, "strike", 0 },
1371 { rtfCharAttr, rtfUnderline, "ul", 0 },
1372 { rtfCharAttr, rtfDotUnderline, "uld", 0 },
1373 { rtfCharAttr, rtfDbUnderline, "uldb", 0 },
1374 { rtfCharAttr, rtfNoUnderline, "ulnone", 0 },
1375 { rtfCharAttr, rtfWordUnderline, "ulw", 0 },
1376 { rtfCharAttr, rtfSuperScript, "up", 0 },
1377 { rtfCharAttr, rtfSuperScrShrink, "super", 0 },
1378 { rtfCharAttr, rtfInvisible, "v", 0 },
1379 { rtfCharAttr, rtfForeColor, "cf", 0 },
1380 { rtfCharAttr, rtfBackColor, "highlight", 0 },
1381 { rtfCharAttr, rtfRTLChar, "rtlch", 0 },
1382 { rtfCharAttr, rtfLTRChar, "ltrch", 0 },
1383 { rtfCharAttr, rtfCharStyleNum, "cs", 0 },
1384 { rtfCharAttr, rtfCharCharSet, "cchs", 0 },
1385 { rtfCharAttr, rtfLanguage, "lang", 0 },
1386 /* this has disappeared from spec 1.2 */
1387 { rtfCharAttr, rtfGray, "gray", 0 },
1388 { rtfCharAttr, rtfUnicodeLength, "uc", 0 },
1389
1390 /*
1391 * Paragraph formatting attributes
1392 */
1393
1394 { rtfParAttr, rtfParDef, "pard", 0 },
1395 { rtfParAttr, rtfStyleNum, "s", 0 },
1396 { rtfParAttr, rtfHyphenate, "hyphpar", 0 },
1397 { rtfParAttr, rtfInTable, "intbl", 0 },
1398 { rtfParAttr, rtfKeep, "keep", 0 },
1399 { rtfParAttr, rtfNoWidowControl, "nowidctlpar", 0 },
1400 { rtfParAttr, rtfKeepNext, "keepn", 0 },
1401 { rtfParAttr, rtfOutlineLevel, "level", 0 },
1402 { rtfParAttr, rtfNoLineNum, "noline", 0 },
1403 { rtfParAttr, rtfPBBefore, "pagebb", 0 },
1404 { rtfParAttr, rtfSideBySide, "sbys", 0 },
1405 { rtfParAttr, rtfQuadLeft, "ql", 0 },
1406 { rtfParAttr, rtfQuadRight, "qr", 0 },
1407 { rtfParAttr, rtfQuadJust, "qj", 0 },
1408 { rtfParAttr, rtfQuadCenter, "qc", 0 },
1409 { rtfParAttr, rtfFirstIndent, "fi", 0 },
1410 { rtfParAttr, rtfLeftIndent, "li", 0 },
1411 { rtfParAttr, rtfRightIndent, "ri", 0 },
1412 { rtfParAttr, rtfSpaceBefore, "sb", 0 },
1413 { rtfParAttr, rtfSpaceAfter, "sa", 0 },
1414 { rtfParAttr, rtfSpaceBetween, "sl", 0 },
1415 { rtfParAttr, rtfSpaceMultiply, "slmult", 0 },
1416
1417 { rtfParAttr, rtfSubDocument, "subdocument", 0 },
1418
1419 { rtfParAttr, rtfRTLPar, "rtlpar", 0 },
1420 { rtfParAttr, rtfLTRPar, "ltrpar", 0 },
1421
1422 { rtfParAttr, rtfTabPos, "tx", 0 },
1423 /*
1424 * FrameMaker writes \tql (to mean left-justified tab, apparently)
1425 * although it's not in the spec. It's also redundant, since lj
1426 * tabs are the default.
1427 */
1428 { rtfParAttr, rtfTabLeft, "tql", 0 },
1429 { rtfParAttr, rtfTabRight, "tqr", 0 },
1430 { rtfParAttr, rtfTabCenter, "tqc", 0 },
1431 { rtfParAttr, rtfTabDecimal, "tqdec", 0 },
1432 { rtfParAttr, rtfTabBar, "tb", 0 },
1433 { rtfParAttr, rtfLeaderDot, "tldot", 0 },
1434 { rtfParAttr, rtfLeaderHyphen, "tlhyph", 0 },
1435 { rtfParAttr, rtfLeaderUnder, "tlul", 0 },
1436 { rtfParAttr, rtfLeaderThick, "tlth", 0 },
1437 { rtfParAttr, rtfLeaderEqual, "tleq", 0 },
1438
1439 { rtfParAttr, rtfParLevel, "pnlvl", 0 },
1440 { rtfParAttr, rtfParBullet, "pnlvlblt", 0 },
1441 { rtfParAttr, rtfParSimple, "pnlvlbody", 0 },
1442 { rtfParAttr, rtfParNumCont, "pnlvlcont", 0 },
1443 { rtfParAttr, rtfParNumOnce, "pnnumonce", 0 },
1444 { rtfParAttr, rtfParNumAcross, "pnacross", 0 },
1445 { rtfParAttr, rtfParHangIndent, "pnhang", 0 },
1446 { rtfParAttr, rtfParNumRestart, "pnrestart", 0 },
1447 { rtfParAttr, rtfParNumCardinal, "pncard", 0 },
1448 { rtfParAttr, rtfParNumDecimal, "pndec", 0 },
1449 { rtfParAttr, rtfParNumULetter, "pnucltr", 0 },
1450 { rtfParAttr, rtfParNumURoman, "pnucrm", 0 },
1451 { rtfParAttr, rtfParNumLLetter, "pnlcltr", 0 },
1452 { rtfParAttr, rtfParNumLRoman, "pnlcrm", 0 },
1453 { rtfParAttr, rtfParNumOrdinal, "pnord", 0 },
1454 { rtfParAttr, rtfParNumOrdinalText, "pnordt", 0 },
1455 { rtfParAttr, rtfParNumBold, "pnb", 0 },
1456 { rtfParAttr, rtfParNumItalic, "pni", 0 },
1457 { rtfParAttr, rtfParNumAllCaps, "pncaps", 0 },
1458 { rtfParAttr, rtfParNumSmallCaps, "pnscaps", 0 },
1459 { rtfParAttr, rtfParNumUnder, "pnul", 0 },
1460 { rtfParAttr, rtfParNumDotUnder, "pnuld", 0 },
1461 { rtfParAttr, rtfParNumDbUnder, "pnuldb", 0 },
1462 { rtfParAttr, rtfParNumNoUnder, "pnulnone", 0 },
1463 { rtfParAttr, rtfParNumWordUnder, "pnulw", 0 },
1464 { rtfParAttr, rtfParNumStrikethru, "pnstrike", 0 },
1465 { rtfParAttr, rtfParNumForeColor, "pncf", 0 },
1466 { rtfParAttr, rtfParNumFont, "pnf", 0 },
1467 { rtfParAttr, rtfParNumFontSize, "pnfs", 0 },
1468 { rtfParAttr, rtfParNumIndent, "pnindent", 0 },
1469 { rtfParAttr, rtfParNumSpacing, "pnsp", 0 },
1470 { rtfParAttr, rtfParNumInclPrev, "pnprev", 0 },
1471 { rtfParAttr, rtfParNumCenter, "pnqc", 0 },
1472 { rtfParAttr, rtfParNumLeft, "pnql", 0 },
1473 { rtfParAttr, rtfParNumRight, "pnqr", 0 },
1474 { rtfParAttr, rtfParNumStartAt, "pnstart", 0 },
1475
1476 { rtfParAttr, rtfBorderTop, "brdrt", 0 },
1477 { rtfParAttr, rtfBorderBottom, "brdrb", 0 },
1478 { rtfParAttr, rtfBorderLeft, "brdrl", 0 },
1479 { rtfParAttr, rtfBorderRight, "brdrr", 0 },
1480 { rtfParAttr, rtfBorderBetween, "brdrbtw", 0 },
1481 { rtfParAttr, rtfBorderBar, "brdrbar", 0 },
1482 { rtfParAttr, rtfBorderBox, "box", 0 },
1483 { rtfParAttr, rtfBorderSingle, "brdrs", 0 },
1484 { rtfParAttr, rtfBorderThick, "brdrth", 0 },
1485 { rtfParAttr, rtfBorderShadow, "brdrsh", 0 },
1486 { rtfParAttr, rtfBorderDouble, "brdrdb", 0 },
1487 { rtfParAttr, rtfBorderDot, "brdrdot", 0 },
1488 { rtfParAttr, rtfBorderDot, "brdrdash", 0 },
1489 { rtfParAttr, rtfBorderHair, "brdrhair", 0 },
1490 { rtfParAttr, rtfBorderWidth, "brdrw", 0 },
1491 { rtfParAttr, rtfBorderColor, "brdrcf", 0 },
1492 { rtfParAttr, rtfBorderSpace, "brsp", 0 },
1493
1494 { rtfParAttr, rtfShading, "shading", 0 },
1495 { rtfParAttr, rtfBgPatH, "bghoriz", 0 },
1496 { rtfParAttr, rtfBgPatV, "bgvert", 0 },
1497 { rtfParAttr, rtfFwdDiagBgPat, "bgfdiag", 0 },
1498 { rtfParAttr, rtfBwdDiagBgPat, "bgbdiag", 0 },
1499 { rtfParAttr, rtfHatchBgPat, "bgcross", 0 },
1500 { rtfParAttr, rtfDiagHatchBgPat, "bgdcross", 0 },
1501 { rtfParAttr, rtfDarkBgPatH, "bgdkhoriz", 0 },
1502 { rtfParAttr, rtfDarkBgPatV, "bgdkvert", 0 },
1503 { rtfParAttr, rtfFwdDarkBgPat, "bgdkfdiag", 0 },
1504 { rtfParAttr, rtfBwdDarkBgPat, "bgdkbdiag", 0 },
1505 { rtfParAttr, rtfDarkHatchBgPat, "bgdkcross", 0 },
1506 { rtfParAttr, rtfDarkDiagHatchBgPat, "bgdkdcross", 0 },
1507 { rtfParAttr, rtfBgPatLineColor, "cfpat", 0 },
1508 { rtfParAttr, rtfBgPatColor, "cbpat", 0 },
1509 { rtfParAttr, rtfNestLevel, "itap", 0 },
1510
1511 /*
1512 * Section formatting attributes
1513 */
1514
1515 { rtfSectAttr, rtfSectDef, "sectd", 0 },
1516 { rtfSectAttr, rtfENoteHere, "endnhere", 0 },
1517 { rtfSectAttr, rtfPrtBinFirst, "binfsxn", 0 },
1518 { rtfSectAttr, rtfPrtBin, "binsxn", 0 },
1519 { rtfSectAttr, rtfSectStyleNum, "ds", 0 },
1520
1521 { rtfSectAttr, rtfNoBreak, "sbknone", 0 },
1522 { rtfSectAttr, rtfColBreak, "sbkcol", 0 },
1523 { rtfSectAttr, rtfPageBreak, "sbkpage", 0 },
1524 { rtfSectAttr, rtfEvenBreak, "sbkeven", 0 },
1525 { rtfSectAttr, rtfOddBreak, "sbkodd", 0 },
1526
1527 { rtfSectAttr, rtfColumns, "cols", 0 },
1528 { rtfSectAttr, rtfColumnSpace, "colsx", 0 },
1529 { rtfSectAttr, rtfColumnNumber, "colno", 0 },
1530 { rtfSectAttr, rtfColumnSpRight, "colsr", 0 },
1531 { rtfSectAttr, rtfColumnWidth, "colw", 0 },
1532 { rtfSectAttr, rtfColumnLine, "linebetcol", 0 },
1533
1534 { rtfSectAttr, rtfLineModulus, "linemod", 0 },
1535 { rtfSectAttr, rtfLineDist, "linex", 0 },
1536 { rtfSectAttr, rtfLineStarts, "linestarts", 0 },
1537 { rtfSectAttr, rtfLineRestart, "linerestart", 0 },
1538 { rtfSectAttr, rtfLineRestartPg, "lineppage", 0 },
1539 { rtfSectAttr, rtfLineCont, "linecont", 0 },
1540
1541 { rtfSectAttr, rtfSectPageWid, "pgwsxn", 0 },
1542 { rtfSectAttr, rtfSectPageHt, "pghsxn", 0 },
1543 { rtfSectAttr, rtfSectMarginLeft, "marglsxn", 0 },
1544 { rtfSectAttr, rtfSectMarginRight, "margrsxn", 0 },
1545 { rtfSectAttr, rtfSectMarginTop, "margtsxn", 0 },
1546 { rtfSectAttr, rtfSectMarginBottom, "margbsxn", 0 },
1547 { rtfSectAttr, rtfSectMarginGutter, "guttersxn", 0 },
1548 { rtfSectAttr, rtfSectLandscape, "lndscpsxn", 0 },
1549 { rtfSectAttr, rtfTitleSpecial, "titlepg", 0 },
1550 { rtfSectAttr, rtfHeaderY, "headery", 0 },
1551 { rtfSectAttr, rtfFooterY, "footery", 0 },
1552
1553 { rtfSectAttr, rtfPageStarts, "pgnstarts", 0 },
1554 { rtfSectAttr, rtfPageCont, "pgncont", 0 },
1555 { rtfSectAttr, rtfPageRestart, "pgnrestart", 0 },
1556 { rtfSectAttr, rtfPageNumRight, "pgnx", 0 },
1557 { rtfSectAttr, rtfPageNumTop, "pgny", 0 },
1558 { rtfSectAttr, rtfPageDecimal, "pgndec", 0 },
1559 { rtfSectAttr, rtfPageURoman, "pgnucrm", 0 },
1560 { rtfSectAttr, rtfPageLRoman, "pgnlcrm", 0 },
1561 { rtfSectAttr, rtfPageULetter, "pgnucltr", 0 },
1562 { rtfSectAttr, rtfPageLLetter, "pgnlcltr", 0 },
1563 { rtfSectAttr, rtfPageNumHyphSep, "pgnhnsh", 0 },
1564 { rtfSectAttr, rtfPageNumSpaceSep, "pgnhnsp", 0 },
1565 { rtfSectAttr, rtfPageNumColonSep, "pgnhnsc", 0 },
1566 { rtfSectAttr, rtfPageNumEmdashSep, "pgnhnsm", 0 },
1567 { rtfSectAttr, rtfPageNumEndashSep, "pgnhnsn", 0 },
1568
1569 { rtfSectAttr, rtfTopVAlign, "vertalt", 0 },
1570 /* misspelled as "vertal" in specification 1.0 */
1571 { rtfSectAttr, rtfBottomVAlign, "vertalb", 0 },
1572 { rtfSectAttr, rtfCenterVAlign, "vertalc", 0 },
1573 { rtfSectAttr, rtfJustVAlign, "vertalj", 0 },
1574
1575 { rtfSectAttr, rtfRTLSect, "rtlsect", 0 },
1576 { rtfSectAttr, rtfLTRSect, "ltrsect", 0 },
1577
1578 /* I've seen these in an old spec, but not in real files... */
1579 /*rtfSectAttr, rtfNoBreak, "nobreak", 0,*/
1580 /*rtfSectAttr, rtfColBreak, "colbreak", 0,*/
1581 /*rtfSectAttr, rtfPageBreak, "pagebreak", 0,*/
1582 /*rtfSectAttr, rtfEvenBreak, "evenbreak", 0,*/
1583 /*rtfSectAttr, rtfOddBreak, "oddbreak", 0,*/
1584
1585 /*
1586 * Document formatting attributes
1587 */
1588
1589 { rtfDocAttr, rtfDefTab, "deftab", 0 },
1590 { rtfDocAttr, rtfHyphHotZone, "hyphhotz", 0 },
1591 { rtfDocAttr, rtfHyphConsecLines, "hyphconsec", 0 },
1592 { rtfDocAttr, rtfHyphCaps, "hyphcaps", 0 },
1593 { rtfDocAttr, rtfHyphAuto, "hyphauto", 0 },
1594 { rtfDocAttr, rtfLineStart, "linestart", 0 },
1595 { rtfDocAttr, rtfFracWidth, "fracwidth", 0 },
1596 /* \makeback was given in old version of spec, it's now */
1597 /* listed as \makebackup */
1598 { rtfDocAttr, rtfMakeBackup, "makeback", 0 },
1599 { rtfDocAttr, rtfMakeBackup, "makebackup", 0 },
1600 { rtfDocAttr, rtfRTFDefault, "defformat", 0 },
1601 { rtfDocAttr, rtfPSOverlay, "psover", 0 },
1602 { rtfDocAttr, rtfDocTemplate, "doctemp", 0 },
1603 { rtfDocAttr, rtfDefLanguage, "deflang", 0 },
1604
1605 { rtfDocAttr, rtfFENoteType, "fet", 0 },
1606 { rtfDocAttr, rtfFNoteEndSect, "endnotes", 0 },
1607 { rtfDocAttr, rtfFNoteEndDoc, "enddoc", 0 },
1608 { rtfDocAttr, rtfFNoteText, "ftntj", 0 },
1609 { rtfDocAttr, rtfFNoteBottom, "ftnbj", 0 },
1610 { rtfDocAttr, rtfENoteEndSect, "aendnotes", 0 },
1611 { rtfDocAttr, rtfENoteEndDoc, "aenddoc", 0 },
1612 { rtfDocAttr, rtfENoteText, "aftntj", 0 },
1613 { rtfDocAttr, rtfENoteBottom, "aftnbj", 0 },
1614 { rtfDocAttr, rtfFNoteStart, "ftnstart", 0 },
1615 { rtfDocAttr, rtfENoteStart, "aftnstart", 0 },
1616 { rtfDocAttr, rtfFNoteRestartPage, "ftnrstpg", 0 },
1617 { rtfDocAttr, rtfFNoteRestart, "ftnrestart", 0 },
1618 { rtfDocAttr, rtfFNoteRestartCont, "ftnrstcont", 0 },
1619 { rtfDocAttr, rtfENoteRestart, "aftnrestart", 0 },
1620 { rtfDocAttr, rtfENoteRestartCont, "aftnrstcont", 0 },
1621 { rtfDocAttr, rtfFNoteNumArabic, "ftnnar", 0 },
1622 { rtfDocAttr, rtfFNoteNumLLetter, "ftnnalc", 0 },
1623 { rtfDocAttr, rtfFNoteNumULetter, "ftnnauc", 0 },
1624 { rtfDocAttr, rtfFNoteNumLRoman, "ftnnrlc", 0 },
1625 { rtfDocAttr, rtfFNoteNumURoman, "ftnnruc", 0 },
1626 { rtfDocAttr, rtfFNoteNumChicago, "ftnnchi", 0 },
1627 { rtfDocAttr, rtfENoteNumArabic, "aftnnar", 0 },
1628 { rtfDocAttr, rtfENoteNumLLetter, "aftnnalc", 0 },
1629 { rtfDocAttr, rtfENoteNumULetter, "aftnnauc", 0 },
1630 { rtfDocAttr, rtfENoteNumLRoman, "aftnnrlc", 0 },
1631 { rtfDocAttr, rtfENoteNumURoman, "aftnnruc", 0 },
1632 { rtfDocAttr, rtfENoteNumChicago, "aftnnchi", 0 },
1633
1634 { rtfDocAttr, rtfPaperWidth, "paperw", 0 },
1635 { rtfDocAttr, rtfPaperHeight, "paperh", 0 },
1636 { rtfDocAttr, rtfPaperSize, "psz", 0 },
1637 { rtfDocAttr, rtfLeftMargin, "margl", 0 },
1638 { rtfDocAttr, rtfRightMargin, "margr", 0 },
1639 { rtfDocAttr, rtfTopMargin, "margt", 0 },
1640 { rtfDocAttr, rtfBottomMargin, "margb", 0 },
1641 { rtfDocAttr, rtfFacingPage, "facingp", 0 },
1642 { rtfDocAttr, rtfGutterWid, "gutter", 0 },
1643 { rtfDocAttr, rtfMirrorMargin, "margmirror", 0 },
1644 { rtfDocAttr, rtfLandscape, "landscape", 0 },
1645 { rtfDocAttr, rtfPageStart, "pgnstart", 0 },
1646 { rtfDocAttr, rtfWidowCtrl, "widowctrl", 0 },
1647
1648 { rtfDocAttr, rtfLinkStyles, "linkstyles", 0 },
1649
1650 { rtfDocAttr, rtfNoAutoTabIndent, "notabind", 0 },
1651 { rtfDocAttr, rtfWrapSpaces, "wraptrsp", 0 },
1652 { rtfDocAttr, rtfPrintColorsBlack, "prcolbl", 0 },
1653 { rtfDocAttr, rtfNoExtraSpaceRL, "noextrasprl", 0 },
1654 { rtfDocAttr, rtfNoColumnBalance, "nocolbal", 0 },
1655 { rtfDocAttr, rtfCvtMailMergeQuote, "cvmme", 0 },
1656 { rtfDocAttr, rtfSuppressTopSpace, "sprstsp", 0 },
1657 { rtfDocAttr, rtfSuppressPreParSpace, "sprsspbf", 0 },
1658 { rtfDocAttr, rtfCombineTblBorders, "otblrul", 0 },
1659 { rtfDocAttr, rtfTranspMetafiles, "transmf", 0 },
1660 { rtfDocAttr, rtfSwapBorders, "swpbdr", 0 },
1661 { rtfDocAttr, rtfShowHardBreaks, "brkfrm", 0 },
1662
1663 { rtfDocAttr, rtfFormProtected, "formprot", 0 },
1664 { rtfDocAttr, rtfAllProtected, "allprot", 0 },
1665 { rtfDocAttr, rtfFormShading, "formshade", 0 },
1666 { rtfDocAttr, rtfFormDisplay, "formdisp", 0 },
1667 { rtfDocAttr, rtfPrintData, "printdata", 0 },
1668
1669 { rtfDocAttr, rtfRevProtected, "revprot", 0 },
1670 { rtfDocAttr, rtfRevisions, "revisions", 0 },
1671 { rtfDocAttr, rtfRevDisplay, "revprop", 0 },
1672 { rtfDocAttr, rtfRevBar, "revbar", 0 },
1673
1674 { rtfDocAttr, rtfAnnotProtected, "annotprot", 0 },
1675
1676 { rtfDocAttr, rtfRTLDoc, "rtldoc", 0 },
1677 { rtfDocAttr, rtfLTRDoc, "ltrdoc", 0 },
1678
1679 { rtfDocAttr, rtfAnsiCodePage, "ansicpg", 0 },
1680 { rtfDocAttr, rtfUTF8RTF, "urtf", 0 },
1681
1682 /*
1683 * Style attributes
1684 */
1685
1686 { rtfStyleAttr, rtfAdditive, "additive", 0 },
1687 { rtfStyleAttr, rtfBasedOn, "sbasedon", 0 },
1688 { rtfStyleAttr, rtfNext, "snext", 0 },
1689
1690 /*
1691 * Picture attributes
1692 */
1693
1694 { rtfPictAttr, rtfMacQD, "macpict", 0 },
1695 { rtfPictAttr, rtfPMMetafile, "pmmetafile", 0 },
1696 { rtfPictAttr, rtfWinMetafile, "wmetafile", 0 },
1697 { rtfPictAttr, rtfDevIndBitmap, "dibitmap", 0 },
1698 { rtfPictAttr, rtfWinBitmap, "wbitmap", 0 },
1699 { rtfPictAttr, rtfEmfBlip, "emfblip", 0 },
1700 { rtfPictAttr, rtfPixelBits, "wbmbitspixel", 0 },
1701 { rtfPictAttr, rtfBitmapPlanes, "wbmplanes", 0 },
1702 { rtfPictAttr, rtfBitmapWid, "wbmwidthbytes", 0 },
1703
1704 { rtfPictAttr, rtfPicWid, "picw", 0 },
1705 { rtfPictAttr, rtfPicHt, "pich", 0 },
1706 { rtfPictAttr, rtfPicGoalWid, "picwgoal", 0 },
1707 { rtfPictAttr, rtfPicGoalHt, "pichgoal", 0 },
1708 /* these two aren't in the spec, but some writers emit them */
1709 { rtfPictAttr, rtfPicGoalWid, "picwGoal", 0 },
1710 { rtfPictAttr, rtfPicGoalHt, "pichGoal", 0 },
1711 { rtfPictAttr, rtfPicScaleX, "picscalex", 0 },
1712 { rtfPictAttr, rtfPicScaleY, "picscaley", 0 },
1713 { rtfPictAttr, rtfPicScaled, "picscaled", 0 },
1714 { rtfPictAttr, rtfPicCropTop, "piccropt", 0 },
1715 { rtfPictAttr, rtfPicCropBottom, "piccropb", 0 },
1716 { rtfPictAttr, rtfPicCropLeft, "piccropl", 0 },
1717 { rtfPictAttr, rtfPicCropRight, "piccropr", 0 },
1718
1719 { rtfPictAttr, rtfPicMFHasBitmap, "picbmp", 0 },
1720 { rtfPictAttr, rtfPicMFBitsPerPixel, "picbpp", 0 },
1721
1722 { rtfPictAttr, rtfPicBinary, "bin", 0 },
1723
1724 /*
1725 * NeXT graphic attributes
1726 */
1727
1728 { rtfNeXTGrAttr, rtfNeXTGWidth, "width", 0 },
1729 { rtfNeXTGrAttr, rtfNeXTGHeight, "height", 0 },
1730
1731 /*
1732 * Destinations
1733 */
1734
1735 { rtfDestination, rtfFontTbl, "fonttbl", 0 },
1736 { rtfDestination, rtfFontAltName, "falt", 0 },
1737 { rtfDestination, rtfEmbeddedFont, "fonteb", 0 },
1738 { rtfDestination, rtfFontFile, "fontfile", 0 },
1739 { rtfDestination, rtfFileTbl, "filetbl", 0 },
1740 { rtfDestination, rtfFileInfo, "file", 0 },
1741 { rtfDestination, rtfColorTbl, "colortbl", 0 },
1742 { rtfDestination, rtfStyleSheet, "stylesheet", 0 },
1743 { rtfDestination, rtfKeyCode, "keycode", 0 },
1744 { rtfDestination, rtfRevisionTbl, "revtbl", 0 },
1745 { rtfDestination, rtfGenerator, "generator", 0 },
1746 { rtfDestination, rtfInfo, "info", 0 },
1747 { rtfDestination, rtfITitle, "title", 0 },
1748 { rtfDestination, rtfISubject, "subject", 0 },
1749 { rtfDestination, rtfIAuthor, "author", 0 },
1750 { rtfDestination, rtfIOperator, "operator", 0 },
1751 { rtfDestination, rtfIKeywords, "keywords", 0 },
1752 { rtfDestination, rtfIComment, "comment", 0 },
1753 { rtfDestination, rtfIVersion, "version", 0 },
1754 { rtfDestination, rtfIDoccomm, "doccomm", 0 },
1755 /* \verscomm may not exist -- was seen in earlier spec version */
1756 { rtfDestination, rtfIVerscomm, "verscomm", 0 },
1757 { rtfDestination, rtfNextFile, "nextfile", 0 },
1758 { rtfDestination, rtfTemplate, "template", 0 },
1759 { rtfDestination, rtfFNSep, "ftnsep", 0 },
1760 { rtfDestination, rtfFNContSep, "ftnsepc", 0 },
1761 { rtfDestination, rtfFNContNotice, "ftncn", 0 },
1762 { rtfDestination, rtfENSep, "aftnsep", 0 },
1763 { rtfDestination, rtfENContSep, "aftnsepc", 0 },
1764 { rtfDestination, rtfENContNotice, "aftncn", 0 },
1765 { rtfDestination, rtfPageNumLevel, "pgnhn", 0 },
1766 { rtfDestination, rtfParNumLevelStyle, "pnseclvl", 0 },
1767 { rtfDestination, rtfHeader, "header", 0 },
1768 { rtfDestination, rtfFooter, "footer", 0 },
1769 { rtfDestination, rtfHeaderLeft, "headerl", 0 },
1770 { rtfDestination, rtfHeaderRight, "headerr", 0 },
1771 { rtfDestination, rtfHeaderFirst, "headerf", 0 },
1772 { rtfDestination, rtfFooterLeft, "footerl", 0 },
1773 { rtfDestination, rtfFooterRight, "footerr", 0 },
1774 { rtfDestination, rtfFooterFirst, "footerf", 0 },
1775 { rtfDestination, rtfParNumText, "pntext", 0 },
1776 { rtfDestination, rtfParNumbering, "pn", 0 },
1777 { rtfDestination, rtfParNumTextAfter, "pntxta", 0 },
1778 { rtfDestination, rtfParNumTextBefore, "pntxtb", 0 },
1779 { rtfDestination, rtfBookmarkStart, "bkmkstart", 0 },
1780 { rtfDestination, rtfBookmarkEnd, "bkmkend", 0 },
1781 { rtfDestination, rtfPict, "pict", 0 },
1782 { rtfDestination, rtfObject, "object", 0 },
1783 { rtfDestination, rtfObjClass, "objclass", 0 },
1784 { rtfDestination, rtfObjName, "objname", 0 },
1785 { rtfObjAttr, rtfObjTime, "objtime", 0 },
1786 { rtfDestination, rtfObjData, "objdata", 0 },
1787 { rtfDestination, rtfObjAlias, "objalias", 0 },
1788 { rtfDestination, rtfObjSection, "objsect", 0 },
1789 /* objitem and objtopic aren't documented in the spec! */
1790 { rtfDestination, rtfObjItem, "objitem", 0 },
1791 { rtfDestination, rtfObjTopic, "objtopic", 0 },
1792 { rtfDestination, rtfObjResult, "result", 0 },
1793 { rtfDestination, rtfDrawObject, "do", 0 },
1794 { rtfDestination, rtfFootnote, "footnote", 0 },
1795 { rtfDestination, rtfAnnotRefStart, "atrfstart", 0 },
1796 { rtfDestination, rtfAnnotRefEnd, "atrfend", 0 },
1797 { rtfDestination, rtfAnnotID, "atnid", 0 },
1798 { rtfDestination, rtfAnnotAuthor, "atnauthor", 0 },
1799 { rtfDestination, rtfAnnotation, "annotation", 0 },
1800 { rtfDestination, rtfAnnotRef, "atnref", 0 },
1801 { rtfDestination, rtfAnnotTime, "atntime", 0 },
1802 { rtfDestination, rtfAnnotIcon, "atnicn", 0 },
1803 { rtfDestination, rtfField, "field", 0 },
1804 { rtfDestination, rtfFieldInst, "fldinst", 0 },
1805 { rtfDestination, rtfFieldResult, "fldrslt", 0 },
1806 { rtfDestination, rtfDataField, "datafield", 0 },
1807 { rtfDestination, rtfIndex, "xe", 0 },
1808 { rtfDestination, rtfIndexText, "txe", 0 },
1809 { rtfDestination, rtfIndexRange, "rxe", 0 },
1810 { rtfDestination, rtfTOC, "tc", 0 },
1811 { rtfDestination, rtfNeXTGraphic, "NeXTGraphic", 0 },
1812 { rtfDestination, rtfNestTableProps, "nesttableprops", 0 },
1813 { rtfDestination, rtfNoNestTables, "nonesttables", 0 },
1814 { rtfDestination, rtfShpPict, "shppict", 0 },
1815 { rtfDestination, rtfNonShpPict, "nonshppict", 0 },
1816
1817 /*
1818 * Font families
1819 */
1820
1821 { rtfFontFamily, rtfFFNil, "fnil", 0 },
1822 { rtfFontFamily, rtfFFRoman, "froman", 0 },
1823 { rtfFontFamily, rtfFFSwiss, "fswiss", 0 },
1824 { rtfFontFamily, rtfFFModern, "fmodern", 0 },
1825 { rtfFontFamily, rtfFFScript, "fscript", 0 },
1826 { rtfFontFamily, rtfFFDecor, "fdecor", 0 },
1827 { rtfFontFamily, rtfFFTech, "ftech", 0 },
1828 { rtfFontFamily, rtfFFBidirectional, "fbidi", 0 },
1829
1830 /*
1831 * Font attributes
1832 */
1833
1834 { rtfFontAttr, rtfFontCharSet, "fcharset", 0 },
1835 { rtfFontAttr, rtfFontPitch, "fprq", 0 },
1836 { rtfFontAttr, rtfFontCodePage, "cpg", 0 },
1837 { rtfFontAttr, rtfFTypeNil, "ftnil", 0 },
1838 { rtfFontAttr, rtfFTypeTrueType, "fttruetype", 0 },
1839
1840 /*
1841 * File table attributes
1842 */
1843
1844 { rtfFileAttr, rtfFileNum, "fid", 0 },
1845 { rtfFileAttr, rtfFileRelPath, "frelative", 0 },
1846 { rtfFileAttr, rtfFileOSNum, "fosnum", 0 },
1847
1848 /*
1849 * File sources
1850 */
1851
1852 { rtfFileSource, rtfSrcMacintosh, "fvalidmac", 0 },
1853 { rtfFileSource, rtfSrcDOS, "fvaliddos", 0 },
1854 { rtfFileSource, rtfSrcNTFS, "fvalidntfs", 0 },
1855 { rtfFileSource, rtfSrcHPFS, "fvalidhpfs", 0 },
1856 { rtfFileSource, rtfSrcNetwork, "fnetwork", 0 },
1857
1858 /*
1859 * Color names
1860 */
1861
1862 { rtfColorName, rtfRed, "red", 0 },
1863 { rtfColorName, rtfGreen, "green", 0 },
1864 { rtfColorName, rtfBlue, "blue", 0 },
1865
1866 /*
1867 * Charset names
1868 */
1869
1870 { rtfCharSet, rtfMacCharSet, "mac", 0 },
1871 { rtfCharSet, rtfAnsiCharSet, "ansi", 0 },
1872 { rtfCharSet, rtfPcCharSet, "pc", 0 },
1873 { rtfCharSet, rtfPcaCharSet, "pca", 0 },
1874
1875 /*
1876 * Table attributes
1877 */
1878
1879 { rtfTblAttr, rtfRowDef, "trowd", 0 },
1880 { rtfTblAttr, rtfRowGapH, "trgaph", 0 },
1881 { rtfTblAttr, rtfCellPos, "cellx", 0 },
1882 { rtfTblAttr, rtfMergeRngFirst, "clmgf", 0 },
1883 { rtfTblAttr, rtfMergePrevious, "clmrg", 0 },
1884
1885 { rtfTblAttr, rtfRowLeft, "trql", 0 },
1886 { rtfTblAttr, rtfRowRight, "trqr", 0 },
1887 { rtfTblAttr, rtfRowCenter, "trqc", 0 },
1888 { rtfTblAttr, rtfRowLeftEdge, "trleft", 0 },
1889 { rtfTblAttr, rtfRowHt, "trrh", 0 },
1890 { rtfTblAttr, rtfRowHeader, "trhdr", 0 },
1891 { rtfTblAttr, rtfRowKeep, "trkeep", 0 },
1892
1893 { rtfTblAttr, rtfRTLRow, "rtlrow", 0 },
1894 { rtfTblAttr, rtfLTRRow, "ltrrow", 0 },
1895
1896 { rtfTblAttr, rtfRowBordTop, "trbrdrt", 0 },
1897 { rtfTblAttr, rtfRowBordLeft, "trbrdrl", 0 },
1898 { rtfTblAttr, rtfRowBordBottom, "trbrdrb", 0 },
1899 { rtfTblAttr, rtfRowBordRight, "trbrdrr", 0 },
1900 { rtfTblAttr, rtfRowBordHoriz, "trbrdrh", 0 },
1901 { rtfTblAttr, rtfRowBordVert, "trbrdrv", 0 },
1902
1903 { rtfTblAttr, rtfCellBordBottom, "clbrdrb", 0 },
1904 { rtfTblAttr, rtfCellBordTop, "clbrdrt", 0 },
1905 { rtfTblAttr, rtfCellBordLeft, "clbrdrl", 0 },
1906 { rtfTblAttr, rtfCellBordRight, "clbrdrr", 0 },
1907
1908 { rtfTblAttr, rtfCellShading, "clshdng", 0 },
1909 { rtfTblAttr, rtfCellBgPatH, "clbghoriz", 0 },
1910 { rtfTblAttr, rtfCellBgPatV, "clbgvert", 0 },
1911 { rtfTblAttr, rtfCellFwdDiagBgPat, "clbgfdiag", 0 },
1912 { rtfTblAttr, rtfCellBwdDiagBgPat, "clbgbdiag", 0 },
1913 { rtfTblAttr, rtfCellHatchBgPat, "clbgcross", 0 },
1914 { rtfTblAttr, rtfCellDiagHatchBgPat, "clbgdcross", 0 },
1915 /*
1916 * The spec lists "clbgdkhor", but the corresponding non-cell
1917 * control is "bgdkhoriz". At any rate Macintosh Word seems
1918 * to accept both "clbgdkhor" and "clbgdkhoriz".
1919 */
1920 { rtfTblAttr, rtfCellDarkBgPatH, "clbgdkhoriz", 0 },
1921 { rtfTblAttr, rtfCellDarkBgPatH, "clbgdkhor", 0 },
1922 { rtfTblAttr, rtfCellDarkBgPatV, "clbgdkvert", 0 },
1923 { rtfTblAttr, rtfCellFwdDarkBgPat, "clbgdkfdiag", 0 },
1924 { rtfTblAttr, rtfCellBwdDarkBgPat, "clbgdkbdiag", 0 },
1925 { rtfTblAttr, rtfCellDarkHatchBgPat, "clbgdkcross", 0 },
1926 { rtfTblAttr, rtfCellDarkDiagHatchBgPat, "clbgdkdcross", 0 },
1927 { rtfTblAttr, rtfCellBgPatLineColor, "clcfpat", 0 },
1928 { rtfTblAttr, rtfCellBgPatColor, "clcbpat", 0 },
1929
1930 /*
1931 * Field attributes
1932 */
1933
1934 { rtfFieldAttr, rtfFieldDirty, "flddirty", 0 },
1935 { rtfFieldAttr, rtfFieldEdited, "fldedit", 0 },
1936 { rtfFieldAttr, rtfFieldLocked, "fldlock", 0 },
1937 { rtfFieldAttr, rtfFieldPrivate, "fldpriv", 0 },
1938 { rtfFieldAttr, rtfFieldAlt, "fldalt", 0 },
1939
1940 /*
1941 * Positioning attributes
1942 */
1943
1944 { rtfPosAttr, rtfAbsWid, "absw", 0 },
1945 { rtfPosAttr, rtfAbsHt, "absh", 0 },
1946
1947 { rtfPosAttr, rtfRPosMargH, "phmrg", 0 },
1948 { rtfPosAttr, rtfRPosPageH, "phpg", 0 },
1949 { rtfPosAttr, rtfRPosColH, "phcol", 0 },
1950 { rtfPosAttr, rtfPosX, "posx", 0 },
1951 { rtfPosAttr, rtfPosNegX, "posnegx", 0 },
1952 { rtfPosAttr, rtfPosXCenter, "posxc", 0 },
1953 { rtfPosAttr, rtfPosXInside, "posxi", 0 },
1954 { rtfPosAttr, rtfPosXOutSide, "posxo", 0 },
1955 { rtfPosAttr, rtfPosXRight, "posxr", 0 },
1956 { rtfPosAttr, rtfPosXLeft, "posxl", 0 },
1957
1958 { rtfPosAttr, rtfRPosMargV, "pvmrg", 0 },
1959 { rtfPosAttr, rtfRPosPageV, "pvpg", 0 },
1960 { rtfPosAttr, rtfRPosParaV, "pvpara", 0 },
1961 { rtfPosAttr, rtfPosY, "posy", 0 },
1962 { rtfPosAttr, rtfPosNegY, "posnegy", 0 },
1963 { rtfPosAttr, rtfPosYInline, "posyil", 0 },
1964 { rtfPosAttr, rtfPosYTop, "posyt", 0 },
1965 { rtfPosAttr, rtfPosYCenter, "posyc", 0 },
1966 { rtfPosAttr, rtfPosYBottom, "posyb", 0 },
1967
1968 { rtfPosAttr, rtfNoWrap, "nowrap", 0 },
1969 { rtfPosAttr, rtfDistFromTextAll, "dxfrtext", 0 },
1970 { rtfPosAttr, rtfDistFromTextX, "dfrmtxtx", 0 },
1971 { rtfPosAttr, rtfDistFromTextY, "dfrmtxty", 0 },
1972 /* \dyfrtext no longer exists in spec 1.2, apparently */
1973 /* replaced by \dfrmtextx and \dfrmtexty. */
1974 { rtfPosAttr, rtfTextDistY, "dyfrtext", 0 },
1975
1976 { rtfPosAttr, rtfDropCapLines, "dropcapli", 0 },
1977 { rtfPosAttr, rtfDropCapType, "dropcapt", 0 },
1978
1979 /*
1980 * Object controls
1981 */
1982
1983 { rtfObjAttr, rtfObjEmb, "objemb", 0 },
1984 { rtfObjAttr, rtfObjLink, "objlink", 0 },
1985 { rtfObjAttr, rtfObjAutoLink, "objautlink", 0 },
1986 { rtfObjAttr, rtfObjSubscriber, "objsub", 0 },
1987 { rtfObjAttr, rtfObjPublisher, "objpub", 0 },
1988 { rtfObjAttr, rtfObjICEmb, "objicemb", 0 },
1989
1990 { rtfObjAttr, rtfObjLinkSelf, "linkself", 0 },
1991 { rtfObjAttr, rtfObjLock, "objupdate", 0 },
1992 { rtfObjAttr, rtfObjUpdate, "objlock", 0 },
1993
1994 { rtfObjAttr, rtfObjHt, "objh", 0 },
1995 { rtfObjAttr, rtfObjWid, "objw", 0 },
1996 { rtfObjAttr, rtfObjSetSize, "objsetsize", 0 },
1997 { rtfObjAttr, rtfObjAlign, "objalign", 0 },
1998 { rtfObjAttr, rtfObjTransposeY, "objtransy", 0 },
1999 { rtfObjAttr, rtfObjCropTop, "objcropt", 0 },
2000 { rtfObjAttr, rtfObjCropBottom, "objcropb", 0 },
2001 { rtfObjAttr, rtfObjCropLeft, "objcropl", 0 },
2002 { rtfObjAttr, rtfObjCropRight, "objcropr", 0 },
2003 { rtfObjAttr, rtfObjScaleX, "objscalex", 0 },
2004 { rtfObjAttr, rtfObjScaleY, "objscaley", 0 },
2005
2006 { rtfObjAttr, rtfObjResRTF, "rsltrtf", 0 },
2007 { rtfObjAttr, rtfObjResPict, "rsltpict", 0 },
2008 { rtfObjAttr, rtfObjResBitmap, "rsltbmp", 0 },
2009 { rtfObjAttr, rtfObjResText, "rslttxt", 0 },
2010 { rtfObjAttr, rtfObjResMerge, "rsltmerge", 0 },
2011
2012 { rtfObjAttr, rtfObjBookmarkPubObj, "bkmkpub", 0 },
2013 { rtfObjAttr, rtfObjPubAutoUpdate, "pubauto", 0 },
2014
2015 /*
2016 * Associated character formatting attributes
2017 */
2018
2019 { rtfACharAttr, rtfACBold, "ab", 0 },
2020 { rtfACharAttr, rtfACAllCaps, "caps", 0 },
2021 { rtfACharAttr, rtfACForeColor, "acf", 0 },
2022 { rtfACharAttr, rtfACSubScript, "adn", 0 },
2023 { rtfACharAttr, rtfACExpand, "aexpnd", 0 },
2024 { rtfACharAttr, rtfACFontNum, "af", 0 },
2025 { rtfACharAttr, rtfACFontSize, "afs", 0 },
2026 { rtfACharAttr, rtfACItalic, "ai", 0 },
2027 { rtfACharAttr, rtfACLanguage, "alang", 0 },
2028 { rtfACharAttr, rtfACOutline, "aoutl", 0 },
2029 { rtfACharAttr, rtfACSmallCaps, "ascaps", 0 },
2030 { rtfACharAttr, rtfACShadow, "ashad", 0 },
2031 { rtfACharAttr, rtfACStrikeThru, "astrike", 0 },
2032 { rtfACharAttr, rtfACUnderline, "aul", 0 },
2033 { rtfACharAttr, rtfACDotUnderline, "auld", 0 },
2034 { rtfACharAttr, rtfACDbUnderline, "auldb", 0 },
2035 { rtfACharAttr, rtfACNoUnderline, "aulnone", 0 },
2036 { rtfACharAttr, rtfACWordUnderline, "aulw", 0 },
2037 { rtfACharAttr, rtfACSuperScript, "aup", 0 },
2038
2039 /*
2040 * Footnote attributes
2041 */
2042
2043 { rtfFNoteAttr, rtfFNAlt, "ftnalt", 0 },
2044
2045 /*
2046 * Key code attributes
2047 */
2048
2049 { rtfKeyCodeAttr, rtfAltKey, "alt", 0 },
2050 { rtfKeyCodeAttr, rtfShiftKey, "shift", 0 },
2051 { rtfKeyCodeAttr, rtfControlKey, "ctrl", 0 },
2052 { rtfKeyCodeAttr, rtfFunctionKey, "fn", 0 },
2053
2054 /*
2055 * Bookmark attributes
2056 */
2057
2058 { rtfBookmarkAttr, rtfBookmarkFirstCol, "bkmkcolf", 0 },
2059 { rtfBookmarkAttr, rtfBookmarkLastCol, "bkmkcoll", 0 },
2060
2061 /*
2062 * Index entry attributes
2063 */
2064
2065 { rtfIndexAttr, rtfIndexNumber, "xef", 0 },
2066 { rtfIndexAttr, rtfIndexBold, "bxe", 0 },
2067 { rtfIndexAttr, rtfIndexItalic, "ixe", 0 },
2068
2069 /*
2070 * Table of contents attributes
2071 */
2072
2073 { rtfTOCAttr, rtfTOCType, "tcf", 0 },
2074 { rtfTOCAttr, rtfTOCLevel, "tcl", 0 },
2075
2076 /*
2077 * Drawing object attributes
2078 */
2079
2080 { rtfDrawAttr, rtfDrawLock, "dolock", 0 },
2081 { rtfDrawAttr, rtfDrawPageRelX, "doxpage", 0 },
2082 { rtfDrawAttr, rtfDrawColumnRelX, "dobxcolumn", 0 },
2083 { rtfDrawAttr, rtfDrawMarginRelX, "dobxmargin", 0 },
2084 { rtfDrawAttr, rtfDrawPageRelY, "dobypage", 0 },
2085 { rtfDrawAttr, rtfDrawColumnRelY, "dobycolumn", 0 },
2086 { rtfDrawAttr, rtfDrawMarginRelY, "dobymargin", 0 },
2087 { rtfDrawAttr, rtfDrawHeight, "dobhgt", 0 },
2088
2089 { rtfDrawAttr, rtfDrawBeginGroup, "dpgroup", 0 },
2090 { rtfDrawAttr, rtfDrawGroupCount, "dpcount", 0 },
2091 { rtfDrawAttr, rtfDrawEndGroup, "dpendgroup", 0 },
2092 { rtfDrawAttr, rtfDrawArc, "dparc", 0 },
2093 { rtfDrawAttr, rtfDrawCallout, "dpcallout", 0 },
2094 { rtfDrawAttr, rtfDrawEllipse, "dpellipse", 0 },
2095 { rtfDrawAttr, rtfDrawLine, "dpline", 0 },
2096 { rtfDrawAttr, rtfDrawPolygon, "dppolygon", 0 },
2097 { rtfDrawAttr, rtfDrawPolyLine, "dppolyline", 0 },
2098 { rtfDrawAttr, rtfDrawRect, "dprect", 0 },
2099 { rtfDrawAttr, rtfDrawTextBox, "dptxbx", 0 },
2100
2101 { rtfDrawAttr, rtfDrawOffsetX, "dpx", 0 },
2102 { rtfDrawAttr, rtfDrawSizeX, "dpxsize", 0 },
2103 { rtfDrawAttr, rtfDrawOffsetY, "dpy", 0 },
2104 { rtfDrawAttr, rtfDrawSizeY, "dpysize", 0 },
2105
2106 { rtfDrawAttr, rtfCOAngle, "dpcoa", 0 },
2107 { rtfDrawAttr, rtfCOAccentBar, "dpcoaccent", 0 },
2108 { rtfDrawAttr, rtfCOBestFit, "dpcobestfit", 0 },
2109 { rtfDrawAttr, rtfCOBorder, "dpcoborder", 0 },
2110 { rtfDrawAttr, rtfCOAttachAbsDist, "dpcodabs", 0 },
2111 { rtfDrawAttr, rtfCOAttachBottom, "dpcodbottom", 0 },
2112 { rtfDrawAttr, rtfCOAttachCenter, "dpcodcenter", 0 },
2113 { rtfDrawAttr, rtfCOAttachTop, "dpcodtop", 0 },
2114 { rtfDrawAttr, rtfCOLength, "dpcolength", 0 },
2115 { rtfDrawAttr, rtfCONegXQuadrant, "dpcominusx", 0 },
2116 { rtfDrawAttr, rtfCONegYQuadrant, "dpcominusy", 0 },
2117 { rtfDrawAttr, rtfCOOffset, "dpcooffset", 0 },
2118 { rtfDrawAttr, rtfCOAttachSmart, "dpcosmarta", 0 },
2119 { rtfDrawAttr, rtfCODoubleLine, "dpcotdouble", 0 },
2120 { rtfDrawAttr, rtfCORightAngle, "dpcotright", 0 },
2121 { rtfDrawAttr, rtfCOSingleLine, "dpcotsingle", 0 },
2122 { rtfDrawAttr, rtfCOTripleLine, "dpcottriple", 0 },
2123
2124 { rtfDrawAttr, rtfDrawTextBoxMargin, "dptxbxmar", 0 },
2125 { rtfDrawAttr, rtfDrawTextBoxText, "dptxbxtext", 0 },
2126 { rtfDrawAttr, rtfDrawRoundRect, "dproundr", 0 },
2127
2128 { rtfDrawAttr, rtfDrawPointX, "dpptx", 0 },
2129 { rtfDrawAttr, rtfDrawPointY, "dppty", 0 },
2130 { rtfDrawAttr, rtfDrawPolyCount, "dppolycount", 0 },
2131
2132 { rtfDrawAttr, rtfDrawArcFlipX, "dparcflipx", 0 },
2133 { rtfDrawAttr, rtfDrawArcFlipY, "dparcflipy", 0 },
2134
2135 { rtfDrawAttr, rtfDrawLineBlue, "dplinecob", 0 },
2136 { rtfDrawAttr, rtfDrawLineGreen, "dplinecog", 0 },
2137 { rtfDrawAttr, rtfDrawLineRed, "dplinecor", 0 },
2138 { rtfDrawAttr, rtfDrawLinePalette, "dplinepal", 0 },
2139 { rtfDrawAttr, rtfDrawLineDashDot, "dplinedado", 0 },
2140 { rtfDrawAttr, rtfDrawLineDashDotDot, "dplinedadodo", 0 },
2141 { rtfDrawAttr, rtfDrawLineDash, "dplinedash", 0 },
2142 { rtfDrawAttr, rtfDrawLineDot, "dplinedot", 0 },
2143 { rtfDrawAttr, rtfDrawLineGray, "dplinegray", 0 },
2144 { rtfDrawAttr, rtfDrawLineHollow, "dplinehollow", 0 },
2145 { rtfDrawAttr, rtfDrawLineSolid, "dplinesolid", 0 },
2146 { rtfDrawAttr, rtfDrawLineWidth, "dplinew", 0 },
2147
2148 { rtfDrawAttr, rtfDrawHollowEndArrow, "dpaendhol", 0 },
2149 { rtfDrawAttr, rtfDrawEndArrowLength, "dpaendl", 0 },
2150 { rtfDrawAttr, rtfDrawSolidEndArrow, "dpaendsol", 0 },
2151 { rtfDrawAttr, rtfDrawEndArrowWidth, "dpaendw", 0 },
2152 { rtfDrawAttr, rtfDrawHollowStartArrow,"dpastarthol", 0 },
2153 { rtfDrawAttr, rtfDrawStartArrowLength,"dpastartl", 0 },
2154 { rtfDrawAttr, rtfDrawSolidStartArrow, "dpastartsol", 0 },
2155 { rtfDrawAttr, rtfDrawStartArrowWidth, "dpastartw", 0 },
2156
2157 { rtfDrawAttr, rtfDrawBgFillBlue, "dpfillbgcb", 0 },
2158 { rtfDrawAttr, rtfDrawBgFillGreen, "dpfillbgcg", 0 },
2159 { rtfDrawAttr, rtfDrawBgFillRed, "dpfillbgcr", 0 },
2160 { rtfDrawAttr, rtfDrawBgFillPalette, "dpfillbgpal", 0 },
2161 { rtfDrawAttr, rtfDrawBgFillGray, "dpfillbggray", 0 },
2162 { rtfDrawAttr, rtfDrawFgFillBlue, "dpfillfgcb", 0 },
2163 { rtfDrawAttr, rtfDrawFgFillGreen, "dpfillfgcg", 0 },
2164 { rtfDrawAttr, rtfDrawFgFillRed, "dpfillfgcr", 0 },
2165 { rtfDrawAttr, rtfDrawFgFillPalette, "dpfillfgpal", 0 },
2166 { rtfDrawAttr, rtfDrawFgFillGray, "dpfillfggray", 0 },
2167 { rtfDrawAttr, rtfDrawFillPatIndex, "dpfillpat", 0 },
2168
2169 { rtfDrawAttr, rtfDrawShadow, "dpshadow", 0 },
2170 { rtfDrawAttr, rtfDrawShadowXOffset, "dpshadx", 0 },
2171 { rtfDrawAttr, rtfDrawShadowYOffset, "dpshady", 0 },
2172
2173 { rtfVersion, -1, "rtf", 0 },
2174 { rtfDefFont, -1, "deff", 0 },
2175
2176 { 0, -1, NULL, 0 }
2177};
2178
2179typedef struct tagRTFHashTableEntry {
2183
2185
2186
2187/*
2188 * Initialize lookup table hash values. Only need to do this once.
2189 */
2190
2191void LookupInit(void)
2192{
2193 RTFKey *rp;
2194
2195 memset(rtfHashTable, 0, sizeof rtfHashTable);
2196 for (rp = rtfKey; rp->rtfKStr != NULL; rp++)
2197 {
2198 int index;
2199
2200 rp->rtfKHash = Hash (rp->rtfKStr);
2201 index = rp->rtfKHash % (ARRAY_SIZE(rtfKey) * 2);
2202 if (!rtfHashTable[index].count)
2204 else
2207 }
2208}
2209
2211{
2212 unsigned int i;
2213
2214 for (i = 0; i < ARRAY_SIZE(rtfKey) * 2; i++)
2215 {
2218 rtfHashTable[i].count = 0;
2219 }
2220}
2221
2222
2223/*
2224 * Determine major and minor number of control token. If it's
2225 * not found, the class turns into rtfUnknown.
2226 */
2227
2228static void Lookup(RTF_Info *info, char *s)
2229{
2230 RTFKey *rp;
2231 int hash;
2233 int i;
2234
2235 ++s; /* skip over the leading \ character */
2236 hash = Hash (s);
2238 for (i = 0; i < entry->count; i++)
2239 {
2240 rp = entry->value[i];
2241 if (hash == rp->rtfKHash && strcmp (s, rp->rtfKStr) == 0)
2242 {
2243 info->rtfClass = rtfControl;
2244 info->rtfMajor = rp->rtfKMajor;
2245 info->rtfMinor = rp->rtfKMinor;
2246 return;
2247 }
2248 }
2249 info->rtfClass = rtfUnknown;
2250}
2251
2252
2253/*
2254 * Compute hash value of symbol
2255 */
2256
2257static int Hash(const char *s)
2258{
2259 char c;
2260 int val = 0;
2261
2262 while ((c = *s++) != '\0')
2263 val += c;
2264 return (val);
2265}
2266
2267
2268
2269/* ---------------------------------------------------------------------- */
2270
2271
2272/*
2273 * Token comparison routines
2274 */
2275
2276int RTFCheckCM(const RTF_Info *info, int class, int major)
2277{
2278 return (info->rtfClass == class && info->rtfMajor == major);
2279}
2280
2281
2282int RTFCheckCMM(const RTF_Info *info, int class, int major, int minor)
2283{
2284 return (info->rtfClass == class && info->rtfMajor == major && info->rtfMinor == minor);
2285}
2286
2287
2288int RTFCheckMM(const RTF_Info *info, int major, int minor)
2289{
2290 return (info->rtfMajor == major && info->rtfMinor == minor);
2291}
2292
2293
2294/* ---------------------------------------------------------------------- */
2295
2296
2298{
2299 if (isupper (c))
2300 c = tolower (c);
2301 if (isdigit (c))
2302 return (c - '0'); /* '0'..'9' */
2303 return (c - 'a' + 10); /* 'a'..'f' */
2304}
2305
2306
2307/* ---------------------------------------------------------------------- */
2308
2309/*
2310 * originally from RTF tools' text-writer.c
2311 *
2312 * text-writer -- RTF-to-text translation writer code.
2313 *
2314 * Read RTF input, write text of document (text extraction).
2315 */
2316
2317static void TextClass (RTF_Info *info);
2318static void ControlClass (RTF_Info *info);
2319static void DefFont(RTF_Info *info);
2320static void Destination (RTF_Info *info);
2321static void SpecialChar (RTF_Info *info);
2322static void RTFPutUnicodeChar (RTF_Info *info, int c);
2323
2324/*
2325 * Initialize the writer.
2326 */
2327
2328void
2330{
2331}
2332
2333
2334int
2336{
2337 /* install class callbacks */
2338
2341
2342 return (1);
2343}
2344
2345/*
2346 * Write out a character.
2347 */
2348
2349static void
2351{
2352 RTFPutCodePageChar(info, info->rtfMajor);
2353}
2354
2355
2356static void
2358{
2359 switch (info->rtfMajor)
2360 {
2361 case rtfCharAttr:
2362 CharAttr(info);
2364 break;
2365 case rtfParAttr:
2367 break;
2368 case rtfTblAttr:
2370 break;
2371 case rtfCharSet:
2372 CharSet(info);
2373 break;
2374 case rtfDefFont:
2375 DefFont(info);
2376 break;
2377 case rtfDestination:
2378 Destination (info);
2379 break;
2380 case rtfDocAttr:
2381 DocAttr(info);
2382 break;
2383 case rtfSpecialChar:
2384 SpecialChar (info);
2386 break;
2387 }
2388}
2389
2390
2391static void
2393{
2394 RTFFont *font;
2395
2396 switch (info->rtfMinor)
2397 {
2398 case rtfFontNum:
2399 font = RTFGetFont(info, info->rtfParam);
2400 if (font)
2401 {
2402 if (info->ansiCodePage != CP_UTF8 && info->codePage != font->rtfFCodePage)
2403 {
2405 info->codePage = font->rtfFCodePage;
2406 }
2407 TRACE("font %d codepage %d\n", info->rtfParam, info->codePage);
2408 }
2409 else
2410 ERR( "unknown font %d\n", info->rtfParam);
2411 break;
2412 case rtfUnicodeLength:
2413 info->unicodeLength = info->rtfParam;
2414 break;
2415 }
2416}
2417
2418
2419static void
2421{
2422 if (info->ansiCodePage == CP_UTF8)
2423 return;
2424
2425 switch (info->rtfMinor)
2426 {
2427 case rtfAnsiCharSet:
2428 info->ansiCodePage = 1252; /* Latin-1 */
2429 break;
2430 case rtfMacCharSet:
2431 info->ansiCodePage = 10000; /* MacRoman */
2432 break;
2433 case rtfPcCharSet:
2434 info->ansiCodePage = 437;
2435 break;
2436 case rtfPcaCharSet:
2437 info->ansiCodePage = 850;
2438 break;
2439 }
2440}
2441
2442/*
2443 * This function notices destinations that aren't explicitly handled
2444 * and skips to their ends. This keeps, for instance, picture
2445 * data from being considered as plain text.
2446 */
2447
2448static void
2450{
2451 if (!RTFGetDestinationCallback(info, info->rtfMinor))
2452 RTFSkipGroup (info);
2453}
2454
2455
2456static void
2458{
2459 TRACE("%d\n", info->rtfParam);
2460 info->defFont = info->rtfParam;
2461}
2462
2463
2464static void
2466{
2467 TRACE("minor %d, param %d\n", info->rtfMinor, info->rtfParam);
2468
2469 switch (info->rtfMinor)
2470 {
2471 case rtfAnsiCodePage:
2472 info->codePage = info->ansiCodePage = info->rtfParam;
2473 break;
2474 case rtfUTF8RTF:
2475 info->codePage = info->ansiCodePage = CP_UTF8;
2476 break;
2477 }
2478}
2479
2480
2482{
2483 switch (info->rtfMinor)
2484 {
2485 case rtfOptDest:
2486 /* the next token determines destination, if it's unknown, skip the group */
2487 /* this way we filter out the garbage coming from unknown destinations */
2488 RTFGetToken(info);
2489 if (info->rtfClass != rtfDestination)
2491 else
2492 RTFRouteToken(info); /* "\*" is ignored with known destinations */
2493 break;
2494 case rtfUnicode:
2495 {
2496 int i;
2497
2498 RTFPutUnicodeChar(info, info->rtfParam);
2499
2500 /* After \u we must skip number of character tokens set by \ucN */
2501 for (i = 0; i < info->unicodeLength; i++)
2502 {
2504 if (info->rtfClass != rtfText)
2505 {
2506 ERR("The token behind \\u is not text, but (%d,%d,%d)\n",
2507 info->rtfClass, info->rtfMajor, info->rtfMinor);
2509 break;
2510 }
2511 }
2512 break;
2513 }
2514 case rtfLine:
2516 ME_InsertEndRowFromCursor(info->editor, 0);
2517 break;
2518 case rtfPage:
2519 case rtfSect:
2520 case rtfPar:
2522 ME_SetSelectionParaFormat(info->editor, &info->fmt);
2523 memset(&info->fmt, 0, sizeof(info->fmt));
2524 info->fmt.cbSize = sizeof(info->fmt);
2525 RTFPutUnicodeChar (info, '\r');
2526 if (info->editor->bEmulateVersion10) RTFPutUnicodeChar (info, '\n');
2527 break;
2528 case rtfNoBrkSpace:
2529 RTFPutUnicodeChar (info, 0x00A0);
2530 break;
2531 case rtfTab:
2532 RTFPutUnicodeChar (info, '\t');
2533 break;
2534 case rtfNoBrkHyphen:
2535 RTFPutUnicodeChar (info, 0x2011);
2536 break;
2537 case rtfBullet:
2538 RTFPutUnicodeChar (info, 0x2022);
2539 break;
2540 case rtfEmDash:
2541 RTFPutUnicodeChar (info, 0x2014);
2542 break;
2543 case rtfEnDash:
2544 RTFPutUnicodeChar (info, 0x2013);
2545 break;
2546 case rtfEmSpace:
2547 RTFPutUnicodeChar (info, ' ');
2548 break;
2549 case rtfEnSpace:
2550 RTFPutUnicodeChar (info, ' ');
2551 break;
2552 case rtfLQuote:
2553 RTFPutUnicodeChar (info, 0x2018);
2554 break;
2555 case rtfRQuote:
2556 RTFPutUnicodeChar (info, 0x2019);
2557 break;
2558 case rtfLDblQuote:
2559 RTFPutUnicodeChar (info, 0x201C);
2560 break;
2561 case rtfRDblQuote:
2562 RTFPutUnicodeChar (info, 0x201D);
2563 break;
2564 case rtfLTRMark:
2565 RTFPutUnicodeChar (info, 0x200E);
2566 break;
2567 case rtfRTLMark:
2568 RTFPutUnicodeChar (info, 0x200F);
2569 break;
2570 case rtfNoWidthJoiner:
2571 RTFPutUnicodeChar (info, 0x200D);
2572 break;
2574 RTFPutUnicodeChar (info, 0x200C);
2575 break;
2576 }
2577}
2578
2579
2580static void
2582{
2583 if (info->dwOutputCount)
2584 {
2585 ME_InsertTextFromCursor(info->editor, 0, info->OutputBuffer,
2586 info->dwOutputCount, info->style);
2587 info->dwOutputCount = 0;
2588 }
2589}
2590
2591
2592static void
2594{
2595 if (info->dwCPOutputCount)
2597 while (length)
2598 {
2599 int fit = min(length, ARRAY_SIZE(info->OutputBuffer) - info->dwOutputCount);
2600
2601 memmove(info->OutputBuffer + info->dwOutputCount, string, fit * sizeof(WCHAR));
2602 info->dwOutputCount += fit;
2603 length -= fit;
2604 string += fit;
2605 if (ARRAY_SIZE(info->OutputBuffer) == info->dwOutputCount)
2607 }
2608}
2609
2610static void
2612{
2613 int bufferMax = info->dwCPOutputCount * 2 * sizeof(WCHAR);
2614 WCHAR *buffer = heap_alloc(bufferMax);
2615 int length;
2616
2617 length = MultiByteToWideChar(info->codePage, 0, info->cpOutputBuffer,
2618 info->dwCPOutputCount, buffer, bufferMax/sizeof(WCHAR));
2619 info->dwCPOutputCount = 0;
2620
2623}
2624
2625void
2627{
2628 if (info->dwCPOutputCount)
2631}
2632
2633static void
2635{
2636 if (info->dwCPOutputCount)
2638 if (info->dwOutputCount * sizeof(WCHAR) >= ( sizeof info->OutputBuffer - 1 ) )
2640 info->OutputBuffer[info->dwOutputCount++] = c;
2641}
2642
2643static void
2645{
2646 /* Use dynamic buffer here because it's the best way to handle
2647 * MBCS codepages without having to worry about partial chars */
2648 if (info->dwCPOutputCount >= info->dwMaxCPOutputCount)
2649 {
2650 info->dwMaxCPOutputCount *= 2;
2651 info->cpOutputBuffer = heap_realloc(info->cpOutputBuffer, info->dwMaxCPOutputCount);
2652 }
2653 info->cpOutputBuffer[info->dwCPOutputCount++] = c;
2654}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define isalpha(c)
Definition: acclib.h:74
#define isdigit(c)
Definition: acclib.h:68
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
#define isxdigit(c)
Definition: acclib.h:70
#define isupper(c)
Definition: acclib.h:71
int tolower(int c)
Definition: utclib.c:902
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:71
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define index(s, c)
Definition: various.h:29
#define ARRAY_SIZE(A)
Definition: main.h:33
#define WARN(fmt,...)
Definition: debug.h:115
#define ERR(fmt,...)
Definition: debug.h:113
CFF_Charset charset
Definition: cffcmap.c:138
static const WCHAR ControlClass[]
Definition: cfgmgr.c:44
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
void ME_InsertEndRowFromCursor(ME_TextEditor *editor, int nCursor)
Definition: caret.c:580
void ME_InsertTextFromCursor(ME_TextEditor *editor, int nCursor, const WCHAR *str, int len, ME_Style *style)
Definition: caret.c:595
void ME_StreamInFill(ME_InStream *stream)
Definition: editor.c:1576
void ME_RTFTblAttrHook(RTF_Info *info)
Definition: editor.c:874
void ME_RTFCharAttrHook(RTF_Info *info)
Definition: editor.c:425
void ME_RTFSpecialCharHook(RTF_Info *info)
Definition: editor.c:948
void ME_RTFParAttrHook(RTF_Info *info)
Definition: editor.c:556
int RTFCheckCM(const RTF_Info *info, int class, int major)
Definition: reader.c:2276
static void Lookup(RTF_Info *, char *)
Definition: reader.c:2228
void RTFDestroy(RTF_Info *info)
Definition: reader.c:161
static void RTFPutCodePageChar(RTF_Info *info, int c)
Definition: reader.c:2644
int RTFCharSetToCodePage(RTF_Info *info, int charset)
Definition: reader.c:493
static void RTFSetClassCallback(RTF_Info *info, int class, RTFFuncPtr callback)
Definition: reader.c:191
static void CharAttr(RTF_Info *info)
Definition: reader.c:2392
static void _RTFGetToken(RTF_Info *)
Definition: reader.c:454
static void SpecialChar(RTF_Info *info)
Definition: reader.c:2481
static void RTFFlushCPOutputBuffer(RTF_Info *info)
Definition: reader.c:2611
static void ReadInfoGroup(RTF_Info *)
Definition: reader.c:1194
static RTFHashTableEntry rtfHashTable[ARRAY_SIZE(rtfKey) *2]
Definition: reader.c:2184
void RTFSetEditStream(RTF_Info *info, ME_InStream *stream)
Definition: reader.c:116
static void RTFDestroyAttrs(RTF_Info *info)
Definition: reader.c:122
static RTFFuncPtr RTFGetReadHook(const RTF_Info *info)
Definition: reader.c:394
int RTFCharToHex(char c)
Definition: reader.c:2297
static void RTFUngetToken(RTF_Info *info)
Definition: reader.c:431
static void RTFPutUnicodeChar(RTF_Info *info, int c)
Definition: reader.c:2634
int BeginFile(RTF_Info *info)
Definition: reader.c:2335
static void _RTFGetToken2(RTF_Info *)
Definition: reader.c:554
static void ReadFontTbl(RTF_Info *)
Definition: reader.c:786
int RTFGetToken(RTF_Info *info)
Definition: reader.c:406
static void ReadColorTbl(RTF_Info *)
Definition: reader.c:965
static void CharSet(RTF_Info *info)
Definition: reader.c:2420
void RTFRead(RTF_Info *info)
Definition: reader.c:308
static RTFFuncPtr RTFGetDestinationCallback(const RTF_Info *info, int dest)
Definition: reader.c:288
static void RTFPutUnicodeString(RTF_Info *info, const WCHAR *string, int length)
Definition: reader.c:2593
static void ReadPictGroup(RTF_Info *)
Definition: reader.c:1201
static int GetChar(RTF_Info *)
Definition: reader.c:725
static void ReadStyleSheet(RTF_Info *)
Definition: reader.c:1025
static char * RTFStrSave(const char *s)
Definition: reader.c:81
RTFFont * RTFGetFont(const RTF_Info *info, int num)
Definition: reader.c:1222
void RTFRouteToken(RTF_Info *info)
Definition: reader.c:321
static int Hash(const char *)
Definition: reader.c:2257
void RTFInit(RTF_Info *info)
Definition: reader.c:212
int RTFCheckMM(const RTF_Info *info, int major, int minor)
Definition: reader.c:2288
static RTFFuncPtr RTFGetClassCallback(const RTF_Info *info, int class)
Definition: reader.c:198
void RTFFlushOutputBuffer(RTF_Info *info)
Definition: reader.c:2626
RTFColor * RTFGetColor(const RTF_Info *info, int num)
Definition: reader.c:1237
static void TextClass(RTF_Info *info)
Definition: reader.c:2350
void RTFSetReadHook(RTF_Info *info, RTFFuncPtr f)
Definition: reader.c:388
void LookupCleanup(void)
Definition: reader.c:2210
struct tagRTFHashTableEntry RTFHashTableEntry
void RTFSkipGroup(RTF_Info *info)
Definition: reader.c:354
static void RTFFlushUnicodeOutputBuffer(RTF_Info *info)
Definition: reader.c:2581
void LookupInit(void)
Definition: reader.c:2191
static void ReadObjGroup(RTF_Info *)
Definition: reader.c:1208
static void DocAttr(RTF_Info *info)
Definition: reader.c:2465
void RTFSetDestinationCallback(RTF_Info *info, int dest, RTFFuncPtr callback)
Definition: reader.c:281
static void DefFont(RTF_Info *info)
Definition: reader.c:2457
int RTFCheckCMM(const RTF_Info *info, int class, int major, int minor)
Definition: reader.c:2282
static RTFKey rtfKey[]
Definition: reader.c:1274
static int _RTFGetChar(RTF_Info *)
Definition: reader.c:95
void WriterInit(RTF_Info *info)
Definition: reader.c:2329
void RTFReadGroup(RTF_Info *info)
Definition: reader.c:379
unsigned char
Definition: typeof.h:29
void ME_AddRefStyle(ME_Style *item) DECLSPEC_HIDDEN
Definition: style.c:454
BOOL ME_SetSelectionParaFormat(ME_TextEditor *editor, const PARAFORMAT2 *pFmt) DECLSPEC_HIDDEN
Definition: para.c:907
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint level
Definition: gl.h:1546
GLdouble s
Definition: gl.h:2039
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLdouble n
Definition: glext.h:7729
GLuint buffer
Definition: glext.h:5915
const GLubyte * c
Definition: glext.h:8905
GLuint index
Definition: glext.h:6031
GLfloat f
Definition: glext.h:7540
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902
GLuint GLuint num
Definition: glext.h:9618
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define EOF
Definition: stdio.h:24
uint32_t entry
Definition: isohybrid.c:63
#define f
Definition: ke_i.h:83
#define c
Definition: ke_i.h:80
if(dx< 0)
Definition: linetemp.h:194
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
POINT cp
Definition: magnifier.c:59
#define sign(x)
Definition: mapdesc.cc:613
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
static IPrintDialogCallback callback
Definition: printdlg.c:326
static const WCHAR sp[]
Definition: suminfo.c:287
static char * dest
Definition: rtl.c:135
#define min(a, b)
Definition: monoChain.cc:55
Definition: mk_font.cpp:20
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:3004
#define minor(rdev)
Definition: propsheet.cpp:929
#define major(rdev)
Definition: propsheet.cpp:928
#define SF_TEXT
Definition: richedit.h:720
#define rtfFwdDarkBgPat
Definition: rtf.h:554
#define rtfPrintColorsBlack
Definition: rtf.h:333
#define rtfFileOSNum
Definition: rtf.h:744
#define rtfPosAttr
Definition: rtf.h:645
#define rtfACBold
Definition: rtf.h:714
#define rtfFieldInst
Definition: rtf.h:176
#define rtfParNumFont
Definition: rtf.h:519
#define rtfBullet
Definition: rtf.h:251
#define rtfACNoUnderline
Definition: rtf.h:730
#define rtfMacQD
Definition: rtf.h:602
#define rtfHyphConsecLines
Definition: rtf.h:279
#define rtfEvenBreak
Definition: rtf.h:367
#define rtfFNoteSep
Definition: rtf.h:233
#define rtfStyleAttr
Definition: rtf.h:271
#define rtfCellDarkBgPatV
Definition: rtf.h:447
#define rtfPicCropLeft
Definition: rtf.h:620
#define rtfPar
Definition: rtf.h:237
#define rtfColumnLine
Definition: rtf.h:374
#define rtfACStrikeThru
Definition: rtf.h:726
#define rtfRTLDoc
Definition: rtf.h:353
#define rtfDrawFgFillGreen
Definition: rtf.h:841
#define rtfCvtMailMergeQuote
Definition: rtf.h:336
#define rtfObjUpdate
Definition: rtf.h:684
#define rtfBgPatLineColor
Definition: rtf.h:558
#define rtfDrawLineHollow
Definition: rtf.h:822
#define rtfAbsWid
Definition: rtf.h:646
#define rtfRowCenter
Definition: rtf.h:422
#define rtfRQuote
Definition: rtf.h:253
#define rtfDrawPointY
Definition: rtf.h:807
#define rtfFacingPage
Definition: rtf.h:324
#define rtfAbsHt
Definition: rtf.h:647
#define rtfPicScaled
Definition: rtf.h:617
#define rtfAnsiCodePage
Definition: rtf.h:355
#define rtfBorderWidth
Definition: rtf.h:542
#define rtfNonShpPict
Definition: rtf.h:188
#define rtfNeXTGrAttr
Definition: rtf.h:630
#define rtfBorderDouble
Definition: rtf.h:538
#define rtfKeepNext
Definition: rtf.h:462
#define rtfPageRestart
Definition: rtf.h:394
#define rtfParNumOnce
Definition: rtf.h:496
#define rtfNeXTGHeight
Definition: rtf.h:632
#define rtfColorName
Definition: rtf.h:201
#define rtfParNumbering
Definition: rtf.h:149
#define rtfPMMetafile
Definition: rtf.h:603
#define rtfIndexRange
Definition: rtf.h:181
#define rtfDrawBgFillBlue
Definition: rtf.h:835
#define rtfColumn
Definition: rtf.h:240
#define rtfObjSetSize
Definition: rtf.h:687
#define rtfPosNegX
Definition: rtf.h:652
#define rtfFNContSep
Definition: rtf.h:133
#define rtfField
Definition: rtf.h:175
#define rtfNoLineNum
Definition: rtf.h:464
#define rtfBgPatV
Definition: rtf.h:547
#define rtfDrawLineGray
Definition: rtf.h:821
#define rtfIndexText
Definition: rtf.h:180
#define rtfQuadLeft
Definition: rtf.h:467
#define rtfDrawHollowEndArrow
Definition: rtf.h:826
#define rtfFooter
Definition: rtf.h:141
#define rtfPageNumColonSep
Definition: rtf.h:404
#define rtfSectAttr
Definition: rtf.h:358
#define rtfFileSource
Definition: rtf.h:746
#define rtfFootnote
Definition: rtf.h:166
#define rtfUnderline
Definition: rtf.h:583
#define rtfSuperScrShrink
Definition: rtf.h:589
#define rtfParNumTextBefore
Definition: rtf.h:151
#define rtfRevDTTM
Definition: rtf.h:579
#define rtfDrawAttr
Definition: rtf.h:757
#define rtfQuadRight
Definition: rtf.h:468
#define rtfFormProtected
Definition: rtf.h:343
#define rtfACSubScript
Definition: rtf.h:717
#define rtfCurHeadDateLong
Definition: rtf.h:226
#define rtfFNSep
Definition: rtf.h:132
#define rtfParNumLeft
Definition: rtf.h:525
#define rtfObjHt
Definition: rtf.h:685
#define rtfRowGapH
Definition: rtf.h:416
#define rtfRTFDefault
Definition: rtf.h:285
#define rtfAnnotAuthor
Definition: rtf.h:170
#define rtfENoteEndDoc
Definition: rtf.h:295
#define rtfHeaderLeft
Definition: rtf.h:142
#define rtfPageULetter
Definition: rtf.h:400
#define rtfBorderRight
Definition: rtf.h:531
#define rtfPageLLetter
Definition: rtf.h:401
#define rtfBeginGroup
Definition: rtf.h:89
#define rtfAnnotIcon
Definition: rtf.h:174
#define rtfColumns
Definition: rtf.h:369
#define rtfRPosColH
Definition: rtf.h:650
#define rtfFNContNotice
Definition: rtf.h:134
#define rtfFieldAttr
Definition: rtf.h:634
#define rtfBorderBar
Definition: rtf.h:533
#define rtfRDblQuote
Definition: rtf.h:255
#define rtfITitle
Definition: rtf.h:121
#define rtfPicMFHasBitmap
Definition: rtf.h:622
#define rtfFileInfo
Definition: rtf.h:115
#define rtfFNoteNumURoman
Definition: rtf.h:309
#define rtfPosY
Definition: rtf.h:661
#define rtfRowBordLeft
Definition: rtf.h:430
#define rtfDrawPolyLine
Definition: rtf.h:775
#define rtfGreen
Definition: rtf.h:203
#define rtfPageNumTop
Definition: rtf.h:396
#define rtfLTRRow
Definition: rtf.h:428
#define rtfDrawLineGreen
Definition: rtf.h:814
#define rtfHyphenate
Definition: rtf.h:458
#define rtfFFTech
Definition: rtf.h:198
#define rtfDrawShadowXOffset
Definition: rtf.h:848
#define rtfCellShading
Definition: rtf.h:439
#define rtfCurHeadTime
Definition: rtf.h:228
#define rtfNoWidowControl
Definition: rtf.h:461
#define rtfFileNum
Definition: rtf.h:742
#define rtfINPages
Definition: rtf.h:220
#define rtfIndex
Definition: rtf.h:179
#define rtfFFModern
Definition: rtf.h:195
#define rtfDrawBgFillGray
Definition: rtf.h:839
#define rtfCurHeadPict
Definition: rtf.h:265
#define rtfWordUnderline
Definition: rtf.h:587
#define rtfDrawTextBoxMargin
Definition: rtf.h:802
#define rtfLTRPar
Definition: rtf.h:480
#define rtfObjAutoLink
Definition: rtf.h:678
#define rtfParNumTextAfter
Definition: rtf.h:150
#define rtfPage
Definition: rtf.h:239
#define rtfMergePrevious
Definition: rtf.h:419
#define rtfRowBordTop
Definition: rtf.h:429
#define rtfFontFamily
Definition: rtf.h:191
#define rtfParNumLevelStyle
Definition: rtf.h:139
#define rtfWinMetafile
Definition: rtf.h:604
#define rtfParNumAcross
Definition: rtf.h:497
#define rtfPageLRoman
Definition: rtf.h:399
#define rtfCellBgPatColor
Definition: rtf.h:453
#define rtfBorderShadow
Definition: rtf.h:537
#define rtfParBullet
Definition: rtf.h:493
#define rtfDrawBeginGroup
Definition: rtf.h:767
#define rtfControlKey
Definition: rtf.h:710
#define rtfCellDarkHatchBgPat
Definition: rtf.h:450
#define rtfBookmarkFirstCol
Definition: rtf.h:627
#define rtfEndGroup
Definition: rtf.h:90
#define rtfRowRight
Definition: rtf.h:421
#define rtfCOAttachSmart
Definition: rtf.h:796
#define rtfCellHatchBgPat
Definition: rtf.h:444
#define rtfPageStarts
Definition: rtf.h:392
#define rtfObjName
Definition: rtf.h:157
#define rtfGray
Definition: rtf.h:598
#define rtfKeep
Definition: rtf.h:460
#define rtfDrawLineDashDot
Definition: rtf.h:817
#define rtfDropCapLines
Definition: rtf.h:672
#define rtfDbUnderline
Definition: rtf.h:585
#define rtfCurHeadPage
Definition: rtf.h:229
#define rtfRTLRow
Definition: rtf.h:427
#define rtfEmfBlip
Definition: rtf.h:607
#define rtfFontAttr
Definition: rtf.h:734
#define rtfIVersion
Definition: rtf.h:127
#define rtfSuppressPreParSpace
Definition: rtf.h:338
#define rtfNestTableProps
Definition: rtf.h:185
#define rtfTopMargin
Definition: rtf.h:322
#define rtfFTypeTrueType
Definition: rtf.h:739
#define rtfBufSiz
Definition: rtf.h:30
#define rtfDrawHeight
Definition: rtf.h:765
#define rtfCOOffset
Definition: rtf.h:795
#define rtfPageNumSpaceSep
Definition: rtf.h:403
#define rtfAnnotRefEnd
Definition: rtf.h:168
#define rtfBorderSingle
Definition: rtf.h:535
#define rtfPosXCenter
Definition: rtf.h:653
#define rtfAdditive
Definition: rtf.h:272
#define rtfPosYTop
Definition: rtf.h:664
#define rtfPosX
Definition: rtf.h:651
#define rtfObjTime
Definition: rtf.h:158
#define rtfCharCharSet
Definition: rtf.h:596
#define rtfObjLinkSelf
Definition: rtf.h:682
#define rtfSideBySide
Definition: rtf.h:466
#define rtfDistFromTextY
Definition: rtf.h:670
#define rtfParLevel
Definition: rtf.h:492
#define rtfSectMarginBottom
Definition: rtf.h:386
#define rtfBgPatColor
Definition: rtf.h:559
#define rtfCOSingleLine
Definition: rtf.h:799
#define rtfAnnotRefStart
Definition: rtf.h:167
#define rtfFNoteAttr
Definition: rtf.h:704
#define rtfVersion
Definition: rtf.h:96
#define rtfUnicode
Definition: rtf.h:267
#define rtfParNumNoUnder
Definition: rtf.h:515
#define rtfDrawGroupCount
Definition: rtf.h:768
#define rtfPageCont
Definition: rtf.h:393
#define rtfNoWidthNonJoiner
Definition: rtf.h:264
#define rtfQuadCenter
Definition: rtf.h:470
#define rtfDefTab
Definition: rtf.h:277
#define rtfUnicodeLength
Definition: rtf.h:599
#define rtfENoteNumLRoman
Definition: rtf.h:314
#define rtfBgPatH
Definition: rtf.h:546
#define rtfDrawFgFillRed
Definition: rtf.h:842
#define rtfACWordUnderline
Definition: rtf.h:731
#define rtfLeaderDot
Definition: rtf.h:487
#define rtfFNoteText
Definition: rtf.h:292
#define rtfCurAnnotRef
Definition: rtf.h:232
#define rtfDrawRect
Definition: rtf.h:776
#define rtfACExpand
Definition: rtf.h:718
#define rtfACSuperScript
Definition: rtf.h:732
#define rtfDrawStartArrowLength
Definition: rtf.h:831
#define rtfParNumItalic
Definition: rtf.h:509
#define rtfCORightAngle
Definition: rtf.h:798
#define rtfCellBordBottom
Definition: rtf.h:435
#define rtfParNumText
Definition: rtf.h:148
#define rtfRTLChar
Definition: rtf.h:593
#define rtfSubScrShrink
Definition: rtf.h:568
#define New(t)
Definition: rtf.h:1086
#define rtfShadow
Definition: rtf.h:581
#define rtfLine
Definition: rtf.h:241
#define rtfDocTemplate
Definition: rtf.h:287
#define rtfSoftLine
Definition: rtf.h:244
#define rtfLineCont
Definition: rtf.h:380
#define rtfIDoccomm
Definition: rtf.h:128
#define rtfParNumCont
Definition: rtf.h:495
#define rtfPcCharSet
Definition: rtf.h:103
#define rtfShpPict
Definition: rtf.h:187
#define rtfWinBitmap
Definition: rtf.h:606
#define rtfENContNotice
Definition: rtf.h:137
#define rtfBorderBottom
Definition: rtf.h:529
#define rtfSubDocument
Definition: rtf.h:478
#define rtfColumnNumber
Definition: rtf.h:371
#define rtfFFBidirectional
Definition: rtf.h:199
#define rtfPrintData
Definition: rtf.h:347
#define rtfDrawShadow
Definition: rtf.h:847
#define rtfDrawSolidEndArrow
Definition: rtf.h:828
#define rtfFontCodePage
Definition: rtf.h:737
#define rtfGutterWid
Definition: rtf.h:325
#define rtfLeaderHyphen
Definition: rtf.h:488
#define rtfParHangIndent
Definition: rtf.h:498
#define rtfENoteNumURoman
Definition: rtf.h:315
#define rtfBitmapPlanes
Definition: rtf.h:609
#define rtfNext
Definition: rtf.h:274
#define rtfRowKeep
Definition: rtf.h:426
#define rtfPageNumLevel
Definition: rtf.h:138
#define rtfTranspMetafiles
Definition: rtf.h:340
#define rtfLineStart
Definition: rtf.h:282
#define rtfParNumFontSize
Definition: rtf.h:520
#define rtfDrawTextBoxText
Definition: rtf.h:803
#define rtfSectMarginTop
Definition: rtf.h:385
#define rtfDistFromTextAll
Definition: rtf.h:668
#define rtfPosXRight
Definition: rtf.h:656
#define rtfPaperWidth
Definition: rtf.h:317
#define rtfENoteBottom
Definition: rtf.h:297
#define rtfPicGoalWid
Definition: rtf.h:613
#define rtfPaperSize
Definition: rtf.h:319
#define rtfSuperScript
Definition: rtf.h:588
#define rtfSectDef
Definition: rtf.h:359
#define rtfPrtBin
Definition: rtf.h:362
#define rtfObjCropBottom
Definition: rtf.h:691
#define rtfAnnotation
Definition: rtf.h:171
#define rtfPosYInline
Definition: rtf.h:663
#define rtfINChars
Definition: rtf.h:222
#define rtfFooterFirst
Definition: rtf.h:147
#define rtfFNoteCont
Definition: rtf.h:234
#define rtfFieldAlt
Definition: rtf.h:639
#define rtfRowBordBottom
Definition: rtf.h:431
#define rtfFontTbl
Definition: rtf.h:110
#define rtfFieldEdited
Definition: rtf.h:636
#define rtfINWords
Definition: rtf.h:221
#define rtfBookmarkLastCol
Definition: rtf.h:628
#define rtfNoUnderline
Definition: rtf.h:586
#define rtfENContSep
Definition: rtf.h:136
#define rtfDrawArc
Definition: rtf.h:770
#define rtfObjPubAutoUpdate
Definition: rtf.h:702
#define rtfSuppressTopSpace
Definition: rtf.h:337
#define rtfFNoteNumULetter
Definition: rtf.h:307
#define rtfSectLandscape
Definition: rtf.h:388
#define rtfTextDistY
Definition: rtf.h:671
#define rtfFTypeNil
Definition: rtf.h:738
#define rtfFontCharSet
Definition: rtf.h:735
#define rtfObjResMerge
Definition: rtf.h:700
#define rtfBottomMargin
Definition: rtf.h:323
#define rtfDrawShadowYOffset
Definition: rtf.h:849
#define rtfISecond
Definition: rtf.h:219
#define rtfENoteNumChicago
Definition: rtf.h:316
#define rtfFNoteStart
Definition: rtf.h:298
#define rtfDrawBgFillRed
Definition: rtf.h:837
#define rtfIBackupTime
Definition: rtf.h:212
#define rtfNormalStyleNum
Definition: rtf.h:71
#define rtfMakeBackup
Definition: rtf.h:284
#define rtfBorderLeft
Definition: rtf.h:530
#define rtfPageNumHyphSep
Definition: rtf.h:402
#define rtfFNoteEndDoc
Definition: rtf.h:291
#define rtfFENoteType
Definition: rtf.h:289
#define rtfStrikeThru
Definition: rtf.h:582
#define rtfTblAttr
Definition: rtf.h:414
#define rtfDrawLineWidth
Definition: rtf.h:824
#define rtfLinkStyles
Definition: rtf.h:330
#define rtfSpecialChar
Definition: rtf.h:206
#define rtfPosYBottom
Definition: rtf.h:666
#define rtfLineDist
Definition: rtf.h:376
#define rtfPicMFBitsPerPixel
Definition: rtf.h:623
#define rtfDefLanguage
Definition: rtf.h:288
#define rtfRowLeft
Definition: rtf.h:420
#define rtfTabDecimal
Definition: rtf.h:485
#define rtfNoBreak
Definition: rtf.h:364
#define rtfFormShading
Definition: rtf.h:345
#define rtfFFRoman
Definition: rtf.h:193
#define rtfParNumUnder
Definition: rtf.h:512
#define rtfSrcMacintosh
Definition: rtf.h:747
#define rtfParNumBold
Definition: rtf.h:508
#define rtfDrawColumnRelY
Definition: rtf.h:763
#define rtfObjScaleX
Definition: rtf.h:694
#define rtfItalic
Definition: rtf.h:575
#define rtfIVerscomm
Definition: rtf.h:129
#define rtfQuadJust
Definition: rtf.h:469
#define rtfRowDef
Definition: rtf.h:415
#define rtfACUnderline
Definition: rtf.h:727
#define rtfNextFile
Definition: rtf.h:130
#define rtfBasedOn
Definition: rtf.h:273
#define rtfPicGoalHt
Definition: rtf.h:614
#define rtfBlue
Definition: rtf.h:204
#define rtfDrawArcFlipY
Definition: rtf.h:811
#define rtfEOF
Definition: rtf.h:82
#define rtfParDef
Definition: rtf.h:456
#define rtfParNumLRoman
Definition: rtf.h:505
#define rtfOddBreak
Definition: rtf.h:368
#define rtfColBreak
Definition: rtf.h:365
#define rtfFontPitch
Definition: rtf.h:736
#define rtfBookmarkStart
Definition: rtf.h:152
#define rtfObjPublisher
Definition: rtf.h:680
#define rtfObjTransposeY
Definition: rtf.h:689
#define rtfCellDiagHatchBgPat
Definition: rtf.h:445
#define rtfCOLength
Definition: rtf.h:792
#define rtfRowHeader
Definition: rtf.h:425
#define rtfTabRight
Definition: rtf.h:483
#define rtfCellBgPatV
Definition: rtf.h:441
#define rtfRowLeftEdge
Definition: rtf.h:423
#define rtfCOAttachAbsDist
Definition: rtf.h:788
#define rtfFunctionKey
Definition: rtf.h:711
#define rtfIComment
Definition: rtf.h:126
#define rtfExpandTwips
Definition: rtf.h:571
#define rtfENoteEndSect
Definition: rtf.h:294
#define rtfParNumCenter
Definition: rtf.h:524
#define rtfENoteNumArabic
Definition: rtf.h:311
#define rtfRPosMargV
Definition: rtf.h:658
#define rtfDrawLineRed
Definition: rtf.h:815
#define rtfMirrorMargin
Definition: rtf.h:326
#define rtfDrawColumnRelX
Definition: rtf.h:760
#define rtfIIntID
Definition: rtf.h:223
#define rtfParNumStartAt
Definition: rtf.h:527
#define rtfGenerator
Definition: rtf.h:184
#define rtfBorderColor
Definition: rtf.h:543
#define rtfPosXInside
Definition: rtf.h:654
#define rtfAnnotProtected
Definition: rtf.h:352
#define rtfObjResult
Definition: rtf.h:162
#define rtfEmbeddedFont
Definition: rtf.h:112
#define rtfCellBordRight
Definition: rtf.h:438
#define rtfFormula
Definition: rtf.h:256
#define rtfOutline
Definition: rtf.h:576
#define rtfBottomVAlign
Definition: rtf.h:408
#define rtfPSOverlay
Definition: rtf.h:286
#define rtfDrawOffsetY
Definition: rtf.h:781
#define rtfObjWid
Definition: rtf.h:686
#define rtfSpaceMultiply
Definition: rtf.h:477
#define rtfRowBordHoriz
Definition: rtf.h:433
#define rtfPageURoman
Definition: rtf.h:398
#define rtfDarkDiagHatchBgPat
Definition: rtf.h:557
#define rtfTOC
Definition: rtf.h:182
#define rtfObjICEmb
Definition: rtf.h:681
#define rtfParNumULetter
Definition: rtf.h:502
#define rtfDrawFillPatIndex
Definition: rtf.h:845
#define rtfParNumDbUnder
Definition: rtf.h:514
#define rtfDrawLock
Definition: rtf.h:758
#define rtfWidowCtrl
Definition: rtf.h:329
#define rtfRevised
Definition: rtf.h:577
#define rtfPrtBinFirst
Definition: rtf.h:361
#define rtfDarkBgPatH
Definition: rtf.h:552
#define rtfObjCropTop
Definition: rtf.h:690
#define rtfObject
Definition: rtf.h:155
#define rtfDrawEndArrowLength
Definition: rtf.h:827
#define rtfSectNum
Definition: rtf.h:230
#define rtfStyleSheet
Definition: rtf.h:117
#define rtfLandscape
Definition: rtf.h:327
#define rtfFNoteNumLLetter
Definition: rtf.h:306
#define rtfFieldResult
Definition: rtf.h:177
#define rtfParSimple
Definition: rtf.h:494
#define rtfDropCapType
Definition: rtf.h:673
#define rtfObjLink
Definition: rtf.h:677
#define rtfSectPageWid
Definition: rtf.h:381
#define rtfDrawBgFillPalette
Definition: rtf.h:838
#define rtfNestLevel
Definition: rtf.h:560
#define rtfACFontNum
Definition: rtf.h:719
void(* RTFFuncPtr)(RTF_Info *)
Definition: rtf.h:1095
#define rtfCOAngle
Definition: rtf.h:784
#define rtfCell
Definition: rtf.h:235
#define rtfACharAttr
Definition: rtf.h:713
#define rtfFileAttr
Definition: rtf.h:741
#define rtfPictAttr
Definition: rtf.h:601
#define rtfFNoteRestartCont
Definition: rtf.h:302
#define rtfSectStyle
Definition: rtf.h:944
#define rtfObjEmb
Definition: rtf.h:676
#define rtfDrawLineSolid
Definition: rtf.h:823
#define rtfNoStyleNum
Definition: rtf.h:70
#define rtfRed
Definition: rtf.h:202
#define rtfFormDisplay
Definition: rtf.h:346
#define rtfColumnSpace
Definition: rtf.h:370
#define rtfIYear
Definition: rtf.h:214
#define rtfPlain
Definition: rtf.h:563
#define rtfDrawFgFillBlue
Definition: rtf.h:840
#define rtfTOCType
Definition: rtf.h:642
#define rtfICreateTime
Definition: rtf.h:209
#define rtfCenterVAlign
Definition: rtf.h:409
#define rtfFieldPrivate
Definition: rtf.h:638
#define rtfPixelBits
Definition: rtf.h:608
#define rtfMergeRngFirst
Definition: rtf.h:418
#define rtfNoReqHyphen
Definition: rtf.h:258
#define rtfSrcHPFS
Definition: rtf.h:750
#define rtfFwdDiagBgPat
Definition: rtf.h:548
#define rtfDataField
Definition: rtf.h:178
#define rtfRightIndent
Definition: rtf.h:473
#define rtfForeColor
Definition: rtf.h:591
#define rtfACSmallCaps
Definition: rtf.h:724
#define rtfFNoteNumLRoman
Definition: rtf.h:308
#define rtfENoteStart
Definition: rtf.h:299
#define rtfFNoteEndSect
Definition: rtf.h:290
#define rtfHyphHotZone
Definition: rtf.h:278
#define rtfDeleted
Definition: rtf.h:566
#define rtfNoWidthJoiner
Definition: rtf.h:263
#define rtfEmSpace
Definition: rtf.h:249
#define rtfDrawLineDash
Definition: rtf.h:819
#define rtfENoteRestartCont
Definition: rtf.h:304
#define rtfTemplate
Definition: rtf.h:131
#define rtfPosNegY
Definition: rtf.h:662
#define rtfCellBwdDiagBgPat
Definition: rtf.h:443
#define rtfRTLSect
Definition: rtf.h:411
#define rtfCellBgPatH
Definition: rtf.h:440
#define rtfCONegXQuadrant
Definition: rtf.h:793
#define rtfSubScript
Definition: rtf.h:567
#define rtfRowHt
Definition: rtf.h:424
#define rtfMaxDestination
Definition: rtf.h:189
#define rtfCellBordLeft
Definition: rtf.h:437
#define rtfCharAttr
Definition: rtf.h:562
#define rtfACDotUnderline
Definition: rtf.h:728
#define rtfLanguage
Definition: rtf.h:597
#define rtfSoftColumn
Definition: rtf.h:243
#define rtfFNAlt
Definition: rtf.h:705
#define rtfDrawPolygon
Definition: rtf.h:774
#define rtfIRevisionTime
Definition: rtf.h:210
#define rtfBookmarkAttr
Definition: rtf.h:626
#define rtfENoteHere
Definition: rtf.h:360
#define rtfAllCaps
Definition: rtf.h:565
#define rtfSmallCaps
Definition: rtf.h:580
#define rtfCOAttachCenter
Definition: rtf.h:790
#define rtfHyphCaps
Definition: rtf.h:280
#define rtfCOAccentBar
Definition: rtf.h:785
#define rtfCOBorder
Definition: rtf.h:787
#define rtfParNumLLetter
Definition: rtf.h:504
#define rtfDiagHatchBgPat
Definition: rtf.h:551
#define rtfDefFont
Definition: rtf.h:98
#define rtfObjResRTF
Definition: rtf.h:696
#define rtfPBBefore
Definition: rtf.h:465
#define rtfNoParam
Definition: rtf.h:62
#define rtfAnnotRef
Definition: rtf.h:172
#define rtfBorderHair
Definition: rtf.h:541
#define rtfText
Definition: rtf.h:80
#define rtfLeftMargin
Definition: rtf.h:320
#define rtfObjTopic
Definition: rtf.h:164
#define rtfTOCAttr
Definition: rtf.h:641
#define rtfAltKey
Definition: rtf.h:708
#define rtfCOTripleLine
Definition: rtf.h:800
#define rtfParNumRestart
Definition: rtf.h:499
#define rtfSect
Definition: rtf.h:238
#define rtfHeaderFirst
Definition: rtf.h:144
#define rtfObjScaleY
Definition: rtf.h:695
#define rtfPosXLeft
Definition: rtf.h:657
#define rtfDrawLineDot
Definition: rtf.h:820
#define rtfRTLPar
Definition: rtf.h:479
#define rtfRow
Definition: rtf.h:236
#define rtfParNumStrikethru
Definition: rtf.h:517
#define rtfShading
Definition: rtf.h:545
#define rtfInfo
Definition: rtf.h:120
#define rtfFNoteBottom
Definition: rtf.h:293
#define rtfSrcNTFS
Definition: rtf.h:749
#define rtfPosXOutSide
Definition: rtf.h:655
#define rtfParNumInclPrev
Definition: rtf.h:523
#define rtfUTF8RTF
Definition: rtf.h:356
#define rtfTab
Definition: rtf.h:246
#define rtfDrawFgFillGray
Definition: rtf.h:844
#define rtfNoBrkHyphen
Definition: rtf.h:259
#define rtfDrawLine
Definition: rtf.h:773
#define rtfCellPos
Definition: rtf.h:417
#define rtfObjCropRight
Definition: rtf.h:693
#define rtfHeaderRight
Definition: rtf.h:143
#define rtfRevBar
Definition: rtf.h:351
#define rtfSectPageHt
Definition: rtf.h:382
#define rtfLeaderUnder
Definition: rtf.h:489
#define rtfFieldDirty
Definition: rtf.h:635
#define rtfExpand
Definition: rtf.h:570
#define rtfENoteNumULetter
Definition: rtf.h:313
#define rtfCONegYQuadrant
Definition: rtf.h:794
#define rtfDistFromTextX
Definition: rtf.h:669
#define rtfSpaceBetween
Definition: rtf.h:476
#define rtfPageStart
Definition: rtf.h:328
#define rtfCOBestFit
Definition: rtf.h:786
#define rtfCurHeadDateAbbrev
Definition: rtf.h:227
#define rtfNestRow
Definition: rtf.h:269
#define rtfHatchBgPat
Definition: rtf.h:550
#define rtfShowHardBreaks
Definition: rtf.h:342
#define rtfObjSection
Definition: rtf.h:161
#define rtfParAttr
Definition: rtf.h:455
#define rtfParNumCardinal
Definition: rtf.h:500
#define rtfShiftKey
Definition: rtf.h:709
#define rtfObjClass
Definition: rtf.h:156
#define rtfISubject
Definition: rtf.h:122
#define rtfSectStyleNum
Definition: rtf.h:363
#define rtfCellFwdDiagBgPat
Definition: rtf.h:442
#define rtfDrawMarginRelY
Definition: rtf.h:764
#define rtfRightMargin
Definition: rtf.h:321
#define rtfNestCell
Definition: rtf.h:268
#define rtfSpaceBefore
Definition: rtf.h:474
#define rtfACAllCaps
Definition: rtf.h:715
#define rtfBold
Definition: rtf.h:564
#define rtfPict
Definition: rtf.h:154
#define rtfColumnSpRight
Definition: rtf.h:372
#define rtfIMinute
Definition: rtf.h:218
#define rtfBorderTop
Definition: rtf.h:528
#define rtfCellBwdDarkBgPat
Definition: rtf.h:449
#define rtfACLanguage
Definition: rtf.h:722
#define rtfSrcDOS
Definition: rtf.h:748
#define rtfDrawEndArrowWidth
Definition: rtf.h:829
#define rtfMaxClass
Definition: rtf.h:83
#define rtfRPosPageH
Definition: rtf.h:649
#define rtfIAuthor
Definition: rtf.h:123
#define rtfDrawSizeY
Definition: rtf.h:782
#define rtfFFDecor
Definition: rtf.h:197
#define rtfAllProtected
Definition: rtf.h:344
#define rtfPosYCenter
Definition: rtf.h:665
#define rtfFFScript
Definition: rtf.h:196
#define rtfNoExtraSpaceRL
Definition: rtf.h:334
#define rtfFooterY
Definition: rtf.h:391
#define rtfDrawLineDashDotDot
Definition: rtf.h:818
#define rtfObjResBitmap
Definition: rtf.h:698
#define rtfRevisionTbl
Definition: rtf.h:119
#define rtfInTable
Definition: rtf.h:459
#define rtfDrawEllipse
Definition: rtf.h:772
#define rtfENoteNumLLetter
Definition: rtf.h:312
#define rtfDrawObject
Definition: rtf.h:165
#define rtfCurHeadDate
Definition: rtf.h:225
#define rtfFFSwiss
Definition: rtf.h:194
#define rtfAnnotTime
Definition: rtf.h:173
#define rtfCellDarkDiagHatchBgPat
Definition: rtf.h:451
#define rtfKeyCodeAttr
Definition: rtf.h:707
#define rtfNeXTGWidth
Definition: rtf.h:631
#define rtfFFNil
Definition: rtf.h:192
#define rtfFontFile
Definition: rtf.h:113
#define rtfDrawCallout
Definition: rtf.h:771
#define rtfObjData
Definition: rtf.h:159
#define rtfSoftPage
Definition: rtf.h:242
#define rtfPageNumEndashSep
Definition: rtf.h:406
#define rtfRevProtected
Definition: rtf.h:348
#define rtfNoNestTables
Definition: rtf.h:186
#define rtfObjAlias
Definition: rtf.h:160
#define rtfFooterRight
Definition: rtf.h:146
#define rtfFNoteRestartPage
Definition: rtf.h:300
#define rtfCharSet
Definition: rtf.h:100
#define rtfSectMarginGutter
Definition: rtf.h:387
#define rtfDrawBgFillGreen
Definition: rtf.h:836
#define rtfParNumForeColor
Definition: rtf.h:518
#define rtfPicHt
Definition: rtf.h:612
#define rtfTOCLevel
Definition: rtf.h:643
#define rtfCODoubleLine
Definition: rtf.h:797
#define rtfCombineTblBorders
Definition: rtf.h:339
#define rtfObjAlign
Definition: rtf.h:688
#define rtfLineModulus
Definition: rtf.h:375
#define rtfControl
Definition: rtf.h:81
#define rtfBorderThick
Definition: rtf.h:536
#define rtfLDblQuote
Definition: rtf.h:254
#define rtfDrawStartArrowWidth
Definition: rtf.h:833
#define rtfDrawHollowStartArrow
Definition: rtf.h:830
#define rtfTopVAlign
Definition: rtf.h:407
#define rtfFirstIndent
Definition: rtf.h:471
#define rtfIndexItalic
Definition: rtf.h:858
#define rtfFieldLocked
Definition: rtf.h:637
#define rtfObjResPict
Definition: rtf.h:697
#define rtfOutlineLevel
Definition: rtf.h:463
#define rtfLTRMark
Definition: rtf.h:261
#define rtfFontSize
Definition: rtf.h:574
#define rtfFooterLeft
Definition: rtf.h:145
#define rtfBorderDot
Definition: rtf.h:539
#define rtfObjCropLeft
Definition: rtf.h:692
#define rtfIndexBold
Definition: rtf.h:857
#define rtfIIntVersion
Definition: rtf.h:208
#define rtfRevDisplay
Definition: rtf.h:350
#define rtfBookmarkEnd
Definition: rtf.h:153
#define rtfParStyle
Definition: rtf.h:942
#define rtfCellDarkBgPatH
Definition: rtf.h:446
#define rtfObjResText
Definition: rtf.h:699
#define rtfDrawLineBlue
Definition: rtf.h:813
#define rtfDrawTextBox
Definition: rtf.h:777
#define rtfDrawRoundRect
Definition: rtf.h:804
#define rtfBwdDiagBgPat
Definition: rtf.h:549
#define rtfHeaderY
Definition: rtf.h:390
#define rtfBwdDarkBgPat
Definition: rtf.h:555
#define rtfLTRSect
Definition: rtf.h:412
#define rtfIMonth
Definition: rtf.h:215
#define rtfPicWid
Definition: rtf.h:611
#define rtfObjItem
Definition: rtf.h:163
#define rtfRevAuthor
Definition: rtf.h:578
#define rtfFNoteNumArabic
Definition: rtf.h:305
#define rtfIHour
Definition: rtf.h:217
#define rtfJustVAlign
Definition: rtf.h:410
#define rtfBackColor
Definition: rtf.h:592
#define rtfCharStyle
Definition: rtf.h:943
#define rtfHeader
Definition: rtf.h:140
#define rtfTabBar
Definition: rtf.h:486
#define rtfFracWidth
Definition: rtf.h:283
#define rtfDarkBgPatV
Definition: rtf.h:553
#define rtfENoteRestart
Definition: rtf.h:303
#define rtfEnDash
Definition: rtf.h:248
#define rtfTabPos
Definition: rtf.h:481
#define rtfCellFwdDarkBgPat
Definition: rtf.h:448
#define rtfFileRelPath
Definition: rtf.h:743
#define rtfHyphAuto
Definition: rtf.h:281
#define rtfNoAutoTabIndent
Definition: rtf.h:331
#define rtfPageNumEmdashSep
Definition: rtf.h:405
#define rtfMacCharSet
Definition: rtf.h:102
#define rtfLineRestart
Definition: rtf.h:378
#define rtfIndexAttr
Definition: rtf.h:855
#define rtfParNumIndent
Definition: rtf.h:521
#define rtfNoColumnBalance
Definition: rtf.h:335
#define rtfDocAttr
Definition: rtf.h:276
#define rtfOptDest
Definition: rtf.h:260
#define rtfPicCropTop
Definition: rtf.h:618
#define rtfStyleNum
Definition: rtf.h:457
#define rtfBitmapWid
Definition: rtf.h:610
#define rtfObjLock
Definition: rtf.h:683
#define rtfSwapBorders
Definition: rtf.h:341
#define rtfSectMarginLeft
Definition: rtf.h:383
#define rtfLTRDoc
Definition: rtf.h:354
#define rtfIPrintTime
Definition: rtf.h:211
#define rtfDrawEndGroup
Definition: rtf.h:769
#define rtfNoBrkSpace
Definition: rtf.h:257
#define rtfGroup
Definition: rtf.h:79
#define rtfDrawPageRelY
Definition: rtf.h:762
#define rtfPaperHeight
Definition: rtf.h:318
#define rtfParNumRight
Definition: rtf.h:526
#define rtfPageBreak
Definition: rtf.h:366
#define rtfAnnotID
Definition: rtf.h:169
#define rtfEmDash
Definition: rtf.h:247
#define rtfLTRChar
Definition: rtf.h:594
#define rtfSrcNetwork
Definition: rtf.h:751
#define rtfCOAttachBottom
Definition: rtf.h:789
#define rtfRTLMark
Definition: rtf.h:262
#define rtfColumnWidth
Definition: rtf.h:373
#define rtfRPosPageV
Definition: rtf.h:659
#define rtfACDbUnderline
Definition: rtf.h:729
#define rtfRPosMargH
Definition: rtf.h:648
#define rtfIKeywords
Definition: rtf.h:125
#define rtfCurFNote
Definition: rtf.h:231
#define rtfSpaceAfter
Definition: rtf.h:475
#define rtfPicScaleY
Definition: rtf.h:616
#define rtfDrawMarginRelX
Definition: rtf.h:761
#define rtfParNumWordUnder
Definition: rtf.h:516
#define rtfColorTbl
Definition: rtf.h:116
#define rtfBorderBetween
Definition: rtf.h:532
#define rtfDrawPageRelX
Definition: rtf.h:759
#define rtfACShadow
Definition: rtf.h:725
#define rtfParNumDotUnder
Definition: rtf.h:513
#define rtfFontAltName
Definition: rtf.h:111
#define rtfDrawLinePalette
Definition: rtf.h:816
#define rtfDrawSizeX
Definition: rtf.h:780
#define rtfTabLeft
Definition: rtf.h:482
#define rtfDrawPolyCount
Definition: rtf.h:808
#define rtfCharStyleNum
Definition: rtf.h:595
#define rtfNoSuperSub
Definition: rtf.h:569
#define rtfCOAttachTop
Definition: rtf.h:791
#define rtfDestination
Definition: rtf.h:109
#define rtfDrawFgFillPalette
Definition: rtf.h:843
#define rtfLineStarts
Definition: rtf.h:377
#define rtfInvisible
Definition: rtf.h:590
#define rtfWrapSpaces
Definition: rtf.h:332
#define rtfFNoteNumChicago
Definition: rtf.h:310
#define rtfFontNum
Definition: rtf.h:573
#define rtfKerning
Definition: rtf.h:572
#define rtfObjSubscriber
Definition: rtf.h:679
#define rtfENoteText
Definition: rtf.h:296
#define rtfObjBookmarkPubObj
Definition: rtf.h:701
#define rtfSoftLineHt
Definition: rtf.h:245
#define rtfRowBordVert
Definition: rtf.h:434
#define rtfTitleSpecial
Definition: rtf.h:389
#define rtfDrawArcFlipX
Definition: rtf.h:810
#define rtfACItalic
Definition: rtf.h:721
#define rtfLeaderThick
Definition: rtf.h:490
#define rtfENSep
Definition: rtf.h:135
#define rtfKeyCode
Definition: rtf.h:118
#define rtfPageDecimal
Definition: rtf.h:397
#define rtfIDay
Definition: rtf.h:216
#define rtfDrawPointX
Definition: rtf.h:806
#define rtfNoWrap
Definition: rtf.h:667
#define rtfUnknown
Definition: rtf.h:78
#define rtfDevIndBitmap
Definition: rtf.h:605
#define rtfCellBordTop
Definition: rtf.h:436
#define rtfPicScaleX
Definition: rtf.h:615
#define rtfFileTbl
Definition: rtf.h:114
#define rtfParNumURoman
Definition: rtf.h:503
#define rtfIndexNumber
Definition: rtf.h:856
#define rtfParNumDecimal
Definition: rtf.h:501
#define rtfLeaderEqual
Definition: rtf.h:491
#define rtfPageNumRight
Definition: rtf.h:395
#define rtfAnsiCharSet
Definition: rtf.h:101
#define rtfRevisions
Definition: rtf.h:349
#define rtfParNumSpacing
Definition: rtf.h:522
#define rtfBorderBox
Definition: rtf.h:534
#define rtfRPosParaV
Definition: rtf.h:660
#define rtfLineRestartPg
Definition: rtf.h:379
#define rtfIEditTime
Definition: rtf.h:213
#define rtfPicBinary
Definition: rtf.h:624
#define rtfParNumOrdinal
Definition: rtf.h:506
#define rtfACForeColor
Definition: rtf.h:716
#define rtfParNumSmallCaps
Definition: rtf.h:511
#define rtfLQuote
Definition: rtf.h:252
#define rtfDarkHatchBgPat
Definition: rtf.h:556
#define rtfRowBordRight
Definition: rtf.h:432
#define rtfDrawSolidStartArrow
Definition: rtf.h:832
#define rtfBorderSpace
Definition: rtf.h:544
#define rtfACFontSize
Definition: rtf.h:720
#define rtfACOutline
Definition: rtf.h:723
#define rtfNeXTGraphic
Definition: rtf.h:183
#define rtfDrawOffsetX
Definition: rtf.h:779
#define rtfCellBgPatLineColor
Definition: rtf.h:452
#define rtfObjAttr
Definition: rtf.h:675
#define rtfFNoteRestart
Definition: rtf.h:301
#define rtfPcaCharSet
Definition: rtf.h:104
#define rtfPicCropBottom
Definition: rtf.h:619
#define rtfIOperator
Definition: rtf.h:124
#define rtfSectMarginRight
Definition: rtf.h:384
#define rtfDotUnderline
Definition: rtf.h:584
#define rtfEnSpace
Definition: rtf.h:250
#define rtfTabCenter
Definition: rtf.h:484
#define rtfLeftIndent
Definition: rtf.h:472
#define rtfPicCropRight
Definition: rtf.h:621
#define rtfParNumAllCaps
Definition: rtf.h:510
#define rtfParNumOrdinalText
Definition: rtf.h:507
#define CP_UTF8
Definition: nls.h:20
#define memset(x, y, z)
Definition: compat.h:39
#define TRACE(s)
Definition: solgame.cpp:4
Definition: rtf.h:979
Definition: rtf.h:960
int rtfFNum
Definition: rtf.h:963
int rtfFType
Definition: rtf.h:967
int rtfFPitch
Definition: rtf.h:966
int rtfFFamily
Definition: rtf.h:964
RTFFont * rtfNextFont
Definition: rtf.h:969
char * rtfFName
Definition: rtf.h:961
int rtfFCodePage
Definition: rtf.h:968
int rtfFCharSet
Definition: rtf.h:965
char * rtfFAltName
Definition: rtf.h:962
int rtfKMajor
Definition: reader.c:1263
const char * rtfKStr
Definition: reader.c:1265
int rtfKMinor
Definition: reader.c:1264
int rtfKHash
Definition: reader.c:1266
int rtfSEMinor
Definition: rtf.h:1006
char * rtfSEText
Definition: rtf.h:1008
int rtfSEParam
Definition: rtf.h:1007
RTFStyleElt * rtfNextSE
Definition: rtf.h:1009
int rtfSEClass
Definition: rtf.h:1004
int rtfSEMajor
Definition: rtf.h:1005
Definition: rtf.h:989
Definition: rtf.h:1026
RTFTable * parent
Definition: rtf.h:1044
Definition: _hash_fun.h:40
Definition: parse.h:23
RTFKey ** value
Definition: reader.c:2181
Definition: pdh_main.c:94
#define DEFAULT_PITCH
Definition: wingdi.h:443
#define RUSSIAN_CHARSET
Definition: wingdi.h:396
#define FF_DONTCARE
Definition: wingdi.h:448
#define ARABIC_CHARSET
Definition: wingdi.h:394
#define HANGEUL_CHARSET
Definition: wingdi.h:387
#define DEFAULT_CHARSET
Definition: wingdi.h:384
#define THAI_CHARSET
Definition: wingdi.h:397
#define GREEK_CHARSET
Definition: wingdi.h:391
#define JOHAB_CHARSET
Definition: wingdi.h:401
#define CHINESEBIG5_CHARSET
Definition: wingdi.h:390
#define ANSI_CHARSET
Definition: wingdi.h:383
#define TCI_SRCCHARSET
Definition: wingdi.h:961
#define OEM_CHARSET
Definition: wingdi.h:400
#define VIETNAMESE_CHARSET
Definition: wingdi.h:402
#define MAC_CHARSET
Definition: wingdi.h:403
#define HEBREW_CHARSET
Definition: wingdi.h:393
#define SHIFTJIS_CHARSET
Definition: wingdi.h:386
BOOL WINAPI TranslateCharsetInfo(_Inout_ PDWORD, _Out_ LPCHARSETINFO, _In_ DWORD)
#define SYMBOL_CHARSET
Definition: wingdi.h:385
#define EASTEUROPE_CHARSET
Definition: wingdi.h:399
#define GB2312_CHARSET
Definition: wingdi.h:389
#define BALTIC_CHARSET
Definition: wingdi.h:395
#define TURKISH_CHARSET
Definition: wingdi.h:392
#define CP_OEMCP
Definition: winnls.h:231
#define CP_SYMBOL
Definition: winnls.h:234
#define CP_MACCP
Definition: winnls.h:232
__wchar_t WCHAR
Definition: xmlstorage.h:180