1940 lines
60 KiB
C
1940 lines
60 KiB
C
#include <limits.h>
|
|
#include "lsmem.h" /* memset() */
|
|
|
|
|
|
#include "break.h"
|
|
#include "dnutils.h"
|
|
#include "iobj.h"
|
|
#include "iobjln.h"
|
|
#include "lsc.h"
|
|
#include "lschp.h"
|
|
#include "lscrline.h"
|
|
#include "lsdevres.h"
|
|
#include "lskysr.h"
|
|
#include "lsffi.h"
|
|
#include "lsidefs.h"
|
|
#include "lsline.h"
|
|
#include "lsfetch.h"
|
|
#include "lstext.h"
|
|
#include "prepdisp.h"
|
|
#include "tlpr.h"
|
|
#include "qheap.h"
|
|
#include "sublutil.h"
|
|
#include "zqfromza.h"
|
|
#include "lscfmtfl.h"
|
|
#include "limqmem.h"
|
|
#include "ntiman.h"
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
long urLeft;
|
|
BOOL fAutoDecimalTab;
|
|
long durAutoDecimalTab;
|
|
LSCP cpFirstVis;
|
|
BOOL fAutonumber;
|
|
BOOL fStopped;
|
|
BOOL fYsrChangeAfter;
|
|
WCHAR wchYsr; /* we need memory to keep wchYsr for kysrChangeAfter */
|
|
|
|
} LINEGEOMETRY;
|
|
|
|
static LSERR CreateLineCore(PLSC, /* IN: ptr to line services context */
|
|
LSCP, /* IN: starting cp in line */
|
|
long, /* IN: column width in twips */
|
|
const BREAKREC*, /* IN: previous line's break records */
|
|
DWORD, /* IN: number of previous line's break records */
|
|
DWORD, /* IN: size of the array of current line's break records */
|
|
BREAKREC*, /* OUT: current line's break records */
|
|
DWORD*, /* OUT: actual number of current line's break records */
|
|
LSLINFO*, /* OUT: visible line info to fill in */
|
|
PLSLINE*, /* OUT: ptr to line opaque to client */
|
|
BOOL*); /* OUT fSuccessful: false means insufficient fetch */
|
|
|
|
static BOOL FRoundingOK(void);
|
|
static LSERR CannotCreateLine(PLSLINE*, /* IN: ponter to a line structure to be deleted */
|
|
LSERR); /* IN: code of an error */
|
|
|
|
static LSERR ErrReleasePreFetchedRun (PLSC, /* IN: ptr to line services context */
|
|
PLSRUN, /* IN: ponter to a run structure to be deleted */
|
|
LSERR); /* IN: code of an error */
|
|
|
|
static LSERR EndFormatting(PLSC, /* IN: ptr to line services context */
|
|
enum endres, /* IN: type of line ending to put in lslinfo */
|
|
LSCP, /* IN: cpLim to put in lslinfo */
|
|
LSDCP, /* IN: dcpDepend to put in lslinfo*/
|
|
LSLINFO*); /* OUT: lslinfo to fill in, output of LsCreateLine*/
|
|
static LSERR FiniFormatGeneralCase (
|
|
PLSC, /* IN: ptr to line services context */
|
|
const BREAKREC*,/* IN: input array of break records */
|
|
DWORD, /* IN: number of records in input array */
|
|
DWORD, /* IN: size of the output array */
|
|
BREAKREC*, /* OUT: output array of break records */
|
|
DWORD*, /* OUT:actual number of records in array*/
|
|
LSLINFO*, /* OUT: lslinfo to fill in, output of LsCreateLine*/
|
|
BOOL*); /* OUT fSuccessful: false means insufficient fetch */
|
|
|
|
static LSERR FiniEndLine(PLSC, /* IN: ptr to line services context */
|
|
ENDRES, /* IN: how the line ended */
|
|
LSCP /* IN: cpLim of a line as a result of breaking,
|
|
can be changed in this procedure*/,
|
|
LSDCP, /* IN: dcpDepend (amount of characters after breaking point
|
|
that has participated in breaking decision)
|
|
can be changed in this procedure */
|
|
LSLINFO*); /* OUT: lslinfo to fill in, output of LsCreateLine*/
|
|
|
|
static LSERR FetchUntilVisible(
|
|
PLSC, /* IN: ptr to line services context */
|
|
LSPAP*, /* IN/OUT current lspap before and after */
|
|
LSCP*, /* IN/OUT current cp before and after */
|
|
LSFRUN*, /* IN/OUT current lsfrun before and after */
|
|
PLSCHP, /* IN/OUT current lschp before and after */
|
|
BOOL*, /* OUT fStopped: procedure stopped fetching because has not been allowed
|
|
to go across paragraph boundaries (result CheckPara Boundaries) */
|
|
BOOL*); /* OUT fNewPara: procedure crossed paragraph boundaries */
|
|
|
|
static LSERR InitTextParams(PLSC, /* IN: ptr to line services context */
|
|
LSCP, /* IN: cp to start fetch */
|
|
long, /* IN: duaColumn */
|
|
LSFRUN*, /* OUT: lsfrun of the first run */
|
|
PLSCHP, /* OUT: lsfrun of the first run */
|
|
LINEGEOMETRY*); /* OUT: set of flags and parameters about a line */
|
|
|
|
static LSERR FiniAuto(PLSC , /* IN: ptr to line services context */
|
|
BOOL , /* IN: fAutonumber */
|
|
BOOL , /* IN: fAutoDecimalTab */
|
|
PLSFRUN , /* IN: first run of the main text */
|
|
long, /* IN: durAutoDecimalTab */
|
|
const BREAKREC*, /* IN: input array of break records */
|
|
DWORD, /* IN: number of records in input array */
|
|
DWORD, /* IN: size of the output array */
|
|
BREAKREC*, /* OUT: output array of break records */
|
|
DWORD*, /* OUT:actual number of records in array*/
|
|
LSLINFO*, /* OUT: lslinfo to fill in, output of LsCreateLine*/
|
|
BOOL*); /* OUT fSuccessful: false means insufficient fetch */
|
|
|
|
static LSERR InitCurLine(PLSC plsc, /* IN: ptr to line services context */
|
|
LSCP cpFirst); /* IN: first cp in al line */
|
|
|
|
static LSERR RemoveLineObjects(PLSLINE plsline); /* IN: ponter to a line structure */
|
|
|
|
static LSERR GetYsrChangeAfterRun(
|
|
PLSC plsc, /* IN: ptr to line services context */
|
|
LSCP cp, /* IN: cp to start fetch */
|
|
BOOL* pfYsrChangeAfter, /* OUT: is it hyphenation of the previous line */
|
|
PLSFRUN plsfrun, /* OUT: lsfrun of modified first run */
|
|
PLSCHP plschp, /* OUT: lschp of modified first run */
|
|
LINEGEOMETRY*); /* OUT: to put wchYsr */
|
|
|
|
static LSERR FillTextParams(
|
|
PLSC plsc, /* IN: ptr to line services context */
|
|
LSCP cp, /* IN: cp to start fetch */
|
|
long duaCol, /* IN: duaColumn */
|
|
PLSPAP plspap, /* IN: paragraph properties */
|
|
BOOL fFirstLineInPara, /* IN: flag fFirstLineInPara */
|
|
BOOL fStopped, /* IN: flag fStopped */
|
|
LINEGEOMETRY*); /* OUT: set of flags and parameters about a line */
|
|
|
|
static LSERR FiniChangeAfter(
|
|
PLSC plsc, /* IN: ptr to line services context */
|
|
LSFRUN* plsfrun, /* IN: lsfrun of modified first run */
|
|
const BREAKREC*, /* IN: input array of break records */
|
|
DWORD, /* IN: number of records in input array */
|
|
DWORD, /* IN: size of the output array */
|
|
BREAKREC*, /* OUT: output array of break records */
|
|
DWORD*, /* OUT:actual number of records in array*/
|
|
LSLINFO*, /* OUT: lslinfo to fill in, output of LsCreateLine*/
|
|
BOOL*); /* OUT fSuccessful: false means insufficient fetch */
|
|
|
|
|
|
|
|
|
|
|
|
/* L I M R G */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: LimRg
|
|
%%Contact: lenoxb
|
|
|
|
Returns # of elements in an array.
|
|
----------------------------------------------------------------------------*/
|
|
#define LimRg(rg) (sizeof(rg)/sizeof((rg)[0]))
|
|
|
|
|
|
|
|
|
|
|
|
#define fFmiAdvancedFormatting (fFmiPunctStartLine | fFmiHangingPunct)
|
|
|
|
|
|
#define FBreakJustSimple(lsbrj) (lsbrj == lsbrjBreakJustify || lsbrj == lsbrjBreakThenSqueeze)
|
|
|
|
#define FAdvancedTypographyEnabled(plsc, cbreakrec) \
|
|
(FNominalToIdealBecauseOfParagraphProperties(plsc->grpfManager, \
|
|
plsc->lsadjustcontext.lskj) || \
|
|
!FBreakJustSimple((plsc)->lsadjustcontext.lsbrj) ||\
|
|
cbreakrec != 0 \
|
|
)
|
|
|
|
#define fFmiSpecialSpaceBreaking (fFmiWrapTrailingSpaces | fFmiWrapAllSpaces)
|
|
|
|
#define fFmiQuickBreakProhibited (fFmiSpecialSpaceBreaking | fFmiDoHyphenation)
|
|
|
|
/* F T R Y Q U I C K B R E A K */
|
|
/*----------------------------------------------------------------------------
|
|
%%Macro: FTryQuickBreak
|
|
%%Contact: igorzv
|
|
|
|
"Returns" fTrue when the formatter flags indicate that it it may be
|
|
possible to use QuickBreakText() instead of the more expensive
|
|
BreakGeneralCase().
|
|
----------------------------------------------------------------------------*/
|
|
#define FTryQuickBreak(plsc) ((((plsc)->grpfManager & fFmiQuickBreakProhibited) == 0) && \
|
|
((plsc)->lMarginIncreaseCoefficient == LONG_MIN) \
|
|
)
|
|
|
|
|
|
#define GetMainSubline(plsc) \
|
|
(Assert(FWorkWithCurrentLine(plsc)),\
|
|
&((plsc)->plslineCur->lssubl))
|
|
|
|
#define FPapInconsistent(plspap) \
|
|
((((plspap)->lsbrj == lsbrjBreakJustify || \
|
|
(plspap)->lsbrj == lsbrjBreakWithCompJustify) \
|
|
&& (plspap)->uaRightBreak < uLsInfiniteRM \
|
|
&& (plspap)->uaRightBreak != (plspap)->uaRightJustify) \
|
|
|| ((plspap)->lsbrj == lsbrjBreakThenExpand \
|
|
&& (plspap)->uaRightBreak < (plspap)->uaRightJustify) \
|
|
|| ((plspap)->lsbrj == lsbrjBreakThenSqueeze \
|
|
&& (plspap)->uaRightBreak > (plspap)->uaRightJustify) \
|
|
|| ((plspap)->lsbrj != lsbrjBreakWithCompJustify \
|
|
&& (plspap)->grpf & fFmiHangingPunct) \
|
|
|| ((plspap)->lsbrj == lsbrjBreakWithCompJustify \
|
|
&& (plspap)->lskj == lskjFullGlyphs))
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* L S C R E A T E L I N E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: LsCreateLine
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cpFirst - (IN) starting cp in line
|
|
duaColumn - (IN) column width in twips
|
|
pbreakrecPrev - (IN) previous line's break records
|
|
breakrecMacPrev - (IN) number of previous line's break records
|
|
breakrecMaxCurrent- (IN) size of the array of current line's break records
|
|
pbreakrecCurrent- (OUT) current line's break records
|
|
pbreakrecMacCurrent-(OUT) actual number of current line's break records
|
|
plsinfo - (OUT) visible line info to fill in
|
|
pplsline - (OUT) ptr to line opaque to client
|
|
|
|
An exported LineServices API.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
LSERR WINAPI LsCreateLine(PLSC plsc,
|
|
LSCP cpFirst,
|
|
long duaColumn,
|
|
const BREAKREC* pbreakrecPrev,
|
|
DWORD breakrecMacPrev,
|
|
DWORD breakrecMaxCurrent,
|
|
BREAKREC* pbreakrecCurrent,
|
|
DWORD* pbreakrecMacCurrent,
|
|
LSLINFO* plslinfo,
|
|
PLSLINE* pplsline)
|
|
{
|
|
|
|
|
|
LSERR lserr;
|
|
BOOL fSuccessful;
|
|
|
|
|
|
/* Check parameters and enviroment */
|
|
|
|
|
|
Assert(FRoundingOK());
|
|
|
|
if (plslinfo == NULL || pplsline == NULL || pbreakrecMacCurrent == NULL)
|
|
return lserrNullOutputParameter;
|
|
|
|
*pplsline = NULL;
|
|
*pbreakrecMacCurrent = 0; /* it's very important to initialize number of break records
|
|
because for example quick break doesn't work with break records */
|
|
|
|
if (!FIsLSC(plsc))
|
|
return lserrInvalidContext;
|
|
|
|
if (plsc->lsstate != LsStateFree)
|
|
return lserrContextInUse;
|
|
|
|
Assert(FIsLsContextValid(plsc));
|
|
|
|
if (pbreakrecPrev == NULL && breakrecMacPrev != 0)
|
|
return lserrInvalidParameter;
|
|
|
|
if (pbreakrecCurrent == NULL && breakrecMaxCurrent != 0)
|
|
return lserrInvalidParameter;
|
|
|
|
if (duaColumn < 0)
|
|
return lserrInvalidParameter;
|
|
|
|
if (duaColumn > uLsInfiniteRM)
|
|
duaColumn = uLsInfiniteRM;
|
|
|
|
/* if we have current line we must prepare it for display before creating of new line */
|
|
/* can change context. We've delayed this untill last moment because of optimisation reasons */
|
|
if (plsc->plslineCur != NULL)
|
|
{
|
|
lserr = PrepareLineForDisplayProc(plsc->plslineCur);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
plsc->plslineCur = NULL;
|
|
}
|
|
|
|
plsc->lMarginIncreaseCoefficient = LONG_MIN;
|
|
|
|
do /* loop allowing change of exceeded right margin if it's not sufficient */
|
|
{
|
|
lserr = CreateLineCore(plsc, cpFirst, duaColumn, pbreakrecPrev, breakrecMacPrev,
|
|
breakrecMaxCurrent, pbreakrecCurrent, pbreakrecMacCurrent,
|
|
plslinfo, pplsline, &fSuccessful);
|
|
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (!fSuccessful)
|
|
{ /* coefficient has not been sufficient before so increase it */
|
|
if (plsc->lMarginIncreaseCoefficient == LONG_MIN)
|
|
plsc->lMarginIncreaseCoefficient = 1;
|
|
else
|
|
{
|
|
if (plsc->lMarginIncreaseCoefficient >= uLsInfiniteRM / 2 )
|
|
plsc->lMarginIncreaseCoefficient = uLsInfiniteRM;
|
|
else
|
|
plsc->lMarginIncreaseCoefficient *= 2;
|
|
}
|
|
}
|
|
}
|
|
while (!fSuccessful);
|
|
|
|
|
|
#ifdef DEBUG
|
|
#ifdef LSTEST_GETMINDUR
|
|
|
|
/* Test LsGetMinDurBreaks () */
|
|
|
|
if ((lserr == lserrNone) && (plslinfo->endr != endrNormal) &&
|
|
(plslinfo->endr != endrHyphenated) && (! (plsc->grpfManager & fFmiDoHyphenation)) )
|
|
{
|
|
/* Line was ended with hard break / stopped */
|
|
|
|
long durMinInclTrail;
|
|
long durMinExclTrail;
|
|
|
|
lserr = LsGetMinDurBreaks ( plsc, *pplsline, &durMinInclTrail,
|
|
&durMinExclTrail );
|
|
};
|
|
|
|
#endif /* LSTEST_GETMINDUR */
|
|
#endif /* DEBUG */
|
|
|
|
|
|
return lserr;
|
|
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* C R E A T E L I N E C O R E*/
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CreateLineCore
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cpFirst - (IN) starting cp in line
|
|
duaColumn - (IN) column width in twips
|
|
pbreakrecPrev - (IN) previous line's break records
|
|
breakrecMacPrev - (IN) number of previous line's break records
|
|
breakrecMaxCurrent- (IN) size of the array of current line's break records
|
|
pbreakrecCurrent- (OUT) current line's break records
|
|
pbreakrecMacCurrent-(OUT) actual number of current line's break records
|
|
plsinfo - (OUT) visible line info to fill in
|
|
pplsline - (OUT) ptr to line opaque to client
|
|
pfSuccessful - (OUT) fSuccessful: false means insufficient fetch
|
|
|
|
Internal procedure organized to handle error in choosing extended right margin
|
|
----------------------------------------------------------------------------*/
|
|
|
|
static LSERR CreateLineCore(PLSC plsc,
|
|
LSCP cpFirst,
|
|
long duaColumn,
|
|
const BREAKREC* pbreakrecPrev,
|
|
DWORD breakrecMacPrev,
|
|
DWORD breakrecMaxCurrent,
|
|
BREAKREC* pbreakrecCurrent,
|
|
DWORD* pbreakrecMacCurrent,
|
|
LSLINFO* plslinfo,
|
|
PLSLINE* pplsline,
|
|
BOOL* pfSuccessful)
|
|
{
|
|
|
|
|
|
PLSLINE plsline;
|
|
LINEGEOMETRY lgeom;
|
|
LSCHP lschp;
|
|
LSERR lserr;
|
|
BOOL fGeneral = fFalse;
|
|
BOOL fHardStop;
|
|
BOOL fSuccessfulQuickBreak;
|
|
LSCP cpLimLine;
|
|
LSDCP dcpDepend = 0;
|
|
LSFRUN lsfrun;
|
|
long urFinalPen;
|
|
long urColumnMaxIncreased;
|
|
ENDRES endr = endrNormal;
|
|
|
|
|
|
/*Initialization; */
|
|
|
|
*pfSuccessful = fTrue;
|
|
|
|
lsfrun.plschp = &lschp; /* we use the same area for lschips */
|
|
/* because we pasing pointer to const nobody can change it */
|
|
|
|
|
|
plsline= PvNewQuick(plsc->pqhLines, cbRep(struct lsline, rgplnobj, plsc->lsiobjcontext.iobjMac));
|
|
if (plsline == NULL)
|
|
return lserrOutOfMemory;
|
|
|
|
plsc->lsstate = LsStateFormatting; /* We start here forwating line. After this momemt we must
|
|
free context before return. We do this either in CannotCreateLine (error)
|
|
or EndFormatting (success) */
|
|
|
|
plsc->plslineCur = plsline;
|
|
*pplsline = plsline;
|
|
|
|
lserr = InitCurLine (plsc, cpFirst);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline, lserr);
|
|
|
|
|
|
/* check initial value of flags */
|
|
Assert(FAllSimpleText(plsc));
|
|
Assert(!FNonRealDnodeEncounted(plsc));
|
|
Assert(!FNonZeroDvpPosEncounted(plsc));
|
|
Assert(AggregatedDisplayFlags(plsc) == 0);
|
|
Assert(!FNominalToIdealEncounted(plsc));
|
|
Assert(!FForeignObjectEncounted(plsc));
|
|
Assert(!FTabEncounted(plsc));
|
|
Assert(!FNonLeftTabEncounted(plsc));
|
|
Assert(!FSubmittedSublineEncounted(plsc));
|
|
Assert(!FAutodecimalTabPresent(plsc));
|
|
|
|
plsc->cLinesActive += 1;
|
|
|
|
|
|
lserr = InitTextParams(plsc, cpFirst, duaColumn, &lsfrun, &lschp, &lgeom);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
|
|
/* prepare starting set for formatting */
|
|
InitFormattingContext(plsc, lgeom.urLeft, lgeom.cpFirstVis);
|
|
|
|
|
|
/* REVIEW comments */
|
|
if (lgeom.fStopped)
|
|
{
|
|
plsc->lsstate = LsStateBreaking; /* we now in a stage of breaking */
|
|
|
|
lserr = FiniEndLine(plsc, endrStopped, lgeom.cpFirstVis, 0, plslinfo);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
|
|
/* change first character because of hyphenation */
|
|
if (lgeom.fYsrChangeAfter)
|
|
{
|
|
Assert(!(lgeom.fAutonumber) || (lgeom.fAutoDecimalTab));
|
|
|
|
lserr = FiniChangeAfter(plsc, &lsfrun, pbreakrecPrev,
|
|
breakrecMacPrev, breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent, plslinfo, pfSuccessful);
|
|
|
|
if (lserr != lserrNone || !*pfSuccessful)
|
|
return CannotCreateLine(pplsline, lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
/* important note to understand code flow : The situation below can happened
|
|
only for first line in a paragraph, the situation above never can happened
|
|
for such line. */
|
|
|
|
/* if autonumbering or auto-decimal tab */
|
|
if ((lgeom.fAutonumber) || (lgeom.fAutoDecimalTab))
|
|
{
|
|
Assert(!lgeom.fYsrChangeAfter);
|
|
|
|
TurnOffAllSimpleText(plsc);
|
|
|
|
/* we will release plsrun in FiniAuto */
|
|
|
|
lserr = FiniAuto(plsc, lgeom.fAutonumber, lgeom.fAutoDecimalTab, &lsfrun,
|
|
lgeom.durAutoDecimalTab, pbreakrecPrev,
|
|
breakrecMacPrev, breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent, plslinfo, pfSuccessful);
|
|
|
|
if (lserr != lserrNone || !*pfSuccessful)
|
|
return CannotCreateLine(pplsline, lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
|
|
if (FAdvancedTypographyEnabled(plsc, breakrecMacPrev ))
|
|
{
|
|
/* we should release run here, in general procedure we will fetch it again */
|
|
if (!plsc->fDontReleaseRuns)
|
|
{
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, lsfrun.plsrun);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
}
|
|
|
|
lserr = FiniFormatGeneralCase(plsc, pbreakrecPrev,
|
|
breakrecMacPrev, breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent, plslinfo, pfSuccessful);
|
|
|
|
if (lserr != lserrNone || !*pfSuccessful)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
|
|
/* it is possible that width of column is negative: in such scase we'll
|
|
use another right margin*/
|
|
if (plsc->urRightMarginBreak <= 0 && plsc->lMarginIncreaseCoefficient == LONG_MIN)
|
|
plsc->lMarginIncreaseCoefficient = 1;
|
|
|
|
if (plsc->lMarginIncreaseCoefficient != LONG_MIN)
|
|
{
|
|
urColumnMaxIncreased = RightMarginIncreasing(plsc, plsc->urRightMarginBreak);
|
|
}
|
|
else
|
|
{
|
|
urColumnMaxIncreased = plsc->urRightMarginBreak;
|
|
}
|
|
|
|
lserr = QuickFormatting(plsc, &lsfrun, urColumnMaxIncreased,
|
|
&fGeneral, &fHardStop, &cpLimLine, &urFinalPen);
|
|
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
|
|
|
|
if (fGeneral)
|
|
{
|
|
lserr = FiniFormatGeneralCase(plsc, pbreakrecPrev,
|
|
breakrecMacPrev, breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent,
|
|
plslinfo, pfSuccessful);
|
|
|
|
if (lserr != lserrNone || !*pfSuccessful)
|
|
return CannotCreateLine(pplsline, lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
|
|
plsc->lsstate = LsStateBreaking; /* we now in a stage of breaking */
|
|
if (FTryQuickBreak(plsc))
|
|
{
|
|
lserr = BreakQuickCase(plsc, fHardStop, &dcpDepend, &cpLimLine,
|
|
&fSuccessfulQuickBreak, &endr);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
}
|
|
else
|
|
{
|
|
fSuccessfulQuickBreak = fFalse;
|
|
}
|
|
|
|
if (fSuccessfulQuickBreak)
|
|
{
|
|
if (endr == endrNormal || endr == endrAltEndPara ||
|
|
(endr == endrEndPara && !plsc->fLimSplat))
|
|
{
|
|
lserr = EndFormatting(plsc, endr, cpLimLine,
|
|
dcpDepend, plslinfo);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
else /* there is splat that is handled in FiniEndLine */
|
|
{
|
|
lserr = FiniEndLine(plsc, endr, cpLimLine, dcpDepend, plslinfo);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline, lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* here we should use BreakGeneralCase */
|
|
lserr = BreakGeneralCase(plsc, fHardStop, breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent,&dcpDepend,
|
|
&cpLimLine, &endr, pfSuccessful);
|
|
if (lserr != lserrNone || !*pfSuccessful)
|
|
return CannotCreateLine(pplsline,lserr);
|
|
|
|
lserr = FiniEndLine(plsc, endr, cpLimLine, dcpDepend, plslinfo);
|
|
if (lserr != lserrNone)
|
|
return CannotCreateLine(pplsline, lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
} /* end LsCreateLine */
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* F I N I F O R M A T G E N E R A L C A S E*/
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FiniFormatGeneralCase
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
pbreakrecPrev - (IN) previous line's break records
|
|
breakrecMacPrev - (IN) number of previous line's break records
|
|
breakrecMaxCurrent- (IN) size of the array of current line's break records
|
|
pbreakrecCurrent- (OUT) current line's break records
|
|
pbreakrecMacCurrent-(OUT) actual number of current line's break records
|
|
plsinfo - (OUT) visible line info to fill in
|
|
pfSuccessful - (OUT) fSuccessful: false means insufficient fetch
|
|
|
|
Formatting and breaking in a case when "quick formatting" is prohibit
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR FiniFormatGeneralCase (PLSC plsc,
|
|
const BREAKREC* pbreakrecPrev,
|
|
DWORD breakrecMacPrev,
|
|
DWORD breakrecMaxCurrent,
|
|
BREAKREC* pbreakrecCurrent,
|
|
DWORD* pbreakrecMacCurrent,
|
|
LSLINFO* plslinfo, BOOL* pfSuccessful)
|
|
|
|
|
|
|
|
{
|
|
long urColumnMaxIncreased;
|
|
FMTRES fmtres;
|
|
LSERR lserr;
|
|
LSCP cpLimLine;
|
|
LSDCP dcpDepend;
|
|
PLSDNODE plsdnFirst, plsdnLast;
|
|
long urFinal;
|
|
ENDRES endr;
|
|
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(FFormattingAllowed(plsc));
|
|
Assert(plslinfo != NULL);
|
|
|
|
*pfSuccessful = fTrue;
|
|
|
|
if (plsc->lMarginIncreaseCoefficient == LONG_MIN) /* we are here for the first time */
|
|
{
|
|
/* increase right margin for nominal to ideal and compression */
|
|
if (!FBreakJustSimple(plsc->lsadjustcontext.lsbrj))
|
|
plsc->lMarginIncreaseCoefficient = 2;
|
|
else
|
|
plsc->lMarginIncreaseCoefficient = 1;
|
|
}
|
|
|
|
urColumnMaxIncreased = RightMarginIncreasing(plsc, plsc->urRightMarginBreak);
|
|
|
|
if (FNominalToIdealBecauseOfParagraphProperties(plsc->grpfManager,
|
|
plsc->lsadjustcontext.lskj))
|
|
TurnOnNominalToIdealEncounted(plsc);
|
|
|
|
if (breakrecMacPrev != 0)
|
|
lserr = FetchAppendEscResumeCore(plsc, urColumnMaxIncreased, NULL, 0,
|
|
pbreakrecPrev, breakrecMacPrev,
|
|
&fmtres, &cpLimLine, &plsdnFirst,
|
|
&plsdnLast, &urFinal);
|
|
else
|
|
lserr = FetchAppendEscCore(plsc, urColumnMaxIncreased, NULL, 0,
|
|
&fmtres, &cpLimLine, &plsdnFirst,
|
|
&plsdnLast, &urFinal);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
|
|
/* fetch append esc can be stopped because of tab */
|
|
/* so we have loop for tabs here */
|
|
while (fmtres == fmtrTab)
|
|
{
|
|
lserr = HandleTab(plsc);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (FBreakthroughLine(plsc))
|
|
{
|
|
urColumnMaxIncreased = RightMarginIncreasing(plsc, plsc->urRightMarginBreak);
|
|
}
|
|
|
|
lserr = FetchAppendEscCore(plsc, urColumnMaxIncreased, NULL, 0,
|
|
&fmtres, &cpLimLine, &plsdnFirst,
|
|
&plsdnLast, &urFinal);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
Assert(fmtres == fmtrStopped || fmtres == fmtrExceededMargin);
|
|
|
|
/* skip back pen dnodes */
|
|
while (plsdnLast != NULL && FIsDnodePen(plsdnLast))
|
|
{
|
|
plsdnLast = plsdnLast->plsdnPrev;
|
|
}
|
|
|
|
/* close last border */
|
|
if (FDnodeHasBorder(plsdnLast) && !FIsDnodeCloseBorder(plsdnLast))
|
|
{
|
|
lserr = CloseCurrentBorder(plsc);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
if (fmtres == fmtrExceededMargin
|
|
&& (urFinal <= plsc->urRightMarginBreak /* it's important for truncation to have <= here */
|
|
|| plsdnLast == NULL || FIsNotInContent(plsdnLast) /* this can happen if in nominal
|
|
to ideal (dcpMaxContext) we deleted everything
|
|
in content, but starting point
|
|
of content is already behind right margin */
|
|
)
|
|
)
|
|
{
|
|
/* return unsuccessful */
|
|
*pfSuccessful = fFalse;
|
|
return lserrNone;
|
|
}
|
|
else
|
|
{
|
|
plsc->lsstate = LsStateBreaking; /* we now in a stage of breaking */
|
|
lserr = BreakGeneralCase(plsc, (fmtres == fmtrStopped), breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent,
|
|
&dcpDepend, &cpLimLine, &endr, pfSuccessful);
|
|
|
|
if (lserr != lserrNone || !*pfSuccessful)
|
|
return lserr;
|
|
|
|
/* because, we work with increased margin we can resolve pending tab only after break */
|
|
/* we use here that after breaking decision we set state after break point*/
|
|
lserr = HandleTab(plsc);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
return FiniEndLine(plsc, endr, cpLimLine, dcpDepend, plslinfo);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* F I N I E N D L I N E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FiniEndLine
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
endr - (IN) how the line ended
|
|
cpLimLine - (IN) cpLim of a line as a result of breaking,
|
|
can be changed in this procedure
|
|
dcpDepend - (IN) amount of characters after breaking point
|
|
that has participated in breaking decision,
|
|
can be changed in this procedure
|
|
plsinfo - (OUT) visible line info to fill in
|
|
|
|
Handles splat, calculates heights, special effects
|
|
----------------------------------------------------------------------------*/
|
|
|
|
static LSERR FiniEndLine(PLSC plsc, ENDRES endr, LSCP cpLimLine,
|
|
LSDCP dcpDepend, LSLINFO* plslinfo)
|
|
|
|
{
|
|
LSLINFO* plslinfoState;
|
|
OBJDIM objdim;
|
|
LSERR lserr;
|
|
PLSLINE plsline;
|
|
BOOL fEmpty;
|
|
ENDRES endrOld;
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(plslinfo != NULL);
|
|
|
|
plsline = plsc->plslineCur;
|
|
plslinfoState = &(plsline->lslinfo);
|
|
|
|
|
|
endrOld = endr;
|
|
if (endr == endrEndPara && plsc->fLimSplat)
|
|
{
|
|
endr = endrEndParaSection;
|
|
cpLimLine++;
|
|
}
|
|
|
|
/* handling splat */
|
|
if (endr == endrEndColumn || endr == endrEndSection ||
|
|
endr == endrEndParaSection|| endr == endrEndPage)
|
|
{
|
|
|
|
if (plsc->grpfManager & fFmiVisiSplats)
|
|
{
|
|
switch (endr)
|
|
{
|
|
case endrEndColumn: plsline->kspl = ksplColumnBreak; break;
|
|
case endrEndSection: plsline->kspl = ksplSectionBreak; break;
|
|
case endrEndParaSection: plsline->kspl = ksplSectionBreak; break;
|
|
case endrEndPage: plsline->kspl = ksplPageBreak; break;
|
|
}
|
|
}
|
|
|
|
lserr = FIsSublineEmpty(GetMainSubline(plsc), &fEmpty);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (!fEmpty && (plsc->grpfManager & fFmiAllowSplatLine))
|
|
{
|
|
cpLimLine--;
|
|
dcpDepend++;
|
|
plsline->kspl = ksplNone;
|
|
if (endrOld == endrEndPara)
|
|
{
|
|
endr = endrEndPara;
|
|
}
|
|
else
|
|
{
|
|
endr = endrNormal;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Height calculation; */
|
|
|
|
lserr = GetObjDimSublineCore(GetMainSubline(plsc), &objdim);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
plslinfoState->dvrAscent = objdim.heightsRef.dvAscent;
|
|
plslinfoState->dvpAscent = objdim.heightsPres.dvAscent;
|
|
plslinfoState->dvrDescent = objdim.heightsRef.dvDescent;
|
|
plslinfoState->dvpDescent = objdim.heightsPres.dvDescent;
|
|
plslinfoState->dvpMultiLineHeight = objdim.heightsPres.dvMultiLineHeight;
|
|
plslinfoState->dvrMultiLineHeight = objdim.heightsRef.dvMultiLineHeight;
|
|
|
|
/* calculation plslinfoState->EffectsFlags*/
|
|
if (plslinfoState->EffectsFlags) /* some run with special effects happend during formating */
|
|
{
|
|
lserr = GetSpecialEffectsSublineCore(GetMainSubline(plsc),
|
|
&plsc->lsiobjcontext, &plslinfoState->EffectsFlags);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
|
|
return EndFormatting(plsc, endr, cpLimLine, dcpDepend, plslinfo);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* F I N I A U T O */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FiniAuto
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
fAutonumber - (IN) does this line containes autonimber
|
|
fAutoDecimaltab - (IN) does this line containes autodecimal tab
|
|
plsfrunMainText - (IN) first run of main text
|
|
durAutoDecimalTab- (IN) tab stop for autodecimal tab
|
|
pbreakrecPrev - (IN) previous line's break records
|
|
breakrecMacPrev - (IN) number of previous line's break records
|
|
breakrecMaxCurrent- (IN) size of the array of current line's break records
|
|
pbreakrecCurrent- (OUT) current line's break records
|
|
pbreakrecMacCurrent-(OUT) actual number of current line's break records
|
|
plsinfo - (OUT) visible line info to fill in
|
|
pfSuccessful - (OUT) fSuccessful: false means insufficient fetch
|
|
|
|
Completes CreateLine logic for autonumbering and auto-decimal tab
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR FiniAuto(
|
|
PLSC plsc,
|
|
BOOL fAutonumber,
|
|
BOOL fAutoDecimalTab,
|
|
PLSFRUN plsfrunMainText,
|
|
long durAutoDecimalTab,
|
|
const BREAKREC* pbreakrecPrev,
|
|
DWORD breakrecMacPrev,
|
|
DWORD breakrecMaxCurrent,
|
|
BREAKREC* pbreakrecCurrent,
|
|
DWORD* pbreakrecMacCurrent,
|
|
LSLINFO* plslinfo, BOOL* pfSuccessful)
|
|
{
|
|
LSERR lserr;
|
|
|
|
|
|
if (plsc->lMarginIncreaseCoefficient == LONG_MIN)
|
|
plsc->lMarginIncreaseCoefficient = 1;
|
|
|
|
if (fAutonumber) /*autonumbering */
|
|
{
|
|
lserr = FormatAnm(plsc, plsfrunMainText);
|
|
if (lserr != lserrNone)
|
|
{
|
|
return ErrReleasePreFetchedRun(plsc, plsfrunMainText->plsrun, lserr);
|
|
}
|
|
}
|
|
|
|
if (fAutoDecimalTab)
|
|
{
|
|
lserr = InitializeAutoDecTab(plsc, durAutoDecimalTab);
|
|
if (lserr != lserrNone)
|
|
{
|
|
return ErrReleasePreFetchedRun(plsc, plsfrunMainText->plsrun, lserr);
|
|
}
|
|
}
|
|
|
|
/* we should release run here, in general procedure we will fetch it again */
|
|
if (!plsc->fDontReleaseRuns)
|
|
{
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, plsfrunMainText->plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
return FiniFormatGeneralCase(plsc, pbreakrecPrev,
|
|
breakrecMacPrev, breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent, plslinfo, pfSuccessful);
|
|
}
|
|
|
|
/* F I N I C H A N G E A F T E R */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FiniChangeAfter
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
plsfrun, - (IN) lsfrun of modified first run
|
|
pbreakrecPrev - (IN) previous line's break records
|
|
breakrecMacPrev - (IN) number of previous line's break records
|
|
breakrecMaxCurrent- (IN) size of the array of current line's break records
|
|
pbreakrecCurrent- (OUT) current line's break records
|
|
pbreakrecMacCurrent-(OUT) actual number of current line's break records
|
|
plsinfo - (OUT) visible line info to fill in
|
|
pfSuccessful - (OUT) fSuccessful: false means insufficient fetch
|
|
|
|
Completes CreateLine logic for change after because of hyphenation
|
|
----------------------------------------------------------------------------*/
|
|
|
|
static LSERR FiniChangeAfter(PLSC plsc, LSFRUN* plsfrun, const BREAKREC* pbreakrecPrev,
|
|
DWORD breakrecMacPrev,
|
|
DWORD breakrecMaxCurrent,
|
|
BREAKREC* pbreakrecCurrent,
|
|
DWORD* pbreakrecMacCurrent,
|
|
LSLINFO* plslinfo, BOOL* pfSuccessful)
|
|
{
|
|
|
|
LSERR lserr;
|
|
FMTRES fmtres;
|
|
|
|
lserr = ProcessOneRun(plsc, plsc->urRightMarginBreak, plsfrun, NULL, 0, &fmtres);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
return FiniFormatGeneralCase(plsc, pbreakrecPrev,
|
|
breakrecMacPrev, breakrecMaxCurrent,
|
|
pbreakrecCurrent, pbreakrecMacCurrent, plslinfo, pfSuccessful);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* E N D F O R M A T T I N G*/
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: EndFormatting
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
endres - (IN) how line ends
|
|
cpLimLine - (IN) cpLim of a line as a result of breaking,
|
|
can be changed in this procedure
|
|
dcpDepend - (IN) amount of characters after breaking point
|
|
that has participated in breaking decision,
|
|
can be changed in this procedure
|
|
plsinfo - (OUT) visible line info to fill in
|
|
|
|
Filles in lslinfo
|
|
----------------------------------------------------------------------------*/
|
|
|
|
|
|
static LSERR EndFormatting (PLSC plsc, enum endres endr,
|
|
LSCP cpLimLine, LSDCP dcpDepend, LSLINFO* plslinfo)
|
|
|
|
{
|
|
|
|
PLSLINE plsline = plsc->plslineCur;
|
|
LSLINFO* plslinfoContext = &(plsline->lslinfo);
|
|
|
|
|
|
Assert(FIsLSC(plsc));
|
|
Assert(plslinfo != NULL);
|
|
|
|
|
|
plslinfoContext->cpLim = cpLimLine;
|
|
plslinfoContext->dcpDepend = dcpDepend;
|
|
plslinfoContext->endr = endr;
|
|
|
|
|
|
*plslinfo = *plslinfoContext;
|
|
plsc->lsstate = LsStateFree; /* we always return through this procedure (in a case of success )
|
|
so we free context here */
|
|
return lserrNone;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
/* L S M O D I F Y L I N E H E I G H T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: LsModifyLineHeight
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
psline - (IN) ptr to a line to be modified
|
|
dvpAbove - (IN) dvpAbove to set in plsline
|
|
dvpAscent - (IN) dvpAscent to set in plsline
|
|
dvpDescent - (IN) dvpDescent to set in plsline
|
|
dvpBelow - (IN) dvpBelow to set in plsline
|
|
|
|
An exported LineServices API.
|
|
Modifies heights in a plsline structure
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI LsModifyLineHeight(PLSC plsc,
|
|
PLSLINE plsline,
|
|
long dvpAbove,
|
|
long dvpAscent,
|
|
long dvpDescent,
|
|
long dvpBelow)
|
|
{
|
|
if (!FIsLSC(plsc))
|
|
return lserrInvalidContext;
|
|
|
|
if (!FIsLSLINE(plsline))
|
|
return lserrInvalidLine;
|
|
|
|
if (plsline->lssubl.plsc != plsc)
|
|
return lserrMismatchLineContext;
|
|
|
|
if (plsc->lsstate != LsStateFree)
|
|
return lserrContextInUse;
|
|
|
|
|
|
|
|
plsline->dvpAbove = dvpAbove;
|
|
plsline->lslinfo.dvpAscent = dvpAscent;
|
|
plsline->lslinfo.dvpDescent = dvpDescent;
|
|
plsline->dvpBelow = dvpBelow;
|
|
return lserrNone;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
/* L S D E S T R O Y L I N E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: LsDestroyLine
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
psline - (IN) ptr to a line to be deleted
|
|
|
|
An exported LineServices API.
|
|
Removed plsline structure , dnode list, line objects structures
|
|
----------------------------------------------------------------------------*/
|
|
|
|
LSERR WINAPI LsDestroyLine(PLSC plsc, /* IN: ptr to line services context */
|
|
PLSLINE plsline) /* IN: ptr to line -- opaque to client */
|
|
{
|
|
POLS pols;
|
|
LSERR lserrNew, lserr = lserrNone;
|
|
|
|
if (!FIsLSC(plsc))
|
|
return lserrInvalidContext;
|
|
|
|
if (!FIsLSLINE(plsline))
|
|
return lserrInvalidLine;
|
|
|
|
if (plsline->lssubl.plsc != plsc)
|
|
return lserrMismatchLineContext;
|
|
|
|
if (plsc->lsstate != LsStateFree)
|
|
return lserrContextInUse;
|
|
|
|
Assert(FIsLsContextValid(plsc));
|
|
Assert(plsc->cLinesActive > 0);
|
|
|
|
plsc->lsstate = LsStateDestroyingLine;
|
|
|
|
pols = plsc->pols;
|
|
|
|
/* optimization */
|
|
/* we use here that text doesn't have pinfosubl and DestroyDobj is actually empty for text */
|
|
if (!plsc->fDontReleaseRuns || !plsline->fAllSimpleText)
|
|
{
|
|
|
|
lserrNew = DestroyDnodeList(&plsc->lscbk, plsc->pols, &plsc->lsiobjcontext,
|
|
plsline->lssubl.plsdnFirst, plsc->fDontReleaseRuns);
|
|
if (lserrNew != lserrNone && lserr == lserrNone)
|
|
lserr = lserrNew;
|
|
}
|
|
|
|
if (plsline == plsc->plslineCur)
|
|
plsc->plslineCur = NULL;
|
|
|
|
|
|
lserrNew = RemoveLineObjects(plsline);
|
|
if (lserrNew != lserrNone && lserr == lserrNone)
|
|
lserr = lserrNew;
|
|
|
|
/* flush heap of dnodes */
|
|
if (plsline->pqhAllDNodes != NULL)
|
|
FlushQuickHeap(plsline->pqhAllDNodes);
|
|
|
|
if (plsc->pqhAllDNodesRecycled != NULL)
|
|
DestroyQuickHeap(plsc->pqhAllDNodesRecycled);
|
|
|
|
/* recycle quick heap of dnodes */
|
|
plsc->pqhAllDNodesRecycled = plsline->pqhAllDNodes;
|
|
|
|
|
|
plsline->tag = tagInvalid;
|
|
DisposeQuickPv(plsc->pqhLines, plsline,
|
|
cbRep(struct lsline, rgplnobj, plsc->lsiobjcontext.iobjMac));
|
|
|
|
plsc->cLinesActive -= 1;
|
|
|
|
plsc->lsstate = LsStateFree;
|
|
return lserr;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* L S G E T L I N E D U R */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: LsGetLineDur
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) LS context
|
|
plsline - (IN) ptr to a line
|
|
pdurInclTrail - (OUT) dur of line incl. trailing area
|
|
pdurExclTrail - (OUT) dur of line excl. trailing area
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI LsGetLineDur (PLSC plsc, PLSLINE plsline,
|
|
long* pdurInclTrail, long* pdurExclTrail)
|
|
{
|
|
LSERR lserr;
|
|
|
|
if (!FIsLSC(plsc))
|
|
return lserrInvalidContext;
|
|
|
|
if (!FIsLSLINE(plsline))
|
|
return lserrInvalidLine;
|
|
|
|
if (plsline->lssubl.plsc != plsc)
|
|
return lserrMismatchLineContext;
|
|
|
|
if (plsc->lsstate != LsStateFree)
|
|
return lserrContextInUse;
|
|
|
|
Assert(FIsLsContextValid(plsc));
|
|
Assert(plsc->cLinesActive > 0);
|
|
|
|
/* check that the line is active */
|
|
if (plsline != plsc->plslineCur)
|
|
return lserrLineIsNotActive;
|
|
|
|
/* set breaking state */
|
|
plsc->lsstate = LsStateBreaking;
|
|
|
|
lserr = GetLineDurCore(plsc, pdurInclTrail, pdurExclTrail);
|
|
|
|
plsc->lsstate = LsStateFree;
|
|
|
|
return lserr;
|
|
|
|
}
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/* L S G E T M I N D U R B R E A K S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: LsGetMinDurBreaks
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) LS context
|
|
plsline - (IN) ptr to a line
|
|
pdurMinInclTrail - (OUT) min dur between breaks including trailing area
|
|
pdurMinExclTrail - (OUT) min dur between breaks excluding trailing area
|
|
|
|
----------------------------------------------------------------------------*/
|
|
|
|
LSERR WINAPI LsGetMinDurBreaks (PLSC plsc, PLSLINE plsline,
|
|
long* pdurMinInclTrail, long* pdurMinExclTrail)
|
|
{
|
|
LSERR lserr;
|
|
|
|
if (!FIsLSC(plsc))
|
|
return lserrInvalidContext;
|
|
|
|
if (!FIsLSLINE(plsline))
|
|
return lserrInvalidLine;
|
|
|
|
if (plsline->lssubl.plsc != plsc)
|
|
return lserrMismatchLineContext;
|
|
|
|
if (plsc->lsstate != LsStateFree)
|
|
return lserrContextInUse;
|
|
|
|
Assert(FIsLsContextValid(plsc));
|
|
Assert(plsc->cLinesActive > 0);
|
|
|
|
/* check that the line is active */
|
|
if (plsline != plsc->plslineCur)
|
|
return lserrLineIsNotActive;
|
|
|
|
/* set breaking state */
|
|
plsc->lsstate = LsStateBreaking;
|
|
|
|
lserr = GetMinDurBreaksCore(plsc, pdurMinInclTrail, pdurMinExclTrail);
|
|
|
|
plsc->lsstate = LsStateFree;
|
|
|
|
return lserr;
|
|
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
#define grpfTextMask ( \
|
|
fFmiVisiCondHyphens | \
|
|
fFmiVisiParaMarks | \
|
|
fFmiVisiSpaces | \
|
|
fFmiVisiTabs | \
|
|
fFmiVisiBreaks | \
|
|
fFmiDoHyphenation | \
|
|
fFmiWrapTrailingSpaces | \
|
|
fFmiWrapAllSpaces | \
|
|
fFmiPunctStartLine | \
|
|
fFmiHangingPunct | \
|
|
fFmiApplyBreakingRules | \
|
|
fFmiFCheckTruncateBefore | \
|
|
fFmiDrawInCharCodes | \
|
|
fFmiSpacesInfluenceHeight | \
|
|
fFmiIndentChangesHyphenZone | \
|
|
fFmiNoPunctAfterAutoNumber | \
|
|
fFmiTreatHyphenAsRegular \
|
|
)
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* I N I T T E X T P A R A M S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: InitTextParams
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cp, - (IN) cp to start fetch
|
|
duaCol - (IN) duaColumn
|
|
plsfrun - (IN) lsfrun of the first run
|
|
plschp - (OUT) lsfrun of the first run
|
|
plgeom - (OUT) set of flags and parameters about a line
|
|
|
|
|
|
LsCreateLine calls this function at the beginning of the line in order
|
|
to skip over vanished text, fetch an LSPAP, and invoke the text APIs
|
|
SetTextLineParams().
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR InitTextParams(PLSC plsc, LSCP cp, long duaCol,
|
|
LSFRUN* plsfrun, PLSCHP plschp, LINEGEOMETRY* plgeom)
|
|
{
|
|
LSERR lserr;
|
|
LSPAP lspap;
|
|
POLS pols = plsc->pols;
|
|
BOOL fFirstLineInPara;
|
|
BOOL fHidden;
|
|
BOOL fStopped = fFalse;
|
|
BOOL fNoLinesParaBefore;
|
|
BOOL fNewPara;
|
|
|
|
plsfrun->lpwchRun = NULL;
|
|
plsfrun->plsrun = NULL;
|
|
plsfrun->cwchRun = 0;
|
|
|
|
plgeom->fYsrChangeAfter = fFalse;
|
|
|
|
Assert(cp >= 0);
|
|
|
|
lserr = plsc->lscbk.pfnFetchPap(pols, cp, &lspap);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
if (FPapInconsistent(&lspap))
|
|
return lserrInvalidPap;
|
|
|
|
/* N.B. lspap.cpFirstContent may be negative, which indicates
|
|
* "no content in this paragraph".
|
|
*/
|
|
|
|
fNoLinesParaBefore = lspap.cpFirstContent < 0 || cp <= lspap.cpFirstContent;
|
|
|
|
if (!fNoLinesParaBefore && (lspap.grpf & fFmiDoHyphenation))
|
|
{
|
|
lserr = GetYsrChangeAfterRun(plsc, cp, &plgeom->fYsrChangeAfter, plsfrun, plschp, plgeom);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
if (plgeom->fYsrChangeAfter)
|
|
{
|
|
fFirstLineInPara = fFalse;
|
|
fStopped = fFalse;
|
|
lserr = FillTextParams(plsc, cp, duaCol, &lspap, fFirstLineInPara,
|
|
fStopped, plgeom);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, plsfrun->plsrun, lserr);
|
|
else
|
|
return lserrNone;
|
|
}
|
|
}
|
|
|
|
lserr = plsc->lscbk.pfnFetchRun(pols, cp,&plsfrun->lpwchRun, &plsfrun->cwchRun,
|
|
&fHidden, plschp, &plsfrun->plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
|
|
if (fHidden) /* vanished text */
|
|
{
|
|
lserr = FetchUntilVisible(plsc, &lspap, &cp, plsfrun, plschp,
|
|
&fStopped, &fNewPara);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
if (fNewPara)
|
|
fNoLinesParaBefore = fTrue;
|
|
}
|
|
|
|
fFirstLineInPara = fNoLinesParaBefore && FBetween(lspap.cpFirstContent, 0, cp);
|
|
lserr = FillTextParams(plsc, cp, duaCol, &lspap, fFirstLineInPara,
|
|
fStopped, plgeom);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, plsfrun->plsrun, lserr);
|
|
else
|
|
return lserrNone;
|
|
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* G E T Y S R C H A N G E A F T E R R U N */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: GetYsrChangeAfterRun
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cp, - (IN) cp to start fetch
|
|
pfYsrChangeAfter (OUT) is it hyphenation of the previous line
|
|
plsfrun, (OUT) lsfrun of modified first run
|
|
plschp (OUT) lschp of modified first run
|
|
plsgeom (OUT) to put wchYsr
|
|
|
|
|
|
InitTextParams calls this procedure if there is a possibility
|
|
for previous line to be hyphenated.
|
|
If previous line has been hyphenated with ysr change after procedure returns
|
|
modified first run for a line
|
|
----------------------------------------------------------------------------*/
|
|
|
|
static LSERR GetYsrChangeAfterRun(PLSC plsc, LSCP cp, BOOL* pfYsrChangeAfter,
|
|
PLSFRUN plsfrun, PLSCHP plschp, LINEGEOMETRY* plgeom)
|
|
{
|
|
LSFRUN lsfrunPrev;
|
|
LSCHP lschpPrev;
|
|
BOOL fHidden;
|
|
LSERR lserr;
|
|
|
|
lsfrunPrev.plschp = &lschpPrev;
|
|
*pfYsrChangeAfter = fFalse;
|
|
|
|
/* Fetch run at cp-1 to handle ysrChangeAfter from previous line.
|
|
*/
|
|
lserr = plsc->lscbk.pfnFetchRun(plsc->pols, cp-1, &lsfrunPrev.lpwchRun,
|
|
&lsfrunPrev.cwchRun, &fHidden,
|
|
&lschpPrev, &lsfrunPrev.plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
/* previous run is hyphenated text */
|
|
if (!fHidden && ((lsfrunPrev.plschp)->idObj == idObjTextChp)
|
|
&& (lsfrunPrev.plschp)->fHyphen)
|
|
{
|
|
DWORD kysr;
|
|
WCHAR wchYsr;
|
|
Assert(lsfrunPrev.cwchRun == 1);
|
|
|
|
lserr = plsc->lscbk.pfnGetHyphenInfo(plsc->pols, lsfrunPrev.plsrun, &kysr, &wchYsr);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, lsfrunPrev.plsrun, lserr);
|
|
|
|
if ((kysr == kysrChangeAfter) &&
|
|
(wchYsr != 0))
|
|
{
|
|
lserr = plsc->lscbk.pfnFetchRun(plsc->pols, cp, &plsfrun->lpwchRun,
|
|
&plsfrun->cwchRun, &fHidden,
|
|
plschp, &plsfrun->plsrun);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, lsfrunPrev.plsrun, lserr);
|
|
|
|
if (!fHidden)
|
|
{
|
|
Assert((plsfrun->plschp)->idObj == idObjTextChp);
|
|
plgeom->wchYsr = wchYsr;
|
|
/* Synthesize a 1-byte run */
|
|
plsfrun->lpwchRun = &plgeom->wchYsr; /* here is the only reason to keep wchrChar in lgeom
|
|
we cann't use local memory to keep it */
|
|
plsfrun->cwchRun = 1;
|
|
plschp->fHyphen = kysrNil;
|
|
|
|
*pfYsrChangeAfter = fTrue;
|
|
}
|
|
else
|
|
{
|
|
if (!plsc->fDontReleaseRuns)
|
|
{
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, plsfrun->plsrun);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, lsfrunPrev.plsrun, lserr);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* Release run from previous line */
|
|
if (!plsc->fDontReleaseRuns)
|
|
{
|
|
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, lsfrunPrev.plsrun);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, plsfrun->plsrun, lserr);
|
|
}
|
|
return lserrNone;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* F I L L T E X T P A R A M S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FillTextParamsTextParams
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cp, - (IN) cp to start fetch
|
|
duaCol - (IN) duaColumn
|
|
plspap - (IN) paragraph properties
|
|
fFirstLineInPara- (IN) flag fFirstLineInPara
|
|
fStopped - (IN) flag fStopped
|
|
plgeom - (OUT) set of flags and parameters about a line
|
|
|
|
|
|
LsCreateLine calls this function at the beginning of the line in order
|
|
to skip over vanished text, fetch an LSPAP, and invoke the text APIs
|
|
SetTextLineParams().
|
|
----------------------------------------------------------------------------*/
|
|
|
|
static LSERR FillTextParams(PLSC plsc, LSCP cp, long duaCol, PLSPAP plspap,
|
|
BOOL fFirstLineInPara, BOOL fStopped, LINEGEOMETRY* plgeom)
|
|
{
|
|
LSERR lserr;
|
|
TLPR tlpr;
|
|
DWORD iobjText;
|
|
PILSOBJ pilsobjText;
|
|
PLNOBJ plnobjText;
|
|
long uaLeft;
|
|
PLSLINE plsline = plsc->plslineCur;
|
|
long duaColumnMaxBreak;
|
|
long duaColumnMaxJustify;
|
|
long urLeft;
|
|
|
|
/* Copy information from lspap to context current line and local for LsCreateLine structure lgeom */
|
|
|
|
uaLeft = plspap->uaLeft;
|
|
if (fFirstLineInPara)
|
|
uaLeft += plspap->duaIndent;
|
|
urLeft = UrFromUa(LstflowFromSubline(GetMainSubline(plsc)),
|
|
&plsc->lsdocinf.lsdevres, uaLeft);
|
|
|
|
|
|
/* line */
|
|
plsline->lslinfo.fFirstLineInPara = fFirstLineInPara;
|
|
plsline->lslinfo.cpFirstVis = cp;
|
|
plsline->lssubl.lstflow = plspap->lstflow;
|
|
|
|
if (duaCol != uLsInfiniteRM && plspap->uaRightBreak < uLsInfiniteRM
|
|
&& plspap->uaRightJustify < uLsInfiniteRM)
|
|
{
|
|
duaColumnMaxBreak = duaCol - plspap->uaRightBreak;
|
|
duaColumnMaxJustify = duaCol - plspap->uaRightJustify;
|
|
}
|
|
else{
|
|
if (duaCol == uLsInfiniteRM)
|
|
{
|
|
duaColumnMaxBreak = uLsInfiniteRM;
|
|
duaColumnMaxJustify = uLsInfiniteRM;
|
|
}
|
|
else
|
|
{
|
|
if (plspap->uaRightBreak >= uLsInfiniteRM)
|
|
duaColumnMaxBreak = uLsInfiniteRM;
|
|
else
|
|
duaColumnMaxBreak = duaCol - plspap->uaRightBreak;
|
|
if (plspap->uaRightJustify >= uLsInfiniteRM)
|
|
duaColumnMaxJustify = uLsInfiniteRM;
|
|
else
|
|
duaColumnMaxJustify = duaCol - plspap->uaRightJustify;
|
|
}
|
|
}
|
|
|
|
|
|
/* fill in context for adjustment */
|
|
SetLineLineContainsAutoNumber(plsc, (plspap->grpf & fFmiAnm) && fFirstLineInPara);
|
|
SetUnderlineTrailSpacesRM(plsc, plspap->grpf & fFmiUnderlineTrailSpacesRM);
|
|
SetForgetLastTabAlignment(plsc, plspap->grpf & fFmiForgetLastTabAlignment);
|
|
plsc->lsadjustcontext.lskj = plspap->lskj;
|
|
plsc->lsadjustcontext.lskalign = plspap->lskal;
|
|
plsc->lsadjustcontext.lsbrj = plspap->lsbrj;
|
|
plsc->lsadjustcontext.urLeftIndent = urLeft;
|
|
plsc->lsadjustcontext.urStartAutonumberingText =0;
|
|
plsc->lsadjustcontext.urStartMainText = urLeft; /* autonumber can change it later */
|
|
if (duaColumnMaxJustify != uLsInfiniteRM)
|
|
{
|
|
plsc->lsadjustcontext.urRightMarginJustify = UrFromUa(
|
|
LstflowFromSubline(GetMainSubline(plsc)),
|
|
&(plsc->lsdocinf.lsdevres), duaColumnMaxJustify);
|
|
}
|
|
else
|
|
{
|
|
plsc->lsadjustcontext.urRightMarginJustify = uLsInfiniteRM;
|
|
}
|
|
if (duaColumnMaxBreak != uLsInfiniteRM)
|
|
{
|
|
plsc->urRightMarginBreak = UrFromUa(LstflowFromSubline(GetMainSubline(plsc)),
|
|
&(plsc->lsdocinf.lsdevres), duaColumnMaxBreak);
|
|
}
|
|
else
|
|
{
|
|
plsc->urRightMarginBreak = uLsInfiniteRM;
|
|
}
|
|
plsc->fIgnoreSplatBreak = plspap->grpf & fFmiIgnoreSplatBreak;
|
|
plsc->grpfManager = plspap->grpf;
|
|
plsc->fLimSplat = plspap->grpf & fFmiLimSplat;
|
|
plsc->urHangingTab = UrFromUa(LstflowFromSubline(GetMainSubline(plsc)),
|
|
&(plsc->lsdocinf.lsdevres), plspap->uaLeft);
|
|
|
|
/* snap grid */
|
|
if (plspap->lskj == lskjSnapGrid)
|
|
{
|
|
if (duaCol != uLsInfiniteRM)
|
|
{
|
|
plsc->lsgridcontext.urColumn = UrFromUa(
|
|
LstflowFromSubline(GetMainSubline(plsc)),
|
|
&(plsc->lsdocinf.lsdevres), duaCol);
|
|
}
|
|
else
|
|
{
|
|
plsc->lsgridcontext.urColumn = uLsInfiniteRM;
|
|
}
|
|
}
|
|
|
|
/* lgeom */
|
|
plgeom->cpFirstVis = cp;
|
|
plgeom->urLeft = urLeft;
|
|
plgeom->fAutonumber = (plspap->grpf & fFmiAnm) && fFirstLineInPara;
|
|
if (plspap->grpf & fFmiAutoDecimalTab)
|
|
{
|
|
plgeom->fAutoDecimalTab = fTrue;
|
|
plgeom->durAutoDecimalTab = UrFromUa(LstflowFromSubline(GetMainSubline(plsc)),
|
|
&(plsc->lsdocinf.lsdevres), plspap->duaAutoDecimalTab);
|
|
}
|
|
else
|
|
{
|
|
plgeom->fAutoDecimalTab = fFalse;
|
|
plgeom->durAutoDecimalTab = LONG_MIN;
|
|
}
|
|
plgeom->fStopped = fStopped;
|
|
|
|
|
|
/* prepare tlpr for text */
|
|
|
|
tlpr.grpfText = (plspap->grpf & grpfTextMask);
|
|
tlpr.fSnapGrid = (plspap->lskj == lskjSnapGrid);
|
|
tlpr.duaHyphenationZone = plspap->duaHyphenationZone;
|
|
tlpr.lskeop = plspap->lskeop;
|
|
|
|
|
|
/* we know that here is the first place we need plnobjText and we are creating it */
|
|
iobjText = IobjTextFromLsc(&(plsc->lsiobjcontext));
|
|
Assert( PlnobjFromLsline(plsline,iobjText) == NULL);
|
|
pilsobjText = PilsobjFromLsc(&(plsc->lsiobjcontext), iobjText);
|
|
lserr = CreateLNObjText(pilsobjText, &(plsline->rgplnobj[iobjText]));
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
plnobjText = PlnobjFromLsline(plsline, iobjText);
|
|
|
|
lserr = SetTextLineParams(plnobjText, &tlpr);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
/* F E T C H U N T I L V I S I B L E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FetchUntilVisible
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
plspap - (IN/OUT) current lspap before and after
|
|
pcp - (IN/OUT) current cp before and after
|
|
plsfrun - (IN/OUT) current lsfrun before and after
|
|
plschp - (IN/OUT) current lschp before and after
|
|
pfStopped - (OUT) fStopped: procedure stopped fetching because has not been allowed
|
|
to go across paragraph boundaries (result CheckPara Boundaries)
|
|
pfNewPara - (OUT) fNewPara: procedure crossed paragraph boundaries
|
|
|
|
Releases the supplied PLSRUN, if any, and fetches runs, starting at
|
|
the supplied cp, until a non-vanished run is fetched. As paragraph
|
|
boundaries are crossed, the LSPAP is updated.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR FetchUntilVisible(PLSC plsc, LSPAP* plspap, LSCP* pcp,
|
|
LSFRUN* plsfrun, PLSCHP plschp,
|
|
BOOL* pfStopped, BOOL* pfNewPara)
|
|
{
|
|
LSERR lserr;
|
|
LSCP dcpPrevRun = plsfrun->cwchRun;
|
|
BOOL fHidden;
|
|
*pfStopped = fFalse;
|
|
*pfNewPara = fFalse;
|
|
|
|
/* we assume here that this finction is called only after hidden run has been fetched
|
|
and such run is passed as an input parameter */
|
|
|
|
do
|
|
{
|
|
const PLSRUN plsrunT = plsfrun->plsrun;
|
|
|
|
|
|
*pcp += dcpPrevRun;
|
|
lserr = plsc->lscbk.pfnCheckParaBoundaries(plsc->pols, *pcp - dcpPrevRun, *pcp, pfStopped);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, plsrunT, lserr);
|
|
if (*pfStopped)
|
|
return lserrNone;
|
|
|
|
lserr = plsc->lscbk.pfnFetchPap(plsc->pols, *pcp, plspap);
|
|
if (lserr != lserrNone)
|
|
return ErrReleasePreFetchedRun(plsc, plsrunT, lserr);
|
|
if (FPapInconsistent(plspap))
|
|
return ErrReleasePreFetchedRun(plsc, plsrunT, lserrInvalidPap);
|
|
|
|
if ((*pcp - dcpPrevRun) < plspap->cpFirst)
|
|
*pfNewPara = fTrue;
|
|
|
|
|
|
plsfrun->plsrun = NULL;
|
|
if (plsrunT != NULL && !plsc->fDontReleaseRuns)
|
|
{
|
|
lserr = plsc->lscbk.pfnReleaseRun(plsc->pols, plsrunT);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
}
|
|
|
|
|
|
lserr = plsc->lscbk.pfnFetchRun(plsc->pols, *pcp,
|
|
&plsfrun->lpwchRun,
|
|
&plsfrun->cwchRun,
|
|
&fHidden,
|
|
plschp,
|
|
&plsfrun->plsrun);
|
|
if (lserr != lserrNone)
|
|
return lserr;
|
|
|
|
dcpPrevRun = plsfrun->cwchRun;
|
|
}
|
|
while (fHidden);
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* I N I T C U R L I N E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: InitCurLine
|
|
%%Contact: igorzv
|
|
|
|
Parameters:
|
|
plsc - (IN) ptr to line services context
|
|
cpFirst - (IN) starting cp for a line
|
|
|
|
Set default value in lsline
|
|
----------------------------------------------------------------------------*/
|
|
|
|
static LSERR InitCurLine(PLSC plsc, LSCP cpFirst)
|
|
{
|
|
PLSLINE plsline = plsc->plslineCur;
|
|
|
|
memset(plsline, 0, cbRep(struct lsline, rgplnobj, plsc->lsiobjcontext.iobjMac));
|
|
plsline->tag = tagLSLINE;
|
|
plsline->lssubl.tag = tagLSSUBL;
|
|
plsline->lssubl.plsc = plsc;
|
|
plsline->lssubl.cpFirst = cpFirst;
|
|
|
|
/* reuse quick heap for dnodes if it possible */
|
|
if (plsc->pqhAllDNodesRecycled != NULL)
|
|
{
|
|
plsline->pqhAllDNodes = plsc->pqhAllDNodesRecycled;
|
|
plsc->pqhAllDNodesRecycled = NULL;
|
|
}
|
|
else
|
|
{
|
|
plsline->pqhAllDNodes = CreateQuickHeap(plsc, limAllDNodes,
|
|
sizeof (struct lsdnode), fTrue);
|
|
if (plsline->pqhAllDNodes == NULL )
|
|
return lserrOutOfMemory;
|
|
|
|
}
|
|
|
|
plsline->lssubl.fDupInvalid = fTrue;
|
|
plsline->lssubl.fContiguous = fTrue;
|
|
plsline->lssubl.plschunkcontext = &(plsc->lschunkcontextStorage);
|
|
plsline->lssubl.fMain = fTrue;
|
|
TurnOnAllSimpleText(plsc);
|
|
plsline->lslinfo.nDepthFormatLineMax = 1;
|
|
TurnOffLineCompressed(plsc);
|
|
TurnOffNominalToIdealEncounted(plsc);
|
|
TurnOffForeignObjectEncounted(plsc);
|
|
TurnOffTabEncounted(plsc);
|
|
TurnOffNonLeftTabEncounted(plsc);
|
|
TurnOffSubmittedSublineEncounted(plsc);
|
|
TurnOffAutodecimalTabPresent(plsc);
|
|
plsc->fHyphenated = fFalse;
|
|
plsc->fAdvanceBack = fFalse;
|
|
|
|
|
|
/* we use memset to set default value, below we check that after memset we really have
|
|
correct defaults */
|
|
Assert(plsline->lssubl.plsdnFirst == NULL);
|
|
Assert(plsline->lssubl.urColumnMax == 0);
|
|
Assert(plsline->lssubl.cpLim == 0);
|
|
Assert(plsline->lssubl.plsdnLast == NULL);
|
|
Assert(plsline->lssubl.urCur == 0);
|
|
Assert(plsline->lssubl.vrCur == 0);
|
|
Assert(plsline->lssubl.fAcceptedForDisplay == fFalse);
|
|
Assert(plsline->lssubl.fRightMarginExceeded == fFalse);
|
|
Assert(plsline->lssubl.plsdnUpTemp == NULL);
|
|
Assert(plsline->lssubl.pbrkcontext == NULL);
|
|
|
|
Assert(plsline->lslinfo.dvpAscent == 0); /* lslinfo */
|
|
Assert(plsline->lslinfo.dvrAscent == 0);
|
|
Assert(plsline->lslinfo.dvpDescent == 0);
|
|
Assert(plsline->lslinfo.dvrDescent == 0);
|
|
Assert(plsline->lslinfo.dvpMultiLineHeight == 0);
|
|
Assert(plsline->lslinfo.dvrMultiLineHeight == 0);
|
|
Assert(plsline->lslinfo.dvpAscentAutoNumber == 0);
|
|
Assert(plsline->lslinfo.dvrAscentAutoNumber == 0);
|
|
Assert(plsline->lslinfo.dvpDescentAutoNumber == 0);
|
|
Assert(plsline->lslinfo.dvrDescentAutoNumber == 0);
|
|
Assert(plsline->lslinfo.cpLim == 0);
|
|
Assert(plsline->lslinfo.dcpDepend == 0);
|
|
Assert(plsline->lslinfo.cpFirstVis == 0);
|
|
Assert(plsline->lslinfo.endr == endrNormal);
|
|
Assert(plsline->lslinfo.fAdvanced == fFalse);
|
|
Assert(plsline->lslinfo.vaAdvance == 0);
|
|
Assert(plsline->lslinfo.fFirstLineInPara == fFalse);
|
|
Assert(plsline->lslinfo.EffectsFlags == 0);
|
|
Assert(plsline->lslinfo.fTabInMarginExLine == fFalse);
|
|
Assert(plsline->lslinfo.fForcedBreak == fFalse);
|
|
|
|
Assert(plsline->upStartAutonumberingText == 0);
|
|
Assert(plsline->upLimAutonumberingText == 0);
|
|
Assert(plsline->upStartMainText == 0);
|
|
Assert(plsline->upLimLine == 0);
|
|
Assert(plsline->dvpAbove == 0);
|
|
Assert(plsline->dvpBelow == 0);
|
|
Assert(plsline->upRightMarginJustify == 0);
|
|
Assert(plsline->upLimUnderline == 0);
|
|
Assert(plsline->kspl == ksplNone);
|
|
Assert(!plsline->fCollectVisual);
|
|
Assert(!plsline->fNonRealDnodeEncounted);
|
|
Assert(!plsline->fNonZeroDvpPosEncounted);
|
|
Assert(plsline->AggregatedDisplayFlags == 0);
|
|
Assert(plsline->pad == 0);
|
|
|
|
#ifdef DEBUG
|
|
{
|
|
DWORD i;
|
|
for (i=0; i < plsc->lsiobjcontext.iobjMac; i++)
|
|
{
|
|
Assert(plsline->rgplnobj[i] == NULL);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
/* C A N N O T C R E A T E L I N E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CannotCreateLine
|
|
%%Contact: igorzv
|
|
Parameters:
|
|
pplsline - (IN) ponter to a line structure to be deleted
|
|
lserr - (IN) code of an error
|
|
|
|
Called when LsCreateLine needs to return for an error condition.
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR CannotCreateLine(PLSLINE* pplsline, LSERR lserr)
|
|
{
|
|
LSERR lserrIgnore;
|
|
PLSLINE plsline = *pplsline;
|
|
PLSC plsc = plsline->lssubl.plsc;
|
|
|
|
plsc->plslineCur = NULL;
|
|
plsc->lsstate = LsStateFree; /* we need free context to destroy line */
|
|
|
|
lserrIgnore = LsDestroyLine(plsc, plsline);
|
|
|
|
*pplsline = NULL;
|
|
return lserr;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
/* E R R R E L E A S E P R E F E T C H E D R U N */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: ErrReleasePreFetchedRun
|
|
%%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 fist run of main text has been prefetched .
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR ErrReleasePreFetchedRun(PLSC plsc, PLSRUN plsrun, LSERR lserr)
|
|
{
|
|
LSERR lserrIgnore;
|
|
|
|
if (!plsc->fDontReleaseRuns)
|
|
lserrIgnore = plsc->lscbk.pfnReleaseRun(plsc->pols, plsrun);
|
|
|
|
return lserr;
|
|
}
|
|
|
|
|
|
/* R E M O V E L I N E O B J E C T S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: RemoveLineObjects
|
|
%%Contact: igorzv
|
|
Parameter:
|
|
plsc - (IN) ponter to a line structure
|
|
|
|
Removes a line context of installed objects from an line.
|
|
----------------------------------------------------------------------------*/
|
|
LSERR RemoveLineObjects(PLSLINE plsline)
|
|
{
|
|
DWORD iobjMac;
|
|
PLSC plsc;
|
|
LSERR lserr, lserrFinal = lserrNone;
|
|
DWORD iobj;
|
|
PLNOBJ plnobj;
|
|
|
|
Assert(FIsLSLINE(plsline));
|
|
|
|
plsc = plsline->lssubl.plsc;
|
|
Assert(FIsLSC(plsc));
|
|
Assert(plsc->lsstate == LsStateDestroyingLine);
|
|
|
|
iobjMac = plsc->lsiobjcontext.iobjMac;
|
|
|
|
for (iobj = 0; iobj < iobjMac; iobj++)
|
|
{
|
|
plnobj = plsline->rgplnobj[iobj];
|
|
if (plnobj != NULL)
|
|
{
|
|
lserr = plsc->lsiobjcontext.rgobj[iobj].lsim.pfnDestroyLNObj(plnobj);
|
|
plsline->rgplnobj[iobj] = NULL;
|
|
if (lserr != lserrNone)
|
|
lserrFinal = lserr;
|
|
}
|
|
}
|
|
|
|
return lserrFinal;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
/* F R O U N D I N G O K */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FRoundingOK
|
|
%%Contact: lenoxb
|
|
|
|
Checks for correctness of rounding algorithm in converting absolute to
|
|
device units, to agree with Word 6.0.
|
|
|
|
Checks that:
|
|
0.5 rounds up to 1.0,
|
|
1.4 rounds down to 1.4,
|
|
-0.5 rounds down to -1.0, and
|
|
-1.4 rounds up to -1.0.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
static BOOL FRoundingOK(void)
|
|
{
|
|
LSDEVRES devresT;
|
|
|
|
Assert((czaUnitInch % 10) == 0);
|
|
|
|
devresT.dxpInch = czaUnitInch / 10;
|
|
|
|
if (UpFromUa(lstflowDefault, &devresT, 5) != 1)
|
|
return fFalse;
|
|
if (UpFromUa(lstflowDefault, &devresT, 14) != 1)
|
|
return fFalse;
|
|
if (UpFromUa(lstflowDefault, &devresT, -5) != -1)
|
|
return fFalse;
|
|
if (UpFromUa(lstflowDefault, &devresT, -14) != -1)
|
|
return fFalse;
|
|
|
|
return fTrue;
|
|
}
|
|
#endif /* DEBUG */
|
|
|