able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/richedit/re41/rtfread.cpp

4518 lines
123 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
* @doc INTERNAL
*
* @module RTFREAD.CPP - RichEdit RTF reader (w/o objects) |
*
* This file contains the nonobject code of RichEdit RTF reader.
* See rtfread2.cpp for embedded-object code.
*
* Authors:<nl>
* Original RichEdit 1.0 RTF converter: Anthony Francisco <nl>
* Conversion to C++ and RichEdit 2.0 w/o objects: Murray Sargent
* Lots of enhancements/maintenance: Brad Olenick
*
* @devnote
* sz's in the RTF*.cpp and RTF*.h files usually refer to a LPSTRs,
* not LPWSTRs.
*
* @todo
* 1. Unrecognized RTF. Also some recognized won't round trip <nl>
* 2. In font.c, add overstrike for CFE_DELETED and underscore for
* CFE_REVISED. Would also be good to change color for CF.bRevAuthor
*
* Copyright (c) 1995-2002, Microsoft Corporation. All rights reserved.
*/
#include "_common.h"
#include "_rtfread.h"
#include "_util.h"
#include "_font.h"
#include "_disp.h"
ASSERTDATA
/*
* Global Variables
*/
#define PFM_ALLRTF (PFM_ALL2 | PFM_COLLAPSED | PFM_OUTLINELEVEL | PFM_BOX)
// for object attachment placeholder list
#define cobPosInitial 8
#define cobPosChunk 8
#if CFE_SMALLCAPS != 0x40 || CFE_ALLCAPS != 0x80 || CFE_HIDDEN != 0x100 \
|| CFE_OUTLINE != 0x200 || CFE_SHADOW != 0x400
#error "Need to change RTF char effect conversion routines
#endif
// for RTF tag coverage testing
#if defined(DEBUG) && !defined(NOFULLDEBUG)
#define TESTPARSERCOVERAGE() \
{ \
if(GetProfileIntA("RICHEDIT DEBUG", "RTFCOVERAGE", 0)) \
{ \
TestParserCoverage(); \
} \
}
#define PARSERCOVERAGE_CASE() \
{ \
if(_fTestingParserCoverage) \
{ \
return ecNoError; \
} \
}
#define PARSERCOVERAGE_DEFAULT() \
{ \
if(_fTestingParserCoverage) \
{ \
return ecStackOverflow; /* some bogus error */ \
} \
}
#else
#define TESTPARSERCOVERAGE()
#define PARSERCOVERAGE_CASE()
#define PARSERCOVERAGE_DEFAULT()
#endif
static WCHAR szRowEnd[] = {ENDFIELD, CR, 0};
static WCHAR szRowStart[] = {STARTFIELD, CR, 0};
WCHAR pchSeparateField[] = {SEPARATOR, 'F'};
WCHAR pchStartField[] = {STARTFIELD, 'F'};
// FF's should not have paragraph number prepended to them
inline BOOL CharGetsNumbering(WORD ch) { return ch != FF; }
// V-GUYB: PWord Converter requires loss notification.
#ifdef REPORT_LOSSAGE
typedef struct
{
IStream *pstm;
BOOL bFirstCallback;
LPVOID *ppwdPWData;
BOOL bLoss;
} LOST_COOKIE;
#endif
//======================== OLESTREAM functions =======================================
DWORD CALLBACK RTFGetFromStream (
RTFREADOLESTREAM *OLEStream, //@parm OleStream
void FAR * pvBuffer, //@parm Buffer to read
DWORD cb) //@parm Bytes to read
{
return OLEStream->Reader->ReadData ((BYTE *)pvBuffer, cb);
}
DWORD CALLBACK RTFGetBinaryDataFromStream (
RTFREADOLESTREAM *OLEStream, //@parm OleStream
void FAR * pvBuffer, //@parm Buffer to read
DWORD cb) //@parm Bytes to read
{
return OLEStream->Reader->ReadBinaryData ((BYTE *)pvBuffer, cb);
}
//============================ STATE Structure =================================
/*
* STATE::AddPF(PF, lDocType, dwMask, dwMask2)
*
* @mfunc
* If the PF contains new info, this info is applied to the PF for the
* state. If this state was sharing a PF with a previous state, a new
* PF is created for the state, and the new info is applied to it.
*
* @rdesc
* TRUE unless needed new PF and couldn't allocate it
*/
BOOL STATE::AddPF(
const CParaFormat &PF, //@parm Current RTFRead _PF
LONG lDocType, //@parm Default doc type to use if no prev state
DWORD dwMask, //@parm Mask to use
DWORD dwMask2) //@parm Mask to use
{
// Create a new PF if:
// 1. The state doesn't have one yet
// 2. The state has one, but it is shared by the previous state and
// there are PF deltas to apply to the state's PF
if(!pPF || dwMask && pstatePrev && pPF == pstatePrev->pPF)
{
Assert(!pstatePrev || pPF);
pPF = new CParaFormat;
if(!pPF)
return FALSE;
// Give the new PF some initial values - either from the previous
// state's PF or by CParaFormat initialization
if(pstatePrev)
{
// Copy the PF from the previous state
*pPF = *pstatePrev->pPF;
dwMaskPF = pstatePrev->dwMaskPF;
}
else
{
// We've just created a new PF for the state - there is no
// previous state to copy from. Use default values.
pPF->InitDefault(lDocType == DT_RTLDOC ? PFE_RTLPARA : 0);
dwMaskPF = PFM_ALLRTF;
dwMaskPF2 = PFM2_TABLEROWSHIFTED;
}
}
// Apply the new PF deltas to the state's PF
if(dwMask)
{
if(dwMask & PFM_TABSTOPS) // Don't change _iTabs here
{
pPF->_bTabCount = PF._bTabCount;
dwMask &= ~PFM_TABSTOPS;
}
pPF->Apply(&PF, dwMask, dwMaskPF2);
}
return TRUE;
}
/*
* STATE::DeletePF()
*
* @mfunc
* If the state's PF is not shared by the previous state, the PF for this
* state is deleted.
*/
void STATE::DeletePF()
{
if(pPF && (!pstatePrev || pPF != pstatePrev->pPF))
delete pPF;
pPF = NULL;
}
/*
* STATE::SetCodePage(CodePage)
*
* @mfunc
* If current nCodePage is CP_UTF8, use it for all conversions (yes, even
* for SYMBOL_CHARSET). Else use CodePage.
*/
void STATE::SetCodePage(
LONG CodePage)
{
if(nCodePage != CP_UTF8)
nCodePage = CodePage;
}
//============================ CRTFRead Class ==================================
/*
* CRTFRead::CRTFRead(prg, pes, dwFlags)
*
* @mfunc
* Constructor for RTF reader
*/
CRTFRead::CRTFRead (
CTxtRange * prg, //@parm CTxtRange to read into
EDITSTREAM * pes, //@parm Edit stream to read from
DWORD dwFlags //@parm Read flags
)
: CRTFConverter(prg, pes, dwFlags, TRUE)
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::CRTFRead");
Assert(prg->GetCch() == 0);
//TODO(BradO): We should examine the member data in the constructor
// and determine which data we want initialized on construction and
// which at the beginning of every read (in CRTFRead::ReadRtf()).
_sDefaultFont = -1; // No \deff n control word yet
_sDefaultLanguage = INVALID_LANGUAGE;
_sDefaultLanguageFE = INVALID_LANGUAGE;
_sDefaultTabWidth = 0;
_sDefaultBiDiFont = -1;
_dwMaskCF = 0; // No char format changes yet
_dwMaskCF2 = 0;
_dwMaskPF = 0; // No char format changes yet
_dwMaskPF2 = 0; // No char format changes yet
_fSeenFontTable = FALSE; // No \fonttbl yet
_fCharSet = FALSE; // No \fcharset yet
_fNon0CharSet = FALSE; // No nonANSI_CHARSET \fcharset yet
_dwFlagsUnion = 0; // No flags yet
_fNotifyLowFiRTF = (_ped->_dwEventMask & ENM_LOWFIRTF) != 0;
_fBody = FALSE; // Wait till something's inserted
_pes->dwError = 0; // No error yet
_cchUsedNumText = 0; // No numbering text yet
_cTab = 0;
_pstateStackTop = NULL;
_pstateLast = NULL;
_szText =
_pchRTFBuffer = // No input buffer yet
_pchRTFCurrent =
_pchRTFEnd = NULL;
_prtfObject = NULL;
_pcpObPos = NULL;
_bTabLeader = 0;
_bTabType = 0;
_bShapeNameIndex = 0;
_pobj = 0;
_fSymbolField = FALSE;
_fMac = FALSE;
_fNo_iTabsTable = FALSE;
_fRTLRow = FALSE;
_dwRowResolveFlags = 0;
_bTableLevelIP = 0;
_iTabsLevel1 = -1;
InitializeTableRowParms(); // Initialize table parms
// Does story size exceed the maximum text size? Be very careful to
// use unsigned comparisons here since _cchMax has to be unsigned
// (EM_LIMITTEXT allows 0xFFFFFFFF to be a large positive maximum
// value). I.e., don't use signed arithmetic.
DWORD cchAdj = _ped->GetAdjustedTextLength();
_cchMax = _ped->TxGetMaxLength();
if(_cchMax > cchAdj)
_cchMax = _cchMax - cchAdj; // Room left
else
_cchMax = 0; // No room left
ZeroMemory(_rgStyles, sizeof(_rgStyles)); // No style levels yet
_iCharRepBiDi = 0;
if(_ped->IsBiDi())
{
_iCharRepBiDi = ARABIC_INDEX; // Default Arabic charset
BYTE iCharRep;
CFormatRunPtr rpCF(prg->_rpCF);
// Look backward in text, trying to find a RTL CharRep.
// NB: \fN with an RTL charset updates _iCharRepBiDi.
do
{
iCharRep = _ped->GetCharFormat(rpCF.GetFormat())->_iCharRep;
if(IsRTLCharRep(iCharRep))
{
_iCharRepBiDi = iCharRep;
break;
}
} while (rpCF.PrevRun());
}
// Initialize OleStream
RTFReadOLEStream.Reader = this;
RTFReadOLEStream.lpstbl->Get = (DWORD (CALLBACK*)(LPOLESTREAM, void *, DWORD))
RTFGetFromStream;
RTFReadOLEStream.lpstbl->Put = NULL;
#if defined(DEBUG) && !defined(NOFULLDEBUG)
_fTestingParserCoverage = FALSE;
_prtflg = NULL;
if(GetProfileIntA("RICHEDIT DEBUG", "RTFLOG", 0))
{
_prtflg = new CRTFLog;
if(_prtflg && !_prtflg->FInit())
{
delete _prtflg;
_prtflg = NULL;
}
AssertSz(_prtflg, "CRTFRead::CRTFRead: Error creating RTF log");
}
#endif // DEBUG
}
/*
* CRTFRead::HandleStartGroup()
*
* @mfunc
* Handle start of new group. Alloc and push new state onto state
* stack
*
* @rdesc
* EC The error code
*/
EC CRTFRead::HandleStartGroup()
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::HandleStartGroup");
STATE * pstate = _pstateStackTop;
STATE * pstateNext = NULL;
if(pstate) // At least one STATE already
{ // allocated
Apply_CF(); // Apply any collected char
// Note (igorzv) we don't Apply_PF() here so as not to change para
// properties before we run into \par i.e. not to use paragraph
// properties if we copy only one word from paragraph. We can use an
// assertion here that neither we nor Word use end of group for
// restoring paragraph properties. So everything will be OK with stack
pstate->iCF = (SHORT)_prg->Get_iCF(); // Save current CF
pstate = pstate->pstateNext; // Use previously allocated
if(pstate) // STATE frame if it exists
pstateNext = pstate->pstateNext; // It does; save its forward
} // link for restoration below
if(!pstate) // No new STATE yet: alloc one
{
pstate = new STATE();
if(!pstate) // Couldn't alloc new STATE
goto memerror;
_pstateLast = pstate; // Update ptr to last STATE
} // alloc'd
STATE *pstateGetsPF;
// Apply the accumulated PF delta's to the old current state or, if there
// is no current state, to the newly created state.
pstateGetsPF = _pstateStackTop ? _pstateStackTop : pstate;
if(!pstateGetsPF->AddPF(_PF, _bDocType, _dwMaskPF, _dwMaskPF2))
goto memerror;
_dwMaskPF = _dwMaskPF2 = 0; // _PF contains delta's from
// *_pstateStackTop->pPF
if(_pstateStackTop) // There's a previous STATE
{
*pstate = *_pstateStackTop; // Copy current state info
// N.B. This will cause the current and previous state to share
// the same PF. PF delta's are accumulated in _PF. A new PF
// is created for _pstateStackTop when the _PF deltas are applied.
_pstateStackTop->pstateNext = pstate;
}
else // Setup default for first state
{
pstate->nCodePage = IsUTF8 ? CP_UTF8 : _nCodePage;
for(LONG i = ARRAY_SIZE(pstate->rgDefFont); i--; )
pstate->rgDefFont[i].sHandle = -1; // Default undefined associate
}
pstate->pstatePrev = _pstateStackTop; // Link STATEs both ways
pstate->pstateNext = pstateNext;
_pstateStackTop = pstate; // Push stack
done:
TRACEERRSZSC("HandleStartGroup()", -_ecParseError);
return _ecParseError;
memerror:
_ped->GetCallMgr()->SetOutOfMemory();
_ecParseError = ecStackOverflow;
goto done;
}
/*
* CRTFRead::HandleEndGroup()
*
* @mfunc
* Handle end of new group
*
* @rdesc
* EC The error code
*/
EC CRTFRead::HandleEndGroup()
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::HandleEndGroup");
STATE * pstate = _pstateStackTop;
STATE * pstatePrev;
Assert(_PF._iTabs == -1);
if(!pstate) // No stack to pop
{
_ecParseError = ecStackUnderflow;
goto done;
}
_pstateStackTop = // Pop stack
pstatePrev = pstate->pstatePrev;
if(!pstatePrev)
{
Assert(pstate->pPF);
// We're ending the parse. Copy the final PF into _PF so that
// subsequent calls to Apply_PF will have a PF to apply.
_PF = *pstate->pPF;
//TODO honwch _dwMaskPF = pstate->dwMaskPF;
_PF._iTabs = -1; // Force recache
_PF._wEffects &= ~PFE_TABLE;
}
// Adjust the PF for the new _pstateStackTop and delete unused PF's.
if(pstate->sDest == destParaNumbering || pstate->sDest == destParaNumText)
{
if(pstatePrev && pstate->pPF != pstatePrev->pPF)
{
// Bleed the PF of the current state into the previous state for
// paragraph numbering groups
Assert(pstatePrev->pPF);
pstatePrev->DeletePF();
pstatePrev->pPF = pstate->pPF;
pstate->pPF = NULL;
}
else
pstate->DeletePF();
// N.B. Here, we retain the _PF diffs since they apply to the
// enclosing group along with the PF of the group we are leaving
}
else
{
// We're popping the state, so delete its PF and discard the _PF diffs
Assert(pstate->pPF);
pstate->DeletePF();
// If !pstatePrev, we're ending the parse, in which case the _PF
// structure contains final PF (so don't toast it).
if(pstatePrev)
_dwMaskPF = _dwMaskPF2 = 0;
}
if(pstatePrev)
{
LONG i;
_dwMaskCF = _dwMaskCF2 = 0; // Discard any CF deltas
switch(pstate->sDest)
{
case destParaNumbering:
// {\pn ...}
pstatePrev->sIndentNumbering = pstate->sIndentNumbering;
pstatePrev->fBullet = pstate->fBullet;
break;
case destObject:
// Clear our object flags just in case we have corrupt RTF
if(_fNeedPres)
{
_fNeedPres = FALSE;
_fNeedIcon = FALSE;
_pobj = NULL;
}
break;
case destFontTable:
if(pstatePrev->sDest == destFontTable)
{
// Leaving subgroup within \fonttbl group
break;
}
// Leaving {\fonttbl...} group
_fSeenFontTable = TRUE;
// Default font should now be defined, so select it (this
// creates CF deltas).
SetPlain(pstate);
if(_sDefaultFont != -1)
{
pstate->rgDefFont[DEFFONT_LTRCH].sHandle = _sDefaultFont;
Assert(pstate->pstatePrev);
if (pstate->pstatePrev)
{
pstate->pstatePrev->rgDefFont[DEFFONT_LTRCH].sHandle = _sDefaultFont;
Assert(pstate->pstatePrev->pstatePrev == NULL);
}
}
if(_sDefaultBiDiFont != -1)
{
// Validate default BiDi font since Word 2000 may choose
// a nonBiDi font
i = _fonts.Count();
TEXTFONT *ptf = _fonts.Elem(0);
for(; i-- && _sDefaultBiDiFont != ptf->sHandle; ptf++)
;
if(i < 0 || !IsRTLCharRep(ptf->iCharRep))
{
_sDefaultBiDiFont = -1;
// Bad DefaultBiDiFont, find the first good bidi font
i = _fonts.Count();
ptf = _fonts.Elem(0);
for (; i--; ptf++)
{
if (IsRTLCharRep(ptf->iCharRep))
{
_sDefaultBiDiFont = ptf->sHandle;
break;
}
}
}
if(_sDefaultBiDiFont != -1)
{
pstate->rgDefFont[DEFFONT_RTLCH].sHandle = _sDefaultBiDiFont;
Assert(pstate->pstatePrev);
if (pstate->pstatePrev)
{
pstate->pstatePrev->rgDefFont[DEFFONT_RTLCH].sHandle = _sDefaultBiDiFont;
Assert(pstate->pstatePrev->pstatePrev == NULL);
}
}
}
// Ensure that a document-level codepage has been determined and
// then scan the font names and retry the conversion to Unicode,
// if necessary.
if(_nCodePage == INVALID_CODEPAGE)
{
// We haven't determined a document-level codepage
// from the \ansicpgN tag, nor from the font table
// \fcharsetN and \cpgN values. As a last resort,
// let's use the \deflangN and \deflangfeN tags
LANGID langid;
if(_sDefaultLanguageFE != INVALID_LANGUAGE)
langid = _sDefaultLanguageFE;
else if(_sDefaultLanguage != INVALID_LANGUAGE &&
_sDefaultLanguage != sLanguageEnglishUS)
{
// _sDefaultLanguage == sLanguageEnglishUS is inreliable
// in the absence of \deflangfeN. Many FE RTF writers
// write \deflang1033 (sLanguageEnglishUS).
langid = _sDefaultLanguage;
}
else if(_dwFlags & SFF_SELECTION)
{
// For copy/paste case, if nothing available, try the system
// default langid. This is to fix FE Excel95 problem.
langid = GetSystemDefaultLangID();
}
else
goto NoLanguageInfo;
_nCodePage = CodePageFromCharRep(CharRepFromLID(langid));
}
NoLanguageInfo:
if(_nCodePage == INVALID_CODEPAGE)
break;
// Fixup misconverted font face names
for(i = 0; i < _fonts.Count(); i++)
{
TEXTFONT *ptf = _fonts.Elem(i);
if (ptf->sCodePage == INVALID_CODEPAGE ||
ptf->sCodePage == CP_SYMBOL)
{
if(ptf->fNameIsDBCS)
{
char szaTemp[LF_FACESIZE];
BOOL fMissingCodePage;
// Unconvert misconverted face name
SideAssert(WCTMB(ptf->sCodePage, 0,
ptf->szName, -1,
szaTemp, sizeof(szaTemp),
NULL, NULL, &fMissingCodePage) > 0);
Assert(ptf->sCodePage == CP_SYMBOL ||
fMissingCodePage);
// Reconvert face name using new codepage info
SideAssert(MBTWC(_nCodePage, 0,
szaTemp, -1,
ptf->szName, sizeof(ptf->szName),
&fMissingCodePage) > 0);
if(!fMissingCodePage)
ptf->fNameIsDBCS = FALSE;
}
}
}
break;
}
_prg->Set_iCF(pstatePrev->iCF); // Restore previous CharFormat
ReleaseFormats(pstatePrev->iCF, -1);
}
done:
TRACEERRSZSC("HandleEndGroup()", - _ecParseError);
return _ecParseError;
}
/*
* CRTFRead::HandleFieldEndGroup()
*
* @mfunc
* Handle end of \field
*/
//FUTURE (keithcu) If I knew the first thing about RTF, I'd cleanup the symbol handling.
void CRTFRead::HandleFieldEndGroup()
{
STATE * pstate = _pstateStackTop;
if (!IN_RANGE(destField, pstate->sDest, destFieldInstruction) ||
pstate->sDest != destField && !_ecParseError)
{
return;
}
// For SYMBOLS
if(_fSymbolField)
{
_fSymbolField = FALSE;
return;
}
// Walk backwards, removing the STARTFIELD and SEPARATOR character.
// Make the instruction field hidden, and mark the whole range
// with CFE_LINK | CFE_LINKPROTECTED so that our automatic URL
// detection code doesn't get in the way and remove this stuff.
// If it is not a hyperlink field, delete fldinst.
CTxtRange rg(*_prg);
long cchInst = -2, cchResult = -2;
WCHAR ch, chNext = 0;
// LONG cpSave = _prg->GetCp();
rg.SetIgnoreFormatUpdate(TRUE);
// Find boundary between instruction and result field
while(!IN_RANGE(STARTFIELD, (ch = rg._rpTX.GetChar()), SEPARATOR) || chNext != 'F')
{
if(!rg.Move(-1, FALSE))
return; // Nothing to fixup
cchResult++;
chNext = ch;
}
if (ch == SEPARATOR)
{
rg.Move(2, TRUE);
rg.ReplaceRange(0, NULL, NULL, SELRR_IGNORE, NULL, RR_NO_LP_CHECK);
}
else //No field result
{
cchInst = cchResult;
cchResult = 0;
}
BOOL fBackSlash = FALSE;
chNext = 0;
while((ch = rg.CRchTxtPtr::GetChar()) != STARTFIELD || chNext != 'F')
{
if(ch == BSLASH)
fBackSlash = TRUE; // Need backslash pass
if(!rg.Move(-1, FALSE))
return; // Nothing to fix up
cchInst++;
chNext = ch;
}
rg.Move(_ecParseError ? tomForward : 2, TRUE);
rg.ReplaceRange(0, NULL, NULL, SELRR_IGNORE, NULL, RR_NO_LP_CHECK);
if(_ecParseError)
return;
// If it's a hyperlink field, set properties, else, delete fldinst
CTxtPtr tp(rg._rpTX);
if(tp.FindText(rg.GetCp() + cchInst, FR_DOWN, L"HYPERLINK", 9) != -1)
{
while((ch = tp.GetChar()) == ' ' || ch == '\"')
tp.Move(1);
ch = tp.GetPrevChar();
if(ch == '\"' && fBackSlash) // Word quadruples backslash, so
{ // need to delete every other one
LONG cp0 = rg.GetCp(); // Save cp at start of instruction
LONG cp1 = tp.GetCp(); // Save cp at start of URL
LONG cpMax = cp0 + cchInst; // Max cp for the instruction
rg.SetCp(cp1, FALSE);
while(rg.GetCp() < cpMax)
{
ch = rg._rpTX.GetChar();
if(ch == '\"')
break;
if(ch == BSLASH)
{
if (!rg.Move(1, TRUE))
break;
ch = rg._rpTX.GetChar();
if(ch == '\"')
break;
if(ch == BSLASH)
{
cchInst--;
rg.ReplaceRange(0, NULL, NULL, SELRR_IGNORE, NULL, RR_NO_LP_CHECK);
}
}
if (!rg.Move(1, FALSE))
break;
}
rg.SetCp(cp0, FALSE); // Restore rg and tp
tp = rg._rpTX; // Rebind tp, since deletions may
tp.SetCp(cp1); // change plain-text arrays
}
CCharFormat CF;
DWORD dwMask, dwMask2;
LONG cch1 = 0;
CTxtPtr tp1(_prg->_rpTX);
tp1.Move(-cchResult); // Point at start of link result
for(LONG cch = cchResult; cch; cch--)
{
DWORD ch1 = tp.GetChar();
if(ch1 != tp1.GetChar())
break;
if(ch1 == ' ')
cch1 = 1;
tp.Move(1); // This could be much
tp1.Move(1); // faster if it matters
}
if(!cch && tp.GetChar() == ch) // Perfect match, so delete
{ // instruction and use built-in
WCHAR chLeftBracket = '<'; // RichEdit URLs. Store autocolor
rg.Move(cchInst, TRUE); // and no underlining
rg.ReplaceRange(cch1, &chLeftBracket, NULL, SELRR_IGNORE, NULL, RR_NO_LP_CHECK);
CF._dwEffects = CFE_LINK | CFE_AUTOCOLOR;
CF._crTextColor = 0; // Won't be used but will be stored
dwMask = CFM_LINK | CFM_COLOR | CFM_UNDERLINE;
dwMask2 = 0;
if(cch1)
{
WCHAR chRightBracket = '>';
_prg->ReplaceRange(cch1, &chRightBracket, NULL, SELRR_IGNORE, NULL, RR_NO_LP_CHECK);
}
}
else
{
rg.Move(cchInst, TRUE); // Set properties on instruction
CF._dwEffects = CFE_HIDDEN | CFE_LINK | CFE_LINKPROTECTED ;
rg.SetCharFormat(&CF, 0, 0, CFM_LINK | CFM_HIDDEN, CFM2_LINKPROTECTED);
dwMask = CFM_LINK;
dwMask2 = CFM2_LINKPROTECTED;
}
rg.Set(rg.GetCp(), -cchResult); // Set properties on result
rg.SetCharFormat(&CF, 0, 0, dwMask, dwMask2);
}
else
{
_iKeyword = i_field; // Might be nice to have field name
if((tp.GetChar() | 0x20) == 'e') // Only fire notification for EQ fields
{
tp.Move(1);
if((tp.GetChar() | 0x20) == 'q')
{
CheckNotifyLowFiRTF(TRUE);
if(HandleEq(rg, tp) == ecNoError)
return;
}
}
rg.Move(cchInst, TRUE);
rg.ReplaceRange(0, NULL, NULL, SELRR_IGNORE, NULL, RR_NO_LP_CHECK);
}
// if(_cpThisPara > rg.GetCp()) // Field result had \par's, so
// _cpThisPara -= cpSave - _prg->GetCp();// subtract cch deleted
}
/*
* CRTFRead::SelectCurrentFont(iFont)
*
* @mfunc
* Set active font to that with index <p iFont>. Take into account
* bad font numbers.
*/
void CRTFRead::SelectCurrentFont(
INT iFont) //@parm Font handle of font to select
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::SelectCurrentFont");
LONG i = _fonts.Count();
STATE * pstate = _pstateStackTop;
TEXTFONT * ptf = _fonts.Elem(0);
AssertSz(i, "CRTFRead::SelectCurrentFont: bad font collection");
for(; i-- && iFont != ptf->sHandle; ptf++) // Search for font with handle
; // iFont
// Font handle not found: use default, which is valid
// since \rtf copied _prg's
if(i < 0)
ptf = _fonts.Elem(0);
BOOL fDefFontFromSystem = (i == (LONG)_fonts.Count() - 1 || i < 0) &&
!_fReadDefFont;
_CF._iFont = GetFontNameIndex(ptf->szName);
_dwMaskCF2 |= CFM2_FACENAMEISDBCS;
_CF._dwEffects &= ~CFE_FACENAMEISDBCS;
if(ptf->fNameIsDBCS)
_CF._dwEffects |= CFE_FACENAMEISDBCS;
if(pstate->sDest != destFontTable)
{
_CF._iCharRep = ptf->iCharRep;
_CF._bPitchAndFamily = ptf->bPitchAndFamily;
_dwMaskCF |= CFM_FACE | CFM_CHARSET;
if (IsRTLCharRep(_CF._iCharRep) && ptf->sCodePage == 1252)
ptf->sCodePage = (SHORT)CodePageFromCharRep(_CF._iCharRep); // Fix sCodePage to match charset
}
if (_ped->Get10Mode() && !_fSeenFontTable &&
_nCodePage == INVALID_CODEPAGE && ptf->sCodePage == 1252)
{
if (W32->IsFECodePage(GetACP()))
_nCodePage = GetACP();
}
// Ensure that the state's codepage is not supplied by the system.
// That is, if we are using the codepage info from the default font,
// be sure that the default font info was read from the RTF file.
pstate->SetCodePage((fDefFontFromSystem && _nCodePage != INVALID_CODEPAGE) ||
ptf->sCodePage == INVALID_CODEPAGE
? _nCodePage : ptf->sCodePage);
pstate->ptf = ptf;
}
/*
* CRTFRead::SetPlain(pstate)
*
* @mfunc
* Setup _CF for \plain
*/
void CRTFRead::SetPlain(
STATE *pstate)
{
ZeroMemory(&_CF, sizeof(CCharFormat));
_dwMaskCF = CFM_ALL2;
_dwMaskCF2 = CFM2_LINKPROTECTED;
if(_dwFlags & SFF_SELECTION && _prg->GetCp() == _cpFirst && !_fCharSet)
{
// Let NT 4.0 CharMap use insertion point size
_CF._yHeight = _ped->GetCharFormat(_prg->Get_iFormat())->_yHeight;
}
else
_CF._yHeight = PointsToFontHeight(yDefaultFontSize);
_CF._dwEffects = CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR; // Set default effects
if(_sDefaultLanguage == INVALID_LANGUAGE)
_dwMaskCF &= ~CFM_LCID;
else
_CF._lcid = MAKELCID((WORD)_sDefaultLanguage, SORT_DEFAULT);
_CF._bUnderlineType = CFU_UNDERLINE;
SelectCurrentFont(_sDefaultFont);
}
/*
* CRTFRead::ReadFontName(pstate, iAllASCII)
*
* @mfunc
* read font name _szText into <p pstate>->ptf->szName and deal with
* tagged fonts
*/
void CRTFRead::ReadFontName(
STATE * pstate, //@parm state whose font name is to be read into
int iAllASCII) //@parm indicates that _szText is all ASCII chars
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::ReadFontName");
if (pstate->ptf)
{
INT cchName = LF_FACESIZE - 1;
WCHAR * pchDst = pstate->ptf->szName;
char * pachName = (char *)_szText ;
// Append additional text from _szText to TEXTFONT::szName
// We need to append here since some RTF writers decide
// to break up a font name with other RTF groups
while(*pchDst && cchName > 0)
{
pchDst++;
cchName--;
}
if(!cchName) // Probably illegal file
{ // e.g., extra {
_ecParseError = ecFontTableOverflow;
return;
}
INT cchLimit = cchName;
BOOL fTaggedName = FALSE;
while (*pachName &&
*pachName != ';' &&
cchLimit) // Remove semicolons
{
pachName++;
cchLimit--;
if (*pachName == '(')
fTaggedName = TRUE;
}
*pachName = '\0';
// Use the codepage of the font in all cases except where the font uses
// the symbol charset (and the codepage has been mapped from the charset)
// and UTF-8 isn't being used
LONG nCodePage = pstate->nCodePage != CP_SYMBOL
? pstate->nCodePage : _nCodePage;
BOOL fMissingCodePage;
Assert(!IsUTF8 || nCodePage == CP_UTF8);
INT cch = MBTWC(nCodePage, 0,
(char *)_szText, -1,
pchDst, cchName, &fMissingCodePage);
if(cch > 0 && fMissingCodePage && iAllASCII == CONTAINS_NONASCII)
pstate->ptf->fNameIsDBCS = TRUE;
else if(pstate->ptf->iCharRep == DEFAULT_INDEX &&
W32->IsFECodePage(nCodePage) &&
GetTrailBytesCount(*_szText, nCodePage))
pstate->ptf->iCharRep = CharRepFromCodePage(nCodePage); // Fix up charset
// Make sure destination is null terminated
if(cch > 0)
pchDst[cch] = 0;
// Fall through even if MBTWC <= 0, since we may be appending text to an
// existing font name.
if(pstate->ptf == _fonts.Elem(0)) // If it's the default font,
SelectCurrentFont(_sDefaultFont); // update _CF accordingly
WCHAR * szNormalName;
if(pstate->ptf->iCharRep && pstate->fRealFontName)
{
// if we don't know about this font don't use the real name
if(!FindTaggedFont(pstate->ptf->szName,
pstate->ptf->iCharRep, &szNormalName))
{
pstate->fRealFontName = FALSE;
pstate->ptf->szName[0] = 0;
}
}
else if(IsTaggedFont(pstate->ptf->szName,
&pstate->ptf->iCharRep, &szNormalName))
{
wcscpy(pstate->ptf->szName, szNormalName);
pstate->ptf->sCodePage = (SHORT)CodePageFromCharRep(pstate->ptf->iCharRep);
pstate->SetCodePage(pstate->ptf->sCodePage);
}
else if(fTaggedName && !fMissingCodePage)
{
HDC hDC = W32->GetScreenDC();
if (!W32->IsFontAvail( hDC, 0, 0, NULL, pstate->ptf->szName))
{
// Fix up tagged name by removing characters after the ' ('
INT i = 0;
WCHAR *pwchTag = pstate->ptf->szName;
while (pwchTag[i] && pwchTag[i] != L'(') // Search for '('
i++;
if(pwchTag[i] && i > 0)
{
while (i > 0 && pwchTag[i-1] == 0x20) // Remove spaces before the '('
i--;
pwchTag[i] = 0;
}
}
}
}
}
/*
* CRTFRead::GetColor (dwMask)
*
* @mfunc
* Store the autocolor or autobackcolor effect bit and return the
* COLORREF for color _iParam
*
* @rdesc
* COLORREF for color _iParam
*
* @devnote
* If the entry in _colors corresponds to tomAutoColor, gets the value
* RGB(0,0,0) (since no \red, \green, and \blue fields are used), but
* isn't used by the RichEdit engine. Entry 1 corresponds to the first
* explicit entry in the \colortbl and is usually RGB(0,0,0). The _colors
* table is built by HandleToken() when it handles the token tokenText
* for text consisting of a ';' for a destination destColorTable.
*/
COLORREF CRTFRead::GetColor(
DWORD dwMask) //@parm Color mask bit
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::GetColor");
if(_iParam < 0 || _iParam >= _colors.Count()) // Illegal _iParam
return RGB(0,0,0);
COLORREF Color = *_colors.Elem(_iParam);
if(dwMask)
{
_dwMaskCF |= dwMask; // Turn on appropriate mask bit
_CF._dwEffects &= ~dwMask; // auto(back)color off: color is to be used
if(Color == tomAutoColor)
{
_CF._dwEffects |= dwMask; // auto(back)color on
Color = RGB(0,0,0);
}
}
return Color;
}
/*
* CRTFRead::GetStandardColorIndex ()
*
* @mfunc
* Return the color index into the standard 16-entry Word \colortbl
* corresponding to the color index _iParam for the current \colortbl
*
* @rdesc
* Standard color index corresponding to the color associated with _iParam
*/
LONG CRTFRead::GetStandardColorIndex()
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::GetColorIndex");
if(_iParam < 0 || _iParam >= _colors.Count()) // Illegal _iParam:
return 0; // use autocolor
COLORREF Color = *_colors.Elem(_iParam);
for(LONG i = 0; i < 16; i++)
{
if(Color == g_Colors[i])
return i + 1;
}
return 0; // Not there: use autocolor
}
/*
* CRTFRead::GetCellColorIndex ()
*
* @mfunc
* Return the color index into the standard 16-entry Word \colortbl
* corresponding to the color index _iParam for the current \colortbl.
* If color isn't found, use _crCellCustom1 or _crCellCustom2.
*
* @rdesc
* Standard or custom color index corresponding to the color associated
* with _iParam
*/
LONG CRTFRead::GetCellColorIndex()
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::GetColorIndex");
LONG i = GetStandardColorIndex(); // 16 standard colors (1 - 16)
if(i || _iParam >= _colors.Count() || _iParam < 0) // plus autocolor (0)
return i;
COLORREF Color = *_colors.Elem(_iParam);// Not there: try using custom colors
if(!_crCellCustom1 || Color == _crCellCustom1)
{
_crCellCustom1 = Color; // First custom cr
return 17;
}
if(!_crCellCustom2 || Color == _crCellCustom2)
{
_crCellCustom2 = Color; // Second custom cr
return 18;
}
return 0; // No custom cr available
}
/*
* CRTFRead::HandleEq(&rg, &tp)
*
* @mfunc
* Handle Word EQ field
*
* @rdesc
* EC The error code
*/
EC CRTFRead::HandleEq(
CTxtRange & rg, //@parm Range to use
CTxtPtr & tp) //@parm TxtPtr to use
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::HandleEq");
#if 0
while(tp.GetCp() < _prg->GetCp())
{
}
#endif
return ecGeneralFailure; // Not yet implemented, but don't set _ecParseError
}
/*
* CRTFRead::HandleCell()
*
* @mfunc
* Handle \cell command
*
* @rdesc
* EC The error code
*/
void CRTFRead::HandleCell()
{
if(!_bTableLevel)
{
if(!_fStartRow)
return;
DelimitRow(szRowStart); // \cell directly follows \row
}
if(_bTableLevel + _bTableLevelIP > MAXTABLENEST)
{
_iCell++;
HandleChar(TAB);
return;
}
LONG cCell = _cCell;
CTabs * pTabs = NULL;
CELLPARMS *pCellParms = NULL;
if(_bTableLevel == 1 && _iTabsLevel1 >= 0 && !_fNo_iTabsTable)
{
pTabs = GetTabsCache()->Elem(_iTabsLevel1);
pCellParms = (CELLPARMS *)(pTabs->_prgxTabs);
cCell = pTabs->_cTab/(CELL_EXTRA + 1);
}
if(!cCell) // _rgxCell has no cell defs
{
if(_iTabsTable < 0) // No cells defined yet
{
_iCell++; // Count cells inserted
HandleEndOfPara(); // Insert cell delimiter
return;
}
// Use previous table defs
Assert(_bTableLevel == 1 && !_fNo_iTabsTable);
pTabs = GetTabsCache()->Elem(_iTabsTable);
cCell = pTabs->_cTab/(CELL_EXTRA + 1);
}
if(_iCell < cCell) // Don't add more cells than
{ // defined, since Word crashes
if(pCellParms && IsLowCell(pCellParms[_iCell].uCell))
HandleChar(NOTACHAR); // Signal pseudo cell (\clvmrg)
_iCell++; // Count cells inserted
HandleEndOfPara(); // Insert cell delimiter
}
}
/*
* CRTFRead::HandleCellx(iParam)
*
* @mfunc
* Handle \cell command
*
* @rdesc
* EC The error code
*/
void CRTFRead::HandleCellx(
LONG iParam)
{
if(_cCell < MAX_TABLE_CELLS) // Save cell right boundaries
{
if(!_cCell)
{ // Save border info
_wBorders = _PF._wBorders;
_wBorderSpace = _PF._wBorderSpace;
_wBorderWidth = _PF._wBorderWidth;
_xCellPrev = _xRowOffset;
}
CELLPARMS *pCellParms = (CELLPARMS *)&_rgxCell[0];
// Store cell widths instead of right boundaries relative to \trleftN
LONG i = iParam - _xCellPrev;
i = max(i, 0);
i = min(i, 1440*22);
pCellParms[_cCell].uCell = i + (_bCellFlags << 24);
pCellParms[_cCell].dxBrdrWidths = _dwCellBrdrWdths;
pCellParms[_cCell].dwColors = _dwCellColors;
pCellParms[_cCell].bShading = (BYTE)min(200, _dwShading);
_dwCellColors = 0; // Default autocolor for next cell
_dwShading = 0;
_xCellPrev = iParam;
_cCell++;
_dwCellBrdrWdths = 0;
_bCellFlags = 0;
}
}
/*
* CRTFRead::HandleChar(ch)
*
* @mfunc
* Handle single Unicode character <p ch>
*
* @rdesc
* EC The error code
*/
EC CRTFRead::HandleChar(
WCHAR ch) //@parm char token to be handled
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::HandleChar");
if(!_ped->_pdp->IsMultiLine() && IsASCIIEOP(ch))
_ecParseError = ecTruncateAtCRLF;
else
{
AssertNr(ch <= 0x7F || ch > 0xFF || FTokIsSymbol(ch));
_dwMaskCF2 |= CFM2_RUNISDBCS;
_CF._dwEffects &= ~CFE_RUNISDBCS;
AddText(&ch, 1, CharGetsNumbering(ch));
}
TRACEERRSZSC("HandleChar()", - _ecParseError);
return _ecParseError;
}
/*
* CRTFRead::HandleEndOfPara()
*
* @mfunc
* Insert EOP and apply current paraformat
*
* @rdesc
* EC the error code
*/
EC CRTFRead::HandleEndOfPara()
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::HandleEndOfPara");
if(!_ped->_pdp->IsMultiLine()) // No EOPs permitted in single-
{ // line controls
Apply_PF(); // Apply any paragraph formatting
_ecParseError = ecTruncateAtCRLF; // Cause RTF reader to finish up
return ecTruncateAtCRLF;
}
Apply_CF(); // Apply _CF and save iCF, since
LONG iFormat = _prg->Get_iCF(); // it gets changed if processing
// CFE2_RUNISDBCS chars
EC ec;
if(IN_RANGE(tokenCell, _token, tokenNestCell) || _token == tokenRow)
ec = HandleChar((unsigned)CELL);
else
ec = _ped->fUseCRLF() // If RichEdit 1.0 compatibility
? HandleText(szaCRLF, ALL_ASCII) // mode, use CRLF; else CR or VT
: HandleChar((unsigned)(_token == tokenLineBreak ? VT :
_token == tokenPage ? FF : CR));
if(ec == ecNoError)
{
Apply_PF();
_cpThisPara = _prg->GetCp(); // New para starts after CRLF
}
_prg->Set_iCF(iFormat); // Restore iFormat if changed
ReleaseFormats(iFormat, -1); // Release iFormat (AddRef'd by
// Get_iCF())
return _ecParseError;
}
/*
* CRTFRead::HandleText(szText, iAllASCII)
*
* @mfunc
* Handle the string of Ansi characters <p szText>
*
* @rdesc
* EC The error code
*/
EC CRTFRead::HandleText(
BYTE * szText, //@parm string to be handled
int iAllASCII, //@parm enum indicating if string is all ASCII chars
LONG cchText) //@parm size of szText in bytes
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::HandleText");
LONG cch;
BOOL fStateChng = FALSE;
WCHAR * pch;
STATE * pstate = _pstateStackTop;
TEXTFONT * ptf = pstate->ptf;
struct TEXTFONTSAVE : TEXTFONT
{
TEXTFONTSAVE(TEXTFONT *ptf)
{
if (ptf)
{
iCharRep = ptf->iCharRep;
sCodePage = ptf->sCodePage;
fCpgFromSystem = ptf->fCpgFromSystem;
}
}
};
BOOL fAdjustPtf = FALSE;
if(IN_RANGE(DEFFONT_LTRCH, pstate->iDefFont, DEFFONT_RTLCH))
{
// CharSet resolution based on directional control words
BOOL frtlch = pstate->iDefFont == DEFFONT_RTLCH;
if(_CF._iCharRep == DEFAULT_INDEX)
{
_CF._iCharRep = (BYTE)(frtlch ? _iCharRepBiDi : ANSI_INDEX);
_dwMaskCF |= CFM_CHARSET;
fAdjustPtf = TRUE;
}
else
{
BOOL fBiDiCharRep = IsRTLCharRep(_CF._iCharRep);
// If direction token doesn't correspond to current charset
if(fBiDiCharRep ^ frtlch)
{
_dwMaskCF |= CFM_CHARSET;
fAdjustPtf = TRUE;
if(!fBiDiCharRep) // Wasn't BiDi, but is now
SelectCurrentFont(_sDefaultBiDiFont);
_CF._iCharRep = (BYTE)(frtlch ? _iCharRepBiDi : ANSI_INDEX);
}
else if (fBiDiCharRep && ptf && !W32->IsBiDiCodePage(ptf->sCodePage))
fAdjustPtf = TRUE;
}
}
else if(_ped->IsBiDi() && _CF._iCharRep == DEFAULT_INDEX)
{
_CF._iCharRep = ANSI_INDEX;
_dwMaskCF |= CFM_CHARSET;
fAdjustPtf = TRUE;
}
if (fAdjustPtf && ptf)
{
ptf->sCodePage = (SHORT)CodePageFromCharRep(_CF._iCharRep);
pstate->SetCodePage(ptf->sCodePage);
}
TEXTFONTSAVE tfSave(ptf);
// TODO: what if szText cuts off in middle of DBCS?
if(!*szText)
goto CleanUp;
if (cchText != -1 && _cchUnicode < cchText)
{
// Re-allocate a bigger buffer
_szUnicode = (WCHAR *)PvReAlloc(_szUnicode, (cchText + 1) * sizeof(WCHAR));
if(!_szUnicode) // Re-allocate space for Unicode conversions
{
_ped->GetCallMgr()->SetOutOfMemory();
_ecParseError = ecNoMemory;
goto CleanUp;
}
_cchUnicode = cchText + 1;
}
if(iAllASCII == ALL_ASCII || pstate->nCodePage == CP_SYMBOL)
{
// Don't use MBTWC() in cases where text contains
// only ASCII chars (which don't require conversion)
for(cch = 0, pch = _szUnicode; *szText; cch++)
{
Assert(*szText <= 0x7F || pstate->nCodePage == CP_SYMBOL);
*pch++ = (WCHAR)*szText++;
}
*pch = 0;
_dwMaskCF2 |= CFM2_RUNISDBCS;
_CF._dwEffects &= ~CFE_RUNISDBCS;
// Fall through to AddText at end of HandleText()
}
else
{
BOOL fMissingCodePage;
// Run of text contains bytes > 0x7F.
// Ensure that we have the correct codepage with which to interpret
// these (possibly DBCS) bytes.
if(ptf && ptf->sCodePage == INVALID_CODEPAGE && !ptf->fCpgFromSystem)
{
if(_dwFlags & SF_USECODEPAGE)
{
_CF._iCharRep = CharRepFromCodePage(_nCodePage);
_dwMaskCF |= CFM_CHARSET;
}
// Determine codepage from the font name
else if(CpgInfoFromFaceName(pstate->ptf))
{
fStateChng = TRUE;
SelectCurrentFont(pstate->ptf->sHandle);
Assert(ptf->sCodePage != INVALID_CODEPAGE && ptf->fCpgFromSystem);
}
else
{
// Here, we were not able to determine a cpg/charset value
// from the font name. We have two choices: (1) either choose
// some fallback value like 1252/0 or (2) rely on the
// document-level cpg value.
//
// I think choosing the document-level cpg value will give
// us the best results. In FE cases, it will likely err
// on the side of tagging too many runs as CFE2_RUNISDBCS, but
// that is safer than using a western cpg and potentially missing
// runs which should be CFE2_RUNISDBCS.
}
}
Assert(!IsUTF8 || pstate->nCodePage == CP_UTF8);
if (pstate->nCodePage == INVALID_CODEPAGE && ptf)
pstate->nCodePage = ptf->sCodePage;
cch = MBTWC(pstate->nCodePage, 0,
(char *)szText, -1,
_szUnicode, _cchUnicode, &fMissingCodePage);
AssertSz(cch > 0, "CRTFRead::HandleText(): MBTWC implementation changed"
" such that it returned a value <= 0");
if(!fMissingCodePage || !W32->IsFECodePage(pstate->nCodePage))
{
// Use result of MBTWC if:
// (1) we converted some chars and did the conversion with the codepage
// provided.
// (2) we converted some chars but couldn't use the codepage provided,
// but the codepage is invalid. Since the codepage is invalid,
// we can't do anything more sophisticated with the text before
// adding to the backing store
cch--; // don't want char count to including terminating NULL
_dwMaskCF2 |= CFM2_RUNISDBCS;
_CF._dwEffects &= ~CFE_RUNISDBCS;
if(pstate->nCodePage == INVALID_CODEPAGE)
_CF._dwEffects |= CFE_RUNISDBCS;
// fall through to AddText at end of HandleText()
}
else
{
// Conversion to Unicode failed. Break up the string of
// text into runs of ASCII and non-ASCII characters.
// FUTURE(BradO): Here, I am saving dwMask and restoring it before
// each AddText. I'm not sure this is neccessary. When I have
// the time, I should revisit this save/restoring and
// determine that it is indeed neccessary.
BOOL fPrevIsASCII = ((*szText <= 0x7F) ? TRUE : FALSE);
BOOL fCurrentIsASCII = FALSE;
BOOL fLastChunk = FALSE;
DWORD dwMaskSave = _dwMaskCF;
#if defined(DEBUG) || defined(_RELEASE_ASSERTS_)
CCharFormat CFSave = _CF;
#endif
pch = _szUnicode;
cch = 0;
// (!*szText && *pch) is the case where we do the AddText for the
// last chunk of text
while(*szText || fLastChunk)
{
// fCurrentIsASCII assumes that no byte <= 0x7F is a
// DBCS lead-byte
if(fLastChunk ||
(fPrevIsASCII != (fCurrentIsASCII = (*szText <= 0x7F))))
{
_dwMaskCF = dwMaskSave;
#if defined(DEBUG) || defined(_RELEASE_ASSERTS_)
_CF = CFSave;
#endif
*pch = 0;
_dwMaskCF2 |= CFM2_RUNISDBCS;
_CF._dwEffects |= CFE_RUNISDBCS;
if(fPrevIsASCII)
_CF._dwEffects &= ~CFE_RUNISDBCS;
Assert(cch);
pch = _szUnicode;
AddText(pch, cch, TRUE);
cch = 0;
fPrevIsASCII = fCurrentIsASCII;
// My assumption in saving _dwMaskCF is that the remainder
// of the _CF is unchanged by AddText. This assert verifies
// this assumption.
AssertSz(!CompareMemory(&CFSave._iCharRep, &_CF._iCharRep,
sizeof(CCharFormat) - sizeof(DWORD)) &&
!((CFSave._dwEffects ^ _CF._dwEffects) & ~CFE_RUNISDBCS),
"CRTFRead::HandleText(): AddText has been changed "
"and now alters the _CF structure.");
if(fLastChunk) // Last chunk of text was AddText'd
break;
}
// Not the last chunk of text.
Assert(*szText);
// Advance szText pointer
if (!fCurrentIsASCII && *(szText + 1) &&
GetTrailBytesCount(*szText, pstate->nCodePage))
{
// Current byte is a lead-byte of a DBCS character
*pch++ = *szText++;
++cch;
}
*pch++ = *szText++;
++cch;
// Must do an AddText for the last chunk of text
if(!*szText || cch >= _cchUnicode - 1)
fLastChunk = TRUE;
}
goto CleanUp;
}
}
if(cch > 0)
{
if(!_cCell || _iCell < _cCell)
AddText(_szUnicode, cch, TRUE);
if(fStateChng && ptf)
{
ptf->iCharRep = tfSave.iCharRep;
ptf->sCodePage = tfSave.sCodePage;
ptf->fCpgFromSystem = tfSave.fCpgFromSystem;
SelectCurrentFont(ptf->sHandle);
}
}
CleanUp:
TRACEERRSZSC("HandleText()", - _ecParseError);
return _ecParseError;
}
/*
* CRTFRead::HandleUN(pstate)
*
* @mfunc
* Handle run of Unicode characters given by \uN control words
*/
void CRTFRead::HandleUN(
STATE *pstate)
{
char ach = 0;
LONG cch = 0;
DWORD ch; // Treat as unsigned quantity
WCHAR * pch = _szUnicode;
_dwMaskCF2 |= CFM2_RUNISDBCS;
_CF._dwEffects &= ~CFE_RUNISDBCS;
do
{
if(_iParam < 0)
_iParam = (WORD)_iParam;
ch = _iParam;
if(pstate->ptf && pstate->ptf->iCharRep == SYMBOL_INDEX)
{
if(IN_RANGE(0xF000, ch, 0xF0FF))// Compensate for converters
ch -= 0xF000; // that write symbol codes
// up high
else if(ch > 255) // Whoops, RTF is using con-
{ // verted value for symbol:
char ach; // convert back
WCHAR wch = ch; // Avoid endian problems
WCTMB(1252, 0, &wch, 1, &ach, 1, NULL, NULL, NULL);
ch = (BYTE)ach; // Review: use CP_ACP??
}
}
if(IN_RANGE(0x10000, ch, 0x10FFFF)) // Higher-plane char:
{ // Store as Unicode surrogate
ch -= 0x10000; // pair
*pch++ = 0xD800 + (ch >> 10);
ch = 0xDC00 + (ch & 0x3FF);
cch++;
}
if(!IN_RANGE(STARTFIELD, ch, NOTACHAR) && // Don't insert 0xFFF9 - 0xFFFF
(!IN_RANGE(0xDC00, ch, 0xDFFF) || // or lone trail surrogate
IN_RANGE(0xD800, cch ? *(pch - 1) : _prg->GetPrevChar(), 0xDBFF)))
{
*pch++ = ch;
cch++;
}
for(LONG i = pstate->cbSkipForUnicodeMax; i--; )
GetCharEx(); // Eat the \uc N chars
ach = GetChar(); // Get next char
while(IsASCIIEOP(ach))
{
ach = GetChar();
if (_ecParseError != ecNoError)
return;
}
if(ach != BSLASH) // Not followed by \, so
{ // not by \uN either
UngetChar(); // Put back BSLASH
break;
}
ach = GetChar();
if((ach | ' ') != 'u')
{
UngetChar(2); // Not \u; put back \x
break;
}
GetParam(GetChar()); // \u so try for _iParam = N
if(!_fParam) // No \uN; put back \u
{
UngetChar(2);
break;
}
} while(cch < _cchUnicode - 2 && _iParam);
AddText(_szUnicode, cch, TRUE, TRUE);
}
/*
* CRTFRead::HandleNumber()
*
* @mfunc
* Insert the number _iParam as text. Useful as a workaround for
* Word RTF that leaves out the blank between \ltrch and a number.
*
* @rdesc
* EC The error code
*/
EC CRTFRead::HandleNumber()
{
if(!_fParam) // Nothing to do
return _ecParseError;
LONG n = _iParam;
BYTE *pch = _szText;
if(n < 0)
{
n = -n;
*pch++ = '-';
}
for(LONG d = 1; d < n; d *= 10) // d = smallest power of 10 > n
;
if(d > n)
d /= 10; // d = largest power of 10 < n
while(d)
{
*pch++ = (WORD)(n/d + '0'); // Store digit
n = n % d; // Setup remainder
d /= 10;
}
*pch = 0;
_token = tokenASCIIText;
HandleTextToken(_pstateStackTop);
return _ecParseError;
}
/*
* CRTFRead::HandleTextToken(pstate)
*
* @mfunc
* Handle tokenText
*
* @rdesc
* EC The error code
*/
EC CRTFRead::HandleTextToken(
STATE *pstate)
{
COLORREF *pclrf;
switch (pstate->sDest)
{
case destColorTable:
pclrf = _colors.Add(1, NULL);
if(!pclrf)
goto OutOfRAM;
*pclrf = _fGetColorYet ?
RGB(pstate->bRed, pstate->bGreen, pstate->bBlue) : tomAutoColor;
// Prepare for next color table entry
pstate->bRed =
pstate->bGreen =
pstate->bBlue = 0;
_fGetColorYet = FALSE; // in case more "empty" color
break;
case destFontTable:
if(!pstate->fRealFontName)
{
ReadFontName(pstate, _token == tokenASCIIText
? ALL_ASCII : CONTAINS_NONASCII);
}
break;
case destRealFontName:
{
STATE * const pstatePrev = pstate->pstatePrev;
if(pstatePrev && pstatePrev->sDest == destFontTable)
{
// Mark previous state so that tagged font name will be ignored
// AROO: Do this before calling ReadFontName so that
// AROO: it doesn't try to match font name
pstatePrev->fRealFontName = TRUE;
ReadFontName(pstatePrev,
_token == tokenASCIIText ? ALL_ASCII : CONTAINS_NONASCII);
}
break;
}
case destFieldInstruction:
HandleFieldInstruction();
break;
case destObjectClass:
if(StrAlloc(&_prtfObject->szClass, _szText))
goto OutOfRAM;
break;
case destObjectName:
if(StrAlloc(&_prtfObject->szName, _szText))
goto OutOfRAM;
break;
case destStyleSheet:
// _szText has style name, e.g., "heading 1"
if(W32->ASCIICompareI(_szText, (unsigned char *)"heading", 7))
{
DWORD dwT = (unsigned)(_szText[8] - '0');
if(dwT < NSTYLES)
_rgStyles[dwT] = (BYTE)_Style;
}
break;
case destShapeName:
if(pstate->fBackground)
{
TOKEN token = TokenFindKeyword(_szText, rgShapeKeyword, cShapeKeywords);
_bShapeNameIndex = (token != tokenUnknownKeyword) ? (BYTE)token : 0;
}
break;
case destShapeValue:
if(_bShapeNameIndex)
{
CDocInfo *pDocInfo = _ped->GetDocInfoNC();
BYTE *pch = _szText;
BOOL fNegative = FALSE;
if(*pch == '-')
{
fNegative = TRUE;
pch++;
}
for(_iParam = 0; IsDigit(*pch); pch++)
_iParam = _iParam*10 + *pch - '0';
if(fNegative)
_iParam = -_iParam;
switch(_bShapeNameIndex)
{
case shapeFillBackColor:
case shapeFillColor:
{
if(_iParam > 0xFFFFFF)
_iParam = 0;
if(_bShapeNameIndex == shapeFillColor)
pDocInfo->_crColor = (COLORREF)_iParam;
else
pDocInfo->_crBackColor = (COLORREF)_iParam;
if(pDocInfo->_nFillType == -1)
pDocInfo->_nFillType = 0;
break;
}
case shapeFillType:
// DEBUGGG: more general _nFillType commented out for now
// pDocInfo->_nFillType = _iParam;
if(pDocInfo->_nFillType)
CheckNotifyLowFiRTF(TRUE);
pDocInfo->_crColor = RGB(255, 255, 255);
pDocInfo->_crBackColor = RGB(255, 255, 255);
break;
case shapeFillAngle:
pDocInfo->_sFillAngle = HIWORD(_iParam);
break;
case shapeFillFocus:
pDocInfo->_bFillFocus = _iParam;
break;
}
}
break;
case destDocumentArea:
case destFollowingPunct:
case destLeadingPunct:
break;
// This has been changed now. We will store the Punct strings as
// raw text strings. So, we don't have to convert them.
// This code is keep here just in case we want to change back.
#if 0
case destDocumentArea:
if (_tokenLast != tokenFollowingPunct &&
_tokenLast != tokenLeadingPunct)
{
break;
} // Else fall thru to
// destFollowingPunct
case destFollowingPunct:
case destLeadingPunct:
// TODO(BradO): Consider some kind of merging heuristic when
// we paste FE RTF (for lead and follow chars, that is).
if(!(_dwFlags & SFF_SELECTION))
{
int cwch = MBTWC(INVALID_CODEPAGE, 0,
(char *)_szText, -1,
NULL, 0,
NULL);
Assert(cwch);
WCHAR *pwchBuf = (WCHAR *)PvAlloc(cwch * sizeof(WCHAR), GMEM_ZEROINIT);
if(!pwchBuf)
goto OutOfRAM;
SideAssert(MBTWC(INVALID_CODEPAGE, 0,
(char *)_szText, -1,
pwchBuf, cwch,
NULL) > 0);
if(pstate->sDest == destFollowingPunct)
_ped->SetFollowingPunct(pwchBuf);
else
{
Assert(pstate->sDest == destLeadingPunct);
_ped->SetLeadingPunct(pwchBuf);
}
FreePv(pwchBuf);
}
break;
#endif
default:
if(!IsLowMergedCell())
HandleText(_szText, _token == tokenASCIIText ? ALL_ASCII : CONTAINS_NONASCII);
}
return _ecParseError;
OutOfRAM:
_ped->GetCallMgr()->SetOutOfMemory();
_ecParseError = ecNoMemory;
return _ecParseError;
}
/*
* CRTFRead::AddText(pch, cch, fNumber, fUN)
*
* @mfunc
* Add <p cch> chars of the string <p pch> to the range _prg
*
* @rdesc
* error code placed in _ecParseError
*/
EC CRTFRead::AddText(
WCHAR * pch, //@parm Text to add
LONG cch, //@parm Count of chars to add
BOOL fNumber, //@parm Indicates whether or not to prepend numbering
BOOL fUN) //@parm TRUE means caller is \uN handler
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::AddText");
LONG cchAdded;
LONG cchT;
STATE * const pstate = _pstateStackTop;
WCHAR * szDest;
LONG cchMove;
// AROO: No saving state before this point (other than pstate)
// AROO: This would screw recursion below
//AssertSz(pstate, "CRTFRead::AddText: no state");
if((DWORD)cch > _cchMax)
{
cch = (LONG)_cchMax;
_ecParseError = ecTextMax;
if(*pch == STARTFIELD)
return ecTextMax; // Don't enter partial startfield
}
if(!cch)
return _ecParseError;
if(_fStartRow)
DelimitRow(szRowStart);
// FUTURE(BradO): This strategy for \pntext is prone to bugs, I believe.
// The recursive call to AddText to add the \pntext will trounce the
// accumulated _CF diffs associated with the text for which AddText is
// called. I believe we should save and restore _CF before and after
// the recursive call to AddText below. Also, it isn't sufficient to
// accumulate bits of \pntext as below, since each bit might be formatted
// with different _CF properties. Instead, we should accumulate a mini-doc
// complete with multiple text, char and para runs (or some stripped down
// version of this strategy).
if(pstate && pstate->sDest == destParaNumText && pch != szRowStart)
{
szDest = _szNumText + _cchUsedNumText;
cch = min(cch, cchMaxNumText - 1 - _cchUsedNumText);
if(cch > 0)
{
MoveMemory((BYTE *)szDest, (BYTE *)pch, cch*2);
szDest[cch] = TEXT('\0'); // HandleText() takes sz
_cchUsedNumText += cch;
}
return ecNoError;
}
if(pstate && _cchUsedNumText && fNumber) // Some \pntext available
{
// Bug 3496 - The fNumber flag is an ugly hack to work around RTF
// commonly written by Word. Often, to separate a numbered list
// by page breaks, Word will write:
// <NUMBERING INFO> \page <PARAGRAPH TEXT>
// The paragraph numbering should precede the paragraph text rather
// than the page break. The fNumber flag is set to FALSE when the
// the text being added should not be prepended with the para-numbering,
// as is the case with \page (mapped to FF).
cchT = _cchUsedNumText;
_cchUsedNumText = 0; // Prevent infinite recursion
if(!pstate->fBullet)
{
// If there are any _CF diffs to be injected, they will be trounced
// by this recursive call (see FUTURE comment above).
// Since we didn't save _CF data from calls to AddText with
// pstate->sDest == destParaNumText, we have no way of setting up
// CFE2_RUNISDBCS and CFM2_RUNISDBCS (see FUTURE comment above).
AddText(_szNumText, cchT, FALSE);
}
else if(_PF.IsListNumbered() && _szNumText[cchT - 1] == TAB)
{
AssertSz(cchT >= 1, "Invalid numbered text count");
if (cchT > 1)
{
WCHAR ch = _szNumText[cchT - 2];
_wNumberingStyle = (_wNumberingStyle & ~0x300)
| (ch == '.' ? PFNS_PERIOD :
ch != ')' ? PFNS_PLAIN :
_szNumText[0] == '(' ? PFNS_PARENS : PFNS_PAREN);
}
else
{
// There is only a tab so we will assume they meant to
// skip numbering.
_wNumberingStyle = PFNS_NONUMBER;
}
}
}
Apply_CF(); // Apply formatting changes in _CF
// CTxtRange::ReplaceRange will change the character formatting
// and possibly adjust the _rpCF forward if the current char
// formatting includes protection. The changes affected by
// CTxtRange::ReplaceRange are necessary only for non-streaming
// input, so we save state before and restore it after the call
// to CTxtRange::ReplaceRange
LONG iFormatSave = _prg->Get_iCF(); // Save state
QWORD qwFlags = GetCharFlags(pch, cch);
if(fUN && // \uN generated string
(!pstate->ptf || pstate->ptf->sCodePage == INVALID_CODEPAGE || qwFlags & FOTHER ||
(qwFlags & GetFontSignatureFromFace(_ped->GetCharFormat(iFormatSave)->_iFont)) != qwFlags &&
(!(qwFlags & (FARABIC | FHEBREW)) || _fNon0CharSet)))
{
// No charset info for \uN or current charset doesn't support char
cchAdded = _prg->CleanseAndReplaceRange(cch, pch, FALSE, NULL, pch);
}
else
{
cchAdded = _prg->ReplaceRange(cch, pch, NULL, SELRR_IGNORE, &cchMove,
RR_NO_LP_CHECK);
for(cchT = cch - 1; cchT; cchT--)
qwFlags |= GetCharFlags(++pch, cchT);// Note if ComplexScript
_ped->OrCharFlags(qwFlags);
}
_fBody = TRUE;
_prg->Set_iCF(iFormatSave); // Restore state
ReleaseFormats(iFormatSave, -1);
Assert(!_prg->GetCch());
if(cchAdded != cch)
{
Tracef(TRCSEVERR, "AddText(): Only added %d out of %d", cchAdded, cch);
_ecParseError = ecGeneralFailure;
if(cchAdded <= 0)
return _ecParseError;
}
_cchMax -= cchAdded;
return _ecParseError;
}
/*
* CRTFRead::Apply_CF()
*
* @mfunc
* Apply character formatting changes collected in _CF
*/
void CRTFRead::Apply_CF()
{
// If any CF changes, update range's _iFormat
if(_dwMaskCF || _dwMaskCF2)
{
AssertSz(_prg->GetCch() == 0,
"CRTFRead::Apply_CF: nondegenerate range");
_prg->SetCharFormat(&_CF, 0, NULL, _dwMaskCF, _dwMaskCF2);
_dwMaskCF = 0;
_dwMaskCF2 = 0;
}
}
/*
* CRTFRead::Apply_PF()
*
* @mfunc
* Apply paragraph format given by _PF
*
* @rdesc
* if table row delimiter with nonzero cell count, PF::_iTabs; else -1
*/
SHORT CRTFRead::Apply_PF()
{
LONG cp = _prg->GetCp();
DWORD dwMask = _dwMaskPF;
DWORD dwMask2 = _dwMaskPF2;
SHORT iTabs = -1;
CParaFormat *pPF = &_PF;
if(_pstateStackTop)
{
Assert(_pstateStackTop->pPF);
// Add PF diffs to *_pstateStackTop->pPF
if(!_pstateStackTop->AddPF(_PF, _bDocType, _dwMaskPF, _dwMaskPF2))
{
_ped->GetCallMgr()->SetOutOfMemory();
_ecParseError = ecNoMemory;
return -1;
}
_dwMaskPF = _dwMaskPF2 = 0; // _PF contains delta's from *_pstateStackTop->pPF
pPF = _pstateStackTop->pPF;
dwMask = _pstateStackTop->dwMaskPF;
Assert(dwMask == PFM_ALLRTF);
if(pPF->_wNumbering)
{
pPF->_wNumberingTab = _pstateStackTop->sIndentNumbering;
pPF->_wNumberingStyle = _wNumberingStyle;
}
if(_bTableLevelIP + _bTableLevel)
{
pPF->_wEffects |= PFE_TABLE;
dwMask |= PFM_TABLE;
pPF->_bTableLevel = min(_bTableLevel + _bTableLevelIP, MAXTABLENEST);
}
}
if(dwMask & PFM_TABSTOPS)
{
LONG cTab = _cTab;
BOOL fIsTableRowDelimiter = pPF->IsTableRowDelimiter();
const LONG *prgxTabs = &_rgxCell[0];
if(fIsTableRowDelimiter)
{
dwMask2 = PFM2_ALLOWTRDCHANGE;
if(!_cCell)
{
if(_iTabsTable >= 0) // No cells defined here;
{ // Use previous table defs
Assert(_bTableLevel == 1 && !_fNo_iTabsTable);
CTabs *pTabs = GetTabsCache()->Elem(_iTabsTable);
_cCell = pTabs->_cTab/(CELL_EXTRA + 1);
prgxTabs = pTabs->_prgxTabs;
}
else if(_prg->_rpTX.IsAfterTRD(ENDFIELD) && _iCell)
{
LONG x = 2000; // Bad RTF: no \cellx's. Def 'em
for(LONG i = 1; i <= _iCell; i++)
{
HandleCellx(x);
x += 2000;
}
}
}
cTab = _cCell;
}
// Caching a tabs array AddRefs the corresponding cached tabs entry.
// Be absolutely sure to release the entry before exiting the routine
// that caches it (see GetTabsCache()->Release at end of this function).
pPF->_bTabCount = cTab;
if(fIsTableRowDelimiter)
cTab *= CELL_EXTRA + 1;
pPF->_iTabs = GetTabsCache()->Cache(prgxTabs, cTab);
if(fIsTableRowDelimiter && _bTableLevel == 1)
{
iTabs = pPF->_iTabs;
if(!_fNo_iTabsTable)
_iTabsTable = pPF->_iTabs;
}
AssertSz(!cTab || pPF->_iTabs >= 0,
"CRTFRead::Apply_PF: illegal pPF->_iTabs");
}
LONG fCell = (_prg->GetPrevChar() == CELL);
LONG fIsAfterTRD = _prg->_rpTX.IsAfterTRD(0);
if(fCell || fIsAfterTRD) // Deal with table delimiters
{ // in hidden text and with
_prg->_rpCF.AdjustBackward(); // custom colors
if(_prg->IsHidden())
{ // Turn off hidden text
CCharFormat CF;
CF._dwEffects = 0;
_prg->Set(cp, fCell ? 1 : 2);
_prg->SetCharFormat(&CF, 0, NULL, CFM_HIDDEN, 0);
CheckNotifyLowFiRTF(TRUE);
_CF._dwEffects |= CFE_HIDDEN; // Restore CFE_HIDDEN
_dwMaskCF |= CFM_HIDDEN;
}
_prg->_rpCF.AdjustForward();
if(fIsAfterTRD && _crCellCustom1)
{
pPF->_crCustom1 = _crCellCustom1;
dwMask |= PFM_SHADING;
if(_crCellCustom2)
{
pPF->_crCustom2 = _crCellCustom2;
dwMask |= PFM_NUMBERINGSTART | PFM_NUMBERINGSTYLE;
}
}
}
if(dwMask)
{
_prg->Set(cp, cp - _cpThisPara); // Select back to _cpThisPara
_prg->SetParaFormat(pPF, NULL, dwMask, dwMask2);
}
_prg->Set(cp, 0); // Restore _prg to an IP
GetTabsCache()->Release(pPF->_iTabs);
pPF->_iTabs = -1;
return iTabs;
}
/*
* CRTFRead::SetBorderParm(&Parm, Value)
*
* @mfunc
* Set the border pen width in half points for the current border
* (_bBorder)
*/
void CRTFRead::SetBorderParm(
WORD& Parm,
LONG Value)
{
Assert(_bBorder <= 3);
Value = min(Value, 15);
Value = max(Value, 0);
Parm &= ~(0xF << 4*_bBorder);
Parm |= Value << 4*_bBorder;
_dwMaskPF |= PFM_BORDER;
}
/*
* CRTFRead::HandleToken()
*
* @mfunc
* Grand switch board that handles all tokens. Switches on _token
*
* @rdesc
* EC The error code
*
* @comm
* Token values are chosen contiguously (see tokens.h and tokens.c) to
* encourage the compiler to use a jump table. The lite-RTF keywords
* come first, so that an optimized OLE-free version works well. Some
* groups of keyword tokens are ordered so as to simplify the code, e.g,
* those for font family names, CF effects, and paragraph alignment.
*/
EC CRTFRead::HandleToken()
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::HandleToken");
DWORD dwT; // Temporary DWORD
LONG dy, i;
LONG iParam = _iParam;
const CCharFormat * pCF;
STATE * pstate = _pstateStackTop;
TEXTFONT * ptf;
WORD wT; // Temporary WORD
if(!pstate && _token != tokenStartGroup ||
IN_RANGE(tokenPicFirst, _token, tokenObjLast) && !_prtfObject)
{
abort: _ecParseError = ecAbort;
return ecAbort;
}
switch (_token)
{
case tokenURtf: // \urtf N - Preferred RE format
PARSERCOVERAGE_CASE(); // Currently we ignore the N
_dwFlags &= 0xFFFF; // Kill possible codepage
_dwFlags |= SF_USECODEPAGE | (CP_UTF8 << 16); // Save bit for Asserts
pstate->SetCodePage(CP_UTF8);
goto rtf;
case tokenPocketWord: // \pwd N - Pocket Word
_dwFlags |= SFF_PWD;
case tokenRtf: // \rtf N - Backward compatible
PARSERCOVERAGE_CASE();
rtf: if(pstate->pstatePrev)
goto abort; // Can't handle nested rtf
pstate->sDest = destRTF;
Assert(pstate->nCodePage == INVALID_CODEPAGE ||
pstate->nCodePage == (int)(_dwFlags >> 16) &&
(_dwFlags & SF_USECODEPAGE));
if(!_fonts.Count() && !_fonts.Add(1, NULL)) // If can't add a font,
goto OutOfRAM; // report the bad news
_sDefaultFont = 0; // Set up valid default font
ptf = _fonts.Elem(0);
pstate->ptf = ptf; // Get char set, pitch, family
pCF = _prg->GetCF(); // from current range font
ptf->iCharRep = pCF->_iCharRep; // These are guaranteed OK
ptf->bPitchAndFamily = pCF->_bPitchAndFamily;
ptf->sCodePage = (SHORT)CodePageFromCharRep(pCF->_iCharRep);
wcscpy(ptf->szName, GetFontName(pCF->_iFont));
ptf->fNameIsDBCS = (pCF->_dwEffects & CFE_FACENAMEISDBCS) != 0;
pstate->cbSkipForUnicodeMax = iUnicodeCChDefault;
break;
case tokenViewKind: // \viewkind N
if(!(_dwFlags & SFF_SELECTION) && IsUTF8)// RTF applies to document:
_ped->SetViewKind(iParam); // For now, only do for \urtf
break; // (need to work some more
// on OutlineView)
case tokenViewScale: // \viewscale N
if(_dwFlags & SFF_PERSISTVIEWSCALE &&
!(_dwFlags & SFF_SELECTION)) // RTF applies to document:
_ped->SetViewScale(iParam);
break;
case tokenCharacterDefault: // \plain
PARSERCOVERAGE_CASE();
SetPlain(pstate);
break;
case tokenCharSetAnsi: // \ansi
PARSERCOVERAGE_CASE();
_iCharRep = ANSI_INDEX;
break;
case tokenMac: // \mac
_fMac = TRUE;
break;
case tokenDefaultLanguage: // \deflang
PARSERCOVERAGE_CASE();
_sDefaultLanguage = (SHORT)iParam;
break;
case tokenDefaultLanguageFE: // \deflangfe
PARSERCOVERAGE_CASE();
_sDefaultLanguageFE = (SHORT)iParam;
break;
case tokenDefaultTabWidth: // \deftab
PARSERCOVERAGE_CASE();
_sDefaultTabWidth = (SHORT)iParam;
break;
//--------------------------- Font Control Words -------------------------------
case tokenDefaultFont: // \deff N
PARSERCOVERAGE_CASE();
if(iParam >= 0)
{
if(!_fonts.Count() && !_fonts.Add(1, NULL)) // If can't add a font,
goto OutOfRAM; // report the bad news
_fonts.Elem(0)->sHandle = _sDefaultFont = (SHORT)iParam;
}
TRACEERRSZSC("tokenDefaultFont: Negative value", iParam);
break;
case tokenDefaultBiDiFont: // \adeff N
PARSERCOVERAGE_CASE();
if(iParam >=0 && _fonts.Count() == 1)
{
if(!_fonts.Add(1, NULL))
goto OutOfRAM;
_fonts.Elem(1)->sHandle = _sDefaultBiDiFont = (SHORT)iParam;
}
TRACEERRSZSC("tokenDefaultBiDiFont: Negative value", iParam);
break;
case tokenFontTable: // \fonttbl
PARSERCOVERAGE_CASE();
pstate->sDest = destFontTable;
pstate->ptf = NULL;
break;
case tokenFontFamilyBidi: // \fbidi
case tokenFontFamilyTechnical: // \ftech
case tokenFontFamilyDecorative: // \fdecor
case tokenFontFamilyScript: // \fscript
case tokenFontFamilyModern: // \fmodern
case tokenFontFamilySwiss: // \fswiss
case tokenFontFamilyRoman: // \froman
case tokenFontFamilyDefault: // \fnil
PARSERCOVERAGE_CASE();
AssertSz(tokenFontFamilyRoman - tokenFontFamilyDefault == 1,
"CRTFRead::HandleToken: invalid token definition");
if(pstate->ptf)
{
pstate->ptf->bPitchAndFamily
= (BYTE)((_token - tokenFontFamilyDefault) << 4
| (pstate->ptf->bPitchAndFamily & 0xF));
// Setup SYMBOL_CHARSET charset for \ftech if there isn't any charset info
if(tokenFontFamilyTechnical == _token && pstate->ptf->iCharRep == DEFAULT_INDEX)
pstate->ptf->iCharRep = SYMBOL_INDEX;
}
break;
case tokenPitch: // \fprq
PARSERCOVERAGE_CASE();
if(pstate->ptf)
pstate->ptf->bPitchAndFamily
= (BYTE)(iParam | (pstate->ptf->bPitchAndFamily & 0xF0));
break;
case tokenAnsiCodePage: // \ansicpg
PARSERCOVERAGE_CASE();
#if !defined(NOFULLDEBUG) && defined(DEBUG)
if(_fSeenFontTable && _nCodePage == INVALID_CODEPAGE)
TRACEWARNSZ("CRTFRead::HandleToken(): Found an \ansicpgN tag after "
"the font table. Should have code to fix-up "
"converted font names and document text.");
#endif
if(!(_dwFlags & SF_USECODEPAGE))
{
_nCodePage = iParam;
pstate->SetCodePage(iParam);
}
Assert(!IsUTF8 || pstate->nCodePage == CP_UTF8);
break;
case tokenCodePage: // \cpg
PARSERCOVERAGE_CASE();
pstate->SetCodePage(iParam);
if(pstate->sDest == destFontTable && pstate->ptf)
{
pstate->ptf->sCodePage = (SHORT)iParam;
pstate->ptf->iCharRep = CharRepFromCodePage(iParam);
// If a document-level code page has not been specified,
// grab this from the first font table entry containing a
// \fcharsetN or \cpgN
if(_nCodePage == INVALID_CODEPAGE)
_nCodePage = iParam;
}
break;
case tokenCharSet: // \fcharset N
PARSERCOVERAGE_CASE();
if(pstate->ptf)
{
pstate->ptf->iCharRep = CharRepFromCharSet((BYTE)iParam);
pstate->ptf->sCodePage = (SHORT)CodePageFromCharRep(pstate->ptf->iCharRep);
pstate->SetCodePage(pstate->ptf->sCodePage);
// If a document-level code page has not been specified,
// grab this from the first font table entry containing a
// \fcharsetN or \cpgN
if (pstate->nCodePage != CP_SYMBOL &&
_nCodePage == INVALID_CODEPAGE)
{
_nCodePage = pstate->nCodePage;
}
if(IsRTLCharSet(iParam))
{
if(_sDefaultBiDiFont == -1)
_sDefaultBiDiFont = pstate->ptf->sHandle;
if(!IsRTLCharRep(_iCharRepBiDi))
_iCharRepBiDi = pstate->ptf->iCharRep;
}
_fCharSet = TRUE;
if(iParam)
_fNon0CharSet = TRUE; // Not HTML converter
}
break;
case tokenRealFontName: // \fname
PARSERCOVERAGE_CASE();
pstate->sDest = destRealFontName;
break;
case tokenAssocFontSelect: // \af N
PARSERCOVERAGE_CASE();
pstate->rgDefFont[pstate->iDefFont].sHandle = iParam;
iParam = 0; // Fall thru to \afs N to 0 sSize
case tokenAssocFontSize: // \afs N
PARSERCOVERAGE_CASE();
pstate->rgDefFont[pstate->iDefFont].sSize = iParam;
break;
case tokenFontSelect: // \f N
PARSERCOVERAGE_CASE();
if(iParam == -1) // Can't handle this bizarre choice
goto skip_group;
if(pstate->sDest == destFontTable) // Building font table
{
if(iParam == _sDefaultFont)
{
_fReadDefFont = TRUE;
ptf = _fonts.Elem(0);
}
else if(iParam == _sDefaultBiDiFont)
ptf = _fonts.Elem(1);
else if(!(ptf =_fonts.Add(1,NULL))) // Make room in font table for
{ // font to be parsed
OutOfRAM:
_ped->GetCallMgr()->SetOutOfMemory();
_ecParseError = ecNoMemory;
break;
}
pstate->ptf = ptf;
ptf->sHandle = (SHORT)iParam; // Save handle
ptf->szName[0] = '\0'; // Start with null string
ptf->bPitchAndFamily = 0;
ptf->fNameIsDBCS = FALSE;
ptf->sCodePage = INVALID_CODEPAGE;
ptf->fCpgFromSystem = FALSE;
ptf->iCharRep = DEFAULT_INDEX;
}
else if(_fonts.Count() && pstate->sDest != destStyleSheet) // Font switch in text
{
SHORT idx = DEFFONT_LTRCH;
SelectCurrentFont(iParam);
if(IsRTLCharRep(pstate->ptf->iCharRep))
{
_iCharRepBiDi = pstate->ptf->iCharRep;
idx = DEFFONT_RTLCH;
if(pstate->iDefFont == DEFFONT_LTRCH)
pstate->iDefFont = DEFFONT_RTLCH;
}
pstate->rgDefFont[idx].sHandle = iParam;
pstate->rgDefFont[idx].sSize = 0;
}
break;
case tokenDBChars: // \dbch
case tokenHIChars: // \hich
case tokenLOChars: // \loch
case tokenRToLChars: // \rtlch
case tokenLToRChars: // \ltrch
pstate->iDefFont = _token - tokenLToRChars + DEFFONT_LTRCH;
if(!IN_RANGE(DEFFONT_LTRCH, pstate->iDefFont, DEFFONT_RTLCH))
break;
i = pstate->rgDefFont[pstate->iDefFont].sHandle;
if(i == -1)
break;
SelectCurrentFont(i);
HandleNumber(); // Fix Word \ltrchN bug
iParam = pstate->rgDefFont[pstate->iDefFont].sSize;
if(!iParam)
break; // No \afs N value specified
// Fall thru to \fs N
case tokenFontSize: // \fs N
PARSERCOVERAGE_CASE();
pstate->rgDefFont[pstate->iDefFont].sSize = iParam;
_CF._yHeight = PointsToFontHeight(iParam); // Convert font size in
_dwMaskCF |= CFM_SIZE; // half points to logical
break; // units
// NOTE: \*\fontemb and \*\fontfile are discarded. The font mapper will
// have to do the best it can given font name, family, and pitch.
// Embedded fonts are particularly nasty because legal use should
// only support read-only which parser cannot enforce.
case tokenLanguage: // \lang N
PARSERCOVERAGE_CASE();
_CF._lcid = MAKELCID(iParam, SORT_DEFAULT);
_dwMaskCF |= CFM_LCID;
if(W32->IsBiDiLcid(_CF._lcid))
{
_iCharRepBiDi = CharRepFromLID(iParam);
if(pstate->iDefFont == DEFFONT_LTRCH) // Workaround Word 10 bug
pstate->iDefFont = DEFFONT_RTLCH;
}
break;
//-------------------------- Color Control Words ------------------------------
case tokenColorTable: // \colortbl
PARSERCOVERAGE_CASE();
pstate->sDest = destColorTable;
_fGetColorYet = FALSE;
break;
case tokenColorRed: // \red
PARSERCOVERAGE_CASE();
pstate->bRed = (BYTE)iParam;
_fGetColorYet = TRUE;
break;
case tokenColorGreen: // \green
PARSERCOVERAGE_CASE();
pstate->bGreen = (BYTE)iParam;
_fGetColorYet = TRUE;
break;
case tokenColorBlue: // \blue
PARSERCOVERAGE_CASE();
pstate->bBlue = (BYTE)iParam;
_fGetColorYet = TRUE;
break;
case tokenColorForeground: // \cf
PARSERCOVERAGE_CASE();
_CF._crTextColor = GetColor(CFM_COLOR);
break;
case tokenColorBackground: // \highlight
PARSERCOVERAGE_CASE();
_CF._crBackColor = GetColor(CFM_BACKCOLOR);
break;
case tokenExpand: // \expndtw N
PARSERCOVERAGE_CASE();
_CF._sSpacing = (SHORT) iParam;
_dwMaskCF |= CFM_SPACING;
break;
case tokenCharStyle: // \cs N
PARSERCOVERAGE_CASE();
/* FUTURE (alexgo): we may want to support character styles
in some future version.
_CF._sStyle = (SHORT)iParam;
_dwMaskCF |= CFM_STYLE; */
if(pstate->sDest == destStyleSheet)
goto skip_group;
break;
case tokenAnimText: // \animtext N
PARSERCOVERAGE_CASE();
_CF._bAnimation = (BYTE)iParam;
_dwMaskCF |= CFM_ANIMATION;
CheckNotifyLowFiRTF(TRUE);
break;
case tokenKerning: // \kerning N
PARSERCOVERAGE_CASE();
_CF._wKerning = (WORD)(10 * iParam); // Convert to twips
_dwMaskCF |= CFM_KERNING;
break;
case tokenHorzInVert: // \horzvert N
PARSERCOVERAGE_CASE();
CheckNotifyLowFiRTF(TRUE);
break;
case tokenFollowingPunct: // \*\fchars
PARSERCOVERAGE_CASE();
pstate->sDest = destFollowingPunct;
{
char *pwchBuf=NULL;
if (ReadRawText((_dwFlags & SFF_SELECTION) ? NULL : &pwchBuf) && pwchBuf)
{
if (_ped->SetFollowingPunct(pwchBuf) != NOERROR) // Store this buffer inside doc
FreePv(pwchBuf);
}
else if (pwchBuf)
FreePv(pwchBuf);
}
break;
case tokenLeadingPunct: // \*\lchars
PARSERCOVERAGE_CASE();
pstate->sDest = destLeadingPunct;
{
char *pwchBuf=NULL;
if (ReadRawText((_dwFlags & SFF_SELECTION) ? NULL : &pwchBuf) && pwchBuf)
{
if (_ped->SetLeadingPunct(pwchBuf) != NOERROR) // Store this buffer inside doc
FreePv(pwchBuf);
}
else if (pwchBuf)
FreePv(pwchBuf);
}
break;
case tokenDocumentArea: // \info
PARSERCOVERAGE_CASE();
pstate->sDest = destDocumentArea;
break;
case tokenVerticalRender: // \vertdoc
PARSERCOVERAGE_CASE();
TRACEINFOSZ("Vertical" );
if (!(_dwFlags & SFF_SELECTION))
HandleSTextFlow(1);
break;
case tokenSTextFlow: // \stextflow N
PARSERCOVERAGE_CASE();
TRACEINFOSZ("STextFlow" );
if (!(_dwFlags & SFF_SELECTION) && !_ped->Get10Mode())
HandleSTextFlow(iParam);
break;
#ifdef FE
USHORT usPunct; // Used for FE word breaking
case tokenNoOverflow: // \nooverflow
PARSERCOVERAGE_CASE();
TRACEINFOSZ("No Overflow");
usPunct = ~WBF_OVERFLOW;
goto setBrkOp;
case tokenNoWordBreak: // \nocwrap
PARSERCOVERAGE_CASE();
TRACEINFOSZ("No Word Break" );
usPunct = ~WBF_WORDBREAK;
goto setBrkOp;
case tokenNoWordWrap: // \nowwrap
PARSERCOVERAGE_CASE();
TRACEINFOSZ("No Word Word Wrap" );
usPunct = ~WBF_WORDWRAP;
setBrkOp:
if(!(_dwFlags & fRTFFE))
{
usPunct &= UsVGetBreakOption(_ped->lpPunctObj);
UsVSetBreakOption(_ped->lpPunctObj, usPunct);
}
break;
case tokenHorizontalRender: // \horzdoc
PARSERCOVERAGE_CASE();
TRACEINFOSZ("Horizontal" );
if(pstate->sDest == destDocumentArea && !(_dwFlags & fRTFFE))
_ped->fModeDefer = FALSE;
break;
#endif
//-------------------- Character Format Control Words -----------------------------
case tokenUnderlineThickLongDash: // \ulthldash [18]
case tokenUnderlineThickDotted: // \ulthd [17]
case tokenUnderlineThickDashDotDot: // \ulthdashdd [16]
case tokenUnderlineThickDashDot: // \ulthdashd [15]
case tokenUnderlineThickDash: // \ulthdash [14]
case tokenUnderlineLongDash: // \ulldash [13]
case tokenUnderlineHeavyWave: // \ulhwave [12]
case tokenUnderlineDoubleWave: // \ululdbwave [11]
case tokenUnderlineHairline: // \ulhair [10]
case tokenUnderlineThick: // \ulth [9]
case tokenUnderlineDouble: // \uldb [3]
case tokenUnderlineWord: // \ulw [2]
// CheckNotifyLowFiRTF();
case tokenUnderlineWave: // \ulwave [8]
case tokenUnderlineDashDotDotted: // \uldashdd [7]
case tokenUnderlineDashDotted: // \uldashd [6]
case tokenUnderlineDash: // \uldash [5]
case tokenUnderlineDotted: // \uld [4]
PARSERCOVERAGE_CASE();
_CF._bUnderlineType = (BYTE)(_token - tokenUnderlineWord + 2);
_token = tokenUnderline; // CRenderer::RenderUnderline()
goto under; // reveals which of these are
// rendered specially
case tokenUnderline: // \ul [Effect 4]
PARSERCOVERAGE_CASE(); // (see handleCF)
_CF._bUnderlineType = CFU_UNDERLINE;
under: _dwMaskCF |= CFM_UNDERLINETYPE;
goto handleCF;
case tokenDeleted: // \deleted
PARSERCOVERAGE_CASE();
_dwMaskCF2 = CFM2_DELETED;
dwT = CFE_DELETED;
goto hndlCF;
// These effects are turned on if their control word parameter is missing
// or nonzero. They are turned off if the parameter is zero. This
// behavior is usually identified by an asterisk (*) in the RTF spec.
// The code uses fact that CFE_xxx = CFM_xxx
case tokenImprint: // \impr [1000]
case tokenEmboss: // \embo [800]
case tokenShadow: // \shad [400]
case tokenOutline: // \outl [200]
case tokenSmallCaps: // \scaps [40]
CheckNotifyLowFiRTF();
handleCF:
case tokenRevised: // \revised [4000]
case tokenDisabled: // \disabled [2000]
case tokenHiddenText: // \v [100]
case tokenCaps: // \caps [80]
case tokenLink: // \link [20]
case tokenProtect: // \protect [10]
case tokenStrikeOut: // \strike [8]
case tokenItalic: // \i [2]
case tokenBold: // \b [1]
PARSERCOVERAGE_CASE();
dwT = 1 << (_token - tokenBold); // Generate effect mask
_dwMaskCF |= dwT;
hndlCF: _CF._dwEffects &= ~dwT; // Default attribute off
if(!_fParam || _iParam) // Effect is on
_CF._dwEffects |= dwT; // In either case, the effect
break; // is defined
case tokenStopUnderline: // \ulnone
PARSERCOVERAGE_CASE();
_CF._dwEffects &= ~CFE_UNDERLINE; // Kill all underlining
_dwMaskCF |= CFM_UNDERLINE;
break;
case tokenRevAuthor: // \revauth N
PARSERCOVERAGE_CASE();
/* FUTURE: (alexgo) this doesn't work well now since we don't support
revision tables. We may want to support this better in the future.
So what we do now is the 1.0 technique of using a color for the
author */
if(iParam > 0)
{
_CF._dwEffects &= ~CFE_AUTOCOLOR;
_dwMaskCF |= CFM_COLOR;
_CF._crTextColor = rgcrRevisions[(iParam - 1) & REVMASK];
}
break;
case tokenUp: // \up
PARSERCOVERAGE_CASE();
dy = 10;
goto StoreOffset;
case tokenDown: // \down
PARSERCOVERAGE_CASE();
dy = -10;
StoreOffset:
if(!_fParam)
iParam = dyDefaultSuperscript;
_CF._yOffset = iParam * dy; // Half points->twips
_dwMaskCF |= CFM_OFFSET;
break;
case tokenSuperscript: // \super
PARSERCOVERAGE_CASE();
dwT = CFE_SUPERSCRIPT;
goto SetSubSuperScript;
case tokenSubscript: // \sub
PARSERCOVERAGE_CASE();
dwT = CFE_SUBSCRIPT;
goto SetSubSuperScript;
case tokenNoSuperSub: // \nosupersub
PARSERCOVERAGE_CASE();
dwT = 0;
SetSubSuperScript:
_dwMaskCF |= (CFE_SUPERSCRIPT | CFE_SUBSCRIPT);
_CF._dwEffects &= ~(CFE_SUPERSCRIPT | CFE_SUBSCRIPT);
_CF._dwEffects |= dwT;
break;
//--------------------- Paragraph Control Words -----------------------------
case tokenStyleSheet: // \stylesheet
PARSERCOVERAGE_CASE();
pstate->sDest = destStyleSheet;
_Style = 0; // Default normal style
break;
case tokenTabBar: // \tb
PARSERCOVERAGE_CASE();
_bTabType = PFT_BAR; // Fall thru to \tx
case tokenTabPosition: // \tx
PARSERCOVERAGE_CASE();
if(_cTab < MAX_TAB_STOPS && (unsigned)iParam < 0x1000000)
{
_rgxCell[_cTab++] = GetTabPos(iParam)
+ (_bTabType << 24) + (_bTabLeader << 28);
_dwMaskPF |= PFM_TABSTOPS;
}
_cCell = 0; // Invalidate _rgxCell array
break; // for table purposes
case tokenDecimalTab: // \tqdec
case tokenFlushRightTab: // \tqr
case tokenCenterTab: // \tqc
PARSERCOVERAGE_CASE();
_bTabType = (BYTE)(_token - tokenCenterTab + PFT_CENTER);
break;
case tokenTabLeaderEqual: // \tleq
case tokenTabLeaderThick: // \tlth
case tokenTabLeaderUnderline: // \tlul
case tokenTabLeaderHyphen: // \tlhyph
CheckNotifyLowFiRTF();
case tokenTabLeaderDots: // \tldot
PARSERCOVERAGE_CASE();
_bTabLeader = (BYTE)(_token - tokenTabLeaderDots + PFTL_DOTS);
break;
// The following need to be kept in sync with PFE_xxx
case tokenRToLPara: // \rtlpar
_ped->OrCharFlags(FRTL);
case tokenCollapsed: // \collapsed
case tokenSideBySide: // \sbys
case tokenHyphPar: // \hyphpar
case tokenNoWidCtlPar: // \nowidctlpar
case tokenNoLineNumber: // \noline
case tokenPageBreakBefore: // \pagebb
case tokenKeepNext: // \keepn
case tokenKeep: // \keep
PARSERCOVERAGE_CASE();
wT = (WORD)(1 << (_token - tokenRToLPara));
_PF._wEffects |= wT;
_dwMaskPF |= (wT << 16);
break;
case tokenLToRPara: // \ltrpar
PARSERCOVERAGE_CASE();
_PF._wEffects &= ~PFE_RTLPARA;
_dwMaskPF |= PFM_RTLPARA;
break;
case tokenLineSpacing: // \sl N
PARSERCOVERAGE_CASE();
_PF._dyLineSpacing = abs(iParam);
_PF._bLineSpacingRule // Handle nonmultiple rules
= (BYTE)(!iParam || iParam == 1000
? 0 : (iParam > 0) ? tomLineSpaceAtLeast
: tomLineSpaceExactly); // \slmult can change (has to
_dwMaskPF |= PFM_LINESPACING; // follow if it appears)
break;
case tokenDropCapLines: // \dropcapliN
if(_PF._bLineSpacingRule == tomLineSpaceExactly) // Don't chop off
_PF._bLineSpacingRule = tomLineSpaceAtLeast; // drop cap
_fBody = TRUE;
break;
case tokenLineSpacingRule: // \slmult N
PARSERCOVERAGE_CASE();
if(iParam)
{ // It's multiple line spacing
_PF._bLineSpacingRule = tomLineSpaceMultiple;
_PF._dyLineSpacing /= 12; // RE line spacing multiple is
_dwMaskPF |= PFM_LINESPACING; // given in 20ths of a line,
} // while RTF uses 240ths
break;
case tokenSpaceBefore: // \sb N
PARSERCOVERAGE_CASE();
_PF._dySpaceBefore = iParam;
_dwMaskPF |= PFM_SPACEBEFORE;
break;
case tokenSpaceAfter: // \sa N
PARSERCOVERAGE_CASE();
_PF._dySpaceAfter = iParam;
_dwMaskPF |= PFM_SPACEAFTER;
break;
case tokenStyle: // \s N
PARSERCOVERAGE_CASE();
_Style = iParam; // Save it in case in StyleSheet
if(pstate->sDest != destStyleSheet)
{ // Select possible heading level
_PF._sStyle = STYLE_NORMAL; // Default Normal style
_PF._bOutlineLevel |= 1;
for(i = 0; i < NSTYLES && iParam != _rgStyles[i]; i++)
; // Check for heading style
if(i < NSTYLES) // Found one
{
_PF._sStyle = (SHORT)(-i - 1); // Store desired heading level
_PF._bOutlineLevel = (BYTE)(2*(i-1));// Update outline level for
} // nonheading styles
_dwMaskPF |= PFM_ALLRTF;
}
break;
case tokenIndentFirst: // \fi N
PARSERCOVERAGE_CASE();
_PF._dxStartIndent += _PF._dxOffset // Cancel current offset
+ iParam; // and add in new one
_PF._dxOffset = -iParam; // Offset for all but 1st line
// = -RTF_FirstLineIndent
_dwMaskPF |= (PFM_STARTINDENT | PFM_OFFSET);
break;
case tokenIndentLeft: // \li N
case tokenIndentRight: // \ri N
PARSERCOVERAGE_CASE();
// AymanA: For RtL para indents has to be flipped.
Assert(PFE_RTLPARA == 0x0001);
if((_token == tokenIndentLeft) ^ (_PF.IsRtlPara()))
{
_PF._dxStartIndent = iParam - _PF._dxOffset;
_dwMaskPF |= PFM_STARTINDENT;
}
else
{
_PF._dxRightIndent = iParam;
_dwMaskPF |= PFM_RIGHTINDENT;
}
break;
case tokenAlignLeft: // \ql
case tokenAlignRight: // \qr
case tokenAlignCenter: // \qc
case tokenAlignJustify: // \qj
PARSERCOVERAGE_CASE();
_PF._bAlignment = (WORD)(_token - tokenAlignLeft + PFA_LEFT);
_dwMaskPF |= PFM_ALIGNMENT;
break;
case tokenBorderOutside: // \brdrbar
case tokenBorderBetween: // \brdrbtw
case tokenBorderShadow: // \brdrsh
PARSERCOVERAGE_CASE();
_PF._dwBorderColor |= 1 << (_token - tokenBorderShadow + 20);
_dwBorderColors = _PF._dwBorderColor;
break;
// Paragraph and cell border segments
case tokenBox: // \box
PARSERCOVERAGE_CASE();
CheckNotifyLowFiRTF();
_PF._wEffects |= PFE_BOX;
_dwMaskPF |= PFM_BOX;
_bBorder = 0; // Store parms as if for
break; // \brdrt
case tokenBorderBottom: // \brdrb
case tokenBorderRight: // \brdrr
case tokenBorderTop: // \brdrt
if((rgKeyword[_iKeyword].szKeyword[0] | 0x20) != 't')
CheckNotifyLowFiRTF();
case tokenBorderLeft: // \brdrl
case tokenCellBorderBottom: // \clbrdrb
case tokenCellBorderRight: // \clbrdrr
case tokenCellBorderTop: // \clbrdrt
case tokenCellBorderLeft: // \clbrdrl
PARSERCOVERAGE_CASE();
_bBorder = (BYTE)(_token - tokenBorderLeft);
break;
// Paragraph border styles
case tokenBorderTriple: // \brdrtriple
case tokenBorderDoubleThick: // \brdrth
case tokenBorderSingleThick: // \brdrs
case tokenBorderHairline: // \brdrhair
case tokenBorderDot: // \brdrdot
case tokenBorderDouble: // \brdrdb
case tokenBorderDashSmall: // \brdrdashsm
case tokenBorderDash: // \brdrdash
PARSERCOVERAGE_CASE();
if(_bBorder < 4) // Only for paragraphs
SetBorderParm(_PF._wBorders, _token - tokenBorderDash);
break;
case tokenBorderColor: // \brdrcf
PARSERCOVERAGE_CASE();
if(_bBorder < 4) // Only for paragraphs
{
iParam = GetStandardColorIndex();
_PF._dwBorderColor &= ~(0x1F << (5*_bBorder));
_PF._dwBorderColor |= iParam << (5*_bBorder);
_dwBorderColors = _PF._dwBorderColor;
}
else // Cell borders
_dwCellColors |= GetCellColorIndex() << (5*(_bBorder - 4));
break;
case tokenBorderWidth: // \brdrw
PARSERCOVERAGE_CASE(); // Store width in half pts
// iParam is in twips
if(_bBorder < 4) // Paragraphs
{
iParam = TwipsToQuarterPoints(iParam);
SetBorderParm(_PF._wBorderWidth, iParam);
}
else // Table cells
{
iParam = CheckTwips(iParam);
_dwCellBrdrWdths |= iParam << 8*(_bBorder - 4);
}
break;
case tokenBorderSpace: // \brsp
PARSERCOVERAGE_CASE(); // Space is in pts
if(_bBorder < 4) // Only for paragraphs
SetBorderParm(_PF._wBorderSpace, iParam/20);// iParam is in twips
break;
// Paragraph shading
case tokenBckgrndVert: // \bgvert
case tokenBckgrndHoriz: // \bghoriz
case tokenBckgrndFwdDiag: // \bgfdiag
case tokenBckgrndDrkVert: // \bgdkvert
case tokenBckgrndDrkHoriz: // \bgdkhoriz
case tokenBckgrndDrkFwdDiag: // \bgdkfdiag
case tokenBckgrndDrkDiagCross: // \bgdkdcross
case tokenBckgrndDrkCross: // \bgdkcross
case tokenBckgrndDrkBckDiag: // \bgdkbdiag
case tokenBckgrndDiagCross: // \bgdcross
case tokenBckgrndCross: // \bgcross
case tokenBckgrndBckDiag: // \bgbdiag
PARSERCOVERAGE_CASE();
_PF._wShadingStyle = (WORD)((_PF._wShadingStyle & 0xFFC0)
| (_token - tokenBckgrndBckDiag + 1));
_dwMaskPF |= PFM_SHADING;
break;
case tokenColorBckgrndPat: // \cbpat
PARSERCOVERAGE_CASE();
iParam = GetStandardColorIndex();
_PF._wShadingStyle = (WORD)((_PF._wShadingStyle & 0x07FF) | (iParam << 11));
_dwMaskPF |= PFM_SHADING;
break;
case tokenColorForgrndPat: // \cfpat
PARSERCOVERAGE_CASE();
iParam = GetStandardColorIndex();
_PF._wShadingStyle = (WORD)((_PF._wShadingStyle & 0xF83F) | (iParam << 6));
_dwMaskPF |= PFM_SHADING;
break;
case tokenShading: // \shading
PARSERCOVERAGE_CASE();
_PF._wShadingWeight = (WORD)iParam;
_dwMaskPF |= PFM_SHADING;
break;
// Paragraph numbering
case tokenParaNum: // \pn
PARSERCOVERAGE_CASE();
pstate->sDest = destParaNumbering;
pstate->fBullet = FALSE;
_PF._wNumberingStart = 1;
_dwMaskPF |= PFM_NUMBERINGSTART;
break;
case tokenParaNumIndent: // \pnindent N
PARSERCOVERAGE_CASE();
if(pstate->sDest == destParaNumbering)
pstate->sIndentNumbering = (SHORT)iParam;
break;
case tokenParaNumStart: // \pnstart N
PARSERCOVERAGE_CASE();
if(pstate->sDest == destParaNumbering)
{
_PF._wNumberingStart = (WORD)iParam;
_dwMaskPF |= PFM_NUMBERINGSTART;
}
break;
case tokenParaNumCont: // \pnlvlcont
PARSERCOVERAGE_CASE();
_prg->_rpPF.AdjustBackward(); // Maintain numbering mode
_PF._wNumbering = _prg->GetPF()->_wNumbering;
_prg->_rpPF.AdjustForward();
_wNumberingStyle = PFNS_NONUMBER; // Signal no number
_dwMaskPF |= PFM_NUMBERING; // Note: can be new para with
pstate->fBullet = TRUE; // its own indents
break;
case tokenParaNumBody: // \pnlvlbody
PARSERCOVERAGE_CASE();
_wNumberingStyle = PFNS_PAREN;
_token = tokenParaNumDecimal; // Default to decimal
goto setnum;
case tokenParaNumBullet: // \pnlvlblt
_wNumberingStyle = 0; // Reset numbering styles
goto setnum;
case tokenParaNumDecimal: // \pndec
case tokenParaNumLCLetter: // \pnlcltr
case tokenParaNumUCLetter: // \pnucltr
case tokenParaNumLCRoman: // \pnlcrm
case tokenParaNumUCRoman: // \pnucrm
PARSERCOVERAGE_CASE();
if(_PF._wNumbering == PFN_BULLET && pstate->fBullet)
break; // Ignore above for bullets
setnum: if(pstate->sDest == destParaNumbering)
{
_PF._wNumbering = (WORD)(PFN_BULLET + _token - tokenParaNumBullet);
_dwMaskPF |= PFM_NUMBERING;
pstate->fBullet = TRUE; // We do bullets, so don't
} // output the \pntext group
break;
case tokenParaNumText: // \pntext
PARSERCOVERAGE_CASE();
// Throw away previously read paragraph numbering and use
// the most recently read to apply to next run of text.
_cchUsedNumText = 0;
pstate->sDest = destParaNumText;
break;
case tokenParaNumAlignCenter: // \pnqc
case tokenParaNumAlignRight: // \pnqr
PARSERCOVERAGE_CASE();
_wNumberingStyle = (_wNumberingStyle & ~3) | _token - tokenParaNumAlignCenter + 1;
break;
case tokenPictureQuickDraw: // \macpict
case tokenPictureOS2Metafile: // \pmmetafile
CheckNotifyLowFiRTF(TRUE);
case tokenParaNumAfter: // \pntxta
case tokenParaNumBefore: // \pntxtb
PARSERCOVERAGE_CASE();
skip_group:
if(!SkipToEndOfGroup())
{
// During \fonttbl processing, we may hit unknown destinations,
// e.g., \panose, that cause the HandleEndGroup to select the
// default font, which may not be defined yet. So, we change
// sDest to avoid this problem.
if(pstate->sDest == destFontTable || pstate->sDest == destStyleSheet)
pstate->sDest = destNULL;
HandleEndGroup();
}
break;
// Tables
case tokenInTable: // \intbl
PARSERCOVERAGE_CASE();
if(pstate->sDest != destRTF && pstate->sDest != destFieldResult &&
pstate->sDest != destParaNumText)
{
_ecParseError = ecUnexpectedToken;
break;
}
if(!_iCell && !_bTableLevel)
DelimitRow(szRowStart); // Start row
break;
case tokenNestCell: // \nestcell
case tokenCell: // \cell
PARSERCOVERAGE_CASE();
HandleCell();
break;
case tokenRowHeight: // \trrh N
PARSERCOVERAGE_CASE();
_dyRow = iParam;
break;
case tokenCellHalfGap: // \trgaph N
PARSERCOVERAGE_CASE(); // Save half space between
if((unsigned)iParam > 255) // Illegal value: use default
iParam = 108;
_dxCell = iParam; // cells to add to tabs
break; // Roundtrip value at end of
// tab array
case tokenCellX: // \cellx N
PARSERCOVERAGE_CASE();
HandleCellx(iParam);
break;
case tokenRowDefault: // \trowd
PARSERCOVERAGE_CASE();
if(_ped->fUsePassword() || pstate->sDest == destParaNumText)
{
_ecParseError = ecUnexpectedToken;
break;
}
// Insert a newline if we are inserting a table behind characters in the
// same line. This follows the Word9 model.
if (_cpFirst == _prg->GetCp() && _cpThisPara != _cpFirst)
{
EC ec = _ped->fUseCRLF() // If RichEdit 1.0 compatibility
? HandleText(szaCRLF, ALL_ASCII)// mode, use CRLF; else CR
: HandleChar((unsigned)(CR));
if(ec == ecNoError)
_cpThisPara = _prg->GetCp(); // New para starts after CRLF
}
_cCell = 0; // No cell right boundaries
_dxCell = 0; // or half gap defined yet
_xRowOffset = 0;
_dwCellBrdrWdths = 0;
_dyRow = 0; // No row height yet
_wBorderWidth = 0; // No borders yet
_dwBorderColors = 0; // No colors yet
_dwCellColors = 0; // No colors yet
_dwShading = 0; // No shading yet
_bAlignment = PFA_LEFT;
_iTabsTable = -1; // No cell widths yet
_bCellFlags = 0; // No cell vert merge
_crCellCustom1 = 0;
_crCellCustom2 = 0;
_fRTLRow = FALSE;
break;
case tokenRowLeft: // \trleft N
PARSERCOVERAGE_CASE();
_xRowOffset = iParam;
break;
case tokenRowAlignCenter: // \trqc
case tokenRowAlignRight: // \trqr
PARSERCOVERAGE_CASE();
_bAlignment = (WORD)(_token - tokenRowAlignRight + PFA_RIGHT);
break;
case tokenRToLRow: // \rtlrow
_fRTLRow = TRUE;
break;
case tokenNestRow: // \nestrow
_fNo_iTabsTable = TRUE;
goto row;
case tokenRow: // \row
PARSERCOVERAGE_CASE();
_iTabsLevel1 = -1;
row:
if(!_bTableLevel) // Ignore \row and \nestrow if not in table
break;
while(_iCell < _cCell) // If not enuf cells, add
HandleCell(); // them since Word crashes
DelimitRow(szRowEnd);
if(_fNo_iTabsTable && !_bTableLevel) // New nested table format
InitializeTableRowParms(); // used so reset _cCell
break; // (new values will be given)
case tokenCellBackColor: // \clcbpat N
_dwCellColors |= GetCellColorIndex() << 4*5;
break;
case tokenCellForeColor: // \clcfpat N
_dwCellColors |= GetCellColorIndex() << 5*5;
break;
case tokenCellShading: // \clshdng N
_dwShading = iParam/50; // Store in .5 per cents
break; // (N is in .01 per cent)
case tokenCellAlignBottom: // \clvertalb
case tokenCellAlignCenter: // \clvertalc
PARSERCOVERAGE_CASE();
_bCellFlags |= _token - tokenCellAlignCenter + 1;
break;
case tokenCellMergeDown: // \clvmgf
_bCellFlags |= fTopCell >> 24;
break;
case tokenCellMergeUp: // \clvmrg
_bCellFlags |= fLowCell >> 24;
break;
case tokenCellTopBotRLVert: // \cltxtbrlv
PARSERCOVERAGE_CASE();
_bCellFlags |= fVerticalCell >> 24;
break;
case tokenCellLRTB: // \cltxlrtb
break; // This is the default
// so don't fire LowFiRTF
case tokenTableLevel: // \itap N
PARSERCOVERAGE_CASE(); // Set table level
if(pstate->fShape) // Bogus shape RTF
break;
AssertSz(iParam >= _bTableLevel,
"CRTFRead::HandleToken: illegal itap N");
if(iParam)
{
if(pstate->sDest != destRTF && pstate->sDest != destFieldResult || iParam > 127)
goto abort;
_iTabsTable = -1; // Previous cell widths invalid
_cCell = 0;
while(iParam > _bTableLevel)
DelimitRow(szRowStart); // Insert enuf table row headers
}
_fNo_iTabsTable = TRUE;
break;
case tokenNestTableProps: // \nesttableprops
break; // Control word is recognized
case tokenNoNestTables: // \nonesttables
goto skip_group; // Ignore info for nesttable
// unaware readers
case tokenPage: // \page
// FUTURE: we want to be smarter about handling FF. But for
// now we ignore it for bulletted and number paragraphs
// and RE 1.0 mode.
if (_PF._wNumbering != 0 || _ped->Get10Mode())
break;
// Intentional fall thru to EOP
case tokenEndParagraph: // \par
case tokenLineBreak: // \line
PARSERCOVERAGE_CASE();
HandleEndOfPara();
break;
case tokenParagraphDefault: // \pard
PARSERCOVERAGE_CASE();
if(pstate->sDest != destParaNumText) // Ignore if \pn destination
Pard(pstate);
break;
case tokenEndSection: // \sect
CheckNotifyLowFiRTF(); // Fall thru to \sectd
case tokenSectionDefault: // \sectd
PARSERCOVERAGE_CASE();
Pard(pstate);
break;
case tokenBackground: // \background
if(_dwFlags & SFF_SELECTION) // If pasting a selection,
goto skip_group; // skip background
pstate->fBackground = TRUE; // Enable background. NB:
break; // InitBackground() already called
//----------------------- Field and Group Control Words --------------------------------
case tokenField: // \field
PARSERCOVERAGE_CASE();
if (pstate->sDest == destDocumentArea ||
pstate->sDest == destLeadingPunct ||
pstate->sDest == destFollowingPunct)
{
// We're not equipped to handle symbols in these destinations, and
// we don't want the fields added accidentally to document text.
goto skip_group;
}
pstate->sDest = destField;
break;
case tokenFieldResult: // \fldrslt
PARSERCOVERAGE_CASE();
if(_fSymbolField)
goto skip_group;
pstate->sDest = destFieldResult;
AddText(pchSeparateField, 2, FALSE);
break;
case tokenFieldInstruction: // \fldinst
PARSERCOVERAGE_CASE();
if(AddText(pchStartField, 2, FALSE) == ecNoError)
pstate->sDest = destFieldInstruction;
break;
case tokenStartGroup: // Save current state by
PARSERCOVERAGE_CASE(); // pushing it onto stack
HandleStartGroup();
if (_fNoRTFtoken)
{
// Hack Alert !!!!! For 1.0 compatibility to allow no \rtf token.
_fNoRTFtoken = FALSE;
pstate = _pstateStackTop;
goto rtf;
}
break;
case tokenEndGroup:
PARSERCOVERAGE_CASE();
HandleFieldEndGroup(); // Special end group handling for \field
HandleEndGroup(); // Restore save state by
break; // popping stack
case tokenOptionalDestination: // (see case tokenUnknown)
PARSERCOVERAGE_CASE();
break;
case tokenNullDestination: // Found a destination whose group
PARSERCOVERAGE_CASE(); // should be skipped
// tokenNullDestination triggers a loss notification here for...
// Footer related tokens - "footer", "footerf", "footerl", "footerr",
// "footnote", "ftncn", "ftnsep", "ftnsepc"
// Header related tokens - "header", "headerf", "headerl", "headerr"
// Table of contents - "tc"
// Index entries - "xe"
CheckNotifyLowFiRTF();
// V-GUYB: PWord Converter requires loss notification.
#ifdef REPORT_LOSSAGE
if(!(_dwFlags & SFF_SELECTION)) // SFF_SELECTION is set if any kind of paste is being done.
{
((LOST_COOKIE*)(_pes->dwCookie))->bLoss = TRUE;
}
#endif // REPORT_LOSSAGE
goto skip_group;
case tokenUnknownKeyword:
PARSERCOVERAGE_CASE();
if(_tokenLast == tokenOptionalDestination)
goto skip_group;
break;
//-------------------------- Text Control Words --------------------------------
case tokenUnicode: // \u N
PARSERCOVERAGE_CASE();
HandleUN(pstate);
break;
case tokenUnicodeCharByteCount: // \uc N
PARSERCOVERAGE_CASE();
if(IN_RANGE(1, iParam, 2))
pstate->cbSkipForUnicodeMax = iParam;
break;
case tokenText: // Lexer concludes tokenText
case tokenASCIIText:
PARSERCOVERAGE_CASE();
HandleTextToken(pstate);
break;
// \ltrmark, \rtlmark, \zwj, and \zwnj are translated directly into
// their Unicode values. \ltrmark and \rtlmark cause no further
// processing here because we assume that the current font has the
// CharSet needed to identify the direction.
case tokenLToRDocument: // \ltrdoc
PARSERCOVERAGE_CASE();
_bDocType = DT_LTRDOC;
break;
case tokenRToLDocument: // \rtldoc
PARSERCOVERAGE_CASE();
_bDocType = DT_RTLDOC;
_ped->OrCharFlags(FRTL);
break;
//--------------------------Shape Control Words---------------------------------
case tokenShape: // \shp
if(!pstate->fBackground)
CheckNotifyLowFiRTF(TRUE);
pstate->fShape = TRUE;
_dwFlagsShape = 0;
break;
case tokenShapeName: // \sn name
pstate->sDest = destShapeName;
break;
case tokenShapeValue: // \sv value
pstate->sDest = destShapeValue;
break;
case tokenShapeWrap: // \shpwr N
if(iParam == 2)
_dwFlagsShape |= REO_WRAPTEXTAROUND;
break;
case tokenPositionRight: // \posxr
_dwFlagsShape |= REO_ALIGNTORIGHT;
break;
//------------------------- Object Control Words --------------------------------
case tokenObject: // \object
PARSERCOVERAGE_CASE();
// V-GUYB: PWord Converter requires loss notification.
#ifdef REPORT_LOSSAGE
if(!(_dwFlags & SFF_SELECTION)) // SFF_SELECTION is set if any kind of paste is being done.
{
((LOST_COOKIE*)(_pes->dwCookie))->bLoss = TRUE;
}
#endif // REPORT_LOSSAGE
// Assume that the object failed to load until proven otherwise
// by RTFRead::ObjectReadFromEditStream
// This works for both:
// - an empty \objdata tag
// - a non-existent \objdata tag
_fFailedPrevObj = TRUE;
case tokenPicture: // \pict
PARSERCOVERAGE_CASE();
pstate->sDest = (SHORT)(_token == tokenPicture ? destPicture : destObject);
FreeRtfObject();
_prtfObject = (RTFOBJECT *) PvAlloc(sizeof(RTFOBJECT), GMEM_ZEROINIT);
if(!_prtfObject)
goto OutOfRAM;
_prtfObject->xScale = _prtfObject->yScale = 100;
_prtfObject->cBitsPerPixel = 1;
_prtfObject->cColorPlanes = 1;
_prtfObject->szClass = NULL;
_prtfObject->szName = NULL;
_prtfObject->sType = -1;
break;
case tokenObjectEBookImage:
// Added by VikramM for E-Book
//
_prtfObject->sType = ROT_EBookImage;
break;
case tokenObjectEmbedded: // \objemb
case tokenObjectLink: // \objlink
case tokenObjectAutoLink: // \objautlink
PARSERCOVERAGE_CASE();
_prtfObject->sType = (SHORT)(_token - tokenObjectEmbedded + ROT_Embedded);
break;
case tokenObjectMacSubscriber: // \objsub
case tokenObjectMacPublisher: // \objpub
case tokenObjectMacICEmbedder:
PARSERCOVERAGE_CASE();
_prtfObject->sType = ROT_MacEdition;
break;
case tokenWidth: // \picw N or \objw N
PARSERCOVERAGE_CASE();
_prtfObject->xExt = iParam;
break;
case tokenHeight: // \pic N or \objh N
PARSERCOVERAGE_CASE();
_prtfObject->yExt = iParam;
break;
case tokenObjectSetSize: // \objsetsize
PARSERCOVERAGE_CASE();
_prtfObject->fSetSize = TRUE;
break;
case tokenScaleX: // \picscalex N or \objscalex N
PARSERCOVERAGE_CASE();
_prtfObject->xScale = iParam;
break;
case tokenScaleY: // \picscaley N or \objscaley N
PARSERCOVERAGE_CASE();
_prtfObject->yScale = iParam;
break;
case tokenCropLeft: // \piccropl or \objcropl
case tokenCropTop: // \piccropt or \objcropt
case tokenCropRight: // \piccropr or \objcropr
case tokenCropBottom: // \piccropb or \objcropb
PARSERCOVERAGE_CASE();
*((LONG *)&_prtfObject->rectCrop
+ (_token - tokenCropLeft)) = iParam;
break;
case tokenObjectClass: // \objclass
PARSERCOVERAGE_CASE();
pstate->sDest = destObjectClass;
break;
case tokenObjectName: // \objname
PARSERCOVERAGE_CASE();
pstate->sDest = destObjectName;
break;
case tokenObjectResult: // \result
PARSERCOVERAGE_CASE();
if(_fMac || // If it's Mac stuff, we don't
_prtfObject->sType==ROT_MacEdition ||// understand the data, or if
_fFailedPrevObj || _fNeedPres) // we need an obj presentation,
{
pstate->sDest = destRTF; // use the object results
break;
}
goto skip_group;
case tokenObjectData: // \objdata
PARSERCOVERAGE_CASE();
pstate->sDest = destObjectData;
if(_prtfObject->sType==ROT_MacEdition) // It's Mac stuff so just
goto skip_group; // throw away the data
break;
case tokenPictureWindowsMetafile: // \wmetafile
#ifdef NOMETAFILES
goto skip_group;
#endif NOMETAFILES
case tokenPngBlip: // \pngblip
case tokenJpegBlip: // \jpegblip
case tokenPictureWindowsDIB: // \dibitmap N
case tokenPictureWindowsBitmap: // \wbitmap N
PARSERCOVERAGE_CASE();
_prtfObject->sType = (SHORT)(_token - tokenPictureWindowsBitmap + ROT_Bitmap);
_prtfObject->sPictureType = (SHORT)iParam;
break;
case tokenBitmapBitsPerPixel: // \wbmbitspixel N
PARSERCOVERAGE_CASE();
_prtfObject->cBitsPerPixel = (SHORT)iParam;
break;
case tokenBitmapNumPlanes: // \wbmplanes N
PARSERCOVERAGE_CASE();
_prtfObject->cColorPlanes = (SHORT)iParam;
break;
case tokenBitmapWidthBytes: // \wbmwidthbytes N
PARSERCOVERAGE_CASE();
_prtfObject->cBytesPerLine = (SHORT)iParam;
break;
case tokenDesiredWidth: // \picwgoal N
PARSERCOVERAGE_CASE();
_prtfObject->xExtGoal = (SHORT)iParam;
break;
case tokenDesiredHeight: // \pichgoal N
PARSERCOVERAGE_CASE();
_prtfObject->yExtGoal = (SHORT)iParam;
break;
case tokenBinaryData: // \bin N
PARSERCOVERAGE_CASE();
// Update OleGet function
RTFReadOLEStream.lpstbl->Get =
(DWORD (CALLBACK* )(LPOLESTREAM, void FAR*, DWORD))
RTFGetBinaryDataFromStream;
_cbBinLeft = iParam; // Set data length
switch (pstate->sDest)
{
case destObjectData:
_fFailedPrevObj = !ObjectReadFromEditStream();
break;
case destPicture:
StaticObjectReadFromEditStream(iParam);
break;
default:
AssertSz(FALSE, "Binary data hit but don't know where to put it");
}
// Restore OleGet function
RTFReadOLEStream.lpstbl->Get =
(DWORD (CALLBACK* )(LPOLESTREAM, void FAR*, DWORD))
RTFGetFromStream;
break;
case tokenObjectDataValue:
PARSERCOVERAGE_CASE();
if(_prtfObject->sType != ROT_EBookImage) // Added by VikramM for E-Book
{
// Normal processing
_fFailedPrevObj = !ObjectReadFromEditStream();
}
else
{
// Do the Ebook Image callback here and set the _prtfObject size here
// Don't need to read the image data at this point, we just want to
// do a callback at a later point to have the E-Book shell render the image
_fFailedPrevObj = !ObjectReadEBookImageInfoFromEditStream();
}
goto EndOfObjectStream;
case tokenPictureDataValue:
PARSERCOVERAGE_CASE();
StaticObjectReadFromEditStream();
EndOfObjectStream:
if(!SkipToEndOfGroup())
HandleEndGroup();
break;
case tokenObjectPlaceholder:
PARSERCOVERAGE_CASE();
if(_ped->GetEventMask() & ENM_OBJECTPOSITIONS)
{
if(!_pcpObPos)
{
_pcpObPos = (LONG *)PvAlloc(sizeof(ULONG) * cobPosInitial, GMEM_ZEROINIT);
if(!_pcpObPos)
{
_ecParseError = ecNoMemory;
break;
}
_cobPosFree = cobPosInitial;
_cobPos = 0;
}
if(_cobPosFree-- <= 0)
{
const int cobPosNew = _cobPos + cobPosChunk;
LPVOID pv;
pv = PvReAlloc(_pcpObPos, sizeof(ULONG) * cobPosNew);
if(!pv)
{
_ecParseError = ecNoMemory;
break;
}
_pcpObPos = (LONG *)pv;
_cobPosFree = cobPosChunk - 1;
}
_pcpObPos[_cobPos++] = _prg->GetCp();
}
break;
default:
PARSERCOVERAGE_DEFAULT();
if(pstate->sDest != destFieldInstruction && // Values outside token
(DWORD)(_token - tokenMin) > // range are treated
(DWORD)(tokenMax - tokenMin)) // as Unicode chars
{
// 1.0 mode doesn't use Unicode bullets nor smart quotes
if (_ped->Get10Mode() && IN_RANGE(LQUOTE, _token, RDBLQUOTE))
{
if (_token == LQUOTE || _token == RQUOTE)
_token = L'\'';
else if (_token == LDBLQUOTE || _token == RDBLQUOTE)
_token = L'\"';
}
if(!IsLowMergedCell())
HandleChar(_token);
}
#if defined(DEBUG) && !defined(NOFULLDEBUG)
else
{
if(GetProfileIntA("RICHEDIT DEBUG", "RTFCOVERAGE", 0))
{
CHAR *pszKeyword = PszKeywordFromToken(_token);
CHAR szBuf[256];
sprintf(szBuf, "CRTFRead::HandleToken(): Token not processed - token = %d, %s%s%s",
_token,
"keyword = ",
pszKeyword ? "\\" : "<unknown>",
pszKeyword ? pszKeyword : "");
AssertSz(0, szBuf);
}
}
#endif
}
TRACEERRSZSC("HandleToken()", - _ecParseError);
return _ecParseError;
}
/*
* CRTFRead::IsLowMergedCell()
*
* @mfunc
* Return TRUE iff _prg is currently in a low merged table cell. Note
* that RichEdit can't insert any text into a low merged cell, but
* Word's RTF sometimes attempts to, e.g., {\listtext...} ignored
* by Word can be (erroneously) emitted for insertion into these cells.
* Hence we discard such insertions.
*
* @rdesc
* Return TRUE iff _prg is currently in a low merged table cell
*/
BOOL CRTFRead::IsLowMergedCell()
{
if(!_bTableLevel)
return FALSE;
CELLPARMS *pCellParms = (CELLPARMS *)&_rgxCell[0];
return IsLowCell(pCellParms[_iCell].uCell);
}
/*
* CRTFRead::Pard(pstate)
*
* @mfunc
* Reset paragraph and pstate properties to default values
*/
void CRTFRead::Pard(
STATE *pstate)
{
if(IN_RANGE(destColorTable, pstate->sDest, destPicture))
{
_ecParseError = ecAbort;
return;
}
BYTE bT = _PF._bOutlineLevel; // Save outline level
_PF.InitDefault(_bDocType == DT_RTLDOC ? PFE_RTLPARA : 0);
// Reset para formatting
pstate->fBullet = FALSE;
pstate->sIndentNumbering = 0;
_cTab = 0; // No tabs defined
_bTabLeader = 0;
_bTabType = 0;
_bBorder = 0;
_fStartRow = FALSE;
_PF._bOutlineLevel = (BYTE)(bT | 1);
_dwMaskPF = PFM_ALLRTF;
_dwMaskPF2 = PFM2_TABLEROWSHIFTED;
}
/*
* CRTFRead::DelimitRow(szRowDelimiter)
*
* @mfunc
* Insert start-of-row or end-of-row paragraph with current table
* properties
*/
void CRTFRead::DelimitRow(
WCHAR *szRowDelimiter) //@parm Delimit text to insert
{
if(!_ped->_pdp->IsMultiLine()) // No tables in single line
{ // controls
_ecParseError = ecTruncateAtCRLF;
return;
}
LONG nTableIndex = _bTableLevel;
if(szRowDelimiter == szRowEnd)
{
if(!_iCell) // Bad RTF: \row with no \cell,
HandleCell(); // so fake one
nTableIndex--;
}
if(nTableIndex + _bTableLevelIP >= MAXTABLENEST)
{
if(szRowDelimiter == szRowEnd) // Maintain _bTableLevel
_bTableLevel--;
else
_bTableLevel++;
_token = tokenEndParagraph;
HandleEndOfPara();
return;
}
if(szRowDelimiter == szRowStart && _prg->GetCp() && !_prg->_rpTX.IsAfterEOP())
{
_token = tokenEndParagraph;
HandleEndOfPara();
}
Assert(_pstateStackTop && _pstateStackTop->pPF);
// Add _PF diffs to *_pstateStackTop->pPF
if(!_pstateStackTop->AddPF(_PF, _bDocType, _dwMaskPF, _dwMaskPF2))
{
_ped->GetCallMgr()->SetOutOfMemory();
_ecParseError = ecNoMemory;
return;
}
DWORD dwMaskPF = _pstateStackTop->dwMaskPF; // Save PF for restoration
DWORD dwMaskPF2 = _pstateStackTop->dwMaskPF2; // Save PF for restoration
SHORT iTabs = -1;
CParaFormat PF = *_pstateStackTop->pPF; // on return
_PF.InitDefault(_fRTLRow ? PFE_RTLPARA : 0);
_fStartRow = FALSE;
_dwMaskPF = PFM_ALLRTF;
_dwMaskPF2 = 0;
if(_wBorderWidth) // Store any border info
{
_PF._dwBorderColor = _dwBorderColors;
_PF._wBorders = _wBorders;
_PF._wBorderSpace = _wBorderSpace;
_PF._wBorderWidth = _wBorderWidth;
_dwMaskPF |= PFM_BORDER;
}
_PF._bAlignment = _bAlignment; // Row alignment (no cell align)
_PF._dxStartIndent = _xRowOffset; // \trleft N
_PF._dxOffset = max(_dxCell, 10); // \trgaph N
_PF._dyLineSpacing = _dyRow; // \trrh N
_PF._wEffects |= PFE_TABLE | PFE_TABLEROWDELIMITER;
BOOL fHidden = _ped->GetCharFormat(_prg->Get_iFormat())->_dwEffects & CFE_HIDDEN;
_prg->_rpCF.AdjustBackward();
if(_prg->IsHidden())
{
CCharFormat CF;
CF._dwEffects = 0; // Don't hide EOP preceding TRD
_prg->BackupCRLF(CSC_NORMAL, TRUE);
_prg->SetCharFormat(&CF, 0, NULL, CFM_HIDDEN, 0);
CheckNotifyLowFiRTF(TRUE);
_prg->AdvanceCRLF(CSC_NORMAL, FALSE);
}
_prg->_rpCF.AdjustForward();
AssertSz(!_prg->GetCp() || IsEOP(_prg->GetPrevChar()),
"CRTFRead::DelimitRow: no EOP precedes TRD");
if(AddText(szRowDelimiter, 2, FALSE) != ecNoError)
goto cleanup;
if(!_bTableLevel && _PF._dxStartIndent < 50)// Move neg shifted table right
{ // (handles common default Word table)
_PF._wEffects |= PFE_TABLEROWSHIFTED;
_dwMaskPF2 |= PFM2_TABLEROWSHIFTED;
_PF._dxStartIndent += _dxCell + 50; // 50 gives room for left border
}
if(szRowDelimiter == szRowStart)
_bTableLevel++;
_PF._bTableLevel = _bTableLevel + _bTableLevelIP;
iTabs = Apply_PF();
if(szRowDelimiter == szRowStart)
{
if(_bTableLevel == 1)
_iTabsLevel1 = iTabs;
_rgTableState[nTableIndex]._iCell = _iCell;
_rgTableState[nTableIndex]._cCell = _cCell;
if(_token == tokenTableLevel)
_cCell = 0;
_iCell = 0;
if(!_cCell) // Cache if need to recompute row PF
_dwRowResolveFlags |= 1 << _bTableLevel;
}
else
{
Assert(szRowDelimiter == szRowEnd);
DWORD dwMask = 1 << _bTableLevel;
if(_dwRowResolveFlags & dwMask)
{ // Copy iPF over to corresponding
CPFRunPtr rpPF(*_prg); // row header
rpPF.ResolveRowStartPF();
_dwRowResolveFlags &= (dwMask - 1);
// Insert NOTACHARs for cells
LONG cp = _prg->GetCp(); // vert merged with cells above
LONG j = _cCell - 1;
CELLPARMS *pCellParms = (CELLPARMS *)&_rgxCell[0];
WCHAR szNOTACHAR[1] = {NOTACHAR};
_prg->Move(-2, FALSE); // Move before row-end delimiter
for(LONG i = _cCell; i--;) // and CELL mark
{
if(IsLowCell(pCellParms[i].uCell))
{
if(i != j)
_prg->Move(tomCell, i - j, NULL);
if(_prg->GetPrevChar() == CELL)
_prg->Move(-1, FALSE); // Backspace over CELL mark
Assert(_prg->_rpTX.GetChar() == CELL);
if(_prg->_rpTX.GetPrevChar() == NOTACHAR)
_prg->Move(-1, FALSE);
else
{
_prg->ReplaceRange(1, szNOTACHAR, NULL, SELRR_IGNORE, NULL, 0);
_prg->Move(-2, FALSE); // Backspace over NOTACHAR CELL combo
cp++;
}
j = i - 1;
}
}
_prg->SetCp(cp, FALSE); // Reposition rg after end-row delim
Assert(_prg->_rpTX.IsAfterTRD(ENDFIELD));
}
_bTableLevel--; // End of current row
_iCell = _rgTableState[nTableIndex]._iCell;
_cCell = _rgTableState[nTableIndex]._cCell;
if(!_bTableLevel)
_fStartRow = TRUE; // Tell AddText to start new row
} // unless \pard terminates it
_cpThisPara = _prg->GetCp(); // New para starts after CRLF
cleanup:
_PF = PF;
_dwMaskPF = dwMaskPF;
_dwMaskPF2 = dwMaskPF2;
if(fHidden) // Restore hidden property
{
_CF._dwEffects |= CFE_HIDDEN;
_dwMaskCF |= CFM_HIDDEN;
}
Assert(!(_PF._wEffects & PFE_TABLEROWDELIMITER));
}
/*
* CRTFRead::InitializeTableRowParms()
*
* @mfunc
* Initialize table parms to no table state
*/
void CRTFRead::InitializeTableRowParms()
{
// Initialize table parms
_cCell = 0; // No table cells yet
_iCell = 0;
_fStartRow = FALSE;
_wBorderWidth = 0;
_bAlignment = PFA_LEFT;
_xRowOffset = 0;
_dxCell = 0;
_dyRow = 0;
_iTabsTable = -1;
}
/*
* CRTFRead::ReadRtf()
*
* @mfunc
* The range _prg is replaced by RTF data resulting from parsing the
* input stream _pes. The CRTFRead object assumes that the range is
* already degenerate (caller has to delete the range contents, if
* any, before calling this routine). Currently any info not used
* or supported by RICHEDIT is thrown away.
*
* @rdesc
* Number of chars inserted into text. 0 means none were inserted
* OR an error occurred.
*/
LONG CRTFRead::ReadRtf()
{
TRACEBEGIN(TRCSUBSYSRTFR, TRCSCOPEINTERN, "CRTFRead::ReadRtf");
LONG cpFirst;
LONG cpFirstInPara;
CTxtRange * prg = _prg;
STATE * pstate;
cpFirst = _cpFirst = prg->GetCp();
if (!_cchMax)
{
// At text limit already, forget it.
_ecParseError = ecTextMax;
goto Quit;
}
if(!InitLex())
goto Quit;
TESTPARSERCOVERAGE();
AssertSz(!prg->GetCch(),
"CRTFRead::ReadRtf: range must be deleted");
if(!(_dwFlags & SFF_SELECTION))
{
// SFF_SELECTION is set if any kind of paste is being done, i.e.,
// not just that using the selection. If it isn't set, data is
// being streamed in and we allow this to reset the doc params
if(_ped->InitDocInfo() != NOERROR)
{
_ecParseError = ecNoMemory;
goto Quit;
}
}
prg->SetIgnoreFormatUpdate(TRUE);
_szUnicode = (WCHAR *)PvAlloc(cachTextMax * sizeof(WCHAR), GMEM_ZEROINIT);
if(!_szUnicode) // Allocate space for Unicode conversions
{
_ped->GetCallMgr()->SetOutOfMemory();
_ecParseError = ecNoMemory;
goto CleanUp;
}
_cchUnicode = cachTextMax;
// Initialize per-read variables
_nCodePage = (_dwFlags & SF_USECODEPAGE)
? (_dwFlags >> 16) : INVALID_CODEPAGE;
// Populate _PF with initial paragraph formatting properties
_PF = *prg->GetPF();
_dwMaskPF = PFM_ALLRTF; // Setup initial MaskPF
_PF._iTabs = -1; // In case it's not -1
if(_PF.IsTableRowDelimiter()) // Do _not_ insert with this property!
{
if(prg->_rpTX.IsAtTRD(ENDFIELD))
{
prg->AdvanceCRLF(CSC_NORMAL, FALSE);// Bypass table row-end delimiter
cpFirst = prg->GetCp(); // Update value
_PF = *prg->GetPF(); // Might still be row-start delimiter
_PF._iTabs = -1;
Assert(!prg->_rpTX.IsAtTRD(ENDFIELD));
}
if(prg->_rpTX.IsAtTRD(STARTFIELD))
{
// REVIEW: this if can probably be omitted now since the caller calls
// DeleteWithTRDCheck()
_ecParseError = ecGeneralFailure;
goto CleanUp;
}
}
_bTableLevelIP = _PF._bTableLevel; // Save table level of insertion pt
AssertSz(_bTableLevelIP >= 0, "CRTFRead::ReadRtf: illegal table level");
// V-GUYB: PWord Converter requires loss notification.
#ifdef REPORT_LOSSAGE
if(!(_dwFlags & SFF_SELECTION)) // SFF_SELECTION is set if any
{ // kind of paste is being done
((LOST_COOKIE*)(_pes->dwCookie))->bLoss = FALSE;
}
#endif // REPORT_LOSSAGE
// Valid RTF files start with "{\rtf", "{urtf", or "{\pwd"
GetChar(); // Fill input buffer
UngetChar(); // Put char back
if(!IsRTF((char *)_pchRTFCurrent, _pchRTFEnd - _pchRTFCurrent)) // Is it RTF?
{ // No
if (_ped->Get10Mode())
_fNoRTFtoken = TRUE;
else
{
_ecParseError = ecUnexpectedToken; // Signal bad file
goto CleanUp;
}
}
// If initial cp follows EOP, use it for _cpThisPara. Else
// search for start of para containing the initial cp.
_cpThisPara = prg->GetCp();
if(!prg->_rpTX.IsAfterEOP())
{
CTxtPtr tp(prg->_rpTX);
tp.FindEOP(tomBackward);
_cpThisPara = tp.GetCp();
}
cpFirstInPara = _cpThisPara; // Backup to start of para before
// parsing
while ( TokenGetToken() != tokenEOF && // Process tokens
_token != tokenError &&
!HandleToken() &&
_pstateStackTop )
;
if(_ecParseError == ecAbort) // Really vile error: delete anything
{ // that was inserted
prg->Set(prg->GetCp(), prg->GetCp() - cpFirst);
prg->ReplaceRange(0, NULL, NULL, SELRR_IGNORE, NULL,
RR_NO_LP_CHECK | RR_NO_TRD_CHECK | RR_NO_CHECK_TABLE_SEL);
goto CleanUp;
}
if(_bTableLevel) // Whoops! still in middle of table
{
LONG cpMin;
prg->_rpPF.AdjustBackward(); // Be sure to get preceding level
prg->FindRow(&cpMin, NULL, _bTableLevelIP + 1);// Find beginning of row and
if(cpMin == prg->GetCp()) // delete from there to here
{ // No table formatting yet
LONG ch; // Just delete back to STARTFIELD
CTxtPtr tp(prg->_rpTX);
while((ch = tp.PrevChar()) && ch != STARTFIELD)
;
cpMin = tp.GetCp();
}
cpMin = max(cpMin, _cpFirst);
prg->Set(prg->GetCp(), prg->GetCp() - cpMin);
prg->ReplaceRange(0, NULL, NULL, SELRR_IGNORE, NULL,
RR_NO_LP_CHECK | RR_NO_TRD_CHECK | RR_NO_CHECK_TABLE_SEL);
#ifdef DEBUG
prg->_rpTX.MoveGapToEndOfBlock();
#endif
}
_cCell = _iCell = 0;
prg->SetIgnoreFormatUpdate(FALSE); // Enable range _iFormat updates
prg->Update_iFormat(-1); // Update _iFormat to CF
// at current active end
if(!(_dwFlags & SFF_SELECTION)) // RTF applies to document:
{ // update CDocInfo
// Apply char and para formatting of
// final text run to final CR
if (prg->GetCp() == _ped->GetAdjustedTextLength() &&
!(_dwMaskPF & (PFM_TABLEROWDELIMITER | PFM_TABLE)))
{
// REVIEW: we need to think about what para properties should
// be transferred here. E.g., borders were being transferred
// incorrectly
_dwMaskPF &= ~(PFM_BORDER | PFM_SHADING);
Apply_PF();
prg->ExtendFormattingCRLF();
}
// Update the per-document information from the RTF read
CDocInfo *pDocInfo = _ped->GetDocInfoNC();
if(!pDocInfo)
{
Assert(FALSE); // Should be allocated by
_ecParseError = ecNoMemory; // earlier call in this function
goto CleanUp;
}
if (ecNoError == _ecParseError) // If range end EOP wasn't
prg->DeleteTerminatingEOP(NULL); // deleted and new text
// ends with an EOP, delete that EOP
pDocInfo->_wCpg = (WORD)(_nCodePage == INVALID_CODEPAGE ?
tomInvalidCpg : _nCodePage);
if (pDocInfo->_wCpg == CP_UTF8)
pDocInfo->_wCpg = 1252;
_ped->SetDefaultLCID(_sDefaultLanguage == INVALID_LANGUAGE ?
tomInvalidLCID :
MAKELCID(_sDefaultLanguage, SORT_DEFAULT));
_ped->SetDefaultLCIDFE(_sDefaultLanguageFE == INVALID_LANGUAGE ?
tomInvalidLCID :
MAKELCID(_sDefaultLanguageFE, SORT_DEFAULT));
_ped->SetDefaultTabStop(TWIPS_TO_FPPTS(_sDefaultTabWidth));
_ped->SetDocumentType(_bDocType);
}
if(_ped->IsComplexScript() && prg->GetCp() > cpFirstInPara)
{
Assert(!prg->GetCch());
LONG cpSave = prg->GetCp();
LONG cpLastInPara = cpSave;
if(_ped->IsBiDi() && !prg->_rpTX.IsAtEOP())
{
CTxtPtr tp(prg->_rpTX);
tp.FindEOP(tomForward);
cpLastInPara = tp.GetCp();
prg->Move(cpLastInPara - cpSave, FALSE);
}
// Itemize from the start of paragraph to be inserted till the end of
// paragraph inserting. We need to cover all affected paragraphs because
// paragraphs we're playing could possibly in conflict direction. Think
// about the case that the range covers one LTR para and one RTL para, then
// the inserting text covers one RTL and one LTR. Both paragraphs' direction
// could have been changed after this insertion.
prg->ItemizeReplaceRange(cpLastInPara - cpFirstInPara, 0, NULL,
_ped->IsBiDi() && !_fNon0CharSet);
if (cpLastInPara != cpSave)
prg->SetCp(cpSave, FALSE);
}
CleanUp:
FreeRtfObject();
pstate = _pstateStackTop;
if(pstate) // Illegal RTF file. Release
{ // unreleased format indices
if(ecNoError == _ecParseError) // It's only an overflow if no
_ecParseError = ecStackOverflow; // other error has occurred
if(_ecParseError != ecAbort)
HandleFieldEndGroup(); // Cleanup possible partial field
while(pstate->pstatePrev)
{
pstate = pstate->pstatePrev;
ReleaseFormats(pstate->iCF, -1);
}
}
pstate = _pstateLast;
if(pstate)
{
while(pstate->pstatePrev) // Free all but first STATE
{
pstate->DeletePF();
pstate = pstate->pstatePrev;
FreePv(pstate->pstateNext);
}
pstate->DeletePF();
}
Assert(_PF._iTabs == -1);
FreePv(pstate); // Free first STATE
FreePv(_szUnicode);
Quit:
DeinitLex();
if(_pcpObPos)
{
if((_ped->GetEventMask() & ENM_OBJECTPOSITIONS) && _cobPos > 0)
{
OBJECTPOSITIONS obpos;
obpos.cObjectCount = _cobPos;
obpos.pcpPositions = _pcpObPos;
if (_ped->Get10Mode())
{
LONG *pcpPositions = _pcpObPos;
for (LONG i = 0; i < _cobPos; i++, pcpPositions++)
*pcpPositions = _ped->GetAcpFromCp(*pcpPositions);
}
_ped->TxNotify(EN_OBJECTPOSITIONS, &obpos);
}
FreePv(_pcpObPos);
_pcpObPos = NULL;
}
// transcribed from winerror.h
#define ERROR_HANDLE_EOF 38L
// FUTURE(BradO): We should devise a direct mapping from our error codes
// to Win32 error codes. In particular our clients are
// not expecting the error code produced by:
// _pes->dwError = (DWORD) -(LONG) _ecParseError;
if(_ecParseError)
{
AssertSz(_ecParseError >= 0,
"Parse error is negative");
if(_ecParseError == ecTextMax)
{
_ped->GetCallMgr()->SetMaxText();
_pes->dwError = (DWORD)STG_E_MEDIUMFULL;
}
if(_ecParseError == ecUnexpectedEOF)
_pes->dwError = (DWORD)HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
if(!_pes->dwError && _ecParseError != ecTruncateAtCRLF)
_pes->dwError = (DWORD) -(LONG) _ecParseError;
#if defined(DEBUG)
TRACEERRSZSC("CchParse_", _pes->dwError);
if(ecNoError < _ecParseError && _ecParseError < ecLastError)
Tracef(TRCSEVERR, "Parse error: %s", rgszParseError[_ecParseError]);
#endif
}
if(cpFirst > _cpFirst && prg->GetCp() == cpFirst)
{
prg->SetCp(_cpFirst, FALSE); // Restore prg cp, since nothing inserted
return 0;
}
return prg->GetCp() - cpFirst;
}
/*
* CRTFRead::CpgInfoFromFaceName()
*
* @mfunc
* This routine fills in the TEXTFONT::bCharSet and TEXTFONT::nCodePage
* members of the TEXTFONT structure by querying the system for the
* metrics of the font described by TEXTFONT::szName.
*
* @rdesc
* A flag indicating whether the charset and codepage were successfully
* determined.
*/
BOOL CRTFRead::CpgInfoFromFaceName(
TEXTFONT *ptf)
{
// FUTURE(BradO): This code is a condensed version of a more sophisticated
// algorithm we use in font.cpp to second-guess the font-mapper.
// We should factor out the code from font.cpp for use here as well.
// Indicates that we've tried to obtain the cpg info from the system,
// so that after a failure we don't re-call this routine.
ptf->fCpgFromSystem = TRUE;
if(ptf->fNameIsDBCS)
{
// If fNameIsDBCS, we have high-ANSI characters in the facename, and
// no codepage with which to interpret them. The facename is gibberish,
// so don't waste time calling the system to match it.
return FALSE;
}
HDC hdc = _ped->TxGetDC();
if(!hdc)
return FALSE;
LOGFONT lf = {0};
TEXTMETRIC tm;
wcscpy(lf.lfFaceName, ptf->szName);
lf.lfCharSet = CharSetFromCharRep(CharRepFromCodePage(GetSystemDefaultCodePage()));
if(!GetTextMetrics(hdc, lf, tm) || tm.tmCharSet != lf.lfCharSet)
{
lf.lfCharSet = DEFAULT_CHARSET; // Doesn't match default sys
GetTextMetrics(hdc, lf, tm); // charset, so see what
} // DEFAULT_CHARSET gives
_ped->TxReleaseDC(hdc);
if(tm.tmCharSet != DEFAULT_CHARSET) // Got something, so use it
{
ptf->iCharRep = CharRepFromCharSet(tm.tmCharSet);
ptf->sCodePage = (SHORT)CodePageFromCharRep(ptf->iCharRep);
return TRUE;
}
return FALSE;
}
// Including a source file, but we only want to compile this code for debug purposes
#if defined(DEBUG)
#include "rtflog.cpp"
#endif
Reference in a new issue Copy permalink