ntgdi.h File Reference

#include <wingdi.h>
#include <winternl.h>
#include <winspool.h>
#include <ddk/d3dkmthk.h>

Include dependency graph for ntgdi.h:

Go to the source code of this file.

Classes
struct	_GDI_HANDLE_ENTRY
struct	_GDI_SHARED_MEMORY
struct	font_realization_info
struct	char_width_info
struct	font_fileinfo

Macros
#define	W32KAPI   DECLSPEC_IMPORT
#define	GDI_MAX_HANDLE_COUNT   0x10000
#define	NTGDI_OBJ_DC   0x010000
#define	NTGDI_OBJ_ENHMETADC   0x210000
#define	NTGDI_OBJ_REGION   0x040000
#define	NTGDI_OBJ_SURF   0x050000
#define	NTGDI_OBJ_METAFILE   0x260000
#define	NTGDI_OBJ_ENHMETAFILE   0x460000
#define	NTGDI_OBJ_METADC   0x660000
#define	NTGDI_OBJ_PAL   0x080000
#define	NTGDI_OBJ_BITMAP   0x090000
#define	NTGDI_OBJ_FONT   0x0a0000
#define	NTGDI_OBJ_BRUSH   0x100000
#define	NTGDI_OBJ_PEN   0x300000
#define	NTGDI_OBJ_EXTPEN   0x500000
#define	NTGDI_OBJ_MEMDC   0x410000
#define	NTGDI_HANDLE_TYPE_SHIFT   16
#define	NTGDI_HANDLE_TYPE_MASK   0x007f0000
#define	NTGDI_HANDLE_STOCK_OBJECT   0x00800000
#define	NTGDI_GETCHARWIDTH_INT   0x02
#define	NTGDI_GETCHARWIDTH_INDICES   0x08
#define	NTGDI_GETCHARABCWIDTHS_INT   0x01
#define	NTGDI_GETCHARABCWIDTHS_INDICES   0x02
#define	MWT_SET   4

Typedefs
typedef struct _GDI_HANDLE_ENTRY	GDI_HANDLE_ENTRY
typedef struct _GDI_HANDLE_ENTRY *	PGDI_HANDLE_ENTRY
typedef struct _GDI_SHARED_MEMORY	GDI_SHARED_MEMORY
typedef struct _GDI_SHARED_MEMORY *	PGDI_SHARED_MEMORY

Enumerations
enum	{ NtGdiArc , NtGdiArcTo , NtGdiChord , NtGdiPie }
enum	{   NtGdiPolyPolygon = 1 , NtGdiPolyPolyline , NtGdiPolyBezier , NtGdiPolyBezierTo ,   NtGdiPolylineTo , NtGdiPolyPolygonRgn }
enum	{ NtGdiLPtoDP , NtGdiDPtoLP }
enum	{   NtGdiSetMapMode = 8 , NtGdiSetBkColor = 100 , NtGdiSetBkMode , NtGdiSetTextColor ,   NtGdiSetDCBrushColor , NtGdiSetDCPenColor , NtGdiSetGraphicsMode , NtGdiSetROP2 ,   NtGdiSetTextAlign }
enum	{   NtGdiGetArcDirection , NtGdiGetBkColor , NtGdiGetBkMode , NtGdiGetDCBrushColor ,   NtGdiGetDCPenColor , NtGdiGetGraphicsMode , NtGdiGetLayout , NtGdiGetPolyFillMode ,   NtGdiGetROP2 , NtGdiGetTextColor , NtGdiIsMemDC }
enum	{ NtGdiGetBrushOrgEx , NtGdiGetCurrentPosition , NtGdiGetDCOrg }
enum	{   NtGdiAnimatePalette , NtGdiSetPaletteEntries , NtGdiGetPaletteEntries , NtGdiGetSystemPaletteEntries ,   NtGdiGetDIBColorTable , NtGdiSetDIBColorTable }

Functions
W32KAPI INT WINAPI	NtGdiAbortDoc (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiAbortPath (HDC hdc)
W32KAPI HANDLE WINAPI	NtGdiAddFontMemResourceEx (void *ptr, DWORD size, void *dv, ULONG dv_size, DWORD *count)
W32KAPI INT WINAPI	NtGdiAddFontResourceW (const WCHAR *str, ULONG size, ULONG files, DWORD flags, DWORD tid, void *dv)
W32KAPI BOOL WINAPI	NtGdiAlphaBlend (HDC hdc_dst, int x_dst, int y_dst, int width_dst, int height_dst, HDC hdc_src, int x_src, int y_src, int width_src, int height_src, DWORD blend_function, HANDLE xform)
W32KAPI BOOL WINAPI	NtGdiAngleArc (HDC hdc, INT x, INT y, DWORD radius, DWORD start_angle, DWORD sweep_angle)
W32KAPI BOOL WINAPI	NtGdiArcInternal (UINT type, HDC hdc, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend)
W32KAPI BOOL WINAPI	NtGdiBeginPath (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiBitBlt (HDC hdc_dst, INT x_dst, INT y_dst, INT width, INT height, HDC hdc_src, INT x_src, INT y_src, DWORD rop, DWORD bk_color, FLONG fl)
W32KAPI BOOL WINAPI	NtGdiCancelDC (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiCloseFigure (HDC hdc)
W32KAPI INT WINAPI	NtGdiCombineRgn (HRGN dest, HRGN src1, HRGN src2, INT mode)
W32KAPI BOOL WINAPI	NtGdiComputeXformCoefficients (HDC hdc)
W32KAPI HBITMAP WINAPI	NtGdiCreateBitmap (INT width, INT height, UINT planes, UINT bpp, const void *bits)
W32KAPI HANDLE WINAPI	NtGdiCreateClientObj (ULONG type)
W32KAPI HBITMAP WINAPI	NtGdiCreateCompatibleBitmap (HDC hdc, INT width, INT height)
W32KAPI HDC WINAPI	NtGdiCreateCompatibleDC (HDC hdc)
W32KAPI HBRUSH WINAPI	NtGdiCreateDIBBrush (const void *data, UINT coloruse, UINT size, BOOL is_8x8, BOOL pen, const void *client)
W32KAPI HBITMAP WINAPI	NtGdiCreateDIBSection (HDC hdc, HANDLE section, DWORD offset, const BITMAPINFO *bmi, UINT usage, UINT header_size, ULONG flags, ULONG_PTR color_space, void **bits)
W32KAPI HBITMAP WINAPI	NtGdiCreateDIBitmapInternal (HDC hdc, INT width, INT height, DWORD init, const void *bits, const BITMAPINFO *data, UINT coloruse, UINT max_info, UINT max_bits, ULONG flags, HANDLE xform)
W32KAPI HRGN WINAPI	NtGdiCreateEllipticRgn (INT left, INT top, INT right, INT bottom)
W32KAPI HPALETTE WINAPI	NtGdiCreateHalftonePalette (HDC hdc)
W32KAPI HBRUSH WINAPI	NtGdiCreateHatchBrushInternal (INT style, COLORREF color, BOOL pen)
W32KAPI HDC WINAPI	NtGdiCreateMetafileDC (HDC hdc)
W32KAPI HPALETTE WINAPI	NtGdiCreatePaletteInternal (const LOGPALETTE *palette, UINT count)
W32KAPI HBRUSH WINAPI	NtGdiCreatePatternBrushInternal (HBITMAP hbitmap, BOOL pen, BOOL is_8x8)
W32KAPI HPEN WINAPI	NtGdiCreatePen (INT style, INT width, COLORREF color, HBRUSH brush)
W32KAPI HRGN WINAPI	NtGdiCreateRectRgn (INT left, INT top, INT right, INT bottom)
W32KAPI HRGN WINAPI	NtGdiCreateRoundRectRgn (INT left, INT top, INT right, INT bottom, INT ellipse_width, INT ellipse_height)
W32KAPI HBRUSH WINAPI	NtGdiCreateSolidBrush (COLORREF color, HBRUSH brush)
W32KAPI BOOL WINAPI	NtGdiDeleteClientObj (HGDIOBJ obj)
W32KAPI BOOL WINAPI	NtGdiDeleteObjectApp (HGDIOBJ obj)
W32KAPI INT WINAPI	NtGdiDescribePixelFormat (HDC hdc, INT format, UINT size, PIXELFORMATDESCRIPTOR *descr)
W32KAPI LONG WINAPI	NtGdiDoPalette (HGDIOBJ handle, WORD start, WORD count, void *entries, DWORD func, BOOL inbound)
W32KAPI BOOL WINAPI	NtGdiDrawStream (HDC hdc, ULONG in, void *pvin)
W32KAPI BOOL WINAPI	NtGdiEllipse (HDC hdc, INT left, INT top, INT right, INT bottom)
W32KAPI INT WINAPI	NtGdiEndDoc (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiEndPath (HDC hdc)
W32KAPI INT WINAPI	NtGdiEndPage (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiEnumFonts (HDC hdc, ULONG type, ULONG win32_compat, ULONG face_name_len, const WCHAR *face_name, ULONG charset, ULONG *count, void *buf)
W32KAPI BOOL WINAPI	NtGdiEqualRgn (HRGN hrgn1, HRGN hrgn2)
W32KAPI INT WINAPI	NtGdiExcludeClipRect (HDC hdc, INT left, INT top, INT right, INT bottom)
W32KAPI HPEN WINAPI	NtGdiExtCreatePen (DWORD style, DWORD width, ULONG brush_style, ULONG color, ULONG_PTR client_hatch, ULONG_PTR hatch, DWORD style_count, const DWORD *style_bits, ULONG dib_size, BOOL old_style, HBRUSH brush)
W32KAPI INT WINAPI	NtGdiExtEscape (HDC hdc, WCHAR *driver, INT driver_id, INT escape, INT input_size, const char *input, INT output_size, char *output)
W32KAPI BOOL WINAPI	NtGdiExtFloodFill (HDC hdc, INT x, INT y, COLORREF color, UINT type)
W32KAPI BOOL WINAPI	NtGdiExtTextOutW (HDC hdc, INT x, INT y, UINT flags, const RECT *rect, const WCHAR *str, UINT count, const INT *dx, DWORD cp)
W32KAPI HRGN WINAPI	NtGdiExtCreateRegion (const XFORM *xform, DWORD count, const RGNDATA *data)
W32KAPI INT WINAPI	NtGdiExtGetObjectW (HGDIOBJ handle, INT count, void *buffer)
W32KAPI INT WINAPI	NtGdiExtSelectClipRgn (HDC hdc, HRGN region, INT mode)
W32KAPI BOOL WINAPI	NtGdiFillPath (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiFillRgn (HDC hdc, HRGN hrgn, HBRUSH hbrush)
W32KAPI BOOL WINAPI	NtGdiFlattenPath (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiFontIsLinked (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiFlush (void)
W32KAPI BOOL WINAPI	NtGdiFrameRgn (HDC hdc, HRGN hrgn, HBRUSH brush, INT width, INT height)
W32KAPI BOOL WINAPI	NtGdiGetAndSetDCDword (HDC hdc, UINT method, DWORD value, DWORD *result)
W32KAPI INT WINAPI	NtGdiGetAppClipBox (HDC hdc, RECT *rect)
W32KAPI LONG WINAPI	NtGdiGetBitmapBits (HBITMAP bitmap, LONG count, void *bits)
W32KAPI BOOL WINAPI	NtGdiGetBitmapDimension (HBITMAP bitmap, SIZE *size)
W32KAPI UINT WINAPI	NtGdiGetBoundsRect (HDC hdc, RECT *rect, UINT flags)
W32KAPI BOOL WINAPI	NtGdiGetCharABCWidthsW (HDC hdc, UINT first, UINT last, WCHAR *chars, ULONG flags, void *buffer)
W32KAPI BOOL WINAPI	NtGdiGetCharWidthW (HDC hdc, UINT first_char, UINT last_char, WCHAR *chars, ULONG flags, void *buffer)
W32KAPI BOOL WINAPI	NtGdiGetCharWidthInfo (HDC hdc, struct char_width_info *info)
W32KAPI BOOL WINAPI	NtGdiGetColorAdjustment (HDC hdc, COLORADJUSTMENT *ca)
W32KAPI BOOL WINAPI	NtGdiGetDCDword (HDC hdc, UINT method, DWORD *result)
W32KAPI HANDLE WINAPI	NtGdiGetDCObject (HDC hdc, UINT type)
W32KAPI BOOL WINAPI	NtGdiGetDCPoint (HDC hdc, UINT method, POINT *result)
W32KAPI INT WINAPI	NtGdiGetDIBitsInternal (HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines, void *bits, BITMAPINFO *info, UINT coloruse, UINT max_bits, UINT max_info)
W32KAPI INT WINAPI	NtGdiGetDeviceCaps (HDC hdc, INT cap)
W32KAPI BOOL WINAPI	NtGdiGetDeviceGammaRamp (HDC hdc, void *ptr)
W32KAPI DWORD WINAPI	NtGdiGetFontData (HDC hdc, DWORD table, DWORD offset, void *buffer, DWORD length)
W32KAPI BOOL WINAPI	NtGdiGetFontFileData (DWORD instance_id, DWORD file_index, UINT64 *offset, void *buff, SIZE_T buff_size)
W32KAPI BOOL WINAPI	NtGdiGetFontFileInfo (DWORD instance_id, DWORD file_index, struct font_fileinfo *info, SIZE_T size, SIZE_T *needed)
W32KAPI DWORD WINAPI	NtGdiGetFontUnicodeRanges (HDC hdc, GLYPHSET *lpgs)
W32KAPI DWORD WINAPI	NtGdiGetGlyphIndicesW (HDC hdc, const WCHAR *str, INT count, WORD *indices, DWORD flags)
W32KAPI DWORD WINAPI	NtGdiGetGlyphOutline (HDC hdc, UINT ch, UINT format, GLYPHMETRICS *metrics, DWORD size, void *buffer, const MAT2 *mat2, BOOL ignore_rotation)
W32KAPI DWORD WINAPI	NtGdiGetKerningPairs (HDC hdc, DWORD count, KERNINGPAIR *kern_pair)
W32KAPI BOOL WINAPI	NtGdiGetMiterLimit (HDC hdc, DWORD *limit)
W32KAPI COLORREF WINAPI	NtGdiGetNearestColor (HDC hdc, COLORREF color)
W32KAPI UINT WINAPI	NtGdiGetNearestPaletteIndex (HPALETTE hpalette, COLORREF color)
W32KAPI UINT WINAPI	NtGdiGetOutlineTextMetricsInternalW (HDC hdc, UINT cbData, OUTLINETEXTMETRICW *otm, ULONG opts)
W32KAPI INT WINAPI	NtGdiGetPath (HDC hdc, POINT *points, BYTE *types, INT size)
W32KAPI COLORREF WINAPI	NtGdiGetPixel (HDC hdc, INT x, INT y)
W32KAPI INT WINAPI	NtGdiGetRandomRgn (HDC hdc, HRGN region, INT code)
W32KAPI BOOL WINAPI	NtGdiGetRasterizerCaps (RASTERIZER_STATUS *status, UINT size)
W32KAPI BOOL WINAPI	NtGdiGetRealizationInfo (HDC hdc, struct font_realization_info *info)
W32KAPI DWORD WINAPI	NtGdiGetRegionData (HRGN hrgn, DWORD count, RGNDATA *data)
W32KAPI INT WINAPI	NtGdiGetRgnBox (HRGN hrgn, RECT *rect)
W32KAPI DWORD WINAPI	NtGdiGetSpoolMessage (void *ptr1, DWORD data2, void *ptr3, DWORD data4)
W32KAPI UINT WINAPI	NtGdiGetSystemPaletteUse (HDC hdc)
W32KAPI UINT WINAPI	NtGdiGetTextCharsetInfo (HDC hdc, FONTSIGNATURE *fs, DWORD flags)
W32KAPI BOOL WINAPI	NtGdiGetTextExtentExW (HDC hdc, const WCHAR *str, INT count, INT max_ext, INT *nfit, INT *dxs, SIZE *size, UINT flags)
W32KAPI INT WINAPI	NtGdiGetTextFaceW (HDC hdc, INT count, WCHAR *name, BOOL alias_name)
W32KAPI BOOL WINAPI	NtGdiGetTextMetricsW (HDC hdc, TEXTMETRICW *metrics, ULONG flags)
W32KAPI BOOL WINAPI	NtGdiGetTransform (HDC hdc, DWORD which, XFORM *xform)
W32KAPI BOOL WINAPI	NtGdiGradientFill (HDC hdc, TRIVERTEX *vert_array, ULONG nvert, void *grad_array, ULONG ngrad, ULONG mode)
W32KAPI HFONT WINAPI	NtGdiHfontCreate (const void *logfont, ULONG unk2, ULONG unk3, ULONG unk4, void *data)
W32KAPI BOOL WINAPI	NtGdiIcmBrushInfo (HDC hdc, HBRUSH handle, BITMAPINFO *info, void *bits, ULONG *bits_size, UINT *usage, BOOL *unk, UINT mode)
W32KAPI DWORD WINAPI	NtGdiInitSpool (void)
W32KAPI INT WINAPI	NtGdiIntersectClipRect (HDC hdc, INT left, INT top, INT right, INT bottom)
W32KAPI BOOL WINAPI	NtGdiInvertRgn (HDC hdc, HRGN hrgn)
W32KAPI BOOL WINAPI	NtGdiLineTo (HDC hdc, INT x, INT y)
W32KAPI BOOL WINAPI	NtGdiMaskBlt (HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, HDC hdc_src, INT x_src, INT y_src, HBITMAP mask, INT x_mask, INT y_mask, DWORD rop, DWORD bk_color)
W32KAPI BOOL WINAPI	NtGdiModifyWorldTransform (HDC hdc, const XFORM *xform, DWORD mode)
W32KAPI BOOL WINAPI	NtGdiMoveTo (HDC hdc, INT x, INT y, POINT *pt)
W32KAPI INT WINAPI	NtGdiOffsetClipRgn (HDC hdc, INT x, INT y)
W32KAPI INT WINAPI	NtGdiOffsetRgn (HRGN hrgn, INT x, INT y)
W32KAPI HDC WINAPI	NtGdiOpenDCW (UNICODE_STRING *device, const DEVMODEW *devmode, UNICODE_STRING *output, ULONG type, BOOL is_display, HANDLE hspool, DRIVER_INFO_2W *driver_info, void *pdev)
W32KAPI BOOL WINAPI	NtGdiPatBlt (HDC hdc, INT left, INT top, INT width, INT height, DWORD rop)
W32KAPI HRGN WINAPI	NtGdiPathToRegion (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiPlgBlt (HDC hdc, const POINT *point, HDC hdc_src, INT x_src, INT y_src, INT width, INT height, HBITMAP mask, INT x_mask, INT y_mask, DWORD bk_color)
W32KAPI BOOL WINAPI	NtGdiPolyDraw (HDC hdc, const POINT *points, const BYTE *types, DWORD count)
W32KAPI ULONG WINAPI	NtGdiPolyPolyDraw (HDC hdc, const POINT *points, const ULONG *counts, DWORD count, UINT function)
W32KAPI BOOL WINAPI	NtGdiPtInRegion (HRGN hrgn, INT x, INT y)
W32KAPI BOOL WINAPI	NtGdiPtVisible (HDC hdc, INT x, INT y)
W32KAPI BOOL WINAPI	NtGdiRectInRegion (HRGN hrgn, const RECT *rect)
W32KAPI BOOL WINAPI	NtGdiRectVisible (HDC hdc, const RECT *rect)
W32KAPI BOOL WINAPI	NtGdiRectangle (HDC hdc, INT left, INT top, INT right, INT bottom)
W32KAPI BOOL WINAPI	NtGdiRemoveFontMemResourceEx (HANDLE handle)
W32KAPI BOOL WINAPI	NtGdiRemoveFontResourceW (const WCHAR *str, ULONG size, ULONG files, DWORD flags, DWORD tid, void *dv)
W32KAPI BOOL WINAPI	NtGdiResetDC (HDC hdc, const DEVMODEW *devmode, BOOL *banding, DRIVER_INFO_2W *driver_info, void *dev)
W32KAPI BOOL WINAPI	NtGdiResizePalette (HPALETTE palette, UINT count)
W32KAPI BOOL WINAPI	NtGdiRestoreDC (HDC hdc, INT level)
W32KAPI BOOL WINAPI	NtGdiRoundRect (HDC hdc, INT left, INT top, INT right, INT bottom, INT ell_width, INT ell_height)
W32KAPI INT WINAPI	NtGdiSaveDC (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiScaleViewportExtEx (HDC hdc, INT x_num, INT x_denom, INT y_num, INT y_denom, SIZE *size)
W32KAPI BOOL WINAPI	NtGdiScaleWindowExtEx (HDC hdc, INT x_num, INT x_denom, INT y_num, INT y_denom, SIZE *size)
W32KAPI HGDIOBJ WINAPI	NtGdiSelectBitmap (HDC hdc, HGDIOBJ handle)
W32KAPI HGDIOBJ WINAPI	NtGdiSelectBrush (HDC hdc, HGDIOBJ handle)
W32KAPI BOOL WINAPI	NtGdiSelectClipPath (HDC hdc, INT mode)
W32KAPI HGDIOBJ WINAPI	NtGdiSelectFont (HDC hdc, HGDIOBJ handle)
W32KAPI HGDIOBJ WINAPI	NtGdiSelectPen (HDC hdc, HGDIOBJ handle)
W32KAPI LONG WINAPI	NtGdiSetBitmapBits (HBITMAP hbitmap, LONG count, const void *bits)
W32KAPI BOOL WINAPI	NtGdiSetBitmapDimension (HBITMAP hbitmap, INT x, INT y, SIZE *prev_size)
W32KAPI BOOL WINAPI	NtGdiSetBrushOrg (HDC hdc, INT x, INT y, POINT *prev_org)
W32KAPI UINT WINAPI	NtGdiSetBoundsRect (HDC hdc, const RECT *rect, UINT flags)
W32KAPI BOOL WINAPI	NtGdiSetColorAdjustment (HDC hdc, const COLORADJUSTMENT *ca)
W32KAPI INT WINAPI	NtGdiSetDIBitsToDeviceInternal (HDC hdc, INT x_dst, INT y_dst, DWORD cx, DWORD cy, INT x_src, INT y_src, UINT startscan, UINT lines, const void *bits, const BITMAPINFO *bmi, UINT coloruse, UINT max_bits, UINT max_info, BOOL xform_coords, HANDLE xform)
W32KAPI BOOL WINAPI	NtGdiSetDeviceGammaRamp (HDC hdc, void *ptr)
W32KAPI DWORD WINAPI	NtGdiSetLayout (HDC hdc, LONG wox, DWORD layout)
W32KAPI BOOL WINAPI	NtGdiSetMagicColors (HDC hdc, DWORD magic, ULONG index)
W32KAPI INT WINAPI	NtGdiSetMetaRgn (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiSetMiterLimit (HDC hdc, DWORD limit, DWORD *prev_limit)
W32KAPI COLORREF WINAPI	NtGdiSetPixel (HDC hdc, INT x, INT y, COLORREF color)
W32KAPI BOOL WINAPI	NtGdiSetPixelFormat (HDC hdc, INT format)
W32KAPI BOOL WINAPI	NtGdiSetRectRgn (HRGN hrgn, INT left, INT top, INT right, INT bottom)
W32KAPI UINT WINAPI	NtGdiSetSystemPaletteUse (HDC hdc, UINT use)
W32KAPI BOOL WINAPI	NtGdiSetTextJustification (HDC hdc, INT extra, INT breaks)
W32KAPI BOOL WINAPI	NtGdiSetVirtualResolution (HDC hdc, DWORD horz_res, DWORD vert_res, DWORD horz_size, DWORD vert_size)
W32KAPI INT WINAPI	NtGdiStartDoc (HDC hdc, const DOCINFOW *doc, BOOL *banding, INT job)
W32KAPI INT WINAPI	NtGdiStartPage (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiStretchBlt (HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src, DWORD rop, COLORREF bk_color)
W32KAPI INT WINAPI	NtGdiStretchDIBitsInternal (HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, INT x_src, INT y_src, INT width_src, INT height_src, const void *bits, const BITMAPINFO *bmi, UINT coloruse, DWORD rop, UINT max_info, UINT max_bits, HANDLE xform)
W32KAPI BOOL WINAPI	NtGdiStrokeAndFillPath (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiStrokePath (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiSwapBuffers (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiTransparentBlt (HDC hdc, int x_dst, int y_dst, int width_dst, int height_dst, HDC hdc_src, int x_src, int y_src, int width_src, int height_src, UINT color)
W32KAPI BOOL WINAPI	NtGdiTransformPoints (HDC hdc, const POINT *points_in, POINT *points_out, INT count, UINT mode)
W32KAPI BOOL WINAPI	NtGdiUnrealizeObject (HGDIOBJ obj)
W32KAPI BOOL WINAPI	NtGdiUpdateColors (HDC hdc)
W32KAPI BOOL WINAPI	NtGdiWidenPath (HDC hdc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICheckVidPnExclusiveOwnership (const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICloseAdapter (const D3DKMT_CLOSEADAPTER *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateAllocation (D3DKMT_CREATEALLOCATION *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateAllocation2 (D3DKMT_CREATEALLOCATION *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateDCFromMemory (D3DKMT_CREATEDCFROMMEMORY *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateDevice (D3DKMT_CREATEDEVICE *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateKeyedMutex (D3DKMT_CREATEKEYEDMUTEX *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateKeyedMutex2 (D3DKMT_CREATEKEYEDMUTEX2 *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateSynchronizationObject (D3DKMT_CREATESYNCHRONIZATIONOBJECT *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDICreateSynchronizationObject2 (D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIDestroyAllocation (const D3DKMT_DESTROYALLOCATION *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIDestroyAllocation2 (const D3DKMT_DESTROYALLOCATION2 *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIDestroyDCFromMemory (const D3DKMT_DESTROYDCFROMMEMORY *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIDestroyDevice (const D3DKMT_DESTROYDEVICE *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIDestroyKeyedMutex (const D3DKMT_DESTROYKEYEDMUTEX *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIDestroySynchronizationObject (const D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIEnumAdapters (D3DKMT_ENUMADAPTERS *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIEnumAdapters2 (D3DKMT_ENUMADAPTERS2 *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIEscape (const D3DKMT_ESCAPE *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenAdapterFromDeviceName (D3DKMT_OPENADAPTERFROMDEVICENAME *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenAdapterFromHdc (D3DKMT_OPENADAPTERFROMHDC *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenAdapterFromLuid (D3DKMT_OPENADAPTERFROMLUID *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenKeyedMutex (D3DKMT_OPENKEYEDMUTEX *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenKeyedMutex2 (D3DKMT_OPENKEYEDMUTEX2 *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenKeyedMutexFromNtHandle (D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenResource (D3DKMT_OPENRESOURCE *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenResource2 (D3DKMT_OPENRESOURCE *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenResourceFromNtHandle (D3DKMT_OPENRESOURCEFROMNTHANDLE *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenSynchronizationObject (D3DKMT_OPENSYNCHRONIZATIONOBJECT *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenSyncObjectFromNtHandle (D3DKMT_OPENSYNCOBJECTFROMNTHANDLE *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenSyncObjectFromNtHandle2 (D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIOpenSyncObjectNtHandleFromName (D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIQueryAdapterInfo (D3DKMT_QUERYADAPTERINFO *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIQueryResourceInfo (D3DKMT_QUERYRESOURCEINFO *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIQueryResourceInfoFromNtHandle (D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE *params)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIQueryStatistics (D3DKMT_QUERYSTATISTICS *stats)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIQueryVideoMemoryInfo (D3DKMT_QUERYVIDEOMEMORYINFO *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDISetQueuedLimit (D3DKMT_SETQUEUEDLIMIT *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDISetVidPnSourceOwner (const D3DKMT_SETVIDPNSOURCEOWNER *desc)
W32KAPI NTSTATUS WINAPI	NtGdiDdDDIShareObjects (UINT count, const D3DKMT_HANDLE *handles, OBJECT_ATTRIBUTES *attr, UINT access, HANDLE *handle)
W32KAPI const struct vulkan_funcs *	__wine_get_vulkan_driver (UINT version)
W32KAPI const struct opengl_funcs *	__wine_get_wgl_driver (HDC hdc, UINT version)
W32KAPI BOOL WINAPI	__wine_get_icm_profile (HDC hdc, BOOL allow_default, DWORD *size, WCHAR *filename)
W32KAPI BOOL WINAPI	__wine_get_file_outline_text_metric (const WCHAR *path, TEXTMETRICW *otm, UINT *em_square, WCHAR *face_name)

Macro Definition Documentation

GDI_MAX_HANDLE_COUNT

#define GDI_MAX_HANDLE_COUNT   0x10000

Definition at line 63 of file ntgdi.h.

MWT_SET

#define MWT_SET   4

Definition at line 169 of file ntgdi.h.

NTGDI_GETCHARABCWIDTHS_INDICES

#define NTGDI_GETCHARABCWIDTHS_INDICES   0x02

Definition at line 167 of file ntgdi.h.

NTGDI_GETCHARABCWIDTHS_INT

#define NTGDI_GETCHARABCWIDTHS_INT   0x01

Definition at line 166 of file ntgdi.h.

NTGDI_GETCHARWIDTH_INDICES

#define NTGDI_GETCHARWIDTH_INDICES   0x08

Definition at line 164 of file ntgdi.h.

NTGDI_GETCHARWIDTH_INT

#define NTGDI_GETCHARWIDTH_INT   0x02

Definition at line 163 of file ntgdi.h.

NTGDI_HANDLE_STOCK_OBJECT

#define NTGDI_HANDLE_STOCK_OBJECT   0x00800000

Definition at line 84 of file ntgdi.h.

NTGDI_HANDLE_TYPE_MASK

#define NTGDI_HANDLE_TYPE_MASK   0x007f0000

Definition at line 83 of file ntgdi.h.

NTGDI_HANDLE_TYPE_SHIFT

#define NTGDI_HANDLE_TYPE_SHIFT   16

Definition at line 82 of file ntgdi.h.

NTGDI_OBJ_BITMAP

#define NTGDI_OBJ_BITMAP   0x090000

Definition at line 73 of file ntgdi.h.

NTGDI_OBJ_BRUSH

#define NTGDI_OBJ_BRUSH   0x100000

Definition at line 75 of file ntgdi.h.

NTGDI_OBJ_DC

#define NTGDI_OBJ_DC   0x010000

Definition at line 65 of file ntgdi.h.

NTGDI_OBJ_ENHMETADC

#define NTGDI_OBJ_ENHMETADC   0x210000

Definition at line 66 of file ntgdi.h.

NTGDI_OBJ_ENHMETAFILE

#define NTGDI_OBJ_ENHMETAFILE   0x460000

Definition at line 70 of file ntgdi.h.

NTGDI_OBJ_EXTPEN

#define NTGDI_OBJ_EXTPEN   0x500000

Definition at line 77 of file ntgdi.h.

NTGDI_OBJ_FONT

#define NTGDI_OBJ_FONT   0x0a0000

Definition at line 74 of file ntgdi.h.

NTGDI_OBJ_MEMDC

#define NTGDI_OBJ_MEMDC   0x410000

Definition at line 80 of file ntgdi.h.

NTGDI_OBJ_METADC

#define NTGDI_OBJ_METADC   0x660000

Definition at line 71 of file ntgdi.h.

NTGDI_OBJ_METAFILE

#define NTGDI_OBJ_METAFILE   0x260000

Definition at line 69 of file ntgdi.h.

NTGDI_OBJ_PAL

#define NTGDI_OBJ_PAL   0x080000

Definition at line 72 of file ntgdi.h.

NTGDI_OBJ_PEN

#define NTGDI_OBJ_PEN   0x300000

Definition at line 76 of file ntgdi.h.

NTGDI_OBJ_REGION

#define NTGDI_OBJ_REGION   0x040000

Definition at line 67 of file ntgdi.h.

NTGDI_OBJ_SURF

#define NTGDI_OBJ_SURF   0x050000

Definition at line 68 of file ntgdi.h.

W32KAPI

#define W32KAPI   DECLSPEC_IMPORT

Definition at line 31 of file ntgdi.h.

Typedef Documentation

GDI_HANDLE_ENTRY

typedef struct _GDI_HANDLE_ENTRY GDI_HANDLE_ENTRY

GDI_SHARED_MEMORY

typedef struct _GDI_SHARED_MEMORY GDI_SHARED_MEMORY

PGDI_HANDLE_ENTRY

typedef struct _GDI_HANDLE_ENTRY * PGDI_HANDLE_ENTRY

PGDI_SHARED_MEMORY

typedef struct _GDI_SHARED_MEMORY * PGDI_SHARED_MEMORY

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NtGdiArc
NtGdiArcTo
NtGdiChord
NtGdiPie

Definition at line 91 of file ntgdi.h.

{
    NtGdiArc,
    NtGdiArcTo,
    NtGdiChord,
    NtGdiPie,
};

anonymous enum

anonymous enum

Enumerator
NtGdiPolyPolygon
NtGdiPolyPolyline
NtGdiPolyBezier
NtGdiPolyBezierTo
NtGdiPolylineTo
NtGdiPolyPolygonRgn

Definition at line 99 of file ntgdi.h.

{
    NtGdiPolyPolygon = 1,
    NtGdiPolyPolyline,
    NtGdiPolyBezier,
    NtGdiPolyBezierTo,
    NtGdiPolylineTo,
    NtGdiPolyPolygonRgn,
};

anonymous enum

anonymous enum

Enumerator
NtGdiLPtoDP
NtGdiDPtoLP

Definition at line 109 of file ntgdi.h.

{
    NtGdiLPtoDP,
    NtGdiDPtoLP,
};

anonymous enum

anonymous enum

Enumerator
NtGdiSetMapMode
NtGdiSetBkColor
NtGdiSetBkMode
NtGdiSetTextColor
NtGdiSetDCBrushColor
NtGdiSetDCPenColor
NtGdiSetGraphicsMode
NtGdiSetROP2
NtGdiSetTextAlign

Definition at line 115 of file ntgdi.h.

{
    NtGdiSetMapMode = 8,
    /* not compatible with Windows */
    NtGdiSetBkColor = 100,
    NtGdiSetBkMode,
    NtGdiSetTextColor,
    NtGdiSetDCBrushColor,
    NtGdiSetDCPenColor,
    NtGdiSetGraphicsMode,
    NtGdiSetROP2,
    NtGdiSetTextAlign,
};

anonymous enum

anonymous enum

Enumerator
NtGdiGetArcDirection
NtGdiGetBkColor
NtGdiGetBkMode
NtGdiGetDCBrushColor
NtGdiGetDCPenColor
NtGdiGetGraphicsMode
NtGdiGetLayout
NtGdiGetPolyFillMode
NtGdiGetROP2
NtGdiGetTextColor
NtGdiIsMemDC

Definition at line 130 of file ntgdi.h.

{
    NtGdiGetArcDirection,
    NtGdiGetBkColor,
    NtGdiGetBkMode,
    NtGdiGetDCBrushColor,
    NtGdiGetDCPenColor,
    NtGdiGetGraphicsMode,
    NtGdiGetLayout,
    NtGdiGetPolyFillMode,
    NtGdiGetROP2,
    NtGdiGetTextColor,
    NtGdiIsMemDC,
};

anonymous enum

anonymous enum

Enumerator
NtGdiGetBrushOrgEx
NtGdiGetCurrentPosition
NtGdiGetDCOrg

Definition at line 146 of file ntgdi.h.

{
    NtGdiGetBrushOrgEx,
    NtGdiGetCurrentPosition,
    NtGdiGetDCOrg,
};

anonymous enum

anonymous enum

Enumerator
NtGdiAnimatePalette
NtGdiSetPaletteEntries
NtGdiGetPaletteEntries
NtGdiGetSystemPaletteEntries
NtGdiGetDIBColorTable
NtGdiSetDIBColorTable

Definition at line 153 of file ntgdi.h.

{
    NtGdiAnimatePalette,
    NtGdiSetPaletteEntries,
    NtGdiGetPaletteEntries,
    NtGdiGetSystemPaletteEntries,
    NtGdiGetDIBColorTable,
    NtGdiSetDIBColorTable,
};

Function Documentation

__wine_get_file_outline_text_metric()

W32KAPI BOOL WINAPI __wine_get_file_outline_text_metric	(	const WCHAR *	path,
		TEXTMETRICW *	otm,
		UINT *	em_square,
		WCHAR *	face_name
	)

__wine_get_icm_profile()

W32KAPI BOOL WINAPI __wine_get_icm_profile	(	HDC	hdc,
		BOOL	allow_default,
		DWORD *	size,
		WCHAR *	filename
	)

__wine_get_vulkan_driver()

W32KAPI const struct vulkan_funcs * __wine_get_vulkan_driver

(

UINT

version

)

__wine_get_wgl_driver()

W32KAPI const struct opengl_funcs * __wine_get_wgl_driver	(	HDC	hdc,
		UINT	version
	)

Referenced by wined3d_adapter_init().

NtGdiAbortDoc()

W32KAPI INT WINAPI NtGdiAbortDoc

(

HDC

hdc

)

Definition at line 16 of file print.c.

{
  UNIMPLEMENTED;
  return 0;
}

NtGdiAbortPath()

W32KAPI BOOL WINAPI NtGdiAbortPath

(

HDC

hdc

)

Definition at line 2474 of file path.c.

{
    PDC dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!dc->dclevel.hPath)
    {
       DC_UnlockDc(dc);
       return TRUE;
    }
 
    if (!PATH_Delete(dc->dclevel.hPath))
    {
       DC_UnlockDc(dc);
       return FALSE;
    }
 
    dc->dclevel.hPath = 0;
    dc->dclevel.flPath &= ~DCPATH_ACTIVE;
 
    DC_UnlockDc(dc);
    return TRUE;
}

NtGdiAddFontMemResourceEx()

W32KAPI HANDLE WINAPI NtGdiAddFontMemResourceEx	(	void *	ptr,
		DWORD	size,
		void *	dv,
		ULONG	dv_size,
		DWORD *	count
	)

NtGdiAddFontResourceW()

W32KAPI INT WINAPI NtGdiAddFontResourceW	(	const WCHAR *	str,
		ULONG	size,
		ULONG	files,
		DWORD	flags,
		DWORD	tid,
		void *	dv
	)

NtGdiAlphaBlend()

W32KAPI BOOL WINAPI NtGdiAlphaBlend	(	HDC	hdc_dst,
		int	x_dst,
		int	y_dst,
		int	width_dst,
		int	height_dst,
		HDC	hdc_src,
		int	x_src,
		int	y_src,
		int	width_src,
		int	height_src,
		DWORD	blend_function,
		HANDLE	xform
	)

NtGdiAngleArc()

W32KAPI BOOL WINAPI NtGdiAngleArc	(	HDC	hdc,
		INT	x,
		INT	y,
		DWORD	radius,
		DWORD	start_angle,
		DWORD	sweep_angle
	)

NtGdiArcInternal()

W32KAPI BOOL WINAPI NtGdiArcInternal	(	UINT	type,
		HDC	hdc,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	xstart,
		INT	ystart,
		INT	xend,
		INT	yend
	)

NtGdiBeginPath()

W32KAPI BOOL WINAPI NtGdiBeginPath

(

HDC

hdc

)

Definition at line 2504 of file path.c.

{
    PPATH pPath;
    PDC dc;
 
    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    /* If path is already open, do nothing. Check if not Save DC state */
    if ((dc->dclevel.flPath & DCPATH_ACTIVE) && !(dc->dclevel.flPath & DCPATH_SAVE))
    {
        DC_UnlockDc(dc);
        return TRUE;
    }
 
    if (dc->dclevel.hPath)
    {
        TRACE("BeginPath 1 0x%p\n", dc->dclevel.hPath);
        if (!(dc->dclevel.flPath & DCPATH_SAVE))
        {
            // Remove previous handle.
            if (!PATH_Delete(dc->dclevel.hPath))
            {
                DC_UnlockDc(dc);
                return FALSE;
            }
        }
        else
        {
            // Clear flags and Handle.
            dc->dclevel.flPath &= ~(DCPATH_SAVE | DCPATH_ACTIVE);
            dc->dclevel.hPath = NULL;
        }
    }
    pPath = PATH_CreatePath(NUM_ENTRIES_INITIAL);
    dc->dclevel.flPath |= DCPATH_ACTIVE; // Set active ASAP!
    dc->dclevel.hPath = pPath->BaseObject.hHmgr;
    IntGetCurrentPositionEx(dc, &pPath->pos);
    IntLPtoDP( dc, &pPath->pos, 1 );
    TRACE("BP : Current pos X %d Y %d\n",pPath->pos.x, pPath->pos.y);
    PATH_UnlockPath(pPath);
    DC_UnlockDc(dc);
 
    if (!pPath)
    {
        return FALSE;
    }
    return TRUE;
}

NtGdiBitBlt()

W32KAPI BOOL WINAPI NtGdiBitBlt	(	HDC	hdc_dst,
		INT	x_dst,
		INT	y_dst,
		INT	width,
		INT	height,
		HDC	hdc_src,
		INT	x_src,
		INT	y_src,
		DWORD	rop,
		DWORD	bk_color,
		FLONG	fl
	)

NtGdiCancelDC()

W32KAPI BOOL WINAPI NtGdiCancelDC

(

HDC

hdc

)

Definition at line 414 of file dcutil.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

NtGdiCloseFigure()

W32KAPI BOOL WINAPI NtGdiCloseFigure

(

HDC

hdc

)

Definition at line 2560 of file path.c.

{
    BOOL Ret = FALSE; // Default to failure
    PDC pDc;
    PPATH pPath;
 
    TRACE("Enter %s\n", __FUNCTION__);
 
    pDc = DC_LockDc(hDC);
    if (!pDc)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPath = PATH_LockPath(pDc->dclevel.hPath);
    if (!pPath)
    {
        DC_UnlockDc(pDc);
        return FALSE;
    }
 
    if (pPath->state == PATH_Open)
    {
        IntGdiCloseFigure(pPath);
        Ret = TRUE;
    }
    else
    {
        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
    }
 
    PATH_UnlockPath(pPath);
    DC_UnlockDc(pDc);
    return Ret;
}

NtGdiCombineRgn()

W32KAPI INT WINAPI NtGdiCombineRgn	(	HRGN	dest,
		HRGN	src1,
		HRGN	src2,
		INT	mode
	)

NtGdiComputeXformCoefficients()

W32KAPI BOOL WINAPI NtGdiComputeXformCoefficients

(

HDC

hdc

)

NtGdiCreateBitmap()

W32KAPI HBITMAP WINAPI NtGdiCreateBitmap	(	INT	width,
		INT	height,
		UINT	planes,
		UINT	bpp,
		const void *	bits
	)

NtGdiCreateClientObj()

W32KAPI HANDLE WINAPI NtGdiCreateClientObj

(

ULONG

type

)

NtGdiCreateCompatibleBitmap()

W32KAPI HBITMAP WINAPI NtGdiCreateCompatibleBitmap	(	HDC	hdc,
		INT	width,
		INT	height
	)

Definition at line 416 of file bitmaps.c.

{
    HBITMAP Bmp;
    PDC Dc;
 
    /* Check parameters */
    if ((Width <= 0) || (Height <= 0) || ((Width * Height) > 0x3FFFFFFF))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    if (!hDC)
        return GreCreateBitmap(Width, Height, 1, 1, 0);
 
    Dc = DC_LockDc(hDC);
 
    DPRINT("NtGdiCreateCompatibleBitmap(%p,%d,%d, bpp:%u) = \n",
           hDC, Width, Height, Dc->ppdev->gdiinfo.cBitsPixel);
 
    if (NULL == Dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
 
    Bmp = IntCreateCompatibleBitmap(Dc, Width, Height, 0, 0);
 
    DC_UnlockDc(Dc);
    return Bmp;
}

NtGdiCreateCompatibleDC()

W32KAPI HDC WINAPI NtGdiCreateCompatibleDC

(

HDC

hdc

)

Definition at line 884 of file dclife.c.

{
    /* Call the internal function to create a normal memory DC */
    return GreCreateCompatibleDC(hdc, FALSE);
}

Referenced by IntGdiCreateDisplayDC().

NtGdiCreateDIBBrush()

W32KAPI HBRUSH WINAPI NtGdiCreateDIBBrush	(	const void *	data,
		UINT	coloruse,
		UINT	size,
		BOOL	is_8x8,
		BOOL	pen,
		const void *	client
	)

NtGdiCreateDIBitmapInternal()

W32KAPI HBITMAP WINAPI NtGdiCreateDIBitmapInternal	(	HDC	hdc,
		INT	width,
		INT	height,
		DWORD	init,
		const void *	bits,
		const BITMAPINFO *	data,
		UINT	coloruse,
		UINT	max_info,
		UINT	max_bits,
		ULONG	flags,
		HANDLE	xform
	)

NtGdiCreateDIBSection()

W32KAPI HBITMAP WINAPI NtGdiCreateDIBSection	(	HDC	hdc,
		HANDLE	section,
		DWORD	offset,
		const BITMAPINFO *	bmi,
		UINT	usage,
		UINT	header_size,
		ULONG	flags,
		ULONG_PTR	color_space,
		void **	bits
	)

NtGdiCreateEllipticRgn()

W32KAPI HRGN WINAPI NtGdiCreateEllipticRgn	(	INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

Definition at line 3570 of file region.c.

{
    return NtGdiCreateRoundRectRgn(Left,
                                   Top,
                                   Right, Bottom,

NtGdiCreateHalftonePalette()

W32KAPI HPALETTE WINAPI NtGdiCreateHalftonePalette

(

HDC

hdc

)

Definition at line 527 of file palette.c.

{
    int i, r, g, b;
    PALETTEENTRY PalEntries[256];
    PPALETTE ppal;
    PDC pdc;
    HPALETTE hpal = NULL;
 
    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
 
    RtlZeroMemory(PalEntries, sizeof(PalEntries));
 
    /* First and last ten entries are default ones */
    for (i = 0; i < 10; i++)
    {
        PalEntries[i].peRed = g_sysPalTemplate[i].peRed;
        PalEntries[i].peGreen = g_sysPalTemplate[i].peGreen;
        PalEntries[i].peBlue = g_sysPalTemplate[i].peBlue;
 
        PalEntries[246 + i].peRed = g_sysPalTemplate[10 + i].peRed;
        PalEntries[246 + i].peGreen = g_sysPalTemplate[10 + i].peGreen;
        PalEntries[246 + i].peBlue = g_sysPalTemplate[10 + i].peBlue;
    }
 
    ppal = PALETTE_ShareLockPalette(pdc->dclevel.hpal);
    if (ppal && (ppal->flFlags & PAL_INDEXED))
    {
        /* FIXME: optimize the palette for the current palette */
        UNIMPLEMENTED;
    }
    else
    {
        for (r = 0; r < 6; r++)
        {
            for (g = 0; g < 6; g++)
            {
                for (b = 0; b < 6; b++)
                {
                    i = r + g*6 + b*36 + 10;
                    PalEntries[i].peRed = r * 51;
                    PalEntries[i].peGreen = g * 51;
                    PalEntries[i].peBlue = b * 51;
                }
            }
        }
 
        for (i = 216; i < 246; i++)
        {
            int v = (i - 216) << 3;
            PalEntries[i].peRed = v;
            PalEntries[i].peGreen = v;
            PalEntries[i].peBlue = v;
        }
    }
 
    if (ppal)
        PALETTE_ShareUnlockPalette(ppal);
 
    DC_UnlockDc(pdc);
 
    ppal = PALETTE_AllocPalWithHandle(PAL_INDEXED, 256, PalEntries, 0, 0, 0);
    if (ppal)
    {
        hpal = ppal->BaseObject.hHmgr;
        PALETTE_UnlockPalette(ppal);
    }
 
    return hpal;
}

NtGdiCreateHatchBrushInternal()

W32KAPI HBRUSH WINAPI NtGdiCreateHatchBrushInternal	(	INT	style,
		COLORREF	color,
		BOOL	pen
	)

NtGdiCreateMetafileDC()

W32KAPI HDC WINAPI NtGdiCreateMetafileDC

(

HDC

hdc

)

NtGdiCreatePaletteInternal()

W32KAPI HPALETTE WINAPI NtGdiCreatePaletteInternal	(	const LOGPALETTE *	palette,
		UINT	count
	)

NtGdiCreatePatternBrushInternal()

W32KAPI HBRUSH WINAPI NtGdiCreatePatternBrushInternal	(	HBITMAP	hbitmap,
		BOOL	pen,
		BOOL	is_8x8
	)

NtGdiCreatePen()

W32KAPI HPEN WINAPI NtGdiCreatePen	(	INT	style,
		INT	width,
		COLORREF	color,
		HBRUSH	brush
	)

NtGdiCreateRectRgn()

W32KAPI HRGN WINAPI NtGdiCreateRectRgn	(	INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

Definition at line 3585 of file region.c.

{
    PREGION pRgn;
    HRGN hRgn;
 
    /* Allocate region data structure with space for 1 RECTL */
    pRgn = REGION_AllocUserRgnWithHandle(1);
    if (pRgn == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    hRgn = pRgn->BaseObject.hHmgr;
 
    REGION_SetRectRgn(pRgn, LeftRect, TopRect, RightRect, BottomRect);
    REGION_UnlockRgn(pRgn);
 
    DPRINT("Returning %p.\n", hRgn);

NtGdiCreateRoundRectRgn()

W32KAPI HRGN WINAPI NtGdiCreateRoundRectRgn	(	INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	ellipse_width,
		INT	ellipse_height
	)

Definition at line 3614 of file region.c.

{
    PREGION obj;
    HRGN hrgn;
    int a, b, i, x, y;
    INT64 asq, bsq, dx, dy, err;
    RECT *rects;
 
    /* Make the dimensions sensible */
    if (left > right)
    {
        INT tmp = left;
        left = right;
        right = tmp;
    }
 
    if (top > bottom)
    {
        INT tmp = top;
        top = bottom;
        bottom = tmp;
    }
 
    /* the region is for the rectangle interior, but only at right and bottom for some reason */
    right--;
    bottom--;
 
    ellipse_width = min( right - left, abs( ellipse_width ));
    ellipse_height = min( bottom - top, abs( ellipse_height ));
 
    /* Check if we can do a normal rectangle instead */
 
    if ((ellipse_width < 2) || (ellipse_height < 2))
        return NtGdiCreateRectRgn(left, top, right, bottom);
 
    obj = REGION_AllocUserRgnWithHandle( ellipse_height );
    if (obj == NULL)
        return 0;
 
    hrgn = obj->BaseObject.hHmgr;
 
    obj->rdh.rcBound.left   = left;
    obj->rdh.rcBound.top    = top;
    obj->rdh.rcBound.right  = right;
    obj->rdh.rcBound.bottom = bottom;
    rects = obj->Buffer;
 
    /* based on an algorithm by Alois Zingl */
 
    a = ellipse_width - 1;
    b = ellipse_height - 1;
    asq = (INT64)8 * a * a;
    bsq = (INT64)8 * b * b;
    dx  = (INT64)4 * b * b * (1 - a);
    dy  = (INT64)4 * a * a * (1 + (b % 2));
    err = dx + dy + a * a * (b % 2);
 
    x = 0;
    y = ellipse_height / 2;
 
    rects[y].left = left;
    rects[y].right = right;
 
    while (x <= ellipse_width / 2)
    {
        INT64 e2 = 2 * err;
        if (e2 >= dx)
        {
            x++;
            err += dx += bsq;
        }
        if (e2 <= dy)
        {
            y++;
            err += dy += asq;
            rects[y].left = left + x;
            rects[y].right = right - x;
        }
    }
    for (i = 0; i < ellipse_height / 2; i++)
    {
        rects[i].left = rects[b - i].left;
        rects[i].right = rects[b - i].right;
        rects[i].top = top + i;
        rects[i].bottom = rects[i].top + 1;
    }
    for (; i < ellipse_height; i++)
    {
        rects[i].top = bottom - ellipse_height + i;
        rects[i].bottom = rects[i].top + 1;
    }
    rects[ellipse_height / 2].top = top + ellipse_height / 2;  /* extend to top of rectangle */
 

Referenced by NtGdiCreateEllipticRgn().

NtGdiCreateSolidBrush()

W32KAPI HBRUSH WINAPI NtGdiCreateSolidBrush	(	COLORREF	color,
		HBRUSH	brush
	)

NtGdiDdDDICheckVidPnExclusiveOwnership()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership

(

const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *

desc

)

NtGdiDdDDICloseAdapter()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICloseAdapter

(

const D3DKMT_CLOSEADAPTER *

desc

)

NtGdiDdDDICreateAllocation()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateAllocation

(

D3DKMT_CREATEALLOCATION *

params

)

NtGdiDdDDICreateAllocation2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateAllocation2

(

D3DKMT_CREATEALLOCATION *

params

)

NtGdiDdDDICreateDCFromMemory()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateDCFromMemory

(

D3DKMT_CREATEDCFROMMEMORY *

desc

)

Definition at line 13 of file d3dkmt.c.

{
    PSURFACE psurf;
    HDC hDC;
 
    const struct d3dddi_format_info
    {
        D3DDDIFORMAT format;
        unsigned int bit_count;
        DWORD compression;
        unsigned int palette_size;
        DWORD mask_r, mask_g, mask_b;
    } *format = NULL;
    unsigned int i;
 
    static const struct d3dddi_format_info format_info[] =
    {
        { D3DDDIFMT_R8G8B8,   24, BI_RGB,       0,   0x00000000, 0x00000000, 0x00000000 },
        { D3DDDIFMT_A8R8G8B8, 32, BI_RGB,       0,   0x00000000, 0x00000000, 0x00000000 },
        { D3DDDIFMT_X8R8G8B8, 32, BI_RGB,       0,   0x00000000, 0x00000000, 0x00000000 },
        { D3DDDIFMT_R5G6B5,   16, BI_BITFIELDS, 0,   0x0000f800, 0x000007e0, 0x0000001f },
        { D3DDDIFMT_X1R5G5B5, 16, BI_BITFIELDS, 0,   0x00007c00, 0x000003e0, 0x0000001f },
        { D3DDDIFMT_A1R5G5B5, 16, BI_BITFIELDS, 0,   0x00007c00, 0x000003e0, 0x0000001f },
        { D3DDDIFMT_A4R4G4B4, 16, BI_BITFIELDS, 0,   0x00000f00, 0x000000f0, 0x0000000f },
        { D3DDDIFMT_X4R4G4B4, 16, BI_BITFIELDS, 0,   0x00000f00, 0x000000f0, 0x0000000f },
        { D3DDDIFMT_P8,       8,  BI_RGB,       256, 0x00000000, 0x00000000, 0x00000000 },
    };
 
    if (!desc)
        return STATUS_INVALID_PARAMETER;
 
    if (!desc->pMemory)
        return STATUS_INVALID_PARAMETER;
 
    for (i = 0; i < sizeof(format_info) / sizeof(*format_info); ++i)
    {
        if (format_info[i].format == desc->Format)
        {
            format = &format_info[i];
            break;
        }
    }
 
    if (!format)
        return STATUS_INVALID_PARAMETER;
 
    if (desc->Width > (UINT_MAX & ~3) / (format->bit_count / 8) ||
        !desc->Pitch || desc->Pitch < (((desc->Width * format->bit_count + 31) >> 3) & ~3) ||
        !desc->Height || desc->Height > UINT_MAX / desc->Pitch)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    if (!desc->hDeviceDc || !(hDC = NtGdiCreateCompatibleDC(desc->hDeviceDc)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Allocate a surface */
    psurf = SURFACE_AllocSurface(STYPE_BITMAP,
                                 desc->Width,
                                 desc->Height,
                                 BitmapFormat(format->bit_count, format->compression),
                                 BMF_TOPDOWN | BMF_NOZEROINIT,
                                 desc->Pitch,
                                 0,
                                 desc->pMemory);
 
    /* Mark as API bitmap */
    psurf->flags |= (DDB_SURFACE | API_BITMAP);
 
    desc->hDc = hDC;
    /* Get the handle for the bitmap */
    desc->hBitmap = (HBITMAP)psurf->SurfObj.hsurf;
 
    /* Allocate a palette for this surface */
    if (format->bit_count <= 8)
    {
        PPALETTE palette = PALETTE_AllocPalette(PAL_INDEXED, 1 << format->bit_count, NULL, 0, 0, 0);
        if (palette)
        {
            SURFACE_vSetPalette(psurf, palette);
            PALETTE_ShareUnlockPalette(palette);
        }
    }
 
    /* Unlock the surface and return */
    SURFACE_UnlockSurface(psurf);
 
    NtGdiSelectBitmap(desc->hDc, desc->hBitmap);
 
    return STATUS_SUCCESS;
}

NtGdiDdDDICreateDevice()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateDevice

(

D3DKMT_CREATEDEVICE *

desc

)

NtGdiDdDDICreateKeyedMutex()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateKeyedMutex

(

D3DKMT_CREATEKEYEDMUTEX *

params

)

NtGdiDdDDICreateKeyedMutex2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateKeyedMutex2

(

D3DKMT_CREATEKEYEDMUTEX2 *

params

)

NtGdiDdDDICreateSynchronizationObject()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateSynchronizationObject

(

D3DKMT_CREATESYNCHRONIZATIONOBJECT *

params

)

NtGdiDdDDICreateSynchronizationObject2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateSynchronizationObject2

(

D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *

params

)

NtGdiDdDDIDestroyAllocation()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyAllocation

(

const D3DKMT_DESTROYALLOCATION *

params

)

NtGdiDdDDIDestroyAllocation2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyAllocation2

(

const D3DKMT_DESTROYALLOCATION2 *

params

)

NtGdiDdDDIDestroyDCFromMemory()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyDCFromMemory

(

const D3DKMT_DESTROYDCFROMMEMORY *

desc

)

Definition at line 109 of file d3dkmt.c.

{
    if (!desc)
        return STATUS_INVALID_PARAMETER;
 
    if (GDI_HANDLE_GET_TYPE(desc->hDc) != GDI_OBJECT_TYPE_DC ||
        GDI_HANDLE_GET_TYPE(desc->hBitmap) != GDI_OBJECT_TYPE_BITMAP)
        return STATUS_INVALID_PARAMETER;
 
    NtGdiDeleteObjectApp(desc->hBitmap);
    NtGdiDeleteObjectApp(desc->hDc);
 
    return STATUS_SUCCESS;
}

NtGdiDdDDIDestroyDevice()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyDevice

(

const D3DKMT_DESTROYDEVICE *

desc

)

NtGdiDdDDIDestroyKeyedMutex()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyKeyedMutex

(

const D3DKMT_DESTROYKEYEDMUTEX *

params

)

NtGdiDdDDIDestroySynchronizationObject()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroySynchronizationObject

(

const D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *

params

)

NtGdiDdDDIEnumAdapters()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIEnumAdapters

(

D3DKMT_ENUMADAPTERS *

desc

)

NtGdiDdDDIEnumAdapters2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIEnumAdapters2

(

D3DKMT_ENUMADAPTERS2 *

desc

)

NtGdiDdDDIEscape()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIEscape

(

const D3DKMT_ESCAPE *

desc

)

NtGdiDdDDIOpenAdapterFromDeviceName()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromDeviceName

(

D3DKMT_OPENADAPTERFROMDEVICENAME *

desc

)

NtGdiDdDDIOpenAdapterFromHdc()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromHdc

(

D3DKMT_OPENADAPTERFROMHDC *

desc

)

NtGdiDdDDIOpenAdapterFromLuid()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid

(

D3DKMT_OPENADAPTERFROMLUID *

desc

)

NtGdiDdDDIOpenKeyedMutex()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenKeyedMutex

(

D3DKMT_OPENKEYEDMUTEX *

params

)

NtGdiDdDDIOpenKeyedMutex2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenKeyedMutex2

(

D3DKMT_OPENKEYEDMUTEX2 *

params

)

NtGdiDdDDIOpenKeyedMutexFromNtHandle()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenKeyedMutexFromNtHandle

(

D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE *

params

)

NtGdiDdDDIOpenResource()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenResource

(

D3DKMT_OPENRESOURCE *

params

)

NtGdiDdDDIOpenResource2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenResource2

(

D3DKMT_OPENRESOURCE *

params

)

NtGdiDdDDIOpenResourceFromNtHandle()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenResourceFromNtHandle

(

D3DKMT_OPENRESOURCEFROMNTHANDLE *

params

)

NtGdiDdDDIOpenSynchronizationObject()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSynchronizationObject

(

D3DKMT_OPENSYNCHRONIZATIONOBJECT *

params

)

NtGdiDdDDIOpenSyncObjectFromNtHandle()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSyncObjectFromNtHandle

(

D3DKMT_OPENSYNCOBJECTFROMNTHANDLE *

params

)

NtGdiDdDDIOpenSyncObjectFromNtHandle2()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSyncObjectFromNtHandle2

(

D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 *

params

)

NtGdiDdDDIOpenSyncObjectNtHandleFromName()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSyncObjectNtHandleFromName

(

D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME *

params

)

NtGdiDdDDIQueryAdapterInfo()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryAdapterInfo

(

D3DKMT_QUERYADAPTERINFO *

desc

)

NtGdiDdDDIQueryResourceInfo()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryResourceInfo

(

D3DKMT_QUERYRESOURCEINFO *

params

)

NtGdiDdDDIQueryResourceInfoFromNtHandle()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryResourceInfoFromNtHandle

(

D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE *

params

)

NtGdiDdDDIQueryStatistics()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryStatistics

(

D3DKMT_QUERYSTATISTICS *

stats

)

NtGdiDdDDIQueryVideoMemoryInfo()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo

(

D3DKMT_QUERYVIDEOMEMORYINFO *

desc

)

NtGdiDdDDISetQueuedLimit()

W32KAPI NTSTATUS WINAPI NtGdiDdDDISetQueuedLimit

(

D3DKMT_SETQUEUEDLIMIT *

desc

)

NtGdiDdDDISetVidPnSourceOwner()

W32KAPI NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner

(

const D3DKMT_SETVIDPNSOURCEOWNER *

desc

)

NtGdiDdDDIShareObjects()

W32KAPI NTSTATUS WINAPI NtGdiDdDDIShareObjects	(	UINT	count,
		const D3DKMT_HANDLE *	handles,
		OBJECT_ATTRIBUTES *	attr,
		UINT	access,
		HANDLE *	handle
	)

NtGdiDeleteClientObj()

W32KAPI BOOL WINAPI NtGdiDeleteClientObj

(

HGDIOBJ

obj

)

NtGdiDeleteObjectApp()

W32KAPI BOOL WINAPI NtGdiDeleteObjectApp

(

HGDIOBJ

obj

)

Definition at line 950 of file dclife.c.

{
    if (GDI_HANDLE_IS_STOCKOBJ(hobj)) return TRUE;
 
    if (GreGetObjectOwner(hobj) != GDI_OBJ_HMGR_POWNED)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (GDI_HANDLE_GET_TYPE(hobj) != GDI_OBJECT_TYPE_DC)
        return GreDeleteObject(hobj);
 
    // FIXME: Everything should be callback based
    return IntGdiDeleteDC(hobj, FALSE);
}

NtGdiDescribePixelFormat()

W32KAPI INT WINAPI NtGdiDescribePixelFormat	(	HDC	hdc,
		INT	format,
		UINT	size,
		PIXELFORMATDESCRIPTOR *	descr
	)

NtGdiDoPalette()

W32KAPI LONG WINAPI NtGdiDoPalette	(	HGDIOBJ	handle,
		WORD	start,
		WORD	count,
		void *	entries,
		DWORD	func,
		BOOL	inbound
	)

NtGdiDrawStream()

W32KAPI BOOL WINAPI NtGdiDrawStream	(	HDC	hdc,
		ULONG	in,
		void *	pvin
	)

NtGdiEllipse()

W32KAPI BOOL WINAPI NtGdiEllipse	(	HDC	hdc,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

NtGdiEndDoc()

W32KAPI INT WINAPI NtGdiEndDoc

(

HDC

hdc

)

Definition at line 24 of file print.c.

{
  UNIMPLEMENTED;
  return 0;
}

NtGdiEndPage()

W32KAPI INT WINAPI NtGdiEndPage

(

HDC

hdc

)

Definition at line 32 of file print.c.

{
  UNIMPLEMENTED;
  return 0;
}

NtGdiEndPath()

W32KAPI BOOL WINAPI NtGdiEndPath

(

HDC

hdc

)

Definition at line 2599 of file path.c.

{
    BOOL ret = TRUE;
    PPATH pPath;
    PDC dc;
 
    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    pPath = PATH_LockPath(dc->dclevel.hPath);
    if (!pPath)
    {
        DC_UnlockDc(dc);
        return FALSE;
    }
 
    /* Check that path is currently being constructed */
    if ((pPath->state != PATH_Open) || !(dc->dclevel.flPath & DCPATH_ACTIVE))
    {
        TRACE("EndPath ERROR! 0x%p\n", dc->dclevel.hPath);
        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
        ret = FALSE;
    }
    /* Set flag to indicate that path is finished */
    else
    {
        TRACE("EndPath 0x%p\n", dc->dclevel.hPath);
        pPath->state = PATH_Closed;
        dc->dclevel.flPath &= ~DCPATH_ACTIVE;
    }
 
    PATH_UnlockPath(pPath);
    DC_UnlockDc(dc);
    return ret;
}

NtGdiEnumFonts()

W32KAPI BOOL WINAPI NtGdiEnumFonts	(	HDC	hdc,
		ULONG	type,
		ULONG	win32_compat,
		ULONG	face_name_len,
		const WCHAR *	face_name,
		ULONG	charset,
		ULONG *	count,
		void *	buf
	)

NtGdiEqualRgn()

W32KAPI BOOL WINAPI NtGdiEqualRgn	(	HRGN	hrgn1,
		HRGN	hrgn2
	)

Definition at line 3719 of file region.c.

{
    HRGN ahrgn[2];
    PREGION aprgn[2];
    PREGION rgn1, rgn2;
    PRECTL tRect1, tRect2;
    ULONG i;
    BOOL bRet = FALSE;
 
    /* Check if we got 2 regions */
    if ((hSrcRgn1 == NULL) || (hSrcRgn2 == NULL))
    {
        return FALSE;
    }
 
    /* Check if these are the same regions */
    if (hSrcRgn1 == hSrcRgn2)
    {
        /* Make sure this region is valid */
        if ((GDI_HANDLE_GET_TYPE(hSrcRgn1) == GDILoObjType_LO_REGION_TYPE) &&
            GreIsHandleValid(hSrcRgn1))
        {
            return TRUE;
        }
        return FALSE;
    }
 
    /* Lock both regions */
    ahrgn[0] = hSrcRgn1;
    ahrgn[1] = hSrcRgn2;
    if (!GDIOBJ_bLockMultipleObjects(2, (HGDIOBJ*)ahrgn, (PVOID*)aprgn, GDIObjType_RGN_TYPE))
    {
        DPRINT1("NtGdiEqualRgn failed to lock regions: %p, %p\n",
                hSrcRgn1, hSrcRgn2);
        return FALSE;
    }
 
    REGION_vSyncRegion(aprgn[0]);
    REGION_vSyncRegion(aprgn[1]);
 
    rgn1 = aprgn[0];
    rgn2 = aprgn[1];
 
    if (rgn1->rdh.nCount != rgn2->rdh.nCount)
        goto exit;
 
    if (rgn1->rdh.nCount == 0)
    {
        bRet = TRUE;
        goto exit;
    }
 
    if ((rgn1->rdh.rcBound.left   != rgn2->rdh.rcBound.left)  ||
        (rgn1->rdh.rcBound.right  != rgn2->rdh.rcBound.right) ||
        (rgn1->rdh.rcBound.top    != rgn2->rdh.rcBound.top)   ||
        (rgn1->rdh.rcBound.bottom != rgn2->rdh.rcBound.bottom))
        goto exit;
 
    tRect1 = rgn1->Buffer;
    tRect2 = rgn2->Buffer;
 
    if ((tRect1 == NULL) || (tRect2 == NULL))
        goto exit;
 
    for (i=0; i < rgn1->rdh.nCount; i++)
    {
        if ((tRect1[i].left   != tRect2[i].left)  ||
            (tRect1[i].right  != tRect2[i].right) ||
            (tRect1[i].top    != tRect2[i].top)   ||
            (tRect1[i].bottom != tRect2[i].bottom))
            goto exit;
    }
 
    bRet = TRUE;
 
exit:
    REGION_UnlockRgn(rgn1);

NtGdiExcludeClipRect()

W32KAPI INT WINAPI NtGdiExcludeClipRect	(	HDC	hdc,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

NtGdiExtCreatePen()

W32KAPI HPEN WINAPI NtGdiExtCreatePen	(	DWORD	style,
		DWORD	width,
		ULONG	brush_style,
		ULONG	color,
		ULONG_PTR	client_hatch,
		ULONG_PTR	hatch,
		DWORD	style_count,
		const DWORD *	style_bits,
		ULONG	dib_size,
		BOOL	old_style,
		HBRUSH	brush
	)

NtGdiExtCreateRegion()

W32KAPI HRGN WINAPI NtGdiExtCreateRegion	(	const XFORM *	xform,
		DWORD	count,
		const RGNDATA *	data
	)

NtGdiExtEscape()

W32KAPI INT WINAPI NtGdiExtEscape	(	HDC	hdc,
		WCHAR *	driver,
		INT	driver_id,
		INT	escape,
		INT	input_size,
		const char *	input,
		INT	output_size,
		char *	output
	)

NtGdiExtFloodFill()

W32KAPI BOOL WINAPI NtGdiExtFloodFill	(	HDC	hdc,
		INT	x,
		INT	y,
		COLORREF	color,
		UINT	type
	)

Definition at line 1159 of file fillshap.c.

{
    PDC dc;
#if 0
    PDC_ATTR   pdcattr;
#endif
    SURFACE    *psurf;
    EXLATEOBJ  exlo;
    BOOL       Ret = FALSE;
    RECTL      DestRect;
    POINTL     Pt;
    ULONG      ConvColor;
    PREGION    prgn;
 
    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!dc->dclevel.pSurface)
    {
        Ret = TRUE;
        goto cleanup;
    }
 
#if 0
    pdcattr = dc->pdcattr;
#endif
 
    Pt.x = XStart;
    Pt.y = YStart;
    IntLPtoDP(dc, (LPPOINT)&Pt, 1);
 
    DC_vPrepareDCsForBlit(dc, &DestRect, NULL, NULL);
 
    psurf = dc->dclevel.pSurface;
 
    prgn = dc->prgnRao ? dc->prgnRao : dc->prgnVis;
    if (prgn)
    {
        Ret = REGION_PtInRegion(prgn, Pt.x, Pt.y);
        if (Ret)
            REGION_GetRgnBox(prgn, (LPRECT)&DestRect);
        else
        {
            DC_vFinishBlit(dc, NULL);
            goto cleanup;
        }
    }
    else
    {
        RECTL_vSetRect(&DestRect, 0, 0, psurf->SurfObj.sizlBitmap.cx, psurf->SurfObj.sizlBitmap.cy);
    }
 
    if (dc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
    {
       IntUpdateBoundsRect(dc, &DestRect);
    }
 
    EXLATEOBJ_vInitialize(&exlo, &gpalRGB, psurf->ppal, 0, 0xffffff, 0);
 
    /* Only solid fills supported for now
     * How to support pattern brushes and non standard surfaces (not offering dib functions):
     * Version a (most likely slow): call DrvPatBlt for every pixel
     * Version b: create a flood mask and let MaskBlt blit a masked brush */
    ConvColor = XLATEOBJ_iXlate(&exlo.xlo, Color);
    Ret = DIB_XXBPP_FloodFillSolid(&psurf->SurfObj, &dc->eboFill.BrushObject, &DestRect, &Pt, ConvColor, FillType);
 
    DC_vFinishBlit(dc, NULL);
 
    EXLATEOBJ_vCleanup(&exlo);
 
cleanup:
    DC_UnlockDc(dc);
    return Ret;
}

NtGdiExtGetObjectW()

W32KAPI INT WINAPI NtGdiExtGetObjectW	(	HGDIOBJ	handle,
		INT	count,
		void *	buffer
	)

Referenced by GetFontObjectA(), and GetObjectW().

NtGdiExtSelectClipRgn()

W32KAPI INT WINAPI NtGdiExtSelectClipRgn	(	HDC	hdc,
		HRGN	region,
		INT	mode
	)

NtGdiExtTextOutW()

W32KAPI BOOL WINAPI NtGdiExtTextOutW	(	HDC	hdc,
		INT	x,
		INT	y,
		UINT	flags,
		const RECT *	rect,
		const WCHAR *	str,
		UINT	count,
		const INT *	dx,
		DWORD	cp
	)

NtGdiFillPath()

W32KAPI BOOL WINAPI NtGdiFillPath

(

HDC

hdc

)

Definition at line 2641 of file path.c.

{
    BOOL ret = FALSE;
    PPATH pPath, pNewPath;
    PDC_ATTR pdcattr;
    PDC dc;
 
    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPath = PATH_LockPath(dc->dclevel.hPath);
    if (!pPath)
    {
        DC_UnlockDc(dc);
        return FALSE;
    }
 
    DC_vPrepareDCsForBlit(dc, NULL, NULL, NULL);
 
    pdcattr = dc->pdcattr;
 
    if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
        DC_vUpdateLineBrush(dc);
 
    if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
        DC_vUpdateFillBrush(dc);
 
    pNewPath = PATH_FlattenPath(pPath);
 
    if (pNewPath->state != PATH_Closed)
    {
        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
    }
    else if (pNewPath->numEntriesUsed)
    {
       ret = PATH_FillPath(dc, pNewPath);
    }
    else ret = TRUE;
 
    PATH_UnlockPath(pNewPath);
    PATH_Delete(pNewPath->BaseObject.hHmgr);
 
    PATH_UnlockPath(pPath);
    PATH_Delete(pPath->BaseObject.hHmgr);
    dc->dclevel.hPath = 0;
    dc->dclevel.flPath &= ~DCPATH_ACTIVE;
 
    DC_vFinishBlit(dc, NULL);
    DC_UnlockDc(dc);
    return ret;
}

NtGdiFillRgn()

W32KAPI BOOL WINAPI NtGdiFillRgn	(	HDC	hdc,
		HRGN	hrgn,
		HBRUSH	hbrush
	)

NtGdiFlattenPath()

W32KAPI BOOL WINAPI NtGdiFlattenPath

(

HDC

hdc

)

Definition at line 2699 of file path.c.

{
    BOOL Ret = FALSE;
    DC *pDc;
    PPATH pPath, pNewPath = NULL;
 
    TRACE("Enter %s\n", __FUNCTION__);
 
    pDc = DC_LockDc(hDC);
    if (!pDc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    pPath = PATH_LockPath(pDc->dclevel.hPath);
    if (!pPath)
    {
        EngSetLastError( ERROR_CAN_NOT_COMPLETE );
        DC_UnlockDc(pDc);
        return FALSE;
    }
 
    if (pPath->state == PATH_Closed)
    {
        pNewPath = PATH_FlattenPath(pPath);
    }
 
    PATH_UnlockPath(pPath);
 
    if (pNewPath)
    {
       PATH_Delete(pDc->dclevel.hPath);
       pDc->dclevel.hPath = pNewPath->BaseObject.hHmgr;
       PATH_UnlockPath(pNewPath);
       Ret = TRUE;
    }
 
    DC_UnlockDc(pDc);
    return Ret;
}

NtGdiFlush()

W32KAPI BOOL WINAPI 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().

NtGdiFontIsLinked()

W32KAPI BOOL WINAPI NtGdiFontIsLinked

(

HDC

hdc

)

NtGdiFrameRgn()

W32KAPI BOOL WINAPI NtGdiFrameRgn	(	HDC	hdc,
		HRGN	hrgn,
		HBRUSH	brush,
		INT	width,
		INT	height
	)

NtGdiGetAndSetDCDword()

W32KAPI BOOL WINAPI NtGdiGetAndSetDCDword	(	HDC	hdc,
		UINT	method,
		DWORD	value,
		DWORD *	result
	)

Referenced by GetAndSetDCDWord().

NtGdiGetAppClipBox()

W32KAPI INT WINAPI NtGdiGetAppClipBox	(	HDC	hdc,
		RECT *	rect
	)

Referenced by GetClipBox().

NtGdiGetBitmapBits()

W32KAPI LONG WINAPI NtGdiGetBitmapBits	(	HBITMAP	bitmap,
		LONG	count,
		void *	bits
	)

NtGdiGetBitmapDimension()

W32KAPI BOOL WINAPI NtGdiGetBitmapDimension	(	HBITMAP	bitmap,
		SIZE *	size
	)

NtGdiGetBoundsRect()

W32KAPI UINT WINAPI NtGdiGetBoundsRect	(	HDC	hdc,
		RECT *	rect,
		UINT	flags
	)

Referenced by GetBoundsRect(), and GetBoundsRectAlt().

NtGdiGetCharABCWidthsW()

W32KAPI BOOL WINAPI NtGdiGetCharABCWidthsW	(	HDC	hdc,
		UINT	first,
		UINT	last,
		WCHAR *	chars,
		ULONG	flags,
		void *	buffer
	)

NtGdiGetCharWidthInfo()

W32KAPI BOOL WINAPI NtGdiGetCharWidthInfo	(	HDC	hdc,
		struct char_width_info *	info
	)

NtGdiGetCharWidthW()

W32KAPI BOOL WINAPI NtGdiGetCharWidthW	(	HDC	hdc,
		UINT	first_char,
		UINT	last_char,
		WCHAR *	chars,
		ULONG	flags,
		void *	buffer
	)

NtGdiGetColorAdjustment()

W32KAPI BOOL WINAPI NtGdiGetColorAdjustment	(	HDC	hdc,
		COLORADJUSTMENT *	ca
	)

NtGdiGetDCDword()

W32KAPI BOOL WINAPI NtGdiGetDCDword	(	HDC	hdc,
		UINT	method,
		DWORD *	result
	)

Definition at line 456 of file dcutil.c.

{
    BOOL Ret = TRUE;
    PDC pdc;
    PDC_ATTR pdcattr;
 
    DWORD SafeResult = 0;
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (!Result)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = pdc->pdcattr;
 
    switch (u)
    {
        case GdiGetJournal:
            break;
 
        case GdiGetRelAbs:
            SafeResult = pdcattr->lRelAbs;
            break;
 
        case GdiGetBreakExtra:
            SafeResult = pdcattr->lBreakExtra;
            break;
 
        case GdiGetCharBreak:
            SafeResult = pdcattr->cBreak;
            break;
 
        case GdiGetArcDirection:
            if (pdcattr->dwLayout & LAYOUT_RTL)
                SafeResult = AD_CLOCKWISE - ((pdc->dclevel.flPath & DCPATH_CLOCKWISE) != 0);
            else
                SafeResult = ((pdc->dclevel.flPath & DCPATH_CLOCKWISE) != 0) + AD_COUNTERCLOCKWISE;
            break;
 
        case GdiGetEMFRestorDc:
            SafeResult = pdc->dclevel.lSaveDepth;
            break;
 
        case GdiGetFontLanguageInfo:
            SafeResult = IntGetFontLanguageInfo(pdc);
            break;
 
        case GdiGetIsMemDc:
            SafeResult = pdc->dctype;
            break;
 
        case GdiGetMapMode:
            SafeResult = pdcattr->iMapMode;
            break;
 
        case GdiGetTextCharExtra:
            SafeResult = pdcattr->lTextExtra;
            break;
 
        default:
            EngSetLastError(ERROR_INVALID_PARAMETER);
            Ret = FALSE;
            break;
    }
 
    if (Ret)
    {
        _SEH2_TRY
        {
            ProbeForWrite(Result, sizeof(DWORD), 1);
            *Result = SafeResult;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
 
        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            Ret = FALSE;
        }
    }
 
    DC_UnlockDc(pdc);
    return Ret;
}

NtGdiGetDCObject()

W32KAPI HANDLE WINAPI NtGdiGetDCObject	(	HDC	hdc,
		UINT	type
	)

NtGdiGetDCPoint()

W32KAPI BOOL WINAPI NtGdiGetDCPoint	(	HDC	hdc,
		UINT	method,
		POINT *	result
	)

Referenced by DPtoLP(), GetAspectRatioFilterEx(), GetDCOrgEx(), and GetViewportExtEx().

NtGdiGetDeviceCaps()

W32KAPI INT WINAPI NtGdiGetDeviceCaps	(	HDC	hdc,
		INT	cap
	)

Definition at line 1137 of file pdevobj.c.

{
    PDC pdc;
    DEVCAPS devcaps;
 
    /* Lock the given DC */
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return 0;
    }
 
    /* Get the data */
    PDEVOBJ_vGetDeviceCaps(pdc->ppdev, &devcaps);
 
    /* Unlock the DC */
    DC_UnlockDc(pdc);
 
    /* Return capability */
    switch (Index)
    {
        case DRIVERVERSION:
            return devcaps.ulVersion;
 
        case TECHNOLOGY:
            return devcaps.ulTechnology;
 
        case HORZSIZE:
            return devcaps.ulHorzSize;
 
        case VERTSIZE:
            return devcaps.ulVertSize;
 
        case HORZRES:
            return devcaps.ulHorzRes;
 
        case VERTRES:
            return devcaps.ulVertRes;
 
        case LOGPIXELSX:
            return devcaps.ulLogPixelsX;
 
        case LOGPIXELSY:
            return devcaps.ulLogPixelsY;
 
        case BITSPIXEL:
            return devcaps.ulBitsPixel;
 
        case PLANES:
            return devcaps.ulPlanes;
 
        case NUMBRUSHES:
            return -1;
 
        case NUMPENS:
            return devcaps.ulNumPens;
 
        case NUMFONTS:
            return devcaps.ulNumFonts;
 
        case NUMCOLORS:
            return devcaps.ulNumColors;
 
        case ASPECTX:
            return devcaps.ulAspectX;
 
        case ASPECTY:
            return devcaps.ulAspectY;
 
        case ASPECTXY:
            return devcaps.ulAspectXY;
 
        case CLIPCAPS:
            return CP_RECTANGLE;
 
        case SIZEPALETTE:
            return devcaps.ulSizePalette;
 
        case NUMRESERVED:
            return 20;
 
        case COLORRES:
            return devcaps.ulColorRes;
 
        case DESKTOPVERTRES:
            return devcaps.ulVertRes;
 
        case DESKTOPHORZRES:
            return devcaps.ulHorzRes;
 
        case BLTALIGNMENT:
            return devcaps.ulBltAlignment;
 
        case SHADEBLENDCAPS:
            return devcaps.ulShadeBlend;
 
        case COLORMGMTCAPS:
            return devcaps.ulColorMgmtCaps;
 
        case PHYSICALWIDTH:
            return devcaps.ulPhysicalWidth;
 
        case PHYSICALHEIGHT:
            return devcaps.ulPhysicalHeight;
 
        case PHYSICALOFFSETX:
            return devcaps.ulPhysicalOffsetX;
 
        case PHYSICALOFFSETY:
            return devcaps.ulPhysicalOffsetY;
 
        case VREFRESH:
            return devcaps.ulVRefresh;
 
        case RASTERCAPS:
            return devcaps.ulRasterCaps;
 
        case CURVECAPS:
            return (CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES | CC_WIDE |
                    CC_STYLED | CC_WIDESTYLED | CC_INTERIORS | CC_ROUNDRECT);
 
        case LINECAPS:
            return (LC_POLYLINE | LC_MARKER | LC_POLYMARKER | LC_WIDE |
                    LC_STYLED | LC_WIDESTYLED | LC_INTERIORS);
 
        case POLYGONALCAPS:
            return (PC_POLYGON | PC_RECTANGLE | PC_WINDPOLYGON | PC_SCANLINE |
                    PC_WIDE | PC_STYLED | PC_WIDESTYLED | PC_INTERIORS);
 
        case TEXTCAPS:
            return devcaps.ulTextCaps;
 
        case CAPS1:
        case PDEVICESIZE:
        case SCALINGFACTORX:
        case SCALINGFACTORY:
        default:
            return 0;
    }
 
    return 0;
}

NtGdiGetDeviceGammaRamp()

W32KAPI BOOL WINAPI NtGdiGetDeviceGammaRamp	(	HDC	hdc,
		void *	ptr
	)

Referenced by GetDeviceGammaRamp().

NtGdiGetDIBitsInternal()

W32KAPI INT WINAPI NtGdiGetDIBitsInternal	(	HDC	hdc,
		HBITMAP	hbitmap,
		UINT	startscan,
		UINT	lines,
		void *	bits,
		BITMAPINFO *	info,
		UINT	coloruse,
		UINT	max_bits,
		UINT	max_info
	)

Referenced by GetDIBits(), and START_TEST().

NtGdiGetFontData()

W32KAPI DWORD WINAPI NtGdiGetFontData	(	HDC	hdc,
		DWORD	table,
		DWORD	offset,
		void *	buffer,
		DWORD	length
	)

Referenced by GetFontData().

NtGdiGetFontFileData()

W32KAPI BOOL WINAPI NtGdiGetFontFileData	(	DWORD	instance_id,
		DWORD	file_index,
		UINT64 *	offset,
		void *	buff,
		SIZE_T	buff_size
	)

NtGdiGetFontFileInfo()

W32KAPI BOOL WINAPI NtGdiGetFontFileInfo	(	DWORD	instance_id,
		DWORD	file_index,
		struct font_fileinfo *	info,
		SIZE_T	size,
		SIZE_T *	needed
	)

NtGdiGetFontUnicodeRanges()

W32KAPI DWORD WINAPI NtGdiGetFontUnicodeRanges	(	HDC	hdc,
		GLYPHSET *	lpgs
	)

NtGdiGetGlyphIndicesW()

W32KAPI DWORD WINAPI NtGdiGetGlyphIndicesW	(	HDC	hdc,
		const WCHAR *	str,
		INT	count,
		WORD *	indices,
		DWORD	flags
	)

NtGdiGetGlyphOutline()

W32KAPI DWORD WINAPI NtGdiGetGlyphOutline	(	HDC	hdc,
		UINT	ch,
		UINT	format,
		GLYPHMETRICS *	metrics,
		DWORD	size,
		void *	buffer,
		const MAT2 *	mat2,
		BOOL	ignore_rotation
	)

NtGdiGetKerningPairs()

W32KAPI DWORD WINAPI NtGdiGetKerningPairs	(	HDC	hdc,
		DWORD	count,
		KERNINGPAIR *	kern_pair
	)

NtGdiGetMiterLimit()

W32KAPI BOOL WINAPI NtGdiGetMiterLimit	(	HDC	hdc,
		DWORD *	limit
	)

NtGdiGetNearestColor()

W32KAPI COLORREF WINAPI NtGdiGetNearestColor	(	HDC	hdc,
		COLORREF	color
	)

NtGdiGetNearestPaletteIndex()

W32KAPI UINT WINAPI NtGdiGetNearestPaletteIndex	(	HPALETTE	hpalette,
		COLORREF	color
	)

Definition at line 717 of file palette.c.

{
    PPALETTE ppal = PALETTE_ShareLockPalette(hpal);
    UINT index  = 0;
 
    if (ppal)
    {
        if (ppal->flFlags & PAL_INDEXED)
        {
            /* Return closest match for the given RGB color */
            index = PALETTE_ulGetNearestPaletteIndex(ppal, crColor);
        }
        // else SetLastError ?
        PALETTE_ShareUnlockPalette(ppal);
    }
 
    return index;
}

NtGdiGetOutlineTextMetricsInternalW()

W32KAPI UINT WINAPI NtGdiGetOutlineTextMetricsInternalW	(	HDC	hdc,
		UINT	cbData,
		OUTLINETEXTMETRICW *	otm,
		ULONG	opts
	)

NtGdiGetPath()

W32KAPI INT WINAPI NtGdiGetPath	(	HDC	hdc,
		POINT *	points,
		BYTE *	types,
		INT	size
	)

NtGdiGetPixel()

W32KAPI COLORREF WINAPI NtGdiGetPixel	(	HDC	hdc,
		INT	x,
		INT	y
	)

NtGdiGetRandomRgn()

W32KAPI INT WINAPI NtGdiGetRandomRgn	(	HDC	hdc,
		HRGN	region,
		INT	code
	)

Todo:

FIXME This is not really correct, since we already modified the region

Definition at line 709 of file dcobjs.c.

{
    INT ret = 0;
    PDC pdc;
    PREGION prgnSrc = NULL;
 
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return -1;
    }
 
    switch (iCode)
    {
        case CLIPRGN:
            prgnSrc = pdc->dclevel.prgnClip;
            break;
 
        case METARGN:
            prgnSrc = pdc->dclevel.prgnMeta;
            break;
 
        case APIRGN:
            if (pdc->fs & DC_DIRTY_RAO)
                CLIPPING_UpdateGCRegion(pdc);
            if (pdc->prgnAPI)
            {
                prgnSrc = pdc->prgnAPI;
            }
            else if (pdc->dclevel.prgnClip)
            {
                prgnSrc = pdc->dclevel.prgnClip;
            }
            else if (pdc->dclevel.prgnMeta)
            {
                prgnSrc = pdc->dclevel.prgnMeta;
            }
            break;
 
        case SYSRGN:
            prgnSrc = pdc->prgnVis;
            break;
 
        default:
            break;
    }
 
    if (prgnSrc)
    {
        PREGION prgnDest = REGION_LockRgn(hrgnDest);
        if (prgnDest)
        {
            ret = IntGdiCombineRgn(prgnDest, prgnSrc, 0, RGN_COPY) == ERROR ? -1 : 1;
            if ((ret == 1) && (iCode == SYSRGN))
            {
                ret = REGION_bOffsetRgn(prgnDest, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y);
            }
            REGION_UnlockRgn(prgnDest);
        }
        else
            ret = -1;
    }
 
    DC_UnlockDc(pdc);
 
    return ret;
}

NtGdiGetRasterizerCaps()

W32KAPI BOOL WINAPI NtGdiGetRasterizerCaps	(	RASTERIZER_STATUS *	status,
		UINT	size
	)

NtGdiGetRealizationInfo()

W32KAPI BOOL WINAPI NtGdiGetRealizationInfo	(	HDC	hdc,
		struct font_realization_info *	info
	)

Referenced by GdiRealizationInfo().

NtGdiGetRegionData()

W32KAPI DWORD WINAPI NtGdiGetRegionData	(	HRGN	hrgn,
		DWORD	count,
		RGNDATA *	data
	)

Referenced by GetRegionData(), and MirrorRgnByWidth().

NtGdiGetRgnBox()

W32KAPI INT WINAPI NtGdiGetRgnBox	(	HRGN	hrgn,
		RECT *	rect
	)

Referenced by emfdrv_stroke_and_fill_path(), and GetRgnBox().

NtGdiGetSpoolMessage()

W32KAPI DWORD WINAPI NtGdiGetSpoolMessage	(	void *	ptr1,
		DWORD	data2,
		void *	ptr3,
		DWORD	data4
	)

NtGdiGetSystemPaletteUse()

W32KAPI UINT WINAPI NtGdiGetSystemPaletteUse

(

HDC

hdc

)

Definition at line 1207 of file palette.c.

{
    return SystemPaletteUse;
}

NtGdiGetTextCharsetInfo()

W32KAPI UINT WINAPI NtGdiGetTextCharsetInfo	(	HDC	hdc,
		FONTSIGNATURE *	fs,
		DWORD	flags
	)

NtGdiGetTextExtentExW()

W32KAPI BOOL WINAPI NtGdiGetTextExtentExW	(	HDC	hdc,
		const WCHAR *	str,
		INT	count,
		INT	max_ext,
		INT *	nfit,
		INT *	dxs,
		SIZE *	size,
		UINT	flags
	)

NtGdiGetTextFaceW()

W32KAPI INT WINAPI NtGdiGetTextFaceW	(	HDC	hdc,
		INT	count,
		WCHAR *	name,
		BOOL	alias_name
	)

NtGdiGetTextMetricsW()

W32KAPI BOOL WINAPI NtGdiGetTextMetricsW	(	HDC	hdc,
		TEXTMETRICW *	metrics,
		ULONG	flags
	)

Referenced by GetTextMetricsA(), and GetTextMetricsW().

NtGdiGetTransform()

W32KAPI BOOL WINAPI NtGdiGetTransform	(	HDC	hdc,
		DWORD	which,
		XFORM *	xform
	)

Referenced by EMFDC_MaskBlt(), EMFDC_PlgBlt(), EMFDRV_StretchBlt(), emfdrv_stretchblt(), GetOutlineTextMetricsW(), and GetWorldTransform().

NtGdiGradientFill()

W32KAPI BOOL WINAPI NtGdiGradientFill	(	HDC	hdc,
		TRIVERTEX *	vert_array,
		ULONG	nvert,
		void *	grad_array,
		ULONG	ngrad,
		ULONG	mode
	)

NtGdiHfontCreate()

W32KAPI HFONT WINAPI NtGdiHfontCreate	(	const void *	logfont,
		ULONG	unk2,
		ULONG	unk3,
		ULONG	unk4,
		void *	data
	)

NtGdiIcmBrushInfo()

W32KAPI BOOL WINAPI NtGdiIcmBrushInfo	(	HDC	hdc,
		HBRUSH	handle,
		BITMAPINFO *	info,
		void *	bits,
		ULONG *	bits_size,
		UINT *	usage,
		BOOL *	unk,
		UINT	mode
	)

NtGdiInitSpool()

W32KAPI DWORD WINAPI NtGdiInitSpool

(

void

)

Definition at line 1048 of file stubs.c.

{
    EngSetLastError(ERROR_NOT_SUPPORTED);
    return FALSE;
}

NtGdiIntersectClipRect()

W32KAPI INT WINAPI NtGdiIntersectClipRect	(	HDC	hdc,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

NtGdiInvertRgn()

W32KAPI BOOL WINAPI NtGdiInvertRgn	(	HDC	hdc,
		HRGN	hrgn
	)

NtGdiLineTo()

W32KAPI BOOL WINAPI NtGdiLineTo	(	HDC	hdc,
		INT	x,
		INT	y
	)

NtGdiMaskBlt()

W32KAPI BOOL WINAPI NtGdiMaskBlt	(	HDC	hdc,
		INT	x_dst,
		INT	y_dst,
		INT	width_dst,
		INT	height_dst,
		HDC	hdc_src,
		INT	x_src,
		INT	y_src,
		HBITMAP	mask,
		INT	x_mask,
		INT	y_mask,
		DWORD	rop,
		DWORD	bk_color
	)

NtGdiModifyWorldTransform()

W32KAPI BOOL WINAPI NtGdiModifyWorldTransform	(	HDC	hdc,
		const XFORM *	xform,
		DWORD	mode
	)

NtGdiMoveTo()

W32KAPI BOOL WINAPI NtGdiMoveTo	(	HDC	hdc,
		INT	x,
		INT	y,
		POINT *	pt
	)

Referenced by Do_LineTo().

NtGdiOffsetClipRgn()

W32KAPI INT WINAPI NtGdiOffsetClipRgn	(	HDC	hdc,
		INT	x,
		INT	y
	)

NtGdiOffsetRgn()

W32KAPI INT WINAPI NtGdiOffsetRgn	(	HRGN	hrgn,
		INT	x,
		INT	y
	)

NtGdiOpenDCW()

W32KAPI HDC WINAPI NtGdiOpenDCW	(	UNICODE_STRING *	device,
		const DEVMODEW *	devmode,
		UNICODE_STRING *	output,
		ULONG	type,
		BOOL	is_display,
		HANDLE	hspool,
		DRIVER_INFO_2W *	driver_info,
		void *	pdev
	)

NtGdiPatBlt()

W32KAPI BOOL WINAPI NtGdiPatBlt	(	HDC	hdc,
		INT	left,
		INT	top,
		INT	width,
		INT	height,
		DWORD	rop
	)

NtGdiPathToRegion()

W32KAPI HRGN WINAPI NtGdiPathToRegion

(

HDC

hdc

)

Definition at line 2861 of file path.c.

{
    PPATH pPath, pNewPath;
    HRGN  hrgnRval = 0;
    int Ret;
    PREGION Rgn;
    DC *pDc;
    PDC_ATTR pdcattr;
 
    TRACE("Enter %s\n", __FUNCTION__);
 
    pDc = DC_LockDc(hDC);
    if (!pDc)
    {
        ERR("Failed to lock DC %p\n", hDC);
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    pdcattr = pDc->pdcattr;
 
    pPath = PATH_LockPath(pDc->dclevel.hPath);
    if (!pPath)
    {
        ERR("Failed to lock DC path %p\n", pDc->dclevel.hPath);
        DC_UnlockDc(pDc);
        return NULL;
    }
 
    if (pPath->state != PATH_Closed)
    {
        // FIXME: Check that setlasterror is being called correctly
        ERR("Path is not closed!\n");
        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
    }
    else
    {
        /* Create the region and fill it with the path strokes */
        Rgn = REGION_AllocUserRgnWithHandle(1);
        if (!Rgn)
        {
            ERR("Failed to allocate a region\n");
            PATH_UnlockPath(pPath);
            DC_UnlockDc(pDc);
            return NULL;
        }
        hrgnRval = Rgn->BaseObject.hHmgr;
 
        pNewPath = PATH_FlattenPath(pPath);
        if (pNewPath == NULL)
        {
            ERR("Failed to flatten path %p\n", pDc->dclevel.hPath);
            REGION_Delete(Rgn);
            PATH_UnlockPath(pPath);
            DC_UnlockDc(pDc);
            return NULL;
        }
 
        Ret = PATH_PathToRegion(pNewPath, pdcattr->jFillMode, Rgn);
 
        PATH_UnlockPath(pNewPath);
        PATH_Delete(pNewPath->BaseObject.hHmgr);
 
        if (!Ret)
        {
            ERR("PATH_PathToRegion failed\n");
            REGION_Delete(Rgn);
            hrgnRval = NULL;
        }
        else
            REGION_UnlockRgn(Rgn);
    }
 
    PATH_UnlockPath(pPath);
    PATH_Delete(pDc->dclevel.hPath);
    pDc->dclevel.hPath = NULL;
    pDc->dclevel.flPath &= ~DCPATH_ACTIVE;
 
    DC_UnlockDc(pDc);
    return hrgnRval;
}

NtGdiPlgBlt()

W32KAPI BOOL WINAPI NtGdiPlgBlt	(	HDC	hdc,
		const POINT *	point,
		HDC	hdc_src,
		INT	x_src,
		INT	y_src,
		INT	width,
		INT	height,
		HBITMAP	mask,
		INT	x_mask,
		INT	y_mask,
		DWORD	bk_color
	)

NtGdiPolyDraw()

W32KAPI BOOL WINAPI NtGdiPolyDraw	(	HDC	hdc,
		const POINT *	points,
		const BYTE *	types,
		DWORD	count
	)

NtGdiPolyPolyDraw()

W32KAPI ULONG WINAPI NtGdiPolyPolyDraw	(	HDC	hdc,
		const POINT *	points,
		const ULONG *	counts,
		DWORD	count,
		UINT	function
	)

NtGdiPtInRegion()

W32KAPI BOOL WINAPI NtGdiPtInRegion	(	HRGN	hrgn,
		INT	x,
		INT	y
	)

NtGdiPtVisible()

W32KAPI BOOL WINAPI NtGdiPtVisible	(	HDC	hdc,
		INT	x,
		INT	y
	)

NtGdiRectangle()

W32KAPI BOOL WINAPI NtGdiRectangle	(	HDC	hdc,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

NtGdiRectInRegion()

W32KAPI BOOL WINAPI NtGdiRectInRegion	(	HRGN	hrgn,
		const RECT *	rect
	)

NtGdiRectVisible()

W32KAPI BOOL WINAPI NtGdiRectVisible	(	HDC	hdc,
		const RECT *	rect
	)

NtGdiRemoveFontMemResourceEx()

W32KAPI BOOL WINAPI NtGdiRemoveFontMemResourceEx

(

HANDLE

handle

)

NtGdiRemoveFontResourceW()

W32KAPI BOOL WINAPI NtGdiRemoveFontResourceW	(	const WCHAR *	str,
		ULONG	size,
		ULONG	files,
		DWORD	flags,
		DWORD	tid,
		void *	dv
	)

NtGdiResetDC()

W32KAPI BOOL WINAPI NtGdiResetDC	(	HDC	hdc,
		const DEVMODEW *	devmode,
		BOOL *	banding,
		DRIVER_INFO_2W *	driver_info,
		void *	dev
	)

NtGdiResizePalette()

W32KAPI BOOL WINAPI NtGdiResizePalette	(	HPALETTE	palette,
		UINT	count
	)

Definition at line 604 of file palette.c.

{
/*  PALOBJ *palPtr = (PALOBJ*)AccessUserObject(hPal);
  UINT cPrevEnt, prevVer;
  INT prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
  XLATEOBJ *XlateObj = NULL;
 
  if(!palPtr) return FALSE;
  cPrevEnt = palPtr->logpalette->palNumEntries;
  prevVer = palPtr->logpalette->palVersion;
  prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) + sizeof(int*) + sizeof(GDIOBJHDR);
  size += sizeof(int*) + sizeof(GDIOBJHDR);
  XlateObj = palPtr->logicalToSystem;
 
  if (!(palPtr = GDI_ReallocObject(size, hPal, palPtr))) return FALSE;
 
  if(XlateObj)
  {
    XLATEOBJ *NewXlateObj = (int*) HeapReAlloc(GetProcessHeap(), 0, XlateObj, cEntries * sizeof(int));
    if(NewXlateObj == NULL)
    {
      ERR("Can not resize logicalToSystem -- out of memory!\n");
      GDI_ReleaseObj( hPal );
      return FALSE;
    }
    palPtr->logicalToSystem = NewXlateObj;
  }
 
  if(cEntries > cPrevEnt)
  {
    if(XlateObj) memset(palPtr->logicalToSystem + cPrevEnt, 0, (cEntries - cPrevEnt)*sizeof(int));
    memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
    PALETTE_ValidateFlags((PALETTEENTRY*)((BYTE*)palPtr + prevsize), cEntries - cPrevEnt );
  }
  palPtr->logpalette->palNumEntries = cEntries;
  palPtr->logpalette->palVersion = prevVer;
//    GDI_ReleaseObj( hPal );
  return TRUE; */
 
  UNIMPLEMENTED;
  return FALSE;
}

NtGdiRestoreDC()

W32KAPI BOOL WINAPI NtGdiRestoreDC	(	HDC	hdc,
		INT	level
	)

Definition at line 213 of file dcstate.c.

{
    PDC pdc;
 
    DPRINT("NtGdiRestoreDC(%p, %d)\n", hdc, iSaveLevel);
 
    /* Lock the original DC */
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    ASSERT(pdc->dclevel.lSaveDepth > 0);
 
    /* Negative values are relative to the stack top */
    if (iSaveLevel < 0)
        iSaveLevel = pdc->dclevel.lSaveDepth + iSaveLevel;
 
    /* Check if we have a valid instance */
    if (iSaveLevel <= 0 || iSaveLevel >= pdc->dclevel.lSaveDepth)
    {
        DPRINT("Illegal save level, requested: %ld, current: %ld\n",
               iSaveLevel, pdc->dclevel.lSaveDepth);
        DC_UnlockDc(pdc);
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* Call the internal function */
    DC_vRestoreDC(pdc, iSaveLevel);
 
    DC_UnlockDc(pdc);
 
    DPRINT("Leave NtGdiRestoreDC\n");
    return TRUE;
}

NtGdiRoundRect()

W32KAPI BOOL WINAPI NtGdiRoundRect	(	HDC	hdc,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	ell_width,
		INT	ell_height
	)

NtGdiSaveDC()

W32KAPI INT WINAPI NtGdiSaveDC

(

HDC

hdc

)

Definition at line 257 of file dcstate.c.

{
    HDC hdcSave;
    PDC pdc, pdcSave;
    INT lSaveDepth;
 
    DPRINT("NtGdiSaveDC(%p)\n", hDC);
 
    /* Lock the original dc */
    pdc = DC_LockDc(hDC);
    if (pdc == NULL)
    {
        DPRINT("Could not lock DC\n");
        EngSetLastError(ERROR_INVALID_HANDLE);
        return 0;
    }
 
    /* Allocate a new dc */
    pdcSave = DC_AllocDcWithHandle(GDILoObjType_LO_DC_TYPE);
    if (pdcSave == NULL)
    {
        DPRINT("Could not allocate a new DC\n");
        DC_UnlockDc(pdc);
        return 0;
    }
    hdcSave = pdcSave->BaseObject.hHmgr;
 
    PDEVOBJ_vReference(pdc->ppdev);
    DC_vInitDc(pdcSave, DCTYPE_MEMORY, pdc->ppdev);
 
    /* Handle references here correctly */
      //pdcSrc->dclevel.pSurface = NULL;
      //pdcSrc->dclevel.pbrFill = NULL;
      //pdcSrc->dclevel.pbrLine = NULL;
      //pdcSrc->dclevel.ppal = NULL;
 
    /* Make it a kernel handle
       (FIXME: Windows handles this differently, see Wiki) */
    GDIOBJ_vSetObjectOwner(&pdcSave->BaseObject, GDI_OBJ_HMGR_PUBLIC);
 
    /* Copy the current state */
    DC_vCopyState(pdc, pdcSave, FALSE);
 
    /* Only memory DC's change their surface */
    if (pdc->dctype == DCTYPE_MEMORY)
        DC_vSelectSurface(pdcSave, pdc->dclevel.pSurface);
 
    /* Copy path */
    if (pdc->dclevel.hPath)
    {
       PATH_SavePath( pdcSave, pdc );
    }
    pdcSave->dclevel.flPath = pdc->dclevel.flPath | DCPATH_SAVESTATE;
 
    /* Set new dc as save dc */
    pdcSave->dclevel.hdcSave = pdc->dclevel.hdcSave;
    pdc->dclevel.hdcSave = hdcSave;
 
    /* Increase save depth, return old value */
    lSaveDepth = pdc->dclevel.lSaveDepth++;
 
    /* Cleanup and return */
    DC_UnlockDc(pdcSave);
    DC_UnlockDc(pdc);
 
    DPRINT("Leave NtGdiSaveDC: %ld, hdcSave = %p\n", lSaveDepth, hdcSave);
    return lSaveDepth;
}

NtGdiScaleViewportExtEx()

W32KAPI BOOL WINAPI NtGdiScaleViewportExtEx	(	HDC	hdc,
		INT	x_num,
		INT	x_denom,
		INT	y_num,
		INT	y_denom,
		SIZE *	size
	)

NtGdiScaleWindowExtEx()

W32KAPI BOOL WINAPI NtGdiScaleWindowExtEx	(	HDC	hdc,
		INT	x_num,
		INT	x_denom,
		INT	y_num,
		INT	y_denom,
		SIZE *	size
	)

NtGdiSelectBitmap()

W32KAPI HGDIOBJ WINAPI NtGdiSelectBitmap	(	HDC	hdc,
		HGDIOBJ	handle
	)

NtGdiSelectBrush()

W32KAPI HGDIOBJ WINAPI NtGdiSelectBrush	(	HDC	hdc,
		HGDIOBJ	handle
	)

NtGdiSelectClipPath()

W32KAPI BOOL WINAPI NtGdiSelectClipPath	(	HDC	hdc,
		INT	mode
	)

NtGdiSelectFont()

W32KAPI HGDIOBJ WINAPI NtGdiSelectFont	(	HDC	hdc,
		HGDIOBJ	handle
	)

NtGdiSelectPen()

W32KAPI HGDIOBJ WINAPI NtGdiSelectPen	(	HDC	hdc,
		HGDIOBJ	handle
	)

NtGdiSetBitmapBits()

W32KAPI LONG WINAPI NtGdiSetBitmapBits	(	HBITMAP	hbitmap,
		LONG	count,
		const void *	bits
	)

NtGdiSetBitmapDimension()

W32KAPI BOOL WINAPI NtGdiSetBitmapDimension	(	HBITMAP	hbitmap,
		INT	x,
		INT	y,
		SIZE *	prev_size
	)

NtGdiSetBoundsRect()

W32KAPI UINT WINAPI NtGdiSetBoundsRect	(	HDC	hdc,
		const RECT *	rect,
		UINT	flags
	)

NtGdiSetBrushOrg()

W32KAPI BOOL WINAPI NtGdiSetBrushOrg	(	HDC	hdc,
		INT	x,
		INT	y,
		POINT *	prev_org
	)

Referenced by SetBrushOrgEx().

NtGdiSetColorAdjustment()

W32KAPI BOOL WINAPI NtGdiSetColorAdjustment	(	HDC	hdc,
		const COLORADJUSTMENT *	ca
	)

NtGdiSetDeviceGammaRamp()

W32KAPI BOOL WINAPI NtGdiSetDeviceGammaRamp	(	HDC	hdc,
		void *	ptr
	)

NtGdiSetDIBitsToDeviceInternal()

W32KAPI INT WINAPI NtGdiSetDIBitsToDeviceInternal	(	HDC	hdc,
		INT	x_dst,
		INT	y_dst,
		DWORD	cx,
		DWORD	cy,
		INT	x_src,
		INT	y_src,
		UINT	startscan,
		UINT	lines,
		const void *	bits,
		const BITMAPINFO *	bmi,
		UINT	coloruse,
		UINT	max_bits,
		UINT	max_info,
		BOOL	xform_coords,
		HANDLE	xform
	)

NtGdiSetLayout()

W32KAPI DWORD WINAPI NtGdiSetLayout	(	HDC	hdc,
		LONG	wox,
		DWORD	layout
	)

NtGdiSetMagicColors()

W32KAPI BOOL WINAPI NtGdiSetMagicColors	(	HDC	hdc,
		DWORD	magic,
		ULONG	index
	)

NtGdiSetMetaRgn()

W32KAPI INT WINAPI NtGdiSetMetaRgn

(

HDC

hdc

)

Definition at line 723 of file cliprgn.c.

{
  INT Ret;
  PDC pDC = DC_LockDc(hDC);
 
  if (!pDC)
  {
     EngSetLastError(ERROR_INVALID_PARAMETER);
     return ERROR;
  }
  Ret = IntGdiSetMetaRgn(pDC);
 
  DC_UnlockDc(pDC);
  return Ret;
}

NtGdiSetMiterLimit()

W32KAPI BOOL WINAPI NtGdiSetMiterLimit	(	HDC	hdc,
		DWORD	limit,
		DWORD *	prev_limit
	)

NtGdiSetPixel()

W32KAPI COLORREF WINAPI NtGdiSetPixel	(	HDC	hdc,
		INT	x,
		INT	y,
		COLORREF	color
	)

NtGdiSetPixelFormat()

W32KAPI BOOL WINAPI NtGdiSetPixelFormat	(	HDC	hdc,
		INT	format
	)

NtGdiSetRectRgn()

W32KAPI BOOL WINAPI NtGdiSetRectRgn	(	HRGN	hrgn,
		INT	left,
		INT	top,
		INT	right,
		INT	bottom
	)

NtGdiSetSystemPaletteUse()

W32KAPI UINT WINAPI NtGdiSetSystemPaletteUse	(	HDC	hdc,
		UINT	use
	)

Definition at line 1180 of file palette.c.

{
    UINT old = SystemPaletteUse;
 
    /* Device doesn't support colour palettes */
    if (!(NtGdiGetDeviceCaps(hDC, RASTERCAPS) & RC_PALETTE)) {
        return SYSPAL_ERROR;
    }
 
    switch (Usage)
    {
        case SYSPAL_NOSTATIC:
        case SYSPAL_NOSTATIC256:
        case SYSPAL_STATIC:
                SystemPaletteUse = Usage;
                break;
 
        default:
                old=SYSPAL_ERROR;
                break;
    }
 
 return old;
}

NtGdiSetTextJustification()

W32KAPI BOOL WINAPI NtGdiSetTextJustification	(	HDC	hdc,
		INT	extra,
		INT	breaks
	)

NtGdiSetVirtualResolution()

W32KAPI BOOL WINAPI NtGdiSetVirtualResolution	(	HDC	hdc,
		DWORD	horz_res,
		DWORD	vert_res,
		DWORD	horz_size,
		DWORD	vert_size
	)

NtGdiStartDoc()

W32KAPI INT WINAPI NtGdiStartDoc	(	HDC	hdc,
		const DOCINFOW *	doc,
		BOOL *	banding,
		INT	job
	)

NtGdiStartPage()

W32KAPI INT WINAPI NtGdiStartPage

(

HDC

hdc

)

Definition at line 272 of file print.c.

{
  UNIMPLEMENTED;
  return 0;
}

NtGdiStretchBlt()

W32KAPI BOOL WINAPI NtGdiStretchBlt	(	HDC	hdc,
		INT	x_dst,
		INT	y_dst,
		INT	width_dst,
		INT	height_dst,
		HDC	hdc_src,
		INT	x_src,
		INT	y_src,
		INT	width_src,
		INT	height_src,
		DWORD	rop,
		COLORREF	bk_color
	)

NtGdiStretchDIBitsInternal()

W32KAPI INT WINAPI NtGdiStretchDIBitsInternal	(	HDC	hdc,
		INT	x_dst,
		INT	y_dst,
		INT	width_dst,
		INT	height_dst,
		INT	x_src,
		INT	y_src,
		INT	width_src,
		INT	height_src,
		const void *	bits,
		const BITMAPINFO *	bmi,
		UINT	coloruse,
		DWORD	rop,
		UINT	max_info,
		UINT	max_bits,
		HANDLE	xform
	)

NtGdiStrokeAndFillPath()

W32KAPI BOOL WINAPI NtGdiStrokeAndFillPath

(

HDC

hdc

)

Definition at line 2985 of file path.c.

{
    DC *pDc;
    PDC_ATTR pdcattr;
    PPATH pPath, pNewPath;
    BOOL bRet = FALSE;
 
    TRACE("Enter %s\n", __FUNCTION__);
 
    if (!(pDc = DC_LockDc(hDC)))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    pPath = PATH_LockPath(pDc->dclevel.hPath);
    if (!pPath)
    {
        DC_UnlockDc(pDc);
        return FALSE;
    }
 
    DC_vPrepareDCsForBlit(pDc, NULL, NULL, NULL);
 
    pdcattr = pDc->pdcattr;
 
    if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
        DC_vUpdateFillBrush(pDc);
 
    if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
        DC_vUpdateLineBrush(pDc);
 
    pNewPath = PATH_FlattenPath(pPath);
 
    if (pNewPath->state != PATH_Closed)
    {
        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
    }
    else if (pNewPath->numEntriesUsed)
    {
       bRet = PATH_FillPath(pDc, pNewPath);
       if (bRet) bRet = PATH_StrokePath(pDc, pNewPath);
    }
    else bRet = TRUE;
 
    PATH_UnlockPath(pNewPath);
    PATH_Delete(pNewPath->BaseObject.hHmgr);
 
    PATH_UnlockPath(pPath);
    PATH_Delete(pPath->BaseObject.hHmgr);
    pDc->dclevel.hPath = 0;
    pDc->dclevel.flPath &= ~DCPATH_ACTIVE;
 
    DC_vFinishBlit(pDc, NULL);
    DC_UnlockDc(pDc);
    return bRet;
}

NtGdiStrokePath()

W32KAPI BOOL WINAPI NtGdiStrokePath

(

HDC

hdc

)

Definition at line 3044 of file path.c.

{
    DC *pDc;
    PDC_ATTR pdcattr;
    PPATH pPath, pNewPath;
    BOOL bRet = FALSE;
 
    TRACE("Enter %s\n", __FUNCTION__);
 
    if (!(pDc = DC_LockDc(hDC)))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPath = PATH_LockPath(pDc->dclevel.hPath);
    if (!pPath)
    {
        DC_UnlockDc(pDc);
        return FALSE;
    }
 
    DC_vPrepareDCsForBlit(pDc, NULL, NULL, NULL);
 
    pdcattr = pDc->pdcattr;
 
    if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
        DC_vUpdateLineBrush(pDc);
 
    pNewPath = PATH_FlattenPath(pPath);
 
    if (pNewPath->state != PATH_Closed)
    {
        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
    }
    else bRet = PATH_StrokePath(pDc, pNewPath);
 
    PATH_UnlockPath(pNewPath);
    PATH_Delete(pNewPath->BaseObject.hHmgr);
 
    DC_vFinishBlit(pDc, NULL);
 
    PATH_UnlockPath(pPath);
    PATH_Delete(pPath->BaseObject.hHmgr);
    pDc->dclevel.hPath = 0;
    pDc->dclevel.flPath &= ~DCPATH_ACTIVE;
 
    DC_UnlockDc(pDc);
    return bRet;
}

NtGdiSwapBuffers()

W32KAPI BOOL WINAPI NtGdiSwapBuffers

(

HDC

hdc

)

NtGdiTransformPoints()

W32KAPI BOOL WINAPI NtGdiTransformPoints	(	HDC	hdc,
		const POINT *	points_in,
		POINT *	points_out,
		INT	count,
		UINT	mode
	)

NtGdiTransparentBlt()

W32KAPI BOOL WINAPI NtGdiTransparentBlt	(	HDC	hdc,
		int	x_dst,
		int	y_dst,
		int	width_dst,
		int	height_dst,
		HDC	hdc_src,
		int	x_src,
		int	y_src,
		int	width_src,
		int	height_src,
		UINT	color
	)

NtGdiUnrealizeObject()

W32KAPI BOOL WINAPI NtGdiUnrealizeObject

(

HGDIOBJ

obj

)

Definition at line 1251 of file palette.c.

{
   BOOL Ret = FALSE;
   PPALETTE palGDI;
 
   if ( !hgdiobj ||
        GDI_HANDLE_IS_STOCKOBJ(hgdiobj) ||
        !GDI_HANDLE_IS_TYPE(hgdiobj, GDI_OBJECT_TYPE_PALETTE) )
      return Ret;
 
   palGDI = PALETTE_ShareLockPalette(hgdiobj);
   if (!palGDI) return FALSE;
 
   // FIXME!!
   // Need to do something!!!
   // Zero out Current and Old Translated pointers?
   //
   Ret = TRUE;
   PALETTE_ShareUnlockPalette(palGDI);
   return Ret;
}

NtGdiUpdateColors()

W32KAPI BOOL WINAPI NtGdiUpdateColors

(

HDC

hdc

)

Definition at line 1214 of file palette.c.

{
   PWND Wnd;
   BOOL calledFromUser, ret;
   USER_REFERENCE_ENTRY Ref;
 
   calledFromUser = UserIsEntered();
 
   if (!calledFromUser){
      UserEnterExclusive();
   }
 
   Wnd = UserGetWindowObject(IntWindowFromDC(hDC));
   if (Wnd == NULL)
   {
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
 
      if (!calledFromUser){
         UserLeave();
      }
 
      return FALSE;
   }
 
   UserRefObjectCo(Wnd, &Ref);
   ret = co_UserRedrawWindow(Wnd, NULL, 0, RDW_INVALIDATE);
   UserDerefObjectCo(Wnd);
 
   if (!calledFromUser){
      UserLeave();
   }
 
   return ret;
}

NtGdiWidenPath()

W32KAPI BOOL WINAPI NtGdiWidenPath

(

HDC

hdc

)

Definition at line 3097 of file path.c.

{
    PPATH pPath;
    BOOL Ret = FALSE;
    PDC pdc = DC_LockDc(hDC);
    TRACE("NtGdiWidenPat Enter\n");
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPath = PATH_WidenPath(pdc);
    if (pPath)
    {
       TRACE("WindenPath New Path\n");
       PATH_Delete(pdc->dclevel.hPath);
       pdc->dclevel.hPath = pPath->BaseObject.hHmgr;
       Ret = TRUE;
    }
    DC_UnlockDc(pdc);
    TRACE("NtGdiWidenPat Ret %d\n",Ret);
    return Ret;
}