#include "lsmem.h"						/* memset() */

#include "lsidefs.h"
#include "chnutils.h"
#include "iobj.h"
#include "dninfo.h"
#include "locchnk.h"
#include "posichnk.h"
#include "plschcon.h"
#include "lschcon.h"
#include "lscbk.h"
#include "limqmem.h"
#include "lstext.h"

#ifdef DEBUG
#define DebugMemset(a,b,c)		if ((a) != NULL) memset(a,b,c); else
#else
#define DebugMemset(a,b,c)		(void)(0)
#endif


static LSERR SetChunkArraysSize(PLSCHUNKCONTEXT, DWORD);
static LSERR IncreaseChunkArrays(PLSCHUNKCONTEXT);
static LSERR IncreaseGroupChunkNonTextArrays(PLSCHUNKCONTEXT plschunkcontext);
static LSERR ConvertChunkToGroupChunk(GRCHUNKEXT*, LSCP);
static void LocateChunk(PLSCHUNKCONTEXT plschnukcontext,/* IN: LS chunk context */
					     PLSDNODE plsdn,	 		    /* IN:  dnode to collect chunk arround  */
						 LSTFLOW  lstflow,				/* IN: text flow */
						 POINTUV* ppoint);  			/* IN: position of dnode */
static LSERR FExpandBeforeNonTextObject(GRCHUNKEXT* pgrchunkext, DWORD cTextBeforePrevioustNonText,
									   BOOL* pfExpand);
static LSERR FExpandAfterNonTextObject(GRCHUNKEXT* pgrchunkext, DWORD cTextBeforeLastNonText,
									   BOOL* pfExpand);

typedef struct groupchunkiterator
	{
	COLLECTSUBLINES Purpose; /* what sublines to take from a complex object */
	PLSDNODE plsdnFirst; /* dnode from which we started collecting */
	PLSDNODE plsdnStart; /* dnode where to start search for next, if NULL then 
							use plsdnFirst as first opportunity */
	LSCP cpLim;			/* boundary for group chunk if we go forward */
	BOOL fForward;		/* direction of traversing is forward otherwise it's backward*/
	}
GROUPCHUNKITERATOR;


static void CreateGroupChunkIterator(
					GROUPCHUNKITERATOR* pgroupchunkiterator, /* handler for iterator */
					COLLECTSUBLINES Purpose, /* what sublines to take from a complex object */
					PLSDNODE plsdnFirst, /* dnode from which we started collecting */
					LSCP cpLim,			/* boundary for group chunk if we go forward */
					BOOL fForward);		/* direction of traversing is forward otherwise it's backward*/


					
static void DestroyGroupChunkIterator(
					GROUPCHUNKITERATOR* pgroupchunkiterator); /* handler for iterator */



static PLSDNODE ContinueGroupChunk(
					GROUPCHUNKITERATOR* pgroupchunkiterator, /* handler for iterator */
					BOOL* pfSuccessful);				/* OUT: do we find dnode */

static PLSDNODE GetNextDnodeInGroupChunk(
					GROUPCHUNKITERATOR* pgroupchunkiterator, /* handler for iterator */
					BOOL* pfSuccessful);				/* OUT: do we find dnode */





#define  LschnkeFromDnode(plschnke, plsdn) \
		 (plschnke)->cpFirst = plsdn->cpFirst; \
		 (plschnke)->dcp = (plsdn)->dcp; \
		 (plschnke)->plschp = &((plsdn)->u.real.lschp); \
		 (plschnke)->plsrun = (plsdn)->u.real.plsrun; \
		 (plschnke)->pdobj = (plsdn)->u.real.pdobj; 


#define FIsGroupChunkBoundary(plsdn, cpLim, cpBase)  \
		(FIsOutOfBoundary((plsdn), (cpLim))  \
		||(FIsDnodePen(plsdn) && (!(plsdn)->fAdvancedPen)) \
		|| ((plsdn)->fTab) \
		||  (((cpBase) >= 0) ? ((plsdn)->cpFirst < 0) : ((plsdn)->cpFirst >= 0)))
/* last check verifies that we are not crossing boundaries of autonumber */

#define FIsGroupChunkStartBoundary(plsdn, cpBase)  \
		(((plsdn) == NULL)  \
		||(FIsDnodePen(plsdn) && (!(plsdn)->fAdvancedPen)) \
		|| ((plsdn)->fTab) \
		||  (((cpBase) >= 0) ? ((plsdn)->cpFirst < 0) : ((plsdn)->cpFirst >= 0)))
/* last check verifies that we are not crossing boundaries of autonumber */

#define FIsGrchnkExtValid(plschunkcontext, pgrchunkext)  \
		(((plschunkcontext) == (pgrchunkext)->plschunkcontext)  &&\
		 ((pgrchunkext)->lsgrchnk.plschnk == (plschunkcontext)->locchnkCurrent.plschnk) &&\
		 ((pgrchunkext)->lsgrchnk.pcont == (plschunkcontext)->pcont) &&\
		 ((pgrchunkext)->pplsdnNonText == (plschunkcontext)->pplsdnNonText) &&\
		 ((pgrchunkext)->pfNonTextExpandAfter == (plschunkcontext)->pfNonTextExpandAfter) \
        )
 
#define FDnodeInsideSubline(plssubl, plsdn) \
	    (FDnodeBeforeCpLim(plsdn, (plssubl)->cpLim) \
		&& FDnodeAfterCpFirst(plsdn, (plssubl)->cpFirst)) 

#define FUseForPurpose(plsdn, purpose)  \
		(*(&((plsdn)->u.real.pinfosubl->fUseForJustification) + (purpose -1)))

#define FIsUsageFlagsCastWorks(plsdn)  \
		((plsdn)->u.real.pinfosubl->fUseForCompression == \
					FUseForPurpose(plsdn, CollectSublinesForCompression) && \
		 (plsdn)->u.real.pinfosubl->fUseForJustification == \
					FUseForPurpose(plsdn, CollectSublinesForJustification)  && \
		 (plsdn)->u.real.pinfosubl->fUseForDisplay == \
					FUseForPurpose(plsdn, CollectSublinesForDisplay)  && \
		 (plsdn)->u.real.pinfosubl->fUseForDecimalTab == \
					FUseForPurpose(plsdn, CollectSublinesForDecimalTab) && \
		 (plsdn)->u.real.pinfosubl->fUseForTrailingArea == \
					FUseForPurpose(plsdn, CollectSublinesForTrailingArea))

#define GetSubmittedSublines(plsdn, purpose) \
	   ((((purpose) == CollectSublinesNone) || \
		 (Assert(FIsDnodeReal(plsdn)), (plsdn)->u.real.pinfosubl == NULL) || \
		 ((plsdn)->u.real.pinfosubl->rgpsubl == NULL)) ?  \
			NULL :  (Assert(FIsUsageFlagsCastWorks(plsdn)), \
					 (FUseForPurpose(plsdn, purpose)) ? \
					(plsdn)->u.real.pinfosubl->rgpsubl : NULL))

#define GetNumberSubmittedSublines(plsdn) \
			(Assert((plsdn)->u.real.pinfosubl != NULL), (plsdn)->u.real.pinfosubl->cSubline)

#define FColinearTflows(t1, t2)  \
			(((t1) & fUVertical) == ((t2) & fUVertical))

#define FSameSemiPlaneTflows(t1, t2)  \
			(((t1) & fUDirection) == ((t2) & fUDirection))

#define FParallelTflows(t1,t2) \
		Assert(FColinearTflows(t1, t2)), \
		FSameSemiPlaneTflows(t1, t2)   // we assume here that they are colinear 



/* C O L L E C T  C H U N K  A R O U N D*/
/*----------------------------------------------------------------------------
    %%Function: CollectChunkAround
    %%Contact: igorzv

Parameters:
	plsc			-		(IN) chunk context
	plsdn			-	    (IN) dnode to collect chunk arround
	lstflow			-		(IN) lstflow
	ppoint					(IN) starting position of dnode

Fill in cnunk elements array for chunk arround pposinline->plsdn
Calculate location of the chunk
----------------------------------------------------------------------------*/

LSERR CollectChunkAround(PLSCHUNKCONTEXT plschunkcontext, PLSDNODE plsdnInChunk, 
						 LSTFLOW lstflow, POINTUV* ppoint)  
						  
{
	WORD idObjChnk;
	PLSDNODE plsdnNext;
	PLSDNODE plsdnCurrent;
	PLOCCHNK plocchnk;
	LSCHNKE* plschnke;
	DWORD clschnk;
	LSERR lserr;
	LSCP cpInChunk;

	Assert(FIsLSDNODE(plsdnInChunk));

	plocchnk = &(plschunkcontext->locchnkCurrent);
	clschnk = plocchnk->clschnk;
	plschnke = plocchnk->plschnk;
	plsdnCurrent = plsdnInChunk;
	cpInChunk = plsdnInChunk->cpFirst;
	
	
	/* check: has this chunk already collected? */
	/* chunk was already collected if there is some chunk and our dnode is within this chunk
	   and nothing was added to list after chunk was collected  			*/
	/* we turn off optimisation for dnodes with dcp=0 (ex. pens) because of a problem how
	   to figure out that dnode is within chunk */
	if ((!plschunkcontext->FChunkValid) || (plschunkcontext->FGroupChunk)  
		||(plschnke[0].cpFirst > plsdnCurrent->cpFirst)
		|| (plschnke[clschnk - 1].cpFirst < plsdnCurrent->cpFirst)
		|| (plsdnCurrent->dcp == 0) 
		|| (plschnke[0].dcp == 0)
		|| ((plschunkcontext->pplsdnChunk[clschnk - 1])->plsdnNext != NULL))
		{
		/* we need to recollect chunk  */

		/* we don't allow caller to pass border as a plsdnInChunk */
		Assert(!FIsDnodeBorder(plsdnInChunk));

		if ( FIsDnodePen(plsdnInChunk) || plsdnInChunk->fTab || FIsDnodeSplat(plsdnInChunk))
			{
			/* for pens and tabs chunk consists of one element and we collect it right away */
			plocchnk->clschnk = 1;
			Assert(plocchnk->clschnk <= plschunkcontext->cchnkMax);
			LschnkeFromDnode((&(plschnke[0])), plsdnInChunk);
			plschunkcontext->pplsdnChunk[0] = plsdnInChunk;
			plschunkcontext->FChunkValid = fTrue;
			plschunkcontext->FLocationValid = fFalse;
			plschunkcontext->FGroupChunk = fFalse;
			/* we should here calculate width of border before dnode, the same way it done
			   in FillChunkArray */
			plschunkcontext->pdurOpenBorderBefore[0] = 0;
			plschunkcontext->pdurCloseBorderAfter[0] = 0;
			plschunkcontext->FBorderInside = fFalse;
			plsdnCurrent = plsdnInChunk->plsdnPrev;
			if (plsdnCurrent != NULL && FIsDnodeOpenBorder(plsdnCurrent))
				{
				plschunkcontext->FBorderInside = fTrue;
				plschunkcontext->pdurOpenBorderBefore[0] += DurFromDnode(plsdnCurrent);
				}
			plsdnCurrent = plsdnInChunk->plsdnNext;
			if (plsdnCurrent != NULL && FIsDnodeCloseBorder(plsdnCurrent))
				{
				plschunkcontext->FBorderInside = fTrue;
				plschunkcontext->pdurCloseBorderAfter[0] += DurFromDnode(plsdnCurrent);
				}
			}
		else
			{
	
			idObjChnk = IdObjFromDnode(plsdnInChunk);
			
			/* go to the end of chunk   */
			plsdnNext = plsdnCurrent->plsdnNext;
			while(!FIsChunkBoundary(plsdnNext, idObjChnk, cpInChunk))
				{
				plsdnCurrent = plsdnNext;
				plsdnNext = plsdnCurrent->plsdnNext;
				}
			
			lserr = FillChunkArray(plschunkcontext, plsdnCurrent);
			if (lserr != lserrNone)
				return lserr;
			}
		}
			
	/* check: is chunck located  */
	if (!plschunkcontext->FLocationValid)
		{
		LocateChunk(plschunkcontext, plsdnInChunk, lstflow, ppoint);
		}
	
	return lserrNone;

}

/* L O C A T E   C H U N K  */
/*----------------------------------------------------------------------------
    %%Function: CollectPreviousChunk
    %%Contact: igorzv

Parameters:
	plsc			-		(IN) chunk context
	plsdn			-	    (IN) dnode to collect chunk arround
	lstflow			-		(IN) lstflow
	ppoint					(IN) starting position of dnode

Calculates location of the chunk. We assume here that pointUv.u in locchunk
contains before this procedure width of border before dnode.
After procedure we put location there 
/*----------------------------------------------------------------------------*/


static void LocateChunk(PLSCHUNKCONTEXT plschunkcontext, PLSDNODE plsdnInChunk, 
						 LSTFLOW lstflow, POINTUV* ppoint)	
	{
	PLSDNODE plsdnFirst;
	PLOCCHNK plocchnk;
	PLSDNODE* pplsdnChunk;
	PLSDNODE plsdnCurrent;
	long urPen,vrPen;
	LONG i;
	PPOINTUV ppointUv;
	LONG* pdurOpenBorderBefore;
	LONG* pdurCloseBorderAfter;

	Assert(!FIsDnodeBorder(plsdnInChunk));  /* we don't allow border as in input */

	plocchnk = &(plschunkcontext->locchnkCurrent);
	plsdnFirst = plschunkcontext->pplsdnChunk[0];
	plocchnk->lsfgi.fFirstOnLine = FIsFirstOnLine(plsdnFirst)   
										&& FIsSubLineMain(SublineFromDnode(plsdnFirst));   
	plocchnk->lsfgi.cpFirst = plsdnFirst->cpFirst;		
	plocchnk->lsfgi.lstflow = lstflow;  		
	/* we can't set urColumnMax here, because during breaking object handler can change it */
	/* and we suppose that caller use  for this purpose SetUrColumnMaxForChunks */
	
	pplsdnChunk = plschunkcontext->pplsdnChunk;
	ppointUv = plocchnk->ppointUvLoc;
	pdurOpenBorderBefore = plschunkcontext->pdurOpenBorderBefore;
	pdurCloseBorderAfter = plschunkcontext->pdurCloseBorderAfter;

	/* calculation of pen position  before chunk */
	if (plsdnFirst->plsdnPrev == NULL)      /* optimization */
		{
		urPen = plschunkcontext->urFirstChunk;		
		vrPen = plschunkcontext->vrFirstChunk;	
		}
	else
		{
		plsdnCurrent = plsdnInChunk; 
		urPen = ppoint->u;
		vrPen = ppoint->v;
		
		for (i = 0; pplsdnChunk[i] != plsdnCurrent; i++)
			{
			Assert(i < (LONG) plocchnk->clschnk);      
			urPen -= DurFromDnode(pplsdnChunk[i]);
			vrPen -= DvrFromDnode(pplsdnChunk[i]);
			/* substract also border before dnode */
			urPen -= pdurOpenBorderBefore[i];
			urPen -= pdurCloseBorderAfter[i];
			}
		/* and now open border before plsdnCurrent */
		urPen -= pdurOpenBorderBefore[i];

		}

	plocchnk->lsfgi.urPen = urPen;
	plocchnk->lsfgi.vrPen = vrPen;

	/* location of all dnodes */
	for (i = 0; i < (LONG) plocchnk->clschnk; i++)
		{
		urPen += pdurOpenBorderBefore[i]; /* count border */
		if (i != 0) urPen += pdurCloseBorderAfter[i - 1];
		ppointUv[i].u = urPen;
		ppointUv[i].v = vrPen;
		urPen += DurFromDnode(pplsdnChunk[i]);
		vrPen += DvrFromDnode(pplsdnChunk[i]);
		}

	plschunkcontext->FLocationValid = fTrue;
	}

/* C O L L E C T  P R E V I O U S  C H U N K  */
/*----------------------------------------------------------------------------
    %%Function: CollectPreviousChunk
    %%Contact: igorzv

Parameters:
	plschuncontext				-	(IN) chunk context
	pfSuccessful		-			(OUT) does previous chunk exist 

Check that we are in the begining of line,
othewise call CollectChunkAround with the previous dnode
----------------------------------------------------------------------------*/


LSERR CollectPreviousChunk(PLSCHUNKCONTEXT plschunkcontext,	 
					   BOOL* pfSuccessful )		
{
	PLOCCHNK plocchnk;
	POINTUV point;
	PLSDNODE plsdn;


	plocchnk = &(plschunkcontext->locchnkCurrent);

	if (FIsFirstOnLine(plschunkcontext->pplsdnChunk[0]))  
		{
		*pfSuccessful = fFalse;
		return lserrNone;
		}
	else
		{
		plsdn = plschunkcontext->pplsdnChunk[0]->plsdnPrev;
		point = plocchnk->ppointUvLoc[0];
		while (FIsDnodeBorder(plsdn))
			{
			point.u -= DurFromDnode(plsdn);
			point.v -= DvrFromDnode(plsdn);
			plsdn = plsdn->plsdnPrev;
			}

		point.u -= DurFromDnode(plsdn);
		point.v -= DvrFromDnode(plsdn);

		*pfSuccessful = fTrue;
		return CollectChunkAround(plschunkcontext, plsdn, 
								  plocchnk->lsfgi.lstflow, &point);
		}
}

/* C O L L E C T  N E X T  C H U N K  */
/*----------------------------------------------------------------------------
    %%Function: CollectNextChunk
    %%Contact: igorzv

Parameters:
	plschuncontext				-	(IN) chunk context
	pfSuccessful		-	(OUT) does next chunk exist 

Check that we are in the end of list, in this case return *pfSuccessful and don't change chunk
othewise call CollectChunkAround with the next dnode
----------------------------------------------------------------------------*/


LSERR CollectNextChunk(PLSCHUNKCONTEXT plschunkcontext,	 
					   BOOL* pfSuccessful )		
	{
	PLOCCHNK plocchnk;
	DWORD clschnk;
	PLSDNODE* pplsdnChunk;
	POINTUV point; 
	PLSDNODE plsdn;
	
	
	plocchnk = &(plschunkcontext->locchnkCurrent);
	clschnk = plocchnk->clschnk;
	Assert(clschnk > 0);
	pplsdnChunk = plschunkcontext->pplsdnChunk;
	
	point = plocchnk->ppointUvLoc[clschnk - 1];
	point.u += DurFromDnode(pplsdnChunk[clschnk - 1]);
	point.v += DvrFromDnode(pplsdnChunk[clschnk - 1]);
	
	plsdn = pplsdnChunk[clschnk - 1]->plsdnNext;
	/* skip borders */
	while (plsdn != NULL && FIsDnodeBorder(plsdn))
		{
		point.u += DurFromDnode(plsdn);
		point.v += DvrFromDnode(plsdn);
		plsdn = plsdn->plsdnNext;
		}

	if (plsdn == NULL)
		{
		*pfSuccessful = fFalse;
		return lserrNone;
		}
	else
		{
		*pfSuccessful = fTrue;
		return CollectChunkAround(plschunkcontext, plsdn, 
			plocchnk->lsfgi.lstflow, &point);
		}
	}

/* F I L L  C H U N K  A R R A Y*/
/*----------------------------------------------------------------------------
    %%Function: FillChunkArray
    %%Contact: igorzv

Parameters:
	plschuncontext		-	(IN) chunk context
	plsdnLast			-	(IN) last dnode in chunk

Fill in chunk elements array for chunk before plsdnLast
----------------------------------------------------------------------------*/
LSERR 	FillChunkArray(PLSCHUNKCONTEXT  plschunkcontext,
						 PLSDNODE  plsdnLast) 
{
	PLSDNODE plsdnCurrent, plsdnPrev;
	WORD idObjChnk;
	PLOCCHNK plocchnk;
	LSCHNKE* plschnke;
	LONG clschnke;
	LSERR lserr;
	LONG i;
	LSCP cpInChunk;
	PPOINTUV ppointUv;
	LONG* pdurOpenBorderBefore;
	LONG* pdurCloseBorderAfter;

	Assert(FIsLSDNODE(plsdnLast));

	Assert(!plsdnLast->fTab);  /* for optimization we assume that caller will resolve */
	Assert(! FIsDnodePen(plsdnLast)); /* pen and tabs */
	Assert(!FIsDnodeSplat(plsdnLast));

	plocchnk = &(plschunkcontext->locchnkCurrent);

	/* skip borders in the end of chunk to figure out what idObj this chunk has */
	while (FIsDnodeBorder(plsdnLast))
		{
		plsdnLast = plsdnLast->plsdnPrev;
		Assert(FIsLSDNODE(plsdnLast));
		}

	idObjChnk = IdObjFromDnode(plsdnLast);
	cpInChunk = plsdnLast->cpFirst;

	/* go to the begining of chunk calculating amount of elements */
	plsdnCurrent = plsdnLast;
	plsdnPrev = plsdnCurrent->plsdnPrev;
	clschnke = 1;

	while (!FIsChunkBoundary(plsdnPrev, idObjChnk, cpInChunk))
			{
			plsdnCurrent = plsdnPrev;
			plsdnPrev = plsdnCurrent->plsdnPrev;
			if (!FIsDnodeBorder(plsdnCurrent)) clschnke++; /* we don't put borders into array */
			}
	/* plsdnCurrent is first dnode in chunk, clschnke is amount of chnk elements */

	if (clschnke > (LONG) plschunkcontext->cchnkMax)
		{
		lserr = SetChunkArraysSize(plschunkcontext, clschnke);
		if (lserr != lserrNone)
			return lserr;
		}
	
	

	/* fill in array of chunk elements   */
	FlushNominalToIdealState(plschunkcontext);
	plschnke = plocchnk->plschnk;
	plocchnk->clschnk = clschnke;
	ppointUv = plocchnk->ppointUvLoc;
	pdurOpenBorderBefore = plschunkcontext->pdurOpenBorderBefore;
	pdurCloseBorderAfter = plschunkcontext->pdurCloseBorderAfter;
	plschunkcontext->FBorderInside = fFalse;

	for (i=0; i < clschnke; i++)
		{
		Assert(!FIsChunkBoundary(plsdnCurrent, idObjChnk, cpInChunk));
		ppointUv[i].u = 0;
		pdurOpenBorderBefore[i] = 0;
		if (i != 0) pdurCloseBorderAfter[i - 1] = 0;
		while (FIsDnodeBorder(plsdnCurrent))
			{
			/* calculates border widths */
			plschunkcontext->FBorderInside = fTrue;
			if (FIsDnodeOpenBorder(plsdnCurrent))
				{
				pdurOpenBorderBefore[i] += DurFromDnode(plsdnCurrent);
				}
			else
				{
				if (i != 0) pdurCloseBorderAfter[i - 1] += DurFromDnode(plsdnCurrent);
				}
				
			plsdnCurrent = plsdnCurrent->plsdnNext;
			}

		LschnkeFromDnode(plschnke, plsdnCurrent);
		plschunkcontext->pplsdnChunk[i] = plsdnCurrent;
		SetNominalToIdealFlags(plschunkcontext, &(plsdnCurrent->u.real.lschp));

		plsdnCurrent = plsdnCurrent->plsdnNext;

		plschnke++;
		}

	/* closing border after chunk */
	if (plsdnCurrent != NULL && FIsDnodeCloseBorder(plsdnCurrent))
		{
		plschunkcontext->FBorderInside = fTrue;
		pdurCloseBorderAfter[clschnke - 1] = DurFromDnode(plsdnCurrent);
		}
	else
		{
		pdurCloseBorderAfter[clschnke - 1] = 0;
		}

	plschunkcontext->FChunkValid = fTrue;	
	plschunkcontext->FLocationValid = fFalse; /* chunk we collected is not located and */
	plschunkcontext->FGroupChunk = fFalse;	/* is not group */

	return lserrNone;

}


/* S E T  P O S  I N  C H U N K */
/*----------------------------------------------------------------------------
    %%Function: SetPosInChunk
    %%Contact: igorzv

Parameters:
	plschunkcontext		-	(IN) LineServices context
	PLSDNODE plsdn		-	(IN) dnode
	LSDCP dcp			-	(IN) dcp
	pposichnk			-	(OUT) position in chunk to fill in

Convert position in line to position in chunk
----------------------------------------------------------------------------*/

void SetPosInChunk(PLSCHUNKCONTEXT plschunkcontext, PLSDNODE plsdn,
				   LSDCP dcp, PPOSICHNK pposichnk)
{

	LONG i;
	LONG clschnkMac;
	PLSDNODE* pplsdnChunk;
	
	Assert(FIsLSDNODE(plsdn));

	pplsdnChunk = plschunkcontext->pplsdnChunk;
	clschnkMac = plschunkcontext->locchnkCurrent.clschnk;  
	for (i=0; (i < clschnkMac) && (plsdn != pplsdnChunk[i]) ; i++);

	Assert(i < clschnkMac);

	pposichnk->dcp = dcp;
	pposichnk->ichnk = i;

}


		 
/* I N I T  G R O U P  C H U N K  E X T */
/*----------------------------------------------------------------------------
    %%Function: InitGroupChunkExt
    %%Contact: igorzv

Parameters:
	plschunkcontext				-	(IN) chunkcontext context
	iobjText				-		(IN) idobj of text
	pgrchunkext			-	(OUT) structure to initialize

Link GroupChunkExt with state 
Fill in default values
----------------------------------------------------------------------------*/


void InitGroupChunkExt(PLSCHUNKCONTEXT plschunkcontext, DWORD iobjText,
					   GRCHUNKEXT* pgrchunkext)
{
	Assert(pgrchunkext != NULL);
	
	pgrchunkext->plschunkcontext = plschunkcontext;

	pgrchunkext->iobjText = iobjText;
	
	/* we don't need to flush everything here */
	/* we will do this in CollectGroupChunk procedures */

	pgrchunkext->lsgrchnk.plschnk = plschunkcontext->locchnkCurrent.plschnk;
	pgrchunkext->lsgrchnk.pcont = plschunkcontext->pcont;
	pgrchunkext->pfNonTextExpandAfter = plschunkcontext->pfNonTextExpandAfter;
	pgrchunkext->pplsdnNonText = plschunkcontext->pplsdnNonText;
}




/* C O L L E C T  T E X T  G R O U P  C H U N K*/
/*----------------------------------------------------------------------------
%%Function: CollectTextGroupChunk
%%Contact: igorzv

  Parameters:
  plsdnFirst			-	(IN) start dnode
  cpLim				-   (IN) boundary for group chunk
  Purpose				-	(IN) what subline to take from complex object
  pgrchunkext			-	(OUT) group chunk to fill in
  
	Fill in group chunk structure with text dnodes located from plsdFirst 
----------------------------------------------------------------------------*/



LSERR CollectTextGroupChunk(		
							PLSDNODE plsdnFirst,
							LSCP cpLim,
							COLLECTSUBLINES Purpose,
							GRCHUNKEXT* pgrchunkext)
	{
	PLSCHUNKCONTEXT plschunkcontext = pgrchunkext->plschunkcontext;
	DWORD iobjText = pgrchunkext->iobjText;
	PLOCCHNK plocchnk;
	DWORD cChunk;
	PLSDNODE plsdnCurrent;
	BOOL fPreviousIsNonText = fFalse;
	LSERR lserr;
	LSCHNKE* plschnke;
	BOOL fSuccessful;
	BOOL fExpand;
	DWORD cTextBeforeLastNonText = 0;
	GROUPCHUNKITERATOR groupchunkiterator;
	PLSDNODE plsdnLastForTrailing;
	int cDnodesTrailing;
	LSDCP dcpStartTrailing;
	PLSDNODE plsdnTrailingObject;
	LSDCP dcpTrailingObject;
	
	
	Assert(FIsLSDNODE(plsdnFirst));
	Assert(FIsGrchnkExtValid(plschunkcontext, pgrchunkext)); 
	
	
	
	/* we try to optimize here in a case when group chunk consist of one (last in a line)
	chunk 	and this chunk has been already collected */
	plocchnk = &(plschunkcontext->locchnkCurrent);
	cChunk = plocchnk->clschnk;
	
	/* if we have text chunk without borders started with plsdnFirst 
	and going up or beyond cpLim */
	if ((cChunk > 0) &&
		(plschunkcontext->FChunkValid) && 
		(!plschunkcontext->FGroupChunk) && 
		(!plschunkcontext->FBorderInside) && 
		(IdObjFromChnk(plocchnk) ==  pgrchunkext->iobjText) && 
		(plschunkcontext->pplsdnChunk[0] == plsdnFirst)
		&& (!plsdnFirst->fTab)
		&& (FIsOutOfBoundary((plschunkcontext->pplsdnChunk[cChunk - 1])->plsdnNext, cpLim)))
		{
		pgrchunkext->Purpose = Purpose;
		return ConvertChunkToGroupChunk(pgrchunkext, cpLim);
		}
	
	/* we have to go through general procedure */
	
	/* flush group chunk				*/
	pgrchunkext->plsdnFirst = plsdnFirst;
	pgrchunkext->durTotal = 0;
	pgrchunkext->durTextTotal = 0;
	pgrchunkext->dupNonTextTotal = 0;
	pgrchunkext->cNonTextObjects = 0;
	pgrchunkext->cNonTextObjectsExpand = 0;
	pgrchunkext->lsgrchnk.clsgrchnk = 0;
	pgrchunkext->plsdnNext = NULL;
	pgrchunkext->plsdnLastUsed = NULL;
	plschunkcontext->FGroupChunk = fTrue;
	plschunkcontext->FBorderInside = fFalse;
	pgrchunkext->Purpose = Purpose;
	
	CreateGroupChunkIterator(&groupchunkiterator, 
		Purpose, plsdnFirst, cpLim,	fTrue);	
	
	plsdnCurrent = GetNextDnodeInGroupChunk(&groupchunkiterator, &fSuccessful);
	
	while(fSuccessful)
		{
		pgrchunkext->plsdnLastUsed = plsdnCurrent;
		
		/* fill in array of elements   */
		if (FIsDnodeReal(plsdnCurrent) && !FIsDnodeSplat(plsdnCurrent)) /* not a pen border or splat*/
			{
			if (IdObjFromDnode(plsdnCurrent) == iobjText) /* is text */
				{
				
				pgrchunkext->lsgrchnk.clsgrchnk++;
				if (pgrchunkext->lsgrchnk.clsgrchnk > plschunkcontext->cchnkMax)
					{
					lserr = IncreaseChunkArrays(plschunkcontext);
					if (lserr != lserrNone)
						{
						DestroyGroupChunkIterator(&groupchunkiterator);
						return lserr;
						}
					pgrchunkext->lsgrchnk.plschnk = plschunkcontext->locchnkCurrent.plschnk;
					pgrchunkext->lsgrchnk.pcont = plschunkcontext->pcont;
					Assert(FIsGrchnkExtValid(plschunkcontext, pgrchunkext)); 
					}
				
				/* fill in group chunk element */
				plschnke = &(pgrchunkext->lsgrchnk.plschnk[pgrchunkext->lsgrchnk.clsgrchnk - 1]);
				LschnkeFromDnode(plschnke, plsdnCurrent);
				
				/* fill in array of dnodes in context */
				plschunkcontext->pplsdnChunk[pgrchunkext->lsgrchnk.clsgrchnk - 1] = plsdnCurrent;
				
				/* flash flags */
				pgrchunkext->lsgrchnk.pcont[pgrchunkext->lsgrchnk.clsgrchnk - 1] = 0;
				
				/* set flags  */
				if (fPreviousIsNonText)
					{
					pgrchunkext->lsgrchnk.pcont[pgrchunkext->lsgrchnk.clsgrchnk - 1] |=
						fcontNonTextBefore;  
					}
				
				
				fPreviousIsNonText = fFalse;
				
				/* calculate integrated information   */
				pgrchunkext->durTextTotal += plsdnCurrent->u.real.objdim.dur;
				pgrchunkext->durTotal += plsdnCurrent->u.real.objdim.dur;
				}
			else
				{
				/* resolve expansion after previous non text */
				if (pgrchunkext->cNonTextObjects > 0)
					{
					lserr = FExpandAfterNonTextObject(pgrchunkext, cTextBeforeLastNonText, 
						&fExpand);
					if (lserr != lserrNone)
						{
						DestroyGroupChunkIterator(&groupchunkiterator);
						return lserr;
						}
					
					pgrchunkext->pfNonTextExpandAfter[pgrchunkext->cNonTextObjects - 1] =
						fExpand;
					
					if (fExpand)
						{
						/* increase amount of expandable non text objects */
						pgrchunkext->cNonTextObjectsExpand++;
						/* it was text between two non texts */
						if (!fPreviousIsNonText)
							{
							Assert(pgrchunkext->lsgrchnk.clsgrchnk > cTextBeforeLastNonText);
							pgrchunkext->lsgrchnk.pcont[cTextBeforeLastNonText] |=
								fcontExpandBefore; 
							}
						}
					}
				
				
				pgrchunkext->cNonTextObjects++;
				if (pgrchunkext->cNonTextObjects > plschunkcontext->cNonTextMax)
					{
					lserr = IncreaseGroupChunkNonTextArrays(plschunkcontext);
					if (lserr != lserrNone)
						{
						DestroyGroupChunkIterator(&groupchunkiterator);
						return lserr;
						}
					pgrchunkext->pplsdnNonText = plschunkcontext->pplsdnNonText;
					pgrchunkext->pfNonTextExpandAfter = plschunkcontext->pfNonTextExpandAfter;
					Assert(FIsGrchnkExtValid(plschunkcontext, pgrchunkext)); 
					}
				
				/* fill in array of non text dnodes in context */
				plschunkcontext->pplsdnNonText[pgrchunkext->cNonTextObjects - 1] = plsdnCurrent;
				
				
				/* set flags in previous text */
				if (!fPreviousIsNonText && pgrchunkext->lsgrchnk.clsgrchnk >= 1)
					{
					Assert(pgrchunkext->lsgrchnk.clsgrchnk >= 1);
					pgrchunkext->lsgrchnk.pcont[pgrchunkext->lsgrchnk.clsgrchnk  - 1] |=
						(fcontNonTextAfter); 
					
					/* resolve expansion before current non text */
					Assert(cTextBeforeLastNonText < pgrchunkext->lsgrchnk.clsgrchnk);
					lserr =FExpandBeforeNonTextObject(pgrchunkext, cTextBeforeLastNonText,
						&fExpand);
					if (lserr != lserrNone)
						{
						DestroyGroupChunkIterator(&groupchunkiterator);
						return lserr;
						}
					if (fExpand)
						{
						pgrchunkext->lsgrchnk.pcont[pgrchunkext->lsgrchnk.clsgrchnk  - 1] |=
							fcontExpandAfter;
						}
					}
				
				fPreviousIsNonText = fTrue;
				cTextBeforeLastNonText = pgrchunkext->lsgrchnk.clsgrchnk;
				
				/* calculate integrated information   */
				pgrchunkext->durTotal += DurFromRealDnode(plsdnCurrent);
				pgrchunkext->dupNonTextTotal += DupFromRealDnode(plsdnCurrent);
				} /* non -text */
			} /* real dnode */
			else
				{  /* pen  or border*/
				Assert(FIsDnodePen(plsdnCurrent) ||
					FIsDnodeBorder(plsdnCurrent) || FIsDnodeSplat(plsdnCurrent));
				Assert(FIsDnodeBorder(plsdnCurrent) || FIsDnodeSplat(plsdnCurrent) ||
					plsdnCurrent->fAdvancedPen); /* only advanced pens are allowed here */
				
				if (FIsDnodeBorder(plsdnCurrent)) 
					plschunkcontext->FBorderInside = fTrue;
				
				pgrchunkext->durTotal += DurFromDnode(plsdnCurrent);
				pgrchunkext->dupNonTextTotal += DupFromDnode(plsdnCurrent);
				}
			
			/* prepare next iteration */
			plsdnCurrent = GetNextDnodeInGroupChunk(&groupchunkiterator, &fSuccessful);
		}
		
		/* resolve expansion after previous non text */
		if (pgrchunkext->cNonTextObjects > 0)
			{
			lserr = FExpandAfterNonTextObject(pgrchunkext, cTextBeforeLastNonText, 
				&fExpand);
			if (lserr != lserrNone)
				{
				DestroyGroupChunkIterator(&groupchunkiterator);
				return lserr;
				}
			
			pgrchunkext->pfNonTextExpandAfter[pgrchunkext->cNonTextObjects - 1] |=
				fExpand;
			
			if (fExpand)
				{
				/* increase amount of expandable non text objects */
				pgrchunkext->cNonTextObjectsExpand++;
				/* it was text between two non texts */
				if (!fPreviousIsNonText)
					{
					Assert(pgrchunkext->lsgrchnk.clsgrchnk > cTextBeforeLastNonText);
					pgrchunkext->lsgrchnk.pcont[cTextBeforeLastNonText] |=
						fcontExpandBefore; 
					}
				}
			}
		
		pgrchunkext->plsdnNext = plsdnCurrent;
		
		DestroyGroupChunkIterator(&groupchunkiterator);
		
		/* because collecting of group chunk can be called before SetBreak, dcp of last
		dnode, if it come from lower level, should be cut using  cpLim */
		
		if ((pgrchunkext->lsgrchnk.clsgrchnk > 0) &&
			(plschunkcontext->pplsdnChunk[pgrchunkext->lsgrchnk.clsgrchnk - 1]->cpLimOriginal 
			> cpLim)
			)
			{
			pgrchunkext->lsgrchnk.plschnk[pgrchunkext->lsgrchnk.clsgrchnk - 1].dcp =
				cpLim - 
				plschunkcontext->pplsdnChunk[pgrchunkext->lsgrchnk.clsgrchnk - 1]->cpFirst;
			}
		
		if (Purpose == CollectSublinesForJustification || 
			Purpose == CollectSublinesForCompression)
			{
			/* we should find here last dnode on the upper level before chunk boundary */
			if (pgrchunkext->plsdnLastUsed == NULL)
				{
				/* first dnode is already out of boundary, it can happened with tabs or pens  */
				Assert(pgrchunkext->plsdnFirst == pgrchunkext->plsdnNext);
				plsdnLastForTrailing = pgrchunkext->plsdnFirst;
				}
			else if (pgrchunkext->plsdnNext != NULL)
				{
				plsdnLastForTrailing = pgrchunkext->plsdnNext->plsdnPrev;
				}
			else
				{
				plsdnLastForTrailing = (SublineFromDnode(pgrchunkext->plsdnFirst))->plsdnLast;
				}
			
			lserr = GetTrailingInfoForTextGroupChunk
				(plsdnLastForTrailing, plsdnLastForTrailing->dcp,
				iobjText, &(pgrchunkext->durTrailing), &(pgrchunkext->dcpTrailing),
				&(pgrchunkext->plsdnStartTrailing), 
				&dcpStartTrailing,
				&cDnodesTrailing, &plsdnTrailingObject, &dcpTrailingObject,
				&(pgrchunkext->fClosingBorderStartsTrailing));
			
			if (lserr != lserrNone)
				{
				return lserr;
				}
			
			if (cDnodesTrailing == 0)
				{
				if (pgrchunkext->lsgrchnk.clsgrchnk != 0)
					{
					pgrchunkext->posichnkBeforeTrailing.ichnk = pgrchunkext->lsgrchnk.clsgrchnk - 1;
					pgrchunkext->posichnkBeforeTrailing.dcp = pgrchunkext->lsgrchnk.plschnk
						[pgrchunkext->posichnkBeforeTrailing.ichnk].dcp;
					}
				else
					{
					/* in this case posichnkBeforeTrailing doesn't make any sense and we can't use
					code above not to triger memory violation, so we put zeroes just to put something */
					pgrchunkext->posichnkBeforeTrailing.ichnk = 0;
					pgrchunkext->posichnkBeforeTrailing.dcp = 0;
					}
				}
			else
				{
				pgrchunkext->posichnkBeforeTrailing.ichnk = pgrchunkext->lsgrchnk.clsgrchnk 
					- cDnodesTrailing;
				if (FIsDnodeReal(pgrchunkext->plsdnStartTrailing) 
					&& IdObjFromDnode(pgrchunkext->plsdnStartTrailing) == iobjText)
					{
					pgrchunkext->posichnkBeforeTrailing.dcp = dcpStartTrailing;
					}
				else
					{
					/* trailing area was interupted by non text, we report to text starting of trailing before
					previous text */
					Assert(pgrchunkext->plsdnStartTrailing->dcp == dcpStartTrailing);
					pgrchunkext->posichnkBeforeTrailing.dcp = 0;
					}
				}
			}
		
		
		return lserrNone;
		
	}
	
	


/* C O N T I N U E  G R O U P  C H U N K*/
/*----------------------------------------------------------------------------
    %%Function: ContinueGroupChunk
    %%Contact: igorzv

Parameters:
	pgroupchunkiterator	-(IN) handler for iterator 
	pfSuccessful	-	(OUT) do we find dnode in this group chunk 

Start traversing list for collecting group chunk 
----------------------------------------------------------------------------*/

PLSDNODE ContinueGroupChunk(
							GROUPCHUNKITERATOR* pgroupchunkiterator, 
							BOOL* pfSuccessful)
	{
	PLSSUBL plssubl;
	PLSSUBL* rgpsubl;
	PLSDNODE plsdnStart = pgroupchunkiterator->plsdnStart;
	BOOL fBoundaryCondition;
	int cSublines;

	/* we assume here that dnode out of group chunk boundary can happen only on main subline of
	the group chunk */

	fBoundaryCondition = pgroupchunkiterator->fForward ? 
		FIsGroupChunkBoundary(plsdnStart, pgroupchunkiterator->cpLim, 
			pgroupchunkiterator->plsdnFirst->cpFirst) :
		FIsGroupChunkStartBoundary(plsdnStart, pgroupchunkiterator->plsdnFirst->cpFirst) ;
		

	if (fBoundaryCondition)		/* we out of limits */
		{	
		AssertImplies(plsdnStart != NULL, FIsLSDNODE(plsdnStart));
		AssertImplies(plsdnStart != NULL, 
			SublineFromDnode(plsdnStart) == SublineFromDnode(pgroupchunkiterator->plsdnFirst));
		*pfSuccessful = fFalse;
		return plsdnStart;
		}

	Assert(FIsLSDNODE(plsdnStart));
	plssubl = SublineFromDnode(plsdnStart);

	/* we assume here that here that plsnStart is valid dnode within subline*/
	Assert(!FIsOutOfBoundary(plsdnStart, plssubl->cpLim));

	*pfSuccessful = fTrue;

	if (FIsDnodeBorder(plsdnStart) || FIsDnodePen(plsdnStart))
		{
		return plsdnStart;
		}

	rgpsubl = GetSubmittedSublines(plsdnStart, pgroupchunkiterator->Purpose);

	if (rgpsubl == NULL)
		{
		return plsdnStart;
		}
	else
		{
		cSublines = GetNumberSubmittedSublines(plsdnStart);
		if (cSublines > 0)
			{
			plssubl = pgroupchunkiterator->fForward ? 
				rgpsubl[0] : rgpsubl[cSublines - 1];
			/* we assume here that empty subline can not be submitted */
			Assert(!FIsOutOfBoundary(plssubl->plsdnFirst, plssubl->cpLim));
			plssubl->plsdnUpTemp = plsdnStart;
			pgroupchunkiterator->plsdnStart = pgroupchunkiterator->fForward ?
				plssubl->plsdnFirst : plssubl->plsdnLast;
			return ContinueGroupChunk(pgroupchunkiterator, pfSuccessful);
			}
		else
			{
			return plsdnStart;
			}
		}
	}


/* G E T  N E X T  D N O D E  I N  G R O U P  C H U N K*/
/*----------------------------------------------------------------------------
    %%Function: GetNextDnodeInGroupChunk
    %%Contact: igorzv

Parameters:
	pgroupchunkiterator	-(IN) handler for iterator 
	pfSuccessful	-	(OUT) do we find dnode in this group chunk 

Continue traversing list for collecting group chunk 
----------------------------------------------------------------------------*/

PLSDNODE GetNextDnodeInGroupChunk(
					GROUPCHUNKITERATOR* pgroupchunkiterator, 
					BOOL* pfSuccessful)
	{
	LONG i;
	PLSSUBL plssubl;
	PLSDNODE plsdnNext;
	PLSDNODE plsdnUp;
	PLSSUBL* rgpsubl;
	LONG cSublines;
	PLSDNODE plsdnStart = pgroupchunkiterator->plsdnStart;

	if (plsdnStart == NULL)  /* first iteration */
		{
		pgroupchunkiterator->plsdnStart = pgroupchunkiterator->plsdnFirst;
		return ContinueGroupChunk(pgroupchunkiterator, pfSuccessful);
		}

	Assert(FIsLSDNODE(plsdnStart));
	
	plssubl = plsdnStart->plssubl;
	plsdnNext = pgroupchunkiterator->fForward ? 
					plsdnStart->plsdnNext : plsdnStart->plsdnPrev;

	/* we are in one of submitted sublines and this subline ended */
	if (plssubl != SublineFromDnode(pgroupchunkiterator->plsdnFirst) && 
		FIsOutOfBoundary(plsdnNext, plssubl->cpLim)) 
		{
		plsdnUp = plssubl->plsdnUpTemp;
		Assert(FIsLSDNODE(plsdnUp));
		/* flush temporary field */
		plssubl->plsdnUpTemp = NULL;

		rgpsubl = GetSubmittedSublines(plsdnUp, pgroupchunkiterator->Purpose);
		cSublines = GetNumberSubmittedSublines(plsdnUp);
		Assert(rgpsubl != NULL);
		Assert(cSublines > 0);

		/* find index in a array of submitted sublines */
		for (i=0; i < cSublines	&& plssubl != rgpsubl[i]; i++);
		Assert(i < cSublines);

		if ( (pgroupchunkiterator->fForward && i == cSublines - 1) ||
			 (!pgroupchunkiterator->fForward && i == 0)
		   )
		/* array ended: return to the upper level */
			{
			pgroupchunkiterator->plsdnStart = plsdnUp;
			return GetNextDnodeInGroupChunk(pgroupchunkiterator, pfSuccessful);
			}
		else
			{
			plssubl = pgroupchunkiterator->fForward ? 
						rgpsubl[i + 1] : rgpsubl[i - 1];
			/* we assume here that empty subline can not be submitted */
			Assert(!FIsOutOfBoundary(plssubl->plsdnFirst, plssubl->cpLim));
			plssubl->plsdnUpTemp = plsdnUp;
			pgroupchunkiterator->plsdnStart = plssubl->plsdnFirst;
			return ContinueGroupChunk(pgroupchunkiterator, pfSuccessful);
			}
		}
	else /* we can continue with the same subline */
		{
		pgroupchunkiterator->plsdnStart = plsdnNext;
		return ContinueGroupChunk(pgroupchunkiterator, pfSuccessful);
		}

	}

/* C R E A T E  G R O U P  C H U N K  I T E R A T O R*/
/*----------------------------------------------------------------------------
    %%Function: CreateGroupChunkIterator
    %%Contact: igorzv

Parameters:
	pgroupchunkiterator	-(IN) handler for iterator 
	Purpose				-(INI what sublines to take from a complex object 
	plsdnFirst			-(IN) dnode from which we started collecting 
	cpLim				-(IN) boundary for group chunk if we go forward 
	fForward			-(IN) direction of traversing is forward otherwise it's backward

----------------------------------------------------------------------------*/
static void CreateGroupChunkIterator(
					GROUPCHUNKITERATOR* pgroupchunkiterator, 
					COLLECTSUBLINES Purpose, 
					PLSDNODE plsdnFirst, 
					LSCP cpLim,			
					BOOL fForward)
	{
	pgroupchunkiterator->Purpose = Purpose;
	pgroupchunkiterator->plsdnFirst = plsdnFirst;
	pgroupchunkiterator->plsdnStart = NULL;
	pgroupchunkiterator->cpLim = cpLim;
	pgroupchunkiterator->fForward = fForward;
	}

/* D E S T R O Y  G R O U P  C H U N K  I T E R A T O R*/
/*----------------------------------------------------------------------------
    %%Function: DesroyGroupChunkIterator
    %%Contact: igorzv

Parameters:
	pgroupchunkiterator	-(IN) handler for iterator 

----------------------------------------------------------------------------*/
static void DestroyGroupChunkIterator(
									  GROUPCHUNKITERATOR* pgroupchunkiterator) 
	{
	PLSSUBL plssubl;
	PLSDNODE plsdn;
	if (pgroupchunkiterator->plsdnStart != NULL)
		{
		plssubl = SublineFromDnode(pgroupchunkiterator->plsdnStart);
		while (SublineFromDnode(pgroupchunkiterator->plsdnFirst) != plssubl)
			{
			plsdn = plssubl->plsdnUpTemp;
			Assert(FIsLSDNODE(plsdn));
			plssubl->plsdnUpTemp = NULL;
			plssubl = SublineFromDnode(plsdn);
			}
		}
	}

/* F  E X P A N D  B E F O R E  N O N  T E X T  O B J E C T*/
/*----------------------------------------------------------------------------
    %%Function: FExpandBeforeNonTextObject
    %%Contact: igorzv

Parameters:
	pgrchunkext					-	(IN) group chunk
	cTextBeforePreviousNonText	-	(IN) number of text before previous non text 
										 to calculate contiguous chunk
	pfExpand					-	(OUT) to expand dnode before non text

----------------------------------------------------------------------------*/
static LSERR FExpandBeforeNonTextObject(GRCHUNKEXT* pgrchunkext, DWORD cTextBeforePrevioustNonText,
									   BOOL* pfExpand)
	{
	DWORD cTextBetween;
	LSERR lserr;
	BOOL fSuccessful;
	WCHAR wchar;
	PLSRUN plsrunText;
	HEIGHTS heightsText;
	MWCLS mwcls;
	DWORD iobj;
	LSIMETHODS* plsim;
	PLSDNODE plsdnNonText;

	*pfExpand = fTrue;

	cTextBetween = pgrchunkext->lsgrchnk.clsgrchnk - cTextBeforePrevioustNonText;
	if (cTextBetween)
		{
		lserr = GetLastCharInChunk(cTextBetween,
				(pgrchunkext->lsgrchnk.plschnk + cTextBeforePrevioustNonText), &fSuccessful,
				&wchar, &plsrunText, &heightsText, &mwcls);
		if (lserr != lserrNone)
			return lserr; 
		if (fSuccessful)
			{
			plsdnNonText = pgrchunkext->pplsdnNonText[pgrchunkext->cNonTextObjects - 1];
			iobj = IdObjFromDnode(plsdnNonText);
			plsim = PLsimFromLsc(pgrchunkext->plschunkcontext->plsiobjcontext, iobj);
			if (plsim->pfnFExpandWithPrecedingChar != NULL)
				{
				lserr = plsim->pfnFExpandWithPrecedingChar(plsdnNonText->u.real.pdobj,
					plsdnNonText->u.real.plsrun, plsrunText, wchar,
					mwcls, pfExpand);
				if (lserr != lserrNone)
					return lserr;
				}  /* object has this method */
			}	/* call back from text was successful  */
		}
	return lserrNone;
	}

/* F  E X P A N D  A F T E R  N O N  T E X T  O B J E C T*/
/*----------------------------------------------------------------------------
    %%Function: FExpandAfterNonTextObject
    %%Contact: igorzv

Parameters:
	pgrchunkext					-	(IN) group chunk
	cTextBeforeLastNonText		-	(IN) number of text before last non text 
										 to calculate contiguous chunk
	pfExpand					-	(OUT) to expand dnode before non text

----------------------------------------------------------------------------*/
static LSERR FExpandAfterNonTextObject(GRCHUNKEXT* pgrchunkext, DWORD cTextBeforeLastNonText,
									   BOOL* pfExpand)
	{
	DWORD cTextBetween;
	LSERR lserr;
	BOOL fSuccessful;
	WCHAR wchar;
	PLSRUN plsrunText;
	HEIGHTS heightsText;
	MWCLS mwcls;
	DWORD iobj;
	LSIMETHODS* plsim;
	PLSDNODE plsdnNonText;

	*pfExpand = fTrue;

	cTextBetween = pgrchunkext->lsgrchnk.clsgrchnk - cTextBeforeLastNonText;
	if (cTextBetween)
		{
		lserr = GetFirstCharInChunk(cTextBetween,
				(pgrchunkext->lsgrchnk.plschnk + cTextBeforeLastNonText), &fSuccessful,
				&wchar, &plsrunText, &heightsText, &mwcls);
		if (lserr != lserrNone)
			return lserr; 
		if (fSuccessful)
			{
			plsdnNonText = pgrchunkext->pplsdnNonText[pgrchunkext->cNonTextObjects - 1];
			iobj = IdObjFromDnode(plsdnNonText);
			plsim = PLsimFromLsc(pgrchunkext->plschunkcontext->plsiobjcontext, iobj);
			if (plsim->pfnFExpandWithFollowingChar != NULL)
				{
				lserr = plsim->pfnFExpandWithFollowingChar(plsdnNonText->u.real.pdobj,
					plsdnNonText->u.real.plsrun, plsrunText, wchar,
					mwcls, pfExpand);
				if (lserr != lserrNone)
					return lserr;
				}  /* object has this method */
			}	/* call back from text was successful  */
		}
	return lserrNone;
	}


/* C O L L E C T  P R E V I O U S  T E X T  G R O U P  C H U N K*/
/*----------------------------------------------------------------------------
    %%Function: CollectPreviousTextGroupChunk
    %%Contact: igorzv

Parameters:
	plsdnEnd			-	(IN) end dnode
	sublinnesToCollect		(IN) what subline to take from complex object
	pgrchunkext			-	(OUT) group chunk to fill in

Fill in group chunk structure with text dnodes located before  plsdEnd
----------------------------------------------------------------------------*/



LSERR CollectPreviousTextGroupChunk(		
			 		 PLSDNODE plsdnEnd,
					 COLLECTSUBLINES Purpose,
					 BOOL fAllSimpleText,
					 GRCHUNKEXT* pgrchunkext)
{
	LSCHUNKCONTEXT* plschunkcontext = pgrchunkext->plschunkcontext;
	PLOCCHNK plocchnk;
	DWORD cChunk;
	LSCP cpLim;
	PLSDNODE plsdn;
	PLSDNODE plsdnPrev;

	Assert(FIsLSDNODE(plsdnEnd));
	Assert(FIsGrchnkExtValid(plschunkcontext, pgrchunkext)); 

	/* we try to optimize here in a case when there is only text in line  */
	/* chunk of text has been already collected */
	plocchnk = &(plschunkcontext->locchnkCurrent);
	cChunk = plocchnk->clschnk;
	cpLim = plsdnEnd->cpLimOriginal; 

	if (fAllSimpleText && cChunk > 0) 
		{
		/* chunk goes up to the end of a line */
		Assert((plschunkcontext->pplsdnChunk[cChunk - 1])->plsdnNext == NULL);
		pgrchunkext->Purpose = Purpose;
		return ConvertChunkToGroupChunk(pgrchunkext, cpLim);
		}

	/* go backward to the start of group chunk  */
	plsdn = plsdnEnd;
	plsdnPrev = plsdn->plsdnPrev;
	while (!FIsGroupChunkStartBoundary(plsdnPrev, plsdnEnd->cpFirst))
		{
		plsdn = plsdnPrev;
		plsdnPrev = plsdn->plsdnPrev;
		}
	
	return CollectTextGroupChunk(plsdn, cpLim, Purpose, pgrchunkext);
	
}

/* C O N V E R T  C H U N K  T O  G R O U P  C H U N K*/
/*----------------------------------------------------------------------------
    %%Function: ConvertChunkToGroupChunk
    %%Contact: igorzv

Parameters:
	cpLim			-		(IN) cpLim
	pgrchunkext			-	(OUT) group chunk to fill in

Fill in group chunk structure with text dnodes located before  plsdEnd
We assume here that chunk doesn't contain border.
----------------------------------------------------------------------------*/


static LSERR ConvertChunkToGroupChunk(GRCHUNKEXT* pgrchunkext, LSCP cpLim)
{
	DWORD clsgrchnkCollected = 0;
	long durTotal = 0;
	LSCHUNKCONTEXT* plschunkcontext = pgrchunkext->plschunkcontext;
	PLOCCHNK plocchnk;
	LONG cChunk;
	LONG i;
	BOOL fLineEnded;
	PLSDNODE plsdn;
	long durTrailingDnode;
	LSDCP dcpTrailingDnode;

	Assert(FIsGrchnkExtValid(plschunkcontext, pgrchunkext)); 

	plocchnk = &(plschunkcontext->locchnkCurrent);
	cChunk = (int) plocchnk->clschnk;
	fLineEnded = fFalse;

	for (i = 0; (i < cChunk) && !fLineEnded; i ++)
		{
		clsgrchnkCollected++;
		pgrchunkext->lsgrchnk.pcont[i] = 0; 
		plsdn = plschunkcontext->pplsdnChunk[i];
		durTotal += DurFromRealDnode(plsdn);
		
		/* if we are in last dnode before cpLim there is possibility 
		that during break it was changed 
		so we  should rewrite dcp in chunk element and quit */
		if ((LSCP)(plsdn->cpLimOriginal) == cpLim)
			{
			plocchnk->plschnk[i].dcp = plsdn->dcp;
			fLineEnded = fTrue;
			}
		}

	/* fill in header  of groupchunkext   */
	pgrchunkext->plsdnFirst = plschunkcontext->pplsdnChunk[0];;
	pgrchunkext->plsdnLastUsed = plschunkcontext->pplsdnChunk[clsgrchnkCollected - 1];
	pgrchunkext->plsdnNext = pgrchunkext->plsdnLastUsed->plsdnNext;
	pgrchunkext->durTotal = durTotal;
	pgrchunkext->durTextTotal = durTotal;
	pgrchunkext->dupNonTextTotal = 0;
	pgrchunkext->cNonTextObjects = 0;
	pgrchunkext->cNonTextObjectsExpand = 0;
	pgrchunkext->lsgrchnk.clsgrchnk = clsgrchnkCollected;

	plschunkcontext->FGroupChunk = fTrue;

	if (pgrchunkext->Purpose == CollectSublinesForJustification || 
		pgrchunkext->Purpose == CollectSublinesForCompression)
		{
		Assert(clsgrchnkCollected > 0);
		pgrchunkext->durTrailing = 0;
		pgrchunkext->dcpTrailing = 0;
		plsdn = NULL;
		dcpTrailingDnode = 0;

		pgrchunkext->fClosingBorderStartsTrailing = fFalse;
		
		for (i = clsgrchnkCollected - 1; i >= 0; i--)
			{
			plsdn = plschunkcontext->pplsdnChunk[i];
			GetTrailInfoText(PdobjFromDnode(plsdn), plsdn->dcp,
				&dcpTrailingDnode, &durTrailingDnode);
			pgrchunkext->durTrailing += durTrailingDnode;
			pgrchunkext->dcpTrailing += dcpTrailingDnode;
			
			/* add opening border before previous dnode */
			if (i < (int) (clsgrchnkCollected - 1))
				pgrchunkext->durTrailing += plschunkcontext->pdurOpenBorderBefore[i +1];

			if (dcpTrailingDnode != 0) 
				/* add closing border after */
				pgrchunkext->durTrailing += plschunkcontext->pdurCloseBorderAfter[i];
			else
				{
				pgrchunkext->fClosingBorderStartsTrailing = 
					(plschunkcontext->pdurCloseBorderAfter[i] != 0);
				}
			
			if (plsdn->dcp != dcpTrailingDnode)
				break;
			
			}
		
		pgrchunkext->plsdnStartTrailing = plsdn;

		if (i == -1) i = 0;
		
		pgrchunkext->posichnkBeforeTrailing.ichnk = i;
		pgrchunkext->posichnkBeforeTrailing.dcp = plsdn->dcp - dcpTrailingDnode;
		}
	

	return lserrNone;
}

/* G E T  T R A I L I N G  I N F O  F O R  T E X T  G R O U P  C H U N K */
/*----------------------------------------------------------------------------
    %%Function: GetTrailingInfoForTextGroupChunk
    %%Contact: igorzv

Parameters:
	plsdnLastDnode		-	(IN) dnode where to start calculation of trailing area
	dcpLastDnode		-	(IN) dcp in this dnode
	iobjText			-	(IN) iobj of text
	pdurTrailing		-	(OUT) dur of trailing area in  group chunk
	pdcpTrailing		-	(OUT) dcp of trailing area in chunk
	pplsdnStartTrailing -	(OUT) dnode where trailing area starts
	pdcpStartTrailing-	(OUT) with pcDnodesTrailing defines last character in text before
								  trailing area
	pcDnodesTrailing	-	(OUT) number of text dnodes participates in trailing area
	pplsdnStartTrailingObject -(OUT) dnode on the upper level where trailing are starts
	pdcpStartTrailingObject	-(OUT) dcp in such dnode 
	pfClosingBorderStartsTrailing - (OUT) closing border located just before trailing area
----------------------------------------------------------------------------*/
	
LSERR GetTrailingInfoForTextGroupChunk
				(PLSDNODE plsdnLast, LSDCP dcpLastDnode, DWORD iobjText,
				 long* pdurTrailing, LSDCP* pdcpTrailing,
				 PLSDNODE* pplsdnStartTrailing, LSDCP* pdcpStartTrailing,
				 int* pcDnodesTrailing, PLSDNODE* pplsdnStartTrailingObject,
				 LSDCP* pdcpStartTrailingObject, BOOL* pfClosingBorderStartsTrailing)
	{
	PLSDNODE plsdn;
	long durTrailingDnode;
	LSDCP dcpTrailingDnode;
	BOOL fSuccessful;
	LSDCP dcpDnode;
	GROUPCHUNKITERATOR groupchunkiterator;
	LSCP cpLim;
	LSCP cpLimTrail;
	LSSUBL* plssubl;
	long durPrevClosingBorder = 0;

	*pdurTrailing = 0;
	*pdcpTrailing = 0;
	*pplsdnStartTrailing = plsdnLast;
	*pdcpStartTrailing = dcpLastDnode;
	*pcDnodesTrailing = 0;
	if (plsdnLast->dcp == dcpLastDnode)
		cpLim = plsdnLast->cpLimOriginal;
	else
		cpLim = plsdnLast->cpFirst + dcpLastDnode;
	
	CreateGroupChunkIterator(&groupchunkiterator, 
					CollectSublinesForTrailingArea, plsdnLast, 
					cpLim, fFalse);	

	plsdn = GetNextDnodeInGroupChunk(&groupchunkiterator, &fSuccessful);
	
	while(fSuccessful)
		{
		*pplsdnStartTrailing = plsdn;
		/* this procedure can be called before SetBreak so we should calculate 
			dcp of last dnode in chunk using cpLim */
		if (plsdn->cpLimOriginal > cpLim)
			dcpDnode = cpLim - plsdn->cpFirst;
		else
			dcpDnode = plsdn->dcp;
		*pdcpStartTrailing = dcpDnode;

		if (FIsDnodeReal(plsdn) && !FIsDnodeSplat(plsdn)) /* not a pen border or splat*/
			{
			if (IdObjFromDnode(plsdn) == iobjText) /* is text */
				{

				GetTrailInfoText(PdobjFromDnode(plsdn), dcpDnode,
					&dcpTrailingDnode, &durTrailingDnode);

				(*pcDnodesTrailing)++;

				if (dcpTrailingDnode == 0)
					{
					break;
					}
				
				*pdurTrailing += durTrailingDnode;
				*pdcpTrailing += dcpTrailingDnode;
				*pdcpStartTrailing -= dcpTrailingDnode;
				*pdurTrailing += durPrevClosingBorder;
				durPrevClosingBorder = 0;

				if (dcpDnode != dcpTrailingDnode)
					break;
				}
			else
				{
				/* object which did not submit subline for trailing */
				break;
				}
			
			}
		else
			{
			/* border or splat */
			if (FIsDnodeCloseBorder(plsdn))
				{
				durPrevClosingBorder = DurFromDnode(plsdn);
				}
			else
				{
				*pdurTrailing += DurFromDnode(plsdn);
				}
			*pdcpTrailing += plsdn->dcp;
			}

		plsdn = GetNextDnodeInGroupChunk(&groupchunkiterator, &fSuccessful);

		}

	*pfClosingBorderStartsTrailing = (durPrevClosingBorder != 0);

	if (*pcDnodesTrailing == 0)
		{
		*pplsdnStartTrailingObject = plsdnLast;
		*pdcpStartTrailingObject = dcpLastDnode;
		}
	else if (SublineFromDnode(*pplsdnStartTrailing) == 
		     SublineFromDnode(plsdnLast))
		{
		*pplsdnStartTrailingObject = *pplsdnStartTrailing;
		*pdcpStartTrailingObject = *pdcpStartTrailing;
		}
	/* the last dnode we've checked was on the lower level */
	else if (fSuccessful) /* and we actually stopped on it */
		{
		if ((*pplsdnStartTrailing)->dcp == *pdcpStartTrailing)
			cpLimTrail = (*pplsdnStartTrailing)->cpLimOriginal;
		else
			cpLimTrail = (*pplsdnStartTrailing)->cpFirst + *pdcpStartTrailing;

		plsdn = *pplsdnStartTrailing;
		plssubl = SublineFromDnode(plsdn);
		while (SublineFromDnode(plsdnLast) != plssubl)
			{
			plsdn = plssubl->plsdnUpTemp;
			Assert(FIsLSDNODE(plsdn));
			plssubl = SublineFromDnode(plsdn);
			}
		*pplsdnStartTrailingObject = plsdn;
		if (plsdn->cpLimOriginal > cpLimTrail)
			*pdcpStartTrailingObject = cpLimTrail - plsdn->cpFirst;
		else
			*pdcpStartTrailingObject = plsdn->dcp;
		}
	else
		{
		/* we went through all group chunk and the last dnode under investigation was on lower level */
		/* plsdn is dnode before group chunk */
		if (plsdn == NULL) /* there is nothing before group chunk */
			{
			*pplsdnStartTrailingObject = (SublineFromDnode(plsdnLast))->plsdnFirst;
			}
		else
			{
			*pplsdnStartTrailingObject = plsdn->plsdnNext;
			}
		Assert(FIsLSDNODE(*pplsdnStartTrailingObject));

		*pdcpStartTrailingObject = 0;
		}

	DestroyGroupChunkIterator(&groupchunkiterator);

	return lserrNone;
	}


/* A L L O C  C H U N K  A R R A Y S */
/*----------------------------------------------------------------------------
    %%Function: AllocChunkArrays
    %%Contact: igorzv

Parameters:
	plschunkcontext				-	(IN) chunk context
	plscbk						-	(IN) callbacks
	pols						-   (IN) pols for callbacks
	plsiobjcontext				-	(IN) pointer to a table of methods
----------------------------------------------------------------------------*/
LSERR AllocChunkArrays(PLSCHUNKCONTEXT plschunkcontext, LSCBK* plscbk, POLS pols,
					   PLSIOBJCONTEXT plsiobjcontext)
	{

	plschunkcontext->pplsdnChunk = plscbk->pfnNewPtr(pols, 
											sizeof(PLSDNODE)*limAllDNodes);
	plschunkcontext->pcont = plscbk->pfnNewPtr(pols, 
											sizeof(DWORD)*limAllDNodes);
	plschunkcontext->locchnkCurrent.plschnk = plscbk->pfnNewPtr(pols, 
											sizeof(LSCHNKE)*limAllDNodes);
	plschunkcontext->locchnkCurrent.ppointUvLoc = plscbk->pfnNewPtr(pols, 
											sizeof(POINTUV)*limAllDNodes);
	plschunkcontext->pfNonTextExpandAfter = plscbk->pfnNewPtr(pols, 
											sizeof(BOOL)*limAllDNodes);
	plschunkcontext->pplsdnNonText = plscbk->pfnNewPtr(pols, 
											sizeof(PLSDNODE)*limAllDNodes);
	plschunkcontext->pdurOpenBorderBefore = plscbk->pfnNewPtr(pols, 
											sizeof(LONG)*limAllDNodes);
	plschunkcontext->pdurCloseBorderAfter = plscbk->pfnNewPtr(pols, 
											sizeof(LONG)*limAllDNodes);

	plschunkcontext->cchnkMax = limAllDNodes;
	plschunkcontext->cNonTextMax = limAllDNodes;
	plschunkcontext->plscbk = plscbk;
	plschunkcontext->pols = pols;
	plschunkcontext->plsiobjcontext = plsiobjcontext;

	if (plschunkcontext->pplsdnChunk == NULL || plschunkcontext->pcont == NULL
		|| plschunkcontext->locchnkCurrent.plschnk == NULL
		|| plschunkcontext->locchnkCurrent.ppointUvLoc == NULL
		|| plschunkcontext->pfNonTextExpandAfter == NULL 
		|| plschunkcontext->pplsdnNonText == NULL
		||plschunkcontext->pdurOpenBorderBefore == NULL
		||plschunkcontext->pdurCloseBorderAfter == NULL
	   )
		{
		return lserrOutOfMemory;
		}
	else
		{
		return lserrNone;
		}

	}
/* G E T  U R  P E N  A T  B E G I N I N G  O F  L A S T  C H U N K */
/*----------------------------------------------------------------------------
    %%Function: GetUrPenAtBeginingOfLastChunk
    %%Contact: igorzv

Parameters:
	plschunkcontext				-	(IN) chunk context
	plsdnFirst					-	(IN) First dnode in a chunk (used for checks)
	plsdnLast					-	(IN) last dnode in subline
	point						-	(IN) point after last dnode
	purPen						-	(OUT) ur before chunk
----------------------------------------------------------------------------*/

LSERR GetUrPenAtBeginingOfLastChunk(PLSCHUNKCONTEXT plschunkcontext,PLSDNODE plsdnFirst,
									PLSDNODE plsdnLast,	POINTUV* ppoint,
									long* purPen)		
	{
	/* chunk must be already collected and has plsdnFirst as the first element */
	Assert(plschunkcontext->locchnkCurrent.clschnk != 0);
	Assert(!plschunkcontext->FGroupChunk);
	Assert(plschunkcontext->pplsdnChunk[0]== plsdnFirst);
	
	if (plschunkcontext->locchnkCurrent.clschnk == 0 ||
		plschunkcontext->FGroupChunk ||
		plschunkcontext->pplsdnChunk[0]!= plsdnFirst)
		return lserrInvalidParameter;

	
	/* calculate point before the last dnode */
	ppoint->u -= DurFromDnode(plsdnLast);
	ppoint->v -= DvrFromDnode(plsdnLast);

	/* go back until first dnode in chunk */
	while(plsdnLast != plsdnFirst)
		{
		plsdnLast = plsdnLast->plsdnPrev;
		Assert(FIsLSDNODE(plsdnLast));
		ppoint->u -= DurFromDnode(plsdnLast);
		ppoint->v -= DvrFromDnode(plsdnLast);
		}

	
	/* locate chunk  */
	if (!plschunkcontext->FLocationValid)
		{
		LocateChunk(plschunkcontext, plsdnFirst, LstflowFromDnode(plsdnFirst), ppoint);
		}
	
	*purPen = plschunkcontext->locchnkCurrent.lsfgi.urPen;
	return lserrNone;
	}

/* F I N D  P O I N T  O F F S E T   */
/*----------------------------------------------------------------------------
    %%Function: FindPointOffset
    %%Contact: igorzv

Parameters:
	plsdnFirst			-	(IN) dnode from the boundaries of which to calculate offset  
	lsdev				-	(IN) presentation or reference device 
	lstflowBase				-	(IN) text flow to use for calculation 
	Purpose				-	(IN) what sublines to take from a complex object 
	plsdnContainsPoint	-	(IN) dnode contains point 
	duInDnode,			-	(IN) offset in the dnode 
	pduOffset			-	(OUT) offset from the starting point 

----------------------------------------------------------------------------*/
void FindPointOffset(PLSDNODE plsdnFirst,	enum lsdevice lsdev,
			  LSTFLOW lstflowBase, COLLECTSUBLINES Purpose,	
			  PLSDNODE plsdnContainsPoint, long duInDnode,	
			  long* pduOffset)
	{
	PLSDNODE plsdnCurrent;
	PLSSUBL plssubl;
	LSTFLOW lstflow;
	LSCP cpFirstDnode;
	PLSSUBL* rgpsubl;
	long cSublines;
	long i;
	long duOffsetSubline;

	plssubl = SublineFromDnode(plsdnFirst);
	lstflow = LstflowFromSubline(plssubl);
	cpFirstDnode = plsdnContainsPoint->cpFirst;
	*pduOffset = 0;

	if (FParallelTflows(lstflow, lstflowBase))
		{
		for(plsdnCurrent = plsdnFirst; 
			plsdnCurrent->cpLimOriginal <= cpFirstDnode && (plsdnCurrent != plsdnContainsPoint);
			/* second check is to catch situation when plsdnContainsPoint has dcp = 0 */
			plsdnCurrent = plsdnCurrent->plsdnNext)
			{
			Assert(FIsLSDNODE(plsdnCurrent));
			if (lsdev == lsdevReference)
				{
				*pduOffset += DurFromDnode(plsdnCurrent);
				}
			else
				{
				Assert(lsdev == lsdevPres);
				*pduOffset += DupFromDnode(plsdnCurrent);
				}
			}

		Assert(FIsLSDNODE(plsdnCurrent));
		
		if (FIsDnodeReal(plsdnCurrent))
			rgpsubl = GetSubmittedSublines(plsdnCurrent, Purpose);
		else
			rgpsubl = NULL;

		if (rgpsubl == NULL)
			{
			Assert(plsdnCurrent == plsdnContainsPoint);
			*pduOffset += duInDnode;
			}
		else
			{
			cSublines = GetNumberSubmittedSublines(plsdnCurrent);
			
			/* if everything is correct we should always find subline in this loop,
			check (i < cSublines) is just to avoid infinite loop and catch situation in a Assert */
			for (i = 0; (i < cSublines) && !FDnodeInsideSubline(rgpsubl[i], plsdnContainsPoint); i++)
				{
				plssubl = rgpsubl[i];
				Assert(FIsLSSUBL(plssubl));
				for (plsdnCurrent = plssubl->plsdnFirst; 
					FDnodeBeforeCpLim(plsdnCurrent, plssubl->cpLim); 
					plsdnCurrent = plsdnCurrent->plsdnNext)
					{
					Assert(FIsLSDNODE(plsdnCurrent));
					if (lsdev == lsdevReference)
						{
						*pduOffset += DurFromDnode(plsdnCurrent);
						}
					else
						{
						Assert(lsdev == lsdevPres);
						*pduOffset += DupFromDnode(plsdnCurrent);
						}
					}
				}
				     

			
			Assert(i != cSublines);
			plssubl = rgpsubl[i];
			Assert(FIsLSSUBL(plssubl));

			FindPointOffset(plssubl->plsdnFirst, lsdev, lstflowBase,
							Purpose, plsdnContainsPoint, duInDnode,	
							&duOffsetSubline);

			*pduOffset += duOffsetSubline;

			}
		}
	else
		{
		for(plsdnCurrent = plssubl->plsdnLast; 
			plsdnCurrent->cpFirst > cpFirstDnode && (plsdnCurrent != plsdnContainsPoint);
			/* second check is to catch situation when plsdnContainsPoint has dcp = 0 */
			plsdnCurrent = plsdnCurrent->plsdnPrev)
			{
			Assert(FIsLSDNODE(plsdnCurrent));
			if (lsdev == lsdevReference)
				{
				*pduOffset += DurFromDnode(plsdnCurrent);
				}
			else
				{
				Assert(lsdev == lsdevPres);
				*pduOffset += DupFromDnode(plsdnCurrent);
				}
			}

		Assert(FIsLSDNODE(plsdnCurrent));

		if (FIsDnodeReal(plsdnCurrent))
			rgpsubl = GetSubmittedSublines(plsdnCurrent, Purpose);
		else
			rgpsubl = NULL;


		if (rgpsubl == NULL)
			{
			Assert(plsdnCurrent == plsdnContainsPoint);
			if (lsdev == lsdevReference)
				{
				*pduOffset += (DurFromDnode(plsdnCurrent) - duInDnode);
				}
			else
				{
				Assert(lsdev == lsdevPres);
				*pduOffset += (DupFromDnode(plsdnCurrent) - duInDnode);
				}
			}
		else
			{
			cSublines = GetNumberSubmittedSublines(plsdnCurrent);
			
			
			/* if everything is correct we should always find subline in this loop,
			check (i >= 0) is just to avoid infinite loop and catch situation in a Assert */
			for (i = cSublines - 1; (i >= 0) && !FDnodeInsideSubline(rgpsubl[i], plsdnContainsPoint); i--)
				{
				plssubl = rgpsubl[i];
				Assert(FIsLSSUBL(plssubl));
				for (plsdnCurrent = plssubl->plsdnFirst; 
					FDnodeBeforeCpLim(plsdnCurrent, plssubl->cpLim); 
					plsdnCurrent = plsdnCurrent->plsdnNext)
					{
					Assert(FIsLSDNODE(plsdnCurrent));
					if (lsdev == lsdevReference)
						{
						*pduOffset += DurFromDnode(plsdnCurrent);
						}
					else
						{
						Assert(lsdev == lsdevPres);
						*pduOffset += DupFromDnode(plsdnCurrent);
						}
					}
				}
			
			Assert(i >= 0);
			plssubl = rgpsubl[i];
			Assert(FIsLSSUBL(plssubl));

			FindPointOffset(plssubl->plsdnFirst, lsdev, lstflowBase,
							Purpose, plsdnContainsPoint, duInDnode,	
							&duOffsetSubline);

			*pduOffset += duOffsetSubline;

			}
		}

	}



/* D I S P O S E  C H U N K  A R R A Y S */
/*----------------------------------------------------------------------------
    %%Function: AllocChunkArrays
    %%Contact: igorzv

Parameters:
	plschunkcontext				-	(IN) chunk context
----------------------------------------------------------------------------*/
void DisposeChunkArrays(PLSCHUNKCONTEXT plschunkcontext)
	{
	if (plschunkcontext->pplsdnChunk != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pplsdnChunk);
	if (plschunkcontext->pcont != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pcont);
	if (plschunkcontext->locchnkCurrent.plschnk != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols, 
										  plschunkcontext->locchnkCurrent.plschnk);
	if (plschunkcontext->locchnkCurrent.ppointUvLoc != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols, 
										  plschunkcontext->locchnkCurrent.ppointUvLoc);
	if (plschunkcontext->pplsdnNonText != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pplsdnNonText);
	if (plschunkcontext->pfNonTextExpandAfter != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pfNonTextExpandAfter);
	if (plschunkcontext->pdurOpenBorderBefore != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pdurOpenBorderBefore);
	if (plschunkcontext->pdurCloseBorderAfter != NULL)
		plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pdurCloseBorderAfter);

	}

/* S E T  C H U N K  A R R A Y S  S I Z E   */
/*----------------------------------------------------------------------------
    %%Function: SetChunkArraysSize
    %%Contact: igorzv

Parameters:
	plschunkcontext				-	(IN) chunk context
	cchnkMax			-	(IN) new max size for array
----------------------------------------------------------------------------*/

static LSERR SetChunkArraysSize(PLSCHUNKCONTEXT plschunkcontext, DWORD cchnkMax)
{

/* arrays pfNonTextExpandAfter and pplsdnNonText should not be touched here:
   they are independable */

	plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pplsdnChunk);
	plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pcont);
	plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols, 
										  plschunkcontext->locchnkCurrent.plschnk);
	plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols, 
										  plschunkcontext->locchnkCurrent.ppointUvLoc);
	plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pdurOpenBorderBefore);
	plschunkcontext->plscbk->pfnDisposePtr(plschunkcontext->pols,
										  plschunkcontext->pdurCloseBorderAfter);


	/* create arrays for chunks  */
	plschunkcontext->pplsdnChunk = plschunkcontext->plscbk->pfnNewPtr(plschunkcontext->pols, 
											sizeof(PLSDNODE)*cchnkMax);
	plschunkcontext->pcont = plschunkcontext->plscbk->pfnNewPtr(plschunkcontext->pols, 
											sizeof(DWORD)*cchnkMax);
	plschunkcontext->locchnkCurrent.plschnk = plschunkcontext->plscbk->pfnNewPtr(plschunkcontext->pols, 
											sizeof(LSCHNKE)*cchnkMax);
	plschunkcontext->locchnkCurrent.ppointUvLoc = plschunkcontext->plscbk->pfnNewPtr(plschunkcontext->pols, 
											sizeof(POINTUV)*cchnkMax);
	plschunkcontext->pdurOpenBorderBefore = plschunkcontext->plscbk->pfnNewPtr(plschunkcontext->pols, 
											sizeof(LONG)*cchnkMax);
	plschunkcontext->pdurCloseBorderAfter = plschunkcontext->plscbk->pfnNewPtr(plschunkcontext->pols, 
											sizeof(LONG)*cchnkMax);


	if (plschunkcontext->pplsdnChunk == NULL || plschunkcontext->pcont == NULL
		|| plschunkcontext->locchnkCurrent.plschnk == NULL
		|| plschunkcontext->locchnkCurrent.ppointUvLoc == NULL
		|| plschunkcontext->pdurOpenBorderBefore == NULL
		|| plschunkcontext->pdurCloseBorderAfter == NULL
	   )
		return lserrOutOfMemory;

	plschunkcontext->cchnkMax = cchnkMax;

	return lserrNone;

}


/* I N C R E A S E  C H U N K  A R R A Y S  S I Z E   */
/*----------------------------------------------------------------------------
    %%Function: IncreaseChunkArrays
    %%Contact: igorzv

Parameters:
	plschunkcontext				-	(IN) chunk context

The difference from previous function is that we don't now final size 
and going to increase size step by step
----------------------------------------------------------------------------*/

static LSERR IncreaseChunkArrays(PLSCHUNKCONTEXT plschunkcontext)
{
/* arrays pfNonTextExpandAfter and pplsdnNonText should not be touched here:
   they are independable */

	DWORD cchnkMax;

	cchnkMax = plschunkcontext->cchnkMax + limAllDNodes;


	/* create arrays for chunks  */
	plschunkcontext->pplsdnChunk = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols, 
											plschunkcontext->pplsdnChunk,
											sizeof(PLSDNODE)*cchnkMax);
	plschunkcontext->pcont = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols,
											plschunkcontext->pcont, 
											sizeof(DWORD)*cchnkMax);
	plschunkcontext->locchnkCurrent.plschnk = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols, 
											plschunkcontext->locchnkCurrent.plschnk,
											sizeof(LSCHNKE)*cchnkMax);
	plschunkcontext->locchnkCurrent.ppointUvLoc = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols, 
											plschunkcontext->locchnkCurrent.ppointUvLoc,
											sizeof(POINTUV)*cchnkMax);
	plschunkcontext->pdurOpenBorderBefore = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols, 
											plschunkcontext->pdurOpenBorderBefore,
											sizeof(LONG)*cchnkMax);
	plschunkcontext->pdurCloseBorderAfter = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols, 
											plschunkcontext->pdurCloseBorderAfter,
											sizeof(LONG)*cchnkMax);

	if (plschunkcontext->pplsdnChunk == NULL || plschunkcontext->pcont == NULL
		|| plschunkcontext->locchnkCurrent.plschnk == NULL
		|| plschunkcontext->locchnkCurrent.ppointUvLoc == NULL
		|| plschunkcontext->pdurOpenBorderBefore == NULL
		|| plschunkcontext->pdurCloseBorderAfter == NULL
	   )
		return lserrOutOfMemory;

	plschunkcontext->cchnkMax = cchnkMax;

	return lserrNone;

}

/* D U P L I C A T E  C H U N K  C O N T E X T  */
/*----------------------------------------------------------------------------
    %%Function: DuplicateChunkContext
    %%Contact: igorzv

Parameters:
	plschunkcontextOld				-	(IN) chunk context to duplicate
	pplschunkcontextNew				-	(OUT) new chunk context 

----------------------------------------------------------------------------*/

LSERR DuplicateChunkContext(PLSCHUNKCONTEXT plschunkcontextOld, 
							PLSCHUNKCONTEXT* pplschunkcontextNew)
	{
	*pplschunkcontextNew = plschunkcontextOld->plscbk->pfnNewPtr(plschunkcontextOld->pols,
											sizeof(LSCHUNKCONTEXT));
	if (*pplschunkcontextNew == NULL)
		return lserrOutOfMemory;

	memcpy(*pplschunkcontextNew, plschunkcontextOld, sizeof(LSCHUNKCONTEXT));

	/* but we need to use new arrays */
	/* create arrays for chunks  */
	(*pplschunkcontextNew)->pplsdnChunk = (*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(PLSDNODE) * ((*pplschunkcontextNew)->cchnkMax));
	(*pplschunkcontextNew)->pcont = (*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(DWORD) * ((*pplschunkcontextNew)->cchnkMax));
	(*pplschunkcontextNew)->locchnkCurrent.plschnk =
					(*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(LSCHNKE) * ((*pplschunkcontextNew)->cchnkMax));
	(*pplschunkcontextNew)->locchnkCurrent.ppointUvLoc = 
					(*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(POINTUV) * ((*pplschunkcontextNew)->cchnkMax));
	(*pplschunkcontextNew)->pfNonTextExpandAfter = 
					(*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(BOOL) * ((*pplschunkcontextNew)->cNonTextMax));
	(*pplschunkcontextNew)->pplsdnNonText = 
					(*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(PLSDNODE) * ((*pplschunkcontextNew)->cNonTextMax));
	(*pplschunkcontextNew)->pdurOpenBorderBefore = 
					(*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(LONG) * ((*pplschunkcontextNew)->cchnkMax));
	(*pplschunkcontextNew)->pdurCloseBorderAfter = 
					(*pplschunkcontextNew)->plscbk->pfnNewPtr((*pplschunkcontextNew)->pols, 
											sizeof(LONG) * ((*pplschunkcontextNew)->cchnkMax));


	if ((*pplschunkcontextNew)->pplsdnChunk == NULL || (*pplschunkcontextNew)->pcont == NULL
		|| (*pplschunkcontextNew)->locchnkCurrent.plschnk == NULL
		|| (*pplschunkcontextNew)->locchnkCurrent.ppointUvLoc == NULL
		|| (*pplschunkcontextNew)->pfNonTextExpandAfter == NULL
		|| (*pplschunkcontextNew)->pplsdnNonText == NULL
		|| (*pplschunkcontextNew)->pdurOpenBorderBefore == NULL
		|| (*pplschunkcontextNew)->pdurCloseBorderAfter == NULL
	   )
		return lserrOutOfMemory;

	/* copy valid parts of the arrays */
	memcpy ((*pplschunkcontextNew)->pplsdnChunk, plschunkcontextOld->pplsdnChunk,
						plschunkcontextOld->locchnkCurrent.clschnk * sizeof(PLSDNODE));
	memcpy ((*pplschunkcontextNew)->pcont, plschunkcontextOld->pcont,
						plschunkcontextOld->locchnkCurrent.clschnk * sizeof(DWORD));
	memcpy ((*pplschunkcontextNew)->locchnkCurrent.plschnk, plschunkcontextOld->locchnkCurrent.plschnk,
						plschunkcontextOld->locchnkCurrent.clschnk * sizeof(LSCHNKE));
	memcpy ((*pplschunkcontextNew)->locchnkCurrent.ppointUvLoc, plschunkcontextOld->locchnkCurrent.ppointUvLoc,
						plschunkcontextOld->locchnkCurrent.clschnk * sizeof(POINTUV));
	memcpy ((*pplschunkcontextNew)->pfNonTextExpandAfter, plschunkcontextOld->pfNonTextExpandAfter,
						plschunkcontextOld->cNonTextMax * sizeof(BOOL));
	memcpy ((*pplschunkcontextNew)->pplsdnNonText, plschunkcontextOld->pplsdnNonText,
						plschunkcontextOld->cNonTextMax * sizeof(PLSDNODE));
	memcpy ((*pplschunkcontextNew)->pdurOpenBorderBefore, plschunkcontextOld->pdurOpenBorderBefore,
						plschunkcontextOld->locchnkCurrent.clschnk * sizeof(LONG));
	memcpy ((*pplschunkcontextNew)->pdurCloseBorderAfter, plschunkcontextOld->pdurCloseBorderAfter,
						plschunkcontextOld->locchnkCurrent.clschnk * sizeof(LONG));


	return lserrNone;

	}

/* D E S T R O Y  C H U N K  C O N T E X T  */
/*----------------------------------------------------------------------------
    %%Function: DestroyChunkContext
    %%Contact: igorzv

Parameters:
	plschunkcontext					-	(IN) chunk context to destroy

----------------------------------------------------------------------------*/

void DestroyChunkContext(PLSCHUNKCONTEXT plschunkcontext)
	{
	POLS pols = plschunkcontext->pols;
	LSCBK* plscbk = plschunkcontext->plscbk;
	DisposeChunkArrays(plschunkcontext);
	DebugMemset(plschunkcontext, 0xE9, sizeof(LSCHUNKCONTEXT));
	plscbk->pfnDisposePtr(pols, plschunkcontext);

	}


/* I N C R E A S E  G R O U P  C H U N K  N O N  T E X T  A R R A Y S  S I Z E   */
/*----------------------------------------------------------------------------
    %%Function: SetGroupChunkNonTextArraysSize
    %%Contact: igorzv

Parameters:
	plschunkcontext				-	(IN) chunk context

The difference from previous function is that we don't now final size 
and going to increase size step by step
----------------------------------------------------------------------------*/

static LSERR IncreaseGroupChunkNonTextArrays(PLSCHUNKCONTEXT plschunkcontext)
{

	DWORD cNonTextMax;

	cNonTextMax = plschunkcontext->cNonTextMax + limAllDNodes;


	/* create arrays for chunks  */
	plschunkcontext->pplsdnNonText = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols, 
											plschunkcontext->pplsdnNonText,
											sizeof(PLSDNODE)*cNonTextMax);
	plschunkcontext->pfNonTextExpandAfter = plschunkcontext->plscbk->pfnReallocPtr(plschunkcontext->pols,
											plschunkcontext->pfNonTextExpandAfter, 
											sizeof(BOOL)*cNonTextMax);

	if (plschunkcontext->pplsdnNonText == NULL || plschunkcontext->pfNonTextExpandAfter == NULL)
		return lserrOutOfMemory;

	plschunkcontext->cNonTextMax = cNonTextMax;

	return lserrNone;

}