gdibatch.c File Reference

#include <win32k.h>
#include <debug.h>

Include dependency graph for gdibatch.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOL FASTCALL	IntPatBlt (PDC, INT, INT, INT, INT, DWORD, PEBRUSHOBJ)
BOOL APIENTRY	IntExtTextOutW (IN PDC, IN INT, IN INT, IN UINT, IN OPTIONAL PRECTL, IN LPCWSTR, IN INT, IN OPTIONAL LPINT, IN DWORD)
VOID FASTCALL	DoDeviceSync (SURFOBJ *Surface, PRECTL Rect, FLONG fl)
VOID FASTCALL	SynchronizeDriver (FLONG Flags)
ULONG FASTCALL	GdiFlushUserBatch (PDC dc, PGDIBATCHHDR pHdr)
__kernel_entry NTSTATUS APIENTRY	NtGdiFlush (VOID)
NTSTATUS APIENTRY	NtGdiFlushUserBatch (VOID)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 4 of file gdibatch.c.

Function Documentation

DoDeviceSync()

VOID FASTCALL DoDeviceSync	(	SURFOBJ *	Surface,
		PRECTL	Rect,
		FLONG	fl
	)

Definition at line 22 of file gdibatch.c.

{
  PPDEVOBJ Device = (PDEVOBJ*)Surface->hdev;
// No punting and "Handle to a surface, provided that the surface is device-managed.
// Otherwise, dhsurf is zero".
  if (!(Device->flFlags & PDEV_DRIVER_PUNTED_CALL) && (Surface->dhsurf))
  {
     if (Device->DriverFunctions.SynchronizeSurface)
     {
       Device->DriverFunctions.SynchronizeSurface(Surface, Rect, fl);
     }
     else
     {
       if (Device->DriverFunctions.Synchronize)
       {
         Device->DriverFunctions.Synchronize(Surface->dhpdev, Rect);
       }
     }
  }
}

Referenced by SynchronizeDriver().

GdiFlushUserBatch()

ULONG FASTCALL GdiFlushUserBatch	(	PDC	dc,
		PGDIBATCHHDR	pHdr
	)

Definition at line 70 of file gdibatch.c.

{
  ULONG Cmd = 0, Size = 0;
  PDC_ATTR pdcattr = NULL;

  if (dc)
  {
     pdcattr = dc->pdcattr;
  }

  _SEH2_TRY
  {
     Cmd = pHdr->Cmd;
     Size = pHdr->Size; // Return the full size of the structure.
  }
  _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
  {
     DPRINT1("WARNING! GdiBatch Fault!\n");
     _SEH2_YIELD(return 0;)
  }
  _SEH2_END;

  switch(Cmd)
  {
     case GdiBCPatBlt:
     {
        PGDIBSPATBLT pgDPB;
        DWORD dwRop, flags;
        HBRUSH hOrgBrush;
        COLORREF crColor, crBkColor, crBrushClr;
        ULONG ulForegroundClr, ulBackgroundClr, ulBrushClr;
        if (!dc) break;
        pgDPB = (PGDIBSPATBLT) pHdr;
        /* Convert the ROP3 to a ROP4 */
        dwRop = pgDPB->dwRop;
        dwRop = MAKEROP4(dwRop & 0xFF0000, dwRop);
        /* Check if the rop uses a source */
        if (WIN32_ROP4_USES_SOURCE(dwRop))
        {
           /* This is not possible */
           break;
        }
        /* Check if the DC has no surface (empty mem or info DC) */
        if (dc->dclevel.pSurface == NULL)
        {
           /* Nothing to do */
           break;
        }
        // Save current attributes and flags
        crColor         = dc->pdcattr->crForegroundClr;
        crBkColor       = dc->pdcattr->ulBackgroundClr;
        crBrushClr      = dc->pdcattr->crBrushClr;
        ulForegroundClr = dc->pdcattr->ulForegroundClr;
        ulBackgroundClr = dc->pdcattr->ulBackgroundClr;
        ulBrushClr      = dc->pdcattr->ulBrushClr;
        hOrgBrush       = dc->pdcattr->hbrush;
        flags = dc->pdcattr->ulDirty_ & (DIRTY_BACKGROUND | DIRTY_TEXT | DIRTY_FILL | DC_BRUSH_DIRTY);
        // Set the attribute snapshot
        dc->pdcattr->hbrush          = pgDPB->hbrush; 
        dc->pdcattr->crForegroundClr = pgDPB->crForegroundClr;
        dc->pdcattr->crBackgroundClr = pgDPB->crBackgroundClr;
        dc->pdcattr->crBrushClr      = pgDPB->crBrushClr;
        dc->pdcattr->ulForegroundClr = pgDPB->ulForegroundClr;
        dc->pdcattr->ulBackgroundClr = pgDPB->ulBackgroundClr;
        dc->pdcattr->ulBrushClr      = pgDPB->ulBrushClr;
        // Process dirty attributes if any.
        if (dc->pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
            DC_vUpdateFillBrush(dc);
        if (dc->pdcattr->ulDirty_ & DIRTY_TEXT)
            DC_vUpdateTextBrush(dc);
        if (pdcattr->ulDirty_ & DIRTY_BACKGROUND)
            DC_vUpdateBackgroundBrush(dc);
        /* Call the internal function */
        IntPatBlt(dc, pgDPB->nXLeft, pgDPB->nYLeft, pgDPB->nWidth, pgDPB->nHeight, dwRop, &dc->eboFill);
        // Restore attributes and flags
        dc->pdcattr->hbrush          = hOrgBrush;
        dc->pdcattr->crForegroundClr = crColor;
        dc->pdcattr->crBackgroundClr = crBkColor;
        dc->pdcattr->crBrushClr      = crBrushClr;
        dc->pdcattr->ulForegroundClr = ulForegroundClr;
        dc->pdcattr->ulBackgroundClr = ulBackgroundClr;
        dc->pdcattr->ulBrushClr      = ulBrushClr;
        dc->pdcattr->ulDirty_ |= flags;
        break;
     }

     case GdiBCPolyPatBlt:
     {
        PGDIBSPPATBLT pgDPB;
        EBRUSHOBJ eboFill;
        PBRUSH pbrush;
        PPATRECT pRects;
        INT i;
        DWORD dwRop, flags;
        COLORREF crColor, crBkColor, crBrushClr;
        ULONG ulForegroundClr, ulBackgroundClr, ulBrushClr;
        if (!dc) break;
        pgDPB = (PGDIBSPPATBLT) pHdr;
        /* Convert the ROP3 to a ROP4 */
        dwRop = pgDPB->rop4;
        dwRop = MAKEROP4(dwRop & 0xFF0000, dwRop);
        /* Check if the rop uses a source */
        if (WIN32_ROP4_USES_SOURCE(dwRop))
        {
           /* This is not possible */
           break;
        }
        /* Check if the DC has no surface (empty mem or info DC) */
        if (dc->dclevel.pSurface == NULL)
        {
           /* Nothing to do */
           break;
        }
        // Save current attributes and flags
        crColor         = dc->pdcattr->crForegroundClr;
        crBkColor       = dc->pdcattr->ulBackgroundClr;
        crBrushClr      = dc->pdcattr->crBrushClr;
        ulForegroundClr = dc->pdcattr->ulForegroundClr;
        ulBackgroundClr = dc->pdcattr->ulBackgroundClr;
        ulBrushClr      = dc->pdcattr->ulBrushClr;
        flags = dc->pdcattr->ulDirty_ & (DIRTY_BACKGROUND | DIRTY_TEXT | DIRTY_FILL | DC_BRUSH_DIRTY);
        // Set the attribute snapshot
        dc->pdcattr->crForegroundClr = pgDPB->crForegroundClr;
        dc->pdcattr->crBackgroundClr = pgDPB->crBackgroundClr;
        dc->pdcattr->crBrushClr      = pgDPB->crBrushClr;
        dc->pdcattr->ulForegroundClr = pgDPB->ulForegroundClr;
        dc->pdcattr->ulBackgroundClr = pgDPB->ulBackgroundClr;
        dc->pdcattr->ulBrushClr      = pgDPB->ulBrushClr;
        // Process dirty attributes if any
        if (dc->pdcattr->ulDirty_ & DIRTY_TEXT)
            DC_vUpdateTextBrush(dc);
        if (pdcattr->ulDirty_ & DIRTY_BACKGROUND)
            DC_vUpdateBackgroundBrush(dc);

        DPRINT1("GdiBCPolyPatBlt Testing\n");
        pRects = &pgDPB->pRect[0];

        for (i = 0; i < pgDPB->Count; i++)
        {
            pbrush = BRUSH_ShareLockBrush(pRects->hBrush);

            /* Check if we could lock the brush */
            if (pbrush != NULL)
            {
                /* Initialize a brush object */
                EBRUSHOBJ_vInitFromDC(&eboFill, pbrush, dc);

                IntPatBlt(
                    dc,
                    pRects->r.left,
                    pRects->r.top,
                    pRects->r.right,
                    pRects->r.bottom,
                    dwRop,
                    &eboFill);

                /* Cleanup the brush object and unlock the brush */
                EBRUSHOBJ_vCleanup(&eboFill);
                BRUSH_ShareUnlockBrush(pbrush);
            }
            pRects++;
        }

        // Restore attributes and flags
        dc->pdcattr->crForegroundClr = crColor;
        dc->pdcattr->crBackgroundClr = crBkColor;
        dc->pdcattr->crBrushClr      = crBrushClr;
        dc->pdcattr->ulForegroundClr = ulForegroundClr;
        dc->pdcattr->ulBackgroundClr = ulBackgroundClr;
        dc->pdcattr->ulBrushClr      = ulBrushClr;
        dc->pdcattr->ulDirty_ |= flags;
        break;
     }

     case GdiBCTextOut:
     {
        PGDIBSTEXTOUT pgO;
        COLORREF crColor = -1, crBkColor;
        ULONG ulForegroundClr, ulBackgroundClr;
        DWORD flags = 0, saveflags;
        FLONG flTextAlign = -1;
        HANDLE hlfntNew;
        PRECTL lprc;
        USHORT jBkMode;
        LONG lBkMode;
        if (!dc) break;
        pgO = (PGDIBSTEXTOUT) pHdr;

        // Save current attributes, flags and Set the attribute snapshots
        saveflags = dc->pdcattr->ulDirty_ & (DIRTY_BACKGROUND|DIRTY_LINE|DIRTY_TEXT|DIRTY_FILL|DC_BRUSH_DIRTY|DIRTY_CHARSET);

        // In this instance check for differences and set the appropriate dirty flags.
        if ( dc->pdcattr->crForegroundClr != pgO->crForegroundClr)
        {
            crColor = dc->pdcattr->crForegroundClr;
            dc->pdcattr->crForegroundClr = pgO->crForegroundClr;
            ulForegroundClr = dc->pdcattr->ulForegroundClr;
            dc->pdcattr->ulForegroundClr = pgO->ulForegroundClr;
            flags |= (DIRTY_FILL|DIRTY_LINE|DIRTY_TEXT);
        }
        if (dc->pdcattr->crBackgroundClr != pgO->crBackgroundClr)
        {
            crBkColor = dc->pdcattr->ulBackgroundClr;
            dc->pdcattr->crBackgroundClr = pgO->crBackgroundClr;
            ulBackgroundClr = dc->pdcattr->ulBackgroundClr;
            dc->pdcattr->ulBackgroundClr = pgO->ulBackgroundClr;
            flags |= (DIRTY_FILL|DIRTY_LINE|DIRTY_TEXT|DIRTY_BACKGROUND);
        }
        if (dc->pdcattr->flTextAlign != pgO->flTextAlign)
        {
            flTextAlign = dc->pdcattr->flTextAlign;
            dc->pdcattr->flTextAlign = pgO->flTextAlign;
        }
        if (dc->pdcattr->hlfntNew != pgO->hlfntNew)
        {
            hlfntNew = dc->pdcattr->hlfntNew;
            dc->pdcattr->hlfntNew = pgO->hlfntNew;
            dc->pdcattr->ulDirty_ &= ~SLOW_WIDTHS;
            flags |= DIRTY_CHARSET;
        }

        dc->pdcattr->ulDirty_ |= flags;

        jBkMode = dc->pdcattr->jBkMode;
        dc->pdcattr->jBkMode = pgO->lBkMode;
        lBkMode = dc->pdcattr->lBkMode;
        dc->pdcattr->lBkMode = pgO->lBkMode;

        lprc = (pgO->Options & GDIBS_NORECT) ? NULL : &pgO->Rect;
        pgO->Options &= ~GDIBS_NORECT;

        IntExtTextOutW( dc,
                        pgO->x,
                        pgO->y,
                        pgO->Options,
                        lprc,
                        (LPCWSTR)&pgO->String[pgO->Size/sizeof(WCHAR)],
                        pgO->cbCount,
                        pgO->Size ? (LPINT)&pgO->Buffer : NULL,
                        pgO->iCS_CP );

        // Restore attributes and flags
        dc->pdcattr->jBkMode = jBkMode;
        dc->pdcattr->lBkMode = lBkMode;

        if (flags & DIRTY_TEXT && crColor != -1)
        {
            dc->pdcattr->crForegroundClr = crColor;
            dc->pdcattr->ulForegroundClr = ulForegroundClr;
        }
        if (flags & DIRTY_BACKGROUND)
        {
            dc->pdcattr->crBackgroundClr = crBkColor;
            dc->pdcattr->ulBackgroundClr = ulBackgroundClr;
        }
        if (flTextAlign != -1)
        {
            dc->pdcattr->flTextAlign = flTextAlign;
        }

        if (flags & DIRTY_CHARSET)
        {
           dc->pdcattr->hlfntNew = hlfntNew;
           dc->pdcattr->ulDirty_ &= ~SLOW_WIDTHS;
        }
        dc->pdcattr->ulDirty_ |= saveflags | flags;
        break;
     }

     case GdiBCExtTextOut:
     {
        PGDIBSEXTTEXTOUT pgO;
        COLORREF crBkColor;
        ULONG ulBackgroundClr;
        DWORD flags = 0, saveflags;
        if (!dc) break;
        pgO = (PGDIBSEXTTEXTOUT) pHdr;

        saveflags = dc->pdcattr->ulDirty_ & (DIRTY_BACKGROUND|DIRTY_TEXT|DIRTY_FILL|DC_BRUSH_DIRTY|DIRTY_CHARSET);

        if (dc->pdcattr->crBackgroundClr != pgO->ulBackgroundClr)
        {
            crBkColor = dc->pdcattr->crBackgroundClr;
            ulBackgroundClr = dc->pdcattr->ulBackgroundClr;
            dc->pdcattr->crBackgroundClr = pgO->ulBackgroundClr;
            dc->pdcattr->ulBackgroundClr = pgO->ulBackgroundClr;
            flags |= (DIRTY_BACKGROUND|DIRTY_LINE|DIRTY_FILL);
        }

        dc->pdcattr->ulDirty_ |= flags;

        IntExtTextOutW( dc,
                        0,
                        0,
                        pgO->Options,
                       &pgO->Rect,
                        NULL,
                        pgO->Count,
                        NULL,
                        0 );

        if (flags & DIRTY_BACKGROUND)
        {
            dc->pdcattr->crBackgroundClr = crBkColor;
            dc->pdcattr->ulBackgroundClr = ulBackgroundClr;
        }
        dc->pdcattr->ulDirty_ |= saveflags | flags;
        break;
     }

     case GdiBCSetBrushOrg:
     {
        PGDIBSSETBRHORG pgSBO;
        if (!dc) break;
        pgSBO = (PGDIBSSETBRHORG) pHdr;
        pdcattr->ptlBrushOrigin = pgSBO->ptlBrushOrigin;
        DC_vSetBrushOrigin(dc, pgSBO->ptlBrushOrigin.x, pgSBO->ptlBrushOrigin.y);
        break;
     }

     case GdiBCExtSelClipRgn:
        break;

     case GdiBCSelObj:
     {
        PGDIBSOBJECT pgO;

        if (!dc) break;
        pgO = (PGDIBSOBJECT) pHdr;

        DC_hSelectFont(dc, (HFONT)pgO->hgdiobj);
        break;
     }

     case GdiBCDelRgn:
        DPRINT("Delete Region Object!\n");
        /* Fall through */
     case GdiBCDelObj:
     {
        PGDIBSOBJECT pgO = (PGDIBSOBJECT) pHdr;
        GreDeleteObject( pgO->hgdiobj );
        break;
     }

     default:
        break;
  }

  return Size;
}

Referenced by NtGdiFlushUserBatch().

IntExtTextOutW()

BOOL APIENTRY IntExtTextOutW	(	IN	PDC,
		IN	INT,
		IN	INT,
		IN	UINT,
		IN OPTIONAL	PRECTL,
		IN	LPCWSTR,
		IN	INT,
		IN OPTIONAL	LPINT,
		IN	DWORD
	)

Definition at line 5510 of file freetype.c.

{
    /*
     * FIXME:
     * Call EngTextOut, which does the real work (calling DrvTextOut where
     * appropriate)
     */

    PDC_ATTR pdcattr;
    SURFOBJ *SurfObj;
    SURFACE *psurf = NULL;
    int error, glyph_index, i;
    FT_Face face;
    FT_GlyphSlot glyph;
    FT_BitmapGlyph realglyph;
    LONGLONG TextLeft64, TextTop64, DeltaX64, DeltaY64, XStart64, YStart64;
    ULONG previous;
    FT_Bool use_kerning;
    RECTL DestRect, MaskRect;
    POINTL SourcePoint, BrushOrigin;
    HBITMAP HSourceGlyph;
    SURFOBJ *SourceGlyphSurf;
    SIZEL bitSize;
    FONTOBJ *FontObj;
    PFONTGDI FontGDI;
    PTEXTOBJ TextObj = NULL;
    EXLATEOBJ exloRGB2Dst, exloDst2RGB;
    FT_Render_Mode RenderMode;
    BOOLEAN Render;
    POINT Start;
    BOOL DoBreak = FALSE;
    USHORT DxShift;
    PMATRIX pmxWorldToDevice;
    LONG lfEscapement, lfWidth;
    FLOATOBJ Scale;
    LOGFONTW *plf;
    BOOL EmuBold, EmuItalic;
    int thickness;
    BOOL bResult;
    FT_Matrix mat = identityMat, matWidth, matEscape, matWorld;
    FT_Vector vecs[9];

    /* Check if String is valid */
    if ((Count > 0xFFFF) || (Count > 0 && String == NULL))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    Render = IntIsFontRenderingEnabled();

    if (PATH_IsPathOpen(dc->dclevel))
    {
        bResult = PATH_ExtTextOut(dc,
                              XStart,
                              YStart,
                              fuOptions,
                              (const RECTL *)lprc,
                              String,
                              Count,
                              (const INT *)Dx);
        return bResult;
    }

    DC_vPrepareDCsForBlit(dc, NULL, NULL, NULL);

    if (!dc->dclevel.pSurface)
    {
        /* Memory DC with no surface selected */
        bResult = TRUE;
        goto Cleanup;
    }

    pdcattr = dc->pdcattr;

    if (lprc && (fuOptions & (ETO_OPAQUE | ETO_CLIPPED)))
    {
        IntLPtoDP(dc, (POINT *)lprc, 2);
    }

    if (pdcattr->flTextAlign & TA_UPDATECP)
    {
        Start.x = pdcattr->ptlCurrent.x;
        Start.y = pdcattr->ptlCurrent.y;
    } else {
        Start.x = XStart;
        Start.y = YStart;
    }

    SourcePoint.x = 0;
    SourcePoint.y = 0;
    MaskRect.left = 0;
    MaskRect.top = 0;
    BrushOrigin.x = 0;
    BrushOrigin.y = 0;

    if ((fuOptions & ETO_OPAQUE) && lprc)
    {
        DestRect.left   = lprc->left;
        DestRect.top    = lprc->top;
        DestRect.right  = lprc->right;
        DestRect.bottom = lprc->bottom;

        DestRect.left   += dc->ptlDCOrig.x;
        DestRect.top    += dc->ptlDCOrig.y;
        DestRect.right  += dc->ptlDCOrig.x;
        DestRect.bottom += dc->ptlDCOrig.y;

        if (dc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
        {
           IntUpdateBoundsRect(dc, &DestRect);
        }

        if (pdcattr->ulDirty_ & DIRTY_BACKGROUND)
            DC_vUpdateBackgroundBrush(dc);
        if (dc->dctype == DCTYPE_DIRECT)
            MouseSafetyOnDrawStart(dc->ppdev, DestRect.left, DestRect.top, DestRect.right, DestRect.bottom);

        psurf = dc->dclevel.pSurface;
        IntEngBitBlt(
            &psurf->SurfObj,
            NULL,
            NULL,
            (CLIPOBJ *)&dc->co,
            NULL,
            &DestRect,
            &SourcePoint,
            &SourcePoint,
            &dc->eboBackground.BrushObject,
            &BrushOrigin,
            ROP4_FROM_INDEX(R3_OPINDEX_PATCOPY));

        if (dc->dctype == DCTYPE_DIRECT)
            MouseSafetyOnDrawEnd(dc->ppdev);

        fuOptions &= ~ETO_OPAQUE;
    }
    else
    {
        if (pdcattr->jBkMode == OPAQUE)
        {
            fuOptions |= ETO_OPAQUE;
        }
    }

    TextObj = RealizeFontInit(pdcattr->hlfntNew);
    if (TextObj == NULL)
    {
        bResult = FALSE;
        goto Cleanup;
    }

    FontObj = TextObj->Font;
    ASSERT(FontObj);
    FontGDI = ObjToGDI(FontObj, FONT);
    ASSERT(FontGDI);

    IntLockFreeType();
    face = FontGDI->SharedFace->Face;

    plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
    EmuBold = (plf->lfWeight >= FW_BOLD && FontGDI->OriginalWeight <= FW_NORMAL);
    EmuItalic = (plf->lfItalic && !FontGDI->OriginalItalic);
    if (FT_IS_SCALABLE(face))
    {
        lfEscapement = IntNormalizeAngle(plf->lfEscapement);
        lfWidth = labs(plf->lfWidth);
    }
    else
    {
        lfEscapement = lfWidth = 0;
    }

    if (Render)
        RenderMode = IntGetFontRenderMode(plf);
    else
        RenderMode = FT_RENDER_MODE_MONO;

    if (!TextIntUpdateSize(dc, TextObj, FontGDI, FALSE))
    {
        IntUnLockFreeType();
        bResult = FALSE;
        goto Cleanup;
    }

    /* NOTE: Don't trust face->size->metrics.ascender and descender values. */
    DC_vUpdateWorldToDevice(dc);
    if (dc->pdcattr->iGraphicsMode == GM_ADVANCED)
    {
        pmxWorldToDevice = DC_pmxWorldToDevice(dc);
    }
    else
    {
        pmxWorldToDevice = (PMATRIX)&gmxWorldToDeviceDefault;
    }

    IntWidthMatrix(face, &matWidth, lfWidth);
    FT_Matrix_Multiply(&matWidth, &mat);

    IntEscapeMatrix(&matEscape, lfEscapement);
    FT_Matrix_Multiply(&matEscape, &mat);

    FtMatrixFromMx(&matWorld, pmxWorldToDevice);
    matWorld.yx = -matWorld.yx;
    matWorld.xy = -matWorld.xy;
    FT_Matrix_Multiply(&matWorld, &mat);

    FT_Set_Transform(face, &mat, NULL);

    // Calculate displacement of the text.
    DeltaX64 = DeltaY64 = 0;
    DxShift = fuOptions & ETO_PDY ? 1 : 0;
    use_kerning = FT_HAS_KERNING(face);
    previous = 0;
    if ((fuOptions & ETO_OPAQUE) ||
        (pdcattr->flTextAlign & (TA_CENTER | TA_RIGHT)) ||
        memcmp(&mat, &identityMat, sizeof(mat)) != 0 ||
        plf->lfUnderline || plf->lfStrikeOut)
    {
        for (i = 0; i < Count; ++i)
        {
            glyph_index = get_glyph_index_flagged(face, String[i], ETO_GLYPH_INDEX, fuOptions);

            // FIXME: Use FT_LOAD_BITMAP_METRICS_ONLY or cache.
            error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
            if (error)
            {
                DPRINT1("Failed to load glyph! [index: %d]\n", glyph_index);
                IntUnLockFreeType();
                bResult = FALSE;
                goto Cleanup;
            }

            glyph = face->glyph;
            if (EmuBold)
                FT_GlyphSlot_Embolden(glyph);
            if (EmuItalic)
                FT_GlyphSlot_Oblique(glyph);
            realglyph = ftGdiGlyphSet(face, glyph, RenderMode);
            if (!realglyph)
            {
                DPRINT1("Failed to render glyph! [index: %d]\n", glyph_index);
                IntUnLockFreeType();
                bResult = FALSE;
                goto Cleanup;
            }

            /* retrieve kerning distance and move pen position */
            if (use_kerning && previous && glyph_index && Dx == NULL)
            {
                FT_Vector delta;
                FT_Get_Kerning(face, previous, glyph_index, 0, &delta);
                DeltaX64 += delta.x;
                DeltaY64 -= delta.y;
            }

            if (Dx == NULL)
            {
                DeltaX64 += realglyph->root.advance.x >> 10;
                DeltaY64 -= realglyph->root.advance.y >> 10;
            }
            else
            {
                // FIXME this should probably be a matrix transform with DeltaY64 as well.
                Scale = pdcattr->mxWorldToDevice.efM11;
                if (FLOATOBJ_Equal0(&Scale))
                    FLOATOBJ_Set1(&Scale);

                /* do the shift before multiplying to preserve precision */
                FLOATOBJ_MulLong(&Scale, Dx[i << DxShift] << 6);
                DeltaX64 += FLOATOBJ_GetLong(&Scale);
            }

            if (DxShift)
            {
                DeltaY64 -= Dx[2 * i + 1] << 6;
            }

            previous = glyph_index;

            FT_Done_Glyph((FT_Glyph)realglyph);
        }
    }

    // Process the X and Y alignments.
    if ((pdcattr->flTextAlign & TA_CENTER) == TA_CENTER)
    {
        XStart64 = -DeltaX64 / 2;
        YStart64 = -DeltaY64 / 2;
    }
    else if ((pdcattr->flTextAlign & TA_RIGHT) == TA_RIGHT)
    {
        XStart64 = -DeltaX64;
        YStart64 = -DeltaY64;
    }
    else
    {
        XStart64 = YStart64 = 0;
    }

    psurf = dc->dclevel.pSurface;
    SurfObj = &psurf->SurfObj ;

    if ((fuOptions & ETO_OPAQUE) && (dc->pdcattr->ulDirty_ & DIRTY_BACKGROUND))
        DC_vUpdateBackgroundBrush(dc) ;

    if (dc->pdcattr->ulDirty_ & DIRTY_TEXT)
        DC_vUpdateTextBrush(dc) ;

    thickness = 1;
    if (face->units_per_EM)
    {
        thickness = face->underline_thickness *
            face->size->metrics.y_ppem / face->units_per_EM;
        if (thickness <= 0)
            thickness = 1;
    }

    /* Process the vertical alignment */
#define VALIGN_MASK  (TA_TOP | TA_BASELINE | TA_BOTTOM)
    RtlZeroMemory(vecs, sizeof(vecs));
    if ((pdcattr->flTextAlign & VALIGN_MASK) == TA_BASELINE)
    {
        vecs[1].y = -FontGDI->tmAscent << 16;   // upper left
        vecs[4].y = 0;                          // baseline
        vecs[0].y = FontGDI->tmDescent << 16;   // lower left
    }
    else if ((pdcattr->flTextAlign & VALIGN_MASK) == TA_BOTTOM)
    {
        vecs[1].y = -FontGDI->tmHeight << 16;   // upper left
        vecs[4].y = -FontGDI->tmDescent << 16;  // baseline
        vecs[0].y = 0;                          // lower left
    }
    else /* TA_TOP */
    {
        vecs[1].y = 0;                          // upper left
        vecs[4].y = FontGDI->tmAscent << 16;    // baseline
        vecs[0].y = FontGDI->tmHeight << 16;    // lower left
    }
    vecs[2] = vecs[1];      // upper right
    vecs[3] = vecs[0];      // lower right
#undef VALIGN_MASK

    // underline
    if (plf->lfUnderline)
    {
        int position = 0;
        if (face->units_per_EM)
        {
            position = face->underline_position *
                face->size->metrics.y_ppem / face->units_per_EM;
        }
        vecs[5].y = vecs[6].y = vecs[4].y - (position << 16);
    }

    // strike through
    if (plf->lfStrikeOut)
    {
        vecs[7].y = vecs[8].y = vecs[4].y - ((FontGDI->tmAscent / 3) << 16);
    }

    // invert y axis
    IntEscapeMatrix(&matEscape, -lfEscapement);

    // convert vecs
    for (i = 0; i < 9; ++i)
    {
        POINT pt;
        FT_Vector_Transform(&vecs[i], &matWidth);
        FT_Vector_Transform(&vecs[i], &matEscape);
        vecs[i].x += (Start.x << 16) + (XStart64 << 10);
        vecs[i].y += (Start.y << 16) + (YStart64 << 10);
        pt.x = vecs[i].x >> 16;
        pt.y = vecs[i].y >> 16;
        IntLPtoDP(dc, &pt, 1);
        vecs[i].x = pt.x + dc->ptlDCOrig.x;
        vecs[i].y = pt.y + dc->ptlDCOrig.y;
    }
    vecs[2].x += DeltaX64 >> 6;
    vecs[2].y += DeltaY64 >> 6;     // upper right
    vecs[3].x += DeltaX64 >> 6;
    vecs[3].y += DeltaY64 >> 6;     // lower right
    vecs[6].x += DeltaX64 >> 6;
    vecs[6].y += DeltaY64 >> 6;     // underline right
    vecs[8].x += DeltaX64 >> 6;
    vecs[8].y += DeltaY64 >> 6;     // strike through right

    if (fuOptions & ETO_OPAQUE)
    {
        /* Draw background */
        RECTL Rect;
        RtlZeroMemory(&Rect, sizeof(Rect));

        if ((mat.xy == 0 && mat.yx == 0) || (mat.xx == 0 && mat.yy == 0))
        {
            Rect.left = Rect.top = MAXLONG;
            Rect.right = Rect.bottom = MINLONG;
            for (i = 0; i < 4; ++i)
            {
                Rect.left = min(Rect.left, vecs[i].x);
                Rect.top = min(Rect.top, vecs[i].y);
                Rect.right = max(Rect.right, vecs[i].x);
                Rect.bottom = max(Rect.bottom, vecs[i].y);
            }
        }
        else
        {
            // FIXME: Use vecs[0] ... vecs[3] and EngFillPath
        }

        if (dc->fs & (DC_ACCUM_APP | DC_ACCUM_WMGR))
        {
            IntUpdateBoundsRect(dc, &Rect);
        }

        if (pdcattr->ulDirty_ & DIRTY_BACKGROUND)
            DC_vUpdateBackgroundBrush(dc);
        if (dc->dctype == DCTYPE_DIRECT)
            MouseSafetyOnDrawStart(dc->ppdev, Rect.left, Rect.top, Rect.right, Rect.bottom);

        SourcePoint.x = SourcePoint.y = 0;
        BrushOrigin.x = BrushOrigin.y = 0;

        psurf = dc->dclevel.pSurface;
        IntEngBitBlt(
            &psurf->SurfObj,
            NULL,
            NULL,
            (CLIPOBJ *)&dc->co,
            NULL,
            &Rect,
            &SourcePoint,
            &SourcePoint,
            &dc->eboBackground.BrushObject,
            &BrushOrigin,
            ROP4_FROM_INDEX(R3_OPINDEX_PATCOPY));

        if (dc->dctype == DCTYPE_DIRECT)
            MouseSafetyOnDrawEnd(dc->ppdev);
    }

    EXLATEOBJ_vInitialize(&exloRGB2Dst, &gpalRGB, psurf->ppal, 0, 0, 0);
    EXLATEOBJ_vInitialize(&exloDst2RGB, psurf->ppal, &gpalRGB, 0, 0, 0);

    // The main rendering loop.
    bResult = TRUE;
    TextLeft64 = vecs[4].x << 6;
    TextTop64 = vecs[4].y << 6;
    previous = 0;
    for (i = 0; i < Count; ++i)
    {
        BOOL bNeedCache = (!EmuBold && !EmuItalic &&
                           memcmp(&mat, &identityMat, sizeof(mat)) == 0);
        glyph_index = get_glyph_index_flagged(face, String[i], ETO_GLYPH_INDEX, fuOptions);
        realglyph = NULL;
        if (bNeedCache)
        {
            realglyph = ftGdiGlyphCacheGet(face, glyph_index, plf->lfHeight,
                                           RenderMode, pmxWorldToDevice);
        }
        if (!realglyph)
        {
            error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
            if (error)
            {
                DPRINT1("Failed to load and render glyph! [index: %d]\n", glyph_index);
                bResult = FALSE;
                break;
            }
            glyph = face->glyph;
            if (bNeedCache)
            {
                realglyph = ftGdiGlyphCacheSet(face,
                                               glyph_index,
                                               plf->lfHeight,
                                               pmxWorldToDevice,
                                               glyph,
                                               RenderMode);
            }
            else
            {
                if (EmuBold)
                    FT_GlyphSlot_Embolden(glyph);
                if (EmuItalic)
                    FT_GlyphSlot_Oblique(glyph);
                realglyph = ftGdiGlyphSet(face, glyph, RenderMode);
            }
            if (!realglyph)
            {
                DPRINT1("Failed to render glyph! [index: %d]\n", glyph_index);
                bResult = FALSE;
                break;
            }
        }

        /* retrieve kerning distance and move pen position */
        if (use_kerning && previous && glyph_index && NULL == Dx)
        {
            FT_Vector delta;
            FT_Get_Kerning(face, previous, glyph_index, 0, &delta);
            TextLeft64 += delta.x;
            TextTop64 -= delta.y;
        }
        DPRINT("TextLeft64: %I64d\n", TextLeft64);
        DPRINT("TextTop64: %I64d\n", TextTop64);
        DPRINT("Advance: %d\n", realglyph->root.advance.x);

        DestRect.left = ((TextLeft64 + 32) >> 6) + realglyph->left;
        DestRect.right = DestRect.left + realglyph->bitmap.width;
        DestRect.top = ((TextTop64 + 32) >> 6) - realglyph->top;
        DestRect.bottom = DestRect.top + realglyph->bitmap.rows;

        bitSize.cx = realglyph->bitmap.width;
        bitSize.cy = realglyph->bitmap.rows;
        MaskRect.right = realglyph->bitmap.width;
        MaskRect.bottom = realglyph->bitmap.rows;

        /* Check if the bitmap has any pixels */
        if ((bitSize.cx != 0) && (bitSize.cy != 0))
        {
            /*
             * We should create the bitmap out of the loop at the biggest possible
             * glyph size. Then use memset with 0 to clear it and sourcerect to
             * limit the work of the transbitblt.
             */
            HSourceGlyph = EngCreateBitmap(bitSize, realglyph->bitmap.pitch,
                                           BMF_8BPP, BMF_TOPDOWN,
                                           realglyph->bitmap.buffer);
            if ( !HSourceGlyph )
            {
                DPRINT1("WARNING: EngCreateBitmap() failed!\n");
                bResult = FALSE;
                if (EmuBold || EmuItalic)
                {
                    FT_Done_Glyph((FT_Glyph)realglyph);
                }

                break;
            }
            SourceGlyphSurf = EngLockSurface((HSURF)HSourceGlyph);
            if ( !SourceGlyphSurf )
            {
                EngDeleteSurface((HSURF)HSourceGlyph);
                DPRINT1("WARNING: EngLockSurface() failed!\n");
                bResult = FALSE;
                if (EmuBold || EmuItalic)
                {
                    FT_Done_Glyph((FT_Glyph)realglyph);
                }

                break;
            }

            /*
             * Use the font data as a mask to paint onto the DCs surface using a
             * brush.
             */
            if (lprc && (fuOptions & ETO_CLIPPED) &&
                    DestRect.right >= lprc->right + dc->ptlDCOrig.x)
            {
                // We do the check '>=' instead of '>' to possibly save an iteration
                // through this loop, since it's breaking after the drawing is done,
                // and x is always incremented.
                DestRect.right = lprc->right + dc->ptlDCOrig.x;
                DoBreak = TRUE;
            }
            if (lprc && (fuOptions & ETO_CLIPPED) &&
                    DestRect.bottom >= lprc->bottom + dc->ptlDCOrig.y)
            {
                DestRect.bottom = lprc->bottom + dc->ptlDCOrig.y;
            }

            if (dc->dctype == DCTYPE_DIRECT)
                MouseSafetyOnDrawStart(dc->ppdev, DestRect.left, DestRect.top, DestRect.right, DestRect.bottom);

            if (!IntEngMaskBlt(
                SurfObj,
                SourceGlyphSurf,
                (CLIPOBJ *)&dc->co,
                &exloRGB2Dst.xlo,
                &exloDst2RGB.xlo,
                &DestRect,
                (PPOINTL)&MaskRect,
                &dc->eboText.BrushObject,
                &BrushOrigin))
            {
                DPRINT1("Failed to MaskBlt a glyph!\n");
            }

            if (dc->dctype == DCTYPE_DIRECT)
                MouseSafetyOnDrawEnd(dc->ppdev) ;

            EngUnlockSurface(SourceGlyphSurf);
            EngDeleteSurface((HSURF)HSourceGlyph);
        }

        if (DoBreak)
        {
            if (EmuBold || EmuItalic)
            {
                FT_Done_Glyph((FT_Glyph)realglyph);
            }

            break;
        }

        if (NULL == Dx)
        {
            TextLeft64 += realglyph->root.advance.x >> 10;
            TextTop64 -= realglyph->root.advance.y >> 10;
            DPRINT("New TextLeft64: %I64d\n", TextLeft64);
            DPRINT("New TextTop64: %I64d\n", TextTop64);
        }
        else
        {
            // FIXME this should probably be a matrix transform with TextTop64 as well.
            Scale = pdcattr->mxWorldToDevice.efM11;
            if (FLOATOBJ_Equal0(&Scale))
                FLOATOBJ_Set1(&Scale);

            /* do the shift before multiplying to preserve precision */
            FLOATOBJ_MulLong(&Scale, Dx[i<<DxShift] << 6); 
            TextLeft64 += FLOATOBJ_GetLong(&Scale);
            DPRINT("New TextLeft64 2: %I64d\n", TextLeft64);
        }

        if (DxShift)
        {
            TextTop64 -= Dx[2 * i + 1] << 6;
        }

        previous = glyph_index;

        /* No cache, so clean up */
        if (!bNeedCache)
        {
            FT_Done_Glyph((FT_Glyph)realglyph);
        }
    }

    if (plf->lfUnderline || plf->lfStrikeOut)
    {
        INT x0 = min(vecs[0].x, vecs[2].x);
        INT y0 = min(vecs[0].y, vecs[2].y);
        INT x1 = max(vecs[0].x, vecs[2].x);
        INT y1 = max(vecs[0].y, vecs[2].y);
        if (dc->dctype == DCTYPE_DIRECT)
            MouseSafetyOnDrawStart(dc->ppdev, x0, y0, x1, y1);
    }

    if (plf->lfUnderline)
    {
        for (i = -thickness / 2; i < -thickness / 2 + thickness; ++i)
        {
            LONG dx = (LONG)(DeltaX64 >> 6), dy = (LONG)(DeltaY64 >> 6);
            if (labs(dx) > labs(dy))
            {
                // move vertical
                EngLineTo(SurfObj, (CLIPOBJ *)&dc->co,
                          &dc->eboText.BrushObject,
                          vecs[5].x, vecs[5].y + i,
                          vecs[6].x, vecs[6].y + i,
                          NULL, ROP2_TO_MIX(R2_COPYPEN));
            }
            else
            {
                // move horizontal
                EngLineTo(SurfObj, (CLIPOBJ *)&dc->co,
                          &dc->eboText.BrushObject,
                          vecs[5].x + i, vecs[5].y,
                          vecs[6].x + i, vecs[6].y,
                          NULL, ROP2_TO_MIX(R2_COPYPEN));
            }
        }
    }

    if (plf->lfStrikeOut)
    {
        for (i = -thickness / 2; i < -thickness / 2 + thickness; ++i)
        {
            LONG dx = (LONG)(DeltaX64 >> 6), dy = (LONG)(DeltaY64 >> 6);
            if (labs(dx) > labs(dy))
            {
                // move vertical
                EngLineTo(SurfObj, (CLIPOBJ *)&dc->co,
                          &dc->eboText.BrushObject,
                          vecs[7].x, vecs[7].y + i,
                          vecs[8].x, vecs[8].y + i,
                          NULL, ROP2_TO_MIX(R2_COPYPEN));
            }
            else
            {
                // move horizontal
                EngLineTo(SurfObj, (CLIPOBJ *)&dc->co,
                          &dc->eboText.BrushObject,
                          vecs[7].x + i, vecs[7].y,
                          vecs[8].x + i, vecs[8].y,
                          NULL, ROP2_TO_MIX(R2_COPYPEN));
            }
        }
    }

    if (plf->lfUnderline || plf->lfStrikeOut)
    {
        if (dc->dctype == DCTYPE_DIRECT)
            MouseSafetyOnDrawEnd(dc->ppdev);
    }

    if (pdcattr->flTextAlign & TA_UPDATECP) {
        pdcattr->ptlCurrent.x = DestRect.right - dc->ptlDCOrig.x;
    }

    IntUnLockFreeType();

    EXLATEOBJ_vCleanup(&exloRGB2Dst);
    EXLATEOBJ_vCleanup(&exloDst2RGB);

Cleanup:

    DC_vFinishBlit(dc, NULL);

    if (TextObj != NULL)
        TEXTOBJ_UnlockText(TextObj);

    return bResult;
}

Referenced by GdiFlushUserBatch(), and GreExtTextOutW().

IntPatBlt()

BOOL FASTCALL IntPatBlt	(	PDC	,
		INT	,
		INT	,
		INT	,
		INT	,
		DWORD	,
		PEBRUSHOBJ
	)

Definition at line 777 of file bitblt.c.

{
    RECTL DestRect;
    SURFACE *psurf;
    POINTL BrushOrigin;
    BOOL ret;
    PBRUSH pbrush;

    ASSERT(pebo);
    pbrush = pebo->pbrush;
    ASSERT(pbrush);

    if (pbrush->flAttrs & BR_IS_NULL)
    {
        return TRUE;
    }

    if (Width > 0)
    {
        DestRect.left = XLeft;
        DestRect.right = XLeft + Width;
    }
    else
    {
        DestRect.left = XLeft + Width + 1;
        DestRect.right = XLeft + 1;
    }

    if (Height > 0)
    {
        DestRect.top = YLeft;
        DestRect.bottom = YLeft + Height;
    }
    else
    {
        DestRect.top = YLeft + Height + 1;
        DestRect.bottom = YLeft + 1;
    }

    IntLPtoDP(pdc, (LPPOINT)&DestRect, 2);

    DestRect.left   += pdc->ptlDCOrig.x;
    DestRect.top    += pdc->ptlDCOrig.y;
    DestRect.right  += pdc->ptlDCOrig.x;
    DestRect.bottom += pdc->ptlDCOrig.y;

    if (pdc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
    {
       IntUpdateBoundsRect(pdc, &DestRect);
    }

#ifdef _USE_DIBLIB_
    BrushOrigin.x = pbrush->ptOrigin.x + pdc->ptlDCOrig.x + XLeft;
    BrushOrigin.y = pbrush->ptOrigin.y + pdc->ptlDCOrig.y + YLeft;
#else
    BrushOrigin.x = pbrush->ptOrigin.x + pdc->ptlDCOrig.x;
    BrushOrigin.y = pbrush->ptOrigin.y + pdc->ptlDCOrig.y;
#endif

    DC_vPrepareDCsForBlit(pdc, &DestRect, NULL, NULL);

    psurf = pdc->dclevel.pSurface;

    ret = IntEngBitBlt(&psurf->SurfObj,
                       NULL,
                       NULL,
                       (CLIPOBJ *)&pdc->co,
                       NULL,
                       &DestRect,
                       NULL,
                       NULL,
                       &pebo->BrushObject,
                       &BrushOrigin,
                       WIN32_ROP3_TO_ENG_ROP4(dwRop3));

    DC_vFinishBlit(pdc, NULL);

    return ret;
}

Referenced by GdiFlushUserBatch(), IntGdiPolyPatBlt(), NtGdiPatBlt(), and NtGdiSetPixel().

NtGdiFlush()

__kernel_entry NTSTATUS APIENTRY NtGdiFlush

(

VOID

)

Definition at line 429 of file gdibatch.c.

{
    SynchronizeDriver(GCAPS2_SYNCFLUSH);
    return STATUS_SUCCESS;
}

Referenced by ExtSelectClipRgn(), GdiAllocBatchCommand(), GdiFlush(), OffsetViewportOrgEx(), OffsetWindowOrgEx(), SetGraphicsMode(), SetMapperFlags(), SetPolyFillMode(), SetROP2(), SetTextCharacterExtra(), SetTextJustification(), SetViewportExtEx(), SetWindowExtEx(), and SetWindowOrgEx().

NtGdiFlushUserBatch()

NTSTATUS APIENTRY NtGdiFlushUserBatch

(

VOID

)

Definition at line 445 of file gdibatch.c.

{
  PTEB pTeb = NtCurrentTeb();
  ULONG GdiBatchCount = pTeb->GdiBatchCount;

  if( (GdiBatchCount > 0) && (GdiBatchCount <= (GDIBATCHBUFSIZE/4)))
  {
    HDC hDC = (HDC) pTeb->GdiTebBatch.HDC;

    /*  If hDC is zero and the buffer fills up with delete objects we need
        to run anyway.
     */
    if (hDC || GdiBatchCount)
    {
      PCHAR pHdr = (PCHAR)&pTeb->GdiTebBatch.Buffer[0];
      PDC pDC = NULL;

      if (GDI_HANDLE_GET_TYPE(hDC) == GDILoObjType_LO_DC_TYPE && GreIsHandleValid(hDC))
      {
          pDC = DC_LockDc(hDC);
      }

       // No need to init anything, just go!
       for (; GdiBatchCount > 0; GdiBatchCount--)
       {
           ULONG Size;
           // Process Gdi Batch!
           Size = GdiFlushUserBatch(pDC, (PGDIBATCHHDR) pHdr);
           if (!Size) break;
           pHdr += Size;
       }

       if (pDC)
       {
           DC_UnlockDc(pDC);
       }

       // Exit and clear out for the next round.
       pTeb->GdiTebBatch.Offset = 0;
       pTeb->GdiBatchCount = 0;
       pTeb->GdiTebBatch.HDC = 0;
    }
  }

  // FIXME: On Windows XP the function returns &pTeb->RealClientId, maybe VOID?
  return STATUS_SUCCESS;
}

Referenced by DriverEntry(), and NtGdiDeleteObjectApp().

SynchronizeDriver()

VOID FASTCALL SynchronizeDriver

(

FLONG

Flags

)

Definition at line 45 of file gdibatch.c.

{
  SURFOBJ *SurfObj;
  //PPDEVOBJ Device;

  if (Flags & GCAPS2_SYNCFLUSH)
      Flags = DSS_FLUSH_EVENT;
  if (Flags & GCAPS2_SYNCTIMER)
      Flags = DSS_TIMER_EVENT;

  //Device = IntEnumHDev();
//  UNIMPLEMENTED;
//ASSERT(FALSE);
  SurfObj = 0;// EngLockSurface( Device->pSurface );
  if(!SurfObj) return;
  DoDeviceSync( SurfObj, NULL, Flags);
  EngUnlockSurface(SurfObj);
  return;
}

Referenced by NtGdiFlush().