Something went wrong. Try again.
Reactos
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635/* * WINE RTF file reader * * Portions Copyright 2004 Mike McCormack for CodeWeavers * Portions Copyright 2006 by Phil Krylov * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
/* * Derived from RTF Tools by Paul DuBois (dubois@primate.wisc.edu) * Homepage: http://www.snake.net/software/RTF/ * Original license follows: */
/* * reader.c - RTF file reader. Release 1.10. * * .... * * Author: Paul DuBois dubois@primate.wisc.edu * * This software may be redistributed without restriction and used for * any purpose whatsoever. */
#include <stdio.h>#include <ctype.h>#include <string.h>#include <stdarg.h>#include <stdlib.h>#include <assert.h>
#include "windef.h"#include "winbase.h"#include "wine/debug.h"
#include "editor.h"#include "rtf.h"
WINE_DEFAULT_DEBUG_CHANNEL(richedit);
static int _RTFGetChar(RTF_Info *);static void _RTFGetToken (RTF_Info *);static void _RTFGetToken2 (RTF_Info *);static int GetChar (RTF_Info *);static void ReadFontTbl (RTF_Info *);static void ReadColorTbl (RTF_Info *);static void ReadStyleSheet (RTF_Info *);static void ReadInfoGroup (RTF_Info *);static void ReadPictGroup (RTF_Info *);static void ReadObjGroup (RTF_Info *);static void Lookup (RTF_Info *, char *);static int Hash (const char *);
static void CharAttr(RTF_Info *info);static void CharSet(RTF_Info *info);static void DocAttr(RTF_Info *info);
static void RTFFlushCPOutputBuffer(RTF_Info *info);static void RTFPutCodePageChar(RTF_Info *info, int c);
/* ---------------------------------------------------------------------- */
int _RTFGetChar(RTF_Info *info){ int ch; ME_InStream *stream = info->stream;
if (stream->dwSize <= stream->dwUsed) { ME_StreamInFill(stream); /* if error, it's EOF */ if (stream->editstream->dwError) return EOF; /* if no bytes read, it's EOF */ if (stream->dwSize == 0) return EOF; } ch = (unsigned char)stream->buffer[stream->dwUsed++]; if (!ch) return ' '; return ch;}
void RTFSetEditStream(RTF_Info *info, ME_InStream *stream){ info->stream = stream;}
static voidRTFDestroyAttrs(RTF_Info *info){ RTFColor *cp; RTFFont *fp; RTFStyle *sp; RTFStyleElt *eltList, *ep;
while (info->fontList) { fp = info->fontList->rtfNextFont; free (info->fontList->rtfFName); free (info->fontList); info->fontList = fp; } while (info->colorList) { cp = info->colorList->rtfNextColor; free (info->colorList); info->colorList = cp; } while (info->styleList) { sp = info->styleList->rtfNextStyle; eltList = info->styleList->rtfSSEList; while (eltList) { ep = eltList->rtfNextSE; free (eltList->rtfSEText); free (eltList); eltList = ep; } free (info->styleList->rtfSName); free (info->styleList); info->styleList = sp; }}
voidRTFDestroy(RTF_Info *info){ if (info->rtfTextBuf) { free(info->rtfTextBuf); free(info->pushedTextBuf); } RTFDestroyAttrs(info); free(info->cpOutputBuffer); while (info->tableDef) { RTFTable *tableDef = info->tableDef; info->tableDef = tableDef->parent; free(tableDef); }}
/* ---------------------------------------------------------------------- */
/* * Callback table manipulation routines */
/* * Install or return a writer callback for a token class */
static void RTFSetClassCallback(RTF_Info *info, int class, RTFFuncPtr callback){ if (class >= 0 && class < rtfMaxClass) info->ccb[class] = callback;}
static RTFFuncPtr RTFGetClassCallback(const RTF_Info *info, int class){ if (class >= 0 && class < rtfMaxClass) return info->ccb[class]; return NULL;}
/* * Initialize the reader. This may be called multiple times, * to read multiple files. The only thing not reset is the input * stream; that must be done with RTFSetStream(). */
void RTFInit(RTF_Info *info){ int i;
if (info->rtfTextBuf == NULL) /* initialize the text buffers */ { info->rtfTextBuf = malloc (rtfBufSiz); info->pushedTextBuf = malloc (rtfBufSiz); if (info->rtfTextBuf == NULL || info->pushedTextBuf == NULL) { ERR ("Cannot allocate text buffers.\n"); return; } info->rtfTextBuf[0] = info->pushedTextBuf[0] = '\0'; }
for (i = 0; i < rtfMaxClass; i++) RTFSetClassCallback (info, i, NULL); for (i = 0; i < rtfMaxDestination; i++) RTFSetDestinationCallback (info, i, NULL);
/* install built-in destination readers */ RTFSetDestinationCallback (info, rtfFontTbl, ReadFontTbl); RTFSetDestinationCallback (info, rtfColorTbl, ReadColorTbl); RTFSetDestinationCallback (info, rtfStyleSheet, ReadStyleSheet); RTFSetDestinationCallback (info, rtfInfo, ReadInfoGroup); RTFSetDestinationCallback (info, rtfPict, ReadPictGroup); RTFSetDestinationCallback (info, rtfObject, ReadObjGroup);
RTFSetReadHook (info, NULL);
/* dump old lists if necessary */
RTFDestroyAttrs(info);
info->ansiCodePage = 1252; /* Latin-1; actually unused */ info->unicodeLength = 1; /* \uc1 is the default */ info->codePage = info->ansiCodePage; info->defFont = 0;
info->rtfClass = -1; info->pushedClass = -1; info->pushedChar = EOF;
info->rtfLineNum = 0; info->rtfLinePos = 0; info->prevChar = EOF; info->bumpLine = FALSE;
info->dwCPOutputCount = 0; if (!info->cpOutputBuffer) { info->dwMaxCPOutputCount = 0x1000; info->cpOutputBuffer = malloc (info->dwMaxCPOutputCount); }
info->tableDef = NULL; info->nestingLevel = 0; info->canInheritInTbl = FALSE; info->borderType = 0;
memset(&info->fmt, 0, sizeof(info->fmt)); info->fmt.cbSize = sizeof(info->fmt);}
/* * Install or return a writer callback for a destination type */
void RTFSetDestinationCallback(RTF_Info *info, int dest, RTFFuncPtr callback){ if (dest >= 0 && dest < rtfMaxDestination) info->dcb[dest] = callback;}
static RTFFuncPtr RTFGetDestinationCallback(const RTF_Info *info, int dest){ if (dest >= 0 && dest < rtfMaxDestination) return info->dcb[dest]; return NULL;}
/* ---------------------------------------------------------------------- */
/* * Token reading routines */
/* * Read the input stream, invoking the writer's callbacks * where appropriate. */
void RTFRead(RTF_Info *info){ while (RTFGetToken (info) != rtfEOF) RTFRouteToken (info);}
/* * Route a token. If it's a destination for which a reader is * installed, process the destination internally, otherwise * pass the token to the writer's class callback. */
void RTFRouteToken(RTF_Info *info){ RTFFuncPtr p;
if (info->rtfClass < 0 || info->rtfClass >= rtfMaxClass) /* watchdog */ { ERR( "Unknown class %d: %s (reader malfunction)\n", info->rtfClass, info->rtfTextBuf); } if (RTFCheckCM (info, rtfControl, rtfDestination)) { /* invoke destination-specific callback if there is one */ p = RTFGetDestinationCallback (info, info->rtfMinor); if (p != NULL) { (*p) (info); return; } } /* invoke class callback if there is one */ p = RTFGetClassCallback (info, info->rtfClass); if (p != NULL) (*p) (info);}
/* * Skip to the end of the current group. When this returns, * writers that maintain a state stack may want to call their * state unstacker; global vars will still be set to the group's * closing brace. */
void RTFSkipGroup(RTF_Info *info){ int level = 1;
while (RTFGetToken (info) != rtfEOF) { if (info->rtfClass == rtfGroup) { if (info->rtfMajor == rtfBeginGroup) ++level; else if (info->rtfMajor == rtfEndGroup) { if (--level < 1) break; /* end of initial group */ } } }}
/* * Do no special processing on the group. * * This acts as a placeholder for a callback in order to indicate that it * shouldn't be ignored. Instead it will fallback on the loop in RTFRead. */void RTFReadGroup (RTF_Info *info){}
/* * Install or return a token reader hook. */
void RTFSetReadHook(RTF_Info *info, RTFFuncPtr f){ info->readHook = f;}
static RTFFuncPtr RTFGetReadHook(const RTF_Info *info){ return (info->readHook);}
/* * Read one token. Call the read hook if there is one. The * token class is the return value. Returns rtfEOF when there * are no more tokens. */
int RTFGetToken(RTF_Info *info){ RTFFuncPtr p;
/* don't try to return anything once EOF is reached */ if (info->rtfClass == rtfEOF) { return rtfEOF; }
for (;;) { _RTFGetToken (info); p = RTFGetReadHook (info); if (p != NULL) (*p) (info); /* give read hook a look at token */
/* Silently discard newlines, carriage returns, nulls. */ if (!(info->rtfClass == rtfText && info->rtfFormat != SF_TEXT && (info->rtfMajor == '\r' || info->rtfMajor == '\n' || info->rtfMajor == '\0'))) break; } return (info->rtfClass);}
static void RTFUngetToken(RTF_Info *info){ if (info->pushedClass >= 0) /* there's already an ungotten token */ ERR ("cannot unget two tokens\n"); if (info->rtfClass < 0) ERR ("no token to unget\n"); info->pushedClass = info->rtfClass; info->pushedMajor = info->rtfMajor; info->pushedMinor = info->rtfMinor; info->pushedParam = info->rtfParam; lstrcpyA (info->pushedTextBuf, info->rtfTextBuf); /* The read hook decrements stackTop on rtfEndGroup, so * increment the value to compensate for it being decremented * twice due to the RTFUngetToken. */ if(RTFCheckCM (info, rtfGroup, rtfEndGroup)) { info->stack[info->stackTop].style = info->style; ME_AddRefStyle(info->style); info->stackTop++; }}
static void _RTFGetToken(RTF_Info *info){ if (info->rtfFormat == SF_TEXT) { info->rtfMajor = GetChar (info); info->rtfMinor = 0; info->rtfParam = rtfNoParam; info->rtfTextBuf[info->rtfTextLen = 0] = '\0'; if (info->rtfMajor == EOF) info->rtfClass = rtfEOF; else info->rtfClass = rtfText; return; }
/* first check for pushed token from RTFUngetToken() */
if (info->pushedClass >= 0) { info->rtfClass = info->pushedClass; info->rtfMajor = info->pushedMajor; info->rtfMinor = info->pushedMinor; info->rtfParam = info->pushedParam; lstrcpyA (info->rtfTextBuf, info->pushedTextBuf); info->rtfTextLen = lstrlenA(info->rtfTextBuf); info->pushedClass = -1; return; }
/* * Beyond this point, no token is ever seen twice, which is * important, e.g., for making sure no "}" pops the font stack twice. */
_RTFGetToken2 (info);}
intRTFCharSetToCodePage(RTF_Info *info, int charset){ switch (charset) { case ANSI_CHARSET: return 1252; case DEFAULT_CHARSET: return CP_ACP; case SYMBOL_CHARSET: return CP_SYMBOL; case MAC_CHARSET: return CP_MACCP; case SHIFTJIS_CHARSET: return 932; case HANGEUL_CHARSET: return 949; case JOHAB_CHARSET: return 1361; case GB2312_CHARSET: return 936; case CHINESEBIG5_CHARSET: return 950; case GREEK_CHARSET: return 1253; case TURKISH_CHARSET: return 1254; case VIETNAMESE_CHARSET: return 1258; case HEBREW_CHARSET: return 1255; case ARABIC_CHARSET: return 1256; case BALTIC_CHARSET: return 1257; case RUSSIAN_CHARSET: return 1251; case THAI_CHARSET: return 874; case EASTEUROPE_CHARSET: return 1250; case OEM_CHARSET: return CP_OEMCP; default: { CHARSETINFO csi; DWORD n = charset;
/* FIXME: TranslateCharsetInfo does not work as good as it * should, so let's use it only when all else fails */ if (!TranslateCharsetInfo(&n, &csi, TCI_SRCCHARSET)) ERR("unknown charset %d\n", charset); else return csi.ciACP; } } return 0;}
/* this shouldn't be called anywhere but from _RTFGetToken() */
static void _RTFGetToken2(RTF_Info *info){ int sign; int c;
/* initialize token vars */
info->rtfClass = rtfUnknown; info->rtfParam = rtfNoParam; info->rtfTextBuf[info->rtfTextLen = 0] = '\0';
/* get first character, which may be a pushback from previous token */
if (info->pushedChar != EOF) { c = info->pushedChar; info->rtfTextBuf[info->rtfTextLen++] = c; info->rtfTextBuf[info->rtfTextLen] = '\0'; info->pushedChar = EOF; } else if ((c = GetChar (info)) == EOF) { info->rtfClass = rtfEOF; return; }
if (c == '{') { info->rtfClass = rtfGroup; info->rtfMajor = rtfBeginGroup; return; } if (c == '}') { info->rtfClass = rtfGroup; info->rtfMajor = rtfEndGroup; return; } if (c != '\\') { /* * Two possibilities here: * 1) ASCII 9, effectively like \tab control symbol * 2) literal text char */ if (c == '\t') /* ASCII 9 */ { info->rtfClass = rtfControl; info->rtfMajor = rtfSpecialChar; info->rtfMinor = rtfTab; } else { info->rtfClass = rtfText; info->rtfMajor = c; } return; } if ((c = GetChar (info)) == EOF) { /* early eof, whoops (class is rtfUnknown) */ return; } if (!isalpha (c)) { /* * Three possibilities here: * 1) hex encoded text char, e.g., \'d5, \'d3 * 2) special escaped text char, e.g., \{, \} * 3) control symbol, e.g., \_, \-, \|, \<10> */ if (c == '\'') /* hex char */ { int c2;
if ((c = GetChar (info)) != EOF && (c2 = GetChar (info)) != EOF && isxdigit(c) && isxdigit(c2)) { info->rtfClass = rtfText; info->rtfMajor = RTFCharToHex (c) * 16 + RTFCharToHex (c2); return; } /* early eof, whoops */ info->rtfClass = rtfEOF; info->stream->editstream->dwError = -14; return; }
/* escaped char */ /*if (index (":{}\\", c) != NULL)*/ /* escaped char */ if (c == ':' || c == '{' || c == '}' || c == '\\') { info->rtfClass = rtfText; info->rtfMajor = c; return; }
/* control symbol */ Lookup (info, info->rtfTextBuf); /* sets class, major, minor */ return; } /* control word */ while (isalpha (c)) { if ((c = GetChar (info)) == EOF) break; }
/* * At this point, the control word is all collected, so the * major/minor numbers are determined before the parameter * (if any) is scanned. There will be one too many characters * in the buffer, though, so fix up before and restore after * looking up. */
if (c != EOF) info->rtfTextBuf[info->rtfTextLen-1] = '\0'; Lookup (info, info->rtfTextBuf); /* sets class, major, minor */ if (c != EOF) info->rtfTextBuf[info->rtfTextLen-1] = c;
/* * Should be looking at first digit of parameter if there * is one, unless it's negative. In that case, next char * is '-', so need to gobble next char, and remember sign. */
sign = 1; if (c == '-') { sign = -1; c = GetChar (info); } if (c != EOF && isdigit (c)) { info->rtfParam = 0; while (isdigit (c)) /* gobble parameter */ { info->rtfParam = info->rtfParam * 10 + c - '0'; if ((c = GetChar (info)) == EOF) break; } info->rtfParam *= sign; } /* * If control symbol delimiter was a blank, gobble it. * Otherwise the character is first char of next token, so * push it back for next call. In either case, delete the * delimiter from the token buffer. */ if (c != EOF) { if (c != ' ') info->pushedChar = c; info->rtfTextBuf[--info->rtfTextLen] = '\0'; }}
/* * Read the next character from the input. This handles setting the * current line and position-within-line variables. Those variables are * set correctly whether lines end with CR, LF, or CRLF (the last being * the tricky case). * * bumpLine indicates whether the line number should be incremented on * the *next* input character. */
static int GetChar(RTF_Info *info){ int c; BOOL oldBumpLine;
if ((c = _RTFGetChar(info)) != EOF) { info->rtfTextBuf[info->rtfTextLen++] = c; info->rtfTextBuf[info->rtfTextLen] = '\0'; } if (info->prevChar == EOF) info->bumpLine = TRUE; oldBumpLine = info->bumpLine; /* TRUE if prev char was line ending */ info->bumpLine = FALSE; if (c == '\r') info->bumpLine = TRUE; else if (c == '\n') { info->bumpLine = TRUE; if (info->prevChar == '\r') /* oops, previous \r wasn't */ oldBumpLine = FALSE; /* really a line ending */ } ++info->rtfLinePos; if (oldBumpLine) /* were we supposed to increment the */ { /* line count on this char? */ ++info->rtfLineNum; info->rtfLinePos = 1; } info->prevChar = c; return (c);}
/* ---------------------------------------------------------------------- */
/* * Special destination readers. They gobble the destination so the * writer doesn't have to deal with them. That's wrong for any * translator that wants to process any of these itself. In that * case, these readers should be overridden by installing a different * destination callback. * * NOTE: The last token read by each of these reader will be the * destination's terminating '}', which will then be the current token. * That '}' token is passed to RTFRouteToken() - the writer has already * seen the '{' that began the destination group, and may have pushed a * state; it also needs to know at the end of the group that a state * should be popped. * * It's important that rtf.h and the control token lookup table list * as many symbols as possible, because these destination readers * unfortunately make strict assumptions about the input they expect, * and a token of class rtfUnknown will throw them off easily. */
/* * Read { \fonttbl ... } destination. Old font tables don't have * braces around each table entry; try to adjust for that. */
static void ReadFontTbl(RTF_Info *info){ RTFFont *fp = NULL; char buf[rtfBufSiz], *bp; int old = -1;
for (;;) { RTFGetToken (info); if (info->rtfClass == rtfEOF) break; if (RTFCheckCM (info, rtfGroup, rtfEndGroup)) break; if (old < 0) /* first entry - determine tbl type */ { if (RTFCheckCMM (info, rtfControl, rtfCharAttr, rtfFontNum)) old = 1; /* no brace */ else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup)) old = 0; /* brace */ else /* can't tell! */ ERR ("cannot determine format\n"); } if (old == 0) /* need to find "{" here */ { if (!RTFCheckCM (info, rtfGroup, rtfBeginGroup)) ERR ("missing \"{\"\n"); RTFGetToken (info); /* yes, skip to next token */ if (info->rtfClass == rtfEOF) break; } fp = malloc (sizeof(*fp)); if (fp == NULL) { ERR ("cannot allocate font entry\n"); break; }
fp->rtfNextFont = info->fontList; info->fontList = fp;
fp->rtfFName = NULL; fp->rtfFAltName = NULL; fp->rtfFNum = -1; fp->rtfFFamily = FF_DONTCARE; fp->rtfFCharSet = DEFAULT_CHARSET; /* 1 */ fp->rtfFPitch = DEFAULT_PITCH; fp->rtfFType = 0; fp->rtfFCodePage = CP_ACP;
while (info->rtfClass != rtfEOF && !RTFCheckCM (info, rtfText, ';') && !RTFCheckCM (info, rtfGroup, rtfEndGroup)) { if (info->rtfClass == rtfControl) { switch (info->rtfMajor) { default: /* ignore token but announce it */ WARN ("unknown token \"%s\"\n", info->rtfTextBuf); break; case rtfFontFamily: fp->rtfFFamily = info->rtfMinor; break; case rtfCharAttr: switch (info->rtfMinor) { default: break; /* ignore unknown? */ case rtfFontNum: fp->rtfFNum = info->rtfParam; break; } break; case rtfFontAttr: switch (info->rtfMinor) { default: break; /* ignore unknown? */ case rtfFontCharSet: fp->rtfFCharSet = info->rtfParam; if (!fp->rtfFCodePage) fp->rtfFCodePage = RTFCharSetToCodePage(info, info->rtfParam); break; case rtfFontPitch: fp->rtfFPitch = info->rtfParam; break; case rtfFontCodePage: fp->rtfFCodePage = info->rtfParam; break; case rtfFTypeNil: case rtfFTypeTrueType: fp->rtfFType = info->rtfParam; break; } break; } } else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup)) /* dest */ { RTFSkipGroup (info); /* ignore for now */ } else if (info->rtfClass == rtfText) /* font name */ { bp = buf; while (info->rtfClass == rtfText && !RTFCheckCM (info, rtfText, ';')) { *bp++ = info->rtfMajor; RTFGetToken (info); }
/* FIX: in some cases the <fontinfo> isn't finished with a semi-column */ if(RTFCheckCM (info, rtfGroup, rtfEndGroup)) { RTFUngetToken (info); } *bp = '\0'; fp->rtfFName = strdup (buf); if (fp->rtfFName == NULL) ERR ("cannot allocate font name\n"); /* already have next token; don't read one */ /* at bottom of loop */ continue; } else { /* ignore token but announce it */ WARN ("unknown token \"%s\"\n", info->rtfTextBuf); } RTFGetToken (info); if (info->rtfClass == rtfEOF) break; } if (info->rtfClass == rtfEOF) break; if (old == 0) /* need to see "}" here */ { RTFGetToken (info); if (!RTFCheckCM (info, rtfGroup, rtfEndGroup)) ERR ("missing \"}\"\n"); if (info->rtfClass == rtfEOF) break; }
/* Apply the real properties of the default font */ if (fp->rtfFNum == info->defFont) { if (info->ansiCodePage != CP_UTF8) info->codePage = fp->rtfFCodePage; TRACE("default font codepage %d\n", info->codePage); } } if (!fp || (fp->rtfFNum == -1)) ERR("missing font number\n");/* * Could check other pieces of structure here, too, I suppose. */ RTFRouteToken (info); /* feed "}" back to router */
/* Set default font */ info->rtfClass = rtfControl; info->rtfMajor = rtfCharAttr; info->rtfMinor = rtfFontNum; info->rtfParam = info->defFont; lstrcpyA(info->rtfTextBuf, "f"); RTFUngetToken(info);}
/* * The color table entries have color values of -1 if * the default color should be used for the entry (only * a semi-colon is given in the definition, no color values). * There will be a problem if a partial entry (1 or 2 but * not 3 color values) is given. The possibility is ignored * here. */
static void ReadColorTbl(RTF_Info *info){ RTFColor *cp; int cnum = 0; int group_level = 1;
for (;;) { RTFGetToken (info); if (info->rtfClass == rtfEOF) break; if (RTFCheckCM (info, rtfGroup, rtfEndGroup)) { group_level--; if (!group_level) break; continue; } else if (RTFCheckCM(info, rtfGroup, rtfBeginGroup)) { group_level++; continue; }
cp = malloc (sizeof(*cp)); if (cp == NULL) { ERR ("cannot allocate color entry\n"); break; } cp->rtfCNum = cnum++; cp->rtfNextColor = info->colorList; info->colorList = cp; if (!RTFCheckCM (info, rtfControl, rtfColorName)) cp->rtfCRed = cp->rtfCGreen = cp->rtfCBlue = -1; else { cp->rtfCRed = cp->rtfCGreen = cp->rtfCBlue = 0; do { switch (info->rtfMinor) { case rtfRed: cp->rtfCRed = info->rtfParam & 0xFF; break; case rtfGreen: cp->rtfCGreen = info->rtfParam & 0xFF; break; case rtfBlue: cp->rtfCBlue = info->rtfParam & 0xFF; break; } RTFGetToken (info); } while (RTFCheckCM (info, rtfControl, rtfColorName)); } if (info->rtfClass == rtfEOF) break; if (!RTFCheckCM (info, rtfText, ';')) ERR ("malformed entry\n"); } RTFRouteToken (info); /* feed "}" back to router */}
/* * The "Normal" style definition doesn't contain any style number, * all others do. Normal style is given style rtfNormalStyleNum. */
static void ReadStyleSheet(RTF_Info *info){ RTFStyle *sp; RTFStyleElt *sep, *sepLast; char buf[rtfBufSiz], *bp; int real_style;
for (;;) { RTFGetToken (info); if (info->rtfClass == rtfEOF) break; if (RTFCheckCM (info, rtfGroup, rtfEndGroup)) break; sp = malloc (sizeof(*sp)); if (sp == NULL) { ERR ("cannot allocate stylesheet entry\n"); break; } sp->rtfSName = NULL; sp->rtfSNum = -1; sp->rtfSType = rtfParStyle; sp->rtfSAdditive = 0; sp->rtfSBasedOn = rtfNoStyleNum; sp->rtfSNextPar = -1; sp->rtfSSEList = sepLast = NULL; sp->rtfNextStyle = info->styleList; sp->rtfExpanding = 0; info->styleList = sp; if (!RTFCheckCM (info, rtfGroup, rtfBeginGroup)) ERR ("missing \"{\"\n"); real_style = TRUE; for (;;) { RTFGetToken (info); if (info->rtfClass == rtfEOF || RTFCheckCM (info, rtfText, ';')) break; if (info->rtfClass == rtfControl) { if (RTFCheckMM (info, rtfSpecialChar, rtfOptDest)) { RTFGetToken(info); ERR("skipping optional destination\n"); RTFSkipGroup(info); info->rtfClass = rtfGroup; info->rtfMajor = rtfEndGroup; real_style = FALSE; break; /* ignore "\*" */ } if (RTFCheckMM (info, rtfParAttr, rtfStyleNum)) { sp->rtfSNum = info->rtfParam; sp->rtfSType = rtfParStyle; continue; } if (RTFCheckMM (info, rtfCharAttr, rtfCharStyleNum)) { sp->rtfSNum = info->rtfParam; sp->rtfSType = rtfCharStyle; continue; } if (RTFCheckMM (info, rtfSectAttr, rtfSectStyleNum)) { sp->rtfSNum = info->rtfParam; sp->rtfSType = rtfSectStyle; continue; } if (RTFCheckMM (info, rtfStyleAttr, rtfBasedOn)) { sp->rtfSBasedOn = info->rtfParam; continue; } if (RTFCheckMM (info, rtfStyleAttr, rtfAdditive)) { sp->rtfSAdditive = 1; continue; } if (RTFCheckMM (info, rtfStyleAttr, rtfNext)) { sp->rtfSNextPar = info->rtfParam; continue; } sep = malloc (sizeof(*sep)); if (sep == NULL) { ERR ("cannot allocate style element\n"); break; } sep->rtfSEClass = info->rtfClass; sep->rtfSEMajor = info->rtfMajor; sep->rtfSEMinor = info->rtfMinor; sep->rtfSEParam = info->rtfParam; sep->rtfSEText = strdup (info->rtfTextBuf); if (sep->rtfSEText == NULL) ERR ("cannot allocate style element text\n"); if (sepLast == NULL) sp->rtfSSEList = sep; /* first element */ else /* add to end */ sepLast->rtfNextSE = sep; sep->rtfNextSE = NULL; sepLast = sep; } else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup)) { /* * This passes over "{\*\keycode ... }, among * other things. A temporary (perhaps) hack. */ ERR("skipping begin\n"); RTFSkipGroup (info); continue; } else if (info->rtfClass == rtfText) /* style name */ { bp = buf; while (info->rtfClass == rtfText) { if (info->rtfMajor == ';') { /* put back for "for" loop */ RTFUngetToken (info); break; } *bp++ = info->rtfMajor; RTFGetToken (info); } *bp = '\0'; sp->rtfSName = strdup (buf); if (sp->rtfSName == NULL) ERR ("cannot allocate style name\n"); } else /* unrecognized */ { /* ignore token but announce it */ WARN ("unknown token \"%s\"\n", info->rtfTextBuf); } } if (real_style) { RTFGetToken (info); if (!RTFCheckCM (info, rtfGroup, rtfEndGroup)) ERR ("missing \"}\"\n"); /* * Check over the style structure. A name is a must. * If no style number was specified, check whether it's the * Normal style (in which case it's given style number * rtfNormalStyleNum). Note that some "normal" style names * just begin with "Normal" and can have other stuff following, * e.g., "Normal,Times 10 point". Ugh. * * Some German RTF writers use "Standard" instead of "Normal". */ if (sp->rtfSName == NULL) ERR ("missing style name\n"); if (sp->rtfSNum < 0) { if (strncmp (buf, "Normal", 6) != 0 && strncmp (buf, "Standard", 8) != 0) ERR ("missing style number\n"); sp->rtfSNum = rtfNormalStyleNum; } if (sp->rtfSNextPar == -1) /* if \snext not given, */ sp->rtfSNextPar = sp->rtfSNum; /* next is itself */ } /* otherwise we're just dealing with fake end group from skipped group */ } RTFRouteToken (info); /* feed "}" back to router */}
static void ReadInfoGroup(RTF_Info *info){ RTFSkipGroup (info); RTFRouteToken (info); /* feed "}" back to router */}
static void ReadPictGroup(RTF_Info *info){ RTFSkipGroup (info); RTFRouteToken (info); /* feed "}" back to router */}
static void ReadObjGroup(RTF_Info *info){ RTFSkipGroup (info); RTFRouteToken (info); /* feed "}" back to router */}
/* ---------------------------------------------------------------------- */
/* * Routines to return pieces of stylesheet, or font or color tables. * References to style 0 are mapped onto the Normal style. */
RTFFont *RTFGetFont(const RTF_Info *info, int num){ RTFFont *f;
if (num == -1) return (info->fontList); for (f = info->fontList; f != NULL; f = f->rtfNextFont) { if (f->rtfFNum == num) break; } return (f); /* NULL if not found */}
RTFColor *RTFGetColor(const RTF_Info *info, int num){ RTFColor *c;
if (num == -1) return (info->colorList); for (c = info->colorList; c != NULL; c = c->rtfNextColor) { if (c->rtfCNum == num) break; } return (c); /* NULL if not found */}
/* ---------------------------------------------------------------------- */
/* * Control symbol lookup routines */
typedef struct RTFKey RTFKey;
struct RTFKey{ int rtfKMajor; /* major number */ int rtfKMinor; /* minor number */ const char *rtfKStr; /* symbol name */ int rtfKHash; /* symbol name hash value */};
/* * A minor number of -1 means the token has no minor number * (all valid minor numbers are >= 0). */
static RTFKey rtfKey[] ={ /* * Special characters */
{ rtfSpecialChar, rtfIIntVersion, "vern", 0 }, { rtfSpecialChar, rtfICreateTime, "creatim", 0 }, { rtfSpecialChar, rtfIRevisionTime, "revtim", 0 }, { rtfSpecialChar, rtfIPrintTime, "printim", 0 }, { rtfSpecialChar, rtfIBackupTime, "buptim", 0 }, { rtfSpecialChar, rtfIEditTime, "edmins", 0 }, { rtfSpecialChar, rtfIYear, "yr", 0 }, { rtfSpecialChar, rtfIMonth, "mo", 0 }, { rtfSpecialChar, rtfIDay, "dy", 0 }, { rtfSpecialChar, rtfIHour, "hr", 0 }, { rtfSpecialChar, rtfIMinute, "min", 0 }, { rtfSpecialChar, rtfISecond, "sec", 0 }, { rtfSpecialChar, rtfINPages, "nofpages", 0 }, { rtfSpecialChar, rtfINWords, "nofwords", 0 }, { rtfSpecialChar, rtfINChars, "nofchars", 0 }, { rtfSpecialChar, rtfIIntID, "id", 0 },
{ rtfSpecialChar, rtfCurHeadDate, "chdate", 0 }, { rtfSpecialChar, rtfCurHeadDateLong, "chdpl", 0 }, { rtfSpecialChar, rtfCurHeadDateAbbrev, "chdpa", 0 }, { rtfSpecialChar, rtfCurHeadTime, "chtime", 0 }, { rtfSpecialChar, rtfCurHeadPage, "chpgn", 0 }, { rtfSpecialChar, rtfSectNum, "sectnum", 0 }, { rtfSpecialChar, rtfCurFNote, "chftn", 0 }, { rtfSpecialChar, rtfCurAnnotRef, "chatn", 0 }, { rtfSpecialChar, rtfFNoteSep, "chftnsep", 0 }, { rtfSpecialChar, rtfFNoteCont, "chftnsepc", 0 }, { rtfSpecialChar, rtfCell, "cell", 0 }, { rtfSpecialChar, rtfRow, "row", 0 }, { rtfSpecialChar, rtfPar, "par", 0 }, /* newline and carriage return are synonyms for */ /* \par when they are preceded by a \ character */ { rtfSpecialChar, rtfPar, "\n", 0 }, { rtfSpecialChar, rtfPar, "\r", 0 }, { rtfSpecialChar, rtfSect, "sect", 0 }, { rtfSpecialChar, rtfPage, "page", 0 }, { rtfSpecialChar, rtfColumn, "column", 0 }, { rtfSpecialChar, rtfLine, "line", 0 }, { rtfSpecialChar, rtfSoftPage, "softpage", 0 }, { rtfSpecialChar, rtfSoftColumn, "softcol", 0 }, { rtfSpecialChar, rtfSoftLine, "softline", 0 }, { rtfSpecialChar, rtfSoftLineHt, "softlheight", 0 }, { rtfSpecialChar, rtfTab, "tab", 0 }, { rtfSpecialChar, rtfEmDash, "emdash", 0 }, { rtfSpecialChar, rtfEnDash, "endash", 0 }, { rtfSpecialChar, rtfEmSpace, "emspace", 0 }, { rtfSpecialChar, rtfEnSpace, "enspace", 0 }, { rtfSpecialChar, rtfBullet, "bullet", 0 }, { rtfSpecialChar, rtfLQuote, "lquote", 0 }, { rtfSpecialChar, rtfRQuote, "rquote", 0 }, { rtfSpecialChar, rtfLDblQuote, "ldblquote", 0 }, { rtfSpecialChar, rtfRDblQuote, "rdblquote", 0 }, { rtfSpecialChar, rtfFormula, "|", 0 }, { rtfSpecialChar, rtfNoBrkSpace, "~", 0 }, { rtfSpecialChar, rtfNoReqHyphen, "-", 0 }, { rtfSpecialChar, rtfNoBrkHyphen, "_", 0 }, { rtfSpecialChar, rtfOptDest, "*", 0 }, { rtfSpecialChar, rtfLTRMark, "ltrmark", 0 }, { rtfSpecialChar, rtfRTLMark, "rtlmark", 0 }, { rtfSpecialChar, rtfNoWidthJoiner, "zwj", 0 }, { rtfSpecialChar, rtfNoWidthNonJoiner, "zwnj", 0 }, /* is this valid? */ { rtfSpecialChar, rtfCurHeadPict, "chpict", 0 }, { rtfSpecialChar, rtfUnicode, "u", 0 }, { rtfSpecialChar, rtfNestCell, "nestcell", 0 }, { rtfSpecialChar, rtfNestRow, "nestrow", 0 },
/* * Character formatting attributes */
{ rtfCharAttr, rtfPlain, "plain", 0 }, { rtfCharAttr, rtfBold, "b", 0 }, { rtfCharAttr, rtfAllCaps, "caps", 0 }, { rtfCharAttr, rtfDeleted, "deleted", 0 }, { rtfCharAttr, rtfSubScript, "dn", 0 }, { rtfCharAttr, rtfSubScrShrink, "sub", 0 }, { rtfCharAttr, rtfNoSuperSub, "nosupersub", 0 }, { rtfCharAttr, rtfExpand, "expnd", 0 }, { rtfCharAttr, rtfExpandTwips, "expndtw", 0 }, { rtfCharAttr, rtfKerning, "kerning", 0 }, { rtfCharAttr, rtfFontNum, "f", 0 }, { rtfCharAttr, rtfFontSize, "fs", 0 }, { rtfCharAttr, rtfItalic, "i", 0 }, { rtfCharAttr, rtfOutline, "outl", 0 }, { rtfCharAttr, rtfRevised, "revised", 0 }, { rtfCharAttr, rtfRevAuthor, "revauth", 0 }, { rtfCharAttr, rtfRevDTTM, "revdttm", 0 }, { rtfCharAttr, rtfSmallCaps, "scaps", 0 }, { rtfCharAttr, rtfShadow, "shad", 0 }, { rtfCharAttr, rtfStrikeThru, "strike", 0 }, { rtfCharAttr, rtfUnderline, "ul", 0 }, { rtfCharAttr, rtfDotUnderline, "uld", 0 }, { rtfCharAttr, rtfDbUnderline, "uldb", 0 }, { rtfCharAttr, rtfNoUnderline, "ulnone", 0 }, { rtfCharAttr, rtfWordUnderline, "ulw", 0 }, { rtfCharAttr, rtfSuperScript, "up", 0 }, { rtfCharAttr, rtfSuperScrShrink, "super", 0 }, { rtfCharAttr, rtfInvisible, "v", 0 }, { rtfCharAttr, rtfForeColor, "cf", 0 }, { rtfCharAttr, rtfBackColor, "highlight", 0 }, { rtfCharAttr, rtfRTLChar, "rtlch", 0 }, { rtfCharAttr, rtfLTRChar, "ltrch", 0 }, { rtfCharAttr, rtfCharStyleNum, "cs", 0 }, { rtfCharAttr, rtfCharCharSet, "cchs", 0 }, { rtfCharAttr, rtfLanguage, "lang", 0 }, /* this has disappeared from spec 1.2 */ { rtfCharAttr, rtfGray, "gray", 0 }, { rtfCharAttr, rtfUnicodeLength, "uc", 0 },
/* * Paragraph formatting attributes */
{ rtfParAttr, rtfParDef, "pard", 0 }, { rtfParAttr, rtfStyleNum, "s", 0 }, { rtfParAttr, rtfHyphenate, "hyphpar", 0 }, { rtfParAttr, rtfInTable, "intbl", 0 }, { rtfParAttr, rtfKeep, "keep", 0 }, { rtfParAttr, rtfNoWidowControl, "nowidctlpar", 0 }, { rtfParAttr, rtfKeepNext, "keepn", 0 }, { rtfParAttr, rtfOutlineLevel, "level", 0 }, { rtfParAttr, rtfNoLineNum, "noline", 0 }, { rtfParAttr, rtfPBBefore, "pagebb", 0 }, { rtfParAttr, rtfSideBySide, "sbys", 0 }, { rtfParAttr, rtfQuadLeft, "ql", 0 }, { rtfParAttr, rtfQuadRight, "qr", 0 }, { rtfParAttr, rtfQuadJust, "qj", 0 }, { rtfParAttr, rtfQuadCenter, "qc", 0 }, { rtfParAttr, rtfFirstIndent, "fi", 0 }, { rtfParAttr, rtfLeftIndent, "li", 0 }, { rtfParAttr, rtfRightIndent, "ri", 0 }, { rtfParAttr, rtfSpaceBefore, "sb", 0 }, { rtfParAttr, rtfSpaceAfter, "sa", 0 }, { rtfParAttr, rtfSpaceBetween, "sl", 0 }, { rtfParAttr, rtfSpaceMultiply, "slmult", 0 },
{ rtfParAttr, rtfSubDocument, "subdocument", 0 },
{ rtfParAttr, rtfRTLPar, "rtlpar", 0 }, { rtfParAttr, rtfLTRPar, "ltrpar", 0 },
{ rtfParAttr, rtfTabPos, "tx", 0 }, /* * FrameMaker writes \tql (to mean left-justified tab, apparently) * although it's not in the spec. It's also redundant, since lj * tabs are the default. */ { rtfParAttr, rtfTabLeft, "tql", 0 }, { rtfParAttr, rtfTabRight, "tqr", 0 }, { rtfParAttr, rtfTabCenter, "tqc", 0 }, { rtfParAttr, rtfTabDecimal, "tqdec", 0 }, { rtfParAttr, rtfTabBar, "tb", 0 }, { rtfParAttr, rtfLeaderDot, "tldot", 0 }, { rtfParAttr, rtfLeaderHyphen, "tlhyph", 0 }, { rtfParAttr, rtfLeaderUnder, "tlul", 0 }, { rtfParAttr, rtfLeaderThick, "tlth", 0 }, { rtfParAttr, rtfLeaderEqual, "tleq", 0 },
{ rtfParAttr, rtfParLevel, "pnlvl", 0 }, { rtfParAttr, rtfParBullet, "pnlvlblt", 0 }, { rtfParAttr, rtfParSimple, "pnlvlbody", 0 }, { rtfParAttr, rtfParNumCont, "pnlvlcont", 0 }, { rtfParAttr, rtfParNumOnce, "pnnumonce", 0 }, { rtfParAttr, rtfParNumAcross, "pnacross", 0 }, { rtfParAttr, rtfParHangIndent, "pnhang", 0 }, { rtfParAttr, rtfParNumRestart, "pnrestart", 0 }, { rtfParAttr, rtfParNumCardinal, "pncard", 0 }, { rtfParAttr, rtfParNumDecimal, "pndec", 0 }, { rtfParAttr, rtfParNumULetter, "pnucltr", 0 }, { rtfParAttr, rtfParNumURoman, "pnucrm", 0 }, { rtfParAttr, rtfParNumLLetter, "pnlcltr", 0 }, { rtfParAttr, rtfParNumLRoman, "pnlcrm", 0 }, { rtfParAttr, rtfParNumOrdinal, "pnord", 0 }, { rtfParAttr, rtfParNumOrdinalText, "pnordt", 0 }, { rtfParAttr, rtfParNumBold, "pnb", 0 }, { rtfParAttr, rtfParNumItalic, "pni", 0 }, { rtfParAttr, rtfParNumAllCaps, "pncaps", 0 }, { rtfParAttr, rtfParNumSmallCaps, "pnscaps", 0 }, { rtfParAttr, rtfParNumUnder, "pnul", 0 }, { rtfParAttr, rtfParNumDotUnder, "pnuld", 0 }, { rtfParAttr, rtfParNumDbUnder, "pnuldb", 0 }, { rtfParAttr, rtfParNumNoUnder, "pnulnone", 0 }, { rtfParAttr, rtfParNumWordUnder, "pnulw", 0 }, { rtfParAttr, rtfParNumStrikethru, "pnstrike", 0 }, { rtfParAttr, rtfParNumForeColor, "pncf", 0 }, { rtfParAttr, rtfParNumFont, "pnf", 0 }, { rtfParAttr, rtfParNumFontSize, "pnfs", 0 }, { rtfParAttr, rtfParNumIndent, "pnindent", 0 }, { rtfParAttr, rtfParNumSpacing, "pnsp", 0 }, { rtfParAttr, rtfParNumInclPrev, "pnprev", 0 }, { rtfParAttr, rtfParNumCenter, "pnqc", 0 }, { rtfParAttr, rtfParNumLeft, "pnql", 0 }, { rtfParAttr, rtfParNumRight, "pnqr", 0 }, { rtfParAttr, rtfParNumStartAt, "pnstart", 0 },
{ rtfParAttr, rtfBorderTop, "brdrt", 0 }, { rtfParAttr, rtfBorderBottom, "brdrb", 0 }, { rtfParAttr, rtfBorderLeft, "brdrl", 0 }, { rtfParAttr, rtfBorderRight, "brdrr", 0 }, { rtfParAttr, rtfBorderBetween, "brdrbtw", 0 }, { rtfParAttr, rtfBorderBar, "brdrbar", 0 }, { rtfParAttr, rtfBorderBox, "box", 0 }, { rtfParAttr, rtfBorderSingle, "brdrs", 0 }, { rtfParAttr, rtfBorderThick, "brdrth", 0 }, { rtfParAttr, rtfBorderShadow, "brdrsh", 0 }, { rtfParAttr, rtfBorderDouble, "brdrdb", 0 }, { rtfParAttr, rtfBorderDot, "brdrdot", 0 }, { rtfParAttr, rtfBorderDot, "brdrdash", 0 }, { rtfParAttr, rtfBorderHair, "brdrhair", 0 }, { rtfParAttr, rtfBorderWidth, "brdrw", 0 }, { rtfParAttr, rtfBorderColor, "brdrcf", 0 }, { rtfParAttr, rtfBorderSpace, "brsp", 0 },
{ rtfParAttr, rtfShading, "shading", 0 }, { rtfParAttr, rtfBgPatH, "bghoriz", 0 }, { rtfParAttr, rtfBgPatV, "bgvert", 0 }, { rtfParAttr, rtfFwdDiagBgPat, "bgfdiag", 0 }, { rtfParAttr, rtfBwdDiagBgPat, "bgbdiag", 0 }, { rtfParAttr, rtfHatchBgPat, "bgcross", 0 }, { rtfParAttr, rtfDiagHatchBgPat, "bgdcross", 0 }, { rtfParAttr, rtfDarkBgPatH, "bgdkhoriz", 0 }, { rtfParAttr, rtfDarkBgPatV, "bgdkvert", 0 }, { rtfParAttr, rtfFwdDarkBgPat, "bgdkfdiag", 0 }, { rtfParAttr, rtfBwdDarkBgPat, "bgdkbdiag", 0 }, { rtfParAttr, rtfDarkHatchBgPat, "bgdkcross", 0 }, { rtfParAttr, rtfDarkDiagHatchBgPat, "bgdkdcross", 0 }, { rtfParAttr, rtfBgPatLineColor, "cfpat", 0 }, { rtfParAttr, rtfBgPatColor, "cbpat", 0 }, { rtfParAttr, rtfNestLevel, "itap", 0 },
/* * Section formatting attributes */
{ rtfSectAttr, rtfSectDef, "sectd", 0 }, { rtfSectAttr, rtfENoteHere, "endnhere", 0 }, { rtfSectAttr, rtfPrtBinFirst, "binfsxn", 0 }, { rtfSectAttr, rtfPrtBin, "binsxn", 0 }, { rtfSectAttr, rtfSectStyleNum, "ds", 0 },
{ rtfSectAttr, rtfNoBreak, "sbknone", 0 }, { rtfSectAttr, rtfColBreak, "sbkcol", 0 }, { rtfSectAttr, rtfPageBreak, "sbkpage", 0 }, { rtfSectAttr, rtfEvenBreak, "sbkeven", 0 }, { rtfSectAttr, rtfOddBreak, "sbkodd", 0 },
{ rtfSectAttr, rtfColumns, "cols", 0 }, { rtfSectAttr, rtfColumnSpace, "colsx", 0 }, { rtfSectAttr, rtfColumnNumber, "colno", 0 }, { rtfSectAttr, rtfColumnSpRight, "colsr", 0 }, { rtfSectAttr, rtfColumnWidth, "colw", 0 }, { rtfSectAttr, rtfColumnLine, "linebetcol", 0 },
{ rtfSectAttr, rtfLineModulus, "linemod", 0 }, { rtfSectAttr, rtfLineDist, "linex", 0 }, { rtfSectAttr, rtfLineStarts, "linestarts", 0 }, { rtfSectAttr, rtfLineRestart, "linerestart", 0 }, { rtfSectAttr, rtfLineRestartPg, "lineppage", 0 }, { rtfSectAttr, rtfLineCont, "linecont", 0 },
{ rtfSectAttr, rtfSectPageWid, "pgwsxn", 0 }, { rtfSectAttr, rtfSectPageHt, "pghsxn", 0 }, { rtfSectAttr, rtfSectMarginLeft, "marglsxn", 0 }, { rtfSectAttr, rtfSectMarginRight, "margrsxn", 0 }, { rtfSectAttr, rtfSectMarginTop, "margtsxn", 0 }, { rtfSectAttr, rtfSectMarginBottom, "margbsxn", 0 }, { rtfSectAttr, rtfSectMarginGutter, "guttersxn", 0 }, { rtfSectAttr, rtfSectLandscape, "lndscpsxn", 0 }, { rtfSectAttr, rtfTitleSpecial, "titlepg", 0 }, { rtfSectAttr, rtfHeaderY, "headery", 0 }, { rtfSectAttr, rtfFooterY, "footery", 0 },
{ rtfSectAttr, rtfPageStarts, "pgnstarts", 0 }, { rtfSectAttr, rtfPageCont, "pgncont", 0 }, { rtfSectAttr, rtfPageRestart, "pgnrestart", 0 }, { rtfSectAttr, rtfPageNumRight, "pgnx", 0 }, { rtfSectAttr, rtfPageNumTop, "pgny", 0 }, { rtfSectAttr, rtfPageDecimal, "pgndec", 0 }, { rtfSectAttr, rtfPageURoman, "pgnucrm", 0 }, { rtfSectAttr, rtfPageLRoman, "pgnlcrm", 0 }, { rtfSectAttr, rtfPageULetter, "pgnucltr", 0 }, { rtfSectAttr, rtfPageLLetter, "pgnlcltr", 0 }, { rtfSectAttr, rtfPageNumHyphSep, "pgnhnsh", 0 }, { rtfSectAttr, rtfPageNumSpaceSep, "pgnhnsp", 0 }, { rtfSectAttr, rtfPageNumColonSep, "pgnhnsc", 0 }, { rtfSectAttr, rtfPageNumEmdashSep, "pgnhnsm", 0 }, { rtfSectAttr, rtfPageNumEndashSep, "pgnhnsn", 0 },
{ rtfSectAttr, rtfTopVAlign, "vertalt", 0 }, /* misspelled as "vertal" in specification 1.0 */ { rtfSectAttr, rtfBottomVAlign, "vertalb", 0 }, { rtfSectAttr, rtfCenterVAlign, "vertalc", 0 }, { rtfSectAttr, rtfJustVAlign, "vertalj", 0 },
{ rtfSectAttr, rtfRTLSect, "rtlsect", 0 }, { rtfSectAttr, rtfLTRSect, "ltrsect", 0 },
/* I've seen these in an old spec, but not in real files... */ /*rtfSectAttr, rtfNoBreak, "nobreak", 0,*/ /*rtfSectAttr, rtfColBreak, "colbreak", 0,*/ /*rtfSectAttr, rtfPageBreak, "pagebreak", 0,*/ /*rtfSectAttr, rtfEvenBreak, "evenbreak", 0,*/ /*rtfSectAttr, rtfOddBreak, "oddbreak", 0,*/
/* * Document formatting attributes */
{ rtfDocAttr, rtfDefTab, "deftab", 0 }, { rtfDocAttr, rtfHyphHotZone, "hyphhotz", 0 }, { rtfDocAttr, rtfHyphConsecLines, "hyphconsec", 0 }, { rtfDocAttr, rtfHyphCaps, "hyphcaps", 0 }, { rtfDocAttr, rtfHyphAuto, "hyphauto", 0 }, { rtfDocAttr, rtfLineStart, "linestart", 0 }, { rtfDocAttr, rtfFracWidth, "fracwidth", 0 }, /* \makeback was given in old version of spec, it's now */ /* listed as \makebackup */ { rtfDocAttr, rtfMakeBackup, "makeback", 0 }, { rtfDocAttr, rtfMakeBackup, "makebackup", 0 }, { rtfDocAttr, rtfRTFDefault, "defformat", 0 }, { rtfDocAttr, rtfPSOverlay, "psover", 0 }, { rtfDocAttr, rtfDocTemplate, "doctemp", 0 }, { rtfDocAttr, rtfDefLanguage, "deflang", 0 },
{ rtfDocAttr, rtfFENoteType, "fet", 0 }, { rtfDocAttr, rtfFNoteEndSect, "endnotes", 0 }, { rtfDocAttr, rtfFNoteEndDoc, "enddoc", 0 }, { rtfDocAttr, rtfFNoteText, "ftntj", 0 }, { rtfDocAttr, rtfFNoteBottom, "ftnbj", 0 }, { rtfDocAttr, rtfENoteEndSect, "aendnotes", 0 }, { rtfDocAttr, rtfENoteEndDoc, "aenddoc", 0 }, { rtfDocAttr, rtfENoteText, "aftntj", 0 }, { rtfDocAttr, rtfENoteBottom, "aftnbj", 0 }, { rtfDocAttr, rtfFNoteStart, "ftnstart", 0 }, { rtfDocAttr, rtfENoteStart, "aftnstart", 0 }, { rtfDocAttr, rtfFNoteRestartPage, "ftnrstpg", 0 }, { rtfDocAttr, rtfFNoteRestart, "ftnrestart", 0 }, { rtfDocAttr, rtfFNoteRestartCont, "ftnrstcont", 0 }, { rtfDocAttr, rtfENoteRestart, "aftnrestart", 0 }, { rtfDocAttr, rtfENoteRestartCont, "aftnrstcont", 0 }, { rtfDocAttr, rtfFNoteNumArabic, "ftnnar", 0 }, { rtfDocAttr, rtfFNoteNumLLetter, "ftnnalc", 0 }, { rtfDocAttr, rtfFNoteNumULetter, "ftnnauc", 0 }, { rtfDocAttr, rtfFNoteNumLRoman, "ftnnrlc", 0 }, { rtfDocAttr, rtfFNoteNumURoman, "ftnnruc", 0 }, { rtfDocAttr, rtfFNoteNumChicago, "ftnnchi", 0 }, { rtfDocAttr, rtfENoteNumArabic, "aftnnar", 0 }, { rtfDocAttr, rtfENoteNumLLetter, "aftnnalc", 0 }, { rtfDocAttr, rtfENoteNumULetter, "aftnnauc", 0 }, { rtfDocAttr, rtfENoteNumLRoman, "aftnnrlc", 0 }, { rtfDocAttr, rtfENoteNumURoman, "aftnnruc", 0 }, { rtfDocAttr, rtfENoteNumChicago, "aftnnchi", 0 },
{ rtfDocAttr, rtfPaperWidth, "paperw", 0 }, { rtfDocAttr, rtfPaperHeight, "paperh", 0 }, { rtfDocAttr, rtfPaperSize, "psz", 0 }, { rtfDocAttr, rtfLeftMargin, "margl", 0 }, { rtfDocAttr, rtfRightMargin, "margr", 0 }, { rtfDocAttr, rtfTopMargin, "margt", 0 }, { rtfDocAttr, rtfBottomMargin, "margb", 0 }, { rtfDocAttr, rtfFacingPage, "facingp", 0 }, { rtfDocAttr, rtfGutterWid, "gutter", 0 }, { rtfDocAttr, rtfMirrorMargin, "margmirror", 0 }, { rtfDocAttr, rtfLandscape, "landscape", 0 }, { rtfDocAttr, rtfPageStart, "pgnstart", 0 }, { rtfDocAttr, rtfWidowCtrl, "widowctrl", 0 },
{ rtfDocAttr, rtfLinkStyles, "linkstyles", 0 },
{ rtfDocAttr, rtfNoAutoTabIndent, "notabind", 0 }, { rtfDocAttr, rtfWrapSpaces, "wraptrsp", 0 }, { rtfDocAttr, rtfPrintColorsBlack, "prcolbl", 0 }, { rtfDocAttr, rtfNoExtraSpaceRL, "noextrasprl", 0 }, { rtfDocAttr, rtfNoColumnBalance, "nocolbal", 0 }, { rtfDocAttr, rtfCvtMailMergeQuote, "cvmme", 0 }, { rtfDocAttr, rtfSuppressTopSpace, "sprstsp", 0 }, { rtfDocAttr, rtfSuppressPreParSpace, "sprsspbf", 0 }, { rtfDocAttr, rtfCombineTblBorders, "otblrul", 0 }, { rtfDocAttr, rtfTranspMetafiles, "transmf", 0 }, { rtfDocAttr, rtfSwapBorders, "swpbdr", 0 }, { rtfDocAttr, rtfShowHardBreaks, "brkfrm", 0 },
{ rtfDocAttr, rtfFormProtected, "formprot", 0 }, { rtfDocAttr, rtfAllProtected, "allprot", 0 }, { rtfDocAttr, rtfFormShading, "formshade", 0 }, { rtfDocAttr, rtfFormDisplay, "formdisp", 0 }, { rtfDocAttr, rtfPrintData, "printdata", 0 },
{ rtfDocAttr, rtfRevProtected, "revprot", 0 }, { rtfDocAttr, rtfRevisions, "revisions", 0 }, { rtfDocAttr, rtfRevDisplay, "revprop", 0 }, { rtfDocAttr, rtfRevBar, "revbar", 0 },
{ rtfDocAttr, rtfAnnotProtected, "annotprot", 0 },
{ rtfDocAttr, rtfRTLDoc, "rtldoc", 0 }, { rtfDocAttr, rtfLTRDoc, "ltrdoc", 0 },
{ rtfDocAttr, rtfAnsiCodePage, "ansicpg", 0 }, { rtfDocAttr, rtfUTF8RTF, "urtf", 0 },
/* * Style attributes */
{ rtfStyleAttr, rtfAdditive, "additive", 0 }, { rtfStyleAttr, rtfBasedOn, "sbasedon", 0 }, { rtfStyleAttr, rtfNext, "snext", 0 },
/* * Picture attributes */
{ rtfPictAttr, rtfMacQD, "macpict", 0 }, { rtfPictAttr, rtfPMMetafile, "pmmetafile", 0 }, { rtfPictAttr, rtfWinMetafile, "wmetafile", 0 }, { rtfPictAttr, rtfDevIndBitmap, "dibitmap", 0 }, { rtfPictAttr, rtfWinBitmap, "wbitmap", 0 }, { rtfPictAttr, rtfEmfBlip, "emfblip", 0 }, { rtfPictAttr, rtfPixelBits, "wbmbitspixel", 0 }, { rtfPictAttr, rtfBitmapPlanes, "wbmplanes", 0 }, { rtfPictAttr, rtfBitmapWid, "wbmwidthbytes", 0 },
{ rtfPictAttr, rtfPicWid, "picw", 0 }, { rtfPictAttr, rtfPicHt, "pich", 0 }, { rtfPictAttr, rtfPicGoalWid, "picwgoal", 0 }, { rtfPictAttr, rtfPicGoalHt, "pichgoal", 0 }, /* these two aren't in the spec, but some writers emit them */ { rtfPictAttr, rtfPicGoalWid, "picwGoal", 0 }, { rtfPictAttr, rtfPicGoalHt, "pichGoal", 0 }, { rtfPictAttr, rtfPicScaleX, "picscalex", 0 }, { rtfPictAttr, rtfPicScaleY, "picscaley", 0 }, { rtfPictAttr, rtfPicScaled, "picscaled", 0 }, { rtfPictAttr, rtfPicCropTop, "piccropt", 0 }, { rtfPictAttr, rtfPicCropBottom, "piccropb", 0 }, { rtfPictAttr, rtfPicCropLeft, "piccropl", 0 }, { rtfPictAttr, rtfPicCropRight, "piccropr", 0 },
{ rtfPictAttr, rtfPicMFHasBitmap, "picbmp", 0 }, { rtfPictAttr, rtfPicMFBitsPerPixel, "picbpp", 0 },
{ rtfPictAttr, rtfPicBinary, "bin", 0 },
/* * NeXT graphic attributes */
{ rtfNeXTGrAttr, rtfNeXTGWidth, "width", 0 }, { rtfNeXTGrAttr, rtfNeXTGHeight, "height", 0 },
/* * Destinations */
{ rtfDestination, rtfFontTbl, "fonttbl", 0 }, { rtfDestination, rtfFontAltName, "falt", 0 }, { rtfDestination, rtfEmbeddedFont, "fonteb", 0 }, { rtfDestination, rtfFontFile, "fontfile", 0 }, { rtfDestination, rtfFileTbl, "filetbl", 0 }, { rtfDestination, rtfFileInfo, "file", 0 }, { rtfDestination, rtfColorTbl, "colortbl", 0 }, { rtfDestination, rtfStyleSheet, "stylesheet", 0 }, { rtfDestination, rtfKeyCode, "keycode", 0 }, { rtfDestination, rtfRevisionTbl, "revtbl", 0 }, { rtfDestination, rtfGenerator, "generator", 0 }, { rtfDestination, rtfInfo, "info", 0 }, { rtfDestination, rtfITitle, "title", 0 }, { rtfDestination, rtfISubject, "subject", 0 }, { rtfDestination, rtfIAuthor, "author", 0 }, { rtfDestination, rtfIOperator, "operator", 0 }, { rtfDestination, rtfIKeywords, "keywords", 0 }, { rtfDestination, rtfIComment, "comment", 0 }, { rtfDestination, rtfIVersion, "version", 0 }, { rtfDestination, rtfIDoccomm, "doccomm", 0 }, /* \verscomm may not exist -- was seen in earlier spec version */ { rtfDestination, rtfIVerscomm, "verscomm", 0 }, { rtfDestination, rtfNextFile, "nextfile", 0 }, { rtfDestination, rtfTemplate, "template", 0 }, { rtfDestination, rtfFNSep, "ftnsep", 0 }, { rtfDestination, rtfFNContSep, "ftnsepc", 0 }, { rtfDestination, rtfFNContNotice, "ftncn", 0 }, { rtfDestination, rtfENSep, "aftnsep", 0 }, { rtfDestination, rtfENContSep, "aftnsepc", 0 }, { rtfDestination, rtfENContNotice, "aftncn", 0 }, { rtfDestination, rtfPageNumLevel, "pgnhn", 0 }, { rtfDestination, rtfParNumLevelStyle, "pnseclvl", 0 }, { rtfDestination, rtfHeader, "header", 0 }, { rtfDestination, rtfFooter, "footer", 0 }, { rtfDestination, rtfHeaderLeft, "headerl", 0 }, { rtfDestination, rtfHeaderRight, "headerr", 0 }, { rtfDestination, rtfHeaderFirst, "headerf", 0 }, { rtfDestination, rtfFooterLeft, "footerl", 0 }, { rtfDestination, rtfFooterRight, "footerr", 0 }, { rtfDestination, rtfFooterFirst, "footerf", 0 }, { rtfDestination, rtfParNumText, "pntext", 0 }, { rtfDestination, rtfParNumbering, "pn", 0 }, { rtfDestination, rtfParNumTextAfter, "pntxta", 0 }, { rtfDestination, rtfParNumTextBefore, "pntxtb", 0 }, { rtfDestination, rtfBookmarkStart, "bkmkstart", 0 }, { rtfDestination, rtfBookmarkEnd, "bkmkend", 0 }, { rtfDestination, rtfPict, "pict", 0 }, { rtfDestination, rtfObject, "object", 0 }, { rtfDestination, rtfObjClass, "objclass", 0 }, { rtfDestination, rtfObjName, "objname", 0 }, { rtfObjAttr, rtfObjTime, "objtime", 0 }, { rtfDestination, rtfObjData, "objdata", 0 }, { rtfDestination, rtfObjAlias, "objalias", 0 }, { rtfDestination, rtfObjSection, "objsect", 0 }, /* objitem and objtopic aren't documented in the spec! */ { rtfDestination, rtfObjItem, "objitem", 0 }, { rtfDestination, rtfObjTopic, "objtopic", 0 }, { rtfDestination, rtfObjResult, "result", 0 }, { rtfDestination, rtfDrawObject, "do", 0 }, { rtfDestination, rtfFootnote, "footnote", 0 }, { rtfDestination, rtfAnnotRefStart, "atrfstart", 0 }, { rtfDestination, rtfAnnotRefEnd, "atrfend", 0 }, { rtfDestination, rtfAnnotID, "atnid", 0 }, { rtfDestination, rtfAnnotAuthor, "atnauthor", 0 }, { rtfDestination, rtfAnnotation, "annotation", 0 }, { rtfDestination, rtfAnnotRef, "atnref", 0 }, { rtfDestination, rtfAnnotTime, "atntime", 0 }, { rtfDestination, rtfAnnotIcon, "atnicn", 0 }, { rtfDestination, rtfField, "field", 0 }, { rtfDestination, rtfFieldInst, "fldinst", 0 }, { rtfDestination, rtfFieldResult, "fldrslt", 0 }, { rtfDestination, rtfDataField, "datafield", 0 }, { rtfDestination, rtfIndex, "xe", 0 }, { rtfDestination, rtfIndexText, "txe", 0 }, { rtfDestination, rtfIndexRange, "rxe", 0 }, { rtfDestination, rtfTOC, "tc", 0 }, { rtfDestination, rtfNeXTGraphic, "NeXTGraphic", 0 }, { rtfDestination, rtfNestTableProps, "nesttableprops", 0 }, { rtfDestination, rtfNoNestTables, "nonesttables", 0 }, { rtfDestination, rtfShpPict, "shppict", 0 }, { rtfDestination, rtfNonShpPict, "nonshppict", 0 },
/* * Font families */
{ rtfFontFamily, rtfFFNil, "fnil", 0 }, { rtfFontFamily, rtfFFRoman, "froman", 0 }, { rtfFontFamily, rtfFFSwiss, "fswiss", 0 }, { rtfFontFamily, rtfFFModern, "fmodern", 0 }, { rtfFontFamily, rtfFFScript, "fscript", 0 }, { rtfFontFamily, rtfFFDecor, "fdecor", 0 }, { rtfFontFamily, rtfFFTech, "ftech", 0 }, { rtfFontFamily, rtfFFBidirectional, "fbidi", 0 },
/* * Font attributes */
{ rtfFontAttr, rtfFontCharSet, "fcharset", 0 }, { rtfFontAttr, rtfFontPitch, "fprq", 0 }, { rtfFontAttr, rtfFontCodePage, "cpg", 0 }, { rtfFontAttr, rtfFTypeNil, "ftnil", 0 }, { rtfFontAttr, rtfFTypeTrueType, "fttruetype", 0 },
/* * File table attributes */
{ rtfFileAttr, rtfFileNum, "fid", 0 }, { rtfFileAttr, rtfFileRelPath, "frelative", 0 }, { rtfFileAttr, rtfFileOSNum, "fosnum", 0 },
/* * File sources */
{ rtfFileSource, rtfSrcMacintosh, "fvalidmac", 0 }, { rtfFileSource, rtfSrcDOS, "fvaliddos", 0 }, { rtfFileSource, rtfSrcNTFS, "fvalidntfs", 0 }, { rtfFileSource, rtfSrcHPFS, "fvalidhpfs", 0 }, { rtfFileSource, rtfSrcNetwork, "fnetwork", 0 },
/* * Color names */
{ rtfColorName, rtfRed, "red", 0 }, { rtfColorName, rtfGreen, "green", 0 }, { rtfColorName, rtfBlue, "blue", 0 },
/* * Charset names */
{ rtfCharSet, rtfMacCharSet, "mac", 0 }, { rtfCharSet, rtfAnsiCharSet, "ansi", 0 }, { rtfCharSet, rtfPcCharSet, "pc", 0 }, { rtfCharSet, rtfPcaCharSet, "pca", 0 },
/* * Table attributes */
{ rtfTblAttr, rtfRowDef, "trowd", 0 }, { rtfTblAttr, rtfRowGapH, "trgaph", 0 }, { rtfTblAttr, rtfCellPos, "cellx", 0 }, { rtfTblAttr, rtfMergeRngFirst, "clmgf", 0 }, { rtfTblAttr, rtfMergePrevious, "clmrg", 0 },
{ rtfTblAttr, rtfRowLeft, "trql", 0 }, { rtfTblAttr, rtfRowRight, "trqr", 0 }, { rtfTblAttr, rtfRowCenter, "trqc", 0 }, { rtfTblAttr, rtfRowLeftEdge, "trleft", 0 }, { rtfTblAttr, rtfRowHt, "trrh", 0 }, { rtfTblAttr, rtfRowHeader, "trhdr", 0 }, { rtfTblAttr, rtfRowKeep, "trkeep", 0 },
{ rtfTblAttr, rtfRTLRow, "rtlrow", 0 }, { rtfTblAttr, rtfLTRRow, "ltrrow", 0 },
{ rtfTblAttr, rtfRowBordTop, "trbrdrt", 0 }, { rtfTblAttr, rtfRowBordLeft, "trbrdrl", 0 }, { rtfTblAttr, rtfRowBordBottom, "trbrdrb", 0 }, { rtfTblAttr, rtfRowBordRight, "trbrdrr", 0 }, { rtfTblAttr, rtfRowBordHoriz, "trbrdrh", 0 }, { rtfTblAttr, rtfRowBordVert, "trbrdrv", 0 },
{ rtfTblAttr, rtfCellBordBottom, "clbrdrb", 0 }, { rtfTblAttr, rtfCellBordTop, "clbrdrt", 0 }, { rtfTblAttr, rtfCellBordLeft, "clbrdrl", 0 }, { rtfTblAttr, rtfCellBordRight, "clbrdrr", 0 },
{ rtfTblAttr, rtfCellShading, "clshdng", 0 }, { rtfTblAttr, rtfCellBgPatH, "clbghoriz", 0 }, { rtfTblAttr, rtfCellBgPatV, "clbgvert", 0 }, { rtfTblAttr, rtfCellFwdDiagBgPat, "clbgfdiag", 0 }, { rtfTblAttr, rtfCellBwdDiagBgPat, "clbgbdiag", 0 }, { rtfTblAttr, rtfCellHatchBgPat, "clbgcross", 0 }, { rtfTblAttr, rtfCellDiagHatchBgPat, "clbgdcross", 0 }, /* * The spec lists "clbgdkhor", but the corresponding non-cell * control is "bgdkhoriz". At any rate Macintosh Word seems * to accept both "clbgdkhor" and "clbgdkhoriz". */ { rtfTblAttr, rtfCellDarkBgPatH, "clbgdkhoriz", 0 }, { rtfTblAttr, rtfCellDarkBgPatH, "clbgdkhor", 0 }, { rtfTblAttr, rtfCellDarkBgPatV, "clbgdkvert", 0 }, { rtfTblAttr, rtfCellFwdDarkBgPat, "clbgdkfdiag", 0 }, { rtfTblAttr, rtfCellBwdDarkBgPat, "clbgdkbdiag", 0 }, { rtfTblAttr, rtfCellDarkHatchBgPat, "clbgdkcross", 0 }, { rtfTblAttr, rtfCellDarkDiagHatchBgPat, "clbgdkdcross", 0 }, { rtfTblAttr, rtfCellBgPatLineColor, "clcfpat", 0 }, { rtfTblAttr, rtfCellBgPatColor, "clcbpat", 0 },
/* * Field attributes */
{ rtfFieldAttr, rtfFieldDirty, "flddirty", 0 }, { rtfFieldAttr, rtfFieldEdited, "fldedit", 0 }, { rtfFieldAttr, rtfFieldLocked, "fldlock", 0 }, { rtfFieldAttr, rtfFieldPrivate, "fldpriv", 0 }, { rtfFieldAttr, rtfFieldAlt, "fldalt", 0 },
/* * Positioning attributes */
{ rtfPosAttr, rtfAbsWid, "absw", 0 }, { rtfPosAttr, rtfAbsHt, "absh", 0 },
{ rtfPosAttr, rtfRPosMargH, "phmrg", 0 }, { rtfPosAttr, rtfRPosPageH, "phpg", 0 }, { rtfPosAttr, rtfRPosColH, "phcol", 0 }, { rtfPosAttr, rtfPosX, "posx", 0 }, { rtfPosAttr, rtfPosNegX, "posnegx", 0 }, { rtfPosAttr, rtfPosXCenter, "posxc", 0 }, { rtfPosAttr, rtfPosXInside, "posxi", 0 }, { rtfPosAttr, rtfPosXOutSide, "posxo", 0 }, { rtfPosAttr, rtfPosXRight, "posxr", 0 }, { rtfPosAttr, rtfPosXLeft, "posxl", 0 },
{ rtfPosAttr, rtfRPosMargV, "pvmrg", 0 }, { rtfPosAttr, rtfRPosPageV, "pvpg", 0 }, { rtfPosAttr, rtfRPosParaV, "pvpara", 0 }, { rtfPosAttr, rtfPosY, "posy", 0 }, { rtfPosAttr, rtfPosNegY, "posnegy", 0 }, { rtfPosAttr, rtfPosYInline, "posyil", 0 }, { rtfPosAttr, rtfPosYTop, "posyt", 0 }, { rtfPosAttr, rtfPosYCenter, "posyc", 0 }, { rtfPosAttr, rtfPosYBottom, "posyb", 0 },
{ rtfPosAttr, rtfNoWrap, "nowrap", 0 }, { rtfPosAttr, rtfDistFromTextAll, "dxfrtext", 0 }, { rtfPosAttr, rtfDistFromTextX, "dfrmtxtx", 0 }, { rtfPosAttr, rtfDistFromTextY, "dfrmtxty", 0 }, /* \dyfrtext no longer exists in spec 1.2, apparently */ /* replaced by \dfrmtextx and \dfrmtexty. */ { rtfPosAttr, rtfTextDistY, "dyfrtext", 0 },
{ rtfPosAttr, rtfDropCapLines, "dropcapli", 0 }, { rtfPosAttr, rtfDropCapType, "dropcapt", 0 },
/* * Object controls */
{ rtfObjAttr, rtfObjEmb, "objemb", 0 }, { rtfObjAttr, rtfObjLink, "objlink", 0 }, { rtfObjAttr, rtfObjAutoLink, "objautlink", 0 }, { rtfObjAttr, rtfObjSubscriber, "objsub", 0 }, { rtfObjAttr, rtfObjPublisher, "objpub", 0 }, { rtfObjAttr, rtfObjICEmb, "objicemb", 0 },
{ rtfObjAttr, rtfObjLinkSelf, "linkself", 0 }, { rtfObjAttr, rtfObjLock, "objupdate", 0 }, { rtfObjAttr, rtfObjUpdate, "objlock", 0 },
{ rtfObjAttr, rtfObjHt, "objh", 0 }, { rtfObjAttr, rtfObjWid, "objw", 0 }, { rtfObjAttr, rtfObjSetSize, "objsetsize", 0 }, { rtfObjAttr, rtfObjAlign, "objalign", 0 }, { rtfObjAttr, rtfObjTransposeY, "objtransy", 0 }, { rtfObjAttr, rtfObjCropTop, "objcropt", 0 }, { rtfObjAttr, rtfObjCropBottom, "objcropb", 0 }, { rtfObjAttr, rtfObjCropLeft, "objcropl", 0 }, { rtfObjAttr, rtfObjCropRight, "objcropr", 0 }, { rtfObjAttr, rtfObjScaleX, "objscalex", 0 }, { rtfObjAttr, rtfObjScaleY, "objscaley", 0 },
{ rtfObjAttr, rtfObjResRTF, "rsltrtf", 0 }, { rtfObjAttr, rtfObjResPict, "rsltpict", 0 }, { rtfObjAttr, rtfObjResBitmap, "rsltbmp", 0 }, { rtfObjAttr, rtfObjResText, "rslttxt", 0 }, { rtfObjAttr, rtfObjResMerge, "rsltmerge", 0 },
{ rtfObjAttr, rtfObjBookmarkPubObj, "bkmkpub", 0 }, { rtfObjAttr, rtfObjPubAutoUpdate, "pubauto", 0 },
/* * Associated character formatting attributes */
{ rtfACharAttr, rtfACBold, "ab", 0 }, { rtfACharAttr, rtfACAllCaps, "caps", 0 }, { rtfACharAttr, rtfACForeColor, "acf", 0 }, { rtfACharAttr, rtfACSubScript, "adn", 0 }, { rtfACharAttr, rtfACExpand, "aexpnd", 0 }, { rtfACharAttr, rtfACFontNum, "af", 0 }, { rtfACharAttr, rtfACFontSize, "afs", 0 }, { rtfACharAttr, rtfACItalic, "ai", 0 }, { rtfACharAttr, rtfACLanguage, "alang", 0 }, { rtfACharAttr, rtfACOutline, "aoutl", 0 }, { rtfACharAttr, rtfACSmallCaps, "ascaps", 0 }, { rtfACharAttr, rtfACShadow, "ashad", 0 }, { rtfACharAttr, rtfACStrikeThru, "astrike", 0 }, { rtfACharAttr, rtfACUnderline, "aul", 0 }, { rtfACharAttr, rtfACDotUnderline, "auld", 0 }, { rtfACharAttr, rtfACDbUnderline, "auldb", 0 }, { rtfACharAttr, rtfACNoUnderline, "aulnone", 0 }, { rtfACharAttr, rtfACWordUnderline, "aulw", 0 }, { rtfACharAttr, rtfACSuperScript, "aup", 0 },
/* * Footnote attributes */
{ rtfFNoteAttr, rtfFNAlt, "ftnalt", 0 },
/* * Key code attributes */
{ rtfKeyCodeAttr, rtfAltKey, "alt", 0 }, { rtfKeyCodeAttr, rtfShiftKey, "shift", 0 }, { rtfKeyCodeAttr, rtfControlKey, "ctrl", 0 }, { rtfKeyCodeAttr, rtfFunctionKey, "fn", 0 },
/* * Bookmark attributes */
{ rtfBookmarkAttr, rtfBookmarkFirstCol, "bkmkcolf", 0 }, { rtfBookmarkAttr, rtfBookmarkLastCol, "bkmkcoll", 0 },
/* * Index entry attributes */
{ rtfIndexAttr, rtfIndexNumber, "xef", 0 }, { rtfIndexAttr, rtfIndexBold, "bxe", 0 }, { rtfIndexAttr, rtfIndexItalic, "ixe", 0 },
/* * Table of contents attributes */
{ rtfTOCAttr, rtfTOCType, "tcf", 0 }, { rtfTOCAttr, rtfTOCLevel, "tcl", 0 },
/* * Drawing object attributes */
{ rtfDrawAttr, rtfDrawLock, "dolock", 0 }, { rtfDrawAttr, rtfDrawPageRelX, "doxpage", 0 }, { rtfDrawAttr, rtfDrawColumnRelX, "dobxcolumn", 0 }, { rtfDrawAttr, rtfDrawMarginRelX, "dobxmargin", 0 }, { rtfDrawAttr, rtfDrawPageRelY, "dobypage", 0 }, { rtfDrawAttr, rtfDrawColumnRelY, "dobycolumn", 0 }, { rtfDrawAttr, rtfDrawMarginRelY, "dobymargin", 0 }, { rtfDrawAttr, rtfDrawHeight, "dobhgt", 0 },
{ rtfDrawAttr, rtfDrawBeginGroup, "dpgroup", 0 }, { rtfDrawAttr, rtfDrawGroupCount, "dpcount", 0 }, { rtfDrawAttr, rtfDrawEndGroup, "dpendgroup", 0 }, { rtfDrawAttr, rtfDrawArc, "dparc", 0 }, { rtfDrawAttr, rtfDrawCallout, "dpcallout", 0 }, { rtfDrawAttr, rtfDrawEllipse, "dpellipse", 0 }, { rtfDrawAttr, rtfDrawLine, "dpline", 0 }, { rtfDrawAttr, rtfDrawPolygon, "dppolygon", 0 }, { rtfDrawAttr, rtfDrawPolyLine, "dppolyline", 0 }, { rtfDrawAttr, rtfDrawRect, "dprect", 0 }, { rtfDrawAttr, rtfDrawTextBox, "dptxbx", 0 },
{ rtfDrawAttr, rtfDrawOffsetX, "dpx", 0 }, { rtfDrawAttr, rtfDrawSizeX, "dpxsize", 0 }, { rtfDrawAttr, rtfDrawOffsetY, "dpy", 0 }, { rtfDrawAttr, rtfDrawSizeY, "dpysize", 0 },
{ rtfDrawAttr, rtfCOAngle, "dpcoa", 0 }, { rtfDrawAttr, rtfCOAccentBar, "dpcoaccent", 0 }, { rtfDrawAttr, rtfCOBestFit, "dpcobestfit", 0 }, { rtfDrawAttr, rtfCOBorder, "dpcoborder", 0 }, { rtfDrawAttr, rtfCOAttachAbsDist, "dpcodabs", 0 }, { rtfDrawAttr, rtfCOAttachBottom, "dpcodbottom", 0 }, { rtfDrawAttr, rtfCOAttachCenter, "dpcodcenter", 0 }, { rtfDrawAttr, rtfCOAttachTop, "dpcodtop", 0 }, { rtfDrawAttr, rtfCOLength, "dpcolength", 0 }, { rtfDrawAttr, rtfCONegXQuadrant, "dpcominusx", 0 }, { rtfDrawAttr, rtfCONegYQuadrant, "dpcominusy", 0 }, { rtfDrawAttr, rtfCOOffset, "dpcooffset", 0 }, { rtfDrawAttr, rtfCOAttachSmart, "dpcosmarta", 0 }, { rtfDrawAttr, rtfCODoubleLine, "dpcotdouble", 0 }, { rtfDrawAttr, rtfCORightAngle, "dpcotright", 0 }, { rtfDrawAttr, rtfCOSingleLine, "dpcotsingle", 0 }, { rtfDrawAttr, rtfCOTripleLine, "dpcottriple", 0 },
{ rtfDrawAttr, rtfDrawTextBoxMargin, "dptxbxmar", 0 }, { rtfDrawAttr, rtfDrawTextBoxText, "dptxbxtext", 0 }, { rtfDrawAttr, rtfDrawRoundRect, "dproundr", 0 },
{ rtfDrawAttr, rtfDrawPointX, "dpptx", 0 }, { rtfDrawAttr, rtfDrawPointY, "dppty", 0 }, { rtfDrawAttr, rtfDrawPolyCount, "dppolycount", 0 },
{ rtfDrawAttr, rtfDrawArcFlipX, "dparcflipx", 0 }, { rtfDrawAttr, rtfDrawArcFlipY, "dparcflipy", 0 },
{ rtfDrawAttr, rtfDrawLineBlue, "dplinecob", 0 }, { rtfDrawAttr, rtfDrawLineGreen, "dplinecog", 0 }, { rtfDrawAttr, rtfDrawLineRed, "dplinecor", 0 }, { rtfDrawAttr, rtfDrawLinePalette, "dplinepal", 0 }, { rtfDrawAttr, rtfDrawLineDashDot, "dplinedado", 0 }, { rtfDrawAttr, rtfDrawLineDashDotDot, "dplinedadodo", 0 }, { rtfDrawAttr, rtfDrawLineDash, "dplinedash", 0 }, { rtfDrawAttr, rtfDrawLineDot, "dplinedot", 0 }, { rtfDrawAttr, rtfDrawLineGray, "dplinegray", 0 }, { rtfDrawAttr, rtfDrawLineHollow, "dplinehollow", 0 }, { rtfDrawAttr, rtfDrawLineSolid, "dplinesolid", 0 }, { rtfDrawAttr, rtfDrawLineWidth, "dplinew", 0 },
{ rtfDrawAttr, rtfDrawHollowEndArrow, "dpaendhol", 0 }, { rtfDrawAttr, rtfDrawEndArrowLength, "dpaendl", 0 }, { rtfDrawAttr, rtfDrawSolidEndArrow, "dpaendsol", 0 }, { rtfDrawAttr, rtfDrawEndArrowWidth, "dpaendw", 0 }, { rtfDrawAttr, rtfDrawHollowStartArrow,"dpastarthol", 0 }, { rtfDrawAttr, rtfDrawStartArrowLength,"dpastartl", 0 }, { rtfDrawAttr, rtfDrawSolidStartArrow, "dpastartsol", 0 }, { rtfDrawAttr, rtfDrawStartArrowWidth, "dpastartw", 0 },
{ rtfDrawAttr, rtfDrawBgFillBlue, "dpfillbgcb", 0 }, { rtfDrawAttr, rtfDrawBgFillGreen, "dpfillbgcg", 0 }, { rtfDrawAttr, rtfDrawBgFillRed, "dpfillbgcr", 0 }, { rtfDrawAttr, rtfDrawBgFillPalette, "dpfillbgpal", 0 }, { rtfDrawAttr, rtfDrawBgFillGray, "dpfillbggray", 0 }, { rtfDrawAttr, rtfDrawFgFillBlue, "dpfillfgcb", 0 }, { rtfDrawAttr, rtfDrawFgFillGreen, "dpfillfgcg", 0 }, { rtfDrawAttr, rtfDrawFgFillRed, "dpfillfgcr", 0 }, { rtfDrawAttr, rtfDrawFgFillPalette, "dpfillfgpal", 0 }, { rtfDrawAttr, rtfDrawFgFillGray, "dpfillfggray", 0 }, { rtfDrawAttr, rtfDrawFillPatIndex, "dpfillpat", 0 },
{ rtfDrawAttr, rtfDrawShadow, "dpshadow", 0 }, { rtfDrawAttr, rtfDrawShadowXOffset, "dpshadx", 0 }, { rtfDrawAttr, rtfDrawShadowYOffset, "dpshady", 0 },
{ rtfVersion, -1, "rtf", 0 }, { rtfDefFont, -1, "deff", 0 },
{ 0, -1, NULL, 0 }};
typedef struct tagRTFHashTableEntry { int count; RTFKey **value;} RTFHashTableEntry;
static RTFHashTableEntry rtfHashTable[ARRAY_SIZE(rtfKey) * 2];
/* * Initialize lookup table hash values. Only need to do this once. */
void LookupInit(void){ RTFKey *rp;
memset(rtfHashTable, 0, sizeof rtfHashTable); for (rp = rtfKey; rp->rtfKStr != NULL; rp++) { int index;
rp->rtfKHash = Hash (rp->rtfKStr); index = rp->rtfKHash % (ARRAY_SIZE(rtfKey) * 2); rtfHashTable[index].value = realloc(rtfHashTable[index].value, sizeof(RTFKey *) * (rtfHashTable[index].count + 1)); rtfHashTable[index].value[rtfHashTable[index].count++] = rp; }}
void LookupCleanup(void){ unsigned int i;
for (i = 0; i < ARRAY_SIZE(rtfKey) * 2; i++) { free(rtfHashTable[i].value); rtfHashTable[i].value = NULL; rtfHashTable[i].count = 0; }}
/* * Determine major and minor number of control token. If it's * not found, the class turns into rtfUnknown. */
static void Lookup(RTF_Info *info, char *s){ RTFKey *rp; int hash; RTFHashTableEntry *entry; int i;
++s; /* skip over the leading \ character */ hash = Hash (s); entry = &rtfHashTable[hash % (ARRAY_SIZE(rtfKey) * 2)]; for (i = 0; i < entry->count; i++) { rp = entry->value[i]; if (hash == rp->rtfKHash && strcmp (s, rp->rtfKStr) == 0) { info->rtfClass = rtfControl; info->rtfMajor = rp->rtfKMajor; info->rtfMinor = rp->rtfKMinor; return; } } info->rtfClass = rtfUnknown;}
/* * Compute hash value of symbol */
static int Hash(const char *s){ char c; int val = 0;
while ((c = *s++) != '\0') val += c; return (val);}
/* ---------------------------------------------------------------------- */
/* * Token comparison routines */
int RTFCheckCM(const RTF_Info *info, int class, int major){ return (info->rtfClass == class && info->rtfMajor == major);}
int RTFCheckCMM(const RTF_Info *info, int class, int major, int minor){ return (info->rtfClass == class && info->rtfMajor == major && info->rtfMinor == minor);}
int RTFCheckMM(const RTF_Info *info, int major, int minor){ return (info->rtfMajor == major && info->rtfMinor == minor);}
/* ---------------------------------------------------------------------- */
int RTFCharToHex(char c){ if (isupper (c)) c = tolower (c); if (isdigit (c)) return (c - '0'); /* '0'..'9' */ return (c - 'a' + 10); /* 'a'..'f' */}
/* ---------------------------------------------------------------------- */
/* * originally from RTF tools' text-writer.c * * text-writer -- RTF-to-text translation writer code. * * Read RTF input, write text of document (text extraction). */
static void TextClass (RTF_Info *info);static void ControlClass (RTF_Info *info);static void DefFont(RTF_Info *info);static void Destination (RTF_Info *info);static void SpecialChar (RTF_Info *info);static void RTFPutUnicodeChar (RTF_Info *info, int c);
/* * Initialize the writer. */
voidWriterInit (RTF_Info *info ){}
intBeginFile (RTF_Info *info ){ /* install class callbacks */
RTFSetClassCallback (info, rtfText, TextClass); RTFSetClassCallback (info, rtfControl, ControlClass);
return (1);}
/* * Write out a character. */
static voidTextClass (RTF_Info *info){ RTFPutCodePageChar(info, info->rtfMajor);}
static voidControlClass (RTF_Info *info){ switch (info->rtfMajor) { case rtfCharAttr: CharAttr(info); ME_RTFCharAttrHook(info); break; case rtfParAttr: ME_RTFParAttrHook(info); break; case rtfTblAttr: ME_RTFTblAttrHook(info); break; case rtfCharSet: CharSet(info); break; case rtfDefFont: DefFont(info); break; case rtfDestination: Destination (info); break; case rtfDocAttr: DocAttr(info); break; case rtfSpecialChar: SpecialChar (info); ME_RTFSpecialCharHook(info); break; }}
static voidCharAttr(RTF_Info *info){ RTFFont *font;
switch (info->rtfMinor) { case rtfFontNum: font = RTFGetFont(info, info->rtfParam); if (font) { if (info->ansiCodePage != CP_UTF8 && info->codePage != font->rtfFCodePage) { RTFFlushOutputBuffer(info); info->codePage = font->rtfFCodePage; } TRACE("font %d codepage %d\n", info->rtfParam, info->codePage); } else ERR( "unknown font %d\n", info->rtfParam); break; case rtfUnicodeLength: info->unicodeLength = info->rtfParam; break; }}
static voidCharSet(RTF_Info *info){ if (info->ansiCodePage == CP_UTF8) return; switch (info->rtfMinor) { case rtfAnsiCharSet: info->ansiCodePage = 1252; /* Latin-1 */ break; case rtfMacCharSet: info->ansiCodePage = 10000; /* MacRoman */ break; case rtfPcCharSet: info->ansiCodePage = 437; break; case rtfPcaCharSet: info->ansiCodePage = 850; break; }}
/* * This function notices destinations that aren't explicitly handled * and skips to their ends. This keeps, for instance, picture * data from being considered as plain text. */
static voidDestination (RTF_Info *info){ if (!RTFGetDestinationCallback(info, info->rtfMinor)) RTFSkipGroup (info); }
static voidDefFont(RTF_Info *info){ TRACE("%d\n", info->rtfParam); info->defFont = info->rtfParam;}
static voidDocAttr(RTF_Info *info){ TRACE("minor %d, param %d\n", info->rtfMinor, info->rtfParam);
switch (info->rtfMinor) { case rtfAnsiCodePage: info->codePage = info->ansiCodePage = info->rtfParam; break; case rtfUTF8RTF: info->codePage = info->ansiCodePage = CP_UTF8; break; }}
static void SpecialChar (RTF_Info *info){ switch (info->rtfMinor) { case rtfOptDest: /* the next token determines destination, if it's unknown, skip the group */ /* this way we filter out the garbage coming from unknown destinations */ RTFGetToken(info); if (info->rtfClass != rtfDestination) RTFSkipGroup(info); else RTFRouteToken(info); /* "\*" is ignored with known destinations */ break; case rtfUnicode: { int i;
RTFPutUnicodeChar(info, info->rtfParam);
/* After \u we must skip number of character tokens set by \ucN */ for (i = 0; i < info->unicodeLength; i++) { RTFGetToken(info); if (info->rtfClass != rtfText) { ERR("The token behind \\u is not text, but (%d,%d,%d)\n", info->rtfClass, info->rtfMajor, info->rtfMinor); RTFUngetToken(info); break; } } break; } case rtfLine: RTFFlushOutputBuffer(info); ME_InsertEndRowFromCursor(info->editor, 0); break; case rtfPage: case rtfSect: case rtfPar: RTFFlushOutputBuffer(info); editor_set_selection_para_fmt( info->editor, &info->fmt ); memset(&info->fmt, 0, sizeof(info->fmt)); info->fmt.cbSize = sizeof(info->fmt); RTFPutUnicodeChar (info, '\r'); if (info->editor->bEmulateVersion10) RTFPutUnicodeChar (info, '\n'); break; case rtfNoBrkSpace: RTFPutUnicodeChar (info, 0x00A0); break; case rtfTab: RTFPutUnicodeChar (info, '\t'); break; case rtfNoBrkHyphen: RTFPutUnicodeChar (info, 0x2011); break; case rtfBullet: RTFPutUnicodeChar (info, 0x2022); break; case rtfEmDash: RTFPutUnicodeChar (info, 0x2014); break; case rtfEnDash: RTFPutUnicodeChar (info, 0x2013); break; case rtfEmSpace: RTFPutUnicodeChar (info, ' '); break; case rtfEnSpace: RTFPutUnicodeChar (info, ' '); break; case rtfLQuote: RTFPutUnicodeChar (info, 0x2018); break; case rtfRQuote: RTFPutUnicodeChar (info, 0x2019); break; case rtfLDblQuote: RTFPutUnicodeChar (info, 0x201C); break; case rtfRDblQuote: RTFPutUnicodeChar (info, 0x201D); break; case rtfLTRMark: RTFPutUnicodeChar (info, 0x200E); break; case rtfRTLMark: RTFPutUnicodeChar (info, 0x200F); break; case rtfNoWidthJoiner: RTFPutUnicodeChar (info, 0x200D); break; case rtfNoWidthNonJoiner: RTFPutUnicodeChar (info, 0x200C); break; }}
static voidRTFFlushUnicodeOutputBuffer(RTF_Info *info){ if (info->dwOutputCount) { ME_InsertTextFromCursor(info->editor, 0, info->OutputBuffer, info->dwOutputCount, info->style); info->dwOutputCount = 0; }}
static voidRTFPutUnicodeString(RTF_Info *info, const WCHAR *string, int length){ if (info->dwCPOutputCount) RTFFlushCPOutputBuffer(info); while (length) { int fit = min(length, ARRAY_SIZE(info->OutputBuffer) - info->dwOutputCount);
memmove(info->OutputBuffer + info->dwOutputCount, string, fit * sizeof(WCHAR)); info->dwOutputCount += fit; length -= fit; string += fit; if (ARRAY_SIZE(info->OutputBuffer) == info->dwOutputCount) RTFFlushUnicodeOutputBuffer(info); }}
static voidRTFFlushCPOutputBuffer(RTF_Info *info){ int bufferMax = info->dwCPOutputCount * 2 * sizeof(WCHAR); WCHAR *buffer = malloc(bufferMax); int length;
length = MultiByteToWideChar(info->codePage, 0, info->cpOutputBuffer, info->dwCPOutputCount, buffer, bufferMax/sizeof(WCHAR)); info->dwCPOutputCount = 0;
RTFPutUnicodeString(info, buffer, length); free(buffer);}
voidRTFFlushOutputBuffer(RTF_Info *info){ if (info->dwCPOutputCount) RTFFlushCPOutputBuffer(info); RTFFlushUnicodeOutputBuffer(info);}
static voidRTFPutUnicodeChar(RTF_Info *info, int c){ if (info->dwCPOutputCount) RTFFlushCPOutputBuffer(info); if (info->dwOutputCount * sizeof(WCHAR) >= ( sizeof info->OutputBuffer - 1 ) ) RTFFlushUnicodeOutputBuffer( info ); info->OutputBuffer[info->dwOutputCount++] = c;}
static voidRTFPutCodePageChar(RTF_Info *info, int c){ /* Use dynamic buffer here because it's the best way to handle * MBCS codepages without having to worry about partial chars */ if (info->dwCPOutputCount >= info->dwMaxCPOutputCount) { info->dwMaxCPOutputCount *= 2; info->cpOutputBuffer = realloc(info->cpOutputBuffer, info->dwMaxCPOutputCount); } info->cpOutputBuffer[info->dwCPOutputCount++] = c;}