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, flXform = 0, saveflags, saveflXform = 0;
        FLONG flTextAlign = -1;
        HANDLE hlfntNew;
        PRECTL lprc;
        USHORT jBkMode;
        LONG lBkMode;
        POINTL ptlViewportOrg;
        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;
        }
 
        if ( dc->pdcattr->ptlViewportOrg.x != pgO->ptlViewportOrg.x ||
             dc->pdcattr->ptlViewportOrg.y != pgO->ptlViewportOrg.y )
        {
            saveflXform = dc->pdcattr->flXform & (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
            ptlViewportOrg = dc->pdcattr->ptlViewportOrg;
            dc->pdcattr->ptlViewportOrg = pgO->ptlViewportOrg;
            flXform = (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
        }
 
        dc->pdcattr->flXform  |= flXform;
        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 (saveflXform)
        {
            dc->pdcattr->ptlViewportOrg = ptlViewportOrg;
            dc->pdcattr->flXform |= saveflXform|flXform;
        }
 
        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;
        dc->pdcattr->flXform  |= saveflXform | flXform;
        break;
     }
 
     case GdiBCExtTextOut:
     {
        PGDIBSEXTTEXTOUT pgO;
        COLORREF crBkColor;
        ULONG ulBackgroundClr;
        POINTL ptlViewportOrg;
        DWORD flags = 0, flXform = 0, saveflags, saveflXform = 0;
        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);
        }
 
        if ( dc->pdcattr->ptlViewportOrg.x != pgO->ptlViewportOrg.x ||
             dc->pdcattr->ptlViewportOrg.y != pgO->ptlViewportOrg.y )
        {
            saveflXform = dc->pdcattr->flXform & (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
            ptlViewportOrg = dc->pdcattr->ptlViewportOrg;
            dc->pdcattr->ptlViewportOrg = pgO->ptlViewportOrg;
            flXform = (PAGE_XLATE_CHANGED|WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID);
        }
 
        dc->pdcattr->flXform  |= flXform;
        dc->pdcattr->ulDirty_ |= flags;
 
        IntExtTextOutW( dc,
                        0,
                        0,
                        pgO->Options,
                       &pgO->Rect,
                        NULL,
                        pgO->Count,
                        NULL,
                        0 );
 
        if (saveflXform)
        {
            dc->pdcattr->ptlViewportOrg = ptlViewportOrg;
            dc->pdcattr->flXform |= saveflXform|flXform;
        }
 
        if (flags & DIRTY_BACKGROUND)
        {
            dc->pdcattr->crBackgroundClr = crBkColor;
            dc->pdcattr->ulBackgroundClr = ulBackgroundClr;
        }
        dc->pdcattr->ulDirty_ |= saveflags | flags;
        dc->pdcattr->flXform  |= saveflXform | flXform;
        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:
     {
        PGDIBSEXTSELCLPRGN pgO;
        if (!dc) break;
        pgO = (PGDIBSEXTSELCLPRGN) pHdr;
        IntGdiExtSelectClipRect( dc, &pgO->rcl, pgO->fnMode);
        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 6031 of file freetype.c.

{
    /*
     * FIXME:
     * Call EngTextOut, which does the real work (calling DrvTextOut where
     * appropriate)
     */
 
    PDC_ATTR pdcattr;
    SURFOBJ *SurfObj, *SourceGlyphSurf;
    SURFACE *psurf;
    INT glyph_index, i;
    FT_Face face;
    FT_BitmapGlyph realglyph;
    LONGLONG X64, Y64, RealXStart64, RealYStart64, DeltaX64, DeltaY64;
    ULONG previous;
    RECTL DestRect, MaskRect;
    HBITMAP HSourceGlyph;
    SIZEL bitSize;
    FONTOBJ *FontObj;
    PFONTGDI FontGDI;
    PTEXTOBJ TextObj = NULL;
    EXLATEOBJ exloRGB2Dst, exloDst2RGB;
    POINT Start;
    PMATRIX pmxWorldToDevice;
    FT_Vector delta, vecAscent64, vecDescent64;
    LOGFONTW *plf;
    BOOL use_kerning, bResult, DoBreak;
    FONT_CACHE_ENTRY Cache;
    FT_Matrix mat;
 
    /* Check if String is valid */
    if (Count > 0xFFFF || (Count > 0 && String == NULL))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (PATH_IsPathOpen(dc->dclevel))
    {
        return PATH_ExtTextOut(dc,
                               XStart, YStart,
                               fuOptions,
                               lprc,
                               String, Count,
                               Dx);
    }
 
    DC_vPrepareDCsForBlit(dc, NULL, NULL, NULL);
 
    if (!dc->dclevel.pSurface)
    {
        /* Memory DC with no surface selected */
        bResult = TRUE;
        goto Cleanup;
    }
 
    pdcattr = dc->pdcattr;
    if (pdcattr->flTextAlign & TA_UPDATECP)
    {
        Start.x = pdcattr->ptlCurrent.x;
        Start.y = pdcattr->ptlCurrent.y;
    }
    else
    {
        Start.x = XStart;
        Start.y = YStart;
    }
 
    IntLPtoDP(dc, &Start, 1);
    RealXStart64 = ((LONGLONG)Start.x + dc->ptlDCOrig.x) << 6;
    RealYStart64 = ((LONGLONG)Start.y + dc->ptlDCOrig.y) << 6;
 
    MaskRect.left = 0;
    MaskRect.top = 0;
 
    psurf = dc->dclevel.pSurface;
    SurfObj = &psurf->SurfObj;
 
    if (pdcattr->iGraphicsMode == GM_ADVANCED)
        pmxWorldToDevice = DC_pmxWorldToDevice(dc);
    else
        pmxWorldToDevice = (PMATRIX)&gmxWorldToDeviceDefault;
 
    if (pdcattr->ulDirty_ & DIRTY_BACKGROUND)
        DC_vUpdateBackgroundBrush(dc);
 
    if (lprc && (fuOptions & (ETO_CLIPPED | ETO_OPAQUE)))
    {
        IntLPtoDP(dc, (POINT*)lprc, 2);
        lprc->left   += dc->ptlDCOrig.x;
        lprc->top    += dc->ptlDCOrig.y;
        lprc->right  += dc->ptlDCOrig.x;
        lprc->bottom += dc->ptlDCOrig.y;
    }
 
    if (lprc && (fuOptions & ETO_OPAQUE))
    {
        IntEngFillBox(dc,
                      lprc->left, lprc->top,
                      lprc->right - lprc->left, lprc->bottom - lprc->top,
                      &dc->eboBackground.BrushObject);
        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();
    Cache.Hashed.Face = face = FontGDI->SharedFace->Face;
 
    plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
    Cache.Hashed.lfHeight = plf->lfHeight;
    Cache.Hashed.lfWidth = plf->lfWidth;
    Cache.Hashed.Aspect.Emu.Bold = EMUBOLD_NEEDED(FontGDI->OriginalWeight, plf->lfWeight);
    Cache.Hashed.Aspect.Emu.Italic = (plf->lfItalic && !FontGDI->OriginalItalic);
 
    if (IntIsFontRenderingEnabled())
        Cache.Hashed.Aspect.RenderMode = (BYTE)IntGetFontRenderMode(plf);
    else
        Cache.Hashed.Aspect.RenderMode = (BYTE)FT_RENDER_MODE_MONO;
 
    if (!TextIntUpdateSize(dc, TextObj, FontGDI, FALSE))
    {
        IntUnLockFreeType();
        bResult = FALSE;
        goto Cleanup;
    }
 
    /* Apply lfEscapement */
    if (FT_IS_SCALABLE(face) && plf->lfEscapement != 0)
        IntEscapeMatrix(&Cache.Hashed.matTransform, plf->lfEscapement);
    else
        Cache.Hashed.matTransform = identityMat;
 
    /* Apply the world transformation */
    IntMatrixFromMx(&mat, pmxWorldToDevice);
    FT_Matrix_Multiply(&mat, &Cache.Hashed.matTransform);
    FT_Set_Transform(face, &Cache.Hashed.matTransform, NULL);
 
    /* Calculate the ascent point and the descent point */
    vecAscent64.x = 0;
    vecAscent64.y = (FontGDI->tmAscent << 6);
    FT_Vector_Transform(&vecAscent64, &Cache.Hashed.matTransform);
    vecDescent64.x = 0;
    vecDescent64.y = -(FontGDI->tmDescent << 6);
    FT_Vector_Transform(&vecDescent64, &Cache.Hashed.matTransform);
 
    /* Process the vertical alignment and fix the real starting point. */
#define VALIGN_MASK  (TA_TOP | TA_BASELINE | TA_BOTTOM)
    if ((pdcattr->flTextAlign & VALIGN_MASK) == TA_BASELINE)
    {
        NOTHING;
    }
    else if ((pdcattr->flTextAlign & VALIGN_MASK) == TA_BOTTOM)
    {
        RealXStart64 -= vecDescent64.x;
        RealYStart64 += vecDescent64.y;
    }
    else /* TA_TOP */
    {
        RealXStart64 -= vecAscent64.x;
        RealYStart64 += vecAscent64.y;
    }
#undef VALIGN_MASK
 
    use_kerning = FT_HAS_KERNING(face);
 
    /* Calculate the text width if necessary */
    if ((fuOptions & ETO_OPAQUE) || (pdcattr->flTextAlign & (TA_CENTER | TA_RIGHT)))
    {
        if (!IntGetTextDisposition(&DeltaX64, &DeltaY64, String, Count, Dx, &Cache, fuOptions))
        {
            IntUnLockFreeType();
            bResult = FALSE;
            goto Cleanup;
        }
 
        /* Adjust the horizontal position by horizontal alignment */
        if ((pdcattr->flTextAlign & TA_CENTER) == TA_CENTER)
        {
            RealXStart64 -= DeltaX64 / 2;
            RealYStart64 -= DeltaY64 / 2;
        }
        else if ((pdcattr->flTextAlign & TA_RIGHT) == TA_RIGHT)
        {
            RealXStart64 -= DeltaX64;
            RealYStart64 -= DeltaY64;
        }
 
        /* Fill background */
        if (fuOptions & ETO_OPAQUE)
        {
            INT X0 = (RealXStart64 + vecAscent64.x + 32) >> 6;
            INT Y0 = (RealYStart64 - vecAscent64.y + 32) >> 6;
            INT DX = (DeltaX64 >> 6);
            if (Cache.Hashed.matTransform.xy == 0 && Cache.Hashed.matTransform.yx == 0)
            {
                INT CY = (vecAscent64.y - vecDescent64.y + 32) >> 6;
                IntEngFillBox(dc, X0, Y0, DX, CY, &dc->eboBackground.BrushObject);
            }
            else
            {
                INT DY = (DeltaY64 >> 6);
                INT X1 = ((RealXStart64 + vecDescent64.x + 32) >> 6);
                INT Y1 = ((RealYStart64 - vecDescent64.y + 32) >> 6);
                POINT Points[4] =
                {
                    { X0,       Y0      },
                    { X0 + DX,  Y0 + DY },
                    { X1 + DX,  Y1 + DY },
                    { X1,       Y1      },
                };
                IntEngFillPolygon(dc, Points, 4, &dc->eboBackground.BrushObject);
            }
        }
    }
 
    EXLATEOBJ_vInitialize(&exloRGB2Dst, &gpalRGB, psurf->ppal, 0, 0, 0);
    EXLATEOBJ_vInitialize(&exloDst2RGB, psurf->ppal, &gpalRGB, 0, 0, 0);
 
    /* Assume success */
    bResult = TRUE;
 
    if (pdcattr->ulDirty_ & DIRTY_TEXT)
        DC_vUpdateTextBrush(dc);
 
    /*
     * The main rendering loop.
     */
    X64 = RealXStart64;
    Y64 = RealYStart64;
    previous = 0;
    DoBreak = FALSE;
    for (i = 0; i < Count; ++i)
    {
        glyph_index = get_glyph_index_flagged(face, *String++, ETO_GLYPH_INDEX, fuOptions);
        Cache.Hashed.GlyphIndex = glyph_index;
 
        realglyph = IntGetRealGlyph(&Cache);
        if (!realglyph)
        {
            bResult = FALSE;
            break;
        }
 
        /* retrieve kerning distance and move pen position */
        if (use_kerning && previous && glyph_index && NULL == Dx)
        {
            FT_Get_Kerning(face, previous, glyph_index, 0, &delta);
            X64 += delta.x;
            Y64 -= delta.y;
        }
 
        DPRINT("X64, Y64: %I64d, %I64d\n", X64, Y64);
        DPRINT("Advance: %d, %d\n", realglyph->root.advance.x, realglyph->root.advance.y);
 
        bitSize.cx = realglyph->bitmap.width;
        bitSize.cy = realglyph->bitmap.rows;
 
        MaskRect.right = realglyph->bitmap.width;
        MaskRect.bottom = realglyph->bitmap.rows;
 
        DestRect.left   = ((X64 + 32) >> 6) + realglyph->left;
        DestRect.right  = DestRect.left + bitSize.cx;
        DestRect.top    = ((Y64 + 32) >> 6) - realglyph->top;
        DestRect.bottom = DestRect.top + bitSize.cy;
 
        /* 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 (Cache.Hashed.Aspect.EmuBoldItalic)
                    FT_Done_Glyph((FT_Glyph)realglyph);
                break;
            }
 
            SourceGlyphSurf = EngLockSurface((HSURF)HSourceGlyph);
            if (!SourceGlyphSurf)
            {
                EngDeleteSurface((HSURF)HSourceGlyph);
                DPRINT1("WARNING: EngLockSurface() failed!\n");
                bResult = FALSE;
                if (Cache.Hashed.Aspect.EmuBoldItalic)
                    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))
            {
                // 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.
                if (DestRect.right >= lprc->right)
                {
                    DestRect.right = lprc->right;
                    DoBreak = TRUE;
                }
 
                if (DestRect.bottom >= lprc->bottom)
                {
                    DestRect.bottom = lprc->bottom;
                }
            }
 
            if (!IntEngMaskBlt(SurfObj,
                               SourceGlyphSurf,
                               (CLIPOBJ *)&dc->co,
                               &exloRGB2Dst.xlo,
                               &exloDst2RGB.xlo,
                               &DestRect,
                               (PPOINTL)&MaskRect,
                               &dc->eboText.BrushObject,
                               &PointZero))
            {
                DPRINT1("Failed to MaskBlt a glyph!\n");
            }
 
            EngUnlockSurface(SourceGlyphSurf);
            EngDeleteSurface((HSURF)HSourceGlyph);
        }
 
        if (DoBreak)
        {
            if (Cache.Hashed.Aspect.EmuBoldItalic)
                FT_Done_Glyph((FT_Glyph)realglyph);
            break;
        }
 
        if (NULL == Dx)
        {
            X64 += realglyph->root.advance.x >> 10;
            Y64 -= realglyph->root.advance.y >> 10;
        }
        else if (fuOptions & ETO_PDY)
        {
            FT_Vector vec = { Dx[2 * i + 0] << 6, Dx[2 * i + 1] << 6 };
            FT_Vector_Transform(&vec, &Cache.Hashed.matTransform);
            X64 += vec.x;
            Y64 -= vec.y;
        }
        else
        {
            FT_Vector vec = { Dx[i] << 6, 0 };
            FT_Vector_Transform(&vec, &Cache.Hashed.matTransform);
            X64 += vec.x;
            Y64 -= vec.y;
        }
 
        DPRINT("New X64, New Y64: %I64d, %I64d\n", X64, Y64);
 
        previous = glyph_index;
 
        if (Cache.Hashed.Aspect.EmuBoldItalic)
        {
            FT_Done_Glyph((FT_Glyph)realglyph);
        }
    }
 
    if (pdcattr->flTextAlign & TA_UPDATECP)
        pdcattr->ptlCurrent.x = DestRect.right - dc->ptlDCOrig.x;
 
    if (plf->lfUnderline || plf->lfStrikeOut) /* Underline or strike-out? */
    {
        /* Calculate the position and the thickness */
        INT underline_position, thickness;
        FT_Vector vecA64, vecB64;
 
        DeltaX64 = X64 - RealXStart64;
        DeltaY64 = Y64 - RealYStart64;
 
        if (!face->units_per_EM)
        {
            underline_position = 0;
            thickness = 1;
        }
        else
        {
            underline_position =
                face->underline_position * face->size->metrics.y_ppem / face->units_per_EM;
            thickness =
                face->underline_thickness * face->size->metrics.y_ppem / face->units_per_EM;
            if (thickness <= 0)
                thickness = 1;
        }
 
        if (plf->lfUnderline) /* Draw underline */
        {
            vecA64.x = 0;
            vecA64.y = (-underline_position - thickness / 2) << 6;
            vecB64.x = 0;
            vecB64.y = vecA64.y + (thickness << 6);
            FT_Vector_Transform(&vecA64, &Cache.Hashed.matTransform);
            FT_Vector_Transform(&vecB64, &Cache.Hashed.matTransform);
            {
                INT X0 = (RealXStart64 - vecA64.x + 32) >> 6;
                INT Y0 = (RealYStart64 + vecA64.y + 32) >> 6;
                INT DX = (DeltaX64 >> 6);
                if (Cache.Hashed.matTransform.xy == 0 && Cache.Hashed.matTransform.yx == 0)
                {
                    INT CY = (vecB64.y - vecA64.y + 32) >> 6;
                    IntEngFillBox(dc, X0, Y0, DX, CY, &dc->eboText.BrushObject);
                }
                else
                {
                    INT DY = (DeltaY64 >> 6);
                    INT X1 = X0 + ((vecA64.x - vecB64.x + 32) >> 6);
                    INT Y1 = Y0 + ((vecB64.y - vecA64.y + 32) >> 6);
                    POINT Points[4] =
                    {
                        { X0,       Y0      },
                        { X0 + DX,  Y0 + DY },
                        { X1 + DX,  Y1 + DY },
                        { X1,       Y1      },
                    };
                    IntEngFillPolygon(dc, Points, 4, &dc->eboText.BrushObject);
                }
            }
        }
 
        if (plf->lfStrikeOut) /* Draw strike-out */
        {
            vecA64.x = 0;
            vecA64.y = -(FontGDI->tmAscent << 6) / 3;
            vecB64.x = 0;
            vecB64.y = vecA64.y + (thickness << 6);
            FT_Vector_Transform(&vecA64, &Cache.Hashed.matTransform);
            FT_Vector_Transform(&vecB64, &Cache.Hashed.matTransform);
            {
                INT X0 = (RealXStart64 - vecA64.x + 32) >> 6;
                INT Y0 = (RealYStart64 + vecA64.y + 32) >> 6;
                INT DX = (DeltaX64 >> 6);
                if (Cache.Hashed.matTransform.xy == 0 && Cache.Hashed.matTransform.yx == 0)
                {
                    INT CY = (vecB64.y - vecA64.y + 32) >> 6;
                    IntEngFillBox(dc, X0, Y0, DX, CY, &dc->eboText.BrushObject);
                }
                else
                {
                    INT DY = (DeltaY64 >> 6);
                    INT X1 = X0 + ((vecA64.x - vecB64.x + 32) >> 6);
                    INT Y1 = Y0 + ((vecB64.y - vecA64.y + 32) >> 6);
                    POINT Points[4] =
                    {
                        { X0,       Y0      },
                        { X0 + DX,  Y0 + DY },
                        { X1 + DX,  Y1 + DY },
                        { X1,       Y1      },
                    };
                    IntEngFillPolygon(dc, Points, 4, &dc->eboText.BrushObject);
                }
            }
        }
    }
 
    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	pdc,
		INT	XLeft,
		INT	YLeft,
		INT	Width,
		INT	Height,
		DWORD	dwRop3,
		PEBRUSHOBJ	pebo
	)

Definition at line 837 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 471 of file gdibatch.c.

{
    SynchronizeDriver(GCAPS2_SYNCFLUSH);
    return STATUS_SUCCESS;
}

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

NtGdiFlushUserBatch()

NTSTATUS APIENTRY NtGdiFlushUserBatch

(

VOID

)

Definition at line 487 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().

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().