able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/richedit/lssrc/lscrline.c

1940 lines
58 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#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 */
Reference in a new issue Copy permalink