1855 lines
56 KiB
C
1855 lines
56 KiB
C
#include "lsidefs.h"
|
|
#include "dninfo.h"
|
|
#include "dnutils.h"
|
|
#include "fmti.h"
|
|
#include "getfmtst.h"
|
|
#include "iobj.h"
|
|
#include "iobjln.h"
|
|
#include "lsc.h"
|
|
#include "lsdnode.h"
|
|
#include "lsfetch.h"
|
|
#include "lsfrun.h"
|
|
#include "lsline.h"
|
|
#include "lsesc.h"
|
|
#include "lstext.h"
|
|
#include "ntiman.h"
|
|
#include "qheap.h"
|
|
#include "setfmtst.h"
|
|
#include "tabutils.h"
|
|
#include "zqfromza.h"
|
|
#include "lssubl.h"
|
|
#include "autonum.h"
|
|
#include "lscfmtfl.h"
|
|
|
|
#include <limits.h>
|
|
#include "lsmem.h" /* memset() */
|
|
|
|
/* L I M R G */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: LimRg
|
|
%%Contact: igorzv
|
|
|
|
Returns # of elements in an array.
|
|
----------------------------------------------------------------------------*/
|
|
#define LimRg(rg) (sizeof(rg)/sizeof((rg)[0]))
|
|
|
|
|
|
|
|
/* A S S E R T V A L I D F M T R E S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Macro: AssertValidFmtres
|
|
%%Contact: lenoxb
|
|
|
|
Verifies that fmtrCk has a legal value.
|
|
----------------------------------------------------------------------------*/
|
|
#define AssertValidFmtres(fmtrCk) \
|
|
Assert( \
|
|
(fmtrCk) == fmtrCompletedRun || \
|
|
(fmtrCk) == fmtrExceededMargin || \
|
|
(fmtrCk) == fmtrTab || \
|
|
(fmtrCk) == fmtrStopped \
|
|
);
|
|
|
|
|
|
|
|
|
|
/* S E T T O M A X */
|
|
/*----------------------------------------------------------------------------
|
|
%%Macro: SetToMax
|
|
%%Contact: lenoxb
|
|
|
|
Sets "a" to the maximum of "a" and "b".
|
|
----------------------------------------------------------------------------*/
|
|
#define SetToMax(a,b) if ((a) < (b)) (a) = (b); else
|
|
|
|
|
|
|
|
|
|
/* S E T H E I G H T T O M A X */
|
|
/*----------------------------------------------------------------------------
|
|
%%Macro: SetHeightToMax
|
|
%%Contact: igorzv
|
|
|
|
Sets the line height elements of an LSLINFO structure to the maximum
|
|
of their current value, and the height of an arbitrary object.
|
|
(plslinfo)->dvrMultiLineHeight == dvHeightIgnore is sign not
|
|
to take into account this dnode
|
|
----------------------------------------------------------------------------*/
|
|
#define SetHeightToMax(plslinfo,pobjdim) \
|
|
{\
|
|
if ((pobjdim)->heightsRef.dvMultiLineHeight != dvHeightIgnore)\
|
|
{\
|
|
SetToMax((plslinfo)->dvrAscent, (pobjdim)->heightsRef.dvAscent);\
|
|
SetToMax((plslinfo)->dvpAscent, (pobjdim)->heightsPres.dvAscent);\
|
|
SetToMax((plslinfo)->dvrDescent, (pobjdim)->heightsRef.dvDescent);\
|
|
SetToMax((plslinfo)->dvpDescent, (pobjdim)->heightsPres.dvDescent);\
|
|
SetToMax((plslinfo)->dvpMultiLineHeight, (pobjdim)->heightsPres.dvMultiLineHeight);\
|
|
SetToMax((plslinfo)->dvrMultiLineHeight, (pobjdim)->heightsRef.dvMultiLineHeight);\
|
|
}\
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define PlnobjFromLsc(plsc,iobj) ((Assert(FIsLSC(plsc)), PlnobjFromLsline((plsc)->plslineCur,iobj)))
|
|
|
|
#define CreateLNObjInLsc(plsc, iobj) ((PLsimFromLsc(&((plsc)->lsiobjcontext),iobj))->pfnCreateLNObj\
|
|
(PilsobjFromLsc(&((plsc)->lsiobjcontext),iobj), \
|
|
&((plsc)->plslineCur->rgplnobj[iobj])))
|
|
|
|
/* This macros created to avoid code duplication */
|
|
|
|
#define FRunIsNotSimple(plschp, fHidden) \
|
|
(((plschp)->idObj != idObjTextChp) || \
|
|
((fHidden)) || \
|
|
((plschp)->fBorder) || \
|
|
FApplyNominalToIdeal(plschp))
|
|
|
|
#define CreateDnode(plsc, plsdnNew) \
|
|
(plsdnNew) = PvNewQuick(GetPqhAllDNodes(plsc), sizeof *(plsdnNew));\
|
|
if ((plsdnNew) == NULL)\
|
|
return lserrOutOfMemory;\
|
|
(plsdnNew)->tag = tagLSDNODE;\
|
|
(plsdnNew)->plsdnPrev = GetCurrentDnode(plsc);\
|
|
(plsdnNew)->plsdnNext = NULL;\
|
|
(plsdnNew)->plssubl = GetCurrentSubline(plsc);\
|
|
/* we don't connect dnode list with this dnode untill handler calls*/ \
|
|
/*Finish API, but we put correct pointer to previous in this dnode,*/ \
|
|
/*so we can easily link list in Finish routines */\
|
|
(plsdnNew)->cpFirst = GetCurrentCpLim(plsc); \
|
|
/* flush all flags, bellow check that result is what we expect */ \
|
|
*((DWORD *) ((&(plsdnNew)->dcp)+1)) = 0;\
|
|
Assert((plsdnNew)->klsdn == klsdnReal);\
|
|
Assert((plsdnNew)->fRigidDup == fFalse);\
|
|
Assert((plsdnNew)->fAdvancedPen == fFalse);\
|
|
Assert((plsdnNew)->fTab == fFalse);\
|
|
Assert((plsdnNew)->icaltbd == 0);\
|
|
Assert((plsdnNew)->fBorderNode == fFalse);\
|
|
Assert((plsdnNew)->fOpenBorder == fFalse);\
|
|
Assert((plsdnNew)->fEndOfSection == fFalse); \
|
|
Assert((plsdnNew)->fEndOfColumn == fFalse); \
|
|
Assert((plsdnNew)->fEndOfPage == fFalse); \
|
|
Assert((plsdnNew)->fEndOfPara == fFalse); \
|
|
Assert((plsdnNew)->fAltEndOfPara == fFalse); \
|
|
Assert((plsdnNew)->fSoftCR == fFalse); \
|
|
Assert((plsdnNew)->fInsideBorder == fFalse); \
|
|
Assert((plsdnNew)->fAutoDecTab == fFalse); \
|
|
Assert((plsdnNew)->fTabForAutonumber == fFalse);
|
|
|
|
|
|
#define FillRealPart(plsdnNew, plsfrunOfDnode)\
|
|
/* we don't initialize here variables that will be set in FiniSimpleRegular */ \
|
|
(plsdnNew)->u.real.pinfosubl = NULL;\
|
|
/* next two assignement we do to use DestroyDnodeList in the case of error */ \
|
|
(plsdnNew)->u.real.plsrun = (plsfrunOfDnode)->plsrun;\
|
|
(plsdnNew)->u.real.pdobj = NULL;\
|
|
/* we put amount of characters to dcp to check it in LsdnFinishSimpleByOneChar */ \
|
|
(plsdnNew)->dcp = (plsfrunOfDnode)->cwchRun; \
|
|
(plsdnNew)->cpLimOriginal = (plsdnNew)->cpFirst + (plsdnNew)->dcp;
|
|
|
|
#define CreateRealDnode(plsc,plsdnNew, plsrun)\
|
|
CreateDnode((plsc), (plsdnNew));\
|
|
FillRealPart((plsdnNew), (plsrun));
|
|
|
|
#define CreatePenDnode(plsc,plsdnNew)\
|
|
CreateDnode((plsc), (plsdnNew));\
|
|
(plsdnNew)->dcp = 0;\
|
|
(plsdnNew)->cpLimOriginal = (plsdnNew)->cpFirst;\
|
|
(plsdnNew)->u.pen.dur = 0;\
|
|
(plsdnNew)->u.pen.dup = 0;\
|
|
(plsdnNew)->u.pen.dvr = 0;\
|
|
(plsdnNew)->u.pen.dvp = 0;\
|
|
(plsdnNew)->klsdn = klsdnPenBorder;
|
|
|
|
#define CreateBorderDnode(plsc,plsdnNew, durBorder, dupBorder)\
|
|
CreateDnode((plsc), (plsdnNew));\
|
|
(plsdnNew)->dcp = 0;\
|
|
(plsdnNew)->cpLimOriginal = (plsdnNew)->cpFirst;\
|
|
(plsdnNew)->u.pen.dur = (durBorder);\
|
|
(plsdnNew)->u.pen.dup = (dupBorder);\
|
|
(plsdnNew)->u.pen.dvr = 0;\
|
|
(plsdnNew)->u.pen.dvp = 0;\
|
|
(plsdnNew)->klsdn = klsdnPenBorder; \
|
|
(plsdnNew)->fBorderNode = fTrue; \
|
|
TurnOnNonRealDnodeEncounted(plsc);
|
|
|
|
#define FNeedToCutPossibleContextViolation(plsc, plsdn) \
|
|
(FIsDnodeReal(plsdn) && \
|
|
((plsdn)->u.real.lschp.dcpMaxContext > 1) && \
|
|
(IdObjFromDnode(plsdn) == IobjTextFromLsc(&((plsc)->lsiobjcontext))) \
|
|
)
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
static LSERR CheckNewPara(PLSC, LSCP, LSCP, BOOL*);
|
|
static BOOL FLimitRunEsc(LSFRUN*, const LSESC*, DWORD);
|
|
static LSERR CreateInitialPen(PLSC plsc, long dur);
|
|
static LSERR UndoLastDnode(PLSC); /* IN: ls context */
|
|
static LSERR OpenBorder(PLSC plsc, PLSRUN plsrun);
|
|
static LSERR HandleSplat(PLSC plsc, FMTRES* pfmtres);
|
|
static LSERR ErrReleaseRunToFormat (PLSC, /* IN: ptr to line services context */
|
|
PLSRUN, /* IN: ponter to a run structure to be deleted */
|
|
LSERR); /* IN: code of an error */
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* F E T C H A P P E N D E S C R E S U M E C O R E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FetchAppendEscResumeCore
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
urColumnMax - (IN) right margin where to stop
|
|
plsesc - (IN) escape characters
|
|
clsesc - (IN) # of escape characters
|
|
rgbreakrec - (IN) input array of break records
|
|
cbreakrec, (IN) number of records in input array
|
|
pfmtres - (OUT) result of last formatter
|
|
pcpLim - (OUT) where we stop fetching
|
|
pplsdnFirst - (OUT) first dnode that was created
|
|
pplsdnLast - (OUT) last dnode that was created
|
|
pur - (OUT) pen position after procedure
|
|
|
|
If cbreakrec > 0 fetches run with cpFirst from first break record.
|
|
After that if rigth msrgin is not exceeded cals FetchAppendEscCore
|
|
----------------------------------------------------------------------------*/
|
|
LSERR FetchAppendEscResumeCore(PLSC plsc, long urColumnMax, const LSESC* plsesc,
|
|
DWORD clsesc, const BREAKREC* rgbreakrec,
|
|
DWORD cbreakrec, FMTRES* pfmtres, LSCP* pcpLim,
|
|
PLSDNODE* pplsdnFirst, PLSDNODE* pplsdnLast,
|
|
long* pur)
|
|
|
|
{
|
|
LSFRUN lsfrun;
|
|
LSCHP lschp; /* local memory to store lschp */
|
|
BOOL fHidden;
|
|
FMTRES fmtresResume;
|
|
LSERR lserr;
|
|
PLSDNODE* pplsdnFirstStore; /* where to find plsdnFirst */
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(FFormattingAllowed(plsc));
|
|
Assert(!(rgbreakrec == NULL && cbreakrec != 0));
|
|
Assert(GetCurrentDnode(plsc) == NULL); /* it should be begining of a subline */
|
|
|
|
if (cbreakrec > 0)
|
|
{
|
|
/*Initialization; */
|
|
|
|
lsfrun.plschp = &lschp;
|
|
pplsdnFirstStore = GetWhereToPutLink(plsc, GetCurrentDnode(plsc));
|
|
|
|
/* fetch run that starts object to resume */
|
|
lserr = plsc->lscbk.pfnFetchRun(plsc->pols, rgbreakrec[0].cpFirst,
|
|
&lsfrun.lpwchRun, &lsfrun.cwchRun,
|
|
&fHidden, &lschp, &lsfrun.plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (lsfrun.cwchRun <= 0 || fHidden || lsfrun.plschp->idObj != rgbreakrec[0].idobj)
|
|
{
|
|
lserr = lserrInvalidBreakRecord;
|
|
if (!plsc->fDontReleaseRuns)
|
|
{
|
|
plsc->lscbk.pfnReleaseRun(plsc->pols, lsfrun.plsrun);
|
|
}
|
|
return lserr;
|
|
}
|
|
|
|
/* zero amount of characters before dispatching to an object */
|
|
lsfrun.cwchRun = 0;
|
|
|
|
lserr = ProcessOneRun(plsc, urColumnMax, &lsfrun, rgbreakrec,
|
|
cbreakrec,&fmtresResume);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
/* we know that resumed object is not text, so only two fmtres are possible
|
|
and we don't consider others */
|
|
Assert(fmtresResume == fmtrCompletedRun || fmtresResume == fmtrExceededMargin);
|
|
|
|
if (fmtresResume == fmtrCompletedRun)
|
|
{
|
|
|
|
lserr = FetchAppendEscCore(plsc, urColumnMax, plsesc, clsesc, pfmtres, pcpLim,
|
|
pplsdnFirst, pplsdnLast, pur);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
/* special handling of empty dnode list as an result of FetchAppendEscCore */
|
|
if (*pplsdnFirst == NULL)
|
|
{
|
|
*pplsdnLast = GetCurrentDnode(plsc); /* this assigning is correct even when
|
|
resumed object produces empty list
|
|
of dnodes because it starts subline */
|
|
|
|
*pfmtres = fmtresResume;
|
|
}
|
|
|
|
/* rewrite first dnode */
|
|
*pplsdnFirst = *pplsdnFirstStore;
|
|
}
|
|
else /* stop fetching here */
|
|
{
|
|
/* Prepare output */
|
|
*pfmtres = fmtresResume;
|
|
*pcpLim = GetCurrentCpLim(plsc);
|
|
*pplsdnFirst = *pplsdnFirstStore;
|
|
*pplsdnLast = GetCurrentDnode(plsc);
|
|
*pur = GetCurrentUr(plsc);
|
|
}
|
|
|
|
Assert((*pplsdnFirst == NULL) == (*pplsdnLast == NULL));
|
|
Assert((*pplsdnLast == NULL) || ((*pplsdnLast)->plsdnNext == NULL));
|
|
|
|
return lserrNone;
|
|
}
|
|
else /* no breakrecords */
|
|
{
|
|
return FetchAppendEscCore(plsc, urColumnMax, plsesc, clsesc, pfmtres, pcpLim,
|
|
pplsdnFirst, pplsdnLast, pur);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* F E T C H A P P E N D E S C C O R E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FetchAppendEscCore
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
urColumnMax - (IN) right margin where to stop
|
|
plsesc - (IN) escape characters
|
|
clsesc - (IN) # of escape characters
|
|
pfmtres - (OUT) result of last formatter
|
|
pcpLim - (OUT) where we stop fetching
|
|
pplsdnFirst - (OUT) first dnode that was created
|
|
pplsdnLast - (OUT) last dnode that was created
|
|
pur - (OUT) pen position after procedure
|
|
|
|
Loop: fetch run, dispatch it to object handler until escape character
|
|
or terminal fmtres.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
|
|
LSERR FetchAppendEscCore(PLSC plsc, long urColumnMax, const LSESC* plsesc,
|
|
DWORD clsesc, FMTRES* pfmtres, LSCP* pcpLim,
|
|
PLSDNODE* pplsdnFirst, PLSDNODE* pplsdnLast,
|
|
long* pur)
|
|
|
|
{
|
|
|
|
BOOL fDone = fFalse;
|
|
LSFRUN lsfrun;
|
|
LSCHP lschp; /* local memory to store lschp */
|
|
FMTRES fmtres;
|
|
BOOL fHidden;
|
|
LSCP cpLimOfCutRun = (LSCP)(-1); /* cpLim of run that was cuted according with Esc character
|
|
is not valid in other cases
|
|
we use it to check that whole such run was handled by formater */
|
|
LSCP cpPrev = (LSCP)(-1); /* cp of previous run valid only after first iteration */
|
|
LSERR lserr;
|
|
PLSDNODE* pplsdnFirstStore; /* where to find plsdnFirst */
|
|
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(FFormattingAllowed(plsc));
|
|
|
|
/*Initialization; */
|
|
lsfrun.plschp = &lschp;
|
|
fmtres = fmtrCompletedRun; /* it will be output if return right away with esc character */
|
|
pplsdnFirstStore = GetWhereToPutLink(plsc, GetCurrentDnode(plsc));
|
|
|
|
while (!fDone)
|
|
{
|
|
cpPrev = GetCurrentCpLim(plsc);
|
|
/* FetchRun */
|
|
lserr = plsc->lscbk.pfnFetchRun(plsc->pols, GetCurrentCpLim(plsc),
|
|
&lsfrun.lpwchRun, &lsfrun.cwchRun,
|
|
&fHidden, &lschp, &lsfrun.plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (lsfrun.cwchRun <= 0)
|
|
{
|
|
lserr = lserrInvalidDcpFetched;
|
|
if (!plsc->fDontReleaseRuns)
|
|
{
|
|
plsc->lscbk.pfnReleaseRun(plsc->pols, lsfrun.plsrun);
|
|
}
|
|
return lserr;
|
|
}
|
|
|
|
if (fHidden)
|
|
{
|
|
AdvanceCurrentCpLim(plsc, lsfrun.cwchRun);
|
|
if (lsfrun.plsrun != NULL && !plsc->fDontReleaseRuns) /* we have not used this plsrun */
|
|
{
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, lsfrun.plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
/* Handle vanish end of paragraph; */
|
|
/* There is situation in Word (see bug 118) when after fetching hidden text
|
|
paragraph boundaries can be changed. So we have to call CheckNewPara
|
|
every time after hidden text */
|
|
|
|
lserr = CheckNewPara(plsc, cpPrev, GetCurrentCpLim(plsc), &fDone);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (fDone)
|
|
{
|
|
/* it will eventually force stop formatting so we should apply
|
|
nominal to ideal here */
|
|
if (FNominalToIdealEncounted(plsc))
|
|
{
|
|
lserr = ApplyNominalToIdeal(PlschunkcontextFromSubline(GetCurrentSubline(plsc)),
|
|
&plsc->lsiobjcontext,
|
|
plsc->grpfManager, plsc->lsadjustcontext.lskj,
|
|
FIsSubLineMain(GetCurrentSubline(plsc)),
|
|
FLineContainsAutoNumber(plsc),
|
|
GetCurrentDnode(plsc));
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
fmtres = fmtrStopped;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Check Esc character; */
|
|
if (clsesc > 0 && FLimitRunEsc(&lsfrun, plsesc, clsesc))
|
|
{
|
|
cpLimOfCutRun = (LSCP) (GetCurrentCpLim(plsc) + lsfrun.cwchRun);
|
|
fDone = (lsfrun.cwchRun == 0);
|
|
}
|
|
|
|
if (!fDone)
|
|
{
|
|
lserr = ProcessOneRun(plsc, urColumnMax, &lsfrun, NULL, 0, &fmtres);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
/*Check fmtres: Are formating done?; */
|
|
switch (fmtres)
|
|
{
|
|
case fmtrCompletedRun:
|
|
fDone = (GetCurrentCpLim(plsc) == cpLimOfCutRun); /* is true only if we cuted because */
|
|
Assert(!fDone || clsesc > 0); /* of esc character and formater handled such*/
|
|
break; /* run completely */
|
|
|
|
case fmtrExceededMargin:
|
|
fDone = fTrue;
|
|
break;
|
|
|
|
case fmtrTab:
|
|
fDone = fTrue;
|
|
break;
|
|
|
|
case fmtrStopped:
|
|
fDone = fTrue;
|
|
break;
|
|
|
|
default:
|
|
NotReached();
|
|
|
|
}
|
|
|
|
}
|
|
else /* after limiting run by esc characters it was empty */
|
|
{
|
|
if (lsfrun.plsrun != NULL && !plsc->fDontReleaseRuns) /* we have not used this plsrun */
|
|
{
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, lsfrun.plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
fmtres = fmtrCompletedRun;
|
|
}
|
|
}
|
|
} /* if/else hidden */
|
|
}
|
|
|
|
|
|
/* Prepare output */
|
|
*pfmtres = fmtres;
|
|
*pcpLim = GetCurrentCpLim(plsc);
|
|
*pplsdnFirst = *pplsdnFirstStore;
|
|
if (*pplsdnFirst != NULL)
|
|
*pplsdnLast = GetCurrentDnode(plsc);
|
|
else
|
|
*pplsdnLast = NULL;
|
|
*pur = GetCurrentUr(plsc);
|
|
|
|
Assert((*pplsdnFirst == NULL) == (*pplsdnLast == NULL));
|
|
Assert((*pplsdnLast == NULL) || ((*pplsdnLast)->plsdnNext == NULL));
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* P R O C E S S O N E R U N */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: ProcessOneRun
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
urColumnMax - (IN) right margin where to stop
|
|
plsfrun - (IN) given run
|
|
rgbreakrec - (IN) input array of break records
|
|
cbreakrec, (IN) number of records in input array
|
|
pfmtres - (OUT) result of formatting
|
|
|
|
1) If run it's not a text run applies nominal to ideal to previous text chunk.
|
|
To have correct pen position before dispatching to an foreign object.
|
|
2) Get text metrics and dispatches run to an handler.
|
|
3) If fmtres is terminal applies nominal to ideal to the last chunk.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
|
|
LSERR ProcessOneRun (PLSC plsc, long urColumnMax, const LSFRUN* plsfrun,
|
|
const BREAKREC* rgbreakrec,
|
|
DWORD cbreakrec, FMTRES* pfmtres)
|
|
|
|
|
|
{
|
|
DWORD iobj;
|
|
LSIMETHODS* plsim;
|
|
PLNOBJ plnobj;
|
|
struct fmtin fmti;
|
|
LSERR lserr;
|
|
PLSDNODE plsdnNew;
|
|
PLSDNODE plsdnToFinishOld; /* we should restore it after every formater */
|
|
PLSSUBL plssublOld;
|
|
PLSDNODE plsdnNomimalToIdeal;
|
|
PLSDNODE* pplsdnToStoreNext;
|
|
PLSDNODE plsdnNext;
|
|
PLSDNODE plsdnCurrent;
|
|
PLSDNODE plsdnLast;
|
|
BOOL fInterruptBorder;
|
|
BOOL fInsideBorderUp = fFalse;
|
|
BOOL fBordered = fFalse;
|
|
|
|
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(!(rgbreakrec == NULL && cbreakrec != 0));
|
|
|
|
|
|
plsdnToFinishOld = GetDnodeToFinish(plsc);
|
|
plssublOld = GetCurrentSubline(plsc);
|
|
plsdnCurrent = GetCurrentDnode(plsc);
|
|
pplsdnToStoreNext = GetWhereToPutLink(plsc, plsdnCurrent);
|
|
if (plsdnToFinishOld != NULL)
|
|
fInsideBorderUp = plsdnToFinishOld->fInsideBorder;
|
|
|
|
|
|
if (plsfrun->plschp->idObj == idObjTextChp)
|
|
iobj = IobjTextFromLsc(&plsc->lsiobjcontext);
|
|
else
|
|
iobj = plsfrun->plschp->idObj;
|
|
|
|
Assert (FIobjValid(&plsc->lsiobjcontext, iobj)); /* Reject other out of range ids */
|
|
if (!FIobjValid(&plsc->lsiobjcontext, iobj)) /* for both debug and ship builds. */
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserrInvalidObjectIdFetched);
|
|
|
|
/* here we are catching for situatuion when client adding text dnode to a chunk to
|
|
which nominal to ideal has been applied, such situation will lead later to applying nominal
|
|
to ideal twice to the same dnode, and this text doesn't like */
|
|
AssertImplies(iobj == IobjTextFromLsc(&plsc->lsiobjcontext),
|
|
!FNTIAppliedToLastChunk(PlschunkcontextFromSubline(plssublOld)));
|
|
if (iobj == IobjTextFromLsc(&plsc->lsiobjcontext) &&
|
|
FNTIAppliedToLastChunk(PlschunkcontextFromSubline(plssublOld)))
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserrFormattingFunctionDisabled);
|
|
|
|
|
|
plsim = PLsimFromLsc(&plsc->lsiobjcontext, iobj);
|
|
|
|
if (iobj != IobjTextFromLsc(&plsc->lsiobjcontext))
|
|
{
|
|
TurnOffAllSimpleText(plsc); /* not text */
|
|
TurnOnForeignObjectEncounted(plsc);
|
|
|
|
if (FNominalToIdealEncounted(plsc))
|
|
{
|
|
lserr = ApplyNominalToIdeal(PlschunkcontextFromSubline(plssublOld), &plsc->lsiobjcontext,
|
|
plsc->grpfManager, plsc->lsadjustcontext.lskj,
|
|
FIsSubLineMain(plssublOld), FLineContainsAutoNumber(plsc),
|
|
plsdnCurrent);
|
|
if (lserr != lserrNone)
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserr);
|
|
|
|
/* we should recalculate plsdnCurrent because nominal to ideal can destroy last dnode */
|
|
plsdnCurrent = GetCurrentDnode(plsc);
|
|
pplsdnToStoreNext = GetWhereToPutLink(plsc, plsdnCurrent);
|
|
}
|
|
|
|
}
|
|
|
|
FlushNTIAppliedToLastChunk(PlschunkcontextFromSubline(plssublOld));
|
|
|
|
/* creating border dnodes */
|
|
/* skip back pen dnodes */
|
|
while (plsdnCurrent != NULL && FIsDnodePen(plsdnCurrent))
|
|
{
|
|
plsdnCurrent = plsdnCurrent->plsdnPrev;
|
|
}
|
|
|
|
if (FDnodeHasBorder(plsdnCurrent) &&
|
|
!(FIsDnodeBorder(plsdnCurrent) && !FIsDnodeOpenBorder(plsdnCurrent))) /* previous dnode has unclosed border */
|
|
/* condition in if looks superfluous but it works correctly even if dnodes deleting
|
|
happend during formatting */
|
|
{
|
|
if (plsfrun->plschp->fBorder)
|
|
{
|
|
/* check that client wants to border runs together */
|
|
lserr = plsc->lscbk.pfnFInterruptBorder(plsc->pols, plsdnCurrent->u.real.plsrun,
|
|
plsfrun->plsrun, &fInterruptBorder);
|
|
if (lserr != lserrNone)
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserr);
|
|
|
|
if (fInterruptBorder)
|
|
{
|
|
/* close previous border and open new one */
|
|
lserr = CloseCurrentBorder(plsc);
|
|
if (lserr != lserrNone)
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserr);
|
|
lserr = OpenBorder(plsc, plsfrun->plsrun);
|
|
if (lserr != lserrNone)
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserr);
|
|
}
|
|
fBordered = fTrue;
|
|
}
|
|
else
|
|
{
|
|
lserr = CloseCurrentBorder(plsc);
|
|
if (lserr != lserrNone)
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (plsfrun->plschp->fBorder)
|
|
{
|
|
if (fInsideBorderUp)
|
|
{
|
|
/* border is open on upper level: turn off border flag */
|
|
((PLSCHP) (plsfrun->plschp))->fBorder = fFalse;
|
|
}
|
|
else
|
|
{
|
|
lserr = OpenBorder(plsc, plsfrun->plsrun);
|
|
if (lserr != lserrNone)
|
|
return ErrReleaseRunToFormat(plsc, plsfrun->plsrun, lserr);
|
|
fBordered = fTrue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* we always create real dnode and change it for pen if needed in Finish method */
|
|
CreateRealDnode(plsc, plsdnNew, plsfrun);
|
|
plsdnNew->fInsideBorder = fInsideBorderUp || fBordered;
|
|
|
|
/* initialization of fmti */
|
|
|
|
|
|
fmti.lsfgi.fFirstOnLine = FIsFirstOnLine(plsdnNew) && FIsSubLineMain(plssublOld);
|
|
fmti.lsfgi.cpFirst = GetCurrentCpLim(plsc);
|
|
fmti.lsfgi.urPen = GetCurrentUr(plsc);
|
|
fmti.lsfgi.vrPen = GetCurrentVr(plsc);
|
|
|
|
fmti.lsfgi.urColumnMax = urColumnMax;
|
|
|
|
fmti.lsfgi.lstflow = plssublOld->lstflow;
|
|
fmti.lsfrun = *plsfrun;
|
|
fmti.plsdnTop = plsdnNew;
|
|
|
|
|
|
lserr = plsc->lscbk.pfnGetRunTextMetrics(plsc->pols, fmti.lsfrun.plsrun,
|
|
lsdevReference, fmti.lsfgi.lstflow, &fmti.lstxmRef);
|
|
if (lserr != lserrNone)
|
|
{
|
|
DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdnNew, plsc->fDontReleaseRuns);
|
|
return lserr;
|
|
}
|
|
|
|
if (plsc->lsdocinf.fPresEqualRef)
|
|
fmti.lstxmPres = fmti.lstxmRef;
|
|
else
|
|
{
|
|
lserr = plsc->lscbk.pfnGetRunTextMetrics(plsc->pols, fmti.lsfrun.plsrun,
|
|
lsdevPres, fmti.lsfgi.lstflow,
|
|
&fmti.lstxmPres);
|
|
if (lserr != lserrNone)
|
|
{
|
|
DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdnNew, plsc->fDontReleaseRuns);
|
|
return lserr;
|
|
}
|
|
}
|
|
|
|
|
|
plnobj = PlnobjFromLsc(plsc, iobj);
|
|
|
|
|
|
if (plnobj == NULL)
|
|
{
|
|
lserr = CreateLNObjInLsc(plsc, iobj);
|
|
if (lserr != lserrNone)
|
|
{
|
|
DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdnNew, plsc->fDontReleaseRuns);
|
|
return lserr;
|
|
}
|
|
plnobj = PlnobjFromLsc(plsc, iobj);
|
|
}
|
|
|
|
/* set dnode to finish */
|
|
SetDnodeToFinish(plsc, plsdnNew);
|
|
/* set current subline to NULL */
|
|
SetCurrentSubline(plsc, NULL);
|
|
|
|
if (cbreakrec == 0)
|
|
{
|
|
lserr = plsim->pfnFmt(plnobj, &fmti, pfmtres);
|
|
}
|
|
else{
|
|
if (plsim->pfnFmtResume == NULL)
|
|
return lserrInvalidBreakRecord;
|
|
lserr = plsim->pfnFmtResume(plnobj, rgbreakrec, cbreakrec, &fmti, pfmtres);
|
|
}
|
|
|
|
if (lserr != lserrNone)
|
|
{
|
|
if (plsc->lslistcontext.plsdnToFinish != NULL) /* dnode hasn't added to list */
|
|
DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdnNew, plsc->fDontReleaseRuns);
|
|
/* we should restore dnode to finish and current subline to properly handle
|
|
error on upper level */
|
|
SetCurrentSubline(plsc, plssublOld);
|
|
SetDnodeToFinish(plsc, plsdnToFinishOld);
|
|
return lserr;
|
|
}
|
|
|
|
AssertValidFmtres(*pfmtres);
|
|
|
|
if (GetCurrentSubline(plsc) != NULL || GetDnodeToFinish(plsc) != NULL)
|
|
{
|
|
/* we should restore dnode to finish and current subline to properly handle
|
|
error on upper level */
|
|
SetCurrentSubline(plsc, plssublOld);
|
|
SetDnodeToFinish(plsc, plsdnToFinishOld);
|
|
return lserrUnfinishedDnode;
|
|
}
|
|
|
|
/* restore dnode to finish and current subline */
|
|
SetCurrentSubline(plsc, plssublOld);
|
|
SetDnodeToFinish(plsc, plsdnToFinishOld);
|
|
|
|
/* to avoid all problems with deleteing dnodes we don't use plsdnNew */
|
|
plsdnLast = GetCurrentDnodeSubl(plssublOld);
|
|
|
|
/* case of tab */
|
|
if (*pfmtres == fmtrTab)
|
|
{
|
|
plsdnLast->fTab = fTrue;
|
|
/* caller later can skip this tab so we prepare zero values */
|
|
Assert(FIsDnodeReal(plsdnLast));
|
|
Assert(IdObjFromDnode(plsdnLast) == IobjTextFromLsc(&plsc->lsiobjcontext));
|
|
|
|
TurnOffAllSimpleText(plsc); /* not text */
|
|
}
|
|
|
|
/* case of splat */
|
|
if (*pfmtres == fmtrStopped && plsdnLast != NULL && FIsDnodeSplat(plsdnLast))
|
|
{
|
|
lserr = HandleSplat(plsc, pfmtres);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
/* Handle splat can delete plsdnLast */
|
|
plsdnLast = GetCurrentDnodeSubl(plssublOld);
|
|
}
|
|
|
|
/* in a case of exceeded margin or hard break or tab (so all values of fmtres but fmtrCompletedRun) */
|
|
/* we need apply nominal to ideal to have correct lenght */
|
|
if (*pfmtres != fmtrCompletedRun && plsdnLast != NULL && FNominalToIdealEncounted(plsc))
|
|
{
|
|
if (*pfmtres == fmtrTab || FIsDnodeSplat(plsdnLast))
|
|
plsdnNomimalToIdeal = plsdnLast->plsdnPrev;
|
|
else
|
|
plsdnNomimalToIdeal = plsdnLast;
|
|
|
|
lserr = ApplyNominalToIdeal(PlschunkcontextFromSubline(plssublOld), &plsc->lsiobjcontext,
|
|
plsc->grpfManager, plsc->lsadjustcontext.lskj,
|
|
FIsSubLineMain(plssublOld), FLineContainsAutoNumber(plsc),
|
|
plsdnNomimalToIdeal);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
/* ApplyNominalToIdeal can delete plsdnLast */
|
|
plsdnLast = GetCurrentDnodeSubl(plssublOld);
|
|
/* if we run nominal to ideal because of tab chunk of text to which
|
|
nominal to ideal is applied is not last chunk */
|
|
if (*pfmtres == fmtrTab || FIsDnodeSplat(plsdnLast))
|
|
FlushNTIAppliedToLastChunk(PlschunkcontextFromSubline(plssublOld));
|
|
|
|
/* in a case of exceeded right margin we should extract dcpMaxContext characters
|
|
because after fetching further result of nominal to ideal can be different for these
|
|
characters: examples ligatures or kerning */
|
|
if (*pfmtres == fmtrExceededMargin &&
|
|
FNeedToCutPossibleContextViolation(plsc, plsdnLast))
|
|
{
|
|
lserr = CutPossibleContextViolation(PlschunkcontextFromSubline(plssublOld),
|
|
plsdnLast);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
/* such procedure also can delete plsdnLast */
|
|
plsdnLast = GetCurrentDnodeSubl(plssublOld);
|
|
}
|
|
|
|
}
|
|
|
|
if (iobj != IobjTextFromLsc(&plsc->lsiobjcontext))
|
|
/* only in this case there is a possibility to apply width modification
|
|
to preceding character */
|
|
{
|
|
/* we are actually applying width modification to preceding character if first
|
|
dnode produced by formating is non text */
|
|
/* we can't relly on plsdnLast here because of such Finish methods as
|
|
FinishByOneCharacter and FinishBySubline */
|
|
/* we still rely here on pplsdnToStoreNext in other words we assume that
|
|
plsdnCurrent (the current dnode in the begining of our procedure ) has not been
|
|
deleted during nominal to ideal. To prove this we use that nominal to ideal has been
|
|
already applied to plsdnCurrent*/
|
|
plsdnNext = *pplsdnToStoreNext;
|
|
Assert(plsdnNext == NULL || FIsLSDNODE(plsdnNext));
|
|
if (FNominalToIdealEncounted(plsc) &&
|
|
plsdnNext != NULL &&
|
|
FIsDnodeReal(plsdnNext) &&
|
|
IdObjFromDnode(plsdnNext) != IobjTextFromLsc(&plsc->lsiobjcontext)
|
|
)
|
|
{
|
|
lserr = ApplyModWidthToPrecedingChar(PlschunkcontextFromSubline(plssublOld),
|
|
&plsc->lsiobjcontext, plsc->grpfManager,
|
|
plsc->lsadjustcontext.lskj, plsdnNext);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* Q U I C K F O R M A T T I N G */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: QuickFormatting
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
plsfrun - (IN) given run
|
|
urColumnMax - (IN) right margin where to stop
|
|
pfGeneral - (OUT) quick formatting was stopped: we should use general formatting
|
|
pfHardStop - (OUT) formatting ended with hard break
|
|
pcpLim - (OUT) cpLim after procedure
|
|
pur - (OUT) pen position after procedure
|
|
|
|
Works only with text runs without nominal to ideal and without tabs.
|
|
Stops if condition below is broken.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
|
|
LSERR QuickFormatting(PLSC plsc, LSFRUN* plsfrun, long urColumnMax,
|
|
BOOL* pfGeneral, BOOL* pfHardStop,
|
|
LSCP* pcpLim, long* pur)
|
|
|
|
{
|
|
|
|
struct fmtin fmti;
|
|
LSLINFO* plslinfoText;
|
|
DWORD iobjText;
|
|
PLNOBJ plnobjText;
|
|
PLSLINE plsline;
|
|
BOOL fHidden;
|
|
const POLS pols = plsc->pols;
|
|
BOOL fGeneral;
|
|
FMTRES fmtres = fmtrCompletedRun;
|
|
LSERR lserr;
|
|
PLSDNODE plsdnNew;
|
|
PLSSUBL plssubl;
|
|
|
|
iobjText = IobjTextFromLsc(&(plsc->lsiobjcontext));
|
|
plnobjText = PlnobjFromLsc(plsc, iobjText);
|
|
plssubl = GetCurrentSubline(plsc);
|
|
|
|
fmti.lsfrun = *plsfrun;
|
|
fmti.lsfgi.fFirstOnLine = TRUE;
|
|
fmti.lsfgi.cpFirst = GetCurrentCpLim(plsc);
|
|
fmti.lsfgi.vrPen = GetCurrentVr(plsc);
|
|
fmti.lsfgi.urPen = GetCurrentUr(plsc);
|
|
fmti.lsfgi.lstflow = plssubl->lstflow;
|
|
fmti.lsfgi.urColumnMax = urColumnMax;
|
|
|
|
|
|
plsline = plsc->plslineCur;
|
|
plslinfoText = &(plsline->lslinfo);
|
|
|
|
fGeneral = fFalse;
|
|
fHidden = fFalse; /* in InitTextParams we already skipped all vanished text */
|
|
|
|
|
|
|
|
for (;;) /* "break" exits quick-format loop */
|
|
{
|
|
/* Run has been alreary fetched */
|
|
|
|
/*we don't want to handle here vanished text, foreign object, nominal to ideal */
|
|
if ( FRunIsNotSimple(fmti.lsfrun.plschp, fHidden))
|
|
{
|
|
/* we should release run here, in general procedure we will fetch it again */
|
|
if (!plsc->fDontReleaseRuns)
|
|
{
|
|
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, fmti.lsfrun.plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
fGeneral = fTrue;
|
|
break;
|
|
}
|
|
|
|
/*Create dnode for text; */
|
|
CreateRealDnode(plsc, plsdnNew, &fmti.lsfrun);
|
|
|
|
SetDnodeToFinish(plsc, plsdnNew);
|
|
|
|
/* prepare fmtin */
|
|
fmti.plsdnTop = plsdnNew;
|
|
|
|
|
|
lserr = plsc->lscbk.pfnGetRunTextMetrics(pols, fmti.lsfrun.plsrun,
|
|
lsdevReference, fmti.lsfgi.lstflow, &fmti.lstxmRef);
|
|
if (lserr != lserrNone)
|
|
{
|
|
DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdnNew, plsc->fDontReleaseRuns);
|
|
return lserr;
|
|
}
|
|
|
|
if (plsc->lsdocinf.fPresEqualRef)
|
|
{
|
|
fmti.lstxmPres = fmti.lstxmRef;
|
|
}
|
|
else
|
|
{
|
|
lserr = plsc->lscbk.pfnGetRunTextMetrics(pols, fmti.lsfrun.plsrun,
|
|
lsdevPres, fmti.lsfgi.lstflow,
|
|
&fmti.lstxmPres);
|
|
if (lserr != lserrNone)
|
|
{
|
|
DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdnNew, plsc->fDontReleaseRuns);
|
|
return lserr;
|
|
}
|
|
}
|
|
|
|
SetCurrentSubline(plsc, NULL);
|
|
lserr = FmtText(plnobjText, &fmti, &fmtres);
|
|
if (lserr != lserrNone)
|
|
{
|
|
if (plsc->lslistcontext.plsdnToFinish != NULL) /* dnode hasn't added to list */
|
|
DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdnNew, plsc->fDontReleaseRuns);
|
|
return lserr;
|
|
}
|
|
/* restore current subline */
|
|
SetCurrentSubline(plsc, plssubl);
|
|
|
|
if (fmtres == fmtrTab ) /* tab: we quite from quick loop deleting this dnode
|
|
because we will append it again in FormatGeneralCase */
|
|
{
|
|
lserr = UndoLastDnode(plsc); /* dnode is already in list */
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
fGeneral = fTrue;
|
|
break;
|
|
}
|
|
|
|
|
|
AssertValidFmtres(fmtres);
|
|
|
|
SetHeightToMax(plslinfoText, &(plsdnNew->u.real.objdim));
|
|
|
|
if (FIsDnodeSplat(plsdnNew))
|
|
{
|
|
lserr = HandleSplat(plsc, &fmtres);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
if (fmtres != fmtrCompletedRun)
|
|
{
|
|
/* after break we should check that final heights is not zero */
|
|
/* otherwise we take heights from last run */
|
|
/* so we will have correct line height after quick break */
|
|
if (plslinfoText->dvrAscent == 0 && plslinfoText->dvrDescent == 0)
|
|
{
|
|
plslinfoText->dvrAscent = fmti.lstxmRef.dvAscent;
|
|
plslinfoText->dvpAscent = fmti.lstxmPres.dvAscent;
|
|
plslinfoText->dvrDescent = fmti.lstxmRef.dvDescent;
|
|
plslinfoText->dvpDescent = fmti.lstxmPres.dvDescent;
|
|
plslinfoText->dvpMultiLineHeight = dvHeightIgnore;
|
|
plslinfoText->dvrMultiLineHeight = dvHeightIgnore;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* prepare next iteration; */
|
|
|
|
fmti.lsfgi.fFirstOnLine = fFalse;
|
|
fmti.lsfgi.urPen = GetCurrentUr(plsc);
|
|
fmti.lsfgi.cpFirst = GetCurrentCpLim(plsc);
|
|
|
|
lserr = plsc->lscbk.pfnFetchRun(pols, fmti.lsfgi.cpFirst,
|
|
&fmti.lsfrun.lpwchRun,
|
|
&fmti.lsfrun.cwchRun,
|
|
&fHidden, (LSCHP *)fmti.lsfrun.plschp,
|
|
&fmti.lsfrun.plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
Assert(fmti.lsfrun.cwchRun > 0);
|
|
|
|
} /* for (;;) */
|
|
|
|
|
|
|
|
/* prepare output */
|
|
*pfGeneral = fGeneral;
|
|
*pfHardStop = (fmtres == fmtrStopped);
|
|
*pcpLim = GetCurrentCpLim(plsc);
|
|
*pur = GetCurrentUr(plsc);
|
|
|
|
return lserrNone;
|
|
|
|
}
|
|
|
|
|
|
/* C H E C K N E W P A R A */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CheckNewPara
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cpPrev - (IN) cp in old paragraph
|
|
cpThis - (IN) cp in new paragraph
|
|
pfQuit - (OUT) stop formatting because new paragraph is not compatible with old
|
|
|
|
Handles leaping from paragraph to paragraph (due to vanished text) on
|
|
behalf of FetchAppendEscCore(). If the new paragraph is compatible
|
|
with the old one, FetchPap is called and text is informed of the
|
|
new para end parameters.
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR CheckNewPara(PLSC plsc, LSCP cpPrev, LSCP cpThis, BOOL* pfQuit)
|
|
{
|
|
LSERR lserr;
|
|
BOOL fHazard;
|
|
LSPAP lspap;
|
|
DWORD iobjText;
|
|
PLNOBJ plnobjText;
|
|
|
|
*pfQuit = fTrue;
|
|
|
|
Assert(cpThis >= 0 && cpThis > cpPrev);
|
|
|
|
|
|
|
|
|
|
lserr = plsc->lscbk.pfnCheckParaBoundaries(plsc->pols, cpPrev, cpThis, &fHazard);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (!fHazard)
|
|
{
|
|
|
|
lserr = plsc->lscbk.pfnFetchPap(plsc->pols, cpThis, &lspap);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
/* we don't know are we really in a new paragraph or not */
|
|
/* so we have to modify information about end of paragraph */
|
|
/* always as would we are in a new paragraph */
|
|
iobjText = IobjTextFromLsc(&plsc->lsiobjcontext);
|
|
plnobjText = PlnobjFromLsc(plsc, iobjText);
|
|
|
|
lserr = ModifyTextLineEnding(plnobjText, lspap.lskeop);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
SetCpInPara(plsc->lstabscontext, cpThis);
|
|
plsc->fLimSplat = lspap.grpf & fFmiLimSplat;
|
|
plsc->fIgnoreSplatBreak = lspap.grpf & fFmiIgnoreSplatBreak;
|
|
|
|
/* we don't invalidate tabs info and other paragraph properties
|
|
/* that we stored in context */
|
|
|
|
*pfQuit = fFalse;
|
|
}
|
|
|
|
return lserr;
|
|
}
|
|
|
|
|
|
/* F L I M I T R U N E S C */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FLimitRunEsc
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsfrun - (IN) run to cut
|
|
plsesc - (IN) set of esc characters
|
|
iescLim - (IN) number of esc characters
|
|
|
|
On behalf of LsFetchAppendEscCore(), this routine limits a run when
|
|
an escape character is present.
|
|
----------------------------------------------------------------------------*/
|
|
static BOOL FLimitRunEsc(LSFRUN* plsfrun, const LSESC* plsesc, DWORD iescLim)
|
|
{
|
|
DWORD iesc;
|
|
DWORD ich;
|
|
const LPCWSTR pwch = plsfrun->lpwchRun;
|
|
const DWORD ichLim = plsfrun->cwchRun;
|
|
|
|
Assert(iescLim > 0); /* optimization -- test before calling */
|
|
|
|
for (ich=0; ich<ichLim; ich++)
|
|
{
|
|
for (iesc=0; iesc<iescLim; iesc++)
|
|
{
|
|
|
|
if (FBetween(pwch[ich], plsesc[iesc].wchFirst, plsesc[iesc].wchLast))
|
|
{
|
|
plsfrun->cwchRun = ich;
|
|
return fTrue;
|
|
}
|
|
}
|
|
}
|
|
return fFalse;
|
|
}
|
|
|
|
|
|
|
|
/* F O R M A T A N M */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FormatAnm
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
plsfrunMainText - (IN) first run of the main text
|
|
|
|
Formats and allignes bullets and numbering
|
|
----------------------------------------------------------------------------*/
|
|
|
|
LSERR FormatAnm(PLSC plsc, PLSFRUN plsfrunMainText)
|
|
{
|
|
long duaSpaceAnm;
|
|
long duaWidthAnm;
|
|
LSKALIGN lskalignAnm;
|
|
WCHAR wchAdd;
|
|
BOOL fWord95Model;
|
|
LSERR lserr;
|
|
LSFRUN lsfrun;
|
|
LSCHP lschp; /* local memory to store lschp */
|
|
FMTRES fmtres;
|
|
long durUsed;
|
|
long urOriginal;
|
|
long durAfter = 0;
|
|
long durBefore = 0;
|
|
LSCP cpLimOriginal;
|
|
OBJDIM* pobjdimAnm;
|
|
PLSDNODE plsdnAllignmentTab;
|
|
BOOL fInterruptBorder;
|
|
LSCHP lschpAdd; /* lschp for character added after autonumber */
|
|
PLSRUN plsrunAdd; /* plsrun for character added after autonumber */
|
|
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(FFormattingAllowed(plsc));
|
|
|
|
|
|
/*Initialization; */
|
|
lsfrun.plschp = &lschp;
|
|
cpLimOriginal = GetCurrentCpLim(plsc);
|
|
urOriginal = GetCurrentUr(plsc);
|
|
SetCurrentCpLim(plsc, cpFirstAnm);
|
|
|
|
/* get autonumbering information */
|
|
lserr = plsc->lscbk.pfnGetAutoNumberInfo(plsc->pols, &lskalignAnm, &lschp, &lsfrun.plsrun,
|
|
&wchAdd, &lschpAdd, &plsrunAdd,
|
|
&fWord95Model, &duaSpaceAnm, &duaWidthAnm);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
Assert(!memcmp(&lschp, &lschpAdd, sizeof(lschpAdd)));
|
|
|
|
lsfrun.cwchRun = 0 ; /* we dont use characters in formating autonumbering object */
|
|
lsfrun.lpwchRun = NULL;
|
|
|
|
/* put idobj of autonumber to lschp */
|
|
lschp.idObj = (WORD) IobjAutonumFromLsc(&plsc->lsiobjcontext);
|
|
|
|
/* remove underlining and some other bits from chp */
|
|
/* we don't underline it as a whole */
|
|
lschp.fUnderline = fFalse;
|
|
lschp.fStrike = fFalse;
|
|
lschp.fShade = fFalse;
|
|
lschp.EffectsFlags = 0;
|
|
|
|
lserr = ProcessOneRun(plsc, uLsInfiniteRM, &lsfrun, NULL,
|
|
0, &fmtres);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
Assert(fmtres == fmtrCompletedRun);
|
|
Assert(GetCurrentDnode(plsc) != NULL);
|
|
|
|
|
|
/* store heights of autonumber */
|
|
Assert(FIsDnodeReal(GetCurrentDnode(plsc)));
|
|
pobjdimAnm = &(GetCurrentDnode(plsc)->u.real.objdim);
|
|
plsc->plslineCur->lslinfo.dvpAscentAutoNumber = pobjdimAnm->heightsPres.dvAscent;
|
|
plsc->plslineCur->lslinfo.dvrAscentAutoNumber = pobjdimAnm->heightsRef.dvAscent;
|
|
plsc->plslineCur->lslinfo.dvpDescentAutoNumber = pobjdimAnm->heightsPres.dvDescent;
|
|
plsc->plslineCur->lslinfo.dvrDescentAutoNumber = pobjdimAnm->heightsRef.dvDescent;
|
|
|
|
|
|
if (wchAdd != 0) /* fill in lsfrun with a run of one character */
|
|
{
|
|
lsfrun.plschp = &lschpAdd;
|
|
lsfrun.plsrun = plsrunAdd;
|
|
lsfrun.lpwchRun = &wchAdd;
|
|
lsfrun.cwchRun = 1;
|
|
|
|
lserr = ProcessOneRun(plsc, uLsInfiniteRM, &lsfrun, NULL,
|
|
0, &fmtres);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
Assert(fmtres == fmtrCompletedRun || fmtres == fmtrTab);
|
|
}
|
|
|
|
plsdnAllignmentTab = GetCurrentDnode(plsc); /* in the case when added character is not tab this
|
|
value will not be used */
|
|
|
|
if (lsfrun.plschp->fBorder)
|
|
{
|
|
if (plsfrunMainText->plschp->fBorder)
|
|
{
|
|
/* check that client wants to border runs together */
|
|
lserr = plsc->lscbk.pfnFInterruptBorder(plsc->pols,
|
|
lsfrun.plsrun, plsfrunMainText->plsrun, &fInterruptBorder);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (fInterruptBorder)
|
|
{
|
|
/* we should close border before allignment */
|
|
lserr = CloseCurrentBorder(plsc);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* we should close border before allignment */
|
|
lserr = CloseCurrentBorder(plsc);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
}
|
|
|
|
durUsed = GetCurrentUr(plsc) - urOriginal;
|
|
|
|
if (fWord95Model)
|
|
{
|
|
Assert(wchAdd != 0);
|
|
Assert(fmtres == fmtrTab);
|
|
|
|
AllignAutonum95(UrFromUa(LstflowFromSubline(GetCurrentSubline(plsc)),
|
|
&(plsc->lsdocinf.lsdevres), duaSpaceAnm),
|
|
UrFromUa(LstflowFromSubline(GetCurrentSubline(plsc)),
|
|
&(plsc->lsdocinf.lsdevres), duaWidthAnm),
|
|
lskalignAnm, durUsed, plsdnAllignmentTab,
|
|
&durBefore, &durAfter);
|
|
}
|
|
else
|
|
{
|
|
lserr = AllignAutonum(&(plsc->lstabscontext), lskalignAnm,
|
|
(wchAdd != 0 && fmtres == fmtrTab),
|
|
plsdnAllignmentTab, GetCurrentUr(plsc),
|
|
durUsed, &durBefore, &durAfter);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
/* if there is no allignment after then durAfter should be zero */
|
|
Assert(!((durAfter != 0) && (!(wchAdd != 0 && fmtres == fmtrTab))));
|
|
}
|
|
|
|
/* change geometry because of durBefore */
|
|
plsc->lsadjustcontext.urStartAutonumberingText =
|
|
plsc->lsadjustcontext.urLeftIndent + durBefore;
|
|
AdvanceCurrentUr(plsc, durBefore);
|
|
|
|
/* change geometry because of durAfter */
|
|
AdvanceCurrentUr(plsc, durAfter);
|
|
|
|
plsc->lsadjustcontext.urStartMainText = GetCurrentUr(plsc);
|
|
|
|
/* restore cpLim */
|
|
SetCurrentCpLim(plsc, cpLimOriginal);
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
#define iobjAutoDecimalTab (idObjTextChp-1)
|
|
|
|
/* I N I T I A L I Z E A U T O D E C T A B */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: InitializeAutoDecTab
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
durAutoDecimalTab - (IN) auto decimal tab offset
|
|
|
|
Creates tab stop record and dnode for "auto-decimal tab"
|
|
----------------------------------------------------------------------------*/
|
|
|
|
|
|
LSERR InitializeAutoDecTab(PLSC plsc, long durAutoDecimalTab)
|
|
|
|
{
|
|
PLSDNODE plsdnTab;
|
|
LSERR lserr;
|
|
LSKTAB lsktab;
|
|
BOOL fBreakThroughTab;
|
|
LSCP cpLimOriginal;
|
|
|
|
if (durAutoDecimalTab > GetCurrentUr(plsc))
|
|
{
|
|
cpLimOriginal = GetCurrentCpLim(plsc);
|
|
SetCurrentCpLim(plsc, LONG_MIN + 1);
|
|
|
|
lserr = InitTabsContextForAutoDecimalTab(&plsc->lstabscontext, durAutoDecimalTab);
|
|
if (lserr != lserrNone)
|
|
return lserrNone;
|
|
|
|
CreateDnode(plsc, plsdnTab);
|
|
|
|
*(GetWhereToPutLink(plsc, plsdnTab->plsdnPrev)) = plsdnTab;
|
|
SetCurrentDnode(plsc, plsdnTab);
|
|
|
|
/* fill in this dnode */
|
|
memset(&plsdnTab->u.real.objdim, 0, sizeof(OBJDIM));
|
|
memset(&plsdnTab->u.real.lschp, 0, sizeof(LSCHP));
|
|
plsdnTab->u.real.lschp.idObj = (WORD) IobjTextFromLsc(&plsc->lsiobjcontext);
|
|
plsdnTab->fTab = fTrue;
|
|
plsdnTab->fAutoDecTab = fTrue;
|
|
plsdnTab->cpLimOriginal = cpLimOriginal; /* it's important to display to put correct value here */
|
|
plsdnTab->dcp = 0;
|
|
|
|
/* If PrepareLineToDisplay is not called, this dnode will not convert to pen and will destroyed
|
|
as real dnode. So we need to put NULL to plsrun, pdobj, pinfosubl*/
|
|
plsdnTab->u.real.plsrun = NULL;
|
|
plsdnTab->u.real.pdobj = NULL;
|
|
plsdnTab->u.real.pinfosubl = NULL;
|
|
|
|
lserr = GetCurTabInfoCore(&plsc->lstabscontext, plsdnTab, GetCurrentUr(plsc),
|
|
fFalse, &lsktab, &fBreakThroughTab);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
TurnOnTabEncounted(plsc);
|
|
if (lsktab != lsktLeft)
|
|
TurnOnNonLeftTabEncounted(plsc);
|
|
|
|
/* restore cpLim */
|
|
SetCurrentCpLim(plsc, cpLimOriginal);
|
|
|
|
TurnOnAutodecimalTabPresent(plsc);
|
|
}
|
|
return lserrNone;
|
|
}
|
|
|
|
/* H A N D L E T A B */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: HandleTab
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
|
|
Wraper around calls to tabutils module.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
LSERR HandleTab(PLSC plsc)
|
|
{
|
|
LSKTAB lsktab;
|
|
LSERR lserr;
|
|
BOOL fBreakThroughTab;
|
|
long durPendingTab;
|
|
long urNewMargin;
|
|
|
|
/* if we are not on a stage of a formatting this procedure resolve previous tab if any */
|
|
|
|
/* before tab calculation we should resolve pending tab */
|
|
lserr = ResolvePrevTabCore(&plsc->lstabscontext, GetCurrentDnode(plsc),
|
|
GetCurrentUr(plsc), &durPendingTab);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
/* move current pen position */
|
|
Assert(durPendingTab >= 0);
|
|
AdvanceCurrentUr(plsc, durPendingTab);
|
|
|
|
if (FFormattingAllowed(plsc))
|
|
{
|
|
/* in this case we are called only after tab */
|
|
Assert(GetCurrentDnode(plsc)->fTab);
|
|
lserr = GetCurTabInfoCore(&plsc->lstabscontext, GetCurrentDnode(plsc), GetCurrentUr(plsc),
|
|
fFalse, &lsktab, &fBreakThroughTab);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
TurnOnTabEncounted(plsc);
|
|
if (lsktab != lsktLeft)
|
|
TurnOnNonLeftTabEncounted(plsc);
|
|
|
|
/* move current pen position */
|
|
AdvanceCurrentUr(plsc, DurFromDnode(GetCurrentDnode(plsc)));
|
|
|
|
if (fBreakThroughTab)
|
|
{
|
|
lserr = GetMarginAfterBreakThroughTab(&plsc->lstabscontext, GetCurrentDnode(plsc),
|
|
&urNewMargin);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
SetBreakthroughLine(plsc, urNewMargin);
|
|
}
|
|
}
|
|
return lserrNone;
|
|
}
|
|
|
|
#define idObjSplat idObjTextChp - 2
|
|
|
|
/* H A N D L E S P L A T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: HandleSplat
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
pfmtres - (OUT) fmtres of the splat dnode, procedure can change it
|
|
in the case of fIgnoreSplatBreak to either fmtrCompletedRun
|
|
or fmtrStopped
|
|
|
|
Markes dnode for splat, deletes it in a case of fIgnoreSplatBreak
|
|
----------------------------------------------------------------------------*/
|
|
|
|
LSERR HandleSplat(PLSC plsc, FMTRES* pfmtres)
|
|
{
|
|
PLSDNODE plsdn;
|
|
LSCP cpAfterSplat;
|
|
BOOL fQuit;
|
|
LSERR lserr;
|
|
|
|
plsdn = GetCurrentDnode(plsc);
|
|
cpAfterSplat = GetCurrentCpLim(plsc);
|
|
|
|
if (plsc->fIgnoreSplatBreak)
|
|
{
|
|
lserr = CheckNewPara(plsc, cpAfterSplat - 1, cpAfterSplat, &fQuit);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (fQuit)
|
|
{
|
|
/* despite plsc->fIgnoreSplatBreak we should stop formatting here */
|
|
*pfmtres = fmtrStopped;
|
|
}
|
|
else
|
|
{
|
|
*pfmtres = fmtrCompletedRun;
|
|
}
|
|
|
|
/* delete splat dnode */
|
|
/* break link */
|
|
*(GetWhereToPutLink(plsc, plsdn->plsdnPrev)) = NULL;
|
|
|
|
/* restore current dnode, don't change cpLim and geometry */
|
|
SetCurrentDnode(plsc, plsdn->plsdnPrev);
|
|
|
|
Assert(plsdn->plsdnNext == NULL);
|
|
lserr = DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdn, plsc->fDontReleaseRuns);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
/* set special idobj that will solve all chunk group chunk problems */
|
|
Assert(FIsDnodeReal(plsdn));
|
|
plsdn->u.real.lschp.idObj = idObjSplat;
|
|
TurnOffAllSimpleText(plsc); /* not simple text */
|
|
|
|
}
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* C R E A T E S U B L I N E C O R E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CreateSublineCore
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cpFirst - (IN) first cp of a subline
|
|
urColumnMax - (IN) max possible width of a subline
|
|
lstflow - (IN) text flow of a subline
|
|
fContiguos - (IN) if TRUE such line has the same coordinate system as main line
|
|
and is allowed to have tabs
|
|
|
|
Allocates, initializes subline structure. Sets subline as current.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
LSERR CreateSublineCore(PLSC plsc, LSCP cpFirst, long urColumnMax,
|
|
LSTFLOW lstflow, BOOL fContiguous)
|
|
{
|
|
PLSSUBL plssubl;
|
|
LSERR lserr;
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(FFormattingAllowed(plsc) || FBreakingAllowed(plsc));
|
|
Assert(GetCurrentSubline(plsc) == NULL);
|
|
|
|
plssubl = plsc->lscbk.pfnNewPtr(plsc->pols,
|
|
sizeof(LSSUBL));
|
|
if (plssubl == NULL)
|
|
return lserrOutOfMemory;
|
|
|
|
/* fill in structure */
|
|
plssubl->tag = tagLSSUBL;
|
|
plssubl->plsc = plsc;
|
|
plssubl->cpFirst = cpFirst;
|
|
plssubl->lstflow = lstflow;
|
|
plssubl->urColumnMax = urColumnMax;
|
|
plssubl->cpLim = cpFirst;
|
|
plssubl->plsdnFirst = NULL;
|
|
plssubl->plsdnLast = NULL;
|
|
plssubl->fMain = fFalse;
|
|
plssubl->plsdnUpTemp = NULL;
|
|
plssubl->fAcceptedForDisplay = fFalse;
|
|
plssubl->fRightMarginExceeded = fFalse;
|
|
|
|
if (fContiguous)
|
|
{
|
|
Assert(FFormattingAllowed(plsc));
|
|
Assert(SublineFromDnode(GetDnodeToFinish(plsc))->fContiguous);
|
|
plssubl->urCur = GetCurrentUrSubl(SublineFromDnode(GetDnodeToFinish(plsc)));
|
|
plssubl->vrCur = GetCurrentVrSubl(SublineFromDnode(GetDnodeToFinish(plsc)));
|
|
}
|
|
else
|
|
{
|
|
plssubl->urCur = 0;
|
|
plssubl->vrCur = 0;
|
|
}
|
|
plssubl->fContiguous = (BYTE) fContiguous;
|
|
plssubl->fDupInvalid = fTrue;
|
|
|
|
plssubl->plschunkcontext = plsc->lscbk.pfnNewPtr(plsc->pols,
|
|
sizeof(LSCHUNKCONTEXT));
|
|
if (plssubl->plschunkcontext == NULL)
|
|
return lserrOutOfMemory;
|
|
|
|
lserr = AllocChunkArrays(plssubl->plschunkcontext, &plsc->lscbk, plsc->pols,
|
|
&plsc->lsiobjcontext);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
InitSublineChunkContext(plssubl->plschunkcontext, plssubl->urCur, plssubl->vrCur);
|
|
|
|
/* allocate break context */
|
|
plssubl->pbrkcontext = plsc->lscbk.pfnNewPtr(plsc->pols,
|
|
sizeof(BRKCONTEXT));
|
|
if (plssubl->pbrkcontext == NULL)
|
|
return lserrOutOfMemory;
|
|
/* set flags */
|
|
plssubl->pbrkcontext->fBreakPrevValid = fFalse;
|
|
plssubl->pbrkcontext->fBreakNextValid = fFalse;
|
|
plssubl->pbrkcontext->fBreakForceValid = fFalse;
|
|
|
|
|
|
/* set this subline as current */
|
|
SetCurrentSubline(plsc, plssubl);
|
|
|
|
IncreaseFormatDepth(plsc);
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/* F I N I S H S U B L I N E C O R E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FinishSublineCore
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plssubl - (IN) subline to finish
|
|
|
|
Applies nominal to ideal to the last chunk of text, flushes current subline
|
|
----------------------------------------------------------------------------*/
|
|
|
|
|
|
LSERR FinishSublineCore(
|
|
PLSSUBL plssubl) /* IN: subline to finish */
|
|
{
|
|
PLSC plsc;
|
|
LSERR lserr;
|
|
PLSDNODE plsdn;
|
|
|
|
Assert(FIsLSSUBL(plssubl));
|
|
|
|
plsc = plssubl->plsc;
|
|
Assert(plssubl == GetCurrentSubline(plsc));
|
|
|
|
/* apply nominal to ideal to the last chunk of text */
|
|
if (FNominalToIdealEncounted(plsc))
|
|
{
|
|
lserr = ApplyNominalToIdeal(PlschunkcontextFromSubline(plssubl), &plsc->lsiobjcontext,
|
|
plsc->grpfManager, plsc->lsadjustcontext.lskj,
|
|
FIsSubLineMain(plssubl), FLineContainsAutoNumber(plsc),
|
|
GetCurrentDnodeSubl(plssubl));
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
/* skip back pen dnodes */
|
|
plsdn = plssubl->plsdnLast;
|
|
while (plsdn != NULL && FIsDnodePen(plsdn))
|
|
{
|
|
plsdn = plsdn->plsdnPrev;
|
|
}
|
|
|
|
/* close last border */
|
|
if (FDnodeHasBorder(plsdn) && !FIsDnodeCloseBorder(plsdn))
|
|
{
|
|
lserr = CloseCurrentBorder(plsc);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
/* set boundaries for display */
|
|
SetCpLimDisplaySubl(plssubl, GetCurrentCpLimSubl(plssubl));
|
|
SetLastDnodeDisplaySubl(plssubl, GetCurrentDnodeSubl(plssubl));
|
|
|
|
|
|
/* flush current subline */
|
|
SetCurrentSubline(plsc, NULL);
|
|
|
|
DecreaseFormatDepth(plsc);
|
|
|
|
lserr = LsSublineFinishedText(PlnobjFromLsc(plsc, IobjTextFromLsc(&((plsc)->lsiobjcontext))));
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* U N D O L A S T D N O D E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: UndoLastDnode
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
|
|
Restores set before last dnode and deletes it.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
static LSERR UndoLastDnode(PLSC plsc)
|
|
{
|
|
PLSDNODE plsdn = GetCurrentDnode(plsc);
|
|
long cpDecrease;
|
|
|
|
Assert(FIsLSDNODE(plsdn));
|
|
|
|
/* break link */
|
|
*(GetWhereToPutLink(plsc, plsdn->plsdnPrev)) = NULL;
|
|
|
|
/* restore state */
|
|
cpDecrease = plsdn->dcp;
|
|
AdvanceCurrentCpLim(plsc, -cpDecrease);
|
|
SetCurrentDnode(plsc, plsdn->plsdnPrev);
|
|
AdvanceCurrentUr(plsc, -DurFromDnode(plsdn));
|
|
AdvanceCurrentVr(plsc, -DvrFromDnode(plsdn));
|
|
|
|
Assert(plsdn->plsdnNext == NULL);
|
|
return DestroyDnodeList (&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsdn, plsc->fDontReleaseRuns);
|
|
|
|
|
|
}
|
|
|
|
/* O P E N B O R D E R */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: OpenBorder
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
plsrun - (IN) run with border information
|
|
|
|
Creates border dnode
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR OpenBorder(PLSC plsc, PLSRUN plsrun)
|
|
{
|
|
PLSDNODE plsdnCurrent;
|
|
PLSDNODE* pplsdnToStoreNext;
|
|
long durBorder, dupBorder;
|
|
PLSDNODE plsdnBorder;
|
|
LSERR lserr;
|
|
|
|
plsdnCurrent = GetCurrentDnode(plsc);
|
|
pplsdnToStoreNext = GetWhereToPutLink(plsc, plsdnCurrent);
|
|
|
|
lserr = plsc->lscbk.pfnGetBorderInfo(plsc->pols, plsrun, GetCurrentLstflow(plsc),
|
|
&durBorder, &dupBorder);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
|
|
CreateBorderDnode(plsc, plsdnBorder, durBorder, dupBorder);
|
|
plsdnBorder->fOpenBorder = fTrue;
|
|
|
|
/* maintain list and state */
|
|
*pplsdnToStoreNext = plsdnBorder;
|
|
SetCurrentDnode(plsc, plsdnBorder);
|
|
AdvanceCurrentUr(plsc, durBorder);
|
|
TurnOffAllSimpleText(plsc); /* not simple text */
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* C L O S E C U R R E N T B O R D E R */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CloseCurrentBorder
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
|
|
Creates border dnode
|
|
----------------------------------------------------------------------------*/
|
|
LSERR CloseCurrentBorder(PLSC plsc)
|
|
{
|
|
PLSDNODE plsdnCurrent;
|
|
PLSDNODE* pplsdnToStoreNext;
|
|
long durBorder, dupBorder;
|
|
PLSDNODE plsdnBorder;
|
|
LSERR lserr;
|
|
PLSDNODE plsdn;
|
|
|
|
plsdnCurrent = GetCurrentDnode(plsc);
|
|
pplsdnToStoreNext = GetWhereToPutLink(plsc, plsdnCurrent);
|
|
|
|
/* find open border */
|
|
plsdn = plsdnCurrent;
|
|
Assert(FIsLSDNODE(plsdn));
|
|
while (! FIsDnodeBorder(plsdn))
|
|
{
|
|
plsdn = plsdn->plsdnPrev;
|
|
Assert(FIsLSDNODE(plsdn));
|
|
}
|
|
Assert(plsdn->fOpenBorder);
|
|
|
|
if (plsdn != plsdnCurrent)
|
|
{
|
|
durBorder = plsdn->u.pen.dur;
|
|
dupBorder = plsdn->u.pen.dup;
|
|
|
|
CreateBorderDnode(plsc, plsdnBorder, durBorder, dupBorder);
|
|
|
|
/* maintain list and state */
|
|
*pplsdnToStoreNext = plsdnBorder;
|
|
SetCurrentDnode(plsc, plsdnBorder);
|
|
AdvanceCurrentUr(plsc, durBorder);
|
|
}
|
|
else
|
|
{
|
|
/* we have empty list between borders */
|
|
lserr = UndoLastDnode(plsc);
|
|
if (lserr != lserrNone)
|
|
return lserrNone;
|
|
}
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
long RightMarginIncreasing(PLSC plsc, long urColumnMax)
|
|
{
|
|
long Coeff = plsc->lMarginIncreaseCoefficient;
|
|
long urInch;
|
|
long One32rd;
|
|
if (urColumnMax <= 0)
|
|
{
|
|
/* such strange formula for non positive margin is to have on
|
|
the first iteration 1 inch and 8 inches on the second*/
|
|
urInch = UrFromUa(LstflowFromSubline(GetCurrentSubline(plsc)),
|
|
&(plsc)->lsdocinf.lsdevres, 1440);
|
|
if (Coeff == uLsInfiniteRM || (Coeff >= uLsInfiniteRM / (7 * urInch)))
|
|
return uLsInfiniteRM;
|
|
else
|
|
return (7*Coeff - 6)* urInch;
|
|
}
|
|
else
|
|
{
|
|
if (urColumnMax <= 32)
|
|
One32rd = 1;
|
|
else
|
|
One32rd = urColumnMax >> 5;
|
|
|
|
if (Coeff == uLsInfiniteRM || (Coeff >= (uLsInfiniteRM - urColumnMax)/One32rd))
|
|
return uLsInfiniteRM;
|
|
else
|
|
return urColumnMax + (Coeff * One32rd);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
/* E R R R E L E A S E R U N T O F O R M A T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: ErrReleaseRunToFormat
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
plsrun - (IN) ponter to a run structure to be deleted
|
|
lserr - (IN) code of an error
|
|
|
|
Called in a error situation when run has not been formatted yet .
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR ErrReleaseRunToFormat(PLSC plsc, PLSRUN plsrun, LSERR lserr)
|
|
{
|
|
LSERR lserrIgnore;
|
|
|
|
if (!plsc->fDontReleaseRuns)
|
|
lserrIgnore = plsc->lscbk.pfnReleaseRun(plsc->pols, plsrun);
|
|
|
|
return lserr;
|
|
}
|
|
|
|
|