685 lines
20 KiB
C
685 lines
20 KiB
C
#include "lsmem.h"
|
|
#include <limits.h>
|
|
|
|
#include "lsstring.h"
|
|
#include "txtils.h"
|
|
#include "txtln.h"
|
|
#include "txtobj.h"
|
|
|
|
/* Internal Functions prototypes */
|
|
static LSERR CheckReallocCharArrays(PLNOBJ plnobj, long cwch, long iwchLocalStart, long *cwchCorrect);
|
|
static LSERR CheckReallocSpacesArrays(PILSOBJ pobj, long cwSpaces);
|
|
static LSERR CopyCharsSpacesToDispList(PLNOBJ plnobj, WCHAR* rgwch, long cwch,
|
|
long* rgwSpaces, long cwSpaces);
|
|
static LSERR CopySpacesToDispList(PLNOBJ plnobj, long iNumOfSpaces, long durSpace);
|
|
|
|
/* Export Functions implementations */
|
|
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: GetWidth
|
|
%%Contact: sergeyge
|
|
|
|
Fetches widths until end of run or right margin
|
|
|
|
Uses cache to improve performance
|
|
----------------------------------------------------------------------------*/
|
|
LSERR GetWidths(PLNOBJ plnobj, PLSRUN plsrun, long iwchStart, LPWSTR lpwch, LSCP cpFirst, long dcp, long durWidthExceed,
|
|
LSTFLOW lstflow, long* pcwchFetched, long* pdurWidth)
|
|
{
|
|
LSERR lserr;
|
|
PILSOBJ pilsobj;
|
|
long durWidth;
|
|
long cwch;
|
|
long iwchDur;
|
|
long cwchCorrect;
|
|
long cwchIter;
|
|
long durWidthIter;
|
|
BOOL fNothingReturned = fTrue;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
|
|
durWidth = 0;
|
|
cwch = 0;
|
|
iwchDur = iwchStart;
|
|
*pcwchFetched = 0;
|
|
*pdurWidth = 0;
|
|
|
|
if (pilsobj->dcpFetchedWidth != 0 && cpFirst == pilsobj->cpFirstFetchedWidth &&
|
|
iwchStart == pilsobj->iwchFetchedWidth && lpwch[0] == pilsobj->wchFetchedWidthFirst)
|
|
{
|
|
Assert(dcp >= pilsobj->dcpFetchedWidth);
|
|
cwch = pilsobj->dcpFetchedWidth;
|
|
durWidth = pilsobj->durFetchedWidth;
|
|
/* FormatRegular assumes that First character exceeding right margin will stop GetCharWidth loop;
|
|
Special character could change situation---fix it.
|
|
*/
|
|
if (durWidth > durWidthExceed)
|
|
{
|
|
while(cwch > 1 && durWidth - durWidthExceed > pilsobj->pdur[iwchStart + cwch - 1])
|
|
{
|
|
cwch--;
|
|
durWidth -= pilsobj->pdur[iwchStart + cwch];
|
|
}
|
|
}
|
|
dcp -= cwch;
|
|
durWidthExceed -= durWidth;
|
|
iwchDur += cwch;
|
|
fNothingReturned = fFalse;
|
|
}
|
|
|
|
while (fNothingReturned || dcp > 0 && durWidthExceed >= 0)
|
|
{
|
|
lserr = CheckReallocCharArrays(plnobj, dcp, iwchDur, &cwchCorrect);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
lserr = (*pilsobj->plscbk->pfnGetRunCharWidths)(pilsobj->pols, plsrun, lsdevReference,
|
|
&lpwch[cwch], cwchCorrect, (int)durWidthExceed,
|
|
lstflow, (int*)&pilsobj->pdur[iwchDur], &durWidthIter, &cwchIter);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
Assert(durWidthIter >= 0);
|
|
Assert(durWidthIter <= uLsInfiniteRM);
|
|
|
|
Assert (durWidthIter <= uLsInfiniteRM - durWidth);
|
|
|
|
if (durWidthIter > uLsInfiniteRM - durWidth)
|
|
return lserrTooLongParagraph;
|
|
|
|
durWidth += durWidthIter;
|
|
|
|
durWidthExceed -= durWidthIter;
|
|
iwchDur += cwchIter;
|
|
cwch += cwchIter;
|
|
dcp -= cwchIter;
|
|
fNothingReturned = fFalse;
|
|
}
|
|
|
|
|
|
*pcwchFetched = cwch;
|
|
*pdurWidth = durWidth;
|
|
|
|
pilsobj->iwchFetchedWidth = iwchStart;
|
|
pilsobj->cpFirstFetchedWidth = cpFirst;
|
|
pilsobj->dcpFetchedWidth = cwch;
|
|
pilsobj->durFetchedWidth = durWidth;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/* F O R M A T S T R I N G */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FormatString
|
|
%%Contact: sergeyge
|
|
|
|
Formats the local run
|
|
----------------------------------------------------------------------------*/
|
|
LSERR FormatString(PLNOBJ plnobj, PTXTOBJ pdobjText, WCHAR* rgwch, long cwch,
|
|
long* rgwSpaces, long cwSpaces, long durWidth)
|
|
{
|
|
LSERR lserr;
|
|
PILSOBJ pilsobj;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
|
|
lserr = CopyCharsSpacesToDispList(plnobj, rgwch, cwch, rgwSpaces, cwSpaces);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
/* fill out all related members from strils and output parameters */
|
|
pdobjText->iwchLim = pdobjText->iwchLim + cwch;
|
|
pdobjText->u.reg.iwSpacesLim = pdobjText->u.reg.iwSpacesLim + cwSpaces;
|
|
|
|
/* Fix Width Fetching state */
|
|
Assert((long)pilsobj->dcpFetchedWidth >= cwch);
|
|
Assert(pilsobj->durFetchedWidth >= durWidth);
|
|
|
|
pilsobj->iwchFetchedWidth = pilsobj->iwchFetchedWidth + cwch;
|
|
pilsobj->cpFirstFetchedWidth += cwch;
|
|
pilsobj->dcpFetchedWidth -= cwch;
|
|
pilsobj->durFetchedWidth -= durWidth;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* F I L L R E G U L A R P R E S W I D T H S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: MeasureStringFirst
|
|
%%Contact: sergeyge
|
|
|
|
Calculates dur of one character.
|
|
----------------------------------------------------------------------------*/
|
|
LSERR FillRegularPresWidths(PLNOBJ plnobj, PLSRUN plsrun, LSTFLOW lstflow, PTXTOBJ pdobjText)
|
|
{
|
|
LSERR lserr;
|
|
PILSOBJ pilsobj;
|
|
int* rgDup;
|
|
long dupJunk;
|
|
long limDupJunk;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
|
|
if (pilsobj->fDisplay)
|
|
{
|
|
rgDup = (int *)&plnobj->pdup[pdobjText->iwchFirst];
|
|
|
|
if (!pilsobj->fPresEqualRef)
|
|
{
|
|
lserr = (*pilsobj->plscbk->pfnGetRunCharWidths)(pilsobj->pols, plsrun, lsdevPres,
|
|
&pilsobj->pwchOrig[pdobjText->iwchFirst], pdobjText->iwchLim - pdobjText->iwchFirst,
|
|
LONG_MAX, lstflow, rgDup, &dupJunk, &limDupJunk);
|
|
if (lserr != lserrNone) return lserr;
|
|
}
|
|
else /* fPresEqualRef */
|
|
{
|
|
memcpy(rgDup, &pilsobj->pdur[pdobjText->iwchFirst], sizeof(long) * (pdobjText->iwchLim - pdobjText->iwchFirst));
|
|
}
|
|
}
|
|
|
|
return lserrNone;
|
|
|
|
}
|
|
|
|
|
|
/* G E T O N E C H A R D U P */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: MeasureStringFirst
|
|
%%Contact: sergeyge
|
|
|
|
Calculates dur of one character.
|
|
----------------------------------------------------------------------------*/
|
|
LSERR GetOneCharDur(PILSOBJ pilsobj, PLSRUN plsrun, WCHAR wch, LSTFLOW lstflow, long* pdur)
|
|
{
|
|
LSERR lserr;
|
|
long durSumJunk;
|
|
long limDurJunk;
|
|
|
|
lserr = (*pilsobj->plscbk->pfnGetRunCharWidths)(pilsobj->pols, plsrun, lsdevReference, &wch, 1, LONG_MAX, lstflow,
|
|
(int*)pdur, &durSumJunk, &limDurJunk);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* G E T O N E C H A R D U P */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: GetOneCharDup
|
|
%%Contact: sergeyge
|
|
|
|
Calculates dup of one character
|
|
----------------------------------------------------------------------------*/
|
|
LSERR GetOneCharDup(PILSOBJ pilsobj, PLSRUN plsrun, WCHAR wch, LSTFLOW lstflow, long dur, long* pdup)
|
|
{
|
|
LSERR lserr;
|
|
long dupSumJunk;
|
|
long limDupJunk;
|
|
|
|
*pdup = 0;
|
|
if (pilsobj->fDisplay)
|
|
{
|
|
if (!pilsobj->fPresEqualRef)
|
|
{
|
|
lserr = (*pilsobj->plscbk->pfnGetRunCharWidths)(pilsobj->pols, plsrun, lsdevPres, &wch, 1,
|
|
LONG_MAX, lstflow, (int*)pdup, &dupSumJunk, &limDupJunk);
|
|
if (lserr != lserrNone) return lserr;
|
|
}
|
|
else
|
|
{
|
|
*pdup = dur;
|
|
}
|
|
}
|
|
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* G E T V I S I D U P */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: GetVisiDup
|
|
%%Contact: sergeyge
|
|
|
|
Calculates dup of visi character character
|
|
----------------------------------------------------------------------------*/
|
|
LSERR GetVisiCharDup(PILSOBJ pilsobj, PLSRUN plsrun, WCHAR wch, LSTFLOW lstflow, long* pdup)
|
|
{
|
|
LSERR lserr;
|
|
long dupSumJunk;
|
|
long limDupJunk;
|
|
|
|
*pdup = 0;
|
|
if (pilsobj->fDisplay)
|
|
{
|
|
lserr = (*pilsobj->plscbk->pfnGetRunCharWidths)(pilsobj->pols, plsrun, lsdevPres, &wch, 1,
|
|
LONG_MAX, lstflow, (int*)pdup, &dupSumJunk, &limDupJunk);
|
|
if (lserr != lserrNone) return lserr;
|
|
}
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/* A D D C H A R A C T E R W I T H W I D T H */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: AddCharacterWithWidth
|
|
%%Contact: sergeyge
|
|
|
|
Writes character code and its width in wchOrig, wch, dup, dur arrays.
|
|
Stores character code (in the VISI situation it can be different from wch)
|
|
in pilsobj->wchPrev.
|
|
----------------------------------------------------------------------------*/
|
|
LSERR AddCharacterWithWidth(PLNOBJ plnobj, PTXTOBJ pdobjText, WCHAR wchOrig, long durWidth, WCHAR wch, long dupWidth)
|
|
{
|
|
LSERR lserr;
|
|
PILSOBJ pilsobj;
|
|
long iwchLocalStart;
|
|
long cjunk;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
|
|
iwchLocalStart = pilsobj->wchMac;
|
|
|
|
lserr = CheckReallocCharArrays(plnobj, 1, iwchLocalStart, &cjunk);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
|
|
/* Fix cached width information before width in the pdur array is overwritten by durWidth.
|
|
Theoretically durWidth can be different from the cached value */
|
|
|
|
if (pilsobj->dcpFetchedWidth > 0)
|
|
{
|
|
pilsobj->iwchFetchedWidth ++;
|
|
pilsobj->cpFirstFetchedWidth ++;
|
|
pilsobj->dcpFetchedWidth --;
|
|
pilsobj->durFetchedWidth -= pilsobj->pdur[iwchLocalStart];
|
|
}
|
|
|
|
|
|
pilsobj->pwchOrig[iwchLocalStart] = wchOrig;
|
|
pilsobj->pdur[iwchLocalStart] = durWidth;
|
|
|
|
if (pilsobj->fDisplay)
|
|
{
|
|
plnobj->pwch[iwchLocalStart] = wch;
|
|
plnobj->pdup[iwchLocalStart] = dupWidth;
|
|
}
|
|
|
|
pilsobj->wchMac++;
|
|
|
|
pdobjText->iwchLim++;
|
|
|
|
Assert(pilsobj->wchMac == pdobjText->iwchLim);
|
|
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* F I X S P A C E S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FixSpaces
|
|
%%Contact: sergeyge
|
|
|
|
Fixes space character code for the Visi Spaces situation
|
|
----------------------------------------------------------------------------*/
|
|
void FixSpaces(PLNOBJ plnobj, PTXTOBJ pdobjText, WCHAR wch)
|
|
{
|
|
PILSOBJ pilsobj;
|
|
long i;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
|
|
if (pilsobj->fDisplay)
|
|
{
|
|
for (i = pdobjText->u.reg.iwSpacesFirst; i < pdobjText->u.reg.iwSpacesLim; i++)
|
|
{
|
|
plnobj->pwch[pilsobj->pwSpaces[i]] = wch;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* A D D S P A C E S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: AddTrailingSpaces
|
|
%%Contact: sergeyge
|
|
|
|
Adds trailing/bordered spaces to the disp list
|
|
----------------------------------------------------------------------------*/
|
|
LSERR AddSpaces(PLNOBJ plnobj, PTXTOBJ pdobjText, long durSpace, long iNumOfSpaces)
|
|
{
|
|
LSERR lserr;
|
|
|
|
lserr = CopySpacesToDispList(plnobj, iNumOfSpaces, durSpace);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
pdobjText->iwchLim = pdobjText->iwchLim + iNumOfSpaces;
|
|
pdobjText->u.reg.iwSpacesLim = pdobjText->u.reg.iwSpacesLim + iNumOfSpaces;
|
|
|
|
/* Fix Fetched Widths part. For non-bordered case, this procedure is activated for
|
|
trailing spaces only, so this state should also be filled with 0s, but
|
|
for bordered case it must be flushed
|
|
*/
|
|
FlushStringState(plnobj->pilsobj);
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* I N C R E A S E W C H M A C B Y @ */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: IncreaseWchMacBy2
|
|
%%Contact: sergeyge
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR IncreaseWchMacBy2(PLNOBJ plnobj)
|
|
{
|
|
LSERR lserr;
|
|
long cwch;
|
|
|
|
lserr = CheckReallocCharArrays(plnobj, 2, plnobj->pilsobj->wchMac, &cwch);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
Assert(cwch <= 2 && cwch > 0);
|
|
|
|
if (cwch == 1)
|
|
{
|
|
lserr = CheckReallocCharArrays(plnobj, 1, plnobj->pilsobj->wchMac + 1, &cwch);
|
|
if (lserr != lserrNone) return lserr;
|
|
Assert(cwch == 1);
|
|
}
|
|
|
|
plnobj->pilsobj->wchMac += 2;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* Internal Functions Implementation */
|
|
|
|
|
|
/* C H E C K R E A L L O C C H A R A R R A Y S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: ReallocCharArrays
|
|
%%Contact: sergeyge
|
|
|
|
Reallocates character based arrays, increasing them by delta
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR CheckReallocCharArrays(PLNOBJ plnobj, long cwch, long iwchLocalStart, long *cwchCorrect)
|
|
{
|
|
PILSOBJ pilsobj;
|
|
WCHAR* pwch;
|
|
long* pdup;
|
|
long* pdur;
|
|
GMAP* pgmap;
|
|
TXTINF* ptxtinf;
|
|
long delta;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
|
|
/* pdupPen was made equal to pdup at the CreateLnObj time;
|
|
it can be changed to pdupPenAlloc at Adjust time only */
|
|
Assert(plnobj->pdup == plnobj->pdupPen);
|
|
|
|
/* Constant 2 is not random. We need to have 2 extra places for characters
|
|
for breaking with AutoHyphen and YSR which adds one charcter and hyphen.
|
|
*/
|
|
if (iwchLocalStart + cwch <= (long)pilsobj->wchMax - 2)
|
|
{
|
|
*cwchCorrect = cwch;
|
|
}
|
|
else if (iwchLocalStart < (long)pilsobj->wchMax - 2)
|
|
{
|
|
*cwchCorrect = pilsobj->wchMax - 2 - iwchLocalStart;
|
|
}
|
|
else
|
|
{
|
|
Assert (iwchLocalStart == (long)pilsobj->wchMax - 2);
|
|
|
|
delta = wchAddM;
|
|
|
|
pwch = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, pilsobj->pwchOrig, (pilsobj->wchMax + delta) * sizeof(WCHAR) );
|
|
if (pwch == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
pilsobj->pwchOrig = pwch;
|
|
|
|
pwch = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, plnobj->pwch, (pilsobj->wchMax + delta) * sizeof(WCHAR) );
|
|
if (pwch == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
plnobj->pwch = pwch;
|
|
|
|
pdur = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, pilsobj->pdur, (pilsobj->wchMax + delta) * sizeof(long) );
|
|
if (pdur == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
pilsobj->pdur = pdur;
|
|
|
|
pdup = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, plnobj->pdup, (pilsobj->wchMax + delta) * sizeof(long) );
|
|
if (pdup == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
plnobj->pdup = pdup;
|
|
|
|
if (plnobj->pdupPenAlloc != NULL)
|
|
{
|
|
pdup = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, plnobj->pdupPenAlloc, (pilsobj->wchMax + delta) * sizeof(long) );
|
|
if (pdup == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
plnobj->pdupPenAlloc = pdup;
|
|
}
|
|
|
|
if (plnobj->pgmap != NULL)
|
|
{
|
|
pgmap = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, plnobj->pgmap, (pilsobj->wchMax + delta) * sizeof(GMAP) );
|
|
if (pgmap == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
plnobj->pgmap = pgmap;
|
|
}
|
|
|
|
if (pilsobj->pdurLeft != NULL)
|
|
{
|
|
pdur = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, pilsobj->pdurLeft, (pilsobj->wchMax + delta) * sizeof(long) );
|
|
if (pdur == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
pilsobj->pdurLeft = pdur;
|
|
memset(&pilsobj->pdurLeft[pilsobj->wchMax], 0, sizeof(long) * delta );
|
|
}
|
|
|
|
if (pilsobj->pdurRight != NULL)
|
|
{
|
|
pdur = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, pilsobj->pdurRight, (pilsobj->wchMax + delta) * sizeof(long) );
|
|
if (pdur == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
pilsobj->pdurRight = pdur;
|
|
memset(&pilsobj->pdurRight[pilsobj->wchMax], 0, sizeof(long) * delta);
|
|
}
|
|
|
|
if (pilsobj->pduAdjust != NULL)
|
|
{
|
|
pdur = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, pilsobj->pduAdjust, (pilsobj->wchMax + delta) * sizeof(long) );
|
|
if (pdur == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
pilsobj->pduAdjust = pdur;
|
|
}
|
|
|
|
if (pilsobj->ptxtinf != NULL)
|
|
{
|
|
ptxtinf = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, pilsobj->ptxtinf, (pilsobj->wchMax + delta) * sizeof(TXTINF) );
|
|
if (ptxtinf == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
pilsobj->ptxtinf = ptxtinf;
|
|
memset(&pilsobj->ptxtinf[pilsobj->wchMax], 0, sizeof(TXTINF) * delta);
|
|
}
|
|
|
|
pilsobj->wchMax += delta;
|
|
plnobj->wchMax = pilsobj->wchMax;
|
|
|
|
*cwchCorrect = delta;
|
|
if (cwch < delta)
|
|
*cwchCorrect = cwch;
|
|
}
|
|
|
|
/* see comment and Assert at the beginning of the file */
|
|
plnobj->pdupPen = plnobj->pdup;
|
|
|
|
return lserrNone;
|
|
|
|
}
|
|
|
|
|
|
/* C H E C K R E A L L O C S P A C E S A R R A Y S */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CheckReallocSpacesArrays
|
|
%%Contact: sergeyge
|
|
|
|
Checks that there is enough space wSpaces
|
|
to accomodate characters & spaces from the current local run.
|
|
Reallocates these arrays if it is needed.
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR CheckReallocSpacesArrays(PILSOBJ pilsobj, long cwSpaces)
|
|
{
|
|
long iwSpacesLocalStart;
|
|
long delta;
|
|
long* pwSpaces;
|
|
|
|
iwSpacesLocalStart = pilsobj->wSpacesMac;
|
|
|
|
/* check that there is enough space for spaces in pwSpaces */
|
|
if (iwSpacesLocalStart + cwSpaces > pilsobj->wSpacesMax)
|
|
{
|
|
delta = wchAddM;
|
|
if (delta < iwSpacesLocalStart + cwSpaces - pilsobj->wSpacesMax)
|
|
{
|
|
delta = iwSpacesLocalStart + cwSpaces - pilsobj->wSpacesMax;
|
|
}
|
|
pwSpaces = (*pilsobj->plscbk->pfnReallocPtr)(pilsobj->pols, pilsobj->pwSpaces, (pilsobj->wSpacesMax + delta) * sizeof(long) );
|
|
if (pwSpaces == NULL)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
pilsobj->pwSpaces = pwSpaces;
|
|
pilsobj->wSpacesMax += delta;
|
|
}
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* C O P Y C H A R S S P A C E S T O D I S P L I S T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CopyCharsSpacesToDispList
|
|
%%Contact: sergeyge
|
|
|
|
Fills wch, dur and wSpaces arrays
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR CopyCharsSpacesToDispList(PLNOBJ plnobj, WCHAR* rgwch, long cwch,
|
|
long* rgwSpaces, long cwSpaces)
|
|
{
|
|
LSERR lserr;
|
|
PILSOBJ pilsobj;
|
|
long iwchLocalStart;
|
|
long iwSpacesLocalStart;
|
|
long i;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
iwchLocalStart = pilsobj->wchMac;
|
|
iwSpacesLocalStart = pilsobj->wSpacesMac;
|
|
|
|
/* check that there is enough space for characters and their widths in pwch and pdup arrays */
|
|
lserr = CheckReallocSpacesArrays(pilsobj, cwSpaces);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
/* fill pwch array */
|
|
memcpy(&pilsobj->pwchOrig[iwchLocalStart], rgwch, sizeof(rgwch[0]) * cwch);
|
|
memcpy(&plnobj->pwch[iwchLocalStart], rgwch, sizeof(rgwch[0]) * cwch);
|
|
pilsobj->wchMac += cwch;
|
|
|
|
/* fill pwSpaces array, note that spaces with idexes greater than cwch should not be copied */
|
|
for (i=0; i < cwSpaces && rgwSpaces[i] < cwch; i++)
|
|
{
|
|
pilsobj->pwSpaces[iwSpacesLocalStart + i] = iwchLocalStart + rgwSpaces[i];
|
|
}
|
|
|
|
pilsobj->wSpacesMac += i;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/* C O P Y S P A C E S T O D I S P L I S T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: CopyTrailingSpacesToDispList
|
|
%%Contact: sergeyge
|
|
|
|
Fills wch, dur, dup, wSpaces arrays with the trailing spaces info
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR CopySpacesToDispList(PLNOBJ plnobj, long iNumOfSpaces, long durSpace)
|
|
{
|
|
LSERR lserr;
|
|
PILSOBJ pilsobj;
|
|
long iwchLocalStart;
|
|
long iwSpacesLocalStart;
|
|
long i;
|
|
long cwch;
|
|
long iwchStartCheck;
|
|
long cwchCorrect;
|
|
|
|
pilsobj = plnobj->pilsobj;
|
|
iwchLocalStart = pilsobj->wchMac;
|
|
iwSpacesLocalStart = pilsobj->wSpacesMac;
|
|
|
|
cwch = iNumOfSpaces;
|
|
iwchStartCheck = iwchLocalStart;
|
|
|
|
while (cwch > 0)
|
|
{
|
|
lserr = CheckReallocCharArrays(plnobj, cwch, iwchStartCheck, &cwchCorrect);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
iwchStartCheck += cwchCorrect;
|
|
cwch -= cwchCorrect;
|
|
}
|
|
|
|
lserr = CheckReallocSpacesArrays(pilsobj, iNumOfSpaces);
|
|
if (lserr != lserrNone) return lserr;
|
|
|
|
for (i=0; i < iNumOfSpaces; i++)
|
|
{
|
|
plnobj->pwch[iwchLocalStart + i] = pilsobj->wchSpace;
|
|
pilsobj->pwchOrig[iwchLocalStart + i] = pilsobj->wchSpace;
|
|
pilsobj->pdur[iwchLocalStart + i] = durSpace;
|
|
pilsobj->pwSpaces[iwSpacesLocalStart + i] = iwchLocalStart + i;
|
|
}
|
|
|
|
pilsobj->wchMac += iNumOfSpaces;
|
|
pilsobj->wSpacesMac += iNumOfSpaces;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
/* F L A S H S T R I N G S T A T E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FlashStringState
|
|
%%Contact: sergeyge
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void FlushStringState(PILSOBJ pilsobj)
|
|
{
|
|
pilsobj->iwchFetchedWidth = 0;
|
|
pilsobj->cpFirstFetchedWidth = 0;
|
|
pilsobj->dcpFetchedWidth = 0;
|
|
pilsobj->durFetchedWidth = 0;
|
|
}
|
|
|