intgdi.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	WIN32_ROP3_TO_ENG_ROP4(dwRop4)   ((((dwRop4) & 0x00FF0000) >> 16) | (((dwRop4) & 0x00FF0000) >> 8))
#define	WIN32_ROP4_TO_ENG_ROP4(dwRop4)   ((dwRop4) >> 16)
#define	WIN32_ROP4_USES_SOURCE(Rop)   ((((Rop) & 0xCCCC0000) >> 2) != ((Rop) & 0x33330000))
#define	FIXUP_ROP2(rop2)   ((((rop2) - 1) & 0xF) + 1)

Functions
BOOL FASTCALL	IntGdiLineTo (DC *dc, int XEnd, int YEnd)
BOOL FASTCALL	IntGdiMoveToEx (DC *dc, int X, int Y, LPPOINT Point)
BOOL FASTCALL	IntGdiPolyBezier (DC *dc, LPPOINT pt, DWORD Count)
BOOL FASTCALL	IntGdiPolyline (DC *dc, LPPOINT pt, int Count)
BOOL FASTCALL	IntGdiPolyBezierTo (DC *dc, LPPOINT pt, DWORD Count)
BOOL FASTCALL	IntGdiPolyPolyline (DC *dc, LPPOINT pt, PULONG PolyPoints, DWORD Count)
BOOL FASTCALL	IntGdiPolylineTo (DC *dc, LPPOINT pt, DWORD Count)
BOOL FASTCALL	GreMoveTo (HDC hdc, INT x, INT y, LPPOINT pptOut)
BOOL NTAPI	GreGradientFill (HDC hdc, PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, ULONG ulMode)
HDC FASTCALL	IntGdiCreateDC (PUNICODE_STRING Driver, PUNICODE_STRING Device, PVOID pUMdhpdev, CONST PDEVMODEW InitData, BOOL CreateAsIC)
VOID FASTCALL	IntSetSysColors (UINT nColors, CONST INT *Elements, CONST COLORREF *Colors)
HGDIOBJ FASTCALL	IntGetSysColorBrush (INT Object)
DWORD FASTCALL	IntGetSysColor (INT nIndex)
NTSTATUS APIENTRY	NtGdiFlushUserBatch (VOID)
DWORD APIENTRY	NtDxEngGetRedirectionBitmap (DWORD Unknown0)
HBITMAP FASTCALL	IntCreateCompatibleBitmap (_In_ PDC Dc, _In_ INT Width, _In_ INT Height, _In_ UINT Bpp, _In_ UINT Planes)
WORD APIENTRY	IntGdiSetHookFlags (HDC hDC, WORD Flags)
UINT APIENTRY	IntSetDIBColorTable (HDC hDC, UINT StartIndex, UINT Entries, CONST RGBQUAD *Colors)
UINT APIENTRY	IntGetDIBColorTable (HDC hDC, UINT StartIndex, UINT Entries, RGBQUAD *Colors)
UINT APIENTRY	IntGetPaletteEntries (HPALETTE hpal, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
UINT APIENTRY	IntGetSystemPaletteEntries (HDC hDC, UINT StartIndex, UINT Entries, LPPALETTEENTRY pe)
VOID FASTCALL	CreateStockObjects (VOID)
VOID FASTCALL	CreateSysColorObjects (VOID)
PPOINT	GDI_Bezier (const POINT *Points, INT count, PINT nPtsOut)
BOOL FASTCALL	IntFillArc (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, double StartArc, double EndArc, ARCTYPE arctype)
BOOL FASTCALL	IntDrawArc (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, double StartArc, double EndArc, ARCTYPE arctype, PBRUSH pbrush)
BOOL FASTCALL	IntFillEllipse (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, PBRUSH pbrush)
BOOL FASTCALL	IntDrawEllipse (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, PBRUSH pbrush)
BOOL FASTCALL	IntFillRoundRect (PDC dc, INT Left, INT Top, INT Right, INT Bottom, INT Wellipse, INT Hellipse, PBRUSH pbrush)
BOOL FASTCALL	IntDrawRoundRect (PDC dc, INT Left, INT Top, INT Right, INT Bottom, INT Wellipse, INT Hellipse, PBRUSH pbrush)

Variables
HDC	hSystemBM
HSEMAPHORE	hsemDriverMgmt

Macro Definition Documentation

FIXUP_ROP2

#define FIXUP_ROP2

(

rop2

)

((((rop2) - 1) & 0xF) + 1)

Definition at line 10 of file intgdi.h.

WIN32_ROP3_TO_ENG_ROP4

#define WIN32_ROP3_TO_ENG_ROP4

(

dwRop4

)

((((dwRop4) & 0x00FF0000) >> 16) | (((dwRop4) & 0x00FF0000) >> 8))

Definition at line 4 of file intgdi.h.

WIN32_ROP4_TO_ENG_ROP4

#define WIN32_ROP4_TO_ENG_ROP4

(

dwRop4

)

((dwRop4) >> 16)

Definition at line 5 of file intgdi.h.

WIN32_ROP4_USES_SOURCE

#define WIN32_ROP4_USES_SOURCE

(

Rop

)

((((Rop) & 0xCCCC0000) >> 2) != ((Rop) & 0x33330000))

Definition at line 7 of file intgdi.h.

Function Documentation

CreateStockObjects()

VOID FASTCALL CreateStockObjects

(

void

)

Creates a bunch of stock objects: brushes, pens, fonts.

Definition at line 247 of file stockobj.c.

{
    UINT Object;
 
    DPRINT("Beginning creation of stock objects\n");
 
    /* Create GDI Stock Objects from the logical structures we've defined */
 
    StockObjects[WHITE_BRUSH] =  IntGdiCreateSolidBrush(RGB(255,255,255));
    StockObjects[DC_BRUSH]    =  IntGdiCreateSolidBrush(RGB(255,255,255));
    StockObjects[LTGRAY_BRUSH] = IntGdiCreateSolidBrush(RGB(192,192,192));
    StockObjects[GRAY_BRUSH] =   IntGdiCreateSolidBrush(RGB(128,128,128));
    StockObjects[DKGRAY_BRUSH] = IntGdiCreateSolidBrush(RGB(64,64,64));
    StockObjects[BLACK_BRUSH] =  IntGdiCreateSolidBrush(RGB(0,0,0));
    StockObjects[NULL_BRUSH] =   IntGdiCreateNullBrush();
 
    StockObjects[WHITE_PEN] = IntCreateStockPen(WhitePen.lopnStyle, WhitePen.lopnWidth.x, BS_SOLID, WhitePen.lopnColor);
    StockObjects[BLACK_PEN] = IntCreateStockPen(BlackPen.lopnStyle, BlackPen.lopnWidth.x, BS_SOLID, BlackPen.lopnColor);
    StockObjects[DC_PEN]    = IntCreateStockPen(BlackPen.lopnStyle, BlackPen.lopnWidth.x, BS_SOLID, BlackPen.lopnColor);
    StockObjects[NULL_PEN]  = IntCreateStockPen(NullPen.lopnStyle, NullPen.lopnWidth.x, BS_SOLID, NullPen.lopnColor);
 
    StockObjects[20] = NULL; /* TODO: Unknown internal stock object */
    StockObjects[DEFAULT_BITMAP] = GreCreateBitmap(1, 1, 1, 1, NULL);
 
    CreateStockFonts();
 
    StockObjects[DEFAULT_PALETTE] = (HGDIOBJ)gppalDefault->BaseObject.hHmgr;
 
    for (Object = 0; Object < NB_STOCK_OBJECTS; Object++)
    {
        if (NULL != StockObjects[Object])
        {
            GDIOBJ_ConvertToStockObj(&StockObjects[Object]);
        }
    }
 
    DPRINT("Completed creation of stock objects\n");
}

Referenced by DriverEntry().

CreateSysColorObjects()

VOID FASTCALL CreateSysColorObjects

(

VOID

)

Definition at line 329 of file stockobj.c.

{
    UINT i;
 
    for (i = 0; i < NUM_SYSCOLORS; i++)
    {
        gpsi->argbSystem[i] = SysColors[i];
    }
 
    /* Create the syscolor brushes */
    for (i = 0; i < NUM_SYSCOLORS; i++)
    {
        if (gpsi->ahbrSystem[i] == NULL)
        {
            gpsi->ahbrSystem[i] = IntGdiCreateSolidBrush(SysColors[i]);
            if (gpsi->ahbrSystem[i] != NULL)
            {
                GDIOBJ_ConvertToStockObj((HGDIOBJ*)&gpsi->ahbrSystem[i]);
            }
        }
    }
}

Referenced by DriverEntry().

GDI_Bezier()

PPOINT GDI_Bezier	(	const POINT *	Points,
		INT	count,
		PINT	nPtsOut
	)

GreGradientFill()

BOOL NTAPI GreGradientFill	(	HDC	hdc,
		PTRIVERTEX	pVertex,
		ULONG	nVertex,
		PVOID	pMesh,
		ULONG	nMesh,
		ULONG	ulMode
	)

Definition at line 940 of file fillshap.c.

{
    PDC pdc;
    SURFACE *psurf;
    EXLATEOBJ exlo;
    RECTL rclExtent;
    POINTL ptlDitherOrg;
    ULONG i;
    BOOL bRet;
 
    /* Check parameters */
    if (ulMode & GRADIENT_FILL_TRIANGLE)
    {
        PGRADIENT_TRIANGLE pTriangle = (PGRADIENT_TRIANGLE)pMesh;
 
        for (i = 0; i < nMesh; i++, pTriangle++)
        {
            if (pTriangle->Vertex1 >= nVertex ||
                pTriangle->Vertex2 >= nVertex ||
                pTriangle->Vertex3 >= nVertex)
            {
                EngSetLastError(ERROR_INVALID_PARAMETER);
                return FALSE;
            }
        }
    }
    else
    {
        PGRADIENT_RECT pRect = (PGRADIENT_RECT)pMesh;
        for (i = 0; i < nMesh; i++, pRect++)
        {
            if (pRect->UpperLeft >= nVertex || pRect->LowerRight >= nVertex)
            {
                EngSetLastError(ERROR_INVALID_PARAMETER);
                return FALSE;
            }
        }
    }
 
    /* Lock the output DC */
    pdc = DC_LockDc(hdc);
    if(!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!pdc->dclevel.pSurface)
    {
        /* Memory DC with no surface selected */
        DC_UnlockDc(pdc);
        return TRUE; // CHECKME
    }
 
    /* Calculate extent */
    rclExtent.left = rclExtent.right = pVertex->x;
    rclExtent.top = rclExtent.bottom = pVertex->y;
    for (i = 0; i < nVertex; i++)
    {
        rclExtent.left = min(rclExtent.left, (pVertex + i)->x);
        rclExtent.right = max(rclExtent.right, (pVertex + i)->x);
        rclExtent.top = min(rclExtent.top, (pVertex + i)->y);
        rclExtent.bottom = max(rclExtent.bottom, (pVertex + i)->y);
    }
    IntLPtoDP(pdc, (LPPOINT)&rclExtent, 2);
 
    rclExtent.left   += pdc->ptlDCOrig.x;
    rclExtent.right  += pdc->ptlDCOrig.x;
    rclExtent.top    += pdc->ptlDCOrig.y;
    rclExtent.bottom += pdc->ptlDCOrig.y;
 
    if (RECTL_bIsEmptyRect(&rclExtent))
    {
        DC_UnlockDc(pdc);
        return TRUE;
    }
 
    ptlDitherOrg.x = ptlDitherOrg.y = 0;
    IntLPtoDP(pdc, (LPPOINT)&ptlDitherOrg, 1);
 
    ptlDitherOrg.x += pdc->ptlDCOrig.x;
    ptlDitherOrg.y += pdc->ptlDCOrig.y;
 
   if (pdc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
   {
      IntUpdateBoundsRect(pdc, &rclExtent);
   }
 
    DC_vPrepareDCsForBlit(pdc, &rclExtent, NULL, NULL);
 
    psurf = pdc->dclevel.pSurface;
 
    EXLATEOBJ_vInitialize(&exlo, &gpalRGB, psurf->ppal, 0, 0, 0);
 
    bRet = IntEngGradientFill(&psurf->SurfObj,
                             (CLIPOBJ *)&pdc->co,
                             &exlo.xlo,
                             pVertex,
                             nVertex,
                             pMesh,
                             nMesh,
                             &rclExtent,
                             &ptlDitherOrg,
                             ulMode);
 
    EXLATEOBJ_vCleanup(&exlo);
    DC_vFinishBlit(pdc, NULL);
    DC_UnlockDc(pdc);
 
    return bRet;
}

Referenced by NtGdiGradientFill(), and UserDrawCaption().

GreMoveTo()

BOOL FASTCALL GreMoveTo	(	HDC	hdc,
		INT	x,
		INT	y,
		LPPOINT	pptOut
	)

Definition at line 110 of file line.c.

{
   BOOL Ret;
   PDC dc;
   if (!(dc = DC_LockDc(hdc)))
   {
      EngSetLastError(ERROR_INVALID_HANDLE);
      return FALSE;
   }
   Ret = IntGdiMoveToEx(dc, x, y, pptOut);
   DC_UnlockDc(dc);
   return Ret;
}

Referenced by IntDrawDiagEdge(), IntDrawMenuBarTemp(), IntDrawRectEdge(), MENU_DrawMenuItem(), NC_DoNCPaint(), TEXT_DrawUnderscore(), and UserDrawCaptionBar().

IntCreateCompatibleBitmap()

HBITMAP FASTCALL IntCreateCompatibleBitmap	(	_In_ PDC	Dc,
		_In_ INT	Width,
		_In_ INT	Height,
		_In_ UINT	Bpp,
		_In_ UINT	Planes
	)

IntDrawArc()

BOOL FASTCALL IntDrawArc	(	PDC	dc,
		INT	XLeft,
		INT	YLeft,
		INT	Width,
		INT	Height,
		double	StartArc,
		double	EndArc,
		ARCTYPE	arctype,
		PBRUSH	pbrush
	)

Definition at line 1342 of file drawing.c.

{
    int Start = (int)ceil(StartArc);
    int End   = (int)ceil(EndArc);
    BOOL Chord = (arctype == GdiTypeChord);
    // Sort out alignment here.
    return app_draw_arc(dc, rect( XLeft, YLeft, Width, Height),
                        (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -End : -Start,
                        (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -Start : -End,
                        pbrush, Chord);
}

Referenced by IntArc().

IntDrawEllipse()

BOOL FASTCALL IntDrawEllipse	(	PDC	dc,
		INT	XLeft,
		INT	YLeft,
		INT	Width,
		INT	Height,
		PBRUSH	pbrush
	)

Definition at line 1364 of file drawing.c.

{
    return (BOOL)app_draw_ellipse(dc, rect( XLeft, YLeft, Width, Height), pbrush);
}

Referenced by NtGdiEllipse().

IntDrawRoundRect()

BOOL FASTCALL IntDrawRoundRect	(	PDC	dc,
		INT	Left,
		INT	Top,
		INT	Right,
		INT	Bottom,
		INT	Wellipse,
		INT	Hellipse,
		PBRUSH	pbrush
	)

Definition at line 1454 of file drawing.c.

{
    Rect r;
    int rx, ry; /* Radius in x and y directions */
    int w = pbrushPen->lWidth;
 
    r = rect( Left, Top, abs(Right-Left), abs(Bottom-Top));
    rx = Wellipse/2;
    ry = Hellipse/2;
 
    if (Wellipse > r.width)
    {
        if (Hellipse > r.height) // > W > H
            app_draw_ellipse(dc, r, pbrushPen);
        else // > W < H
        {
            app_draw_arc(dc, rect( r.x, r.y, r.width - 1, Hellipse - 1),
                         0, 180, pbrushPen, FALSE);
            app_draw_arc(dc, rect(r.x, Bottom - Hellipse, r.width - 1, Hellipse - 1),
                         180, 360, pbrushPen, FALSE);
        }
    }
    else if(Hellipse > r.height) // < W > H
    {
        app_draw_arc(dc, rect(r.x, r.y, Wellipse - 1, r.height - 1),
                     90, 270, pbrushPen, FALSE);
        app_draw_arc(dc, rect(Right - Wellipse, r.y, Wellipse - 1, r.height - 1),
                     270, 90, pbrushPen, FALSE);
    }
    else // < W < H
    {
        app_draw_arc(dc, rect(r.x, r.y, rx+rx, ry+ry),
                     90, 180, pbrushPen, FALSE);
 
        app_draw_arc(dc, rect(r.x,r.y+r.height-ry-ry,rx+rx,ry+ry),
                     180, 270, pbrushPen, FALSE);
 
        app_draw_arc(dc, rect(r.x+r.width-rx-rx, r.y+r.height-ry-ry, rx+rx, ry+ry),
                     270, 360, pbrushPen, FALSE);
 
        app_draw_arc(dc, rect(r.x+r.width-rx-rx,r.y,rx+rx,ry+ry),
                     0, 90, pbrushPen, FALSE);
    }
    if ( Hellipse < r.height)
    {
        app_fill_rect(dc, rect(r.x, r.y+ry+1, w, r.height-ry-ry), pbrushPen, TRUE);
 
 
        app_fill_rect(dc, rect(r.x+r.width-w, r.y+ry+1, w, r.height-ry-ry),
                      pbrushPen, TRUE);
    }
    if ( Wellipse < r.width)
    {
        app_fill_rect(dc, rect(r.x+rx, r.y+r.height-w, r.width-rx-rx, w),
                      pbrushPen, TRUE);
 
        app_fill_rect(dc, rect(r.x+rx, r.y, r.width-rx-rx, w), pbrushPen, TRUE);
    }
    return TRUE;
}

Referenced by IntRoundRect().

IntFillArc()

BOOL FASTCALL IntFillArc	(	PDC	dc,
		INT	XLeft,
		INT	YLeft,
		INT	Width,
		INT	Height,
		double	StartArc,
		double	EndArc,
		ARCTYPE	arctype
	)

Definition at line 1306 of file drawing.c.

{
    PDC_ATTR pdcattr;
    PBRUSH pbrush;
    int Start = (int)ceil(StartArc);
    int End   = (int)ceil(EndArc);
    BOOL Chord = (arctype == GdiTypeChord), ret;
 
    pdcattr = dc->pdcattr;
 
    pbrush = BRUSH_ShareLockBrush(pdcattr->hbrush);
    if (!pbrush)
    {
        DPRINT1("FillArc Fail\n");
        EngSetLastError(ERROR_INTERNAL_ERROR);
        return FALSE;
    }
    // Sort out alignment here.
    ret = app_fill_arc(dc, rect( XLeft, YLeft, Width, Height),
                       (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -End : -Start,
                       (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -Start : -End,
                       pbrush, Chord);
 
    BRUSH_ShareUnlockBrush(pbrush);
    return ret;
}

Referenced by IntArc().

IntFillEllipse()

BOOL FASTCALL IntFillEllipse	(	PDC	dc,
		INT	XLeft,
		INT	YLeft,
		INT	Width,
		INT	Height,
		PBRUSH	pbrush
	)

Definition at line 1376 of file drawing.c.

{
    return (BOOL)app_fill_ellipse(dc, rect( XLeft, YLeft, Width, Height), pbrush);
}

Referenced by NtGdiEllipse().

IntFillRoundRect()

BOOL FASTCALL IntFillRoundRect	(	PDC	dc,
		INT	Left,
		INT	Top,
		INT	Right,
		INT	Bottom,
		INT	Wellipse,
		INT	Hellipse,
		PBRUSH	pbrush
	)

Definition at line 1388 of file drawing.c.

{
    Rect r;
    int rx, ry; /* Radius in x and y directions */
 
    //           x    y          Width          Height
    r = rect( Left, Top, abs(Right-Left), abs(Bottom-Top));
    rx = Wellipse/2;
    ry = Hellipse/2;
 
    if (Wellipse > r.width)
    {
        if (Hellipse > r.height) // > W > H
            app_fill_ellipse(dc, r, pbrush);
        else // > W < H
        {
            app_fill_arc(dc, rect( r.x, r.y, r.width - 1, Hellipse),
                         0, 180, pbrush,FALSE);
            app_fill_arc(dc, rect(r.x, Bottom - Hellipse - 1, r.width - 1, Hellipse),
                         180, 360, pbrush, FALSE);
        }
    }
    else if(Hellipse > r.height) // < W > H
    {
        app_fill_arc(dc, rect(r.x, r.y, Wellipse, r.height - 1),
                     90, 270, pbrush, FALSE);
        app_fill_arc(dc, rect(Right - Wellipse - 1, r.y, Wellipse, r.height - 1),
                     270, 90, pbrush,FALSE);
    }
    else // < W < H
    {
        app_fill_arc(dc, rect(r.x, r.y, rx+rx, ry+ry),
                     90, 180, pbrush, FALSE);
 
        app_fill_arc(dc, rect(r.x, r.y+r.height-ry-ry, rx+rx, ry+ry),
                     180, 270, pbrush, FALSE);
 
        app_fill_arc(dc, rect(r.x+r.width-rx-rx, r.y+r.height-ry-ry, rx+rx, ry+ry),
                     270, 360, pbrush,FALSE);
 
        app_fill_arc(dc, rect(r.x+r.width-rx-rx, r.y, rx+rx, ry+ry),
                     0, 90, pbrush,FALSE);
    }
    if (Wellipse < r.width)
    {
        app_fill_rect(dc, rect(r.x+rx, r.y, r.width-rx-rx, ry+1), pbrush, FALSE);
        app_fill_rect(dc, rect(r.x+rx, r.y+r.height-ry+1, r.width-rx-rx, ry-1), pbrush, FALSE);
    }
    if (Hellipse < r.height)
    {
        app_fill_rect(dc, rect(r.x, r.y+ry+1, r.width, r.height-ry-ry), pbrush, FALSE);
    }
 
    return TRUE;
}

Referenced by IntRoundRect().

IntGdiCreateDC()

HDC FASTCALL IntGdiCreateDC	(	PUNICODE_STRING	Driver,
		PUNICODE_STRING	Device,
		PVOID	pUMdhpdev,
		CONST PDEVMODEW	InitData,
		BOOL	CreateAsIC
	)

Definition at line 1040 of file dclife.c.

{
    HDC hdc;
 
    hdc = GreOpenDCW(pustrDevice,
                     pdmInit,
                     NULL,
                     CreateAsIC ? DCTYPE_INFO :
                          (Driver ? DCTYPE_DIRECT : DCTYPE_DIRECT),
                     TRUE,
                     NULL,
                     NULL,
                     pUMdhpdev);
 
    return hdc;
}

Referenced by co_IntInitializeDesktopGraphics(), DceCreateDisplayDC(), EngpRegisterGraphicsDevice(), IntGdiCreateDisplayDC(), and UserLoadImage().

IntGdiLineTo()

BOOL FASTCALL IntGdiLineTo	(	DC *	dc,
		int	XEnd,
		int	YEnd
	)

Definition at line 148 of file line.c.

{
    SURFACE *psurf;
    BOOL      Ret = TRUE;
    PBRUSH pbrLine;
    RECTL     Bounds;
    POINT     Points[2];
    PDC_ATTR  pdcattr;
    PPATH     pPath;
 
    ASSERT_DC_PREPARED(dc);
 
    pdcattr = dc->pdcattr;
 
    if (PATH_IsPathOpen(dc->dclevel))
    {
        Ret = PATH_LineTo(dc, XEnd, YEnd);
    }
    else
    {
        psurf = dc->dclevel.pSurface;
        if (NULL == psurf)
        {
            EngSetLastError(ERROR_INVALID_HANDLE);
            return FALSE;
        }
 
        Points[0].x = pdcattr->ptlCurrent.x;
        Points[0].y = pdcattr->ptlCurrent.y;
        Points[1].x = XEnd;
        Points[1].y = YEnd;
 
        IntLPtoDP(dc, Points, 2);
 
        /* The DCOrg is in device coordinates */
        Points[0].x += dc->ptlDCOrig.x;
        Points[0].y += dc->ptlDCOrig.y;
        Points[1].x += dc->ptlDCOrig.x;
        Points[1].y += dc->ptlDCOrig.y;
 
        Bounds.left = min(Points[0].x, Points[1].x);
        Bounds.top = min(Points[0].y, Points[1].y);
        Bounds.right = max(Points[0].x, Points[1].x);
        Bounds.bottom = max(Points[0].y, Points[1].y);
 
        /* Get BRUSH from current pen. */
        pbrLine = dc->dclevel.pbrLine;
        ASSERT(pbrLine);
 
        if (dc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
        {
           DPRINT("Bounds dc %p l %d t %d\n",dc,Bounds.left,Bounds.top);
           DPRINT("                   r %d b %d\n",Bounds.right,Bounds.bottom);
           AddPenLinesBounds(dc, 2, Points);
        }
 
        if (!(pbrLine->flAttrs & BR_IS_NULL))
        {
            if (IntIsEffectiveWidePen(pbrLine))
            {
                /* Clear the path */
                PATH_Delete(dc->dclevel.hPath);
                dc->dclevel.hPath = NULL;
 
                /* Begin a path */
                pPath = PATH_CreatePath(2);
                dc->dclevel.flPath |= DCPATH_ACTIVE;
                dc->dclevel.hPath = pPath->BaseObject.hHmgr;
                IntGetCurrentPositionEx(dc, &pPath->pos);
                IntLPtoDP(dc, &pPath->pos, 1);
 
                PATH_MoveTo(dc, pPath);
                PATH_LineTo(dc, XEnd, YEnd);
 
                /* Close the path */
                pPath->state = PATH_Closed;
                dc->dclevel.flPath &= ~DCPATH_ACTIVE;
 
                /* Actually stroke a path */
                Ret = PATH_StrokePath(dc, pPath);
 
                /* Clear the path */
                PATH_UnlockPath(pPath);
                PATH_Delete(dc->dclevel.hPath);
                dc->dclevel.hPath = NULL;
            }
            else
            {
                Ret = IntEngLineTo(&psurf->SurfObj,
                                   (CLIPOBJ *)&dc->co,
                                   &dc->eboLine.BrushObject,
                                   Points[0].x, Points[0].y,
                                   Points[1].x, Points[1].y,
                                   &Bounds,
                                   ROP2_TO_MIX(pdcattr->jROP2));
            }
        }
    }
 
    if (Ret)
    {
        pdcattr->ptlCurrent.x = XEnd;
        pdcattr->ptlCurrent.y = YEnd;
        pdcattr->ptfxCurrent = pdcattr->ptlCurrent;
        CoordLPtoDP(dc, &pdcattr->ptfxCurrent); // Update fx
        pdcattr->ulDirty_ &= ~(DIRTY_PTLCURRENT|DIRTY_PTFXCURRENT|DIRTY_STYLESTATE);
    }
 
    return Ret;
}

Referenced by IntGdiArcInternal(), and NtGdiLineTo().

IntGdiMoveToEx()

BOOL FASTCALL IntGdiMoveToEx	(	DC *	dc,
		int	X,
		int	Y,
		LPPOINT	Point
	)

Definition at line 80 of file line.c.

{
    PDC_ATTR pdcattr = dc->pdcattr;
    if ( Point )
    {
        if ( pdcattr->ulDirty_ & DIRTY_PTLCURRENT ) // Double hit!
        {
            Point->x = pdcattr->ptfxCurrent.x; // ret prev before change.
            Point->y = pdcattr->ptfxCurrent.y;
            IntDPtoLP ( dc, Point, 1);         // Reconvert back.
        }
        else
        {
            Point->x = pdcattr->ptlCurrent.x;
            Point->y = pdcattr->ptlCurrent.y;
        }
    }
    pdcattr->ptlCurrent.x = X;
    pdcattr->ptlCurrent.y = Y;
    pdcattr->ptfxCurrent = pdcattr->ptlCurrent;
    CoordLPtoDP(dc, &pdcattr->ptfxCurrent); // Update fx
    pdcattr->ulDirty_ &= ~(DIRTY_PTLCURRENT|DIRTY_PTFXCURRENT|DIRTY_STYLESTATE);
 
    return TRUE;
}

Referenced by _Success_(), add_log_points_new_stroke(), GdiPolyDraw(), GreMoveTo(), IntGdiAngleArc(), IntGdiArcInternal(), PATH_PolyDraw(), and PATH_StrokePath().

IntGdiPolyBezier()

BOOL FASTCALL IntGdiPolyBezier	(	DC *	dc,
		LPPOINT	pt,
		DWORD	Count
	)

Definition at line 262 of file line.c.

{
    BOOL ret = FALSE; // Default to FAILURE
 
    if ( PATH_IsPathOpen(dc->dclevel) )
    {
        return PATH_PolyBezier ( dc, pt, Count );
    }
 
    /* We'll convert it into line segments and draw them using Polyline */
    {
        POINT *Pts;
        INT nOut;
 
        Pts = GDI_Bezier ( pt, Count, &nOut );
        if ( Pts )
        {
            ret = IntGdiPolyline(dc, Pts, nOut);
            ExFreePoolWithTag(Pts, TAG_BEZIER);
        }
    }
 
    return ret;
}

Referenced by IntGdiPolyBezierTo(), and NtGdiPolyPolyDraw().

IntGdiPolyBezierTo()

BOOL FASTCALL IntGdiPolyBezierTo	(	DC *	dc,
		LPPOINT	pt,
		DWORD	Count
	)

Definition at line 290 of file line.c.

{
    BOOL ret = FALSE; // Default to failure
    PDC_ATTR pdcattr = dc->pdcattr;
 
    if ( PATH_IsPathOpen(dc->dclevel) )
        ret = PATH_PolyBezierTo ( dc, pt, Count );
    else /* We'll do it using PolyBezier */
    {
        POINT *npt;
        npt = ExAllocatePoolWithTag(PagedPool,
                                    sizeof(POINT) * (Count + 1),
                                    TAG_BEZIER);
        if ( npt )
        {
            npt[0].x = pdcattr->ptlCurrent.x;
            npt[0].y = pdcattr->ptlCurrent.y;
            memcpy(npt + 1, pt, sizeof(POINT) * Count);
            ret = IntGdiPolyBezier(dc, npt, Count+1);
            ExFreePoolWithTag(npt, TAG_BEZIER);
        }
    }
    if ( ret )
    {
        pdcattr->ptlCurrent.x = pt[Count-1].x;
        pdcattr->ptlCurrent.y = pt[Count-1].y;
        pdcattr->ptfxCurrent = pdcattr->ptlCurrent;
        CoordLPtoDP(dc, &pdcattr->ptfxCurrent); // Update fx
        pdcattr->ulDirty_ &= ~(DIRTY_PTLCURRENT|DIRTY_PTFXCURRENT|DIRTY_STYLESTATE);
    }
 
    return ret;
}

Referenced by NtGdiPolyPolyDraw().

IntGdiPolyline()

BOOL FASTCALL IntGdiPolyline	(	DC *	dc,
		LPPOINT	pt,
		int	Count
	)

Definition at line 327 of file line.c.

{
    SURFACE *psurf;
    BRUSH *pbrLine;
    LPPOINT Points;
    BOOL Ret = TRUE;
    LONG i;
    PDC_ATTR pdcattr = dc->pdcattr;
    PPATH pPath;
 
    if (!dc->dclevel.pSurface)
    {
        return TRUE;
    }
 
    DC_vPrepareDCsForBlit(dc, NULL, NULL, NULL);
    psurf = dc->dclevel.pSurface;
 
    /* Get BRUSHOBJ from current pen. */
    pbrLine = dc->dclevel.pbrLine;
    ASSERT(pbrLine);
 
    if (!(pbrLine->flAttrs & BR_IS_NULL))
    {
        Points = EngAllocMem(0, Count * sizeof(POINT), GDITAG_TEMP);
        if (Points != NULL)
        {
            RtlCopyMemory(Points, pt, Count * sizeof(POINT));
            IntLPtoDP(dc, Points, Count);
 
            /* Offset the array of points by the DC origin */
            for (i = 0; i < Count; i++)
            {
                Points[i].x += dc->ptlDCOrig.x;
                Points[i].y += dc->ptlDCOrig.y;
            }
 
            if (dc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
            {
               AddPenLinesBounds(dc, Count, Points);
            }
 
            if (IntIsEffectiveWidePen(pbrLine))
            {
                /* Clear the path */
                PATH_Delete(dc->dclevel.hPath);
                dc->dclevel.hPath = NULL;
 
                /* Begin a path */
                pPath = PATH_CreatePath(Count);
                dc->dclevel.flPath |= DCPATH_ACTIVE;
                dc->dclevel.hPath = pPath->BaseObject.hHmgr;
                pPath->pos = pt[0];
                IntLPtoDP(dc, &pPath->pos, 1);
 
                PATH_MoveTo(dc, pPath);
                for (i = 1; i < Count; ++i)
                {
                    PATH_LineTo(dc, pt[i].x, pt[i].y);
                }
 
                /* Close the path */
                pPath->state = PATH_Closed;
                dc->dclevel.flPath &= ~DCPATH_ACTIVE;
 
                /* Actually stroke a path */
                Ret = PATH_StrokePath(dc, pPath);
 
                /* Clear the path */
                PATH_UnlockPath(pPath);
                PATH_Delete(dc->dclevel.hPath);
                dc->dclevel.hPath = NULL;
            }
            else
            {
                Ret = IntEngPolyline(&psurf->SurfObj,
                                     (CLIPOBJ *)&dc->co,
                                     &dc->eboLine.BrushObject,
                                     Points,
                                     Count,
                                     ROP2_TO_MIX(pdcattr->jROP2));
            }
            EngFreeMem(Points);
        }
        else
        {
            Ret = FALSE;
        }
    }
 
    DC_vFinishBlit(dc, NULL);
 
    return Ret;
}

Referenced by GdiPolyDraw(), IntGdiPolyBezier(), IntGdiPolylineTo(), IntGdiPolyPolyline(), and PATH_StrokePath().

IntGdiPolylineTo()

BOOL FASTCALL IntGdiPolylineTo	(	DC *	dc,
		LPPOINT	pt,
		DWORD	Count
	)

Definition at line 425 of file line.c.

{
    BOOL ret = FALSE; // Default to failure
    PDC_ATTR pdcattr = dc->pdcattr;
 
    if (PATH_IsPathOpen(dc->dclevel))
    {
        ret = PATH_PolylineTo(dc, pt, Count);
    }
    else /* Do it using Polyline */
    {
        POINT *pts = ExAllocatePoolWithTag(PagedPool,
                                           sizeof(POINT) * (Count + 1),
                                           TAG_SHAPE);
        if ( pts )
        {
            pts[0].x = pdcattr->ptlCurrent.x;
            pts[0].y = pdcattr->ptlCurrent.y;
            memcpy( pts + 1, pt, sizeof(POINT) * Count);
            ret = IntGdiPolyline(dc, pts, Count + 1);
            ExFreePoolWithTag(pts, TAG_SHAPE);
        }
    }
    if ( ret )
    {
        pdcattr->ptlCurrent.x = pt[Count-1].x;
        pdcattr->ptlCurrent.y = pt[Count-1].y;
        pdcattr->ptfxCurrent = pdcattr->ptlCurrent;
        CoordLPtoDP(dc, &pdcattr->ptfxCurrent); // Update fx
        pdcattr->ulDirty_ &= ~(DIRTY_PTLCURRENT|DIRTY_PTFXCURRENT|DIRTY_STYLESTATE);
    }
 
    return ret;
}

Referenced by NtGdiPolyPolyDraw().

IntGdiPolyPolyline()

BOOL FASTCALL IntGdiPolyPolyline	(	DC *	dc,
		LPPOINT	pt,
		PULONG	PolyPoints,
		DWORD	Count
	)

Definition at line 464 of file line.c.

{
    ULONG i;
    LPPOINT pts;
    PULONG pc;
    BOOL ret = FALSE; // Default to failure
    pts = pt;
    pc = PolyPoints;
 
    if (PATH_IsPathOpen(dc->dclevel))
    {
        return PATH_PolyPolyline( dc, pt, PolyPoints, Count );
    }
    for (i = 0; i < Count; i++)
    {
        ret = IntGdiPolyline ( dc, pts, *pc );
        if (ret == FALSE)
        {
            return ret;
        }
        pts+=*pc++;
    }
 
    return ret;
}

Referenced by NtGdiPolyPolyDraw().

IntGdiSetHookFlags()

WORD APIENTRY IntGdiSetHookFlags	(	HDC	hDC,
		WORD	Flags
	)

Definition at line 422 of file dcutil.c.

{
    WORD wRet;
    DC *dc = DC_LockDc(hDC);
 
    if (NULL == dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return 0;
    }
 
    wRet = dc->fs & DC_DIRTY_RAO; // FIXME: Wrong flag!
 
    /* Info in "Undocumented Windows" is slightly confusing. */
    DPRINT("DC %p, Flags %04x\n", hDC, Flags);
 
    if (Flags & DCHF_INVALIDATEVISRGN)
    {
        /* hVisRgn has to be updated */
        dc->fs |= DC_DIRTY_RAO;
    }
    else if (Flags & DCHF_VALIDATEVISRGN || 0 == Flags)
    {
        //dc->fs &= ~DC_DIRTY_RAO;
    }
 
    DC_UnlockDc(dc);
 
    return wRet;
}

Referenced by DceDeleteClipRgn(), DceResetActiveDCEs(), and UserGetDCEx().

IntGetDIBColorTable()

UINT APIENTRY IntGetDIBColorTable	(	HDC	hDC,
		UINT	StartIndex,
		UINT	Entries,
		RGBQUAD *	Colors
	)

IntGetPaletteEntries()

UINT APIENTRY IntGetPaletteEntries	(	HPALETTE	hpal,
		UINT	StartIndex,
		UINT	Entries,
		LPPALETTEENTRY	pe
	)

Definition at line 850 of file palette.c.

{
    PPALETTE palGDI;
    UINT numEntries;
 
    palGDI = (PPALETTE) PALETTE_ShareLockPalette(hpal);
    if (NULL == palGDI)
    {
        return 0;
    }
 
    numEntries = palGDI->NumColors;
    if (NULL != pe)
    {
        if (numEntries < StartIndex + Entries)
        {
            Entries = numEntries - StartIndex;
        }
        if (numEntries <= StartIndex)
        {
            PALETTE_ShareUnlockPalette(palGDI);
            return 0;
        }
        memcpy(pe, palGDI->IndexedColors + StartIndex, Entries * sizeof(PALETTEENTRY));
    }
    else
    {
        Entries = numEntries;
    }
 
    PALETTE_ShareUnlockPalette(palGDI);
    return Entries;
}

Referenced by NtGdiDoPalette().

IntGetSysColor()

DWORD FASTCALL IntGetSysColor

(

INT

nIndex

)

Definition at line 323 of file stockobj.c.

{
    return (NUM_SYSCOLORS <= (UINT)nIndex) ? 0 : gpsi->argbSystem[nIndex];
}

Referenced by DefWndControlColor(), IntDrawDiagEdge(), IntDrawMenuBarTemp(), IntDrawRectEdge(), MENU_DrawBitmapItem(), MENU_DrawMenuItem(), MENU_DrawPopupGlyph(), NC_DoNCActive(), NC_DoNCPaint(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), UITOOLS95_DrawFrameMenu(), UITOOLS95_DrawFrameScroll(), UITOOLS_DrawCheckedRect(), UserDrawCaption(), UserDrawCaptionBar(), and UserDrawCaptionText().

IntGetSysColorBrush()

HGDIOBJ FASTCALL IntGetSysColorBrush

(

INT

Object

)

Definition at line 317 of file stockobj.c.

{
    return ((Object < 0) || (NUM_SYSCOLORS <= Object)) ? NULL : gpsi->ahbrSystem[Object];
}

Referenced by DefWndControlColor(), DrawFrameControl(), FillRect(), IntDefWindowProc(), IntDrawMenuBarTemp(), IntDrawRectEdge(), IntDrawScrollInterior(), MENU_DrawMenuItem(), MENU_DrawPopupMenu(), MENU_DrawScrollArrows(), NC_DoNCPaint(), NC_DrawFrame(), PaintSuspendedWindow(), UITOOLS95_DFC_ButtonPush(), UITOOLS_DrawCheckedRect(), UserDrawCaption(), UserDrawCaptionBar(), and UserRegisterSystemClasses().

IntGetSystemPaletteEntries()

UINT APIENTRY IntGetSystemPaletteEntries	(	HDC	hDC,
		UINT	StartIndex,
		UINT	Entries,
		LPPALETTEENTRY	pe
	)

Definition at line 889 of file palette.c.

{
    PPALETTE palGDI = NULL;
    PDC dc = NULL;
    UINT EntriesSize = 0;
    UINT Ret = 0;
 
    if (Entries == 0)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (pe != NULL)
    {
        EntriesSize = Entries * sizeof(pe[0]);
        if (Entries != EntriesSize / sizeof(pe[0]))
        {
            /* Integer overflow! */
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return 0;
        }
    }
 
    if (!(dc = DC_LockDc(hDC)))
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return 0;
    }
 
    palGDI = PALETTE_ShareLockPalette(dc->dclevel.hpal);
    if (palGDI != NULL)
    {
        if (pe != NULL)
        {
            if (StartIndex >= palGDI->NumColors)
                Entries = 0;
            else if (Entries > palGDI->NumColors - StartIndex)
                Entries = palGDI->NumColors - StartIndex;
 
            memcpy(pe,
                   palGDI->IndexedColors + StartIndex,
                   Entries * sizeof(pe[0]));
 
            Ret = Entries;
        }
        else
        {
            Ret = dc->ppdev->gdiinfo.ulNumPalReg;
        }
    }
 
    if (palGDI != NULL)
        PALETTE_ShareUnlockPalette(palGDI);
 
    if (dc != NULL)
        DC_UnlockDc(dc);
 
    return Ret;
}

Referenced by NtGdiDoPalette().

IntSetDIBColorTable()

UINT APIENTRY IntSetDIBColorTable	(	HDC	hDC,
		UINT	StartIndex,
		UINT	Entries,
		CONST RGBQUAD *	Colors
	)

IntSetSysColors()

VOID FASTCALL IntSetSysColors	(	UINT	nColors,
		CONST INT *	Elements,
		CONST COLORREF *	Colors
	)

Definition at line 300 of file stockobj.c.

{
    UINT i;
 
    for (i = 0; i < nColors; i++)
    {
        if ((UINT)(*Elements) < NUM_SYSCOLORS)
        {
            gpsi->argbSystem[*Elements] = *Colors;
            IntGdiSetSolidBrushColor(gpsi->ahbrSystem[*Elements], *Colors);
        }
        Elements++;
        Colors++;
    }
}

Referenced by NtUserSetSysColors().

NtDxEngGetRedirectionBitmap()

DWORD APIENTRY NtDxEngGetRedirectionBitmap

(

DWORD

Unknown0

)

Definition at line 974 of file ntstubs.c.

{
    STUB;
    return 0;
}

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

Variable Documentation

hsemDriverMgmt

HSEMAPHORE hsemDriverMgmt

extern

hSystemBM

HDC hSystemBM

extern

Definition at line 52 of file stockobj.c.

Referenced by co_IntInitializeDesktopGraphics(), NtUserBitBltSysBmp(), and UserChangeDisplaySettings().