#include "dispul.h"
#include "lsc.h"    
#include "lsdnode.h"
#include "lstfset.h"
#include "lsulinfo.h"
#include "lsstinfo.h"
#include "dninfo.h"
#include "dispmisc.h"

#include "zqfromza.h"


/* GetULMetric output */
typedef struct {
    UINT kul;                   
    DWORD cNumberOfLines;       
    __int64 dvpUnderlineOriginOffset;       
    __int64 dvpFirstUnderlineOffset;    
    __int64 dvpFirstUnderlineSize;      
    __int64 dvpGapBetweenLines;     
    __int64 dvpSecondUnderlineSize; 
} ULMETRIC;

/* weighted sums for averaging */
typedef struct {
    __int64 dupSum;                     // the sum of weights
    
    __int64 dvpFirstUnderlineOffset;        // unnormalized values -
    __int64 dvpFirstUnderlineSize;      
    __int64 dvpGapBetweenLines;         // divide them by dupSum    
    __int64 dvpSecondUnderlineSize;     // to get weighted averages
} ULMETRICSUM;

//    %%Function:   InitULMetricSums
//    %%Contact:    victork
//
// Neighbouring dnodes with good metrics and same baseline get averaged.
// We use weighted average with dnode width for weights.
// If the first dnode to participate in averaging happens to have zero width (almost never),
// we arbitrarily change width to 1. This hack changes result very slightly and in a very rare case,
// but simplify the logic considerably.

static void InitULMetricSums(long dup, const ULMETRIC* pulm, ULMETRICSUM* pulmSum)
{
    Assert(dup >= 0);
    
    if (dup == 0)
        {
        dup = 1;
        }
    pulmSum->dvpFirstUnderlineOffset = Mul64 (pulm->dvpFirstUnderlineOffset, dup);
    pulmSum->dvpFirstUnderlineSize = Mul64 (pulm->dvpFirstUnderlineSize, dup);
    pulmSum->dvpGapBetweenLines = Mul64 (pulm->dvpGapBetweenLines, dup);
    pulmSum->dvpSecondUnderlineSize = Mul64 (pulm->dvpSecondUnderlineSize, dup);

    pulmSum->dupSum = dup;
}

//    %%Function:   AddToULMetricSums
//    %%Contact:    victork
//
static void AddToULMetricSums(long dup, const ULMETRIC* pulm, ULMETRICSUM* pulmSum)
{
    Assert(dup >= 0);
    
    /* Add to running sums */

    pulmSum->dvpFirstUnderlineOffset += Mul64 (pulm->dvpFirstUnderlineOffset, dup);
    pulmSum->dvpFirstUnderlineSize += Mul64 (pulm->dvpFirstUnderlineSize, dup);
    pulmSum->dvpGapBetweenLines += Mul64 (pulm->dvpGapBetweenLines, dup);
    pulmSum->dvpSecondUnderlineSize += Mul64 (pulm->dvpSecondUnderlineSize, dup);

    pulmSum->dupSum += dup;
}

//    %%Function:   GetAveragedMetrics
//    %%Contact:    victork
//
static void GetAveragedMetrics(const ULMETRICSUM* pulmSum, LSULMETRIC* pulm)
{
    __int64 dupSum = pulmSum->dupSum;
    
    Assert(dupSum > 0);
    
    /* divide by sum of weights */
    
    pulm->dvpFirstUnderlineOffset = (long) Div64 (pulmSum->dvpFirstUnderlineOffset + Div64 (dupSum, 2), dupSum);
    pulm->dvpFirstUnderlineSize = (long) Div64 (pulmSum->dvpFirstUnderlineSize + Div64 (dupSum, 2), dupSum);
    pulm->dvpGapBetweenLines = (long) Div64 (pulmSum->dvpGapBetweenLines + Div64 (dupSum, 2), dupSum);
    pulm->dvpSecondUnderlineSize = (long) Div64 (pulmSum->dvpSecondUnderlineSize + Div64 (dupSum, 2), dupSum);

    Assert (pulm->dvpFirstUnderlineOffset == Div64 (pulmSum->dvpFirstUnderlineOffset + Div64 (dupSum, 2), dupSum));
    Assert (pulm->dvpFirstUnderlineSize == Div64 (pulmSum->dvpFirstUnderlineSize + Div64 (dupSum, 2), dupSum));
    Assert (pulm->dvpGapBetweenLines == Div64 (pulmSum->dvpGapBetweenLines + Div64 (dupSum, 2), dupSum));
    Assert (pulm->dvpSecondUnderlineSize == Div64 (pulmSum->dvpSecondUnderlineSize + Div64 (dupSum, 2), dupSum));
}

//    %%Function:   GetULMetric
//    %%Contact:    victork
//
/*
 *      Normally, when underlining goes on the under (negative, descent) side,
 *          dvpFirstUnderlineOffset >= 0.
 *      However, underlining on the other side is possible too, (vertical Japanese)
 *
 *      Notice that offsets are from dnode baseline, not from the current baseline, so
 *      underline can be both above current baseline and on the under side for raised dnodes.
 *
 *      We have to be compatible with Word meaning what's good for him should be good for us (pity).
 *      For example, Word sometimes allow the lower UL to be below descent.
 */

static LSERR GetULMetric(PLSC plsc, PLSDNODE pdn, LSTFLOW lstflow,
                        BOOL* pfUnderlineFromBelow, ULMETRIC* pulm, BOOL *pfGood)
{
    LSULINFO lsulinfo;
    LSERR   lserr;
    long    dvpUnderlineLim;

    lserr = (*plsc->lscbk.pfnGetRunUnderlineInfo)(plsc->pols, pdn->u.real.plsrun,
                                                    &(pdn->u.real.objdim.heightsPres), lstflow,
                                                    &lsulinfo);
    if (lserr != lserrNone) return lserr;

    pulm->kul = lsulinfo.kulbase;
    pulm->cNumberOfLines = lsulinfo.cNumberOfLines;
    
    pulm->dvpFirstUnderlineSize = lsulinfo.dvpFirstUnderlineSize;

    *pfUnderlineFromBelow = (lsulinfo.dvpFirstUnderlineOffset >= lsulinfo.dvpUnderlineOriginOffset);

    if (*pfUnderlineFromBelow)
        {
        pulm->dvpFirstUnderlineOffset = lsulinfo.dvpFirstUnderlineOffset;
        pulm->dvpUnderlineOriginOffset = lsulinfo.dvpUnderlineOriginOffset;
        dvpUnderlineLim = pdn->u.real.objdim.heightsPres.dvDescent + pdn->u.real.lschp.dvpPos;
        }
    else
        {
        pulm->dvpFirstUnderlineOffset = -lsulinfo.dvpFirstUnderlineOffset;
        pulm->dvpUnderlineOriginOffset = -lsulinfo.dvpUnderlineOriginOffset;
        dvpUnderlineLim = pdn->u.real.objdim.heightsPres.dvAscent + 1 - pdn->u.real.lschp.dvpPos;
        }

    *pfGood = pulm->dvpFirstUnderlineSize > 0 &&
                (dvpUnderlineLim == 0 || pulm->dvpFirstUnderlineOffset < dvpUnderlineLim);
    
    if (lsulinfo.cNumberOfLines == 2)
        {
        pulm->dvpGapBetweenLines = lsulinfo.dvpGapBetweenLines;
        pulm->dvpSecondUnderlineSize = lsulinfo.dvpSecondUnderlineSize;
        
        *pfGood = *pfGood && pulm->dvpSecondUnderlineSize > 0;
        }
    else
    	{
    	Assert (lsulinfo.cNumberOfLines == 1);
    	
        pulm->dvpGapBetweenLines = 0;
        pulm->dvpSecondUnderlineSize = 0;
        };
   	   

    if (!*pfGood)
        {
        pulm->dvpUnderlineOriginOffset = 0;     // to provide good input to DrawUnderlineAsText
        }

    // dvpFirstUnderlineOffset was relative to local baseline until this moment, it is relative
    //  to the UnderlineOrigin from now on. (because we average runs with the same UnderlineOrigin)
    pulm->dvpFirstUnderlineOffset -= pulm->dvpUnderlineOriginOffset;

	// The notion of bad metrics was introduced in Word to deal with particular, now obsolete, printers.
	// Word doesn't support them any more, other clients never cared about them.
	// We drop the support for them now too.
	// The assignment below makes a lot of code in dispul.c and dispmain.c unneeded or unreachable.
	// Callback pfnDrawUnderlineAsText will never be called now. Input parameter fUnderline to 
	// pfnDrawTextRun is now always False.
	// Now is not the time to make big changes, maybe later.
	
	*pfGood = fTrue;
    
    return lserrNone;
}

//    %%Function:   GetUnderlineOrigin
//    %%Contact:    victork
//
/* normal and raised text are in the same group, lowered texts doesn't mix */

// Note: dvpUnderlineOriginOffset is relative to the local baseline, positive means down the page
//          in case of fUnderlineFromBelow - bigger means lower.
// dvpUnderlineOrigin is relative to the current baseline, negative means down the page
//          in case of fUnderlineFromBelow - bigger means higher (sign changed).
//
static void GetUnderlineOrigin(PLSDNODE pdn, BOOL fUnderlineFromBelow, long dvpUnderlineOriginOffset,
                            long* pdvpSubscriptOffset, long* pdvpUnderlineOrigin)

{
    if (fUnderlineFromBelow)
        {
        *pdvpSubscriptOffset = pdn->u.real.lschp.dvpPos;
        *pdvpUnderlineOrigin = pdn->u.real.lschp.dvpPos - dvpUnderlineOriginOffset;
        }
    else
        {
        *pdvpSubscriptOffset = -pdn->u.real.lschp.dvpPos;
        *pdvpUnderlineOrigin = -pdn->u.real.lschp.dvpPos - dvpUnderlineOriginOffset;
        }
        
    if (*pdvpSubscriptOffset > 0)
        {
        *pdvpSubscriptOffset = 0;       // put all superscripts in the baseline group
        }
    
    return;
}

//    %%Function:   GetUnderlineMergeMetric
//    %%Contact:    victork
//
/* For aesthetics, we try to underline dnodes (typically text) on the same side of
    the baseline (normal text and superscripts are considered to be on the
    same side of the baseline, versus subscripts, which are on the other side) with one
    continuous underline in even thickness. The underline metric used is the
    average from all those dnodes which are at the lowest height in the
    merge group. Merge is sometimes not possible because some dnodes may have
    bad underline metric. The following rules describe the merge decision
    under all possible scenarios. The dnodes in question are all on the same
    side of the baseline, i.e, there is never a merge of underline if it involes
    crossing the baseline.

Rules for merging underlined dnodes on the same side of the baseline

A. current: good Metric, new dnode: good metric
                                Merge?      Metric Used
    new dnode same height   :   yes         average
    new dnode lower         :   yes         new dnode
    new dnode higher        :   yes         current

B. current: good Metric, new dnode: bad metric
                                Merge?      Metric Used
    new dnode same height   :   no
    new dnode lower         :   no
    new dnode higher        :   yes         current

C. current: bad Metric, new dnode: good metric
                                Merge?      Metric Used
    new dnode same height   :   no
    new dnode lower         :   yes         new dnode
    new dnode higher        :   no

B. current: bad Metric, new dnode: bad metric
                                Merge?      Metric Used (baseline only)
    new dnode same height   :   no
    new dnode lower         :   yes         new dnode
    new dnode higher        :   yes         current

*/
LSERR GetUnderlineMergeMetric(PLSC plsc, PLSDNODE pdn, POINTUV pt, long upLimUnderline,
                    LSTFLOW lstflow, LSCP cpLimBreak, LSULMETRIC* pulmMerge, int* pcdnodes, BOOL* pfGoodMerge)
{
    LSERR       lserr;
    
    long        dupNew;
    long        dvpUnderlineOriginMerge, dvpUnderlineOriginNew;
    long        dvpSubscriptOffsetNew, dvpSubscriptOffsetMerge;
    BOOL        fGoodNew;
    BOOL        fUnderlineFromBelowMerge, fUnderlineFromBelowNew;
    ULMETRIC    ulm;
    ULMETRICSUM ulmSum;
    UINT        kulMerge;               
    DWORD       cNumberOfLinesMerge;

    lserr = GetULMetric(plsc, pdn, lstflow, &fUnderlineFromBelowMerge, &ulm, pfGoodMerge);
    if (lserr != lserrNone) return lserr;

    *pcdnodes = 1;  /* Counter for number of dnodes participationg in UL merge */
        
    kulMerge = ulm.kul;
    cNumberOfLinesMerge = ulm.cNumberOfLines;

    /* Initialize running sums with current dnode */
    dupNew = pdn->u.real.dup;
    InitULMetricSums(dupNew, &ulm, &ulmSum);

    GetUnderlineOrigin(pdn, fUnderlineFromBelowMerge, (long)ulm.dvpUnderlineOriginOffset,
                        &dvpSubscriptOffsetMerge, &dvpUnderlineOriginMerge);
        
    /* March down display list to collect merge participants */
    pdn = AdvanceToNextDnode(pdn, lstflow, &pt);


    /* Iterate till end of list, or end of UL */
    while (FDnodeBeforeCpLim(pdn, cpLimBreak)
            && pdn->klsdn == klsdnReal
            && !pdn->u.real.lschp.fInvisible
            && pdn->u.real.lschp.fUnderline && pt.u < upLimUnderline
            )
        {   
        /* loop invariance:
         *  *pcdnodes are merged already, merge ends at pt.u,
         *  dvpUnderlineOriginMerge reflect lowest dnode in merge group,
         *  other variables ending with Merge - other Merge info
         *  ulmSum contains ulm info of Merge, entries in it are not normalized yet.
         */

        lserr = GetULMetric(plsc, pdn, lstflow, &fUnderlineFromBelowNew, &ulm, &fGoodNew);
        if (lserr != lserrNone) return lserr;

        /* break if new dnode has different underline type or position */
        
        GetUnderlineOrigin(pdn, fUnderlineFromBelowNew, (long)ulm.dvpUnderlineOriginOffset,
                                &dvpSubscriptOffsetNew, &dvpUnderlineOriginNew);

        if (ulm.kul != kulMerge ||
                ulm.cNumberOfLines != cNumberOfLinesMerge ||
                dvpSubscriptOffsetNew != dvpSubscriptOffsetMerge ||
                fUnderlineFromBelowNew != fUnderlineFromBelowMerge)
            {
            break;
            }

        /* Type and position are the same - try to extend merge */
        
        dupNew = pdn->u.real.dup;

        if (dvpUnderlineOriginNew < dvpUnderlineOriginMerge)    
            {                                   /* new dnode lower - previous metrics is irrelevant     */
            if (*pfGoodMerge && !fGoodNew)
                break;                          /* except we won't change from good to bad          */

            dvpUnderlineOriginMerge = dvpUnderlineOriginNew;
            *pfGoodMerge = fGoodNew;
            if (fGoodNew)                       /* New good metrics - */
                {                               /* restart running sums from this dnode */      
                InitULMetricSums(dupNew, &ulm, &ulmSum);
                }
            }

        else if (dvpUnderlineOriginNew > dvpUnderlineOriginMerge)
            {                                   /* new dnode higher - new metrics is irrelevant     */
            if (!*pfGoodMerge && fGoodNew)
                break;                          /* except we won't throw away good for bad      */
            }
            /* NB We are not adding contribution of higher dnode to running sums */

        else                                    /* new dnode the same height */
            if (*pfGoodMerge && fGoodNew)
                {
                /* Add contribution of current dnode to running sums */
                AddToULMetricSums(dupNew, &ulm, &ulmSum);
                }
            else                                /* dvpUnderlineOriginNew == dvpUnderlineOriginMerge && */
                break;                          /* !both good */

        /* Advance to next dnode */
        ++*pcdnodes;
        pdn = AdvanceToNextDnode(pdn, lstflow, &pt);
        }


    pulmMerge->kul = kulMerge;
    pulmMerge->cNumberOfLines = cNumberOfLinesMerge;
    
    if (*pfGoodMerge)
        {
        GetAveragedMetrics(&ulmSum, pulmMerge);
        }

    if (!fUnderlineFromBelowMerge)
        {
        pulmMerge->dvpFirstUnderlineOffset = -pulmMerge->dvpFirstUnderlineOffset;
        dvpUnderlineOriginMerge = -dvpUnderlineOriginMerge;
        }

    pulmMerge->vpUnderlineOrigin = pt.v + dvpUnderlineOriginMerge;
    
    return lserrNone;
}

//    %%Function:   DrawUnderlineMerge
//    %%Contact:    victork
//
LSERR DrawUnderlineMerge(PLSC plsc, PLSDNODE pdn, const POINT* pptOrg, int cdnodes, long upUnderlineStart,
                        BOOL fgoodmetric, const LSULMETRIC* pulm, UINT kdispmode,
                        const RECT* prectclip, long upLimUnderline, LSTFLOW lstflow)

{
/*  pdn is the first of cdnodes dnodes, merged and averaged by LSULMetric. Now we cut this merge into
 *  smaller ones if client wants interruption. Merge here means this smaller merge.
 */
    LSERR   lserr;
    POINTUV ptUnderlineStart[2];
    long    dvpUnderlineSize[2];
    long    dup = 0;
    
    BOOL    fInterruptUnderline;
    BOOL    fFirstNode = TRUE;
    PLSRUN  plsrunFirstInMerge, plsrunPrevious, plsrunCurrent = NULL;
    LSCP    cpLastInPrevious, cpFirstInCurrent = 0;
    LSDCP   dcpCurrent = 0;
    
    int     cLines, i;

    POINT   ptXY;
    POINTUV ptDummy = {0,0};
    
    cLines = (fgoodmetric && pulm->cNumberOfLines == 2) ? 2 : 1;

    ptUnderlineStart[0].u = upUnderlineStart;

    if (fgoodmetric)
        ptUnderlineStart[0].v = pulm->vpUnderlineOrigin - pulm->dvpFirstUnderlineOffset;
    else
        ptUnderlineStart[0].v = pulm->vpUnderlineOrigin;

    dvpUnderlineSize[0] = pulm->dvpFirstUnderlineSize;

    if (cLines == 2)
        {
        ptUnderlineStart[1].u = upUnderlineStart;
        ptUnderlineStart[1].v = ptUnderlineStart[0].v - pulm->dvpFirstUnderlineSize -
                                                        pulm->dvpGapBetweenLines;
        dvpUnderlineSize[1] = pulm->dvpSecondUnderlineSize;
        }

    plsrunFirstInMerge = pdn->u.real.plsrun;

    while (cdnodes >= 0)    /* cdnodes is at least 1 coming in */
        {
        Assert(FIsDnodeReal(pdn));
        /* Check to flush out pending UL */
        if (fFirstNode)
            {
            fFirstNode = FALSE;
            fInterruptUnderline = FALSE;
            plsrunCurrent = pdn->u.real.plsrun;
            cpFirstInCurrent = pdn->cpFirst;
            dcpCurrent = pdn->dcp;
            }
        else if (cdnodes != 0)
            {
            plsrunPrevious = plsrunCurrent;
            cpLastInPrevious = cpFirstInCurrent + dcpCurrent - 1;
            plsrunCurrent = pdn->u.real.plsrun;
            cpFirstInCurrent = pdn->cpFirst;
            dcpCurrent = pdn->dcp;
            lserr = (*plsc->lscbk.pfnFInterruptUnderline)(plsc->pols, plsrunPrevious, cpLastInPrevious,
                                plsrunCurrent, cpFirstInCurrent, &fInterruptUnderline);
            if (lserr != lserrNone) return lserr;
            }
        else                                        /* we've come to the last one */
            fInterruptUnderline = TRUE;

        if (fInterruptUnderline)
            {   
            if (ptUnderlineStart[0].u + dup > upLimUnderline)
                {
                dup = upLimUnderline - ptUnderlineStart[0].u;
                }

            Assert(dup >= 0);                       /* upLimUnderline should not change */

            if (fgoodmetric)
                for (i = 0; i < cLines; ++i)
                    {
                    LsPointXYFromPointUV(pptOrg, lstflow, &ptUnderlineStart[i], &ptXY);

                    lserr = (*plsc->lscbk.pfnDrawUnderline)(plsc->pols, plsrunFirstInMerge, pulm->kul,
                                    &ptXY, dup, dvpUnderlineSize[i], lstflow, kdispmode, prectclip);
                    if (lserr != lserrNone) return lserr;
                    }
            else
                {
                LsPointXYFromPointUV(pptOrg, lstflow, &ptUnderlineStart[0], &ptXY);
                
                lserr = (*plsc->lscbk.pfnDrawUnderlineAsText)(plsc->pols, plsrunFirstInMerge, &ptXY,
                                                                dup, kdispmode, lstflow, prectclip);
                if (lserr != lserrNone) return lserr;
                }

            /* reset states to start with current dnode */
            ptUnderlineStart[0].u += dup;
            if (cLines == 2) ptUnderlineStart[1].u += dup;
            dup = 0;
            plsrunFirstInMerge = pdn->u.real.plsrun;
            }
            
        dup += pdn->u.real.dup;
        --cdnodes;
        if (cdnodes > 0)
            {
            pdn = AdvanceToNextDnode(pdn, lstflow, &ptDummy);
            }
        }
    return lserrNone;
}

//    %%Function:   GetStrikeMetric
//    %%Contact:    victork
//
LSERR GetStrikeMetric(PLSC plsc, PLSDNODE pdn, LSTFLOW lstflow, LSSTRIKEMETRIC* pstm, BOOL* pfgood)
{
    LSSTINFO lsstinfo;
    LSERR lserr;
    long dvpAscent = pdn->u.real.objdim.heightsPres.dvAscent;               // dvpUppermost
    long dvpDescent = -pdn->u.real.objdim.heightsPres.dvDescent + 1;        // dvpLowest

    lserr = (*plsc->lscbk.pfnGetRunStrikethroughInfo)(plsc->pols, pdn->u.real.plsrun,
                                        &(pdn->u.real.objdim.heightsPres), lstflow, &lsstinfo);
    if (lserr != lserrNone) return lserr;

    pstm->cNumberOfLines = lsstinfo.cNumberOfLines;
    pstm->kul = lsstinfo.kstbase;

    if (lsstinfo.cNumberOfLines == 2)
        {
        *pfgood = lsstinfo.dvpLowerStrikethroughOffset  >= dvpDescent
                && lsstinfo.dvpLowerStrikethroughSize  > 0
                && lsstinfo.dvpUpperStrikethroughOffset > lsstinfo.dvpLowerStrikethroughOffset  + lsstinfo.dvpLowerStrikethroughSize
                && lsstinfo.dvpUpperStrikethroughSize > 0
                && lsstinfo.dvpUpperStrikethroughOffset + lsstinfo.dvpUpperStrikethroughSize <= dvpAscent;
        if (*pfgood)
            {
            pstm->dvp1stSSSize = lsstinfo.dvpLowerStrikethroughSize;
            pstm->dvp1stSSOffset = lsstinfo.dvpLowerStrikethroughOffset;
            pstm->dvp2ndSSSize = lsstinfo.dvpUpperStrikethroughSize;
            pstm->dvp2ndSSOffset = lsstinfo.dvpUpperStrikethroughOffset;
            }
        }
    else
        {
        *pfgood = lsstinfo.dvpLowerStrikethroughOffset  >= dvpDescent
                && lsstinfo.dvpLowerStrikethroughSize  > 0
                && lsstinfo.dvpLowerStrikethroughOffset  + lsstinfo.dvpLowerStrikethroughSize  <= dvpAscent;
        if (*pfgood)
            {
            pstm->dvp1stSSSize = lsstinfo.dvpLowerStrikethroughSize;
            pstm->dvp1stSSOffset = lsstinfo.dvpLowerStrikethroughOffset;
            }
        }
    return lserrNone;
}

//    %%Function:   StrikeDnode
//    %%Contact:    victork
//
LSERR StrikeDnode(PLSC plsc, PLSDNODE pdn, const POINT* pptOrg, POINTUV pt, const LSSTRIKEMETRIC* pstm,
                    UINT kdispmode, const RECT* prectclip, long upLimUnderline, LSTFLOW lstflow)
{

    LSERR lserr = lserrNone;
    
    long    dup;
    POINT   ptXY;


    if (pt.u < upLimUnderline)
        {
        dup = pdn->u.real.dup;
        if (pt.u + dup > upLimUnderline) dup = upLimUnderline - pt.u;

        pt.v += pdn->u.real.lschp.dvpPos + pstm->dvp1stSSOffset;
        LsPointXYFromPointUV(pptOrg, lstflow, &pt, &ptXY);
        
        lserr = (*plsc->lscbk.pfnDrawStrikethrough)(plsc->pols, pdn->u.real.plsrun, pstm->kul,
                            &ptXY, dup, pstm->dvp1stSSSize, lstflow, kdispmode, prectclip);

        if (lserr == lserrNone && pstm->cNumberOfLines == 2)
            {
            pt.v += pstm->dvp2ndSSOffset - pstm->dvp1stSSOffset;
            LsPointXYFromPointUV(pptOrg, lstflow, &pt, &ptXY);
            
            lserr = (*plsc->lscbk.pfnDrawStrikethrough)(plsc->pols, pdn->u.real.plsrun, pstm->kul,
                                &ptXY, dup, pstm->dvp2ndSSSize, lstflow, kdispmode, prectclip);
            }
        }

    return lserr;

}

// Note:    Lstfow and BiDi
// Lstfow used in this file is always lstflow of the main subline.
// It doesn't matter if no sublines are submitted and looks logical for submitted dnodes.