Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-08-12 06:06:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Major Win32k Header Cleanup: Add ntgdi.h based on latest Platform SDK Public header. It contains the official definitions for NtGdi APIs.

Browse source 
- Added ntgdityps.h for structures needed to use the header (which were sadly not publically shipped).
- Removed internal win32k header data from public headers and put it to internal win32k headers.
- Fixed ntuser.h STDCALL->WINAPI.
- Added ntgdihdl.h for shared GDI Handle information between gdi32/win32k
- Added ntusrtyp.h for some shared NtUser types.
- Added ntgdibad.h which contains all non-compatible NtGdi prototypes, along with a detailed comment for each, and information on how to fix it. I had a 20 000+ line patch fixing all these issues, but it contained many bugs and I scrapped it in place for this approach, which while dirtier at first, simplifies the number of changes needed so that others can work on it as well.
- Fixed some gdi32/win32k/user32 header issues.

svn path=/trunk/; revision=20367
This commit is contained in:
Alex Ionescu 2005-12-27 03:41:13 +00:00
parent 901929a787
commit 06c7dcc913
84 changed files with 6999 additions and 4057 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

343
reactos/include/win32k/bitmaps.h
View file

@ -1,343 +0,0 @@
#ifndef __WIN32K_BITMAPS_H
#define __WIN32K_BITMAPS_H
/* GDI logical bitmap object */
typedef struct _BITMAPOBJ
{
SURFOBJ SurfObj;
FLONG flHooks;
FLONG flFlags;
SIZE dimension; /* For SetBitmapDimension(), do NOT use
to get width/height of bitmap, use
bitmap.bmWidth/bitmap.bmHeight for
that */
#ifdef NTOS_MODE_USER
PVOID BitsLock;
#else
PFAST_MUTEX BitsLock; /* You need to hold this lock before you touch
the actual bits in the bitmap */
#endif
/* For device-independent bitmaps: */
DIBSECTION *dib;
HPALETTE hDIBPalette;
} BITMAPOBJ, *PBITMAPOBJ;
#define BITMAPOBJ_IS_APIBITMAP 0x1
/* Internal interface */
#define BITMAPOBJ_AllocBitmap() \
((HBITMAP) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BITMAP))
#define BITMAPOBJ_FreeBitmap(hBMObj) \
GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP)
/* NOTE: Use shared locks! */
#define BITMAPOBJ_LockBitmap(hBMObj) (PBITMAPOBJ)EngLockSurface((HSURF)hBMObj)
#define BITMAPOBJ_UnlockBitmap(pBMObj) EngUnlockSurface(&pBMObj->SurfObj)
BOOL INTERNAL_CALL BITMAP_Cleanup(PVOID ObjectBody);
BOOL INTERNAL_CALL BITMAPOBJ_InitBitsLock(BITMAPOBJ *pBMObj);
#define BITMAPOBJ_LockBitmapBits(pBMObj) ExEnterCriticalRegionAndAcquireFastMutexUnsafe((pBMObj)->BitsLock)
#define BITMAPOBJ_UnlockBitmapBits(pBMObj) ExReleaseFastMutexUnsafeAndLeaveCriticalRegion((pBMObj)->BitsLock)
void INTERNAL_CALL BITMAPOBJ_CleanupBitsLock(BITMAPOBJ *pBMObj);
INT FASTCALL BITMAPOBJ_GetWidthBytes (INT bmWidth, INT bpp);
HBITMAP FASTCALL BITMAPOBJ_CopyBitmap (HBITMAP hBitmap);
INT FASTCALL DIB_GetDIBWidthBytes (INT width, INT depth);
int STDCALL DIB_GetDIBImageBytes (INT width, INT height, INT depth);
INT FASTCALL DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse);
INT STDCALL BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer);
HBITMAP FASTCALL BitmapToSurf(PBITMAPOBJ BitmapObj, HDEV GDIDevice);
HBITMAP FASTCALL IntCreateCompatibleBitmap(PDC Dc, INT Width, INT Height);
/* User Entry Points */
BOOL
STDCALL
NtGdiAlphaBlend(
HDC hDCDest,
INT XOriginDest,
INT YOriginDest,
INT WidthDest,
INT HeightDest,
HDC hDCSrc,
INT XOriginSrc,
INT YOriginSrc,
INT WidthSrc,
INT HeightSrc,
BLENDFUNCTION BlendFunc);
BOOL
STDCALL
NtGdiBitBlt (
HDC hDCDest,
INT XDest,
INT YDest,
INT Width,
INT Height,
HDC hDCSrc,
INT XSrc,
INT YSrc,
DWORD ROP
);
HBITMAP
STDCALL
NtGdiCreateBitmap (
INT Width,
INT Height,
UINT Planes,
UINT BitsPerPel,
CONST VOID * Bits
);
HBITMAP
STDCALL
NtGdiCreateCompatibleBitmap (
HDC hDC,
INT Width,
INT Height
);
HBITMAP
STDCALL
NtGdiCreateBitmapIndirect (
CONST BITMAP * BM
);
HBITMAP
STDCALL
NtGdiCreateDIBitmap (
HDC hDC,
CONST BITMAPINFOHEADER * bmih,
DWORD Init,
CONST VOID * bInit,
CONST BITMAPINFO * bmi,
UINT Usage
);
HBITMAP
STDCALL
NtGdiCreateDIBSection (
HDC hDC,
CONST BITMAPINFO * bmi,
UINT Usage,
VOID * Bits,
HANDLE hSection,
DWORD dwOffset
);
HBITMAP
STDCALL
NtGdiCreateDiscardableBitmap (
HDC hDC,
INT Width,
INT Height
);
BOOL
STDCALL
NtGdiExtFloodFill (
HDC hDC,
INT XStart,
INT YStart,
COLORREF Color,
UINT FillType
);
BOOL
STDCALL
NtGdiFloodFill (
HDC hDC,
INT XStart,
INT YStart,
COLORREF Fill
);
LONG
STDCALL
NtGdiGetBitmapBits (
HBITMAP hBitmap,
LONG Buffer,
LPVOID Bits
);
BOOL
STDCALL
NtGdiGetBitmapDimensionEx (
HBITMAP hBitmap,
LPSIZE Dimension
);
UINT
STDCALL
NtGdiGetDIBColorTable (
HDC hDC,
UINT StartIndex,
UINT Entries,
RGBQUAD * Colors
);
INT
STDCALL
NtGdiGetDIBits (
HDC hDC,
HBITMAP hBitmap,
UINT StartScan,
UINT ScanLines,
LPVOID Bits,
LPBITMAPINFO bi,
UINT Usage
);
COLORREF
STDCALL
NtGdiGetPixel (
HDC hDC,
INT XPos,
INT YPos
);
BOOL
STDCALL
NtGdiGradientFill (
HDC hdc,
PTRIVERTEX pVertex,
ULONG uVertex,
PVOID pMesh,
ULONG uMesh,
ULONG ulMode
);
BOOL
STDCALL
NtGdiMaskBlt (
HDC hDCDest,
INT XDest,
INT YDest,
INT Width,
INT Height,
HDC hDCSrc,
INT XSrc,
INT YSrc,
HBITMAP hMaskBitmap,
INT xMask,
INT yMask,
DWORD ROP
);
BOOL
STDCALL
NtGdiPlgBlt (
HDC hDCDest,
CONST POINT * Point,
HDC hDCSrc,
INT XSrc,
INT YSrc,
INT Width,
INT Height,
HBITMAP hMaskBitmap,
INT xMask,
INT yMask
);
LONG
STDCALL
NtGdiSetBitmapBits (
HBITMAP hBitmap,
DWORD Bytes,
CONST VOID * Bits
);
BOOL
STDCALL
NtGdiSetBitmapDimensionEx (
HBITMAP hBitmap,
INT Width,
INT Height,
LPSIZE Size
);
UINT
STDCALL
NtGdiSetDIBColorTable (
HDC hDC,
UINT StartIndex,
UINT Entries,
CONST RGBQUAD * Colors
);
INT
STDCALL
NtGdiSetDIBits (
HDC hDC,
HBITMAP hBitmap,
UINT StartScan,
UINT ScanLines,
CONST VOID * Bits,
CONST BITMAPINFO * bmi,
UINT ColorUse
);
INT
STDCALL
NtGdiSetDIBitsToDevice (
HDC hDC,
INT XDest,
INT YDest,
DWORD Width,
DWORD Height,
INT XSrc,
INT YSrc,
UINT StartScan,
UINT ScanLines,
CONST VOID * Bits,
CONST BITMAPINFO * bmi,
UINT ColorUse
);
COLORREF
STDCALL
NtGdiSetPixel (
HDC hDC,
INT X,
INT Y,
COLORREF Color
);
BOOL
STDCALL
NtGdiSetPixelV (
HDC hDC,
INT X,
INT Y,
COLORREF Color
);
BOOL
STDCALL
NtGdiStretchBlt (
HDC hDCDest,
INT XOriginDest,
INT YOriginDest,
INT WidthDest,
INT HeightDest,
HDC hDCSrc,
INT XOriginSrc,
INT YOriginSrc,
INT WidthSrc,
INT HeightSrc,
DWORD ROP
);
INT
STDCALL
NtGdiStretchDIBits (
HDC hDC,
INT XDest,
INT YDest,
INT DestWidth,
INT DestHeight,
INT XSrc,
INT YSrc,
INT SrcWidth,
INT SrcHeight,
CONST VOID * Bits,
CONST BITMAPINFO * BitsInfo,
UINT Usage,
DWORD ROP
);
BOOL
STDCALL
NtGdiTransparentBlt(
HDC hdcDst,
INT xDst,
INT yDst,
INT cxDst,
INT cyDst,
HDC hdcSrc,
INT xSrc,
INT ySrc,
INT cxSrc,
INT cySrc,
COLORREF TransColor
);
#endif

23
reactos/include/win32k/caret.h
View file

@ -1,23 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: include/win32k/caret.h
* PURPOSE: GDI32/Win32k Caret interface
* PROGRAMMER:
*
*/
#ifndef WIN32K_CARET_H_INCLUDED
#define WIN32K_CARET_H_INCLUDED
typedef struct _THRDCARETINFO
{
HWND hWnd;
HBITMAP Bitmap;
POINT Pos;
SIZE Size;
BYTE Visible;
BYTE Showing;
} THRDCARETINFO, *PTHRDCARETINFO;
#endif /* WIN32K_FONT_H_INCLUDED */

81
reactos/include/win32k/cliprgn.h
View file

@ -1,81 +0,0 @@
#ifndef _WIN32K_CLIPRGN_H
#define _WIN32K_CLIPRGN_H
HRGN WINAPI SaveVisRgn(HDC hdc);
INT WINAPI SelectVisRgn(HDC hdc, HRGN hrgn);
int
STDCALL
NtGdiExcludeClipRect (
HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect
);
int
STDCALL
NtGdiExtSelectClipRgn (
HDC hDC,
HRGN hrgn,
int fnMode
);
int
STDCALL
NtGdiGetClipBox (
HDC hDC,
LPRECT rc
);
int
STDCALL
NtGdiGetMetaRgn (
HDC hDC,
HRGN hrgn
);
int
STDCALL
NtGdiIntersectClipRect (
HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect
);
int
STDCALL
NtGdiOffsetClipRgn (
HDC hDC,
int XOffset,
int YOffset
);
BOOL
STDCALL
NtGdiPtVisible (
HDC hDC,
int X,
int Y
);
BOOL
STDCALL
NtGdiRectVisible (
HDC hDC,
CONST PRECT rc
);
BOOL
STDCALL
NtGdiSelectClipPath (
HDC hDC,
int Mode
);
int
STDCALL
NtGdiSelectClipRgn (
HDC hDC,
HRGN hrgn
);
int
STDCALL
NtGdiSetMetaRgn (
HDC hDC
);
#endif

116
reactos/include/win32k/color.h
View file

@ -1,116 +0,0 @@
#ifndef __WIN32K_COLOR_H
#define __WIN32K_COLOR_H
#ifndef CLR_INVALID
#define CLR_INVALID 0xffffffff
#endif
#define PC_SYS_USED 0x80 /* palentry is used (both system and logical) */
#define PC_SYS_RESERVED 0x40 /* system palentry is not to be mapped to */
#define PC_SYS_MAPPED 0x10 /* logical palentry is a direct alias for system palentry */
BOOL
STDCALL
NtGdiAnimatePalette (
HPALETTE hpal,
UINT StartIndex,
UINT Entries,
CONST PPALETTEENTRY ppe
);
HPALETTE
STDCALL
NtGdiCreateHalftonePalette (
HDC hDC
);
HPALETTE
STDCALL
NtGdiCreatePalette (
CONST PLOGPALETTE lgpl
);
BOOL
STDCALL
NtGdiGetColorAdjustment (
HDC hDC,
LPCOLORADJUSTMENT ca
);
COLORREF
STDCALL
NtGdiGetNearestColor (
HDC hDC,
COLORREF Color
);
UINT
STDCALL
NtGdiGetNearestPaletteIndex (
HPALETTE hpal,
COLORREF Color
);
UINT
STDCALL
NtGdiGetPaletteEntries (
HPALETTE hpal,
UINT StartIndex,
UINT Entries,
LPPALETTEENTRY pe
);
UINT
STDCALL
NtGdiGetSystemPaletteEntries (
HDC hDC,
UINT StartIndex,
UINT Entries,
LPPALETTEENTRY pe
);
UINT
STDCALL
NtGdiGetSystemPaletteUse (
HDC hDC
);
UINT
STDCALL
NtGdiRealizePalette (
HDC hDC
);
BOOL
STDCALL
NtGdiResizePalette (
HPALETTE hpal,
UINT Entries
);
HPALETTE
STDCALL
NtGdiSelectPalette (
HDC hDC,
HPALETTE hpal,
BOOL ForceBackground
);
BOOL
STDCALL
NtGdiSetColorAdjustment (
HDC hDC,
CONST LPCOLORADJUSTMENT ca
);
UINT
STDCALL
NtGdiSetPaletteEntries (
HPALETTE hpal,
UINT Start,
UINT Entries,
CONST LPPALETTEENTRY pe
);
UINT
STDCALL
NtGdiSetSystemPaletteUse (
HDC hDC,
UINT Usage
);
BOOL
STDCALL
NtGdiUnrealizeObject (
HGDIOBJ hgdiobj
);
BOOL
STDCALL
NtGdiUpdateColors (
HDC hDC
);
#endif

151
reactos/include/win32k/coord.h
View file

@ -1,151 +0,0 @@
#ifndef __WIN32K_COORD_H
#define __WIN32K_COORD_H
BOOL
STDCALL
NtGdiCombineTransform (
LPXFORM XformResult,
CONST LPXFORM xform1,
CONST LPXFORM xform2
);
VOID
FASTCALL
IntDPtoLP ( PDC dc, LPPOINT Points, INT Count );
VOID
FASTCALL
CoordDPtoLP ( PDC Dc, LPPOINT Point );
BOOL
STDCALL
NtGdiDPtoLP (
HDC hDC,
LPPOINT Points,
int Count
);
int
FASTCALL
IntGetGraphicsMode ( PDC dc );
int
STDCALL
NtGdiGetGraphicsMode ( HDC hDC );
BOOL
STDCALL
NtGdiGetWorldTransform (
HDC hDC,
LPXFORM Xform
);
VOID
FASTCALL
CoordLPtoDP ( PDC Dc, LPPOINT Point );
VOID
FASTCALL
IntLPtoDP ( PDC dc, LPPOINT Points, INT Count );
BOOL
STDCALL
NtGdiLPtoDP (
HDC hDC,
LPPOINT Points,
int Count
);
BOOL
STDCALL
NtGdiModifyWorldTransform (
HDC hDC,
CONST LPXFORM Xform,
DWORD Mode
);
BOOL
STDCALL
NtGdiOffsetViewportOrgEx (
HDC hDC,
int XOffset,
int YOffset,
LPPOINT Point
);
BOOL
STDCALL
NtGdiOffsetWindowOrgEx (
HDC hDC,
int XOffset,
int YOffset,
LPPOINT Point
);
BOOL
STDCALL
NtGdiScaleViewportExtEx (
HDC hDC,
int Xnum,
int Xdenom,
int Ynum,
int Ydenom,
LPSIZE Size
);
BOOL
STDCALL
NtGdiScaleWindowExtEx (
HDC hDC,
int Xnum,
int Xdenom,
int Ynum,
int Ydenom,
LPSIZE Size
);
int
STDCALL
NtGdiSetGraphicsMode (
HDC hDC,
int Mode
);
int
STDCALL
NtGdiSetMapMode (
HDC hDC,
int MapMode
);
BOOL
STDCALL
NtGdiSetViewportExtEx (
HDC hDC,
int XExtent,
int YExtent,
LPSIZE Size
);
BOOL
STDCALL
NtGdiSetViewportOrgEx (
HDC hDC,
int X,
int Y,
LPPOINT Point
);
BOOL
STDCALL
NtGdiSetWindowExtEx (
HDC hDC,
int XExtent,
int YExtent,
LPSIZE Size
);
BOOL
STDCALL
NtGdiSetWindowOrgEx (
HDC hDC,
int X,
int Y,
LPPOINT Point
);
BOOL
STDCALL
NtGdiSetWorldTransform (
HDC hDC,
CONST LPXFORM Xform
);
#endif

95
reactos/include/win32k/cursoricon.h
View file

@ -1,95 +0,0 @@
#ifndef __WIN32K_CURSORICON_H
#define __WIN32K_CURSORICON_H
#include <pshpack1.h>
/* Structures for reading icon/cursor files and resources */
// Structures for reading icon files and resources
typedef struct _ICONIMAGE
{
BITMAPINFOHEADER icHeader; // DIB header
RGBQUAD icColors[1]; // Color table
BYTE icXOR[1]; // DIB bits for XOR mask
BYTE icAND[1]; // DIB bits for AND mask
} ICONIMAGE, *LPICONIMAGE;
typedef struct _CURSORIMAGE
{
BITMAPINFOHEADER icHeader; // DIB header
RGBQUAD icColors[1]; // Color table
BYTE icXOR[1]; // DIB bits for XOR mask
BYTE icAND[1]; // DIB bits for AND mask
} CURSORIMAGE, *LPCURSORIMAGE;
typedef struct
{
BYTE bWidth;
BYTE bHeight;
BYTE bColorCount;
BYTE bReserved;
} ICONRESDIR;
typedef struct
{
WORD wWidth;
WORD wHeight;
} CURSORRESDIR;
typedef struct
{
WORD wPlanes; // Number of Color Planes in the XOR image
WORD wBitCount; // Bits per pixel in the XOR image
} ICONDIR;
typedef struct
{
WORD wXHotspot; // Number of Color Planes in the XOR image
WORD wYHotspot; // Bits per pixel in the XOR image
} CURSORDIR;
typedef struct
{
BYTE bWidth; // Width, in pixels, of the icon image
BYTE bHeight; // Height, in pixels, of the icon image
BYTE bColorCount; // Number of colors in image (0 if >=8bpp)
BYTE bReserved; // Reserved ( must be 0)
union
{ ICONDIR icon;
CURSORDIR cursor;
} Info;
DWORD dwBytesInRes; // How many bytes in this resource?
DWORD dwImageOffset; // Where in the file is this image?
} CURSORICONDIRENTRY;
typedef struct
{
WORD idReserved; // Reserved (must be 0)
WORD idType; // Resource Type (1 for icons, 0 for cursors)
WORD idCount; // How many images?
CURSORICONDIRENTRY idEntries[1]; // An entry for idCount number of images
} CURSORICONDIR;
typedef struct
{
union
{ ICONRESDIR icon;
CURSORRESDIR cursor;
} ResInfo;
WORD wPlanes; // Color Planes
WORD wBitCount; // Bits per pixel
DWORD dwBytesInRes; // how many bytes in this resource?
WORD nID; // the ID
} GRPCURSORICONDIRENTRY;
typedef struct
{
WORD idReserved; // Reserved (must be 0)
WORD idType; // Resource type (1 for icons)
WORD idCount; // How many images?
GRPCURSORICONDIRENTRY idEntries[1]; // The entries for each image
} GRPCURSORICONDIR;
#include <poppack.h>
#endif

68
reactos/include/win32k/fillshap.h
View file

@ -1,68 +0,0 @@
#ifndef __WIN32K_FILLSHAP_H
#define __WIN32K_FILLSHAP_H
BOOL
STDCALL
NtGdiChord(HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect,
int XRadial1,
int YRadial1,
int XRadial2,
int YRadial2);
BOOL
STDCALL
NtGdiEllipse(HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect);
BOOL
STDCALL
NtGdiPie(HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect,
int XRadial1,
int YRadial1,
int XRadial2,
int YRadial2);
BOOL
STDCALL
NtGdiPolygon(HDC hDC,
CONST PPOINT Points,
int Count);
BOOL
STDCALL
NtGdiPolyPolygon(HDC hDC,
CONST LPPOINT Points,
CONST LPINT PolyCounts,
int Count);
BOOL
STDCALL
NtGdiRectangle(HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect);
BOOL
STDCALL
NtGdiRoundRect(HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect,
int Width,
int Height);
#endif

25
reactos/include/win32k/font.h
View file

@ -1,25 +0,0 @@
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: include/win32k/font.h
* PURPOSE: GDI32/Win32k font interface
* PROGRAMMER:
*
*/
#ifndef WIN32K_FONT_H_INCLUDED
#define WIN32K_FONT_H_INCLUDED
typedef struct tagFONTFAMILYINFO
{
ENUMLOGFONTEXW EnumLogFontEx;
NEWTEXTMETRICEXW NewTextMetricEx;
DWORD FontType;
} FONTFAMILYINFO, *PFONTFAMILYINFO;
int STDCALL NtGdiGetFontFamilyInfo(HDC Dc, LPLOGFONTW LogFont, PFONTFAMILYINFO Info, DWORD Size);
BOOL STDCALL NtGdiTranslateCharsetInfo(PDWORD Src, LPCHARSETINFO CSI, DWORD Flags);
DWORD STDCALL NtGdiGetFontData(HDC,DWORD,DWORD,LPVOID,DWORD);
#endif /* WIN32K_FONT_H_INCLUDED */

81
reactos/include/win32k/icm.h
View file

@ -1,81 +0,0 @@
#ifndef __WIN32K_ICM_H
#define __WIN32K_ICM_H
BOOL
STDCALL
NtGdiCheckColorsInGamut(HDC hDC,
LPVOID RGBTriples,
LPVOID Buffer,
UINT Count);
BOOL
STDCALL
NtGdiColorMatchToTarget(HDC hDC,
HDC hDCTarget,
DWORD Action);
HCOLORSPACE
STDCALL
NtGdiCreateColorSpace(LPLOGCOLORSPACEW LogColorSpace);
BOOL
STDCALL
NtGdiDeleteColorSpace(HCOLORSPACE hColorSpace);
INT
STDCALL
NtGdiEnumICMProfiles(HDC hDC,
LPWSTR lpstrBuffer,
UINT cch );
HCOLORSPACE
STDCALL
NtGdiGetColorSpace(HDC hDC);
BOOL
STDCALL
NtGdiGetDeviceGammaRamp(HDC hDC,
LPVOID Ramp);
BOOL
STDCALL
NtGdiGetICMProfile(HDC hDC,
LPDWORD NameSize,
LPWSTR Filename);
BOOL
STDCALL
NtGdiGetLogColorSpace(HCOLORSPACE hColorSpace,
LPLOGCOLORSPACEW Buffer,
DWORD Size);
HCOLORSPACE
STDCALL
NtGdiSetColorSpace(HDC hDC,
HCOLORSPACE hColorSpace);
BOOL
STDCALL
NtGdiSetDeviceGammaRamp(HDC hDC,
LPVOID Ramp);
INT
STDCALL
NtGdiSetICMMode(HDC hDC,
INT EnableICM);
BOOL
STDCALL
NtGdiSetICMProfile(HDC hDC,
LPWSTR Filename);
BOOL
STDCALL
NtGdiUpdateICMRegKey(DWORD Reserved,
LPWSTR CMID,
LPWSTR Filename,
UINT Command);
#endif

33
reactos/include/win32k/kapi.h
View file

@ -1,33 +0,0 @@
#ifndef _WIN32K_KAPI_H
#define _WIN32K_KAPI_H
#ifndef INTERNAL_CALL
#define INTERNAL_CALL STDCALL
#endif
#include <win32k/brush.h>
#include <win32k/callback.h>
#include <win32k/caret.h>
#include <win32k/cliprgn.h>
#include <win32k/color.h>
#include <win32k/cursoricon.h>
#include <win32k/path.h>
#include <win32k/driver.h>
#include <win32k/dc.h>
#include <win32k/coord.h>
#include <win32k/bitmaps.h>
#include <win32k/fillshap.h>
#include <win32k/font.h>
#include <win32k/icm.h>
#include <win32k/line.h>
#include <win32k/metafile.h>
#include <win32k/menu.h>
#include <win32k/misc.h>
#include <win32k/ntuser.h>
#include <win32k/paint.h>
#include <win32k/pen.h>
#include <win32k/print.h>
#include <win32k/region.h>
#include <win32k/text.h>
#include <win32k/wingl.h>
#endif /* ndef _WIN32K_KAPI_H */

101
reactos/include/win32k/line.h
View file

@ -1,101 +0,0 @@
#ifndef __WIN32K_LINE_H
#define __WIN32K_LINE_H
BOOL
STDCALL
NtGdiAngleArc(HDC hDC,
int X,
int Y,
DWORD Radius,
FLOAT StartAngle,
FLOAT SweepAngle);
BOOL
STDCALL
NtGdiArc(HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect,
int XStartArc,
int YStartArc,
int XEndArc,
int YEndArc);
BOOL
STDCALL
NtGdiArcTo(HDC hDC,
int LeftRect,
int TopRect,
int RightRect,
int BottomRect,
int XRadial1,
int YRadial1,
int XRadial2,
int YRadial2);
INT
FASTCALL
IntGetArcDirection ( PDC dc );
INT
STDCALL
NtGdiGetArcDirection ( HDC hDC );
BOOL
STDCALL
NtGdiLineTo(HDC hDC,
int XEnd,
int YEnd );
BOOL
STDCALL
NtGdiMoveToEx(HDC hDC,
int X,
int Y,
LPPOINT Point);
BOOL
STDCALL
NtGdiPolyBezier(HDC hDC,
CONST LPPOINT pt,
DWORD Count);
BOOL
STDCALL
NtGdiPolyBezierTo(HDC hDC,
CONST LPPOINT pt,
DWORD Count);
BOOL
STDCALL
NtGdiPolyDraw(HDC hDC,
CONST LPPOINT pt,
CONST LPBYTE Types,
int Count);
BOOL
STDCALL
NtGdiPolyline(HDC hDC,
CONST LPPOINT pt,
int Count);
BOOL
STDCALL
NtGdiPolylineTo(HDC hDC,
CONST LPPOINT pt,
DWORD Count);
BOOL
STDCALL
NtGdiPolyPolyline(HDC hDC,
CONST LPPOINT pt,
CONST LPDWORD PolyPoints,
DWORD Count);
int
STDCALL
NtGdiSetArcDirection(HDC hDC,
int ArcDirection);
#endif

168
reactos/include/win32k/math.h
View file

@ -1,168 +0,0 @@
/*
* math.h
*
* Mathematical functions.
*
* This file is part of the Mingw32 package.
*
* Contributors:
* Created by Colin Peters <colin@bird.fu.is.saga-u.ac.jp>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* $Revision: 1.4 $
* $Author$
* $Date$
*
*/
/* added modfl */
#ifndef _MATH_H_
#define _MATH_H_
#include_next <math.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* HUGE_VAL is returned by strtod when the value would overflow the
* representation of 'double'. There are other uses as well.
*
* __imp__HUGE is a pointer to the actual variable _HUGE in
* MSVCRT.DLL. If we used _HUGE directly we would get a pointer
* to a thunk function.
*
* NOTE: The CRTDLL version uses _HUGE_dll instead.
*/
#ifdef __MSVCRT__
extern double* __imp__HUGE;
#define HUGE_VAL (*__imp__HUGE)
#else
/* CRTDLL */
extern double* _HUGE_dll;
#define HUGE_VAL (*_HUGE_dll)
#endif
#define M_PI 22 / 7
#define M_PI_2 M_PI * 2
struct _exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
/*
* Types for the above _exception structure.
*/
#define _DOMAIN 1 /* domain error in argument */
#define _SING 2 /* singularity */
#define _OVERFLOW 3 /* range overflow */
#define _UNDERFLOW 4 /* range underflow */
#define _TLOSS 5 /* total loss of precision */
#define _PLOSS 6 /* partial loss of precision */
/*
* Exception types with non-ANSI names for compatibility.
*/
#ifndef __STRICT_ANSI__
#ifndef _NO_OLDNAMES
#define DOMAIN _DOMAIN
#define SING _SING
#define OVERFLOW _OVERFLOW
#define UNDERFLOW _UNDERFLOW
#define TLOSS _TLOSS
#define PLOSS _PLOSS
#endif /* Not _NO_OLDNAMES */
#endif /* Not __STRICT_ANSI__ */
double sin (double x);
double cos (double x);
double tan (double x);
double sinh (double x);
double cosh (double x);
double tanh (double x);
double asin (double x);
double acos (double x);
double atan (double x);
double atan2 (double y, double x);
double exp (double x);
double log (double x);
double log10 (double x);
double pow (double x, double y);
long double powl (long double x,long double y);
double sqrt (double x);
double ceil (double x);
double floor (double x);
double fabs (double x);
double ldexp (double x, int n);
double frexp (double x, int* exp);
double modf (double x, double* ip);
long double modfl (long double x,long double* ip);
double fmod (double x, double y);
#ifndef __STRICT_ANSI__
/* Complex number (for cabs) */
struct _complex
{
double x; /* Real part */
double y; /* Imaginary part */
};
double _cabs (struct _complex x);
double _hypot (double x, double y);
double _j0 (double x);
double _j1 (double x);
double _jn (int n, double x);
double _y0 (double x);
double _y1 (double x);
double _yn (int n, double x);
#ifndef _NO_OLDNAMES
/*
* Non-underscored versions of non-ANSI functions. These reside in
* liboldnames.a. Provided for extra portability.
*/
#if 0
/* GCC 3.4 warns that this is not equal to it's internal definition for cabs */
double cabs (struct _complex x);
#endif
double hypot (double x, double y);
double j0 (double x);
double j1 (double x);
double jn (int n, double x);
double y0 (double x);
double y1 (double x);
double yn (int n, double x);
#endif /* Not _NO_OLDNAMES */
#endif /* Not __STRICT_ANSI__ */
#ifdef __cplusplus
}
#endif
#endif /* Not _MATH_H_ */

250
reactos/include/win32k/menu.h
View file

@ -1,250 +0,0 @@
/* $Id$ */
#ifndef WIN32K_MENU_H_INCLUDED
#define WIN32K_MENU_H_INCLUDED
typedef struct tagROSMENUINFO {
/* ----------- MENUINFO ----------- */
DWORD cbSize;
DWORD fMask;
DWORD dwStyle;
UINT cyMax;
HBRUSH hbrBack;
DWORD dwContextHelpID;
ULONG_PTR dwMenuData;
/* ----------- Extra ----------- */
HMENU Self; /* Handle of this menu */
WORD Flags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
UINT FocusedItem; /* Currently focused item */
UINT MenuItemCount; /* Number of items in the menu */
HWND Wnd; /* Window containing the menu */
WORD Width; /* Width of the whole menu */
WORD Height; /* Height of the whole menu */
HWND WndOwner; /* window receiving the messages for ownerdraw */
BOOL TimeToHide; /* Request hiding when receiving a second click in the top-level menu item */
SIZE maxBmpSize; /* Maximum size of the bitmap items in MIIM_BITMAP state */
} ROSMENUINFO, *PROSMENUINFO;
/* (other FocusedItem values give the position of the focused item) */
#define NO_SELECTED_ITEM 0xffff
typedef struct tagROSMENUITEMINFO
{
/* ----------- MENUITEMINFOW ----------- */
UINT cbSize;
UINT fMask;
UINT fType;
UINT fState;
UINT wID;
HMENU hSubMenu;
HBITMAP hbmpChecked;
HBITMAP hbmpUnchecked;
DWORD dwItemData;
LPWSTR dwTypeData;
UINT cch;
HBITMAP hbmpItem;
/* ----------- Extra ----------- */
RECT Rect; /* Item area (relative to menu window) */
UINT XTab; /* X position of text after Tab */
} ROSMENUITEMINFO, *PROSMENUITEMINFO;
typedef struct _SETMENUITEMRECT
{
UINT uItem;
BOOL fByPosition;
RECT rcRect;
} SETMENUITEMRECT, *PSETMENUITEMRECT;
DWORD
STDCALL
NtUserBuildMenuItemList(
HMENU hMenu,
PVOID Buffer,
ULONG nBufSize,
DWORD Reserved);
DWORD
STDCALL
NtUserCheckMenuItem(
HMENU hmenu,
UINT uIDCheckItem,
UINT uCheck);
HMENU
STDCALL
NtUserCreateMenu(BOOL PopupMenu);
BOOL
STDCALL
NtUserDeleteMenu(
HMENU hMenu,
UINT uPosition,
UINT uFlags);
BOOL
STDCALL
NtUserDestroyMenu(
HMENU hMenu);
DWORD
STDCALL
NtUserDrawMenuBarTemp(
HWND hWnd,
HDC hDC,
PRECT hRect,
HMENU hMenu,
HFONT hFont);
UINT
STDCALL
NtUserEnableMenuItem(
HMENU hMenu,
UINT uIDEnableItem,
UINT uEnable);
DWORD
STDCALL
NtUserInsertMenuItem(
HMENU hMenu,
UINT uItem,
BOOL fByPosition,
LPCMENUITEMINFOW lpmii);
BOOL
STDCALL
NtUserEndMenu(VOID);
UINT STDCALL
NtUserGetMenuDefaultItem(
HMENU hMenu,
UINT fByPos,
UINT gmdiFlags);
BOOL
STDCALL
NtUserGetMenuBarInfo(
HWND hwnd,
LONG idObject,
LONG idItem,
PMENUBARINFO pmbi);
UINT
STDCALL
NtUserGetMenuIndex(
HMENU hMenu,
UINT wID);
BOOL
STDCALL
NtUserGetMenuItemRect(
HWND hWnd,
HMENU hMenu,
UINT uItem,
LPRECT lprcItem);
HMENU
STDCALL
NtUserGetSystemMenu(
HWND hWnd,
BOOL bRevert);
BOOL
STDCALL
NtUserHiliteMenuItem(
HWND hwnd,
HMENU hmenu,
UINT uItemHilite,
UINT uHilite);
BOOL
STDCALL
NtUserMenuInfo(
HMENU hmenu,
PROSMENUINFO lpmi,
BOOL fsog
);
int
STDCALL
NtUserMenuItemFromPoint(
HWND hWnd,
HMENU hMenu,
DWORD X,
DWORD Y);
BOOL
STDCALL
NtUserMenuItemInfo(
HMENU hMenu,
UINT uItem,
BOOL fByPosition,
PROSMENUITEMINFO lpmii,
BOOL fsog
);
BOOL
STDCALL
NtUserRemoveMenu(
HMENU hMenu,
UINT uPosition,
UINT uFlags);
BOOL
STDCALL
NtUserSetMenu(
HWND hWnd,
HMENU hMenu,
BOOL bRepaint);
BOOL
STDCALL
NtUserSetMenuContextHelpId(
HMENU hmenu,
DWORD dwContextHelpId);
BOOL
STDCALL
NtUserSetMenuDefaultItem(
HMENU hMenu,
UINT uItem,
UINT fByPos);
BOOL
STDCALL
NtUserSetMenuFlagRtoL(
HMENU hMenu);
BOOL
STDCALL
NtUserSetSystemMenu(
HWND hWnd,
HMENU hMenu);
DWORD
STDCALL
NtUserThunkedMenuInfo(
HMENU hMenu,
LPCMENUINFO lpcmi);
DWORD
STDCALL
NtUserThunkedMenuItemInfo(
HMENU hMenu,
UINT uItem,
BOOL fByPosition,
BOOL bInsert,
LPMENUITEMINFOW lpmii,
PUNICODE_STRING lpszCaption);
BOOL
STDCALL
NtUserTrackPopupMenuEx(
HMENU hmenu,
UINT fuFlags,
int x,
int y,
HWND hwnd,
LPTPMPARAMS lptpm);
#endif /* WIN32K_MENU_H_INCLUDED */

180
reactos/include/win32k/metafile.h
View file

@ -1,180 +0,0 @@
#ifndef __WIN32K_METAFILE_H
#define __WIN32K_METAFILE_H
HENHMETAFILE
STDCALL
NtGdiCloseEnhMetaFile (
HDC hDC
);
HMETAFILE
STDCALL
NtGdiCloseMetaFile (
HDC hDC
);
HENHMETAFILE
STDCALL
NtGdiCopyEnhMetaFile (
HENHMETAFILE Src,
LPCWSTR File
);
HMETAFILE
STDCALL
NtGdiCopyMetaFile (
HMETAFILE Src,
LPCWSTR File
);
HDC
STDCALL
NtGdiCreateEnhMetaFile (
HDC hDCRef,
LPCWSTR File,
CONST LPRECT Rect,
LPCWSTR Description
);
HDC
STDCALL
NtGdiCreateMetaFile (
LPCWSTR File
);
BOOL
STDCALL
NtGdiDeleteEnhMetaFile (
HENHMETAFILE emf
);
BOOL
STDCALL
NtGdiDeleteMetaFile (
HMETAFILE mf
);
BOOL
STDCALL
NtGdiEnumEnhMetaFile (
HDC hDC,
HENHMETAFILE emf,
ENHMFENUMPROC EnhMetaFunc,
LPVOID Data,
CONST LPRECT Rect
);
BOOL
STDCALL
NtGdiEnumMetaFile (
HDC hDC,
HMETAFILE mf,
MFENUMPROC MetaFunc,
LPARAM lParam
);
BOOL
STDCALL
NtGdiGdiComment (
HDC hDC,
UINT Size,
CONST LPBYTE Data
);
HENHMETAFILE
STDCALL
NtGdiGetEnhMetaFile (
LPCWSTR MetaFile
);
UINT
STDCALL
NtGdiGetEnhMetaFileBits (
HENHMETAFILE hemf,
UINT BufSize,
LPBYTE Buffer
);
UINT
STDCALL
NtGdiGetEnhMetaFileDescription (
HENHMETAFILE hemf,
UINT BufSize,
LPWSTR Description
);
UINT
STDCALL
NtGdiGetEnhMetaFileHeader (
HENHMETAFILE hemf,
UINT BufSize,
LPENHMETAHEADER emh
);
UINT
STDCALL
NtGdiGetEnhMetaFilePaletteEntries (
HENHMETAFILE hemf,
UINT Entries,
LPPALETTEENTRY pe
);
HMETAFILE
STDCALL
NtGdiGetMetaFile (
LPCWSTR MetaFile
);
UINT
STDCALL
NtGdiGetMetaFileBitsEx (
HMETAFILE hmf,
UINT Size,
LPVOID Data
);
UINT
STDCALL
NtGdiGetWinMetaFileBits (
HENHMETAFILE hemf,
UINT BufSize,
LPBYTE Buffer,
INT MapMode,
HDC Ref
);
BOOL
STDCALL
NtGdiPlayEnhMetaFile (
HDC hDC,
HENHMETAFILE hemf,
CONST PRECT Rect
);
BOOL
STDCALL
NtGdiPlayEnhMetaFileRecord (
HDC hDC,
LPHANDLETABLE Handletable,
CONST ENHMETARECORD * EnhMetaRecord,
UINT Handles
);
BOOL
STDCALL
NtGdiPlayMetaFile (
HDC hDC,
HMETAFILE hmf
);
BOOL
STDCALL
NtGdiPlayMetaFileRecord (
HDC hDC,
LPHANDLETABLE Handletable,
LPMETARECORD MetaRecord,
UINT Handles
);
HENHMETAFILE
STDCALL
NtGdiSetEnhMetaFileBits (
UINT BufSize,
CONST PBYTE Data
);
HMETAFILE
STDCALL
NtGdiSetMetaFileBitsEx (
UINT Size,
CONST PBYTE Data
);
#if 0
HENHMETAFILE
STDCALL
NtGdiSetWinMetaFileBits (
UINT BufSize,
CONST PBYTE Buffer,
HDC Ref,
CONST METAFILEPICT * mfp
);
#endif
#endif

325
reactos/include/win32k/ntddraw.h
View file

@ -1,325 +0,0 @@
#ifndef __WIN32K_NTDDRAW_H
#define __WIN32K_NTDDRAW_H
#ifdef __cplusplus
extern "C" {
#endif
BOOL STDCALL NtGdiD3dContextCreate(
HANDLE hDirectDrawLocal,
HANDLE hSurfColor,
HANDLE hSurfZ,
/* Is msdn wrong on D3DNTHAL_CONTEXTCREATEDATA ?? */
D3DNTHAL_CONTEXTCREATEDATA *pdcci
);
DWORD STDCALL NtGdiD3dContextDestroy(
LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData
);
DWORD STDCALL NtGdiD3dContextDestroyAll(VOID);
DWORD STDCALL NtGdiD3dDrawPrimitives2(
HANDLE hCmdBuf,
HANDLE hVBuf,
LPD3DNTHAL_DRAWPRIMITIVES2DATA pded,
FLATPTR *pfpVidMemCmd,
DWORD *pdwSizeCmd,
FLATPTR *pfpVidMemVtx,
DWORD *pdwSizeVtx
);
DWORD STDCALL NtGdiD3dValidateTextureStageState(
LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA pData
);
DWORD STDCALL NtGdiDdAddAttachedSurface(
HANDLE hSurface,
HANDLE hSurfaceAttached,
PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData
);
DWORD STDCALL NtGdiDdAlphaBlt(VOID);
BOOL STDCALL NtGdiDdAttachSurface(
HANDLE hSurfaceFrom,
HANDLE hSurfaceTo
);
DWORD STDCALL NtGdiDdBeginMoCompFrame(
HANDLE hMoComp,
PDD_BEGINMOCOMPFRAMEDATA puBeginFrameData
);
DWORD STDCALL NtGdiDdBlt(
HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData
);
DWORD STDCALL NtGdiDdCanCreateD3DBuffer(
HANDLE hDirectDraw,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
);
DWORD STDCALL NtGdiDdCanCreateSurface(
HANDLE hDirectDraw,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
);
DWORD STDCALL NtGdiDdColorControl(
HANDLE hSurface,
PDD_COLORCONTROLDATA puColorControlData
);
DWORD STDCALL NtGdiDdCreateD3DBuffer(
HANDLE hDirectDraw,
HANDLE *hSurface,
DDSURFACEDESC *puSurfaceDescription,
DD_SURFACE_GLOBAL *puSurfaceGlobalData,
DD_SURFACE_LOCAL *puSurfaceLocalData,
DD_SURFACE_MORE *puSurfaceMoreData,
PDD_CREATESURFACEDATA puCreateSurfaceData,
HANDLE *puhSurface
);
HANDLE STDCALL NtGdiDdCreateDirectDrawObject(
HDC hdc
);
HANDLE STDCALL NtGdiDdCreateMoComp(
HANDLE hDirectDraw,
PDD_CREATEMOCOMPDATA puCreateMoCompData
);
DWORD STDCALL NtGdiDdCreateSurface(
HANDLE hDirectDraw,
HANDLE *hSurface,
DDSURFACEDESC *puSurfaceDescription,
DD_SURFACE_GLOBAL *puSurfaceGlobalData,
DD_SURFACE_LOCAL *puSurfaceLocalData,
DD_SURFACE_MORE *puSurfaceMoreData,
PDD_CREATESURFACEDATA puCreateSurfaceData,
HANDLE *puhSurface
);
DWORD STDCALL NtGdiDdCreateSurfaceEx(
HANDLE hDirectDraw,
HANDLE hSurface,
DWORD dwSurfaceHandle
);
HANDLE STDCALL NtGdiDdCreateSurfaceObject(
HANDLE hDirectDrawLocal,
HANDLE hSurface,
PDD_SURFACE_LOCAL puSurfaceLocal,
PDD_SURFACE_MORE puSurfaceMore,
PDD_SURFACE_GLOBAL puSurfaceGlobal,
BOOL bComplete
);
BOOL STDCALL NtGdiDdDeleteDirectDrawObject(
HANDLE hDirectDrawLocal
);
BOOL STDCALL NtGdiDdDeleteSurfaceObject(
HANDLE hSurface
);
DWORD STDCALL NtGdiDdDestroyD3DBuffer(
HANDLE hSurface
);
DWORD STDCALL NtGdiDdDestroyMoComp(
HANDLE hMoComp,
PDD_DESTROYMOCOMPDATA puBeginFrameData
);
DWORD STDCALL NtGdiDdDestroySurface(
HANDLE hSurface,
BOOL bRealDestroy
);
DWORD STDCALL NtGdiDdEndMoCompFrame(
HANDLE hMoComp,
PDD_ENDMOCOMPFRAMEDATA puEndFrameData
);
DWORD STDCALL NtGdiDdFlip(
HANDLE hSurfaceCurrent,
HANDLE hSurfaceTarget,
HANDLE hSurfaceCurrentLeft,
HANDLE hSurfaceTargetLeft,
PDD_FLIPDATA puFlipData
);
DWORD STDCALL NtGdiDdFlipToGDISurface(
HANDLE hDirectDraw,
PDD_FLIPTOGDISURFACEDATA puFlipToGDISurfaceData
);
DWORD STDCALL NtGdiDdGetAvailDriverMemory(
HANDLE hDirectDraw,
PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
);
DWORD STDCALL NtGdiDdGetBltStatus(
HANDLE hSurface,
PDD_GETBLTSTATUSDATA puGetBltStatusData
);
HDC STDCALL NtGdiDdGetDC(
HANDLE hSurface,
PALETTEENTRY *puColorTable
);
DWORD STDCALL NtGdiDdGetDriverInfo(
HANDLE hDirectDraw,
PDD_GETDRIVERINFODATA puGetDriverInfoData
);
DWORD STDCALL NtGdiDdGetDriverState(
PDD_GETDRIVERSTATEDATA pdata
);
DWORD STDCALL NtGdiDdGetDxHandle(
HANDLE hDirectDraw,
HANDLE hSurface,
BOOL bRelease
);
DWORD STDCALL NtGdiDdGetFlipStatus(
HANDLE hSurface,
PDD_GETFLIPSTATUSDATA puGetFlipStatusData
);
DWORD STDCALL NtGdiDdGetInternalMoCompInfo(
HANDLE hDirectDraw,
PDD_GETINTERNALMOCOMPDATA puGetInternalData
);
DWORD STDCALL NtGdiDdGetMoCompBuffInfo(
HANDLE hDirectDraw,
PDD_GETMOCOMPCOMPBUFFDATA puGetBuffData
);
DWORD STDCALL NtGdiDdGetMoCompFormats(
HANDLE hDirectDraw,
PDD_GETMOCOMPFORMATSDATA puGetMoCompFormatsData
);
DWORD STDCALL NtGdiDdGetMoCompGuids(
HANDLE hDirectDraw,
PDD_GETMOCOMPGUIDSDATA puGetMoCompGuidsData
);
DWORD STDCALL NtGdiDdGetScanLine(
HANDLE hDirectDraw,
PDD_GETSCANLINEDATA puGetScanLineData
);
DWORD STDCALL NtGdiDdLock(
HANDLE hSurface,
PDD_LOCKDATA puLockData,
HDC hdcClip
);
DWORD STDCALL NtGdiDdLockD3D(
HANDLE hSurface,
PDD_LOCKDATA puLockData
);
BOOL STDCALL NtGdiDdQueryDirectDrawObject(
HANDLE hDirectDrawLocal,
DD_HALINFO *pHalInfo,
DWORD *pCallBackFlags,
LPD3DNTHAL_CALLBACKS puD3dCallbacks,
LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
LPDDSURFACEDESC puD3dTextureFormats,
DWORD *puNumHeaps,
VIDEOMEMORY *puvmList,
DWORD *puNumFourCC,
DWORD *puFourCC
);
DWORD STDCALL NtGdiDdQueryMoCompStatus(
HANDLE hMoComp,
PDD_QUERYMOCOMPSTATUSDATA puQueryMoCompStatusData
);
BOOL STDCALL NtGdiDdReenableDirectDrawObject(
HANDLE hDirectDrawLocal,
BOOL *pubNewMode
);
BOOL STDCALL NtGdiDdReleaseDC(
HANDLE hSurface
);
DWORD STDCALL NtGdiDdRenderMoComp(
HANDLE hMoComp,
PDD_RENDERMOCOMPDATA puRenderMoCompData
);
BOOL STDCALL NtGdiDdResetVisrgn(
HANDLE hSurface,
HWND hwnd
);
DWORD STDCALL NtGdiDdSetColorKey(
HANDLE hSurface,
PDD_SETCOLORKEYDATA puSetColorKeyData
);
DWORD STDCALL NtGdiDdSetExclusiveMode(
HANDLE hDirectDraw,
PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData
);
BOOL STDCALL NtGdiDdSetGammaRamp(
HANDLE hDirectDraw,
HDC hdc,
LPVOID lpGammaRamp
);
DWORD STDCALL NtGdiDdSetOverlayPosition(
HANDLE hSurfaceSource,
HANDLE hSurfaceDestination,
PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
);
VOID STDCALL NtGdiDdUnattachSurface(
HANDLE hSurface,
HANDLE hSurfaceAttached
);
DWORD STDCALL NtGdiDdUnlock(
HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData
);
DWORD STDCALL NtGdiDdUnlockD3D(
HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData
);
DWORD STDCALL NtGdiDdUpdateOverlay(
HANDLE hSurfaceDestination,
HANDLE hSurfaceSource,
PDD_UPDATEOVERLAYDATA puUpdateOverlayData
);
DWORD STDCALL NtGdiDdWaitForVerticalBlank(
HANDLE hDirectDraw,
PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData
);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif

1256
reactos/include/win32k/ntgdibad.h Normal file
View file

File diff suppressed because it is too large Load diff

86
reactos/include/win32k/ntgdihdl.h Normal file
View file

@ -0,0 +1,86 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Win32 Graphical Subsystem (WIN32K)
* FILE: include/win32k/ntgdihal.h
* PURPOSE: Win32 Shared GDI Handle/Object Types
* PROGRAMMER: Alex Ionescu (alex@relsoft.net)
*/
/* INCLUDES ******************************************************************/
#ifndef _NTGDIHDL_
#define _NTGDIHDL_
/* DEFINES *******************************************************************/
/* Base address where the handle table is mapped to */
#define GDI_HANDLE_TABLE_BASE_ADDRESS (0x400000)
/* GDI handle table can hold 0x4000 handles */
#define GDI_HANDLE_COUNT 0x4000
#define GDI_GLOBAL_PROCESS (0x0)
/* Handle Masks and shifts */
#define GDI_HANDLE_INDEX_MASK (GDI_HANDLE_COUNT - 1)
#define GDI_HANDLE_TYPE_MASK 0x007f0000
#define GDI_HANDLE_STOCK_MASK 0x00800000
#define GDI_HANDLE_REUSE_MASK 0xff000000
#define GDI_HANDLE_REUSECNT_SHIFT 24
/*! \defgroup GDI object types
*
* GDI object types
*
*/
/*@{*/
#define GDI_OBJECT_TYPE_DC 0x00010000
#define GDI_OBJECT_TYPE_REGION 0x00040000
#define GDI_OBJECT_TYPE_BITMAP 0x00050000
#define GDI_OBJECT_TYPE_PALETTE 0x00080000
#define GDI_OBJECT_TYPE_FONT 0x000a0000
#define GDI_OBJECT_TYPE_BRUSH 0x00100000
#define GDI_OBJECT_TYPE_EMF 0x00210000
#define GDI_OBJECT_TYPE_PEN 0x00300000
#define GDI_OBJECT_TYPE_EXTPEN 0x00500000
/* Following object types made up for ROS */
#define GDI_OBJECT_TYPE_METADC 0x00710000
#define GDI_OBJECT_TYPE_METAFILE 0x00720000
#define GDI_OBJECT_TYPE_ENHMETAFILE 0x00730000
#define GDI_OBJECT_TYPE_ENHMETADC 0x00740000
#define GDI_OBJECT_TYPE_MEMDC 0x00750000
#define GDI_OBJECT_TYPE_DCE 0x00770000
#define GDI_OBJECT_TYPE_DONTCARE 0x007f0000
/** Not really an object type. Forces GDI_FreeObj to be silent. */
#define GDI_OBJECT_TYPE_SILENT 0x80000000
/*@}*/
/* Handle macros */
#define GDI_HANDLE_CREATE(i, t) \
((HANDLE)(((i) & GDI_HANDLE_INDEX_MASK) | ((t) & GDI_HANDLE_TYPE_MASK)))
#define GDI_HANDLE_GET_INDEX(h) \
(((ULONG_PTR)(h)) & GDI_HANDLE_INDEX_MASK)
#define GDI_HANDLE_GET_TYPE(h) \
(((ULONG_PTR)(h)) & GDI_HANDLE_TYPE_MASK)
#define GDI_HANDLE_IS_TYPE(h, t) \
((t) == (((ULONG_PTR)(h)) & GDI_HANDLE_TYPE_MASK))
#define GDI_HANDLE_IS_STOCKOBJ(h) \
(0 != (((ULONG_PTR)(h)) & GDI_HANDLE_STOCK_MASK))
#define GDI_HANDLE_SET_STOCKOBJ(h) \
((h) = (HANDLE)(((ULONG_PTR)(h)) | GDI_HANDLE_STOCK_MASK))
/* TYPES *********************************************************************/
typedef struct _GDI_TABLE_ENTRY
{
PVOID KernelData; /* Points to the kernel mode structure */
HANDLE ProcessId; /* process id that created the object, 0 for stock objects */
LONG Type; /* the first 16 bit is the object type including the stock obj flag, the last 16 bits is just the object type */
PVOID UserData; /* Points to the user mode structure, usually NULL though */
} GDI_TABLE_ENTRY, *PGDI_TABLE_ENTRY;
#endif

90
reactos/include/win32k/ntgdityp.h Normal file
View file

@ -0,0 +1,90 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Win32 Graphical Subsystem (WIN32K)
* FILE: include/win32k/ntgdityp.h
* PURPOSE: Win32 Shared GDI Types for NtGdi*
* PROGRAMMER: Alex Ionescu (alex@relsoft.net)
*/
/* INCLUDES ******************************************************************/
#ifndef _NTGDITYP_
#define _NTGDITYP_
/* ENUMERATIONS **************************************************************/
typedef enum _ARCTYPE
{
GdiTypeArc,
GdiTypeArcTo,
GdiTypeChord,
GdiTypePie,
} ARCTYPE, *PARCTYPE;
typedef enum _PALFUNCTYPE
{
GdiPalAnimate,
GdiPalSetEntries,
GdiPalGetEntries,
GdiPalGetSystemEntries,
GdiPalSetColorTable,
GdiPalGetColorTable,
} PALFUNCTYPE, *PPALFUNCTYPE;
typedef enum _POLYFUNCTYPE
{
GdiPolyPolygon = 1,
GdiPolyPolyLine,
GdiPolyBezier,
GdiPolyLineTo,
GdiPolyBezierTo,
GdiPolyPolyRgn,
} POLYFUNCTYPE, *PPOLYFUNCTYPE;
typedef enum _GETDCDWORD
{
GdiGetRelAbs = 1,
GdiGetArcDirection = 4,
} GETDCDWORD, *PGETDCDWORD;
typedef enum _GETSETDCDWORD
{
GdiGetSetArcDirection = 9,
} GETSETDCDWORD, *PGETSETDCDWORD;
typedef enum _GETDCPOINT
{
GdiGetViewPortExt = 1,
GdiGetDCOrg = 7,
} GETDCPOINT, *PGETDCPOINT;
typedef enum _TRANSFORMTYPE
{
GdiDpToLp,
GdiLpToDp,
} TRANSFORMTYPE, *PTRANSFORMTYPE;
#define GdiWorldSpaceToPageSpace 0x203
/* FIXME: Unknown */
typedef DWORD FULLSCREENCONTROL;
typedef DWORD LFTYPE;
/* TYPES *********************************************************************/
typedef PVOID KERNEL_PVOID;
typedef DWORD UNIVERSAL_FONT_ID;
typedef UNIVERSAL_FONT_ID *PUNIVERSAL_FONT_ID;
typedef DWORD CHWIDTHINFO;
typedef CHWIDTHINFO *PCHWIDTHINFO;
typedef D3DNTHAL_CONTEXTCREATEDATA D3DNTHAL_CONTEXTCREATEI;
/* FIXME: Unknown; easy to guess, usually based on public types and converted */
typedef struct _WIDTHDATA WIDTHDATA, *PWIDTHDATA;
typedef struct _TMDIFF TMDIFF, *PTMDIFF;
typedef struct _TMW_INTERNAL TMW_INTERNAL, *PTMW_INTERNAL;
typedef struct _ENUMFONTDATAW ENUMFONTDATAW, *PENUMFONTDATAW;
typedef struct _DEVCAPS DEVCAPS, *PDEVCAPS;
typedef struct _REALIZATION_INFO REALIZATION_INFO, *PREALIZATION_INFO;
#endif

747
reactos/include/win32k/ntuser.h
View file

File diff suppressed because it is too large Load diff

167
reactos/include/win32k/ntusrtyp.h Normal file
View file

@ -0,0 +1,167 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Win32 Graphical Subsystem (WIN32K)
* FILE: include/win32k/ntusrtyp.h
* PURPOSE: Win32 Shared USER Types for NtUser*
* PROGRAMMER: Alex Ionescu (alex@relsoft.net)
*/
/* INCLUDES ******************************************************************/
#ifndef _NTUSRTYP_
#define _NTUSRTYP_
/* ENUMERATIONS **************************************************************/
/* TYPES *********************************************************************/
typedef struct _PATRECT
{
RECT r;
HBRUSH hBrush;
} PATRECT, * PPATRECT;
/* Structures for reading icon/cursor files and resources */
typedef struct _ICONIMAGE
{
BITMAPINFOHEADER icHeader; // DIB header
RGBQUAD icColors[1]; // Color table
BYTE icXOR[1]; // DIB bits for XOR mask
BYTE icAND[1]; // DIB bits for AND mask
} ICONIMAGE, *LPICONIMAGE;
typedef struct _CURSORIMAGE
{
BITMAPINFOHEADER icHeader; // DIB header
RGBQUAD icColors[1]; // Color table
BYTE icXOR[1]; // DIB bits for XOR mask
BYTE icAND[1]; // DIB bits for AND mask
} CURSORIMAGE, *LPCURSORIMAGE;
typedef struct
{
BYTE bWidth;
BYTE bHeight;
BYTE bColorCount;
BYTE bReserved;
} ICONRESDIR;
typedef struct
{
WORD wWidth;
WORD wHeight;
} CURSORRESDIR;
typedef struct
{
WORD wPlanes; // Number of Color Planes in the XOR image
WORD wBitCount; // Bits per pixel in the XOR image
} ICONDIR;
typedef struct
{
WORD wXHotspot; // Number of Color Planes in the XOR image
WORD wYHotspot; // Bits per pixel in the XOR image
} CURSORDIR;
typedef struct
{
BYTE bWidth; // Width, in pixels, of the icon image
BYTE bHeight; // Height, in pixels, of the icon image
BYTE bColorCount; // Number of colors in image (0 if >=8bpp)
BYTE bReserved; // Reserved ( must be 0)
union
{
ICONDIR icon;
CURSORDIR cursor;
} Info;
DWORD dwBytesInRes; // How many bytes in this resource?
DWORD dwImageOffset; // Where in the file is this image?
} CURSORICONDIRENTRY;
typedef struct
{
WORD idReserved; // Reserved (must be 0)
WORD idType; // Resource Type (1 for icons, 0 for cursors)
WORD idCount; // How many images?
CURSORICONDIRENTRY idEntries[1];// An entry for idCount number of images
} CURSORICONDIR;
typedef struct
{
union
{
ICONRESDIR icon;
CURSORRESDIR cursor;
} ResInfo;
WORD wPlanes; // Color Planes
WORD wBitCount; // Bits per pixel
DWORD dwBytesInRes; // how many bytes in this resource?
WORD nID; // the ID
} GRPCURSORICONDIRENTRY;
typedef struct
{
WORD idReserved; // Reserved (must be 0)
WORD idType; // Resource type (1 for icons)
WORD idCount; // How many images?
GRPCURSORICONDIRENTRY idEntries[1]; // The entries for each image
} GRPCURSORICONDIR;
typedef struct _THRDCARETINFO
{
HWND hWnd;
HBITMAP Bitmap;
POINT Pos;
SIZE Size;
BYTE Visible;
BYTE Showing;
} THRDCARETINFO, *PTHRDCARETINFO;
typedef struct tagROSMENUINFO
{
/* ----------- MENUINFO ----------- */
DWORD cbSize;
DWORD fMask;
DWORD dwStyle;
UINT cyMax;
HBRUSH hbrBack;
DWORD dwContextHelpID;
ULONG_PTR dwMenuData;
/* ----------- Extra ----------- */
HMENU Self; /* Handle of this menu */
WORD Flags; /* Menu flags (MF_POPUP, MF_SYSMENU) */
UINT FocusedItem; /* Currently focused item */
UINT MenuItemCount; /* Number of items in the menu */
HWND Wnd; /* Window containing the menu */
WORD Width; /* Width of the whole menu */
WORD Height; /* Height of the whole menu */
HWND WndOwner; /* window receiving the messages for ownerdraw */
BOOL TimeToHide; /* Request hiding when receiving a second click in the top-level menu item */
SIZE maxBmpSize; /* Maximum size of the bitmap items in MIIM_BITMAP state */
} ROSMENUINFO, *PROSMENUINFO;
/* (other FocusedItem values give the position of the focused item) */
#define NO_SELECTED_ITEM 0xffff
typedef struct tagROSMENUITEMINFO
{
/* ----------- MENUITEMINFOW ----------- */
UINT cbSize;
UINT fMask;
UINT fType;
UINT fState;
UINT wID;
HMENU hSubMenu;
HBITMAP hbmpChecked;
HBITMAP hbmpUnchecked;
DWORD dwItemData;
LPWSTR dwTypeData;
UINT cch;
HBITMAP hbmpItem;
/* ----------- Extra ----------- */
RECT Rect; /* Item area (relative to menu window) */
UINT XTab; /* X position of text after Tab */
} ROSMENUITEMINFO, *PROSMENUITEMINFO;
#endif

43
reactos/include/win32k/paint.h
View file

@ -1,43 +0,0 @@
#ifndef __WIN32K_PAINT_H
#define __WIN32K_PAINT_H
typedef struct _PATRECT {
RECT r;
HBRUSH hBrush;
} PATRECT, * PPATRECT;
BOOL STDCALL
NtGdiPatBlt(
HDC hDC,
INT XLeft,
INT YLeft,
INT Width,
INT Height,
DWORD ROP);
BOOL STDCALL
NtGdiPolyPatBlt(
HDC hDC,
DWORD dwRop,
PPATRECT pRects,
INT cRects,
ULONG Reserved);
BOOL STDCALL
NtGdiPatBlt(
HDC hDC,
INT XLeft,
INT YLeft,
INT Width,
INT Height,
DWORD ROP);
BOOL STDCALL NtGdiGdiFlush (VOID);
DWORD STDCALL NtGdiGdiGetBatchLimit (VOID);
DWORD STDCALL NtGdiGdiSetBatchLimit (DWORD Limit);
UINT STDCALL NtGdiGetBoundsRect (HDC hDC, LPRECT Bounds, UINT Flags);
COLORREF STDCALL NtGdiSetBkColor (HDC hDC, COLORREF Color);
UINT STDCALL NtGdiSetBoundsRect (HDC hDC, CONST PRECT Bounds, UINT Flags);
#endif

54
reactos/include/win32k/path.h
View file

@ -1,54 +0,0 @@
#ifndef __WIN32K_PATH_H
#define __WIN32K_PATH_H
typedef enum tagGdiPathState
{
PATH_Null,
PATH_Open,
PATH_Closed
} GdiPathState;
typedef struct tagGdiPath
{
GdiPathState state;
POINT *pPoints;
BYTE *pFlags;
int numEntriesUsed, numEntriesAllocated;
BOOL newStroke;
} GdiPath;
#define PATH_IsPathOpen(path) ((path).state==PATH_Open)
BOOL STDCALL NtGdiAbortPath(HDC hDC);
BOOL STDCALL NtGdiBeginPath(HDC hDC);
BOOL STDCALL NtGdiCloseFigure(HDC hDC);
BOOL STDCALL NtGdiEndPath(HDC hDC);
BOOL STDCALL NtGdiFillPath(HDC hDC);
BOOL STDCALL NtGdiFlattenPath(HDC hDC);
BOOL STDCALL NtGdiGetMiterLimit(HDC hDC,
PFLOAT Limit);
INT STDCALL NtGdiGetPath(HDC hDC,
LPPOINT Points,
LPBYTE Types,
INT nSize);
HRGN STDCALL NtGdiPathToRegion(HDC hDC);
BOOL STDCALL NtGdiSetMiterLimit(HDC hDC,
FLOAT NewLimit,
PFLOAT OldLimit);
BOOL STDCALL NtGdiStrokeAndFillPath(HDC hDC);
BOOL STDCALL NtGdiStrokePath(HDC hDC);
BOOL STDCALL NtGdiWidenPath(HDC hDC);
#endif

48
reactos/include/win32k/print.h
View file

@ -1,48 +0,0 @@
#ifndef __WIN32K_PRINT_H
#define __WIN32K_PRINT_H
INT
STDCALL
NtGdiAbortDoc(HDC hDC);
INT
STDCALL
NtGdiEndDoc(HDC hDC);
INT
STDCALL
NtGdiEndPage(HDC hDC);
INT
STDCALL
NtGdiEscape(HDC hDC,
INT Escape,
INT InSize,
LPCSTR InData,
LPVOID OutData);
INT
STDCALL
NtGdiExtEscape(HDC hDC,
INT Escape,
INT InSize,
LPCSTR InData,
INT OutSize,
LPSTR OutData);
INT
STDCALL
NtGdiSetAbortProc(HDC hDC,
ABORTPROC AbortProc);
INT
STDCALL
NtGdiStartDoc(HDC hDC,
CONST LPDOCINFOW di);
INT
STDCALL
NtGdiStartPage(HDC hDC);
#endif

151
reactos/include/win32k/region.h
View file

@ -1,151 +0,0 @@
#ifndef __WIN32K_REGION_H
#define __WIN32K_REGION_H
#include <win32k/gdiobj.h>
/* Internal region data. Can't use RGNDATA structure because buffer is allocated statically */
typedef struct _ROSRGNDATA {
RGNDATAHEADER rdh;
PRECT Buffer;
} ROSRGNDATA, *PROSRGNDATA, *LPROSRGNDATA;
#define RGNDATA_FreeRgn(hRgn) GDIOBJ_FreeObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION)
#define RGNDATA_LockRgn(hRgn) ((PROSRGNDATA)GDIOBJ_LockObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION))
#define RGNDATA_UnlockRgn(pRgn) GDIOBJ_UnlockObjByPtr(pRgn)
HRGN FASTCALL RGNDATA_AllocRgn(INT n);
BOOL INTERNAL_CALL RGNDATA_Cleanup(PVOID ObjectBody);
/* User entry points */
HRGN STDCALL
NtGdiUnionRectWithRgn(HRGN hDest, CONST PRECT Rect);
INT
STDCALL
NtGdiCombineRgn(HRGN hDest,
HRGN hSrc1,
HRGN hSrc2,
INT CombineMode);
HRGN
STDCALL
NtGdiCreateEllipticRgn(INT LeftRect,
INT TopRect,
INT RightRect,
INT BottomRect);
HRGN
STDCALL
NtGdiCreateEllipticRgnIndirect(CONST PRECT rc);
HRGN
STDCALL
NtGdiCreatePolygonRgn(CONST PPOINT pt,
INT Count,
INT PolyFillMode);
HRGN
STDCALL
NtGdiCreatePolyPolygonRgn(CONST PPOINT pt,
CONST PINT PolyCounts,
INT Count,
INT PolyFillMode);
HRGN
STDCALL
NtGdiCreateRectRgn(INT LeftRect,
INT TopRect,
INT RightRect,
INT BottomRect);
HRGN
STDCALL
NtGdiCreateRectRgnIndirect(CONST PRECT rc);
HRGN
STDCALL
NtGdiCreateRoundRectRgn(INT LeftRect,
INT TopRect,
INT RightRect,
INT BottomRect,
INT WidthEllipse,
INT HeightEllipse);
BOOL
STDCALL
NtGdiEqualRgn(HRGN hSrcRgn1,
HRGN hSrcRgn2);
HRGN
STDCALL
NtGdiExtCreateRegion(CONST XFORM *Xform,
DWORD Count,
CONST RGNDATA *RgnData);
BOOL
STDCALL
NtGdiFillRgn(HDC hDC,
HRGN hRgn,
HBRUSH hBrush);
BOOL
STDCALL
NtGdiFrameRgn(HDC hDC,
HRGN hRgn,
HBRUSH hBrush,
INT Width,
INT Height);
INT
STDCALL
NtGdiGetRgnBox(HRGN hRgn,
LPRECT Rect);
BOOL
STDCALL
NtGdiInvertRgn(HDC hDC,
HRGN hRgn);
INT
STDCALL
NtGdiOffsetRgn(HRGN hRgn,
INT XOffset,
INT YOffset);
BOOL
STDCALL
NtGdiPaintRgn(HDC hDC,
HRGN hRgn);
BOOL
STDCALL
NtGdiPtInRegion(HRGN hRgn,
INT X,
INT Y);
BOOL
STDCALL
NtGdiRectInRegion(HRGN hRgn,
CONST LPRECT rc);
INT
STDCALL
NtGdiSelectVisRgn(HDC hdc,
HRGN hrgn);
BOOL
STDCALL
NtGdiSetRectRgn(HRGN hRgn,
INT LeftRect,
INT TopRect,
INT RightRect,
INT BottomRect);
DWORD
STDCALL
NtGdiGetRegionData(HRGN hrgn,
DWORD count,
LPRGNDATA rgndata);
#endif

233
reactos/include/win32k/text.h
View file

@ -1,233 +0,0 @@
#ifndef __WIN32K_TEXT_H
#define __WIN32K_TEXT_H
/* GDI logical font object */
typedef struct
{
LOGFONTW logfont;
FONTOBJ *Font;
BOOLEAN Initialized; /* Don't reinitialize for each DC */
} TEXTOBJ, *PTEXTOBJ;
/* Internal interface */
#define TEXTOBJ_AllocText() \
((HFONT) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_FONT))
#define TEXTOBJ_FreeText(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT)
#define TEXTOBJ_LockText(hBMObj) ((PTEXTOBJ) GDIOBJ_LockObj ((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT))
#define TEXTOBJ_UnlockText(pBMObj) GDIOBJ_UnlockObjByPtr (pBMObj)
NTSTATUS FASTCALL TextIntRealizeFont(HFONT FontHandle);
NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont);
int
STDCALL
NtGdiAddFontResource(PUNICODE_STRING Filename,
DWORD fl);
HFONT
STDCALL
NtGdiCreateFont(int Height,
int Width,
int Escapement,
int Orientation,
int Weight,
DWORD Italic,
DWORD Underline,
DWORD StrikeOut,
DWORD CharSet,
DWORD OutputPrecision,
DWORD ClipPrecision,
DWORD Quality,
DWORD PitchAndFamily,
LPCWSTR Face);
HFONT
STDCALL
NtGdiCreateFontIndirect(CONST LPLOGFONTW lf);
BOOL
STDCALL
NtGdiCreateScalableFontResource(DWORD Hidden,
LPCWSTR FontRes,
LPCWSTR FontFile,
LPCWSTR CurrentPath);
int
STDCALL
NtGdiEnumFonts(HDC hDC,
LPCWSTR FaceName,
FONTENUMPROCW FontFunc,
LPARAM lParam);
BOOL
STDCALL
NtGdiExtTextOut(HDC hdc,
int X,
int Y,
UINT fuOptions,
CONST RECT *lprc,
LPCWSTR lpString,
UINT cbCount,
CONST INT *lpDx);
BOOL
STDCALL
NtGdiGetAspectRatioFilterEx(HDC hDC,
LPSIZE AspectRatio);
BOOL
STDCALL
NtGdiGetCharABCWidths(HDC hDC,
UINT FirstChar,
UINT LastChar,
LPABC abc);
BOOL
STDCALL
NtGdiGetCharABCWidthsFloat(HDC hDC,
UINT FirstChar,
UINT LastChar,
LPABCFLOAT abcF);
DWORD
STDCALL
NtGdiGetCharacterPlacement(HDC hDC,
LPCWSTR String,
int Count,
int MaxExtent,
LPGCP_RESULTSW Results,
DWORD Flags);
BOOL
STDCALL
NtGdiGetCharWidth32(HDC hDC,
UINT FirstChar,
UINT LastChar,
LPINT Buffer);
BOOL
STDCALL
NtGdiGetCharWidthFloat(HDC hDC,
UINT FirstChar,
UINT LastChar,
PFLOAT Buffer);
DWORD
STDCALL
NtGdiGetFontLanguageInfo(HDC hDC);
DWORD
STDCALL
NtGdiGetGlyphOutline(HDC hDC,
UINT Char,
UINT Format,
LPGLYPHMETRICS gm,
DWORD Bufsize,
LPVOID Buffer,
CONST LPMAT2 mat2);
DWORD
STDCALL
NtGdiGetKerningPairs(HDC hDC,
DWORD NumPairs,
LPKERNINGPAIR krnpair);
UINT
STDCALL
NtGdiGetOutlineTextMetrics(HDC hDC,
UINT Data,
LPOUTLINETEXTMETRICW otm);
BOOL
STDCALL
NtGdiGetRasterizerCaps(LPRASTERIZER_STATUS rs,
UINT Size);
UINT
STDCALL
NtGdiGetTextCharset(HDC hDC);
UINT
STDCALL
NtGdiGetTextCharsetInfo(HDC hDC,
LPFONTSIGNATURE Sig,
DWORD Flags);
BOOL
STDCALL
NtGdiGetTextExtentExPoint(HDC hDC,
LPCWSTR String,
int Count,
int MaxExtent,
LPINT Fit,
LPINT Dx,
LPSIZE Size);
BOOL
STDCALL
NtGdiGetTextExtentPoint(HDC hDC,
LPCWSTR String,
int Count,
LPSIZE Size);
BOOL
STDCALL
NtGdiGetTextExtentPoint32(HDC hDC,
LPCWSTR String,
int Count,
LPSIZE Size);
int
STDCALL
NtGdiGetTextFace(HDC hDC,
int Count,
LPWSTR FaceName);
BOOL
STDCALL
NtGdiGetTextMetrics(HDC hDC,
LPTEXTMETRICW tm);
BOOL
STDCALL
NtGdiPolyTextOut(HDC hDC,
CONST LPPOLYTEXTW txt,
int Count);
BOOL
STDCALL
NtGdiRemoveFontResource(LPCWSTR FileName);
DWORD
STDCALL
NtGdiSetMapperFlags(HDC hDC,
DWORD Flag);
UINT
STDCALL
NtGdiSetTextAlign(HDC hDC,
UINT Mode);
COLORREF
STDCALL
NtGdiSetTextColor(HDC hDC,
COLORREF Color);
BOOL
STDCALL
NtGdiSetTextJustification(HDC hDC,
int BreakExtra,
int BreakCount);
BOOL
STDCALL
NtGdiTextOut(HDC hDC,
int XStart,
int YStart,
LPCWSTR String,
int Count);
#endif

1
reactos/include/win32k/win32k.h
View file

@ -1 +0,0 @@
#include <win32k/kapi.h>

38
reactos/include/win32k/wingl.h
View file

@ -1,38 +0,0 @@
#ifndef __WIN32K_WINGL_H
#define __WIN32K_WINGL_H
INT
STDCALL
NtGdiChoosePixelFormat(HDC hDC,
CONST PPIXELFORMATDESCRIPTOR pfd);
INT
STDCALL
NtGdiDescribePixelFormat(HDC hDC,
INT PixelFormat,
UINT BufSize,
PPIXELFORMATDESCRIPTOR pfd);
UINT
STDCALL
NtGdiGetEnhMetaFilePixelFormat(HENHMETAFILE hEMF,
DWORD BufSize,
CONST PPIXELFORMATDESCRIPTOR pfd);
INT
STDCALL
NtGdiGetPixelFormat(HDC hDC);
BOOL
STDCALL
NtGdiSetPixelFormat(HDC hDC,
INT PixelFormat,
CONST PPIXELFORMATDESCRIPTOR pfd);
BOOL
STDCALL
NtGdiSwapBuffers(HDC hDC);
#endif

6
reactos/lib/gdi32/gdi32.def
View file

@ -26,7 +26,7 @@ BRUSHOBJ_hGetColorTransform@4
BRUSHOBJ_pvAllocRbrush@8
BRUSHOBJ_pvGetRbrush@4
BRUSHOBJ_ulGetBrushColor@4
BitBlt@36=NtGdiBitBlt@36
BitBlt@36
CancelDC@4
CheckColorsInGamut@16
ChoosePixelFormat@8
@ -88,7 +88,7 @@ CreateRectRgnIndirect@4=NtGdiCreateRectRgnIndirect@4
CreateRoundRectRgn@24=NtGdiCreateRoundRectRgn@24
CreateScalableFontResourceA@16
CreateScalableFontResourceW@16
CreateSolidBrush@4=NtGdiCreateSolidBrush@4
CreateSolidBrush@4
DPtoLP@12=NtGdiDPtoLP@12
DeleteColorSpace@4
DeleteDC@4=NtGdiDeleteDC@4
@ -393,7 +393,7 @@ GetGlyphIndicesA@20
GetGlyphIndicesW@20
GetGlyphOutline=GetGlyphOutlineA@28
GetGlyphOutlineA@28
GetGlyphOutlineW@28=NtGdiGetGlyphOutline@28
GetGlyphOutlineW@28
GetGlyphOutlineWow@28
GetGraphicsMode@4=NtGdiGetGraphicsMode@4
GetHFONT@4

106
reactos/lib/gdi32/include/gdi32p.h Normal file
View file

@ -0,0 +1,106 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS System Libraries
* FILE: lib/gdi32/include/gdi32p.h
* PURPOSE: User-Mode Win32 GDI Library Private Header
* PROGRAMMER: Alex Ionescu (alex@relsoft.net)
*/
/* DATA **********************************************************************/
extern PGDI_TABLE_ENTRY GdiHandleTable;
extern HANDLE hProcessHeap;
extern HANDLE CurrentProcessId;
typedef INT
(CALLBACK* EMFPLAYPROC)(
HDC hdc,
INT iFunction,
HANDLE hPageQuery
);
/* FUNCTIONS *****************************************************************/
PVOID
HEAP_alloc(DWORD len);
NTSTATUS
HEAP_strdupA2W(
LPWSTR* ppszW,
LPCSTR lpszA
);
VOID
HEAP_free(LPVOID memory);
BOOL
FASTCALL
TextMetricW2A(
TEXTMETRICA *tma,
TEXTMETRICW *tmw
);
BOOL
FASTCALL
NewTextMetricW2A(
NEWTEXTMETRICA *tma,
NEWTEXTMETRICW *tmw
);
BOOL
FASTCALL
NewTextMetricExW2A(
NEWTEXTMETRICEXA *tma,
NEWTEXTMETRICEXW *tmw
);
BOOL
GdiIsHandleValid(HGDIOBJ hGdiObj);
BOOL
GdiGetHandleUserData(
HGDIOBJ hGdiObj,
PVOID *UserData
);
BOOL
WINAPI
CalculateColorTableSize(
CONST BITMAPINFOHEADER *BitmapInfoHeader,
UINT *ColorSpec,
UINT *ColorTableSize
);
LPBITMAPINFO
WINAPI
ConvertBitmapInfo(
CONST BITMAPINFO *BitmapInfo,
UINT ColorSpec,
UINT *BitmapInfoSize,
BOOL FollowedByData
);
DEVMODEW *
NTAPI
GdiConvertToDevmodeW(DEVMODEA *dm);
VOID
NTAPI
LogFontA2W(
LPLOGFONTW pW,
CONST LOGFONTA *pA
);
VOID
NTAPI
LogFontW2A(
LPLOGFONTA pA,
CONST LOGFONTW *pW
);
/* FIXME: Put in some public header */
UINT
WINAPI
UserRealizePalette(HDC hDC);
/* EOF */

91
reactos/lib/gdi32/include/precomp.h
View file

@ -8,89 +8,26 @@
/* INCLUDES ******************************************************************/
/* SDK/DDK/NDK Headers. */
/* Definitions */
#define WIN32_NO_STATUS
#define NTOS_MODE_USER
#define __GDI32__
/* SDK/DDK/NDK Headers. */
#include <windows.h>
#include <ddraw.h>
#include <ddrawi.h>
#include <winddi.h>
#include <prntfont.h>
#include <ddrawgdi.h>
#include <ndk/ntndk.h>
#include <tchar.h>
#include <winddi.h>
#include <d3dnthal.h>
#include <prntfont.h>
/* Win32K External Headers */
#include <win32k/kapi.h>
/* Public Win32K Headers */
#include <win32k/ntgdityp.h>
#include <ntgdi.h>
#include <win32k/ntgdihdl.h>
/* directdraw syscall */
#include <win32k/ntddraw.h>
/* Private GDI32 Header */
#include "gdi32p.h"
/* Deprecated NTGDI calls which shouldn't exist */
#include <win32k/ntgdibad.h>
#define NtUserGetDCBrushColor(hbr) \
(COLORREF)NtUserCallTwoParam((DWORD)(hbr), OBJ_BRUSH, TWOPARAM_ROUTINE_GETDCCOLOR)
#define NtUserGetDCPenColor(hbr) \
(COLORREF)NtUserCallTwoParam((DWORD)(hbr), OBJ_PEN, TWOPARAM_ROUTINE_GETDCCOLOR)
#define NtUserSetDCBrushColor(hbr, crColor) \
(COLORREF)NtUserCallTwoParam((DWORD)(hbr), (DWORD)crColor, TWOPARAM_ROUTINE_SETDCBRUSHCOLOR)
#define NtUserSetDCPenColor(hbr, crColor) \
(COLORREF)NtUserCallTwoParam((DWORD)(hbr), (DWORD)crColor, TWOPARAM_ROUTINE_SETDCPENCOLOR)
typedef int (CALLBACK* EMFPLAYPROC)( HDC, INT, HANDLE );
typedef DWORD FULLSCREENCONTROL;
typedef DWORD UNIVERSAL_FONT_ID;
typedef UNIVERSAL_FONT_ID *PUNIVERSAL_FONT_ID;
typedef DWORD REALIZATION_INFO;
typedef REALIZATION_INFO *PREALIZATION_INFO;
typedef DWORD CHWIDTHINFO;
typedef CHWIDTHINFO *PCHWIDTHINFO;
/* == GLOBAL VARIABLES ====================================================== */
extern PGDI_TABLE_ENTRY GdiHandleTable;
extern HANDLE hProcessHeap;
extern HANDLE CurrentProcessId;
/* == HEAP ================================================================== */
PVOID HEAP_alloc ( DWORD len );
NTSTATUS HEAP_strdupA2W ( LPWSTR* ppszW, LPCSTR lpszA );
VOID HEAP_free ( LPVOID memory );
/* == FONT ================================================================== */
BOOL FASTCALL TextMetricW2A(TEXTMETRICA *tma, TEXTMETRICW *tmw);
BOOL FASTCALL NewTextMetricW2A(NEWTEXTMETRICA *tma, NEWTEXTMETRICW *tmw);
BOOL FASTCALL NewTextMetricExW2A(NEWTEXTMETRICEXA *tma, NEWTEXTMETRICEXW *tmw);
/* == GDI HANDLES =========================================================== */
BOOL GdiIsHandleValid(HGDIOBJ hGdiObj);
BOOL GdiGetHandleUserData(HGDIOBJ hGdiObj, PVOID *UserData);
/* == BITMAP UTILITY FUNCTIONS ============================================== */
BOOL STDCALL CalculateColorTableSize(CONST BITMAPINFOHEADER *BitmapInfoHeader, UINT *ColorSpec, UINT *ColorTableSize);
LPBITMAPINFO STDCALL ConvertBitmapInfo(CONST BITMAPINFO *BitmapInfo, UINT ColorSpec, UINT *BitmapInfoSize, BOOL FollowedByData);
/* == CONVERSION FUNCTIONS ================================================== */
DEVMODEW *
STDCALL
GdiConvertToDevmodeW(DEVMODEA *dm);
VOID
STDCALL
LogFontA2W(LPLOGFONTW pW, CONST LOGFONTA *pA);
VOID
STDCALL
LogFontW2A(LPLOGFONTA pA, CONST LOGFONTW *pW);
/* == Directx FUNCTIONS ================================================== */
BOOL
intDDCreateSurface ( LPDDRAWI_DDRAWSURFACE_LCL pSurface, BOOL bComplete);
/* EOF */

43
reactos/lib/gdi32/misc/gdientry.c
View file

@ -27,9 +27,16 @@
#include "precomp.h"
#include <ddraw.h>
#include <ddrawi.h>
#include <ddrawint.h>
#include <ddrawgdi.h>
static LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobalInternal;
static ULONG RemberDdQueryDisplaySettingsUniquenessID = 0;
BOOL
intDDCreateSurface ( LPDDRAWI_DDRAWSURFACE_LCL pSurface,
BOOL bComplete);
/*
* @implemented
@ -91,8 +98,42 @@ DdCreateDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
return TRUE;
}
/*
* @unimplemented
*/
BOOL
STDCALL
DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
LPDDHALINFO pHalInfo,
LPDDHAL_DDCALLBACKS pDDCallbacks,
LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks,
LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks,
LPD3DHAL_CALLBACKS pD3dCallbacks,
LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData,
LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks,
LPDDSURFACEDESC pD3dTextureFormats,
LPDWORD pdwFourCC,
LPVIDMEM pvmList)
{
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/*
* @unimplemented
*/
HBITMAP
STDCALL
DdCreateDIBSection(HDC hdc,
CONST BITMAPINFO *pbmi,
UINT iUsage,
VOID **ppvBits,
HANDLE hSectionApp,
DWORD dwOffset)
{
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/*
* @implemented

43
reactos/lib/gdi32/misc/stubs.c
View file

@ -3634,49 +3634,6 @@ XLATEOBJ_piVector(XLATEOBJ *XlateObj)
return 0;
}
/*
* @unimplemented
*/
BOOL STDCALL DdQueryDirectDrawObject(
LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
LPDDHALINFO pHalInfo,
LPDDHAL_DDCALLBACKS pDDCallbacks,
LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks,
LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks,
LPD3DHAL_CALLBACKS pD3dCallbacks,
LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData,
LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks,
LPDDSURFACEDESC pD3dTextureFormats,
LPDWORD pdwFourCC,
LPVIDMEM pvmList
)
{
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/*
* @unimplemented
*/
HBITMAP STDCALL DdCreateDIBSection(
HDC hdc,
CONST BITMAPINFO *pbmi,
UINT iUsage,
VOID **ppvBits,
HANDLE hSectionApp,
DWORD dwOffset
)
{
UNIMPLEMENTED;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
/*
* @unimplemented
*/

8
reactos/lib/gdi32/misc/stubsa.c
View file

@ -157,9 +157,9 @@ CreateColorSpaceA(
BOOL
STDCALL
GetICMProfileA(
HDC a0,
DWORD a1, /* MS says LPDWORD! */
LPSTR a2
HDC hdc,
LPDWORD pBufSize,
LPSTR pszFilename
)
{
UNIMPLEMENTED;
@ -258,7 +258,7 @@ BOOL
STDCALL
UpdateICMRegKeyA(
DWORD a0,
DWORD a1,
LPSTR a1,
LPSTR a2,
UINT a3
)

4
reactos/lib/gdi32/misc/stubsw.c
View file

@ -129,7 +129,7 @@ BOOL
STDCALL
GetICMProfileW(
HDC a0,
DWORD a1, /* MS says LPDWORD! */
LPDWORD a1,
LPWSTR a2
)
{
@ -228,7 +228,7 @@ BOOL
STDCALL
UpdateICMRegKeyW(
DWORD a0,
DWORD a1,
LPWSTR a1,
LPWSTR a2,
UINT a3
)

6
reactos/lib/gdi32/misc/wingl.c
View file

@ -187,8 +187,8 @@ UINT
STDCALL
GetEnhMetaFilePixelFormat(
HENHMETAFILE hemf,
DWORD cbBuffer,
CONST PIXELFORMATDESCRIPTOR *ppfd
UINT cbBuffer,
PIXELFORMATDESCRIPTOR *ppfd
)
{
ENHMETAHEADER pemh;
@ -199,7 +199,7 @@ GetEnhMetaFilePixelFormat(
{
if(pemh.cbPixelFormat)
{
memcpy((void*)ppfd, (const void *)pemh.offPixelFormat, cbBuffer );
memcpy((void*)ppfd, UlongToPtr(pemh.offPixelFormat), cbBuffer );
return(pemh.cbPixelFormat);
}
}

35
reactos/lib/gdi32/objects/bitmap.c
View file

@ -20,8 +20,7 @@ CreateDIBSection(
&ConvertedInfoSize, FALSE);
if (pConvertedInfo)
{
hBitmap = NtGdiCreateDIBSection(hDC, pConvertedInfo, Usage, Bits,
hSection, dwOffset);
hBitmap = NtGdiCreateDIBSection(hDC, hSection, dwOffset, pConvertedInfo, Usage, 0, 0, 0, Bits);
if (BitmapInfo != pConvertedInfo)
RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
}
@ -29,6 +28,34 @@ CreateDIBSection(
return hBitmap;
}
/*
* @implemented
*/
BOOL
STDCALL
BitBlt(HDC hdcDest, /* handle to destination DC */
int nXOriginDest, /* x-coord of destination upper-left corner */
int nYOriginDest, /* y-coord of destination upper-left corner */
int nWidthDest, /* width of destination rectangle */
int nHeightDest, /* height of destination rectangle */
HDC hdcSrc, /* handle to source DC */
int nXSrc, /* x-coordinate of source upper-left corner */
int nYSrc, /* y-coordinate of source upper-left corner */
DWORD dwRop) /* raster operation code */
{
return NtGdiBitBlt(hdcDest,
nXOriginDest,
nYOriginDest,
nWidthDest,
nHeightDest,
hdcSrc,
nXSrc,
nYSrc,
dwRop,
0,
0);
}
/*
* @implemented
*/
@ -51,9 +78,9 @@ StretchBlt(
{
return NtGdiStretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest,
nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc,
nWidthSrc, nHeightSrc, dwRop);
nWidthSrc, nHeightSrc, dwRop, 0);
}
return NtGdiBitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest,
nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, dwRop);
nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, dwRop, 0, 0);
}

17
reactos/lib/gdi32/objects/brush.c
View file

@ -39,7 +39,7 @@ CreateDIBPatternBrush(
if (pConvertedInfo)
{
hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec,
ConvertedInfoSize, lpPackedDIB);
ConvertedInfoSize, FALSE, FALSE, lpPackedDIB);
if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo)
RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
}
@ -69,7 +69,7 @@ CreateDIBPatternBrushPt(
if (pConvertedInfo)
{
hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec,
ConvertedInfoSize, lpPackedDIB);
ConvertedInfoSize, FALSE, FALSE, (PVOID)lpPackedDIB);
if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo)
RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
}
@ -77,6 +77,17 @@ CreateDIBPatternBrushPt(
return hBrush;
}
/*
* @implemented
*/
HBRUSH
STDCALL
CreateSolidBrush(IN COLORREF crColor)
{
/* Call Server-Side API */
return NtGdiCreateSolidBrush(crColor, NULL);
}
/*
* @implemented
*/
@ -105,7 +116,7 @@ CreateBrushIndirect(
break;
case BS_SOLID:
hBrush = NtGdiCreateSolidBrush(LogBrush->lbColor);
hBrush = NtGdiCreateSolidBrush(LogBrush->lbColor, 0);
break;
case BS_HATCHED:

10
reactos/lib/gdi32/objects/dc.c
View file

@ -348,7 +348,8 @@ ResetDCW(
CONST DEVMODEW *lpInitData
)
{
return NtGdiResetDC ( hdc, lpInitData );
NtGdiResetDC ( hdc, (PDEVMODEW)lpInitData, NULL, NULL, NULL);
return hdc;
}
@ -363,13 +364,12 @@ ResetDCA(
)
{
LPDEVMODEW InitDataW;
HDC hDc;
InitDataW = GdiConvertToDevmodeW((LPDEVMODEA)lpInitData);
hDc = NtGdiResetDC ( hdc, InitDataW );
NtGdiResetDC ( hdc, InitDataW, NULL, NULL, NULL);
HEAP_free(InitDataW);
return hDc;
return hdc;
}
@ -383,7 +383,7 @@ StartDocW(
CONST DOCINFOW *a1
)
{
return NtGdiStartDoc ( hdc, (DOCINFOW *)a1 );
return NtGdiStartDoc ( hdc, (DOCINFOW *)a1, NULL, 0);
}

21
reactos/lib/gdi32/objects/font.c
View file

@ -517,9 +517,28 @@ GetGlyphOutlineA(
CONST MAT2 *lpmat2
)
{
return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2 );
return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
}
/*
* @implemented
*/
DWORD
STDCALL
GetGlyphOutlineW(
HDC hdc,
UINT uChar,
UINT uFormat,
LPGLYPHMETRICS lpgm,
DWORD cbBuffer,
LPVOID lpvBuffer,
CONST MAT2 *lpmat2
)
{
return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
}
/*
* @implemented

4
reactos/lib/gdi32/objects/path.c
View file

@ -127,7 +127,7 @@ SetMiterLimit(
PFLOAT a2
)
{
return NtGdiSetMiterLimit ( hdc, a1, a2 );
return NtGdiSetMiterLimit ( hdc, a1, (PDWORD)a2 );
}
@ -180,7 +180,7 @@ GetMiterLimit(
PFLOAT a1
)
{
return NtGdiGetMiterLimit ( hdc, a1 );
return NtGdiGetMiterLimit ( hdc, (PDWORD)a1 );
}
/*

12
reactos/lib/user32/include/user32.h
View file

@ -26,13 +26,10 @@
/* CSRSS Headers */
#include <csrss/csrss.h>
/* External Win32K Headers */
/* Public Win32K Headers */
#include <win32k/ntusrtyp.h>
#include <win32k/ntuser.h>
#include <win32k/caret.h>
#include <win32k/callback.h>
#include <win32k/cursoricon.h>
#include <win32k/menu.h>
#include <win32k/paint.h>
/* WINE Headers */
#include <wine/debug.h>
@ -41,6 +38,7 @@
/* Internal User32 Headers */
#include "user32p.h"
/* FIXME: FILIP */
/* FIXME: Use ntgdi.h then cleanup... */
HGDIOBJ STDCALL NtGdiSelectObject(HDC hDC, HGDIOBJ hGDIObj);
DWORD STDCALL GdiGetCharDimensions(HDC, LPTEXTMETRICW, LONG *);
BOOL STDCALL NtGdiPatBlt(HDC hdcDst, INT x, INT y, INT cx, INT cy, DWORD rop4);
DWORD STDCALL GdiGetCharDimensions(HDC, LPTEXTMETRICW, DWORD *);

32
reactos/subsys/win32k/eng/objects.h
View file

@ -83,50 +83,50 @@ typedef struct _STRGDI {
STROBJ StrObj;
} STRGDI;
typedef BOOL STDCALL (*PFN_BitBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
typedef BOOL (STDCALL *PFN_BitBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
XLATEOBJ *, RECTL *, POINTL *, POINTL *,
BRUSHOBJ *, POINTL *, ROP4);
typedef BOOL STDCALL (*PFN_TransparentBlt)(SURFOBJ *, SURFOBJ *, CLIPOBJ *, XLATEOBJ *, RECTL *, RECTL *, ULONG, ULONG);
typedef BOOL (STDCALL *PFN_TransparentBlt)(SURFOBJ *, SURFOBJ *, CLIPOBJ *, XLATEOBJ *, RECTL *, RECTL *, ULONG, ULONG);
typedef BOOL STDCALL (*PFN_StretchBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
typedef BOOL (STDCALL *PFN_StretchBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
XLATEOBJ *, COLORADJUSTMENT *, POINTL *,
RECTL *, RECTL *, PPOINT, ULONG);
typedef BOOL STDCALL (*PFN_TextOut)(SURFOBJ *, STROBJ *, FONTOBJ *, CLIPOBJ *,
typedef BOOL (STDCALL *PFN_TextOut)(SURFOBJ *, STROBJ *, FONTOBJ *, CLIPOBJ *,
RECTL *, RECTL *, BRUSHOBJ *, BRUSHOBJ *,
POINTL *, MIX);
typedef BOOL STDCALL (*PFN_Paint)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *, POINTL *, MIX);
typedef BOOL (STDCALL *PFN_Paint)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *, POINTL *, MIX);
typedef BOOL STDCALL (*PFN_StrokePath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, XFORMOBJ *,
typedef BOOL (STDCALL *PFN_StrokePath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, XFORMOBJ *,
BRUSHOBJ *, POINTL *, LINEATTRS *, MIX);
typedef BOOL STDCALL (*PFN_FillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, BRUSHOBJ *,
typedef BOOL (STDCALL *PFN_FillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, BRUSHOBJ *,
POINTL *, MIX, ULONG);
typedef BOOL STDCALL (*PFN_StrokeAndFillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *,
typedef BOOL (STDCALL *PFN_StrokeAndFillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *,
XFORMOBJ *, BRUSHOBJ *, LINEATTRS *, BRUSHOBJ *,
POINTL *, MIX, ULONG);
typedef BOOL STDCALL (*PFN_LineTo)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *,
typedef BOOL (STDCALL *PFN_LineTo)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *,
LONG, LONG, LONG, LONG, RECTL *, MIX);
typedef BOOL STDCALL (*PFN_CopyBits)(SURFOBJ *, SURFOBJ *, CLIPOBJ *,
typedef BOOL (STDCALL *PFN_CopyBits)(SURFOBJ *, SURFOBJ *, CLIPOBJ *,
XLATEOBJ *, RECTL *, POINTL *);
typedef VOID STDCALL (*PFN_Synchronize)(DHPDEV, RECTL *);
typedef VOID (STDCALL *PFN_Synchronize)(DHPDEV, RECTL *);
typedef VOID STDCALL (*PFN_MovePointer)(SURFOBJ *, LONG, LONG, RECTL *);
typedef VOID (STDCALL *PFN_MovePointer)(SURFOBJ *, LONG, LONG, RECTL *);
typedef ULONG STDCALL (*PFN_SetPointerShape)(SURFOBJ *, SURFOBJ *, SURFOBJ *, XLATEOBJ *,
typedef ULONG (STDCALL *PFN_SetPointerShape)(SURFOBJ *, SURFOBJ *, SURFOBJ *, XLATEOBJ *,
LONG, LONG, LONG, LONG, RECTL *, FLONG);
typedef HBITMAP STDCALL (*PFN_CreateDeviceBitmap)(DHPDEV, SIZEL, ULONG);
typedef HBITMAP (STDCALL *PFN_CreateDeviceBitmap)(DHPDEV, SIZEL, ULONG);
typedef BOOL STDCALL (*PFN_SetPalette)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG);
typedef BOOL (STDCALL *PFN_SetPalette)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG);
typedef BOOL STDCALL (*PFN_GradientFill)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);
typedef BOOL (STDCALL *PFN_GradientFill)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);
typedef struct _WNDGDI {
WNDOBJ WndObj;

50
reactos/subsys/win32k/include/bitmaps.h Normal file
View file

@ -0,0 +1,50 @@
#ifndef __WIN32K_BITMAPS_H
#define __WIN32K_BITMAPS_H
/* GDI logical bitmap object */
typedef struct _BITMAPOBJ
{
SURFOBJ SurfObj;
FLONG flHooks;
FLONG flFlags;
SIZE dimension; /* For SetBitmapDimension(), do NOT use
to get width/height of bitmap, use
bitmap.bmWidth/bitmap.bmHeight for
that */
PFAST_MUTEX BitsLock; /* You need to hold this lock before you touch
the actual bits in the bitmap */
/* For device-independent bitmaps: */
DIBSECTION *dib;
HPALETTE hDIBPalette;
} BITMAPOBJ, *PBITMAPOBJ;
#define BITMAPOBJ_IS_APIBITMAP 0x1
/* Internal interface */
#define BITMAPOBJ_AllocBitmap() \
((HBITMAP) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BITMAP))
#define BITMAPOBJ_FreeBitmap(hBMObj) \
GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP)
/* NOTE: Use shared locks! */
#define BITMAPOBJ_LockBitmap(hBMObj) (PBITMAPOBJ)EngLockSurface((HSURF)hBMObj)
#define BITMAPOBJ_UnlockBitmap(pBMObj) EngUnlockSurface(&pBMObj->SurfObj)
BOOL INTERNAL_CALL BITMAP_Cleanup(PVOID ObjectBody);
BOOL INTERNAL_CALL BITMAPOBJ_InitBitsLock(BITMAPOBJ *pBMObj);
#define BITMAPOBJ_LockBitmapBits(pBMObj) ExAcquireFastMutex((pBMObj)->BitsLock)
#define BITMAPOBJ_UnlockBitmapBits(pBMObj) ExReleaseFastMutex((pBMObj)->BitsLock)
void INTERNAL_CALL BITMAPOBJ_CleanupBitsLock(BITMAPOBJ *pBMObj);
INT FASTCALL BITMAPOBJ_GetWidthBytes (INT bmWidth, INT bpp);
HBITMAP FASTCALL BITMAPOBJ_CopyBitmap (HBITMAP hBitmap);
INT FASTCALL DIB_GetDIBWidthBytes (INT width, INT depth);
int NTAPI DIB_GetDIBImageBytes (INT width, INT height, INT depth);
INT FASTCALL DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse);
INT NTAPI BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer);
HBITMAP FASTCALL BitmapToSurf(PBITMAPOBJ BitmapObj, HDEV GDIDevice);
#endif

189
reactos/include/win32k/brush.h → reactos/subsys/win32k/include/brush.h
View file

@ -1,112 +1,77 @@
#ifndef __WIN32K_BRUSH_H
#define __WIN32K_BRUSH_H
#include <win32k/gdiobj.h>
/* Internal interface */
#define NB_HATCH_STYLES 6
/*
* The layout of this structure is taken from "Windows Graphics Programming"
* book written by Feng Yuan.
*
* DON'T MODIFY THIS STRUCTURE UNLESS REALLY NEEDED AND EVEN THEN ASK ON
* A MAILING LIST FIRST.
*/
typedef struct
{
ULONG AttrFlags;
COLORREF lbColor;
} BRUSHATTR, *PBRUSHATTR;
typedef struct
{
ULONG ulStyle;
HBITMAP hbmPattern;
HANDLE hbmClient;
ULONG flAttrs;
ULONG ulBrushUnique;
BRUSHATTR *pBrushAttr;
BRUSHATTR BrushAttr;
POINT ptOrigin;
ULONG bCacheGrabbed;
COLORREF crBack;
COLORREF crFore;
ULONG ulPalTime;
ULONG ulSurfTime;
PVOID ulRealization;
ULONG Unknown4C[3];
POINT ptPenWidth;
ULONG ulPenStyle;
DWORD *pStyle;
ULONG dwStyleCount;
ULONG Unknown6C;
} GDIBRUSHOBJ, *PGDIBRUSHOBJ;
typedef struct
{
BRUSHOBJ BrushObject;
PGDIBRUSHOBJ GdiBrushObject;
XLATEOBJ *XlateObject;
} GDIBRUSHINST, *PGDIBRUSHINST;
/* GDI Brush Attributes */
#define GDIBRUSH_NEED_BK_CLR 0x0002 /* Background color is needed */
#define GDIBRUSH_DITHER_OK 0x0004 /* Allow color dithering */
#define GDIBRUSH_IS_SOLID 0x0010 /* Solid brush */
#define GDIBRUSH_IS_HATCH 0x0020 /* Hatch brush */
#define GDIBRUSH_IS_BITMAP 0x0040 /* DDB pattern brush */
#define GDIBRUSH_IS_DIB 0x0080 /* DIB pattern brush */
#define GDIBRUSH_IS_NULL 0x0100 /* Null/hollow brush */
#define GDIBRUSH_IS_GLOBAL 0x0200 /* Stock objects */
#define GDIBRUSH_IS_PEN 0x0400 /* Pen */
#define GDIBRUSH_IS_OLDSTYLEPEN 0x0800 /* Geometric pen */
#define GDIBRUSH_IS_MASKING 0x8000 /* Pattern bitmap is used as transparent mask (?) */
#define GDIBRUSH_CACHED_IS_SOLID 0x80000000
#define BRUSHOBJ_AllocBrush() ((HBRUSH) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BRUSH))
#define BRUSHOBJ_FreeBrush(hBrush) GDIOBJ_FreeObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)
#define BRUSHOBJ_LockBrush(hBrush) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH))
#define BRUSHOBJ_UnlockBrush(pBrush) GDIOBJ_UnlockObjByPtr(pBrush)
BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody);
HBRUSH STDCALL
NtGdiCreateBrushIndirect(
CONST LOGBRUSH *LogBrush);
HBRUSH STDCALL
NtGdiCreateDIBBrush(
CONST BITMAPINFO *BitmapInfoAndData,
UINT ColorSpec,
UINT BitmapInfoSize,
CONST VOID *PackedDIB);
HBRUSH STDCALL
NtGdiCreateHatchBrush(
INT Style,
COLORREF Color);
HBRUSH STDCALL
NtGdiCreatePatternBrush(
HBITMAP hBitmap);
HBRUSH STDCALL
NtGdiCreateSolidBrush(
COLORREF Color);
BOOL STDCALL
NtGdiFixBrushOrgEx(
VOID);
BOOL STDCALL
NtGdiSetBrushOrgEx(
HDC hDC,
INT XOrg,
INT YOrg,
LPPOINT Point);
#endif
#ifndef __WIN32K_BRUSH_H
#define __WIN32K_BRUSH_H
#include "gdiobj.h"
/* Internal interface */
#define NB_HATCH_STYLES 6
/*
* The layout of this structure is taken from "Windows Graphics Programming"
* book written by Feng Yuan.
*
* DON'T MODIFY THIS STRUCTURE UNLESS REALLY NEEDED AND EVEN THEN ASK ON
* A MAILING LIST FIRST.
*/
typedef struct
{
ULONG AttrFlags;
COLORREF lbColor;
} BRUSHATTR, *PBRUSHATTR;
typedef struct
{
ULONG ulStyle;
HBITMAP hbmPattern;
HANDLE hbmClient;
ULONG flAttrs;
ULONG ulBrushUnique;
BRUSHATTR *pBrushAttr;
BRUSHATTR BrushAttr;
POINT ptOrigin;
ULONG bCacheGrabbed;
COLORREF crBack;
COLORREF crFore;
ULONG ulPalTime;
ULONG ulSurfTime;
PVOID ulRealization;
ULONG Unknown4C[3];
POINT ptPenWidth;
ULONG ulPenStyle;
DWORD *pStyle;
ULONG dwStyleCount;
ULONG Unknown6C;
} GDIBRUSHOBJ, *PGDIBRUSHOBJ;
typedef struct
{
BRUSHOBJ BrushObject;
PGDIBRUSHOBJ GdiBrushObject;
XLATEOBJ *XlateObject;
} GDIBRUSHINST, *PGDIBRUSHINST;
/* GDI Brush Attributes */
#define GDIBRUSH_NEED_BK_CLR 0x0002 /* Background color is needed */
#define GDIBRUSH_DITHER_OK 0x0004 /* Allow color dithering */
#define GDIBRUSH_IS_SOLID 0x0010 /* Solid brush */
#define GDIBRUSH_IS_HATCH 0x0020 /* Hatch brush */
#define GDIBRUSH_IS_BITMAP 0x0040 /* DDB pattern brush */
#define GDIBRUSH_IS_DIB 0x0080 /* DIB pattern brush */
#define GDIBRUSH_IS_NULL 0x0100 /* Null/hollow brush */
#define GDIBRUSH_IS_GLOBAL 0x0200 /* Stock objects */
#define GDIBRUSH_IS_PEN 0x0400 /* Pen */
#define GDIBRUSH_IS_OLDSTYLEPEN 0x0800 /* Geometric pen */
#define GDIBRUSH_IS_MASKING 0x8000 /* Pattern bitmap is used as transparent mask (?) */
#define GDIBRUSH_CACHED_IS_SOLID 0x80000000
#define BRUSHOBJ_AllocBrush() ((HBRUSH) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BRUSH))
#define BRUSHOBJ_FreeBrush(hBrush) GDIOBJ_FreeObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)
#define BRUSHOBJ_LockBrush(hBrush) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH))
#define BRUSHOBJ_UnlockBrush(pBrush) GDIOBJ_UnlockObjByPtr(pBrush)
BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody);
#endif

8
reactos/subsys/win32k/include/color.h
View file

@ -1,6 +1,13 @@
#ifndef _WIN32K_COLOR_H
#define _WIN32K_COLOR_H
#ifndef CLR_INVALID
#define CLR_INVALID 0xffffffff
#endif
#define PC_SYS_USED 0x80 /* palentry is used (both system and logical) */
#define PC_SYS_RESERVED 0x40 /* system palentry is not to be mapped to */
#define PC_SYS_MAPPED 0x10 /* logical palentry is a direct alias for system palentry */
#define NB_RESERVED_COLORS 20 /* number of fixed colors in system palette */
const PALETTEENTRY* FASTCALL COLOR_GetSystemPaletteTemplate (VOID);
@ -8,4 +15,5 @@ COLORREF STDCALL COLOR_LookupNearestColor (PALETTEENTRY* palPalEntry, INT size,
INT STDCALL COLOR_PaletteLookupExactIndex (PALETTEENTRY* palPalEntry, INT size, COLORREF col);
INT STDCALL COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, INT size, XLATEOBJ *XlateObj, COLORREF col, BOOL skipReserved);
#endif /* _WIN32K_COLOR_H */

24
reactos/subsys/win32k/include/coord.h Normal file
View file

@ -0,0 +1,24 @@
#ifndef __WIN32K_COORD_H
#define __WIN32K_COORD_H
VOID
FASTCALL
IntDPtoLP ( PDC dc, LPPOINT Points, INT Count );
VOID
FASTCALL
CoordDPtoLP ( PDC Dc, LPPOINT Point );
int
FASTCALL
IntGetGraphicsMode ( PDC dc );
VOID
FASTCALL
CoordLPtoDP ( PDC Dc, LPPOINT Point );
VOID
FASTCALL
IntLPtoDP ( PDC dc, LPPOINT Points, INT Count );
#endif

423
reactos/include/win32k/dc.h → reactos/subsys/win32k/include/dc.h
View file

@ -1,238 +1,185 @@
#ifndef __WIN32K_DC_H
#define __WIN32K_DC_H
typedef struct _WIN_DC_INFO
{
int flags;
HRGN hClipRgn; /* Clip region (may be 0) */
HRGN hVisRgn; /* Visible region (must never be 0) */
HRGN hGCClipRgn; /* GC clip region (ClipRgn AND VisRgn) */
HPEN hPen;
HBRUSH hBrush;
HFONT hFont;
HBITMAP hBitmap;
HBITMAP hFirstBitmap; /* Bitmap selected at creation of the DC */
/* #if 0 */
HANDLE hDevice;
HPALETTE hPalette;
GdiPath path;
/* #endif */
WORD ROPmode;
WORD polyFillMode;
WORD stretchBltMode;
WORD relAbsMode;
WORD backgroundMode;
COLORREF backgroundColor;
COLORREF textColor;
short brushOrgX;
short brushOrgY;
WORD textAlign; /* Text alignment from SetTextAlign() */
short charExtra; /* Spacing from SetTextCharacterExtra() */
short breakTotalExtra; /* Total extra space for justification */
short breakCount; /* Break char. count */
short breakExtra; /* breakTotalExtra / breakCount */
short breakRem; /* breakTotalExtra % breakCount */
RECT totalExtent;
BYTE bitsPerPixel;
INT MapMode;
INT GraphicsMode; /* Graphics mode */
INT DCOrgX; /* DC origin */
INT DCOrgY;
#if 0
FARPROC lpfnPrint; /* AbortProc for Printing */
#endif
INT CursPosX; /* Current position */
INT CursPosY;
INT ArcDirection;
XFORM xformWorld2Wnd; /* World-to-window transformation */
XFORM xformWorld2Vport; /* World-to-viewport transformation */
XFORM xformVport2World; /* Inverse of the above transformation */
BOOL vport2WorldValid; /* Is xformVport2World valid? */
} WIN_DC_INFO;
/* DC flags */
#define DC_MEMORY 0x0001 /* It is a memory DC */
#define DC_SAVED 0x0002 /* It is a saved DC */
#define DC_DIRTY 0x0004 /* hVisRgn has to be updated */
#define DC_THUNKHOOK 0x0008 /* DC hook is in the 16-bit code */
#define GDI_DC_TYPE (1)
typedef struct _DC
{
HDC hSelf;
HDC hNext;
DHPDEV PDev;
HSURF FillPatternSurfaces[HS_DDI_MAX];
PGDIINFO GDIInfo;
PDEVINFO DevInfo;
HDEV GDIDevice;
DRIVER_FUNCTIONS DriverFunctions;
UNICODE_STRING DriverName;
HANDLE DeviceDriver;
INT wndOrgX; /* Window origin */
INT wndOrgY;
INT wndExtX; /* Window extent */
INT wndExtY;
INT vportOrgX; /* Viewport origin */
INT vportOrgY;
INT vportExtX; /* Viewport extent */
INT vportExtY;
CLIPOBJ *CombinedClip;
XLATEOBJ *XlateBrush;
XLATEOBJ *XlatePen;
INT saveLevel;
BOOL IsIC;
HPALETTE PalIndexed;
WIN_DC_INFO w;
} DC, *PDC;
typedef struct _GDIPOINTER /* should stay private to ENG */
{
/* private GDI pointer handling information, required for software emulation */
BOOL Enabled;
POINTL Pos;
SIZEL Size;
POINTL HotSpot;
XLATEOBJ *XlateObject;
HSURF ColorSurface;
HSURF MaskSurface;
HSURF SaveSurface;
/* public pointer information */
RECTL Exclude; /* required publicly for SPS_ACCEPT_EXCLUDE */
PGD_MOVEPOINTER MovePointer;
ULONG Status;
} GDIPOINTER, *PGDIPOINTER;
typedef struct
{
HANDLE Handle;
DHPDEV PDev;
DEVMODEW DMW;
HSURF FillPatterns[HS_DDI_MAX];
GDIINFO GDIInfo;
DEVINFO DevInfo;
DRIVER_FUNCTIONS DriverFunctions;
#ifdef NTOS_MODE_USER
PVOID VideoFileObject;
#else
PFILE_OBJECT VideoFileObject;
#endif
BOOLEAN PreparedDriver;
ULONG DisplayNumber;
GDIPOINTER Pointer;
/* Stuff to keep track of software cursors; win32k gdi part */
UINT SafetyRemoveLevel; /* at what level was the cursor removed?
0 for not removed */
UINT SafetyRemoveCount;
} GDIDEVICE;
/* Internal functions */
#ifndef NTOS_MODE_USER
#define DC_LockDc(hDC) \
((PDC) GDIOBJ_LockObj ((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC))
#define DC_UnlockDc(pDC) \
GDIOBJ_UnlockObjByPtr (pDC)
HDC FASTCALL RetrieveDisplayHDC(VOID);
HDC FASTCALL DC_AllocDC(PUNICODE_STRING Driver);
VOID FASTCALL DC_InitDC(HDC DCToInit);
HDC FASTCALL DC_FindOpenDC(PUNICODE_STRING Driver);
VOID FASTCALL DC_FreeDC(HDC DCToFree);
BOOL INTERNAL_CALL DC_Cleanup(PVOID ObjectBody);
HDC FASTCALL DC_GetNextDC (PDC pDC);
VOID FASTCALL DC_SetNextDC (PDC pDC, HDC hNextDC);
VOID FASTCALL DC_SetOwnership(HDC DC, PEPROCESS Owner);
VOID FASTCALL DC_UpdateXforms(PDC dc);
BOOL FASTCALL DC_InvertXform(const XFORM *xformSrc, XFORM *xformDest);
#endif
/* User entry points */
BOOL STDCALL NtGdiCancelDC(HDC hDC);
HDC STDCALL NtGdiCreateCompatibleDC(HDC hDC);
HDC STDCALL NtGdiCreateDC(PUNICODE_STRING Driver,
PUNICODE_STRING Device,
PUNICODE_STRING Output,
CONST PDEVMODEW InitData);
HDC STDCALL NtGdiCreateIC(PUNICODE_STRING Driver,
PUNICODE_STRING Device,
PUNICODE_STRING Output,
CONST PDEVMODEW DevMode);
BOOL STDCALL NtGdiDeleteDC(HDC hDC);
BOOL STDCALL NtGdiDeleteObject(HGDIOBJ hObject);
INT STDCALL NtGdiDrawEscape(HDC hDC,
INT nEscape,
INT cbInput,
LPCSTR lpszInData);
INT STDCALL NtGdiEnumObjects(HDC hDC,
INT ObjectType,
GOBJENUMPROC ObjectFunc,
LPARAM lParam);
COLORREF STDCALL NtGdiGetBkColor(HDC hDC);
INT STDCALL NtGdiGetBkMode(HDC hDC);
BOOL STDCALL NtGdiGetBrushOrgEx(HDC hDC, LPPOINT brushOrg);
HRGN STDCALL NtGdiGetClipRgn(HDC hDC);
HGDIOBJ STDCALL NtGdiGetCurrentObject(HDC hDC, UINT ObjectType);
VOID FASTCALL IntGetCurrentPositionEx (PDC dc, LPPOINT currentPosition);
BOOL STDCALL NtGdiGetCurrentPositionEx(HDC hDC, LPPOINT currentPosition);
BOOL STDCALL NtGdiGetDCOrgEx(HDC hDC, LPPOINT Point);
HDC STDCALL NtGdiGetDCState(HDC hDC);
INT STDCALL NtGdiGetDeviceCaps(HDC hDC, INT Index);
INT STDCALL NtGdiGetMapMode(HDC hDC);
INT STDCALL NtGdiGetObject(HGDIOBJ hGDIObj,
INT BufSize,
LPVOID Object);
DWORD STDCALL NtGdiGetObjectType(HGDIOBJ hGDIObj);
INT STDCALL NtGdiGetPolyFillMode(HDC hDC);
INT STDCALL NtGdiGetRelAbs(HDC hDC);
INT STDCALL NtGdiGetROP2(HDC hDC);
HGDIOBJ STDCALL NtGdiGetStockObject(INT Object);
INT STDCALL NtGdiGetStretchBltMode(HDC hDC);
COLORREF STDCALL NtGdiGetTextColor(HDC hDC);
UINT STDCALL NtGdiGetTextAlign(HDC hDC);
BOOL STDCALL NtGdiGetViewportExtEx(HDC hDC, LPSIZE viewportExt);
BOOL STDCALL NtGdiGetViewportOrgEx(HDC hDC, LPPOINT viewportOrg);
BOOL STDCALL NtGdiGetWindowExtEx(HDC hDC, LPSIZE windowExt);
BOOL STDCALL NtGdiGetWindowOrgEx(HDC hDC, LPPOINT windowOrg);
HDC STDCALL NtGdiResetDC(HDC hDC, CONST DEVMODEW *InitData);
BOOL STDCALL NtGdiRestoreDC(HDC hDC, INT SavedDC);
INT STDCALL NtGdiSaveDC(HDC hDC);
HGDIOBJ STDCALL NtGdiSelectObject(HDC hDC, HGDIOBJ hGDIObj);
INT STDCALL NtGdiSetBkMode(HDC hDC, INT backgroundMode);
VOID STDCALL NtGdiSetDCState ( HDC hDC, HDC hDCSave );
WORD STDCALL NtGdiSetHookFlags(HDC hDC, WORD Flags);
INT STDCALL NtGdiSetPolyFillMode(HDC hDC, INT polyFillMode);
INT STDCALL NtGdiSetRelAbs(HDC hDC, INT relAbsMode);
INT STDCALL NtGdiSetROP2(HDC hDC, INT ROPmode);
INT STDCALL NtGdiSetStretchBltMode(HDC hDC, INT stretchBltMode);
COLORREF STDCALL NtGdiSetTextColor(HDC hDC, COLORREF color);
#endif
#ifndef __WIN32K_DC_H
#define __WIN32K_DC_H
#include "driver.h"
typedef enum tagGdiPathState
{
PATH_Null,
PATH_Open,
PATH_Closed
} GdiPathState;
typedef struct tagGdiPath
{
GdiPathState state;
POINT *pPoints;
BYTE *pFlags;
int numEntriesUsed, numEntriesAllocated;
BOOL newStroke;
} GdiPath;
typedef struct _WIN_DC_INFO
{
int flags;
HRGN hClipRgn; /* Clip region (may be 0) */
HRGN hVisRgn; /* Visible region (must never be 0) */
HRGN hGCClipRgn; /* GC clip region (ClipRgn AND VisRgn) */
HPEN hPen;
HBRUSH hBrush;
HFONT hFont;
HBITMAP hBitmap;
HBITMAP hFirstBitmap; /* Bitmap selected at creation of the DC */
/* #if 0 */
HANDLE hDevice;
HPALETTE hPalette;
GdiPath path;
/* #endif */
WORD ROPmode;
WORD polyFillMode;
WORD stretchBltMode;
WORD relAbsMode;
WORD backgroundMode;
COLORREF backgroundColor;
COLORREF textColor;
short brushOrgX;
short brushOrgY;
WORD textAlign; /* Text alignment from SetTextAlign() */
short charExtra; /* Spacing from SetTextCharacterExtra() */
short breakTotalExtra; /* Total extra space for justification */
short breakCount; /* Break char. count */
short breakExtra; /* breakTotalExtra / breakCount */
short breakRem; /* breakTotalExtra % breakCount */
RECT totalExtent;
BYTE bitsPerPixel;
INT MapMode;
INT GraphicsMode; /* Graphics mode */
INT DCOrgX; /* DC origin */
INT DCOrgY;
#if 0
FARPROC lpfnPrint; /* AbortProc for Printing */
#endif
INT CursPosX; /* Current position */
INT CursPosY;
INT ArcDirection;
XFORM xformWorld2Wnd; /* World-to-window transformation */
XFORM xformWorld2Vport; /* World-to-viewport transformation */
XFORM xformVport2World; /* Inverse of the above transformation */
BOOL vport2WorldValid; /* Is xformVport2World valid? */
} WIN_DC_INFO;
/* DC flags */
#define DC_MEMORY 0x0001 /* It is a memory DC */
#define DC_SAVED 0x0002 /* It is a saved DC */
#define DC_DIRTY 0x0004 /* hVisRgn has to be updated */
#define DC_THUNKHOOK 0x0008 /* DC hook is in the 16-bit code */
#define GDI_DC_TYPE (1)
typedef struct _DC
{
HDC hSelf;
HDC hNext;
DHPDEV PDev;
HSURF FillPatternSurfaces[HS_DDI_MAX];
PGDIINFO GDIInfo;
PDEVINFO DevInfo;
HDEV GDIDevice;
DRIVER_FUNCTIONS DriverFunctions;
UNICODE_STRING DriverName;
HANDLE DeviceDriver;
INT wndOrgX; /* Window origin */
INT wndOrgY;
INT wndExtX; /* Window extent */
INT wndExtY;
INT vportOrgX; /* Viewport origin */
INT vportOrgY;
INT vportExtX; /* Viewport extent */
INT vportExtY;
CLIPOBJ *CombinedClip;
XLATEOBJ *XlateBrush;
XLATEOBJ *XlatePen;
INT saveLevel;
BOOL IsIC;
HPALETTE PalIndexed;
WIN_DC_INFO w;
} DC, *PDC;
typedef struct _GDIPOINTER /* should stay private to ENG */
{
/* private GDI pointer handling information, required for software emulation */
BOOL Enabled;
POINTL Pos;
SIZEL Size;
POINTL HotSpot;
XLATEOBJ *XlateObject;
HSURF ColorSurface;
HSURF MaskSurface;
HSURF SaveSurface;
/* public pointer information */
RECTL Exclude; /* required publicly for SPS_ACCEPT_EXCLUDE */
PGD_MOVEPOINTER MovePointer;
ULONG Status;
} GDIPOINTER, *PGDIPOINTER;
typedef struct
{
HANDLE Handle;
DHPDEV PDev;
DEVMODEW DMW;
HSURF FillPatterns[HS_DDI_MAX];
GDIINFO GDIInfo;
DEVINFO DevInfo;
DRIVER_FUNCTIONS DriverFunctions;
PFILE_OBJECT VideoFileObject;
BOOLEAN PreparedDriver;
ULONG DisplayNumber;
GDIPOINTER Pointer;
/* Stuff to keep track of software cursors; win32k gdi part */
UINT SafetyRemoveLevel; /* at what level was the cursor removed?
0 for not removed */
UINT SafetyRemoveCount;
} GDIDEVICE;
/* Internal functions */
#define DC_LockDc(hDC) \
((PDC) GDIOBJ_LockObj ((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC))
#define DC_UnlockDc(pDC) \
GDIOBJ_UnlockObjByPtr (pDC)
HDC FASTCALL RetrieveDisplayHDC(VOID);
HDC FASTCALL DC_AllocDC(PUNICODE_STRING Driver);
VOID FASTCALL DC_InitDC(HDC DCToInit);
HDC FASTCALL DC_FindOpenDC(PUNICODE_STRING Driver);
VOID FASTCALL DC_FreeDC(HDC DCToFree);
BOOL INTERNAL_CALL DC_Cleanup(PVOID ObjectBody);
HDC FASTCALL DC_GetNextDC (PDC pDC);
VOID FASTCALL DC_SetNextDC (PDC pDC, HDC hNextDC);
VOID FASTCALL DC_SetOwnership(HDC DC, PEPROCESS Owner);
VOID FASTCALL DC_UpdateXforms(PDC dc);
BOOL FASTCALL DC_InvertXform(const XFORM *xformSrc, XFORM *xformDest);
#endif

2
reactos/subsys/win32k/include/dib.h
View file

@ -1,7 +1,7 @@
#ifndef _WIN32K_DIB_H
#define _WIN32K_DIB_H
#include <win32k/dc.h>
#include "dc.h"
INT FASTCALL
DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse);

380
reactos/include/win32k/driver.h → reactos/subsys/win32k/include/driver.h
View file

@ -1,192 +1,188 @@
#ifndef __WIN32K_DRIVER_H
#define __WIN32K_DRIVER_H
#include <winddi.h>
typedef BOOL (STDCALL *PGD_ENABLEDRIVER)(ULONG, ULONG, PDRVENABLEDATA);
typedef DHPDEV (STDCALL *PGD_ENABLEPDEV)(DEVMODEW *,
LPWSTR,
ULONG,
HSURF *,
ULONG,
ULONG *,
ULONG,
DEVINFO *,
LPWSTR,
LPWSTR,
HANDLE);
typedef VOID (STDCALL *PGD_COMPLETEPDEV)(DHPDEV, HDEV);
typedef VOID (STDCALL *PGD_DISABLEPDEV)(DHPDEV);
typedef HSURF (STDCALL *PGD_ENABLESURFACE)(DHPDEV);
typedef VOID (STDCALL *PGD_DISABLESURFACE)(DHPDEV);
typedef BOOL (STDCALL *PGD_ASSERTMODE)(DHPDEV, BOOL);
typedef BOOL (STDCALL *PGD_OFFSET)(SURFOBJ*, LONG, LONG, FLONG);
typedef BOOL (STDCALL *PGD_RESETPDEV)(DHPDEV, DHPDEV);
typedef VOID (STDCALL *PGD_DISABLEDRIVER)(VOID);
typedef HBITMAP (STDCALL *PGD_CREATEDEVICEBITMAP)(DHPDEV, SIZEL, ULONG);
typedef VOID (STDCALL *PGD_DELETEDEVICEBITMAP)(DHSURF);
typedef BOOL (STDCALL *PGD_ALPHABLEND)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, BLENDOBJ*);
typedef BOOL (STDCALL *PGD_REALIZEBRUSH)(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*,
XLATEOBJ*, ULONG);
typedef ULONG (STDCALL *PGD_DITHERCOLOR)(DHPDEV, ULONG, ULONG, PULONG);
typedef BOOL (STDCALL *PGD_STROKEPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*,
BRUSHOBJ*, POINTL*, PLINEATTRS, MIX);
typedef BOOL (STDCALL *PGD_FILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*,
POINTL*, MIX, ULONG);
typedef BOOL (STDCALL *PGD_STROKEANDFILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*,
XFORMOBJ*, BRUSHOBJ*, PLINEATTRS,
BRUSHOBJ*, POINTL*, MIX, ULONG);
typedef BOOL (STDCALL *PGD_PAINT)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX);
typedef BOOL (STDCALL *PGD_BITBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*,
XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*,
POINTL*, ROP4);
typedef BOOL (STDCALL *PGD_TRANSPARENTBLT)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
RECTL*, RECTL*, ULONG, ULONG);
typedef BOOL (STDCALL *PGD_COPYBITS)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
RECTL*, POINTL*);
typedef BOOL (STDCALL *PGD_STRETCHBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*,
XLATEOBJ*, COLORADJUSTMENT*, POINTL*,
RECTL*, RECTL*, POINTL*, ULONG);
typedef BOOL (STDCALL *PGD_STRETCHBLTROP)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*,
XLATEOBJ*, COLORADJUSTMENT*, POINTL*,
RECTL*, RECTL*, POINTL*, ULONG,
BRUSHOBJ*, DWORD);
typedef BOOL (STDCALL *PGD_SETPALETTE)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG);
typedef BOOL (STDCALL *PGD_TEXTOUT)(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*,
RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX);
typedef ULONG (STDCALL *PGD_ESCAPE)(SURFOBJ*, ULONG, ULONG, PVOID *, ULONG, PVOID *);
typedef ULONG (STDCALL *PGD_DRAWESCAPE)(SURFOBJ*, ULONG, CLIPOBJ*, RECTL*, ULONG,
PVOID *);
typedef PIFIMETRICS (STDCALL *PGD_QUERYFONT)(DHPDEV, ULONG, ULONG, PULONG);
typedef PVOID (STDCALL *PGD_QUERYFONTTREE)(DHPDEV, ULONG, ULONG, ULONG, PULONG);
typedef LONG (STDCALL *PGD_QUERYFONTDATA)(DHPDEV, FONTOBJ*, ULONG, HGLYPH, GLYPHDATA*,
PVOID, ULONG);
typedef ULONG (STDCALL *PGD_SETPOINTERSHAPE)(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*,
LONG, LONG, LONG, LONG, RECTL*, ULONG);
typedef VOID (STDCALL *PGD_MOVEPOINTER)(SURFOBJ*, LONG, LONG, RECTL*);
typedef BOOL (STDCALL *PGD_LINETO)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG,
LONG, RECTL*, MIX);
typedef BOOL (STDCALL *PGD_SENDPAGE)(SURFOBJ*);
typedef BOOL (STDCALL *PGD_STARTPAGE)(SURFOBJ*);
typedef BOOL (STDCALL *PGD_ENDDOC)(SURFOBJ*, ULONG);
typedef BOOL (STDCALL *PGD_STARTDOC)(SURFOBJ*, PWSTR, DWORD);
typedef ULONG (STDCALL *PGD_GETGLYPHMODE)(DHPDEV, FONTOBJ*);
typedef VOID (STDCALL *PGD_SYNCHRONIZE)(DHPDEV, RECTL*);
typedef ULONG (STDCALL *PGD_SAVESCREENBITS)(SURFOBJ*, ULONG, ULONG, RECTL*);
typedef ULONG (STDCALL *PGD_GETMODES)(HANDLE, ULONG, PDEVMODEW);
typedef VOID (STDCALL *PGD_FREE)(PVOID, ULONG);
typedef VOID (STDCALL *PGD_DESTROYFONT)(FONTOBJ*);
typedef LONG (STDCALL *PGD_QUERYFONTCAPS)(ULONG, PULONG);
typedef ULONG (STDCALL *PGD_LOADFONTFILE)(ULONG, PVOID, ULONG, ULONG);
typedef BOOL (STDCALL *PGD_UNLOADFONTFILE)(ULONG);
typedef ULONG (STDCALL *PGD_FONTMANAGEMENT)(SURFOBJ*, FONTOBJ*, ULONG, ULONG, PVOID,
ULONG, PVOID);
typedef LONG (STDCALL *PGD_QUERYTRUETYPETABLE)(ULONG, ULONG, ULONG, PTRDIFF, ULONG,
PBYTE);
typedef LONG (STDCALL *PGD_QUERYTRUETYPEOUTLINE)(DHPDEV, FONTOBJ*, HGLYPH, BOOL,
GLYPHDATA*, ULONG, TTPOLYGONHEADER*);
typedef PVOID (STDCALL *PGD_GETTRUETYPEFILE)(ULONG, PULONG);
typedef LONG (STDCALL *PGD_QUERYFONTFILE)(ULONG, ULONG, ULONG, PULONG);
typedef BOOL (STDCALL *PGD_QUERYADVANCEWIDTHS)(DHPDEV, FONTOBJ*, ULONG, HGLYPH *,
PVOID *, ULONG);
typedef BOOL (STDCALL *PGD_SETPIXELFORMAT)(SURFOBJ*, LONG, ULONG);
typedef LONG (STDCALL *PGD_DESCRIBEPIXELFORMAT)(DHPDEV, LONG, ULONG,
PPIXELFORMATDESCRIPTOR);
typedef BOOL (STDCALL *PGD_SWAPBUFFERS)(SURFOBJ*, PWNDOBJ);
typedef BOOL (STDCALL *PGD_STARTBANDING)(SURFOBJ*, POINTL*);
typedef BOOL (STDCALL *PGD_NEXTBAND)(SURFOBJ*, POINTL*);
typedef BOOL (STDCALL *PGD_GETDIRECTDRAWINFO)(DHPDEV, PDD_HALINFO, PDWORD, VIDEOMEMORY*, PDWORD, PDWORD);
typedef BOOL (STDCALL *PGD_ENABLEDIRECTDRAW)(DHPDEV, PDD_CALLBACKS, PDD_SURFACECALLBACKS, PDD_PALETTECALLBACKS);
typedef VOID (STDCALL *PGD_DISABLEDIRECTDRAW)(DHPDEV);
typedef LONG (STDCALL *PGD_QUERYSPOOLTYPE)(DHPDEV, LPWSTR);
typedef BOOL (STDCALL *PGD_GRADIENTFILL)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);
typedef VOID (STDCALL *PGD_SYNCHRONIZESURFACE)(SURFOBJ*, RECTL *, FLONG);
typedef struct _DRIVER_FUNCTIONS
{
PGD_ENABLEDRIVER EnableDriver;
PGD_ENABLEPDEV EnablePDEV;
PGD_COMPLETEPDEV CompletePDEV;
PGD_DISABLEPDEV DisablePDEV;
PGD_ENABLESURFACE EnableSurface;
PGD_DISABLESURFACE DisableSurface;
PGD_ASSERTMODE AssertMode;
PGD_OFFSET Offset;
PGD_RESETPDEV ResetPDEV;
PGD_DISABLEDRIVER DisableDriver;
PGD_CREATEDEVICEBITMAP CreateDeviceBitmap;
PGD_DELETEDEVICEBITMAP DeleteDeviceBitmap;
PGD_REALIZEBRUSH RealizeBrush;
PGD_DITHERCOLOR DitherColor;
PGD_STROKEPATH StrokePath;
PGD_FILLPATH FillPath;
PGD_STROKEANDFILLPATH StrokeAndFillPath;
PGD_PAINT Paint;
PGD_BITBLT BitBlt;
PGD_TRANSPARENTBLT TransparentBlt;
PGD_COPYBITS CopyBits;
PGD_STRETCHBLT StretchBlt;
PGD_STRETCHBLTROP StretchBltROP;
PGD_SETPALETTE SetPalette;
PGD_TEXTOUT TextOut;
PGD_ESCAPE Escape;
PGD_DRAWESCAPE DrawEscape;
PGD_QUERYFONT QueryFont;
PGD_QUERYFONTTREE QueryFontTree;
PGD_QUERYFONTDATA QueryFontData;
PGD_SETPOINTERSHAPE SetPointerShape;
PGD_MOVEPOINTER MovePointer;
PGD_LINETO LineTo;
PGD_SENDPAGE SendPage;
PGD_STARTPAGE StartPage;
PGD_ENDDOC EndDoc;
PGD_STARTDOC StartDoc;
PGD_GETGLYPHMODE GetGlyphMode;
PGD_SYNCHRONIZE Synchronize;
PGD_SAVESCREENBITS SaveScreenBits;
PGD_GETMODES GetModes;
PGD_FREE Free;
PGD_DESTROYFONT DestroyFont;
PGD_QUERYFONTCAPS QueryFontCaps;
PGD_LOADFONTFILE LoadFontFile;
PGD_UNLOADFONTFILE UnloadFontFile;
PGD_FONTMANAGEMENT FontManagement;
PGD_QUERYTRUETYPETABLE QueryTrueTypeTable;
PGD_QUERYTRUETYPEOUTLINE QueryTrueTypeOutline;
PGD_GETTRUETYPEFILE GetTrueTypeFile;
PGD_QUERYFONTFILE QueryFontFile;
PGD_QUERYADVANCEWIDTHS QueryAdvanceWidths;
PGD_SETPIXELFORMAT SetPixelFormat;
PGD_DESCRIBEPIXELFORMAT DescribePixelFormat;
PGD_SWAPBUFFERS SwapBuffers;
PGD_STARTBANDING StartBanding;
PGD_NEXTBAND NextBand;
PGD_GETDIRECTDRAWINFO GetDirectDrawInfo;
PGD_ENABLEDIRECTDRAW EnableDirectDraw;
PGD_DISABLEDIRECTDRAW DisableDirectDraw;
PGD_QUERYSPOOLTYPE QuerySpoolType;
PGD_GRADIENTFILL GradientFill;
PGD_SYNCHRONIZESURFACE SynchronizeSurface;
PGD_ALPHABLEND AlphaBlend;
} DRIVER_FUNCTIONS, *PDRIVER_FUNCTIONS;
#ifndef NTOS_MODE_USER
BOOL DRIVER_RegisterDriver(LPCWSTR Name, PGD_ENABLEDRIVER EnableDriver);
PGD_ENABLEDRIVER DRIVER_FindDDIDriver(LPCWSTR Name);
PFILE_OBJECT DRIVER_FindMPDriver(ULONG DisplayNumber);
BOOL DRIVER_BuildDDIFunctions(PDRVENABLEDATA DED,
PDRIVER_FUNCTIONS DF);
BOOL DRIVER_UnregisterDriver(LPCWSTR Name);
INT DRIVER_ReferenceDriver (LPCWSTR Name);
INT DRIVER_UnreferenceDriver (LPCWSTR Name);
#endif
#endif
#ifndef __WIN32K_DRIVER_H
#define __WIN32K_DRIVER_H
#include <winddi.h>
typedef BOOL (NTAPI *PGD_ENABLEDRIVER)(ULONG, ULONG, PDRVENABLEDATA);
typedef DHPDEV (NTAPI *PGD_ENABLEPDEV)(DEVMODEW *,
LPWSTR,
ULONG,
HSURF *,
ULONG,
ULONG *,
ULONG,
DEVINFO *,
LPWSTR,
LPWSTR,
HANDLE);
typedef VOID (NTAPI *PGD_COMPLETEPDEV)(DHPDEV, HDEV);
typedef VOID (NTAPI *PGD_DISABLEPDEV)(DHPDEV);
typedef HSURF (NTAPI *PGD_ENABLESURFACE)(DHPDEV);
typedef VOID (NTAPI *PGD_DISABLESURFACE)(DHPDEV);
typedef BOOL (NTAPI *PGD_ASSERTMODE)(DHPDEV, BOOL);
typedef BOOL (NTAPI *PGD_OFFSET)(SURFOBJ*, LONG, LONG, FLONG);
typedef BOOL (NTAPI *PGD_RESETPDEV)(DHPDEV, DHPDEV);
typedef VOID (NTAPI *PGD_DISABLEDRIVER)(VOID);
typedef HBITMAP (NTAPI *PGD_CREATEDEVICEBITMAP)(DHPDEV, SIZEL, ULONG);
typedef VOID (NTAPI *PGD_DELETEDEVICEBITMAP)(DHSURF);
typedef BOOL (NTAPI *PGD_ALPHABLEND)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, BLENDOBJ*);
typedef BOOL (NTAPI *PGD_REALIZEBRUSH)(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*,
XLATEOBJ*, ULONG);
typedef ULONG (NTAPI *PGD_DITHERCOLOR)(DHPDEV, ULONG, ULONG, PULONG);
typedef BOOL (NTAPI *PGD_STROKEPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*,
BRUSHOBJ*, POINTL*, PLINEATTRS, MIX);
typedef BOOL (NTAPI *PGD_FILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*,
POINTL*, MIX, ULONG);
typedef BOOL (NTAPI *PGD_STROKEANDFILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*,
XFORMOBJ*, BRUSHOBJ*, PLINEATTRS,
BRUSHOBJ*, POINTL*, MIX, ULONG);
typedef BOOL (NTAPI *PGD_PAINT)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX);
typedef BOOL (NTAPI *PGD_BITBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*,
XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*,
POINTL*, ROP4);
typedef BOOL (NTAPI *PGD_TRANSPARENTBLT)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
RECTL*, RECTL*, ULONG, ULONG);
typedef BOOL (NTAPI *PGD_COPYBITS)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*,
RECTL*, POINTL*);
typedef BOOL (NTAPI *PGD_STRETCHBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*,
XLATEOBJ*, COLORADJUSTMENT*, POINTL*,
RECTL*, RECTL*, POINTL*, ULONG);
typedef BOOL (NTAPI *PGD_STRETCHBLTROP)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*,
XLATEOBJ*, COLORADJUSTMENT*, POINTL*,
RECTL*, RECTL*, POINTL*, ULONG,
BRUSHOBJ*, DWORD);
typedef BOOL (NTAPI *PGD_SETPALETTE)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG);
typedef BOOL (NTAPI *PGD_TEXTOUT)(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*,
RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX);
typedef ULONG (NTAPI *PGD_ESCAPE)(SURFOBJ*, ULONG, ULONG, PVOID *, ULONG, PVOID *);
typedef ULONG (NTAPI *PGD_DRAWESCAPE)(SURFOBJ*, ULONG, CLIPOBJ*, RECTL*, ULONG,
PVOID *);
typedef PIFIMETRICS (NTAPI *PGD_QUERYFONT)(DHPDEV, ULONG, ULONG, PULONG);
typedef PVOID (NTAPI *PGD_QUERYFONTTREE)(DHPDEV, ULONG, ULONG, ULONG, PULONG);
typedef LONG (NTAPI *PGD_QUERYFONTDATA)(DHPDEV, FONTOBJ*, ULONG, HGLYPH, GLYPHDATA*,
PVOID, ULONG);
typedef ULONG (NTAPI *PGD_SETPOINTERSHAPE)(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*,
LONG, LONG, LONG, LONG, RECTL*, ULONG);
typedef VOID (NTAPI *PGD_MOVEPOINTER)(SURFOBJ*, LONG, LONG, RECTL*);
typedef BOOL (NTAPI *PGD_LINETO)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG,
LONG, RECTL*, MIX);
typedef BOOL (NTAPI *PGD_SENDPAGE)(SURFOBJ*);
typedef BOOL (NTAPI *PGD_STARTPAGE)(SURFOBJ*);
typedef BOOL (NTAPI *PGD_ENDDOC)(SURFOBJ*, ULONG);
typedef BOOL (NTAPI *PGD_STARTDOC)(SURFOBJ*, PWSTR, DWORD);
typedef ULONG (NTAPI *PGD_GETGLYPHMODE)(DHPDEV, FONTOBJ*);
typedef VOID (NTAPI *PGD_SYNCHRONIZE)(DHPDEV, RECTL*);
typedef ULONG (NTAPI *PGD_SAVESCREENBITS)(SURFOBJ*, ULONG, ULONG, RECTL*);
typedef ULONG (NTAPI *PGD_GETMODES)(HANDLE, ULONG, PDEVMODEW);
typedef VOID (NTAPI *PGD_FREE)(PVOID, ULONG);
typedef VOID (NTAPI *PGD_DESTROYFONT)(FONTOBJ*);
typedef LONG (NTAPI *PGD_QUERYFONTCAPS)(ULONG, PULONG);
typedef ULONG (NTAPI *PGD_LOADFONTFILE)(ULONG, PVOID, ULONG, ULONG);
typedef BOOL (NTAPI *PGD_UNLOADFONTFILE)(ULONG);
typedef ULONG (NTAPI *PGD_FONTMANAGEMENT)(SURFOBJ*, FONTOBJ*, ULONG, ULONG, PVOID,
ULONG, PVOID);
typedef LONG (NTAPI *PGD_QUERYTRUETYPETABLE)(ULONG, ULONG, ULONG, PTRDIFF, ULONG,
PBYTE);
typedef LONG (NTAPI *PGD_QUERYTRUETYPEOUTLINE)(DHPDEV, FONTOBJ*, HGLYPH, BOOL,
GLYPHDATA*, ULONG, TTPOLYGONHEADER*);
typedef PVOID (NTAPI *PGD_GETTRUETYPEFILE)(ULONG, PULONG);
typedef LONG (NTAPI *PGD_QUERYFONTFILE)(ULONG, ULONG, ULONG, PULONG);
typedef BOOL (NTAPI *PGD_QUERYADVANCEWIDTHS)(DHPDEV, FONTOBJ*, ULONG, HGLYPH *,
PVOID *, ULONG);
typedef BOOL (NTAPI *PGD_SETPIXELFORMAT)(SURFOBJ*, LONG, ULONG);
typedef LONG (NTAPI *PGD_DESCRIBEPIXELFORMAT)(DHPDEV, LONG, ULONG,
PPIXELFORMATDESCRIPTOR);
typedef BOOL (NTAPI *PGD_SWAPBUFFERS)(SURFOBJ*, PWNDOBJ);
typedef BOOL (NTAPI *PGD_STARTBANDING)(SURFOBJ*, POINTL*);
typedef BOOL (NTAPI *PGD_NEXTBAND)(SURFOBJ*, POINTL*);
typedef BOOL (NTAPI *PGD_GETDIRECTDRAWINFO)(DHPDEV, PDD_HALINFO, PDWORD, VIDEOMEMORY*, PDWORD, PDWORD);
typedef BOOL (NTAPI *PGD_ENABLEDIRECTDRAW)(DHPDEV, PDD_CALLBACKS, PDD_SURFACECALLBACKS, PDD_PALETTECALLBACKS);
typedef VOID (NTAPI *PGD_DISABLEDIRECTDRAW)(DHPDEV);
typedef LONG (NTAPI *PGD_QUERYSPOOLTYPE)(DHPDEV, LPWSTR);
typedef BOOL (NTAPI *PGD_GRADIENTFILL)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);
typedef VOID (NTAPI *PGD_SYNCHRONIZESURFACE)(SURFOBJ*, RECTL *, FLONG);
typedef struct _DRIVER_FUNCTIONS
{
PGD_ENABLEDRIVER EnableDriver;
PGD_ENABLEPDEV EnablePDEV;
PGD_COMPLETEPDEV CompletePDEV;
PGD_DISABLEPDEV DisablePDEV;
PGD_ENABLESURFACE EnableSurface;
PGD_DISABLESURFACE DisableSurface;
PGD_ASSERTMODE AssertMode;
PGD_OFFSET Offset;
PGD_RESETPDEV ResetPDEV;
PGD_DISABLEDRIVER DisableDriver;
PGD_CREATEDEVICEBITMAP CreateDeviceBitmap;
PGD_DELETEDEVICEBITMAP DeleteDeviceBitmap;
PGD_REALIZEBRUSH RealizeBrush;
PGD_DITHERCOLOR DitherColor;
PGD_STROKEPATH StrokePath;
PGD_FILLPATH FillPath;
PGD_STROKEANDFILLPATH StrokeAndFillPath;
PGD_PAINT Paint;
PGD_BITBLT BitBlt;
PGD_TRANSPARENTBLT TransparentBlt;
PGD_COPYBITS CopyBits;
PGD_STRETCHBLT StretchBlt;
PGD_STRETCHBLTROP StretchBltROP;
PGD_SETPALETTE SetPalette;
PGD_TEXTOUT TextOut;
PGD_ESCAPE Escape;
PGD_DRAWESCAPE DrawEscape;
PGD_QUERYFONT QueryFont;
PGD_QUERYFONTTREE QueryFontTree;
PGD_QUERYFONTDATA QueryFontData;
PGD_SETPOINTERSHAPE SetPointerShape;
PGD_MOVEPOINTER MovePointer;
PGD_LINETO LineTo;
PGD_SENDPAGE SendPage;
PGD_STARTPAGE StartPage;
PGD_ENDDOC EndDoc;
PGD_STARTDOC StartDoc;
PGD_GETGLYPHMODE GetGlyphMode;
PGD_SYNCHRONIZE Synchronize;
PGD_SAVESCREENBITS SaveScreenBits;
PGD_GETMODES GetModes;
PGD_FREE Free;
PGD_DESTROYFONT DestroyFont;
PGD_QUERYFONTCAPS QueryFontCaps;
PGD_LOADFONTFILE LoadFontFile;
PGD_UNLOADFONTFILE UnloadFontFile;
PGD_FONTMANAGEMENT FontManagement;
PGD_QUERYTRUETYPETABLE QueryTrueTypeTable;
PGD_QUERYTRUETYPEOUTLINE QueryTrueTypeOutline;
PGD_GETTRUETYPEFILE GetTrueTypeFile;
PGD_QUERYFONTFILE QueryFontFile;
PGD_QUERYADVANCEWIDTHS QueryAdvanceWidths;
PGD_SETPIXELFORMAT SetPixelFormat;
PGD_DESCRIBEPIXELFORMAT DescribePixelFormat;
PGD_SWAPBUFFERS SwapBuffers;
PGD_STARTBANDING StartBanding;
PGD_NEXTBAND NextBand;
PGD_GETDIRECTDRAWINFO GetDirectDrawInfo;
PGD_ENABLEDIRECTDRAW EnableDirectDraw;
PGD_DISABLEDIRECTDRAW DisableDirectDraw;
PGD_QUERYSPOOLTYPE QuerySpoolType;
PGD_GRADIENTFILL GradientFill;
PGD_SYNCHRONIZESURFACE SynchronizeSurface;
PGD_ALPHABLEND AlphaBlend;
} DRIVER_FUNCTIONS, *PDRIVER_FUNCTIONS;
BOOL DRIVER_RegisterDriver(LPCWSTR Name, PGD_ENABLEDRIVER EnableDriver);
PGD_ENABLEDRIVER DRIVER_FindDDIDriver(LPCWSTR Name);
PFILE_OBJECT DRIVER_FindMPDriver(ULONG DisplayNumber);
BOOL DRIVER_BuildDDIFunctions(PDRVENABLEDATA DED,
PDRIVER_FUNCTIONS DF);
BOOL DRIVER_UnregisterDriver(LPCWSTR Name);
INT DRIVER_ReferenceDriver (LPCWSTR Name);
INT DRIVER_UnreferenceDriver (LPCWSTR Name);
#endif

206
reactos/include/win32k/float.h → reactos/subsys/win32k/include/gdifloat.h
View file

@ -1,103 +1,103 @@
#ifndef __WIN32K_FLOAT_H
#define __WIN32K_FLOAT_H
#include <win32k/math.h>
#include <win32k/dc.h>
#include <ft2build.h>
#include FT_FREETYPE_H
typedef struct tagFLOAT_POINT
{
FLOAT x, y;
} FLOAT_POINT;
/* Rounds a floating point number to integer. The world-to-viewport
* transformation process is done in floating point internally. This function
* is then used to round these coordinates to integer values.
*/
static __inline INT GDI_ROUND(FLOAT val)
{
return (int)floor(val + 0.5);
}
/* Performs a world-to-viewport transformation on the specified point (which
* is in floating point format).
*/
static __inline void INTERNAL_LPTODP_FLOAT(DC *dc, FLOAT_POINT *point)
{
FLOAT x, y;
/* Perform the transformation */
x = point->x;
y = point->y;
point->x = x * dc->w.xformWorld2Vport.eM11 +
y * dc->w.xformWorld2Vport.eM21 +
dc->w.xformWorld2Vport.eDx;
point->y = x * dc->w.xformWorld2Vport.eM12 +
y * dc->w.xformWorld2Vport.eM22 +
dc->w.xformWorld2Vport.eDy;
}
/* Performs a viewport-to-world transformation on the specified point (which
* is in integer format). Returns TRUE if successful, else FALSE.
*/
#if 0
static __inline BOOL INTERNAL_DPTOLP(DC *dc, LPPOINT point)
{
FLOAT_POINT floatPoint;
/* Perform operation with floating point */
floatPoint.x=(FLOAT)point->x;
floatPoint.y=(FLOAT)point->y;
if (!INTERNAL_DPTOLP_FLOAT(dc, &floatPoint))
return FALSE;
/* Round to integers */
point->x = GDI_ROUND(floatPoint.x);
point->y = GDI_ROUND(floatPoint.y);
return TRUE;
}
/* Performs a world-to-viewport transformation on the specified point (which
* is in integer format).
*/
static __inline void INTERNAL_LPTODP(DC *dc, LPPOINT point)
{
FLOAT_POINT floatPoint;
/* Perform operation with floating point */
floatPoint.x=(FLOAT)point->x;
floatPoint.y=(FLOAT)point->y;
INTERNAL_LPTODP_FLOAT(dc, &floatPoint);
/* Round to integers */
point->x = GDI_ROUND(floatPoint.x);
point->y = GDI_ROUND(floatPoint.y);
}
#endif
#define MulDiv( x, y, z ) EngMulDiv( x, y, z )
#define XDPTOLP(dc,x) \
(MulDiv(((x)-(dc)->vportOrgX), (dc)->wndExtX, (dc)->vportExtX) + (dc)->wndOrgX)
#define YDPTOLP(dc,y) \
(MulDiv(((y)-(dc)->vportOrgY), (dc)->wndExtY, (dc)->vportExtY) + (dc)->wndOrgY)
#define XLPTODP(dc,x) \
(MulDiv(((x)-(dc)->wndOrgX), (dc)->vportExtX, (dc)->wndExtX) + (dc)->vportOrgX)
#define YLPTODP(dc,y) \
(MulDiv(((y)-(dc)->wndOrgY), (dc)->vportExtY, (dc)->wndExtY) + (dc)->vportOrgY)
/* Device <-> logical size conversion */
#define XDSTOLS(dc,x) \
MulDiv((x), (dc)->wndExtX, (dc)->vportExtX)
#define YDSTOLS(dc,y) \
MulDiv((y), (dc)->wndExtY, (dc)->vportExtY)
#define XLSTODS(dc,x) \
MulDiv((x), (dc)->vportExtX, (dc)->wndExtX)
#define YLSTODS(dc,y) \
MulDiv((y), (dc)->vportExtY, (dc)->wndExtY)
#endif
#ifndef __WIN32K_FLOAT_H
#define __WIN32K_FLOAT_H
#include "dc.h"
#include "math.h"
#include <ft2build.h>
#include FT_FREETYPE_H
typedef struct tagFLOAT_POINT
{
FLOAT x, y;
} FLOAT_POINT;
/* Rounds a floating point number to integer. The world-to-viewport
* transformation process is done in floating point internally. This function
* is then used to round these coordinates to integer values.
*/
static inline INT GDI_ROUND(FLOAT val)
{
return (int)floor(val + 0.5);
}
/* Performs a world-to-viewport transformation on the specified point (which
* is in floating point format).
*/
static inline void INTERNAL_LPTODP_FLOAT(DC *dc, FLOAT_POINT *point)
{
FLOAT x, y;
/* Perform the transformation */
x = point->x;
y = point->y;
point->x = x * dc->w.xformWorld2Vport.eM11 +
y * dc->w.xformWorld2Vport.eM21 +
dc->w.xformWorld2Vport.eDx;
point->y = x * dc->w.xformWorld2Vport.eM12 +
y * dc->w.xformWorld2Vport.eM22 +
dc->w.xformWorld2Vport.eDy;
}
/* Performs a viewport-to-world transformation on the specified point (which
* is in integer format). Returns TRUE if successful, else FALSE.
*/
#if 0
static inline BOOL INTERNAL_DPTOLP(DC *dc, LPPOINT point)
{
FLOAT_POINT floatPoint;
/* Perform operation with floating point */
floatPoint.x=(FLOAT)point->x;
floatPoint.y=(FLOAT)point->y;
if (!INTERNAL_DPTOLP_FLOAT(dc, &floatPoint))
return FALSE;
/* Round to integers */
point->x = GDI_ROUND(floatPoint.x);
point->y = GDI_ROUND(floatPoint.y);
return TRUE;
}
/* Performs a world-to-viewport transformation on the specified point (which
* is in integer format).
*/
static inline void INTERNAL_LPTODP(DC *dc, LPPOINT point)
{
FLOAT_POINT floatPoint;
/* Perform operation with floating point */
floatPoint.x=(FLOAT)point->x;
floatPoint.y=(FLOAT)point->y;
INTERNAL_LPTODP_FLOAT(dc, &floatPoint);
/* Round to integers */
point->x = GDI_ROUND(floatPoint.x);
point->y = GDI_ROUND(floatPoint.y);
}
#endif
#define MulDiv( x, y, z ) EngMulDiv( x, y, z )
#define XDPTOLP(dc,x) \
(MulDiv(((x)-(dc)->vportOrgX), (dc)->wndExtX, (dc)->vportExtX) + (dc)->wndOrgX)
#define YDPTOLP(dc,y) \
(MulDiv(((y)-(dc)->vportOrgY), (dc)->wndExtY, (dc)->vportExtY) + (dc)->wndOrgY)
#define XLPTODP(dc,x) \
(MulDiv(((x)-(dc)->wndOrgX), (dc)->vportExtX, (dc)->wndExtX) + (dc)->vportOrgX)
#define YLPTODP(dc,y) \
(MulDiv(((y)-(dc)->wndOrgY), (dc)->vportExtY, (dc)->wndExtY) + (dc)->vportOrgY)
/* Device <-> logical size conversion */
#define XDSTOLS(dc,x) \
MulDiv((x), (dc)->wndExtX, (dc)->vportExtX)
#define YDSTOLS(dc,y) \
MulDiv((y), (dc)->wndExtY, (dc)->vportExtY)
#define XLSTODS(dc,x) \
MulDiv((x), (dc)->vportExtX, (dc)->wndExtX)
#define YLSTODS(dc,y) \
MulDiv((y), (dc)->vportExtY, (dc)->wndExtY)
#endif

193
reactos/include/win32k/gdiobj.h → reactos/subsys/win32k/include/gdiobj.h
View file

@ -1,125 +1,68 @@
/*
* GDI object common header definition
*
*/
#ifndef __WIN32K_GDIOBJ_H
#define __WIN32K_GDIOBJ_H
/* base address where the handle table is mapped to */
#define GDI_HANDLE_TABLE_BASE_ADDRESS (0x400000)
/* gdi handle table can hold 0x4000 handles */
#define GDI_HANDLE_COUNT 0x4000
#define GDI_GLOBAL_PROCESS (0x0)
#define GDI_HANDLE_INDEX_MASK (GDI_HANDLE_COUNT - 1)
#define GDI_HANDLE_TYPE_MASK 0x007f0000
#define GDI_HANDLE_STOCK_MASK 0x00800000
#define GDI_HANDLE_REUSE_MASK 0xff000000
#define GDI_HANDLE_REUSECNT_SHIFT 24
#define GDI_HANDLE_CREATE(i, t) ((HANDLE)(((i) & GDI_HANDLE_INDEX_MASK) | ((t) & GDI_HANDLE_TYPE_MASK)))
#define GDI_HANDLE_GET_INDEX(h) (((ULONG_PTR)(h)) & GDI_HANDLE_INDEX_MASK)
#define GDI_HANDLE_GET_TYPE(h) (((ULONG_PTR)(h)) & GDI_HANDLE_TYPE_MASK)
#define GDI_HANDLE_IS_TYPE(h, t) ((t) == (((ULONG_PTR)(h)) & GDI_HANDLE_TYPE_MASK))
#define GDI_HANDLE_IS_STOCKOBJ(h) (0 != (((ULONG_PTR)(h)) & GDI_HANDLE_STOCK_MASK))
#define GDI_HANDLE_SET_STOCKOBJ(h) ((h) = (HANDLE)(((ULONG_PTR)(h)) | GDI_HANDLE_STOCK_MASK))
/*! \defgroup GDI object types
*
* GDI object types
*
*/
/*@{*/
#define GDI_OBJECT_TYPE_DC 0x00010000
#define GDI_OBJECT_TYPE_REGION 0x00040000
#define GDI_OBJECT_TYPE_BITMAP 0x00050000
#define GDI_OBJECT_TYPE_PALETTE 0x00080000
#define GDI_OBJECT_TYPE_FONT 0x000a0000
#define GDI_OBJECT_TYPE_BRUSH 0x00100000
#define GDI_OBJECT_TYPE_EMF 0x00210000
#define GDI_OBJECT_TYPE_PEN 0x00300000
#define GDI_OBJECT_TYPE_EXTPEN 0x00500000
/* Following object types made up for ROS */
#define GDI_OBJECT_TYPE_METADC 0x00710000
#define GDI_OBJECT_TYPE_METAFILE 0x00720000
#define GDI_OBJECT_TYPE_ENHMETAFILE 0x00730000
#define GDI_OBJECT_TYPE_ENHMETADC 0x00740000
#define GDI_OBJECT_TYPE_MEMDC 0x00750000
#define GDI_OBJECT_TYPE_DCE 0x00770000
#define GDI_OBJECT_TYPE_DONTCARE 0x007f0000
/** Not really an object type. Forces GDI_FreeObj to be silent. */
#define GDI_OBJECT_TYPE_SILENT 0x80000000
/*@}*/
typedef PVOID PGDIOBJ;
#ifndef NTOS_MODE_USER
typedef BOOL (INTERNAL_CALL *GDICLEANUPPROC)(PVOID ObjectBody);
#endif
/*!
* GDI object header. This is a part of any GDI object
*/
typedef struct _GDIOBJHDR
{
#ifdef NTOS_MODE_USER
PVOID LockingThread;
#else
PETHREAD LockingThread; /* only assigned if a thread is holding the lock! */
#endif
ULONG Locks;
#ifdef GDI_DEBUG
const char* createdfile;
int createdline;
const char* lockfile;
int lockline;
#endif
} GDIOBJHDR, *PGDIOBJHDR;
#ifndef NTOS_MODE_USER
BOOL INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle);
void INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner);
void INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo);
BOOL INTERNAL_CALL GDIOBJ_ConvertToStockObj(HGDIOBJ *hObj);
VOID INTERNAL_CALL GDIOBJ_UnlockObjByPtr(PGDIOBJ Object);
#define GDIOBJ_GetObjectType(Handle) \
GDI_HANDLE_GET_TYPE(Handle)
#ifdef GDI_DEBUG
/* a couple macros for debugging GDIOBJ locking */
#define GDIOBJ_AllocObj(ty) GDIOBJ_AllocObjDbg(__FILE__,__LINE__,ty)
#define GDIOBJ_FreeObj(obj,ty) GDIOBJ_FreeObjDbg(__FILE__,__LINE__,obj,ty)
#define GDIOBJ_LockObj(obj,ty) GDIOBJ_LockObjDbg(__FILE__,__LINE__,obj,ty)
#define GDIOBJ_ShareLockObj(obj,ty) GDIOBJ_ShareLockObjDbg(__FILE__,__LINE__,obj,ty)
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObjDbg(const char* file, int line, ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_LockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
#else /* !GDI_DEBUG */
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObj(ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObj (HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_LockObj (HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ObjectType);
#endif /* GDI_DEBUG */
PVOID INTERNAL_CALL GDI_MapHandleTable(PEPROCESS Process);
#endif
#define GDIOBJFLAG_DEFAULT (0x0)
#define GDIOBJFLAG_IGNOREPID (0x1)
#define GDIOBJFLAG_IGNORELOCK (0x2)
#endif
/*
* GDI object common header definition
*
*/
#ifndef __WIN32K_GDIOBJ_H
#define __WIN32K_GDIOBJ_H
/* Public GDI Object/Handle definitions */
#include <win32k/ntgdihdl.h>
typedef PVOID PGDIOBJ;
typedef BOOL (INTERNAL_CALL *GDICLEANUPPROC)(PVOID ObjectBody);
/*!
* GDI object header. This is a part of any GDI object
*/
typedef struct _GDIOBJHDR
{
PETHREAD LockingThread; /* only assigned if a thread is holding the lock! */
ULONG Locks;
#ifdef GDI_DEBUG
const char* createdfile;
int createdline;
const char* lockfile;
int lockline;
#endif
} GDIOBJHDR, *PGDIOBJHDR;
BOOL INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle);
void INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner);
void INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo);
BOOL INTERNAL_CALL GDIOBJ_ConvertToStockObj(HGDIOBJ *hObj);
VOID INTERNAL_CALL GDIOBJ_UnlockObjByPtr(PGDIOBJ Object);
#define GDIOBJ_GetObjectType(Handle) \
GDI_HANDLE_GET_TYPE(Handle)
#ifdef GDI_DEBUG
/* a couple macros for debugging GDIOBJ locking */
#define GDIOBJ_AllocObj(ty) GDIOBJ_AllocObjDbg(__FILE__,__LINE__,ty)
#define GDIOBJ_FreeObj(obj,ty) GDIOBJ_FreeObjDbg(__FILE__,__LINE__,obj,ty)
#define GDIOBJ_LockObj(obj,ty) GDIOBJ_LockObjDbg(__FILE__,__LINE__,obj,ty)
#define GDIOBJ_ShareLockObj(obj,ty) GDIOBJ_ShareLockObjDbg(__FILE__,__LINE__,obj,ty)
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObjDbg(const char* file, int line, ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_LockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
#else /* !GDI_DEBUG */
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObj(ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObj (HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_LockObj (HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ObjectType);
#endif /* GDI_DEBUG */
PVOID INTERNAL_CALL GDI_MapHandleTable(PEPROCESS Process);
#define GDIOBJFLAG_DEFAULT (0x0)
#define GDIOBJFLAG_IGNOREPID (0x1)
#define GDIOBJFLAG_IGNORELOCK (0x2)
#endif

2
reactos/subsys/win32k/include/intgdi.h
View file

@ -1,6 +1,8 @@
#ifndef _WIN32K_INTGDI_H
#define _WIN32K_INTGDI_H
#include "region.h"
/* Brush functions */
XLATEOBJ* FASTCALL

9
reactos/subsys/win32k/include/menu.h
View file

@ -1,8 +1,6 @@
#ifndef _WIN32K_MENU_H
#define _WIN32K_MENU_H
#include <win32k/menu.h>
#define IS_ATOM(x) \
(((ULONG_PTR)(x) > 0x0) && ((ULONG_PTR)(x) < 0x10000))
@ -38,6 +36,13 @@ typedef struct _MENU_OBJECT
BOOL RtoL;
} MENU_OBJECT, *PMENU_OBJECT;
typedef struct _SETMENUITEMRECT
{
UINT uItem;
BOOL fByPosition;
RECT rcRect;
} SETMENUITEMRECT, *PSETMENUITEMRECT;
PMENU_OBJECT FASTCALL
IntGetMenuObject(HMENU hMenu);

30
reactos/include/win32k/misc.h → reactos/subsys/win32k/include/misc.h
View file

@ -1,17 +1,13 @@
#ifndef __WIN32K_MISC_H
#define __WIN32K_MISC_H
#ifndef NTOS_MODE_USER
/* W32PROCESS flags */
#define W32PF_NOWINDOWGHOSTING (0x0001)
#define W32PF_MANUALGUICHECK (0x0002)
#define W32PF_CREATEDWINORDC (0x0004)
VOID
FASTCALL
DestroyThreadWindows(struct _ETHREAD *Thread);
#endif
#endif /* __WIN32K_MISC_H */
#ifndef __WIN32K_MISC_H
#define __WIN32K_MISC_H
/* W32PROCESS flags */
#define W32PF_NOWINDOWGHOSTING (0x0001)
#define W32PF_MANUALGUICHECK (0x0002)
#define W32PF_CREATEDWINORDC (0x0004)
VOID
FASTCALL
DestroyThreadWindows(struct _ETHREAD *Thread);
#endif /* __WIN32K_MISC_H */

6
reactos/subsys/win32k/include/object.h
View file

@ -1,9 +1,9 @@
#ifndef _WIN32K_OBJECT_H
#define _WIN32K_OBJECT_H
#include <win32k/gdiobj.h>
#include <win32k/bitmaps.h>
#include <win32k/pen.h>
#include "gdiobj.h"
#include "bitmaps.h"
#include "pen.h"
#define FIRST_USER_HANDLE 0x0020 /* first possible value for low word of user handle */
#define LAST_USER_HANDLE 0xffef /* last possible value for low word of user handle */

2
reactos/subsys/win32k/include/path.h
View file

@ -1,6 +1,8 @@
#ifndef _WIN32K_PATH_H
#define _WIN32K_PATH_H
#define PATH_IsPathOpen(path) ((path).state==PATH_Open)
BOOL FASTCALL PATH_Arc (PDC dc, INT x1, INT y1, INT x2, INT y2, INT xStart, INT yStart, INT xEnd, INT yEnd);
BOOL FASTCALL PATH_AssignGdiPath (GdiPath *pPathDest, const GdiPath *pPathSrc);
VOID FASTCALL PATH_DestroyGdiPath (GdiPath *pPath);

46
reactos/include/win32k/pen.h → reactos/subsys/win32k/include/pen.h
View file

@ -1,32 +1,14 @@
#ifndef __WIN32K_PEN_H
#define __WIN32K_PEN_H
#include <win32k/gdiobj.h>
#include <win32k/brush.h>
/* Internal interface */
#define PENOBJ_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDI_OBJECT_TYPE_PEN))
#define PENOBJ_FreePen(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN)
#define PENOBJ_LockPen(hBMObj) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN))
#define PENOBJ_UnlockPen(pPenObj) GDIOBJ_UnlockObjByPtr(pPenObj)
HPEN STDCALL
NtGdiCreatePen(
INT PenStyle,
INT Width,
COLORREF Color);
HPEN STDCALL
NtGdiCreatePenIndirect(
CONST PLOGPEN LogBrush);
HPEN STDCALL
NtGdiExtCreatePen(
DWORD PenStyle,
DWORD Width,
CONST LOGBRUSH *LogBrush,
DWORD StyleCount,
CONST DWORD *Style);
#endif
#ifndef __WIN32K_PEN_H
#define __WIN32K_PEN_H
#include "gdiobj.h"
#include "brush.h"
/* Internal interface */
#define PENOBJ_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDI_OBJECT_TYPE_PEN))
#define PENOBJ_FreePen(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN)
#define PENOBJ_LockPen(hBMObj) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN))
#define PENOBJ_UnlockPen(pPenObj) GDIOBJ_UnlockObjByPtr(pPenObj)
#endif

21
reactos/subsys/win32k/include/region.h Normal file
View file

@ -0,0 +1,21 @@
#ifndef __WIN32K_REGION_H
#define __WIN32K_REGION_H
#include "gdiobj.h"
/* Internal region data. Can't use RGNDATA structure because buffer is allocated statically */
typedef struct _ROSRGNDATA {
RGNDATAHEADER rdh;
PRECT Buffer;
} ROSRGNDATA, *PROSRGNDATA, *LPROSRGNDATA;
#define RGNDATA_FreeRgn(hRgn) GDIOBJ_FreeObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION)
#define RGNDATA_LockRgn(hRgn) ((PROSRGNDATA)GDIOBJ_LockObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION))
#define RGNDATA_UnlockRgn(pRgn) GDIOBJ_UnlockObjByPtr(pRgn)
HRGN FASTCALL RGNDATA_AllocRgn(INT n);
BOOL INTERNAL_CALL RGNDATA_Cleanup(PVOID ObjectBody);
#endif

18
reactos/subsys/win32k/include/text.h
View file

@ -1,6 +1,24 @@
#ifndef _WIN32K_TEXT_H
#define _WIN32K_TEXT_H
/* GDI logical font object */
typedef struct
{
LOGFONTW logfont;
FONTOBJ *Font;
BOOLEAN Initialized; /* Don't reinitialize for each DC */
} TEXTOBJ, *PTEXTOBJ;
/* Internal interface */
#define TEXTOBJ_AllocText() \
((HFONT) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_FONT))
#define TEXTOBJ_FreeText(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT)
#define TEXTOBJ_LockText(hBMObj) ((PTEXTOBJ) GDIOBJ_LockObj ((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT))
#define TEXTOBJ_UnlockText(pBMObj) GDIOBJ_UnlockObjByPtr (pBMObj)
NTSTATUS FASTCALL TextIntRealizeFont(HFONT FontHandle);
NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont);
BOOL FASTCALL InitFontSupport(VOID);
BOOL FASTCALL IntIsFontRenderingEnabled(VOID);
BOOL FASTCALL IntIsFontRenderingEnabled(VOID);

7
reactos/subsys/win32k/include/win32k.h
View file

@ -1,4 +1,4 @@
/*
t/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Graphics Subsystem
* FILE: subsys/win32k/include/win32k.h
@ -9,6 +9,8 @@
/* INCLUDES ******************************************************************/
#ifndef __WIN32K_H
#define __WIN32K_H
#define INTERNAL_CALL NTAPI
/* Internal Win32k Headers */
#include <include/ntuser.h>
#include <include/win32.h>
@ -59,6 +61,9 @@
#include <include/winpos.h>
#include <include/winsta.h>
#include <include/mmcopy.h>
#include <include/misc.h>
#include <include/coord.h>
#include <include/gdifloat.h>
#include <eng/objects.h>
#include <eng/misc.h>
#include <dib/dib.h>

1
reactos/subsys/win32k/main/dllmain.c
View file

@ -22,7 +22,6 @@
*/
#include <w32k.h>
#include <win32k/ntddraw.h>
#include <include/napi.h>
#define NDEBUG

12
reactos/subsys/win32k/ntddraw/stubs.c
View file

@ -16,11 +16,11 @@
BOOL STDCALL NtGdiD3dContextCreate(
DWORD STDCALL NtGdiD3dContextCreate(
HANDLE hDirectDrawLocal,
HANDLE hSurfColor,
HANDLE hSurfZ,
D3DNTHAL_CONTEXTCREATEDATA *pdcci
LPD3DNTHAL_CONTEXTCREATEDATA pdcci
)
{
UNIMPLEMENTED
@ -37,7 +37,7 @@ DWORD STDCALL NtGdiD3dContextDestroy(
return 0;
}
DWORD STDCALL NtGdiD3dContextDestroyAll(VOID)
DWORD STDCALL NtGdiD3dContextDestroyAll(LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad)
{
/* This entry point is not supported on NT5 and ROS */
UNIMPLEMENTED
@ -226,7 +226,7 @@ DWORD STDCALL NtGdiDdGetDriverState(
return 0;
}
DWORD STDCALL NtGdiDdGetDxHandle(
HANDLE STDCALL NtGdiDdGetDxHandle(
HANDLE hDirectDraw,
HANDLE hSurface,
BOOL bRelease
@ -383,7 +383,9 @@ DWORD STDCALL NtGdiDdUnlockD3D(
DWORD STDCALL NtGdiDdAlphaBlt(VOID)
DWORD STDCALL NtGdiDdAlphaBlt(IN HANDLE hSurfaceDest,
IN OPTIONAL HANDLE hSurfaceSrc,
IN OUT PDD_BLTDATA puBltData)
{
UNIMPLEMENTED

12
reactos/subsys/win32k/ntuser/cursoricon.c
View file

@ -1285,13 +1285,13 @@ DoStretchBlt(HDC DcDest, int XDest, int YDest, int WidthDest, int HeightDest,
if (WidthDest == WidthSrc && HeightDest == HeightSrc)
{
NtGdiBitBlt(DcDest, XDest, YDest, WidthDest, HeightDest,
DcSrc, XSrc, YSrc, Rop3);
DcSrc, XSrc, YSrc, Rop3, 0, 0);
}
else if (SRCCOPY == Rop3)
{
NtGdiStretchBlt(DcDest, XDest, YDest, WidthDest, HeightDest,
DcSrc, XSrc, YSrc, WidthSrc, HeightSrc,
Rop3);
Rop3, 0);
}
else
{
@ -1326,9 +1326,9 @@ DoStretchBlt(HDC DcDest, int XDest, int YDest, int WidthDest, int HeightDest,
}
if (! NtGdiStretchBlt(DcStretched, 0, 0, WidthDest, HeightDest,
DcSrc, XSrc, YSrc, WidthSrc, HeightSrc,
SRCCOPY) ||
SRCCOPY, 0) ||
! NtGdiBitBlt(DcDest, XDest, YDest, WidthDest, HeightDest,
DcStretched, 0, 0, Rop3))
DcStretched, 0, 0, Rop3, 0, 0))
{
DPRINT1("Failed to blt\n");
}
@ -1342,7 +1342,7 @@ DoStretchBlt(HDC DcDest, int XDest, int YDest, int WidthDest, int HeightDest,
DcSrc, XSrc, YSrc, WidthSrc, HeightSrc, Rop3, Color) \
NtGdiStretchBlt((DcDest), (XDest), (YDest), (WidthDest), (HeightDest), \
(DcSrc), (XSrc), (YSrc), (WidthSrc), (HeightSrc), \
(Rop3))
(Rop3), 0)
#endif /* STRETCH_CAN_SRCCOPY_ONLY */
/*
@ -1495,7 +1495,7 @@ NtUserDrawIconEx(
}
if(DoFlickerFree)
NtGdiBitBlt(hdc, xLeft, yTop, cxWidth, cyHeight, hdcOff, 0, 0, SRCCOPY);
NtGdiBitBlt(hdc, xLeft, yTop, cxWidth, cyHeight, hdcOff, 0, 0, SRCCOPY, 0, 0);
NtGdiSetTextColor(hdcOff, oldFg);
NtGdiSetBkColor(hdcOff, oldBg);

11
reactos/subsys/win32k/ntuser/desktop.c
View file

@ -1281,7 +1281,8 @@ NtUserPaintDesktop(HDC hDC)
0,
WinSta->cxWallpaper,
WinSta->cyWallpaper,
SRCCOPY);
SRCCOPY,
0);
}
else if (WinSta->WallpaperMode == wmTile)
{
@ -1298,7 +1299,9 @@ NtUserPaintDesktop(HDC hDC)
hWallpaperDC,
0,
0,
SRCCOPY);
SRCCOPY,
0,
0);
}
}
}
@ -1312,7 +1315,9 @@ NtUserPaintDesktop(HDC hDC)
hWallpaperDC,
0,
0,
SRCCOPY);
SRCCOPY,
0,
0);
}
NtGdiSelectObject(hWallpaperDC, hOldBitmap);
NtGdiDeleteDC(hWallpaperDC);

2
reactos/subsys/win32k/ntuser/menu.c
View file

@ -322,7 +322,7 @@ IntCreateMenu(PHANDLE Handle, BOOL IsMenuBar)
Menu->MenuInfo.dwStyle = 0; /* FIXME */
Menu->MenuInfo.cyMax = 0; /* default */
Menu->MenuInfo.hbrBack =
NtGdiCreateSolidBrush(RGB(192, 192, 192)); /* FIXME: default background color */
NtGdiCreateSolidBrush(RGB(192, 192, 192), 0); /* FIXME: default background color */
Menu->MenuInfo.dwContextHelpID = 0; /* default */
Menu->MenuInfo.dwMenuData = 0; /* default */
Menu->MenuInfo.Self = *Handle;

2
reactos/subsys/win32k/ntuser/painting.c
View file

@ -1132,7 +1132,7 @@ UserScrollDC(HDC hDC, INT dx, INT dy, const RECT *lprcScroll,
if (!NtGdiBitBlt(hDC, rDst_lp.left, rDst_lp.top, rDst_lp.right - rDst_lp.left,
rDst_lp.bottom - rDst_lp.top, hDC, rSrc_lp.left, rSrc_lp.top,
SRCCOPY))
SRCCOPY, 0, 0))
return FALSE;
}
else

2
reactos/subsys/win32k/ntuser/winpos.c
View file

@ -1192,7 +1192,7 @@ co_WinPosSetWindowPos(
CopyRect.left, CopyRect.top, CopyRect.right - CopyRect.left,
CopyRect.bottom - CopyRect.top, Dc,
CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
CopyRect.top + (OldWindowRect.top - NewWindowRect.top), SRCCOPY);
CopyRect.top + (OldWindowRect.top - NewWindowRect.top), SRCCOPY, 0, 0);
UserReleaseDC(Window, Dc, FALSE);
IntValidateParent(Window, CopyRgn);
NtGdiOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);

81
reactos/subsys/win32k/objects/bitmaps.c
View file

@ -41,7 +41,9 @@ NtGdiBitBlt(
HDC hDCSrc,
INT XSrc,
INT YSrc,
DWORD ROP)
DWORD ROP,
IN DWORD crBackColor,
IN FLONG fl)
{
PDC DCDest = NULL;
PDC DCSrc = NULL;
@ -457,7 +459,7 @@ NtGdiCreateBitmap(
INT Height,
UINT Planes,
UINT BitsPixel,
CONST VOID *Bits)
IN OPTIONAL LPBYTE Bits)
{
BITMAP BM;
@ -467,7 +469,7 @@ NtGdiCreateBitmap(
BM.bmWidthBytes = BITMAPOBJ_GetWidthBytes(Width, Planes * BitsPixel);
BM.bmPlanes = Planes;
BM.bmBitsPixel = BitsPixel;
BM.bmBits = (LPVOID) Bits;
BM.bmBits = Bits;
return IntCreateBitmapIndirect(&BM);
}
@ -712,7 +714,7 @@ NtGdiGetPixel(HDC hDC, INT XPos, INT YPos)
{
PBITMAPOBJ bmpobj;
NtGdiBitBlt ( hDCTmp, 0, 0, 1, 1, hDC, XPos, YPos, SRCCOPY );
NtGdiBitBlt ( hDCTmp, 0, 0, 1, 1, hDC, XPos, YPos, SRCCOPY, 0, 0 );
NtGdiSelectObject ( hDCTmp, hBmpOld );
// our bitmap is no longer selected, so we can access it's stuff...
@ -756,7 +758,8 @@ NtGdiMaskBlt (
HDC hdcDest, INT nXDest, INT nYDest,
INT nWidth, INT nHeight, HDC hdcSrc,
INT nXSrc, INT nYSrc, HBITMAP hbmMask,
INT xMask, INT yMask, DWORD dwRop)
INT xMask, INT yMask, DWORD dwRop,
IN DWORD crBackColor)
{
HBITMAP hOldMaskBitmap, hBitmap2, hOldBitmap2, hBitmap3, hOldBitmap3;
HDC hDCMask, hDC1, hDC2;
@ -893,7 +896,7 @@ NtGdiMaskBlt (
};
if (!hbmMask)
return NtGdiBitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, FRGND_ROP3(dwRop));
return NtGdiBitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, FRGND_ROP3(dwRop), 0, 0);
/* 1. make mask bitmap's dc */
hDCMask = NtGdiCreateCompatibleDC(hdcDest);
@ -907,9 +910,9 @@ NtGdiMaskBlt (
hOldBitmap2 = (HBITMAP)NtGdiSelectObject(hDC1, hBitmap2);
/* 2.2 draw dest bitmap and mask */
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, SRCCOPY);
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hdcDest, nXDest, nYDest, BKGND_ROP3(dwRop));
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hDCMask, xMask, yMask, DSTERASE);
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, SRCCOPY, 0, 0);
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hdcDest, nXDest, nYDest, BKGND_ROP3(dwRop), 0, 0);
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hDCMask, xMask, yMask, DSTERASE, 0, 0);
/* 3. make masked Foreground bitmap */
@ -919,13 +922,13 @@ NtGdiMaskBlt (
hOldBitmap3 = (HBITMAP)NtGdiSelectObject(hDC2, hBitmap3);
/* 3.2 draw src bitmap and mask */
NtGdiBitBlt(hDC2, 0, 0, nWidth, nHeight, hdcDest, nXDest, nYDest, SRCCOPY);
NtGdiBitBlt(hDC2, 0, 0, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, FRGND_ROP3(dwRop));
NtGdiBitBlt(hDC2, 0, 0, nWidth, nHeight, hDCMask, xMask, yMask, SRCAND);
NtGdiBitBlt(hDC2, 0, 0, nWidth, nHeight, hdcDest, nXDest, nYDest, SRCCOPY, 0, 0);
NtGdiBitBlt(hDC2, 0, 0, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, FRGND_ROP3(dwRop), 0,0);
NtGdiBitBlt(hDC2, 0, 0, nWidth, nHeight, hDCMask, xMask, yMask, SRCAND, 0, 0);
/* 4. combine two bitmap and copy it to hdcDest */
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hDC2, 0, 0, SRCPAINT);
NtGdiBitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hDC1, 0, 0, SRCCOPY);
NtGdiBitBlt(hDC1, 0, 0, nWidth, nHeight, hDC2, 0, 0, SRCPAINT, 0, 0);
NtGdiBitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hDC1, 0, 0, SRCCOPY, 0, 0);
/* 5. restore all object */
NtGdiSelectObject(hDCMask, hOldMaskBitmap);
@ -943,18 +946,20 @@ NtGdiMaskBlt (
return TRUE;
}
BOOL STDCALL
BOOL
APIENTRY
NtGdiPlgBlt(
HDC hDCDest,
CONST POINT *Point,
HDC hDCSrc,
INT XSrc,
INT YSrc,
INT Width,
INT Height,
HBITMAP hMaskBitmap,
INT xMask,
INT yMask)
IN HDC hdcTrg,
IN LPPOINT pptlTrg,
IN HDC hdcSrc,
IN INT xSrc,
IN INT ySrc,
IN INT cxSrc,
IN INT cySrc,
IN HBITMAP hbmMask,
IN INT xMask,
IN INT yMask,
IN DWORD crBackColor)
{
UNIMPLEMENTED;
return FALSE;
@ -964,7 +969,7 @@ LONG STDCALL
NtGdiSetBitmapBits(
HBITMAP hBitmap,
DWORD Bytes,
CONST VOID *Bits)
IN PBYTE Bits)
{
LONG height, ret;
PBITMAPOBJ bmp;
@ -1072,7 +1077,7 @@ NtGdiSetPixelV(
INT Y,
COLORREF Color)
{
HBRUSH NewBrush = NtGdiCreateSolidBrush(Color);
HBRUSH NewBrush = NtGdiCreateSolidBrush(Color, NULL);
HGDIOBJ OldBrush;
if (NewBrush == NULL)
@ -1101,7 +1106,8 @@ NtGdiStretchBlt(
INT YOriginSrc,
INT WidthSrc,
INT HeightSrc,
DWORD ROP)
DWORD ROP,
IN DWORD dwBackColor)
{
PDC DCDest = NULL;
PDC DCSrc = NULL;
@ -1323,16 +1329,17 @@ failed:
BOOL STDCALL
NtGdiAlphaBlend(
HDC hDCDest,
INT XOriginDest,
INT YOriginDest,
INT WidthDest,
INT HeightDest,
LONG XOriginDest,
LONG YOriginDest,
LONG WidthDest,
LONG HeightDest,
HDC hDCSrc,
INT XOriginSrc,
INT YOriginSrc,
INT WidthSrc,
INT HeightSrc,
BLENDFUNCTION BlendFunc)
LONG XOriginSrc,
LONG YOriginSrc,
LONG WidthSrc,
LONG HeightSrc,
BLENDFUNCTION BlendFunc,
IN HANDLE hcmXform)
{
PDC DCDest = NULL;
PDC DCSrc = NULL;

23
reactos/subsys/win32k/objects/brush.c
View file

@ -318,7 +318,7 @@ IntGdiCreateHatchBrush(
return 0;
}
hPattern = NtGdiCreateBitmap(8, 8, 1, 1, HatchBrushes[Style]);
hPattern = NtGdiCreateBitmap(8, 8, 1, 1, (LPBYTE)HatchBrushes[Style]);
if (hPattern == NULL)
{
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
@ -557,10 +557,12 @@ IntGdiPolyPatBlt(
HBRUSH STDCALL
NtGdiCreateDIBBrush(
CONST BITMAPINFO *BitmapInfoAndData,
UINT ColorSpec,
UINT BitmapInfoSize,
CONST VOID *PackedDIB)
IN PVOID BitmapInfoAndData,
IN FLONG ColorSpec,
IN UINT BitmapInfoSize,
IN BOOL b8X8,
IN BOOL bPen,
IN PVOID PackedDIB)
{
BITMAPINFO *SafeBitmapInfoAndData;
NTSTATUS Status = STATUS_SUCCESS;
@ -619,7 +621,8 @@ NtGdiCreatePatternBrush(
}
HBRUSH STDCALL
NtGdiCreateSolidBrush(COLORREF Color)
NtGdiCreateSolidBrush(COLORREF Color,
IN OPTIONAL HBRUSH hbr)
{
return IntGdiCreateSolidBrush(Color);
}
@ -682,9 +685,9 @@ BOOL STDCALL
NtGdiPolyPatBlt(
HDC hDC,
DWORD dwRop,
PPATRECT pRects,
INT cRects,
ULONG Reserved)
IN PPOLYPATBLT pRects,
IN DWORD cRects,
IN DWORD Mode)
{
PPATRECT rb = NULL;
NTSTATUS Status = STATUS_SUCCESS;
@ -721,7 +724,7 @@ NtGdiPolyPatBlt(
}
}
Ret = IntGdiPolyPatBlt(hDC, dwRop, pRects, cRects, Reserved);
Ret = IntGdiPolyPatBlt(hDC, dwRop, (PPATRECT)pRects, cRects, Mode);
if (cRects > 0)
ExFreePool(rb);

34
reactos/subsys/win32k/objects/dc.c
View file

@ -1137,21 +1137,25 @@ NtGdiDeleteDC(HDC DCHandle)
return TRUE;
}
INT STDCALL
NtGdiDrawEscape(HDC hDC,
INT nEscape,
INT cbInput,
LPCSTR lpszInData)
INT
APIENTRY
NtGdiDrawEscape(
IN HDC hdc,
IN INT iEsc,
IN INT cjIn,
IN OPTIONAL LPSTR pjIn)
{
UNIMPLEMENTED;
return 0;
}
INT STDCALL
NtGdiEnumObjects(HDC hDC,
INT ObjectType,
GOBJENUMPROC ObjectFunc,
LPARAM lParam)
ULONG
APIENTRY
NtGdiEnumObjects(
IN HDC hdc,
IN INT iObjectType,
IN ULONG cjBuf,
OUT OPTIONAL PVOID pvBuf)
{
UNIMPLEMENTED;
return 0;
@ -1915,8 +1919,14 @@ DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY, POINT, x, y )
DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY, SIZE, cx, cy )
DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY, POINT, x, y )
HDC STDCALL
NtGdiResetDC(HDC hDC, CONST DEVMODEW *InitData)
BOOL
APIENTRY
NtGdiResetDC(
IN HDC hdc,
IN LPDEVMODEW pdm,
OUT PBOOL pbBanding,
IN OPTIONAL VOID *pDriverInfo2,
OUT VOID *ppUMdhpdev)
{
UNIMPLEMENTED;
return 0;

25
reactos/subsys/win32k/objects/dib.c
View file

@ -557,11 +557,11 @@ INT STDCALL NtGdiStretchDIBits(HDC hDC,
/* copy existing bitmap from destination dc */
if (SrcWidth == DestWidth && SrcHeight == DestHeight)
NtGdiBitBlt(hdcMem, XSrc, abs(BitsInfo->bmiHeader.biHeight) - SrcHeight - YSrc,
SrcWidth, SrcHeight, hDC, XDest, YDest, ROP);
SrcWidth, SrcHeight, hDC, XDest, YDest, ROP, 0, 0);
else
NtGdiStretchBlt(hdcMem, XSrc, abs(BitsInfo->bmiHeader.biHeight) - SrcHeight - YSrc,
SrcWidth, SrcHeight, hDC, XDest, YDest, DestWidth, DestHeight,
ROP);
ROP, 0);
}
NtGdiSetDIBits(hdcMem, hBitmap, 0, BitsInfo->bmiHeader.biHeight, Bits,
@ -572,11 +572,11 @@ INT STDCALL NtGdiStretchDIBits(HDC hDC,
if (SrcWidth == DestWidth && SrcHeight == DestHeight)
NtGdiBitBlt(hDC, XDest, YDest, DestWidth, DestHeight,
hdcMem, XSrc, abs(BitsInfo->bmiHeader.biHeight) - SrcHeight - YSrc,
ROP);
ROP, 0, 0);
else
NtGdiStretchBlt(hDC, XDest, YDest, DestWidth, DestHeight,
hdcMem, XSrc, abs(BitsInfo->bmiHeader.biHeight) - SrcHeight - YSrc,
SrcWidth, SrcHeight, ROP);
SrcWidth, SrcHeight, ROP, 0);
NtGdiSelectObject(hdcMem, hOldBitmap);
NtGdiDeleteDC(hdcMem);
@ -586,8 +586,8 @@ INT STDCALL NtGdiStretchDIBits(HDC hDC,
}
LONG STDCALL NtGdiGetBitmapBits(HBITMAP hBitmap,
LONG Count,
LPVOID Bits)
ULONG Count,
OUT OPTIONAL PBYTE Bits)
{
PBITMAPOBJ bmp;
LONG height, ret;
@ -767,11 +767,14 @@ HBITMAP STDCALL NtGdiCreateDIBitmap(HDC hDc, const BITMAPINFOHEADER *Header,
}
HBITMAP STDCALL NtGdiCreateDIBSection(HDC hDC,
CONST BITMAPINFO *bmi,
UINT Usage,
VOID *Bits,
HANDLE hSection,
DWORD dwOffset)
IN OPTIONAL HANDLE hSection,
IN DWORD dwOffset,
IN LPBITMAPINFO bmi,
DWORD Usage,
IN UINT cjHeader,
IN FLONG fl,
IN ULONG_PTR dwColorSpace,
PVOID *Bits)
{
HBITMAP hbitmap = 0;
DC *dc;

18
reactos/subsys/win32k/objects/icm.c
View file

@ -44,17 +44,19 @@ NtGdiColorMatchToTarget(HDC hDC,
return FALSE;
}
HCOLORSPACE
STDCALL
NtGdiCreateColorSpace(LPLOGCOLORSPACEW LogColorSpace)
HANDLE
APIENTRY
NtGdiCreateColorSpace(
IN PLOGCOLORSPACEEXW pLogColorSpace)
{
UNIMPLEMENTED;
return 0;
}
BOOL
STDCALL
NtGdiDeleteColorSpace(HCOLORSPACE hColorSpace)
APIENTRY
NtGdiDeleteColorSpace(
IN HANDLE hColorSpace)
{
UNIMPLEMENTED;
return FALSE;
@ -112,10 +114,10 @@ NtGdiGetLogColorSpace(HCOLORSPACE hColorSpace,
return FALSE;
}
HCOLORSPACE
BOOL
STDCALL
NtGdiSetColorSpace(HDC hDC,
HCOLORSPACE hColorSpace)
NtGdiSetColorSpace(IN HDC hdc,
IN HCOLORSPACE hColorSpace)
{
UNIMPLEMENTED;
return 0;

26
reactos/subsys/win32k/objects/line.c
View file

@ -338,13 +338,14 @@ IntGdiPolyPolyline(DC *dc,
/******************************************************************************/
BOOL
STDCALL
NtGdiAngleArc(HDC hDC,
int X,
int Y,
DWORD Radius,
FLOAT StartAngle,
FLOAT SweepAngle)
APIENTRY
NtGdiAngleArc(
IN HDC hdc,
IN INT x,
IN INT y,
IN DWORD dwRadius,
IN DWORD dwStartAngle,
IN DWORD dwSweepAngle)
{
UNIMPLEMENTED;
return FALSE;
@ -725,11 +726,12 @@ NtGdiPolyBezierTo(HDC hDC,
}
BOOL
STDCALL
NtGdiPolyDraw(HDC hDC,
CONST LPPOINT pt,
CONST LPBYTE Types,
int Count)
APIENTRY
NtGdiPolyDraw(
IN HDC hdc,
IN LPPOINT ppt,
IN LPBYTE pjAttr,
IN ULONG cpt)
{
UNIMPLEMENTED;
return FALSE;

22
reactos/subsys/win32k/objects/paint.c
View file

@ -47,21 +47,23 @@ NtGdiGdiSetBatchLimit(DWORD Limit)
return 0;
}
UINT
STDCALL
NtGdiGetBoundsRect(HDC hDC,
LPRECT Bounds,
UINT Flags)
DWORD
APIENTRY
NtGdiGetBoundsRect(
IN HDC hdc,
OUT LPRECT prc,
IN DWORD f)
{
DPRINT("stub");
return DCB_RESET; /* bounding rectangle always empty */
}
UINT
STDCALL
NtGdiSetBoundsRect(HDC hDC,
CONST PRECT Bounds,
UINT Flags)
DWORD
APIENTRY
NtGdiSetBoundsRect(
IN HDC hdc,
IN LPRECT prc,
IN DWORD f)
{
DPRINT("stub");
return DCB_DISABLE; /* bounding rectangle always empty */

18
reactos/subsys/win32k/objects/path.c
View file

@ -19,7 +19,7 @@
/* $Id$ */
#include <w32k.h>
#include <win32k/float.h>
#include "math.h"
#define NDEBUG
#include <debug.h>
@ -174,9 +174,10 @@ NtGdiFlattenPath(HDC hDC)
BOOL
STDCALL
NtGdiGetMiterLimit(HDC hDC,
PFLOAT Limit)
APIENTRY
NtGdiGetMiterLimit(
IN HDC hdc,
OUT PDWORD pdwOut)
{
UNIMPLEMENTED;
return FALSE;
@ -202,10 +203,11 @@ NtGdiPathToRegion(HDC hDC)
}
BOOL
STDCALL
NtGdiSetMiterLimit(HDC hDC,
FLOAT NewLimit,
PFLOAT OldLimit)
APIENTRY
NtGdiSetMiterLimit(
IN HDC hdc,
IN DWORD dwNew,
IN OUT OPTIONAL PDWORD pdwOut)
{
UNIMPLEMENTED;
return FALSE;

19
reactos/subsys/win32k/objects/pen.c
View file

@ -63,7 +63,7 @@ IntGdiCreatePenIndirect(PLOGPEN LogPen)
case PS_ALTERNATE:
PenObject->flAttrs |= GDIBRUSH_IS_BITMAP;
PenObject->hbmPattern = NtGdiCreateBitmap(8, 1, 1, 1, wPatternAlternate);
PenObject->hbmPattern = NtGdiCreateBitmap(8, 1, 1, 1, (LPBYTE)wPatternAlternate);
break;
default:
@ -81,7 +81,8 @@ HPEN STDCALL
NtGdiCreatePen(
INT PenStyle,
INT Width,
COLORREF Color)
COLORREF Color,
IN HBRUSH hbr)
{
LOGPEN LogPen;
@ -125,11 +126,19 @@ HPEN STDCALL
NtGdiExtCreatePen(
DWORD PenStyle,
DWORD Width,
CONST LOGBRUSH *LogBrush,
IN ULONG iBrushStyle,
IN ULONG ulColor,
IN ULONG_PTR lClientHatch,
IN ULONG_PTR lHatch,
DWORD StyleCount,
CONST DWORD *Style)
PULONG Style,
IN ULONG cjDIB,
IN BOOL bOldStylePen,
IN OPTIONAL HBRUSH hbrush)
{
/* NOTE: This is HACK! */
DPRINT1("FIXME: FIX CALLERS FIRST!\n");
KEBUGCHECK(0);
LOGPEN LogPen;
if (PenStyle & PS_USERSTYLE)
@ -137,7 +146,7 @@ NtGdiExtCreatePen(
LogPen.lopnStyle = PenStyle & PS_STYLE_MASK;
LogPen.lopnWidth.x = Width;
LogPen.lopnColor = (LogBrush != NULL) ? LogBrush->lbColor : 0;
LogPen.lopnColor = ulColor;
return IntGdiCreatePenIndirect(&LogPen);
}

15
reactos/subsys/win32k/objects/print.c
View file

@ -148,11 +148,13 @@ INT
STDCALL
NtGdiExtEscape(
HDC hDC,
IN OPTIONAL PWCHAR pDriver,
IN INT nDriver,
INT Escape,
INT InSize,
LPCSTR UnsafeInData,
OPTIONAL LPSTR UnsafeInData,
INT OutSize,
LPSTR UnsafeOutData)
OPTIONAL LPSTR UnsafeOutData)
{
PDC pDC = DC_LockDc(hDC);
LPVOID SafeInData = NULL;
@ -297,9 +299,12 @@ NtGdiSetAbortProc(HDC hDC,
}
INT
STDCALL
NtGdiStartDoc(HDC hDC,
CONST LPDOCINFOW di)
APIENTRY
NtGdiStartDoc(
IN HDC hdc,
IN DOCINFOW *pdi,
OUT BOOL *pbBanding,
IN INT iJob)
{
UNIMPLEMENTED;
return 0;

5
reactos/subsys/win32k/objects/region.c
View file

@ -115,7 +115,6 @@ SOFTWARE.
/* $Id$ */
#include <w32k.h>
#include <win32k/float.h>
#define NDEBUG
#include <debug.h>
@ -2250,9 +2249,9 @@ exit:
HRGN
STDCALL
NtGdiExtCreateRegion(CONST XFORM *Xform,
NtGdiExtCreateRegion(OPTIONAL LPXFORM Xform,
DWORD Count,
CONST RGNDATA *RgnData)
LPRGNDATA RgnData)
{
HRGN hRgn;
PROSRGNDATA Region;

42
reactos/subsys/win32k/objects/text.c
View file

@ -1554,7 +1554,7 @@ NtGdiExtTextOut(
{
goto fail;
}
hBrushFg = NtGdiCreateSolidBrush(XLATEOBJ_iXlate(XlateObj, dc->w.textColor));
hBrushFg = NtGdiCreateSolidBrush(XLATEOBJ_iXlate(XlateObj, dc->w.textColor), 0);
if ( !hBrushFg )
{
goto fail;
@ -1567,7 +1567,7 @@ NtGdiExtTextOut(
IntGdiInitBrushInstance(&BrushFgInst, BrushFg, NULL);
if ((fuOptions & ETO_OPAQUE) || dc->w.backgroundMode == OPAQUE)
{
hBrushBg = NtGdiCreateSolidBrush(XLATEOBJ_iXlate(XlateObj, dc->w.backgroundColor));
hBrushBg = NtGdiCreateSolidBrush(XLATEOBJ_iXlate(XlateObj, dc->w.backgroundColor), 0);
if ( !hBrushBg )
{
goto fail;
@ -2115,15 +2115,17 @@ NtGdiGetFontLanguageInfo(HDC hDC)
return 0;
}
DWORD
STDCALL
NtGdiGetGlyphOutline(HDC hDC,
UINT Char,
UINT Format,
LPGLYPHMETRICS gm,
DWORD Bufsize,
LPVOID Buffer,
CONST LPMAT2 mat2)
ULONG
APIENTRY
NtGdiGetGlyphOutline(
IN HDC hdc,
IN WCHAR wch,
IN UINT iFormat,
OUT LPGLYPHMETRICS pgm,
IN ULONG cjBuf,
OUT OPTIONAL PVOID pvBuf,
IN LPMAT2 pmat2,
IN BOOL bIgnoreRotation)
{
UNIMPLEMENTED;
return 0;
@ -2150,9 +2152,10 @@ NtGdiGetOutlineTextMetrics(HDC hDC,
}
BOOL
STDCALL
NtGdiGetRasterizerCaps(LPRASTERIZER_STATUS rs,
UINT Size)
APIENTRY
NtGdiGetRasterizerCaps(
OUT LPRASTERIZER_STATUS praststat,
IN ULONG cjBytes)
{
UNIMPLEMENTED;
return FALSE;
@ -2166,11 +2169,12 @@ NtGdiGetTextCharset(HDC hDC)
return 0;
}
UINT
STDCALL
NtGdiGetTextCharsetInfo(HDC hDC,
LPFONTSIGNATURE Sig,
DWORD Flags)
INT
APIENTRY
NtGdiGetTextCharsetInfo(
IN HDC hdc,
OUT OPTIONAL LPFONTSIGNATURE lpSig,
IN DWORD dwFlags)
{
UNIMPLEMENTED;
return 0;

8
reactos/subsys/win32k/objects/wingl.c
View file

@ -63,10 +63,10 @@ NtGdiGetPixelFormat(HDC hDC)
}
BOOL
STDCALL
NtGdiSetPixelFormat(HDC hDC,
INT PixelFormat,
CONST PPIXELFORMATDESCRIPTOR pfd)
APIENTRY
NtGdiSetPixelFormat(
IN HDC hdc,
IN INT ipfd)
{
UNIMPLEMENTED;
return FALSE;

16
reactos/subsys/win32k/w32k.h
View file

@ -8,11 +8,13 @@
/* INCLUDES ******************************************************************/
#define _NO_COM
/* DDK/NDK/SDK Headers */
#include <ntifs.h>
#include <ntddk.h>
#include <ntddmou.h>
#include <ntifs.h>
#include <ndk/ntndk.h>
#include <ntndk.h>
/* Win32 Headers */
/* FIXME: Defines in winbase.h that we need... */
@ -25,6 +27,7 @@ typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
#include <wingdi.h>
#include <winddi.h>
#include <winuser.h>
#include <prntfont.h>
#include <dde.h>
#include <wincon.h>
@ -40,8 +43,13 @@ typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
/* Probe and capture */
#include <reactos/probe.h>
/* External Win32K Header */
#include <win32k/win32k.h>
/* Public Win32K Headers */
#include <win32k/callback.h>
#include <win32k/ntusrtyp.h>
#include <win32k/ntuser.h>
#include <win32k/ntgdityp.h>
#include <win32k/ntgdibad.h>
#include <ntgdi.h>
/* Internal Win32K Header */
#include "include/win32k.h"

16
reactos/tools/nci/w32ksvc.db
View file

@ -8,7 +8,7 @@ NtGdiAnimatePalette 4
NtGdiArc 9
NtGdiArcTo 9
NtGdiBeginPath 1
NtGdiBitBlt 9
NtGdiBitBlt 11
NtGdiCancelDC 1
NtGdiCheckColorsInGamut 4
NtGdiChord 9
@ -27,8 +27,8 @@ NtGdiCreateCompatibleBitmap 3
NtGdiCreateCompatibleDC 1
NtGdiCreateDC 4
NtGdiCreateDIBitmap 6
NtGdiCreateDIBBrush 4
NtGdiCreateDIBSection 6
NtGdiCreateDIBBrush 6
NtGdiCreateDIBSection 9
NtGdiCreateDiscardableBitmap 3
NtGdiCreateEllipticRgn 4
NtGdiCreateEllipticRgnIndirect 1
@ -49,7 +49,7 @@ NtGdiCreateRectRgn 4
NtGdiCreateRectRgnIndirect 1
NtGdiCreateRoundRectRgn 6
NtGdiCreateScalableFontResource 4
NtGdiCreateSolidBrush 1
NtGdiCreateSolidBrush 2
NtGdiDPtoLP 3
NtGdiDeleteColorSpace 1
NtGdiDeleteDC 1
@ -124,7 +124,7 @@ NtGdiGetFontData 5
NtGdiGetFontFamilyInfo 4
NtGdiGetFontLanguageInfo 1
#NtGdiGetFontResourceInfo ?
NtGdiGetGlyphOutline 7
NtGdiGetGlyphOutline 8
#NtGdiGetGlyphOutlineWow ?
NtGdiGetGraphicsMode 1
NtGdiGetICMProfile 3
@ -208,7 +208,7 @@ NtGdiRectInRegion 2
NtGdiRectVisible 2
NtGdiRectangle 5
NtGdiRemoveFontResource 1
NtGdiResetDC 2
NtGdiResetDC 5
NtGdiResizePalette 2
NtGdiRestoreDC 2
NtGdiRoundRect 7
@ -264,9 +264,9 @@ NtGdiSetViewportOrgEx 4
NtGdiSetWindowExtEx 4
NtGdiSetWindowOrgEx 4
NtGdiSetWorldTransform 2
NtGdiStartDoc 2
NtGdiStartDoc 4
NtGdiStartPage 1
NtGdiStretchBlt 11
NtGdiStretchBlt 12
NtGdiStretchDIBits 13
NtGdiStrokeAndFillPath 1
NtGdiStrokePath 1

3624
reactos/w32api/include/ntgdi.h Normal file
View file

File diff suppressed because it is too large Load diff

14
reactos/w32api/include/wingdi.h
View file

@ -831,6 +831,8 @@ extern "C" {
#define MWT_IDENTITY 1
#define MWT_LEFTMULTIPLY 2
#define MWT_RIGHTMULTIPLY 3
#define MWT_MIN MWT_IDENTITY
#define MWT_MAX MWT_RIGHTMULTIPLY
#define OPAQUE 2
#define TRANSPARENT 1
#define BLACKONWHITE 1
@ -1352,7 +1354,7 @@ typedef struct tagCOLORADJUSTMENT {
SHORT caBrightness;
SHORT caColorfulness;
SHORT caRedGreenTint;
} COLORADJUSTMENT,*LPCOLORADJUSTMENT;
} COLORADJUSTMENT, *PCOLORADJUSTMENT, FAR *LPCOLORADJUSTMENT;
typedef struct _devicemodeA {
BYTE dmDeviceName[CCHDEVICENAME];
WORD dmSpecVersion;
@ -2701,14 +2703,14 @@ UINT WINAPI GetEnhMetaFileDescriptionA(HENHMETAFILE,UINT,LPSTR);
UINT WINAPI GetEnhMetaFileDescriptionW(HENHMETAFILE,UINT,LPWSTR);
UINT WINAPI GetEnhMetaFileHeader(HENHMETAFILE,UINT,LPENHMETAHEADER);
UINT WINAPI GetEnhMetaFilePaletteEntries(HENHMETAFILE,UINT,LPPALETTEENTRY);
UINT WINAPI GetEnhMetaFilePixelFormat(HENHMETAFILE,DWORD,CONST PIXELFORMATDESCRIPTOR*);
UINT WINAPI GetEnhMetaFilePixelFormat(HENHMETAFILE,UINT,PIXELFORMATDESCRIPTOR*);
DWORD WINAPI GetFontData(HDC,DWORD,DWORD,PVOID,DWORD);
DWORD WINAPI GetFontLanguageInfo(HDC);
DWORD WINAPI GetGlyphOutlineA(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,PVOID,const MAT2*);
DWORD WINAPI GetGlyphOutlineW(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,PVOID,const MAT2*);
int WINAPI GetGraphicsMode(HDC);
BOOL WINAPI GetICMProfileA(HDC,DWORD,LPSTR);
BOOL WINAPI GetICMProfileW(HDC,DWORD,LPWSTR);
BOOL WINAPI GetICMProfileA(HDC,LPDWORD,LPSTR);
BOOL WINAPI GetICMProfileW(HDC,LPDWORD,LPWSTR);
DWORD WINAPI GetKerningPairsA(HDC,DWORD,LPKERNINGPAIR);
DWORD WINAPI GetKerningPairsW(HDC,DWORD,LPKERNINGPAIR);
BOOL WINAPI GetLogColorSpaceA(HCOLORSPACE,LPLOGCOLORSPACEA,DWORD);
@ -2877,8 +2879,8 @@ BOOL WINAPI TextOutW(HDC,int,int,LPCWSTR,int);
BOOL WINAPI TranslateCharsetInfo(PDWORD,LPCHARSETINFO,DWORD);
BOOL WINAPI UnrealizeObject(HGDIOBJ);
BOOL WINAPI UpdateColors(HDC);
BOOL WINAPI UpdateICMRegKeyA(DWORD,DWORD,LPSTR,UINT);
BOOL WINAPI UpdateICMRegKeyW(DWORD,DWORD,LPWSTR,UINT);
BOOL WINAPI UpdateICMRegKeyA(DWORD,LPSTR,LPSTR,UINT);
BOOL WINAPI UpdateICMRegKeyW(DWORD,LPWSTR,LPWSTR,UINT);
BOOL WINAPI WidenPath(HDC);
BOOL WINAPI wglCopyContext(HGLRC,HGLRC,UINT);
HGLRC WINAPI wglCreateContext(HDC);