/*************************************************************************\
* Module Name: EngStroke.c
*
* EngStrokePath for bitmap simulations, plus its kith.
*
* Created: 5-Apr-91
* Author: Paul Butzi
*
* Copyright (c) 1990-1999 Microsoft Corporation
*
\**************************************************************************/

#include "precomp.hxx"
#include "solline.hxx"
#include "engline.hxx"

// #define DEBUG_ENGSTROK

// Style array for alternate style (alternates one pixel on, one pixel off):

STYLEPOS gaspAlternateStyle[] = { 1 };

// Array to compute ROP masks:

LONG aiLineMix[] = {
    AND_ZERO   | XOR_ONE,
    AND_ZERO   | XOR_ZERO,
    AND_NOTPEN | XOR_NOTPEN,
    AND_NOTPEN | XOR_ZERO,
    AND_ZERO   | XOR_NOTPEN,
    AND_PEN    | XOR_PEN,
    AND_ONE    | XOR_ONE,
    AND_ONE    | XOR_PEN,
    AND_PEN    | XOR_ONE,
    AND_PEN    | XOR_ZERO,
    AND_ONE    | XOR_NOTPEN,
    AND_ONE    | XOR_ZERO,
    AND_PEN    | XOR_NOTPEN,
    AND_ZERO   | XOR_PEN,
    AND_NOTPEN | XOR_ONE,
    AND_NOTPEN | XOR_PEN
};

static CHUNK mask1[] = {
    0xffffffff, 0xffffff7f, 0xffffff3f, 0xffffff1f,
    0xffffff0f, 0xffffff07, 0xffffff03, 0xffffff01,
    0xffffff00, 0xffff7f00, 0xffff3f00, 0xffff1f00,
    0xffff0f00, 0xffff0700, 0xffff0300, 0xffff0100,
    0xffff0000, 0xff7f0000, 0xff3f0000, 0xff1f0000,
    0xff0f0000, 0xff070000, 0xff030000, 0xff010000,
    0xff000000, 0x7f000000, 0x3f000000, 0x1f000000,
    0x0f000000, 0x07000000, 0x03000000, 0x01000000,
    0x00000000,
};

static CHUNK mask4[] = {
    0xffffffff,
    0xffffff0f,
    0xffffff00,
    0xffff0f00,
    0xffff0000,
    0xff0f0000,
    0xff000000,
    0x0f000000,
    0x00000000,
};

static CHUNK mask8[] = {
    0xffffffff,
    0xffffff00,
    0xffff0000,
    0xff000000,
    0x00000000,
};

static CHUNK mask16[] = {
    0xffffffff,
    0xffff0000,
    0x00000000,
};

static CHUNK mask24[] = {
    0xffffff00,
    0x00ffffff,
    0x0000ffff,
    0x000000ff,
    0x00000000,
};

static CHUNK mask32[] = {
    0xffffffff,
    0x00000000,
};

static CHUNK maskpel1[] = {
    0x00000080, 0x00000040, 0x00000020, 0x00000010,
    0x00000008, 0x00000004, 0x00000002, 0x00000001,
    0x00008000, 0x00004000, 0x00002000, 0x00001000,
    0x00000800, 0x00000400, 0x00000200, 0x00000100,
    0x00800000, 0x00400000, 0x00200000, 0x00100000,
    0x00080000, 0x00040000, 0x00020000, 0x00010000,
    0x80000000, 0x40000000, 0x20000000, 0x10000000,
    0x08000000, 0x04000000, 0x02000000, 0x01000000,
    0x00000000,
};

static CHUNK maskpel4[] = {
    0x000000f0,
    0x0000000f,
    0x0000f000,
    0x00000f00,
    0x00f00000,
    0x000f0000,
    0xf0000000,
    0x0f000000,
    0x00000000,
};

static CHUNK maskpel8[] = {
    0x000000ff,
    0x0000ff00,
    0x00ff0000,
    0xff000000,
    0x00000000,
};

static CHUNK maskpel16[] = {
    0x0000ffff,
    0xffff0000,
    0x00000000,
};

static CHUNK maskpel24[] = {
    0x00000000,
    0x00000000,
    0xff000000,
    0xffff0000,
};

static CHUNK maskpel32[] = {
    0xffffffff,
    0x00000000,
};

// { Pointer to array of start masks,
//   Pointer to array of pixel masks,
//   # of pels per chunk (power of 2)
//   # of bits per pel
//   log2(pels per chunk)
//   pels per chunk - 1 }

BMINFO gabminfo[] = {
    { NULL,    NULL,        0,  0,  0,  0  },   // BMF_DEVICE
    { mask1,   maskpel1,    32, 1,  5,  31 },   // BMF_1BPP
    { mask4,   maskpel4,    8,  4,  3,  7  },   // BMF_4BPP
    { mask8,   maskpel8,    4,  8,  2,  3  },   // BMF_8BPP
    { mask16,  maskpel16,   2,  16, 1,  1  },   // BMF_16BPP
    { mask24,  maskpel24,   0,  0, -1,  0  },   // BMF_24BPP
    { mask32,  maskpel32,   1,  32, 0,  0  },   // BMF_32BPP
};

#if (BMF_1BPP != 1L)
error Invalid value for BMF_1BPP
#endif

#if (BMF_4BPP != 2L)
error Invalid value for BMF_4BPP
#endif

#if (BMF_8BPP != 3L)
error Invalid value for BMF_8BPP
#endif

#if (BMF_16BPP != 4L)
error Invalid value for BMF_16BPP
#endif

#if (BMF_24BPP != 5L)
error Invalid value for BMF_24BPP
#endif

#if (BMF_32BPP != 6L)
error Invalid value for BMF_32BPP
#endif



/******************************Public*Routine******************************\
* BOOL bStrokeCosmetic(pso, ppo, eco, pbo, pla, mix)
*
* Strokes the path.
*
* History:
*  20-Mar-1991 -by- Paul Butzi
* Wrote it.
\**************************************************************************/

BOOL bStrokeCosmetic(
SURFACE*   pSurf,
PATHOBJ*   ppo,
CLIPOBJ*   pco,
BRUSHOBJ*  pbo,
LINEATTRS* pla,
MIX        mix)
{
    STYLEPOS  aspLeftToRight[STYLE_MAX_COUNT];
    STYLEPOS  aspRightToLeft[STYLE_MAX_COUNT];
    LINESTATE ls;

// Verify that things are as they should be:

    ASSERTGDI(pbo->iSolidColor != 0xFFFFFFFF, "Expect solid cosmetic pen");
    ASSERTGDI(!(pla->fl & LA_GEOMETRIC) && !(ppo->fl & PO_BEZIERS),
              "Unprocessable path");

    FLONG fl = 0;

// Look after styling initialization:

    if (pla->fl & LA_ALTERNATE)
    {
        ls.bStartGap      = 0;                      // First pel is a dash
        ls.cStyle         = 1;                      // Size of style array
        ls.xStep          = 1;                      // x-styled step size
        ls.yStep          = 1;                      // y-styled step size
        ls.spTotal        = 1;                      // Sum of style array
        ls.spTotal2       = 2;                      // Twice the sum
        ls.aspRightToLeft = &gaspAlternateStyle[0]; // Right-to-left array
        ls.aspLeftToRight = &gaspAlternateStyle[0]; // Left-to-right array
        ls.spNext         = HIWORD(pla->elStyleState.l) & 1;
                                                    // Light first pixel if
                                                    //   a multiple of 2
        ls.xyDensity      = 1;                      // Each 'dot' is one pixel
                                                    //   long
        fl               |= FL_STYLED;
    }
    else if (pla->pstyle != (FLOAT_LONG*) NULL)
    {
        ASSERTGDI(pla->cstyle <= STYLE_MAX_COUNT, "Style array too large");

        {
            HDEV hdev = ((SURFACE *)pSurf)->hdev();

            if (hdev == 0)
            {
            // It is a pretty common mistake made by driver writers
            // (I've made it several times myself) to call EngStrokePath
            // on a temporary bitmap that it forgot to EngAssociateSurface.

                WARNING("Can't get at the physical device information!\n");
                WARNING("I'll bet the display/printer driver forgot to call");
                WARNING("EngAssociateSurface for a bitmap it created, and");
                WARNING("is now asking us to draw styled lines on it (we");
                WARNING("need the device's style information).\n");
                RIP("Please call EngAssociateSurface on the bitmap.");

            // Assume some defaults:

                ls.xStep     = 1;
                ls.yStep     = 1;
                ls.xyDensity = 3;
            }
            else
            {
            // We need the PDEV style information so that we can draw
            // the styles with the correct length dashes:

                PDEVOBJ po(hdev);

                ls.xStep     = po.xStyleStep();
                ls.yStep     = po.yStyleStep();
                ls.xyDensity = po.denStyleStep();

                ASSERTGDI(ls.xyDensity != 0,
                          "Invalid denStyleStep supplied by the device!");
            }
        }

        fl               |= FL_STYLED;
        ls.cStyle         = pla->cstyle;
        ls.bStartGap      = (pla->fl & LA_STARTGAP) > 0;
        ls.aspRightToLeft = aspRightToLeft;
        ls.aspLeftToRight = aspLeftToRight;

        FLOAT_LONG* pstyle  = pla->pstyle;
        STYLEPOS*   pspDown = &ls.aspRightToLeft[ls.cStyle - 1];
        STYLEPOS*   pspUp   = &ls.aspLeftToRight[0];

        ls.spTotal = 0;

        while (pspDown >= &ls.aspRightToLeft[0])
        {
            ASSERTGDI(pstyle->l > 0 && pstyle->l <= STYLE_MAX_VALUE,
                      "Illegal style array value");

            *pspDown    = pstyle->l * ls.xyDensity;
            *pspUp      = *pspDown;
            ls.spTotal += *pspDown;

            pspUp++;
            pspDown--;
            pstyle++;
        }

        ls.spTotal2 = 2 * ls.spTotal;

    // Compute starting style position (this is guaranteed not to overflow):

        ls.spNext = HIWORD(pla->elStyleState.l) * ls.xyDensity +
                    LOWORD(pla->elStyleState.l);

    // Do some normalizing:

        if (ls.spNext < 0)
        {
            RIP("Someone left style state negative");
            ls.spNext = 0;
        }

        if (ls.spNext >= ls.spTotal2)
            ls.spNext %= ls.spTotal2;
    }

    // Get device all warmed up and ready to go

    LONG   lOldStyleState = pla->elStyleState.l;
    ULONG  ulFormat       = pSurf->iFormat();
    LONG   lDelta         = pSurf->lDelta() / (LONG)sizeof(CHUNK);
    CHUNK* pchBits        = (CHUNK*)pSurf->pvScan0();

    BMINFO* pbmi = &gabminfo[ulFormat];
    CHUNK  chOriginalColor = pbo->iSolidColor;

    switch (ulFormat)
    {
    case BMF_1BPP:
        chOriginalColor |= (chOriginalColor << 1);
        chOriginalColor |= (chOriginalColor << 2);
        // fall thru
    case BMF_4BPP:
        chOriginalColor |= (chOriginalColor << 4);
        // fall thru
    case BMF_8BPP:
        chOriginalColor |= (chOriginalColor << 8);
        // fall thru
    case BMF_16BPP:
        chOriginalColor |= (chOriginalColor << 16);
        // fall thru
    case BMF_24BPP:
    case BMF_32BPP:
        break;
    default:
        RIP("Invalid bitmap format");
    }

    {
        // All ROPs are handled in a single pass.

        CHUNK achColor[4];

        achColor[AND_ZERO]   =  0;
        achColor[AND_PEN]    =  chOriginalColor;
        achColor[AND_NOTPEN] = ~chOriginalColor;
        achColor[AND_ONE]    =  0xffffffff;

        LONG iIndex = aiLineMix[mix & 0xf];

        ls.chAnd = achColor[(iIndex & 0xff)];
        ls.chXor = achColor[iIndex >> MIX_XOR_OFFSET];
    }

    // Figure out which set of strippers to use:

    LONG iStrip = (ulFormat == BMF_24BPP) ? 8 : 0;
    iStrip |= (fl & FL_STYLED) ? 4 : 0;

    PFNSTRIP* apfn = &gapfnStrip[iStrip];

    if ((pco != NULL) && (pco->iDComplexity != DC_TRIVIAL))
    {
        // Handle complex clipping!

        BOOL bMore;
        union {
            BYTE     aj[sizeof(CLIPLINE) + (RUN_MAX - 1) * sizeof(RUN)];
            CLIPLINE cl;
        } cl;

        fl |= FL_COMPLEX_CLIP;

        ((ECLIPOBJ*) pco)->vEnumPathStart(ppo, pSurf, pla);

        do {
            bMore = ((ECLIPOBJ*) ((EPATHOBJ*)ppo)->pco)->bEnumPath(ppo,
                                   sizeof(cl), &cl.cl);

            if (cl.cl.c != 0)
            {
                if (fl & FL_STYLED)
                {
                    ls.spComplex = HIWORD(cl.cl.lStyleState) * ls.xyDensity
                                 + LOWORD(cl.cl.lStyleState);
                }
                if (!bLines(pbmi,
                            &cl.cl.ptfxA,
                            &cl.cl.ptfxB,
                            &cl.cl.arun[0],
                            cl.cl.c,
                            &ls,
                            (RECTL*) NULL,
                            apfn,
                            fl,
                            pchBits,
                            lDelta))
                    return(FALSE);
            }
        } while (bMore);
    }
    else
    {
        // Handle simple or trivial clipping!

        PATHDATA  pd;
        BOOL      bMore;
        ULONG     cptfx;
        POINTFIX  ptfxStartFigure;
        POINTFIX  ptfxLast;
        POINTFIX* pptfxFirst;
        POINTFIX* pptfxBuf;

        pd.flags = 0;
        ((EPATHOBJ*) ppo)->vEnumStart();

        do {
            bMore = ((EPATHOBJ*) ppo)->bEnum(&pd);

            cptfx = pd.count;
            if (cptfx == 0)
            {
                ASSERTGDI(!bMore, "Empty path record in non-empty path");
                break;
            }

            if (pd.flags & PD_BEGINSUBPATH)
            {
                ptfxStartFigure  = *pd.pptfx;
                pptfxFirst       = pd.pptfx;
                pptfxBuf         = pd.pptfx + 1;
                cptfx--;
            }
            else
            {
                pptfxFirst       = &ptfxLast;
                pptfxBuf         = pd.pptfx;
            }

            if (pd.flags & PD_RESETSTYLE)
                ls.spNext = 0;

            // We have to check for cptfx == 0 because the only point in the
            // subpath may have been the StartFigure point:

            if (cptfx > 0)
            {
                if (!bLines(pbmi,
                            pptfxFirst,
                            pptfxBuf,
                            (RUN*) NULL,
                            cptfx,
                            &ls,
                            NULL,
                            apfn,
                            fl,
                            pchBits,
                            lDelta))
                    return(FALSE);
            }

            ptfxLast = pd.pptfx[pd.count - 1];

            if (pd.flags & PD_CLOSEFIGURE)
            {
                if (!bLines(pbmi,
                            &ptfxLast,
                            &ptfxStartFigure,
                            (RUN*) NULL,
                            1,
                            &ls,
                            NULL,
                            apfn,
                            fl,
                            pchBits,
                            lDelta))
                    return(FALSE);
            }
        } while (bMore);

        if (fl & FL_STYLED)
        {
            // Save the style state:

            ULONG ulHigh = ls.spNext / ls.xyDensity;
            ULONG ulLow  = ls.spNext % ls.xyDensity;

            pla->elStyleState.l = MAKELONG(ulLow, ulHigh);
        }
    }

    return(TRUE);
}

/******************************Public*Routine******************************\
* BOOL EngStrokePath(pso, ppo, pco, pxo, pbo, pptlBrushOrg, pla, mix)
*
* Strokes the path.
*
* History:
*  5-Apr-1992 -by- J. Andrew Goossen
* Wrote it.
\**************************************************************************/

BOOL EngStrokePath(
SURFOBJ   *pso,
PATHOBJ   *ppo,
CLIPOBJ   *pco,
XFORMOBJ  *pxo,
BRUSHOBJ  *pbo,
PPOINTL    pptlBrushOrg,
PLINEATTRS pla,
MIX        mix)
{
    ASSERTGDI(pso != (SURFOBJ *) NULL, "EngStrokePath: surface\n");
    ASSERTGDI(ppo != (PATHOBJ *) NULL, "EngStrokePath: path\n");
    ASSERTGDI(pbo != (BRUSHOBJ *) NULL, "EngStrokePath: brushobj\n");

    PSURFACE pSurf = SURFOBJ_TO_SURFACE(pso);

    if (pla->fl & LA_GEOMETRIC)
    {
        // Handle wide lines, remembering that the widened bounds have
        // already been computed:

        if (!((EPATHOBJ*) ppo)->bWiden(pxo, pla))
            return(FALSE);

        return(EngFillPath(pSurf->pSurfobj(),
                           ppo,
                           pco,
                           pbo,
                           pptlBrushOrg,
                           mix,
                           WINDING));
    }

    if (ppo->fl & PO_BEZIERS)
        if (!((EPATHOBJ*) ppo)->bFlatten())
            return(FALSE);

    if (pSurf->iType() != STYPE_BITMAP)
    {
        // It's a cosmetic line to a device-managed surface.  The DDI
        // requires that the driver support DrvStrokePath for cosmetic
        // lines if it has any device-managed surfaces:

        PDEVOBJ po(pSurf->hdev());

        ASSERTGDI(PPFNVALID(po, StrokePath),
            "Driver must hook DrvStrokePath if it supports device-managed surfaces");

        return((*PPFNDRV(po, StrokePath))(pSurf->pSurfobj(),
                                          ppo,
                                          pco,
                                          pxo,
                                          pbo,
                                          pptlBrushOrg,
                                          pla,
                                          mix));
    }

    // Before we touch any bits, make sure the device is happy about it.
    {
        PDEVOBJ po(pSurf->hdev());
        po.vSync(pso,NULL, 0);
    }

    // If this is a single pixel wide solid color line
    // with trivial or simple clipping then call solid line routine:

    if (((mix & 0xFF) == R2_COPYPEN)                         &&
        ((pco == NULL) || (pco->iDComplexity != DC_COMPLEX)) &&
        (pla->pstyle == NULL)                                &&
        !(pla->fl & LA_ALTERNATE))
    {
        vSolidLine(pSurf,
                  ppo,
                  NULL,
                  pco,
                  pbo->iSolidColor);

        return(TRUE);
    }

    return(bStrokeCosmetic(pSurf, ppo, pco, pbo, pla, mix));
}

/******************************Public*Routine******************************\
* BOOL EngLineTo(pso, pco, pbo, x1, y1, x2, y2, prclBounds, mix)
*
* Draws a single solid integer-only cosmetic line.
*
* History:
*
*  12-Sept-1996 -by- Tom Zakrajsek
* Made it work for device managed surfaces.
*
*  4-June-1995 -by- J. Andrew Goossen
* Wrote it.
\**************************************************************************/

BOOL EngLineTo(
SURFOBJ   *pso,
CLIPOBJ   *pco,
BRUSHOBJ  *pbo,
LONG       x1,
LONG       y1,
LONG       x2,
LONG       y2,
RECTL     *prclBounds,
MIX        mix)
{
    GDIFunctionID(EngLineTo);
    ASSERTGDI(pso != (SURFOBJ *) NULL, "pso is NULL\n");

    BOOL bReturn;
    PSURFACE pSurf = SURFOBJ_TO_SURFACE(pso);
    LINEATTRS la;
    PATHOBJ* ppo;
    POINTFIX aptfx[2];

    bReturn = FALSE;

    aptfx[0].x = x1 << 4;
    aptfx[0].y = y1 << 4;
    aptfx[1].x = x2 << 4;
    aptfx[1].y = y2 << 4;

    if (pSurf->iType() != STYPE_BITMAP)
    {
        // Device managed surface

        {
            // Solid cosmetic lines have everything zeroed in the LINEATTRS:

            memset(&la, 0, sizeof(LINEATTRS));
            la.elWidth.l = 1;

            // Create a path that describes the line:

            ppo = EngCreatePath();
            if (ppo != NULL)
            {
                if (PATHOBJ_bMoveTo(ppo, aptfx[0]) &&
                    PATHOBJ_bPolyLineTo(ppo, &aptfx[1], 1))
                {
                    PDEVOBJ  pdo(pSurf->hdev());
                    ECLIPOBJ  eco;
                    RGNMEMOBJTMP rmoTmp;

                    // StrokePath is guaranteed not to get a NULL clip
                    // object, so construct a temporary one:

                    if (pco == NULL)
                    {
                        if (rmoTmp.bValid())
                        {
                            rmoTmp.vSet(prclBounds);
                            eco.vSetup(rmoTmp.prgnGet(),
                                       *(ERECTL *) prclBounds);

                            pco = &eco;
                        }
                    }

                    // Clip may still be NULL if RGNMEMOBJTMP constructor
                    // failed, so need to check:

                    if (pco)
                    {
                        bReturn = (*PPFNGET(pdo,StrokePath,pSurf->flags())) (
                                            pso,
                                            ppo,
                                            pco,
                                            NULL,   // pxo
                                            pbo,
                                            NULL,   // pptlBrush
                                            &la,
                                            mix);
                    }
                }

                EngDeletePath(ppo);
            }
        }
    }
    else
    {
        // Engine managed surface

        // Before we touch any bits, make sure the device is happy about it.
        {
            PDEVOBJ po(pSurf->hdev());
            po.vSync(pso,NULL,0);
        }

        if (((pco == NULL) || (pco->iDComplexity != DC_COMPLEX)) &&
            (mix == 0x0d0d))
        {
            // If this is a single pixel wide solid color line
            // with trivial or simple clipping then call solid line routine:

            vSolidLine(pSurf,
                      NULL,
                      aptfx,
                      pco,
                      pbo->iSolidColor);

            bReturn = TRUE;
        }
        else
        {
            // Solid cosmetic lines have everything zeroed in the LINEATTRS:

            memset(&la, 0, sizeof(LINEATTRS));

            // Create a path that describes the line:

            ppo = EngCreatePath();
            if (ppo != NULL)
            {
                if (PATHOBJ_bMoveTo(ppo, aptfx[0]) &&
                    PATHOBJ_bPolyLineTo(ppo, &aptfx[1], 1))
                {
                    bReturn = bStrokeCosmetic(pSurf, ppo, pco, pbo, &la, mix);
                }

                EngDeletePath(ppo);
            }
        }
    }

    return(bReturn);
}