windows-nt/Source/XPSP1/NT/windows/richedit/lssrc/dispmain.c

#include "dispmain.h"
#include "lsc.h"
#include "lsdnode.h"
#include "lstflow.h"
#include "lsline.h"
#include "lssubl.h"
#include "dispul.h"	
#include "lstfset.h"
#include "lssubset.h"
#include "dispmisc.h"
#include "dispi.h"
#include "dninfo.h"
#include "memory.h"
#include "port.h"


static LSERR DisplayDnode(PLSC plsc, PLSDNODE pdn, const POINT* pptOrg, POINTUV pt,
				UINT kdispmode,	LSTFLOW lstflow, const RECT* prectClip, 
				BOOL fDrawStrike, BOOL fDrawUnderline, long upLimUnderline);
				
static LSERR ShadeSubline(PLSSUBL plssubl, const POINT* pptOrg, UINT kdispmode,
						const RECT* prectClip, long upLimUnderline, long upLeftIndent);

static LSERR DrawBorders(PLSSUBL plssubl, const POINT* pptOrg, UINT kdispmode,
						const RECT* prectClip, long upLimUnderline, long upLeftIndent);

static long GetDupUnderline(long up, long dup, long upLimUnderline);

static BOOL FGetNeighboringOpeningBorder(PLSDNODE pdnClosingBorder, PLSDNODE pdnNext, POINTUV* pptStart, 
										LSCP cpLim,	LSTFLOW	lstflowMain,
										PLSDNODE* ppdnOpeningBorder, POINTUV* pptStartOpeningBorder);

#define FIsDnodeToShade(pdn, cpLim) 	(FDnodeBeforeCpLim(pdn, cpLim) && FIsDnodeReal(pdn) && 	\
									!(pdn)->u.real.lschp.fInvisible && (pdn)->u.real.lschp.fShade)

#define UpdateMaximum(a,b)		if ((a) < (b)) (a) = (b); else

#define FIsDnodeOpeningBorder(pdn, lstflowMain)	((pdn)->fOpenBorder ^ ((pdn)->plssubl->lstflow != (lstflowMain)))
#define FIsDnodeClosingBorder(pdn, lstflowMain)	(!FIsDnodeOpeningBorder(pdn, lstflowMain))




//    %%Function:	DisplaySublineCore
//    %%Contact:	victork
//
// 
//	Displays subline with shading, striking and underlining, merging consecutive underlined dnodes
//	
//	Logic to select underlining method:
//	
//	If (metrics_are_good)
//		Draw_by_fnDrawUnderline;
//	else
//		if (There_is_merging_going)
//			Draw_by_pfnDrawUnderlineAsText;
//		else
//			Draw_along_with_Display;

LSERR DisplaySublineCore(		
						PLSSUBL plssubl,			/* subline to display */
						const POINT* pptOrg, 		/*  (x,y) starting point */
						UINT kdispmode,				/*  transparent or opaque */
						const RECT* prectClip, 		/*  clipping rect (x,y) */
						long upLimUnderline,
						long upLeftIndent)
{
	LSERR 		lserr;
	LSCP		cpLim = plssubl->cpLimDisplay;
	PLSC		plsc = plssubl->plsc;
	LSTFLOW		lstflowMain = plssubl->lstflow;
	BOOL 		fCollectVisual = plsc->plslineDisplay->fCollectVisual;

	LSSTRIKEMETRIC lsstrikemetric;

	//	Underline merge group - normal scenario: we first count dnodes willing to participate 
	//	in merging looking ahead, then draw them, then underline them as a whole
	
	PLSDNODE pdnFirstInGroup = NULL;			/* First dnode in Underline merge group */
	int 	cdnodesLeftInGroup = 0;				/* these are not displayed yet */
	int 	cdnodesToUnderline = 0;				/* these are already displayed */
	BOOL 	fGoodUnderline = fFalse;			/* is there metric for UL */
	LSULMETRIC lsulmetric;						/* merge metric info (if fGoodUnderline) */
	long 	upUnderlineStart = 0;				/* Starting point for the group */
	BOOL 	fMergeUnderline = fFalse;			/* There is more then one dnode in the group */

	BOOL 	fUnderlineWithDisplay, fStrikeWithDisplay;

	POINTUV		pt;
	PLSDNODE	pdn;

	FLineValid(plsc->plslineDisplay, plsc);					// Assert the display context is valid
	
	Assert(plssubl->plsdnUpTemp == NULL);					// against displaying accepted sublines

	if (fCollectVisual)
		{
		CreateDisplayTree(plssubl);
		}

	if (plsc->plslineDisplay->AggregatedDisplayFlags & fPortDisplayShade)
		{
		lserr = ShadeSubline(plssubl, pptOrg, kdispmode, prectClip, upLimUnderline, upLeftIndent);
		if (lserr != lserrNone) return lserr;
		}

	pt.u = upLeftIndent;						
	pt.v = 0;
	
	pdn = AdvanceToFirstDnode(plssubl, lstflowMain, &pt);

	while (FDnodeBeforeCpLim(pdn, cpLim))
		{

		if (pdn->klsdn == klsdnReal && !pdn->u.real.lschp.fInvisible)
			{	
			/* Real dnode */
				
			fStrikeWithDisplay = fFalse;
			if (pdn->u.real.lschp.fStrike)
				{
				BOOL fGoodStrike;
				lserr = GetStrikeMetric(plsc, pdn, lstflowMain, &lsstrikemetric, &fGoodStrike);
				if (lserr != lserrNone) return lserr;
				fStrikeWithDisplay = !fGoodStrike;
				}

			fUnderlineWithDisplay = fFalse;
			if (pdn->u.real.lschp.fUnderline && pt.u < upLimUnderline)	
				{	
				/* Node has underline */
				
				if (cdnodesLeftInGroup  == 0) 
					{ 
					/* There are no on-going UL group */
					/* Find out how many dnodes will participate in the merge and what metric to use */
					
					lserr = GetUnderlineMergeMetric(plsc, pdn, pt, upLimUnderline, lstflowMain, 
										cpLim, &lsulmetric, &cdnodesLeftInGroup , &fGoodUnderline);
					if (lserr != lserrNone) return lserr;
					fMergeUnderline = (cdnodesLeftInGroup  > 1);
					cdnodesToUnderline = 0;
					}

				if (!fGoodUnderline)				
					fUnderlineWithDisplay = !fMergeUnderline;
				else
					fUnderlineWithDisplay = fFalse;

				if (!fUnderlineWithDisplay)
					{
					if (cdnodesToUnderline == 0)
						{	
						/* Mark starting point of underline merge */
						
						pdnFirstInGroup = pdn;
						upUnderlineStart = pt.u;
						}
						
					/* Add to pending UL dnode count */
					
					++cdnodesToUnderline;	
					}
					
				// current dnode will be displayed shortly - consider it done
				
				--cdnodesLeftInGroup ;		
				}							
			
			lserr = DisplayDnode(plsc, pdn, pptOrg, pt, kdispmode, lstflowMain, prectClip,
									fStrikeWithDisplay, fUnderlineWithDisplay, upLimUnderline);
			if (lserr != lserrNone) return lserr;
			
			if (pdn->u.real.lschp.fStrike && !fStrikeWithDisplay)
				{
				lserr = StrikeDnode(plsc, pdn, pptOrg, pt, &lsstrikemetric, kdispmode, prectClip, 
										upLimUnderline, lstflowMain);
				if (lserr != lserrNone) return lserr;
				}
				
			/* Draw any pending UL after last dnode in group has been drawn */
			
			if (cdnodesToUnderline != 0 && cdnodesLeftInGroup  == 0)
				{
				lserr = DrawUnderlineMerge(plsc, pdnFirstInGroup, pptOrg, 
									cdnodesToUnderline, upUnderlineStart, fGoodUnderline, &lsulmetric, 
									kdispmode, prectClip, upLimUnderline, lstflowMain);
				if (lserr != lserrNone) return lserr;
				
				cdnodesToUnderline = 0;
				}
			}
			
		pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
		}
		
	if (fCollectVisual)
		{
		// call display method for submitting dnodes
		
		pt.u = upLeftIndent;						
		pt.v = 0;
		
		pdn = AdvanceToFirstSubmittingDnode(plssubl, lstflowMain, &pt);

		while (FDnodeBeforeCpLim(pdn, cpLim))
			{
			lserr = DisplayDnode(plsc, pdn, pptOrg, pt, kdispmode, lstflowMain, prectClip,
									fFalse, fFalse, upLimUnderline);
			if (lserr != lserrNone) return lserr;
			
			pdn = AdvanceToNextSubmittingDnode(pdn, lstflowMain, &pt);
			}
		}
		
	if (plsc->plslineDisplay->AggregatedDisplayFlags & fPortDisplayBorder)
		{
		lserr = DrawBorders(plssubl, pptOrg, kdispmode, prectClip, upLimUnderline, upLeftIndent);
		if (lserr != lserrNone) return lserr;
		}

	if (fCollectVisual)
		{
		// destroy display tree

		DestroyDisplayTree(plssubl);
		}

	return lserrNone;			
}

//    %%Function:	DisplayDnode
//    %%Contact:	victork

static LSERR DisplayDnode(PLSC plsc, PLSDNODE pdn, const POINT* pptOrg, POINTUV pt,
						UINT kdispmode,	LSTFLOW lstflowMain, const RECT* prectClip,
						BOOL fDrawStrike, BOOL fDrawUnderline, long upLimUnderline)
{
	PDOBJ 	pdobj;
	DISPIN 	dispin;

	pdobj = pdn->u.real.pdobj;

	dispin.plschp = &(pdn->u.real.lschp);
	dispin.plsrun = pdn->u.real.plsrun;
	
	dispin.kDispMode = kdispmode;
	dispin.lstflow = pdn->plssubl->lstflow;								
	dispin.prcClip = (RECT*) prectClip;

	dispin.fDrawUnderline = fDrawUnderline;
	dispin.fDrawStrikethrough = fDrawStrike;
	
	dispin.heightsPres = pdn->u.real.objdim.heightsPres;
	dispin.dup = pdn->u.real.dup;
	
	dispin.dupLimUnderline = GetDupUnderline(pt.u, dispin.dup, upLimUnderline);

	if (dispin.lstflow != lstflowMain)
		{
		// Dnode lstflow is opposite to lstflowMain - get real starting point
		
		pt.u = pt.u + dispin.dup - 1;

		// Partial underlining can only happen on the top level
		
		Assert(dispin.dupLimUnderline == 0 || dispin.dupLimUnderline == dispin.dup);
		}

	pt.v += pdn->u.real.lschp.dvpPos;
	
	LsPointXYFromPointUV(pptOrg, lstflowMain, &pt, &(dispin.ptPen));
	
	
	return (*plsc->lsiobjcontext.rgobj[pdn->u.real.lschp.idObj].lsim.pfnDisplay)(pdobj, &dispin);
}


//    %%Function:	ShadeSubline
//    %%Contact:	victork

LSERR ShadeSubline(PLSSUBL plssubl,				/* subline to shade */
					const POINT* pptOrg, 		/*  (x,y) starting point */
					UINT kdispmode,				/*  transparent or opaque */
					const RECT* prectClip, 		/*  clipping rect (x,y) */
					long upLimUnderline,
					long upLeftIndent)
{
	LSERR 		lserr;
	LSCP		cpLim = plssubl->cpLimDisplay;
	PLSC		plsc = plssubl->plsc;
	PLSLINE		plsline = plsc->plslineDisplay;
	LSTFLOW		lstflowMain = plssubl->lstflow;

	POINTUV		pt;
	PLSDNODE	pdn;

	HEIGHTS		heightsLineWithAddedSpace;
	HEIGHTS		heightsLineWithoutAddedSpace;
	OBJDIM		objdimSubline;
	
	POINT		ptStart;
	PLSRUN		plsrunFirst, plsrunPrevious;
	long		upStart;
	long		dupInclTrail, dupExclTrail;
	HEIGHTS		heightsRunsInclTrail;
	HEIGHTS		heightsRunsExclTrail;

	BOOL	 	fInterruptShading;
	BOOL 		fCollectVisual = plsc->plslineDisplay->fCollectVisual;


	heightsLineWithAddedSpace.dvAscent = plsline->dvpAbove + plsline->lslinfo.dvpAscent;
	heightsLineWithAddedSpace.dvDescent = plsline->dvpBelow + plsline->lslinfo.dvpDescent;
	heightsLineWithAddedSpace.dvMultiLineHeight = dvHeightIgnore;
	
	heightsLineWithoutAddedSpace.dvAscent = plsline->lslinfo.dvpAscent;
	heightsLineWithoutAddedSpace.dvDescent = plsline->lslinfo.dvpDescent;
	heightsLineWithoutAddedSpace.dvMultiLineHeight = dvHeightIgnore;
	
	lserr = LssbGetObjDimSubline(plssubl, &lstflowMain, &objdimSubline);
	if (lserr != lserrNone) return lserr;
	
	if (fCollectVisual)
		{
		// shade submitting dnodes - pretend they are on the top level, no merging for them
		
		pt.u = upLeftIndent;						
		pt.v = 0;
		
		pdn = AdvanceToFirstSubmittingDnode(plssubl, lstflowMain, &pt);

		while (FDnodeBeforeCpLim(pdn, cpLim))
			{
			if (FIsDnodeToShade(pdn, cpLim))
				{
				LsPointXYFromPointUV(pptOrg, lstflowMain, &pt, &ptStart);
				dupInclTrail = pdn->u.real.dup;
				dupExclTrail = GetDupUnderline(pt.u, dupInclTrail, upLimUnderline);
				lserr = (*plsc->lscbk.pfnShadeRectangle)(plsc->pols, pdn->u.real.plsrun, &ptStart, 
									&heightsLineWithAddedSpace,	&heightsLineWithoutAddedSpace, 
									&(objdimSubline.heightsPres),
									&(pdn->u.real.objdim.heightsPres), &(pdn->u.real.objdim.heightsPres),
									dupExclTrail, dupInclTrail, 
									lstflowMain, kdispmode, prectClip);
				if (lserr != lserrNone) return lserr;
				}
			
			pdn = AdvanceToNextSubmittingDnode(pdn, lstflowMain, &pt);
			}
		}


	pt.u = upLeftIndent;						
	pt.v = 0;
	
	pdn = AdvanceToFirstDnode(plssubl, lstflowMain, &pt);

	while (FDnodeBeforeCpLim(pdn, cpLim)  && !FIsDnodeToShade(pdn, cpLim))
		{
		pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
		}

	// next loop will do one shading merge at a run

	while (FDnodeBeforeCpLim(pdn, cpLim))
		{
		// pdn is the first dnode to participate in the shade merge
		// initialize the merge with this dnode data
		
		LsPointXYFromPointUV(pptOrg, lstflowMain, &pt, &ptStart);
		plsrunFirst = pdn->u.real.plsrun;
		upStart = pt.u;
		
		heightsRunsInclTrail = pdn->u.real.objdim.heightsPres;

		// What should we have in heightsRunsExclTrail if all shading is in trailing spaces?
		// I decided to put heights of the first run there for convenience sake
		// Client can check for dupExclTrail == 0.
		
		heightsRunsExclTrail = heightsRunsInclTrail;

		// We will now append to the merge as many dnodes as possible
		// The loop will stop when dnode doesn't need to be shaded - while condition
		// or if callback says two dnodes are not to be shaded together - break inside

		plsrunPrevious = pdn->u.real.plsrun;
		pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
	
		while (FIsDnodeToShade(pdn, cpLim))
			{
			lserr = (*plsc->lscbk.pfnFInterruptShade)(plsc->pols, plsrunPrevious,pdn->u.real.plsrun,
														&fInterruptShading);
			if (lserr != lserrNone) return lserr;

			if (fInterruptShading)
				{
				break;
				}
				
			plsrunPrevious = pdn->u.real.plsrun;

			UpdateMaximum(heightsRunsInclTrail.dvAscent, pdn->u.real.objdim.heightsPres.dvAscent);
			UpdateMaximum(heightsRunsInclTrail.dvDescent, pdn->u.real.objdim.heightsPres.dvDescent);
			UpdateMaximum(heightsRunsInclTrail.dvMultiLineHeight, pdn->u.real.objdim.heightsPres.dvMultiLineHeight);

			if (pt.u < upLimUnderline)
				{
				UpdateMaximum(heightsRunsExclTrail.dvAscent, pdn->u.real.objdim.heightsPres.dvAscent);
				UpdateMaximum(heightsRunsExclTrail.dvDescent, pdn->u.real.objdim.heightsPres.dvDescent);
				UpdateMaximum(heightsRunsExclTrail.dvMultiLineHeight, pdn->u.real.objdim.heightsPres.dvMultiLineHeight);
				}

			pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
			}
			
		// Merge is stopped - time to draw
		
		dupInclTrail = pt.u - upStart;
		dupExclTrail = GetDupUnderline(upStart, dupInclTrail, upLimUnderline);

		lserr = (*plsc->lscbk.pfnShadeRectangle)(plsc->pols, plsrunFirst, &ptStart, 
									&heightsLineWithAddedSpace,	&heightsLineWithoutAddedSpace, 
									&(objdimSubline.heightsPres),
									&heightsRunsExclTrail, &heightsRunsInclTrail, 
									dupExclTrail, dupInclTrail, 
									lstflowMain, kdispmode, prectClip);
		if (lserr != lserrNone) return lserr;

		// get to the beginning of the next shade merge
		
		while (FDnodeBeforeCpLim(pdn, cpLim)  && !FIsDnodeToShade(pdn, cpLim))
			{
			pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
			}
		
		}
		
	return lserrNone;
}

//    %%Function:	GetDupUnderline
//    %%Contact:	victork
//
// Calculate dup of underlined part (of dnode). Deals with situations when upLimUnderline is
//  outside of [upStart, upStart + dup]

static long GetDupUnderline(long upStart, long dup, long upLimUnderline)

{
	long dupLimUnderline;
	
	dupLimUnderline = upLimUnderline - upStart;
	
	if (dupLimUnderline >= dup)
		{
		dupLimUnderline = dup;
		}
	else if (dupLimUnderline < 0)
		{
		dupLimUnderline = 0;
		}

	return dupLimUnderline;
}

//    %%Function:	DrawBorders
//    %%Contact:	victork

LSERR DrawBorders(PLSSUBL plssubl,
					const POINT* pptOrg, 		/*  (x,y) starting point */
					UINT kdispmode,				/*  transparent or opaque */
					const RECT* prectClip, 		/*  clipping rect (x,y) */
					long upLimUnderline,
					long upLeftIndent)
{
	LSERR 		lserr;
	LSCP		cpLim = plssubl->cpLimDisplay;
	PLSC		plsc = plssubl->plsc;
	PLSLINE		plsline = plsc->plslineDisplay;
	LSTFLOW		lstflowMain = plssubl->lstflow;

	HEIGHTS		heightsLineWithAddedSpace;
	HEIGHTS		heightsLineWithoutAddedSpace;
	OBJDIM		objdimSubline;
	HEIGHTS		heightsRuns;

	long		upStart, dupBorder, dupBordered;
	POINT		ptStart;
	PLSRUN		plsrunOpeningBorder, plsrunClosingBorder;
	POINTUV		pt, ptAfterClosingBorder;
	PLSDNODE	pdn, pdnPrev, pdnClosingBorder, pdnAfterClosingBorder;

	BOOL	 	fClosingOpeningBorderSequenceFound;
	PLSDNODE	pdnNextOpeningBorder;
	POINTUV		ptStartNextOpeningBorder;
	BOOL	 	fInterruptBorder;

	heightsLineWithAddedSpace.dvAscent = plsline->dvpAbove + plsline->lslinfo.dvpAscent;
	heightsLineWithAddedSpace.dvDescent = plsline->dvpBelow + plsline->lslinfo.dvpDescent;
	heightsLineWithAddedSpace.dvMultiLineHeight = dvHeightIgnore;
	
	heightsLineWithoutAddedSpace.dvAscent = plsline->lslinfo.dvpAscent;
	heightsLineWithoutAddedSpace.dvDescent = plsline->lslinfo.dvpDescent;
	heightsLineWithoutAddedSpace.dvMultiLineHeight = dvHeightIgnore;
	
	lserr = LssbGetObjDimSubline(plssubl, &lstflowMain, &objdimSubline);
	if (lserr != lserrNone) return lserr;
	
	pt.u = upLeftIndent;						
	pt.v = 0;
	
	pdn = AdvanceToFirstDnode(plssubl, lstflowMain, &pt);

	// next loop will draw one border at a run

	while (FDnodeBeforeCpLim(pdn, cpLim))
		{
		// first find an opening border

		while (FDnodeBeforeCpLim(pdn, cpLim) && !FIsDnodeBorder(pdn))
			{
			pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
			}

		if (FDnodeBeforeCpLim(pdn, cpLim))
			{
			// border is found - it must be an opening one

			Assert(FIsDnodeOpeningBorder(pdn, lstflowMain));

			// remember the starting point and border width
			
			upStart = pt.u;
			LsPointXYFromPointUV(pptOrg, lstflowMain, &pt, &ptStart);
			dupBorder = pdn->u.pen.dup;

			// take lsrun from the first bordered run
			
			pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);

			Assert(FDnodeBeforeCpLim(pdn, cpLim) && FIsDnodeReal(pdn));

			plsrunOpeningBorder = pdn->u.real.plsrun;

			// start collecting max run height
			
			heightsRuns = pdn->u.real.objdim.heightsPres;

			// now look for an closing border to draw, collecting max run height
			// loop will be ended by break
			
			for (;;)
				{
				// find a border

				pdnPrev = NULL;

				while (FDnodeBeforeCpLim(pdn, cpLim) && !FIsDnodeBorder(pdn))
					{
					if (FIsDnodeReal(pdn))
						{
						UpdateMaximum(heightsRuns.dvAscent, pdn->u.real.objdim.heightsPres.dvAscent);
						UpdateMaximum(heightsRuns.dvDescent, pdn->u.real.objdim.heightsPres.dvDescent);
						UpdateMaximum(heightsRuns.dvMultiLineHeight, pdn->u.real.objdim.heightsPres.dvMultiLineHeight);
						}
						
					pdnPrev = pdn;
					pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
					}
					
				Assert(FDnodeBeforeCpLim(pdn, cpLim));
				
				// border is found - it must be a closing one
				// Sequence opening border - closing border is prohibited by formatting

				Assert(pdnPrev != NULL);						
				Assert(FIsDnodeReal(pdnPrev));
				Assert(FIsDnodeClosingBorder(pdn, lstflowMain));
				Assert(pdn->u.pen.dup == dupBorder);

				pdnClosingBorder = pdn;
				plsrunClosingBorder = pdnPrev->u.real.plsrun;
				
				pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
				
				ptAfterClosingBorder = pt;
				pdnAfterClosingBorder = pdn;

				// check for the "surplus borders" situation: closing border and opening border of the same
				// type brought together by submitting sublines. (Hard to check at formatting time)
				
				// It can be more complicated if there are bordered trailing spaces between the two borders
				// (Trailing spaces can happen in the middle of the line in Bidi case). The problem is
				// that border is moved away from trailing spaces at SetBreak time. We try to restore 
				// bordering of trailing spaces when they are in the middle of bordered line below.
				
				fClosingOpeningBorderSequenceFound = FGetNeighboringOpeningBorder(pdnClosingBorder, pdn, &pt, 
											cpLim, lstflowMain,	&pdnNextOpeningBorder, &ptStartNextOpeningBorder);
				
				if (fClosingOpeningBorderSequenceFound)
					{
					pdn = pdnNextOpeningBorder;
					pt = ptStartNextOpeningBorder;
					
					pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);

					Assert(FDnodeBeforeCpLim(pdn, cpLim) && FIsDnodeReal(pdn));

					lserr = (*plsc->lscbk.pfnFInterruptBorder)(plsc->pols, plsrunClosingBorder, 
										pdn->u.real.plsrun,	&fInterruptBorder);
					if (lserr != lserrNone) return lserr;
					
					if (!fInterruptBorder)
						{
						// Client decided against interrupting border here. These two border dnodes
						// will be ignored. Space reserved for them by formatting will be left empty.
						// Continue seeking for closing border starting from pdn
						
						continue;
						}
					}
					
				// No special situation - we are ready to display
				
				// Well, we are almost ready. Word doesn't normally draw borders in trailing spaces, 
				// just reserve space for them and leave this space blank. In FE Word, however,  
				// borders are drawn if underlining of trailing spaces is required.
				// We hack in the following way: Borders in trailing area are deleted after formatting.
				// If there are a border which opens in text and closes in trailing spaces, it is moved
				// to the left to exclude trailing spaces. If the fUnderlineTrailSpacesRM flag is on 
				// the "moved" border is marked and now have to be displayed up to upLimUnderline.
				// Yes, it's bad, it will appear painted over already displayed spaces (queries!) and 
				// what about a scenario when not all trailing spaces are bordered? We know, we know.
				// Word can even get a "negative" border with a negative advance field.

				dupBordered = ptAfterClosingBorder.u - upStart;
				
				if (pdnClosingBorder->fBorderMovedFromTrailingArea)
					{
					Assert(ptAfterClosingBorder.u <= upLimUnderline);
					
					dupBordered = upLimUnderline - upStart;
					}
					
				lserr = (*plsc->lscbk.pfnDrawBorder)(plsc->pols, plsrunOpeningBorder, &ptStart, 
										&heightsLineWithAddedSpace,	&heightsLineWithoutAddedSpace, 
										&(objdimSubline.heightsPres), &heightsRuns,
										dupBorder, dupBordered,
										lstflowMain, kdispmode, prectClip);
				if (lserr != lserrNone) return lserr;
				
				// maybe we peeped ahead checking for the surplus borders - return
				
				pdn = pdnAfterClosingBorder;
				pt = ptAfterClosingBorder;
				break;
				}
			}

			// Previous border is drawn, start looking for the next one from pdn.
		}
		
	return lserrNone;
}


// Find an opening border neighboring pdnClosingBorder broght together by submitting sublines. 
// Ignore trailing spaces that lost their borders during SetBreak - their heights will be ignored.

// Input: 	pdnClosingBorder
//			pdnNext - next to pdnClosingBorder (in visual order)
//			ptStart - starting poing of pdnNext (in visual order)
//			cpLim and lstflowMain
// Output:	pdnOpeningBorder and ptStartOpeningBorder


static BOOL FGetNeighboringOpeningBorder(PLSDNODE pdnClosingBorder, PLSDNODE pdnNext, POINTUV* pptStart, 
										LSCP cpLim,	LSTFLOW	lstflowMain,
										PLSDNODE* ppdnOpeningBorder, POINTUV* pptStartOpeningBorder)
{
	PLSDNODE	pdn;
	POINTUV		pt;

	pdn = pdnNext;
	pt = *pptStart;
	
	// skip spaces that were bordered once
	// not sure about spaces, but what else could be skipped?
	
	while (FDnodeBeforeCpLim(pdn, cpLim) && FIsDnodeReal(pdn) && pdn->u.real.lschp.fBorder)
		{
		pdn = AdvanceToNextDnode(pdn, lstflowMain, &pt);
		}

	if (!FDnodeBeforeCpLim(pdn, cpLim))
		{
		return fFalse;
		}

	// looking for an opening border from another subline

	if (FIsDnodeOpeningBorder(pdn, lstflowMain) && pdn->plssubl != pdnClosingBorder->plssubl)
		{
		*ppdnOpeningBorder = pdn;
		*pptStartOpeningBorder = pt;
		return fTrue;
		}

	return fFalse;
}

	
// N.B. 
//	Interruption of underlining/shading logic by invisible dnode is OK, because we are sure that no
//		underlining/shading is allowed in preprinted forms.