Added little prog. that builds the WIN32K.SYS service table

and the stubs to be used in GDI32.DLL.
Converted to __stdcall every W32k... call in WIN32K.SYS.
Fixed the entry point in GDI32.DLL.
WARNING: the thing compiles, but Jason reports it does not work as is
(he tested a preliminary stub piece of code).
Perhaps changing it (as Phillip proposes) or fixing it to make WIN32K.SYS
work the NT way is required (Hernan, are you there: I did not understand
well how the additional service tables work). Feel free to change it.

svn path=/trunk/; revision=993

reactos/Makefile

@@ -14,7 +14,7 @@ include rules.mak
 #
 # Required to run the system
 #
-COMPONENTS = iface_native ntoskrnl
+COMPONENTS = iface_native iface_additional ntoskrnl
 DLLS = ntdll kernel32 crtdll advapi32 fmifs gdi32 
 #DLLS = mingw32 user32
 SUBSYS = smss win32k
@@ -106,8 +106,20 @@ iface_native_floppy:
 
 iface_native_dist:
 
+iface_additional:
+	make -C iface/addsys
+
+iface_additional_clean:
+	make -C iface/addsys clean
+
+iface_additional_floppy:
+
+iface_additional_dist:
+
 .PHONY: iface_native iface_native_clean iface_native_floppy \
-        iface_native_dist
+        iface_native_dist \
+	iface_additional iface_additional_clean iface_additional_floppy \
+        iface_additional_dist \
 
 #
 # Device driver rules

reactos/drivers/dd/null/makefile

@@ -1,44 +1,44 @@
-# $Id: makefile,v 1.6 1999/12/04 20:58:39 ea Exp $
+# $Id: makefile,v 1.7 2000/02/20 22:52:49 ea Exp $
 #
 #
-TARGET=null
-OBJECTS= $(TARGET).o $(TARGET).coff ../../../ntoskrnl/ntoskrnl.a
+TARGETNAME=null
+OBJECTS= $(TARGETNAME).o $(TARGETNAME).coff ../../../ntoskrnl/ntoskrnl.a
 
 BASE_CFLAGS = -I../../../include
 
-all: $(TARGET).sys
+all: $(TARGETNAME).sys
 
 .phony: all
 
 clean:
-	- $(RM) $(TARGET).o
-	- $(RM) $(TARGET).coff
+	- $(RM) $(TARGETNAME).o
+	- $(RM) $(TARGETNAME).coff
 	- $(RM) junk.tmp
 	- $(RM) base.tmp
 	- $(RM) temp.exp
-	- $(RM) $(TARGET).sys
+	- $(RM) $(TARGETNAME).sys
 
 .phony: clean
 
-floppy: $(FLOPPY_DIR)/drivers/$(TARGET).sys
+floppy: $(FLOPPY_DIR)/drivers/$(TARGETNAME).sys
 
-$(FLOPPY_DIR)/drivers/$(TARGET).sys: $(TARGET).sys
+$(FLOPPY_DIR)/drivers/$(TARGETNAME).sys: $(TARGETNAME).sys
 ifeq ($(DOSCLI),yes)
-	$(CP) $(TARGET).sys $(FLOPPY_DIR)\drivers\$(TARGET).sys
+	$(CP) $(TARGETNAME).sys $(FLOPPY_DIR)\drivers\$(TARGETNAME).sys
 else
-	$(CP) $(TARGET).sys $(FLOPPY_DIR)/drivers/$(TARGET).sys
+	$(CP) $(TARGETNAME).sys $(FLOPPY_DIR)/drivers/$(TARGETNAME).sys
 endif
 
-dist: ../../../$(DIST_DIR)/drivers/$(TARGET).sys
+dist: ../../../$(DIST_DIR)/drivers/$(TARGETNAME).sys
 
-../../../$(DIST_DIR)/drivers/$(TARGET).sys: $(TARGET).sys
+../../../$(DIST_DIR)/drivers/$(TARGETNAME).sys: $(TARGETNAME).sys
 ifeq ($(DOSCLI),yes)
-	$(CP) $(TARGET).sys ..\..\..\$(DIST_DIR)\drivers\$(TARGET).sys
+	$(CP) $(TARGETNAME).sys ..\..\..\$(DIST_DIR)\drivers\$(TARGETNAME).sys
 else
-	$(CP) $(TARGET).sys ../../../$(DIST_DIR)/drivers/$(TARGET).sys
+	$(CP) $(TARGETNAME).sys ../../../$(DIST_DIR)/drivers/$(TARGETNAME).sys
 endif
 
-$(TARGET).sys: $(OBJECTS)
+$(TARGETNAME).sys: $(OBJECTS)
 	$(CC) \
 		-specs=../../svc_specs \
 		-mdll \
@@ -50,7 +50,7 @@ $(TARGET).sys: $(OBJECTS)
 		$(OBJECTS)
 	- $(RM) junk.tmp
 	$(DLLTOOL) \
-		--dllname $(TARGET).sys \
+		--dllname $(TARGETNAME).sys \
 		--base-file base.tmp \
 		--output-exp temp.exp \
 		--kill-at
@@ -62,7 +62,7 @@ $(TARGET).sys: $(OBJECTS)
 		-Wl,temp.exp \
 		-specs=../../svc_specs \
 		-mdll \
-		-o $(TARGET).sys \
+		-o $(TARGETNAME).sys \
 		$(OBJECTS)
 	- $(RM) temp.exp
 

reactos/iface/addsys/.cvsignore

@@ -0,0 +1,2 @@
+mktab
+mktab.exe

reactos/iface/addsys/makefile

@@ -0,0 +1,52 @@
+# $Id: makefile,v 1.1 2000/02/20 22:52:47 ea Exp $
+#
+# ReactOS Operating System
+#
+# Generate files for a kernel module that needs to add a service table.
+#
+TARGETNAME = mktab
+
+# WIN32K.SYS
+SVC_DB=w32ksvc.db
+SVC_MASK=0x10000000
+
+ifeq ($(DOSCLI),yes)
+SVC_SERVICE_TABLE_PATH=..\\..\\subsys\\win32k\\main\\
+SVC_CLIENT_STUBS_PATH=..\\..\\lib\\gdi32\\misc\\
+else
+SVC_SERVICE_TABLE_PATH=../../subsys/win32k/main/
+SVC_CLIENT_STUBS_PATH=../../lib/gdi32/misc/
+endif
+
+SVC_SERVICE_TABLE=$(SVC_SERVICE_TABLE_PATH)svctab.c
+SVC_CLIENT_STUBS=$(SVC_CLIENT_STUBS_PATH)win32k.c
+
+SVC_FILES = $(SVC_CLIENT_STUBS) $(SVC_SERVICE_TABLE)
+
+BASE_CFLAGS = -I../../include
+
+all: $(SVC_FILES)
+
+$(TARGETNAME)$(EXE_POSTFIX): $(TARGETNAME).cc
+	$(CC) \
+		$(CFLAGS) \
+		-o $(TARGETNAME) \
+		-O2 \
+		$(TARGETNAME).cc
+
+$(SVC_FILES): $(SVC_DB) $(TARGETNAME)$(EXE_POSTFIX) 
+	./$(TARGETNAME)$(EXE_POSTFIX) \
+		$(SVC_DB) \
+		$(SVC_MASK) \
+		$(SVC_CLIENT_STUBS) \
+		$(SVC_SERVICE_TABLE)
+
+
+clean:
+	- $(RM) $(TARGETNAME)$(EXE_POSTFIX)
+	- $(RM) $(SVC_CLIENT_STUBS)
+	- $(RM) $(SVC_SERVICE_TABLE)
+	
+.PHONY: all clean 
+
+include ../../rules.mak

reactos/iface/addsys/mktab.cc

@@ -0,0 +1,410 @@
+/* $Id: mktab.cc,v 1.1 2000/02/20 22:52:47 ea Exp $
+ *
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT  : ReactOS 
+ * FILE     : iface/addsys/mktab.c
+ * PURPOSE  : Generating any files required for a kernel module 
+ *            to register an additional system calls table in
+ *            NTOSKRNL.
+ * REVISIONS: 
+ * 	2000-02-13 (ea)
+ * 		Derived from genntdll.c mainly to build
+ * 		win32k.sys functions table.
+ */
+
+/* INCLUDE ******************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define VERBOSE
+
+#define INPUT_BUFFER_SIZE 255
+
+#define DB_RECORD_NAME_SIZE 64
+
+#define STACK_ENTRY_SIZE (sizeof(void*))
+
+#define FALSE 0
+#define TRUE  1
+
+typedef unsigned int 	DWORD;
+typedef int		INT;
+typedef char		* LPSTR, CHAR, * PCHAR;
+typedef int		BOOL;
+typedef void		VOID, * PVOID;
+
+typedef
+struct _DB_RECORD
+{
+	CHAR	Name [DB_RECORD_NAME_SIZE];
+	INT	ArgumentCount;
+	INT	StackSize;
+	
+} DB_RECORD, * PDB_RECORD;
+
+typedef
+enum 
+{
+	SELECT_OK,
+	SELECT_EOF,
+	SELECT_ERROR
+
+} SELECT_TYPE;
+
+
+/* FUNCTIONS ****************************************************************/
+
+
+void usage (char * argv0)
+{
+	printf (
+"\nUsage: %s api.db mask table.c apistubs.c\n\n"
+"  api.db     additional system functions database (NAME, ARG_COUNT)\n"
+"  mask       service table mask (in hex; e.g. 0x1000000)\n"
+"  table.c    service table file to be linked in the kernel module\n"
+"  apistubs.c stubs for user mode clients to call the API\n\n"
+"NOTE: NAME must be an ASCII string and ARG_COUNT a decimal number;\n"
+"between NAME and ARG_COUNT there must be at least one space or tab.\n",
+		argv0
+		);
+}
+
+
+void
+CloseAllFiles (FILE * f0, FILE * f1, FILE * f2)
+{
+	if (f0) fclose (f0);
+	if (f1) fclose (f1);
+	if (f2) fclose (f2);
+}
+
+
+SELECT_TYPE
+GetNextRecord (
+	FILE		* InputFile,
+	PDB_RECORD	Dbr
+	)
+{
+	CHAR		InputBuffer [INPUT_BUFFER_SIZE];
+	PCHAR		s;
+	static INT	LineNumber = 0;
+	BOOL		BadData = TRUE;
+
+	if (	(NULL == InputFile) 
+		|| (NULL == Dbr)
+		)
+	{
+		fprintf (stderr, "GetNextRecord: bad argument!\n");
+		return SELECT_ERROR;
+	}
+	while (TRUE == BadData)
+	{
+		if (	feof (InputFile)
+			|| (NULL == fgets (
+					InputBuffer,
+					sizeof InputBuffer,
+					InputFile
+					)
+				)
+			)
+		{
+#ifdef VERBOSE
+			fprintf (
+				stderr,
+				"GetNextRecord: EOF at line %d\n",
+				LineNumber
+				);
+#endif
+			return SELECT_EOF;
+		}
+		++ LineNumber;
+		/*
+		 * Remove, if present, the trailing CR.
+		 * (os specific?)
+		 */
+		if (NULL != (s = (char *) strchr (InputBuffer,'\r')))
+		{
+			*s = '\0';
+		}
+		/*
+		 * Skip comments (#) and empty lines.
+		 */
+		s = & InputBuffer [0];
+		if (	('#' != (*s))
+			&& ('\0' != (*s))
+			)
+		{
+			BadData = FALSE;
+		}
+	}
+	if (2 != sscanf (
+			InputBuffer,
+			"%s%d",
+			Dbr->Name,
+			& Dbr->ArgumentCount
+			)
+		)
+	{
+		fprintf (
+			stderr,
+			"GetNextRecord: line %d: syntax error!\n",
+			LineNumber
+			);
+		return SELECT_ERROR;
+	}
+	Dbr->StackSize = (Dbr->ArgumentCount * sizeof (void*));
+	return SELECT_OK;
+}
+
+
+/* User mode service stubs file generation */
+
+
+void
+OutputStubPrologue (FILE * of)
+{
+	fprintf (
+		of,
+		"/* Machine generated. Don't edit! */\n\n"
+		"__asm (\n"
+		);
+}
+
+
+BOOL
+OutputStub (FILE * of, PDB_RECORD Dbr, INT Id, DWORD Mask)
+{
+	DWORD	CallId = (Mask | (DWORD) Id);
+	CHAR	DecoratedName [DB_RECORD_NAME_SIZE];
+	
+	sprintf (
+		DecoratedName,
+		"_%s@%d",
+		Dbr->Name,
+		Dbr->StackSize
+		);
+	fprintf (
+		of,
+		"\t\".global %s\\n\\t\"\n"
+		"\"%s:\\n\\t\"\n"
+		"\t\"mov\t$0x%08x,%%eax\\n\\t\"\n"
+		"\t\"lea\t4(%%esp),%%edx\\n\\t\"\n"
+		"\t\"int\t$0x2E\\n\\t\"\n"
+		"\t\"ret\t$%d\\n\\t\"\n",
+		DecoratedName,
+		DecoratedName,
+		CallId,
+		Dbr->StackSize
+		);
+	return TRUE;
+}
+
+
+void
+OutputStubEpilog (FILE * of)
+{
+	fprintf (
+		of,
+		");\n\n/* EOF */\n"
+		);
+}
+
+
+/* Service table file generation (used by the kernel module) */
+
+
+void
+OutputTablePrologue (FILE * of)
+{
+	fprintf (
+		of,
+		"/* Machine generated. Don't edit! */\n\n"
+		"SERVICE_TABLE W32kServiceTable [] =\n{\n"
+		);
+}
+
+
+BOOL
+OutputTable (FILE * of, PDB_RECORD Dbr)
+{
+	static BOOL First = TRUE;
+	
+	if (TRUE == First)
+	{
+		fprintf (
+			of,
+			"{%d,(ULONG)%s}",
+			Dbr->StackSize,
+			Dbr->Name
+			);
+		First = FALSE;
+	}
+	else
+	{
+		fprintf (
+			of,
+			",\n{%d,(ULONG)%s}",
+			Dbr->StackSize,
+			Dbr->Name
+			);
+	}
+	return TRUE;
+}
+
+
+void
+OutputTableEpilog (FILE * of)
+{
+	fprintf (
+		of,
+		"\n};\n/* EOF */"
+		);
+}
+
+
+/* MAIN */
+
+int
+main (int argc, char * argv [])
+{
+	FILE		* ApiDb = NULL;
+	FILE		* Table = NULL;
+	FILE		* Stubs = NULL;
+
+	DWORD		Mask = 0;
+	DB_RECORD	Dbr;
+	INT		Id = 0;
+
+	SELECT_TYPE	ReturnValue;
+	
+	/* --- Check arguments --- */
+	
+	if (argc != 5)
+	{
+		usage (argv[0]);
+		return (1);
+	}
+
+	/* --- Create files --- */
+
+	ApiDb = fopen (argv[1], "rb");
+	if (NULL == ApiDb)
+	{
+		fprintf (
+			stderr,
+			"%s: fatal: could not open the file \"%s\".\n",
+			argv [0],
+			argv [1]
+			);
+		return (1);
+	}
+	printf ("< %s\n", argv[1]);
+
+	Stubs = fopen (argv[3], "wb");
+	if (NULL == Stubs)
+	{
+		fprintf (
+			stderr,
+			"%s: fatal: could not open the file \"%s\".\n",
+			argv [0],
+			argv [3]
+			);
+		CloseAllFiles (ApiDb, Table, Stubs);
+		return (1);
+	}
+	printf ("> %s\n", argv[3]);
+
+	Table = fopen (argv[4], "wb");
+	if (NULL == Table)
+	{
+		fprintf (
+			stderr,
+			"%s: fatal: could not open the file \"%s\".\n",
+			argv [0],
+			argv [4]
+			);
+		CloseAllFiles (ApiDb, Table, Stubs);
+		return (1);
+	}
+	printf ("> %s\n", argv[4]);
+	
+	/* --- Convert the mask value --- */
+
+	if (1 != sscanf (argv[2], "%x", & Mask))
+	{
+		fprintf (
+			stderr,
+			"%s: fatal: could not convert the mask \"%s\".\n",
+			argv [0],
+			argv [2]
+			);
+		CloseAllFiles (ApiDb, Table, Stubs);
+		return (1);
+	}
+	printf ("& 0x%08x\n", Mask);
+	
+	/* --- Process data --- */
+
+	printf ("Processing data...\n");
+	OutputStubPrologue (Stubs);
+	OutputTablePrologue (Table);
+	while (SELECT_OK == (ReturnValue = GetNextRecord (ApiDb, & Dbr)))
+	{
+		if (TRUE == OutputTable (Table, & Dbr))
+		{
+			if (FALSE == OutputStub (Stubs, & Dbr, Id, Mask))
+			{
+				fprintf (
+					stderr,
+					"%s: WARNING: %s has no user mode stub\n",
+					argv [0],
+					Dbr.Name
+					);
+			}
+		}
+		else
+		{
+			fprintf (
+				stderr,
+				"%s: WARNING: %s skipped on I/O error\n",
+				argv [0],
+				Dbr.Name
+				);
+		}
+		++ Id;
+#ifdef VERBOSE
+		printf (
+			"%3d: _%s@%d\n",
+			Id,
+			Dbr.Name,
+			Dbr.StackSize
+			);
+#endif
+	}
+	if (SELECT_EOF == ReturnValue)
+	{
+		OutputStubEpilog (Stubs);
+		OutputTableEpilog (Table);
+	}
+	else
+	{
+		fprintf (
+			stderr,
+			"%s: generated files may be incomplete!\n",
+			argv [0]
+			);
+	}
+
+	/* --- Close files --- */
+
+	CloseAllFiles (ApiDb, Table, Stubs);
+
+	printf ("Done\n");
+
+	return (0);
+}
+
+
+/* EOF */

reactos/iface/addsys/w32ksvc.db

@@ -0,0 +1,280 @@
+# NAME					ARG_COUNT
+W32kAbortDoc				1
+W32kAbortPath				1
+W32kAddFontResource			1
+W32kAngleArc				6
+W32kAnimatePalette			4
+W32kArc					9
+W32kArcTo				9
+W32kBeginPath				1
+W32kBitBlt				9
+W32kCancelDC				1
+W32kCheckColorsInGamut			4
+#W32kChoosePixelFormat			(2?)
+W32kChord				9
+W32kCloseEnhMetaFile			1
+W32kCloseFigure				1
+W32kCloseMetaFile			1
+W32kColorMatchToTarget			3
+W32kCombineRgn				4
+W32kCombineTransform			3
+W32kCopyEnhMetaFile			2
+W32kCopyMetaFile			2
+W32kCreateBitmap			5
+W32kCreateBitmapIndirect		1
+W32kCreateBrushIndirect			1
+W32kCreateColorSpace			1
+W32kCreateCompatibleBitmap		3
+W32kCreateCompatableDC			1
+W32kCreateDC				4
+W32kCreateDIBitmap			6
+W32kCreateDIBPatternBrush		2
+W32kCreateDIBPatternBrushPt		2
+W32kCreateDIBSection			6
+W32kCreateDiscardableBitmap		3
+W32kCreateEllipticRgn			4
+W32kCreateEllipticRgnIndirect		1
+W32kCreateEnhMetaFile			4
+W32kCreateFont				14
+W32kCreateFontIndirect			1
+W32kCreateHalftonePalette		1
+W32kCreateHatchBrush			2
+W32kCreateIC				4
+W32kCreateMetaFile			1
+W32kCreatePalette			1
+W32kCreatePatternBrush			1
+W32kCreatePen				3
+W32kCreatePenIndirect			1
+W32kCreatePolygonRgn			3
+W32kCreatePolyPolygonRgn		4
+W32kCreateRectRgn			4
+W32kCreateRectRgnIndirect		1
+W32kCreateRoundRectRgn			6
+W32kCreateScalableFontResource		4
+W32kCreateSolidBrush			1
+W32kDPtoLP				3
+W32kDeleteColorSpace			1
+W32kDeleteDC				1
+W32kDeleteEnhMetaFile			1
+W32kDeleteMetaFile			1
+W32kDeleteObject			1
+W32kDescribePixelFormat			4
+#W32kDeviceCapabilitiesEx		?
+W32kDrawEscape				4
+W32kEllipse				5
+W32kEndDoc				1
+W32kEndPage				1
+W32kEndPath				1
+W32kEnumEnhMetaFile			5
+W32kEnumFontFamilies			4
+W32kEnumFontFamiliesEx			5
+W32kEnumFonts				4
+W32kEnumICMProfiles			3
+W32kEnumMetaFile			4
+W32kEnumObjects				4
+W32kEqualRgn				2
+W32kEscape				5
+W32kExcludeClipRect			5
+W32kExtCreatePen			5
+W32kExtCreateRegion			3
+W32kExtEscape				6
+W32kExtFloodFill			5
+W32kExtSelectClipRgn			3
+W32kExtTextOut				8
+W32kFillPath				1
+W32kFillRgn				3
+W32kFixBrushOrgEx			0
+W32kFlattenPath				1
+W32kFloodFill				4
+W32kFrameRgn				5
+W32kGdiComment				3
+W32kGdiFlush				0
+W32kGdiGetBatchLimit			0
+#W32kGdiPlayDCScript			?
+#W32kGdiPlayJournal			?
+#W32kGdiPlayScript			?
+#W32kGdiPlaySpoolStream			?
+W32kGdiSetBatchLimit			1
+W32kGetArcDirection			1
+W32kGetAspectRatioFilterEx		2
+W32kGetBitmapBits			3
+W32kGetBitmapDimensionEx		2
+W32kGetBkColor				1
+W32kGetBkMode				1
+W32kGetBoundsRect			3
+W32kGetBrushOrgEx			2
+W32kGetCharABCWidths			4
+W32kGetCharABCWidthsFloat		4
+W32kGetCharacterPlacement		6
+W32kGetCharWidth			4
+W32kGetCharWidth32			4
+W32kGetCharWidthFloat			4
+W32kGetClipBox				2
+W32kGetClipRgn				1
+W32kGetColorAdjustment			2
+W32kGetColorSpace			1
+W32kGetCurrentObject			2
+W32kGetCurrentPositionEx		2
+W32kGetDCOrgEx				2
+W32kGetDIBColorTable			4
+W32kGetDIBits				7
+W32kGetDeviceCaps			2
+W32kGetDeviceGammaRamp			2
+W32kGetEnhMetaFile			1
+W32kGetEnhMetaFileBits			3
+W32kGetEnhMetaFileDescription		3
+W32kGetEnhMetaFileHeader		3
+W32kGetEnhMetaFilePaletteEntries	3
+W32kGetEnhMetaFilePixelFormat		3
+W32kGetFontLanguageInfo			1
+#W32kGetFontResourceInfo		?
+W32kGetGlyphOutline			7
+#W32kGetGlyphOutlineWow			?
+W32kGetGraphicsMode			1
+W32kGetICMProfile			3
+W32kGetKerningPairs			3
+W32kGetLogColorSpace			3
+W32kGetMapMode				1
+W32kGetMetaFile				1
+W32kGetMetaFileBitsEx			3
+W32kGetMetaRgn				2
+W32kGetMiterLimit			2
+W32kGetNearestColor			2
+W32kGetNearestPaletteIndex		2
+W32kGetObject				3
+W32kGetObjectType			1
+W32kGetOutlineTextMetrics		3
+W32kGetPaletteEntries			4
+W32kGetPath				4
+W32kGetPixel				1
+W32kGetPixelFormat			1
+W32kGetPolyFillMode			1
+W32kGetROP2				1
+#W32kGetRandomRgn			?
+W32kGetRasterizerCaps			2
+W32kGetRelAbs				1
+W32kGetRgnBox				2
+W32kGetStockObject			1
+W32kGetStretchBltMode			1
+W32kGetSystemPaletteEntries		4
+W32kGetSystemPaletteUse			1
+W32kGetTextAlign			1
+W32kGetTextCharset			1
+W32kGetTextCharsetInfo			3
+W32kGetTextColor			1
+W32kGetTextExtentExPoint		7
+W32kGetTextExtentPoint			4
+W32kGetTextExtentPoint32		4
+W32kGetTextFace				3
+W32kGetTextMetrics			2
+W32kGetViewportExtEx			2
+W32kGetViewportOrgEx			2
+W32kGetWinMetaFileBits			5
+W32kGetWindowExtEx			2
+W32kGetWindowOrgEx			2
+W32kGetWorldTransform			2
+W32kIntersectClipRect			5
+W32kInvertRgn				2
+W32kLPtoDP				3
+W32kLineTo				3
+W32kMaskBlt				12
+W32kModifyWorldTransform		3
+W32kMoveToEx				4
+W32kOffsetClipRgn			3
+W32kOffsetRgn				3
+W32kOffsetViewportOrgEx			4
+W32kOffsetWindowOrgEx			4
+W32kPaintRgn				2
+W32kPatBlt				6
+W32kPathToRegion			1
+W32kPie					9
+W32kPlayEnhMetaFile			3
+W32kPlayEnhMetaFileRecord		4
+W32kPlayMetaFile			2
+W32kPlayMetaFileRecord			4
+W32kPlgBlt				10
+W32kPolyBezier				3
+W32kPolyBezierTo			3
+W32kPolyDraw				4
+W32kPolyline				3
+W32kPolylineTo				3
+W32kPolyPolyline			4
+W32kPolyTextOut				3
+W32kPolygon				3
+W32kPolyPolygon				4
+W32kPtInRegion				3
+W32kPtVisible				3
+W32kRealizePalette			1
+W32kRectInRegion			2
+W32kRectVisible				2
+W32kRectangle				5
+W32kRemoveFontResource			1
+W32kResetDC				2
+W32kResizePalette			2
+W32kRestoreDC				2
+W32kRoundRect				7
+W32kSaveDC				1
+W32kScaleViewportExtEx			6
+W32kScaleWindowExtEx			6
+#W32kSelectBrushLocal			?
+W32kSelectClipPath			2
+W32kSelectClipRgn			2
+#W32kSelectFontLocal			?
+W32kSelectObject			2
+W32kSelectPalette			3
+W32kSetAbortProc			2
+W32kSetArcDirection			2
+W32kSetBitmapBits			3
+W32kSetBitmapDimensionEx		4
+W32kSetBkColor				2
+W32kSetBkMode				2
+W32kSetBoundsRect			3
+W32kSetBrushOrgEx			4
+W32kSetColorAdjustment			2
+W32kSetColorSpace			2
+W32kSetDIBColorTable			4
+W32kSetDIBits				7
+W32kSetDIBitsToDevice			12
+W32kSetDeviceGammaRamp			2
+W32kSetEnhMetaFileBits			2
+#W32kSetFontEnumeration			?
+W32kSetGraphicsMode			2
+W32kSetICMMode				2
+W32kSetICMProfile			2
+W32kSetMapMode				2
+W32kSetMapperFlags			2
+W32kSetMetaFileBitsEx			2
+W32kSetMetaRgn				1
+W32kSetMiterLimit			3
+W32kSetPaletteEntries			4
+W32kSetPixel				4
+W32kSetPixelFormat			3
+W32kSetPixelV				4
+W32kSetPolyFillMode			2
+W32kSetROP2				2
+W32kSetRectRgn				5
+#W32kSetRelAbs				2
+W32kSetStretchBltMode			2
+W32kSetSystemPaletteUse			2
+W32kSetTextAlign			2
+W32kSetTextColor			2
+W32kSetTextJustification		3
+W32kSetViewportExtEx			4
+W32kSetViewportOrgEx			4
+#W32kSetWinMetaFileBits			1
+W32kSetWindowExtEx			4
+W32kSetWindowOrgEx			4
+W32kSetWorldTransform			2
+W32kStartDoc				2
+W32kStartPage				1
+W32kStretchBlt				11
+W32kStretchDIBits			13
+W32kStrokeAndFillPath			1
+W32kStrokePath				1
+W32kSwapBuffers				1
+W32kTextOut				5
+W32kTranslateCharsetInfo		3
+W32kUnrealizeObject			2
+W32kUpdateColors			1
+W32kUpdateICMRegKey			4
+W32kWidenPath				1

reactos/include/ddk/obfuncs.h

@@ -6,7 +6,7 @@
  * ARGUMENTS:
  *        Object = Object's body
  */
-VOID ObDereferenceObject(PVOID Object);
+VOID STDCALL ObDereferenceObject(PVOID Object);
 
 /*
  * FUNCTION: Performs access validation on an object handle and if access
@@ -38,7 +38,7 @@ NTSTATUS ObReferenceObjectByHandle(HANDLE Handle,
  *      AccessMode = Access mode to use for the security check
  * RETURNS: Status
  */
-NTSTATUS ObReferenceObjectByPointer(PVOID Object,
+NTSTATUS STDCALL ObReferenceObjectByPointer(PVOID Object,
 				    ACCESS_MASK DesiredAccess,
 				    POBJECT_TYPE ObjectType,
 				    KPROCESSOR_MODE AccessMode);

reactos/include/reactos/config.h

@@ -1,15 +1,16 @@
 #ifndef _INC_REACTOS_CONFIG_H
 #define _INC_REACTOS_CONFIG_H 
-/* $Id: config.h,v 1.2 1999/10/12 21:17:03 ea Exp $ */
+/* $Id: config.h,v 1.3 2000/02/20 22:52:47 ea Exp $ */
 /* ReactOS global configuration options */
 
-#define CONFIG_PROCESSOR_FAMILY_I386	"i386"
-#define CONFIG_PROCESSOR_FAMILY_I486	"i486"
-#define CONFIG_PROCESSOR_FAMILY_I586	"i586"
+#define CONFIG_PROCESSOR_FAMILY_I386	386L
+#define CONFIG_PROCESSOR_FAMILY_I486	486L
+#define CONFIG_PROCESSOR_FAMILY_I586	586L
+#define CONFIG_PROCESSOR_FAMILY_IPII	686L
 
-#define CONFIG_PROCESSOR_FAMILY_ALPHA	"ALPHA"
+#define CONFIG_PROCESSOR_FAMILY_ALPHA	0x10000000
 
-#define CONFIG_ARCHITECTURE_IBMPC	"IBMPC"
+#define CONFIG_ARCHITECTURE_IBMPC	0x00000000
 /*
  * Processor and architecture.
  */

reactos/include/win32k/bitmaps.h

@@ -43,152 +43,250 @@ int DIB_GetDIBImageBytes (int  width, int  height, int  depth);
 int DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse);
 
 /*  User Entry Points  */
-BOOL  W32kBitBlt(HDC  hDCDest,
-                 INT  XDest,
-                 INT  YDest,
-                 INT  Width,
-                 INT  Height,
-                 HDC  hDCSrc,
-                 INT  XSrc,
-                 INT  YSrc,
-                 DWORD  ROP);
-HBITMAP  W32kCreateBitmap(INT  Width,
-                          INT  Height,
-                          UINT  Planes,
-                          UINT  BitsPerPel,
-                          CONST VOID *Bits);
-HBITMAP  W32kCreateCompatibleBitmap(HDC hDC,
-                                    INT  Width,
-                                    INT  Height);
-HBITMAP  W32kCreateBitmapIndirect(CONST BITMAP  *BM);
-HBITMAP  W32kCreateDIBitmap(HDC  hDC,
-                            CONST BITMAPINFOHEADER  *bmih,
-                            DWORD  Init,
-                            CONST VOID  *bInit,
-                            CONST BITMAPINFO  *bmi,
-                            UINT  Usage);
-HBITMAP  W32kCreateDIBSection(HDC hDC,
-                              CONST BITMAPINFO  *bmi,
-                              UINT  Usage,
-                              VOID  *Bits,
-                              HANDLE hSection,
-                              DWORD dwOffset);
-HBITMAP  W32kCreateDiscardableBitmap(HDC  hDC,
-                                     INT  Width,
-                                     INT  Height);
-BOOL  W32kExtFloodFill(HDC  hDC,
-                       INT  XStart,
-                       INT  YStart,
-                       COLORREF  Color, 
-                       UINT  FillType);
-BOOL  W32kFloodFill(HDC  hDC,
-                    INT  XStart,
-                    INT  YStart,
-                    COLORREF  Fill);
-LONG  W32kGetBitmapBits(HBITMAP  hBitmap,
-                        LONG  Buffer,
-                        LPVOID  Bits);
-BOOL  W32kGetBitmapDimensionEx(HBITMAP  hBitmap,
-                               LPSIZE  Dimension);
-UINT  W32kGetDIBColorTable(HDC  hDC,
-                           UINT  StartIndex,
-                           UINT  Entries,
-                           RGBQUAD  *Colors);
-INT  W32kGetDIBits(HDC  hDC,
-                   HBITMAP hBitmap,
-                   UINT  StartScan,
-                   UINT  ScanLines,
-                   LPVOID  Bits,
-                   LPBITMAPINFO   bi,
-                   UINT  Usage);
-COLORREF  W32kGetPixel(HDC  hDC,
-                       INT  XPos,
-                       INT  YPos);
-BOOL  W32kMaskBlt(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 W32kPlgBlt(HDC  hDCDest,
-                CONST POINT  *Point,
-                HDC  hDCSrc, 
-                INT  XSrc,  
-                INT  YSrc,  
-                INT  Width, 
-                INT  Height,
-                HBITMAP  hMaskBitmap,
-                INT  xMask,      
-                INT  yMask);
-LONG  W32kSetBitmapBits(HBITMAP  hBitmap,
-                        DWORD  Bytes,
-                        CONST VOID *Bits);
-BOOL  W32kSetBitmapDimensionEx(HBITMAP  hBitmap,
-                               INT  Width,
-                               INT  Height,
-                               LPSIZE  Size);
-UINT  W32kSetDIBColorTable(HDC  hDC,
-                           UINT  StartIndex,
-                           UINT  Entries,
-                           CONST RGBQUAD  *Colors);
-INT  W32kSetDIBits(HDC  hDC,
-                   HBITMAP  hBitmap,
-                   UINT  StartScan,
-                   UINT  ScanLines,
-                   CONST VOID  *Bits,
-                   CONST BITMAPINFO  *bmi,
-                   UINT  ColorUse);
-INT  W32kSetDIBitsToDevice(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  W32kSetPixel(HDC  hDC,
-                       INT  X,
-                       INT  Y,
-                       COLORREF  Color);
-BOOL  W32kSetPixelV(HDC  hDC,
-                    INT  X,
-                    INT  Y,
-                    COLORREF  Color);
-BOOL  W32kStretchBlt(HDC  hDCDest,
-                     INT  XOriginDest,
-                     INT  YOriginDest,
-                     INT  WidthDest,
-                     INT  HeightDest,
-                     HDC  hDCSrc,
-                     INT  XOriginSrc,
-                     INT  YOriginSrc,
-                     INT  WidthSrc,    
-                     INT  HeightSrc, 
-                     DWORD  ROP);
-INT  W32kStretchDIBits(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
+W32kBitBlt (
+	HDC	hDCDest,
+	INT	XDest,
+	INT	YDest,
+	INT	Width,
+	INT	Height,
+	HDC	hDCSrc,
+	INT	XSrc,
+	INT	YSrc,
+	DWORD	ROP
+	);
+HBITMAP
+STDCALL
+W32kCreateBitmap (
+	INT		Width,
+	INT		Height,
+	UINT		Planes,
+	UINT		BitsPerPel,
+	CONST VOID	* Bits
+	);
+HBITMAP
+STDCALL
+W32kCreateCompatibleBitmap (
+	HDC	hDC,
+	INT	Width,
+	INT	Height
+	);
+HBITMAP
+STDCALL
+W32kCreateBitmapIndirect (
+	CONST BITMAP	* BM
+	);
+HBITMAP
+STDCALL
+W32kCreateDIBitmap (
+	HDC			hDC,
+	CONST BITMAPINFOHEADER	* bmih,
+	DWORD			Init,
+	CONST VOID		* bInit,
+	CONST BITMAPINFO	* bmi,
+	UINT			Usage
+	);
+HBITMAP
+STDCALL
+W32kCreateDIBSection (
+	HDC			hDC,
+	CONST BITMAPINFO	* bmi,
+	UINT			Usage,
+	VOID			* Bits,
+	HANDLE			hSection,
+	DWORD			dwOffset
+	);
+HBITMAP
+STDCALL
+W32kCreateDiscardableBitmap (
+	HDC	hDC,
+	INT	Width,
+	INT	Height
+	);
+BOOL
+STDCALL
+W32kExtFloodFill (
+	HDC		hDC,
+	INT		XStart,
+	INT		YStart,
+	COLORREF	Color, 
+	UINT		FillType
+	);
+BOOL
+STDCALL
+W32kFloodFill (
+	HDC		hDC,
+	INT		XStart,
+	INT		YStart,
+	COLORREF	Fill
+	);
+LONG
+STDCALL
+W32kGetBitmapBits (
+	HBITMAP	hBitmap,
+	LONG	Buffer,
+	LPVOID	Bits
+	);
+BOOL
+STDCALL
+W32kGetBitmapDimensionEx (
+	HBITMAP	hBitmap,
+	LPSIZE	Dimension
+	);
+UINT
+STDCALL
+W32kGetDIBColorTable (
+	HDC	hDC,
+	UINT	StartIndex,
+	UINT	Entries,
+	RGBQUAD	* Colors
+	);
+INT
+STDCALL
+W32kGetDIBits (
+	HDC		hDC,
+	HBITMAP		hBitmap,
+	UINT		StartScan,
+	UINT		ScanLines,
+	LPVOID		Bits,
+	LPBITMAPINFO	bi,
+	UINT		Usage
+	);
+COLORREF
+STDCALL
+W32kGetPixel (
+	HDC	hDC,
+	INT	XPos,
+	INT	YPos
+	);
+BOOL
+STDCALL
+W32kMaskBlt (
+	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
+W32kPlgBlt (
+	HDC		hDCDest,
+	CONST POINT	* Point,
+	HDC		hDCSrc, 
+	INT		XSrc,  
+	INT		YSrc,  
+	INT		Width, 
+	INT		Height,
+	HBITMAP		hMaskBitmap,
+	INT		xMask,      
+	INT		yMask
+	);
+LONG
+STDCALL
+W32kSetBitmapBits (
+	HBITMAP		hBitmap,
+	DWORD		Bytes,
+	CONST VOID	* Bits
+	);
+BOOL
+STDCALL
+W32kSetBitmapDimensionEx (
+	HBITMAP	hBitmap,
+	INT	Width,
+	INT	Height,
+	LPSIZE	Size
+	);
+UINT
+STDCALL
+W32kSetDIBColorTable (
+	HDC		hDC,
+	UINT		StartIndex,
+	UINT		Entries,
+	CONST RGBQUAD	* Colors
+	);
+INT
+STDCALL
+W32kSetDIBits (
+	HDC			hDC,
+	HBITMAP			hBitmap,
+	UINT			StartScan,
+	UINT			ScanLines,
+	CONST VOID		* Bits,
+	CONST BITMAPINFO	* bmi,
+	UINT			ColorUse
+	);
+INT
+STDCALL
+W32kSetDIBitsToDevice (
+	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
+W32kSetPixel (
+	HDC		hDC,
+	INT		X,
+	INT		Y,
+	COLORREF	Color
+	);
+BOOL
+STDCALL
+W32kSetPixelV (
+	HDC		hDC,
+	INT		X,
+	INT		Y,
+	COLORREF	Color
+	);
+BOOL
+STDCALL
+W32kStretchBlt (
+	HDC	hDCDest,
+	INT	XOriginDest,
+	INT	YOriginDest,
+	INT	WidthDest,
+	INT	HeightDest,
+	HDC	hDCSrc,
+	INT	XOriginSrc,
+	INT	YOriginSrc,
+	INT	WidthSrc,    
+	INT	HeightSrc, 
+	DWORD	ROP
+	);
+INT
+STDCALL
+W32kStretchDIBits (
+	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
+	);
 #endif
 

reactos/include/win32k/brush.h

@@ -1,4 +1,3 @@
-
 #ifndef __WIN32K_BRUSH_H
 #define __WIN32K_BRUSH_H
 
@@ -18,26 +17,61 @@
 #define  BRUSHOBJ_LockBrush(hBrush) GDIOBJ_LockObject((HGDIOBJ)hBrush)
 #define  BRUSHOBJ_UnlockBrush(hBrush) GDIOBJ_UnlockObject((HGDIOBJ)hBrush)
 
-HBRUSH  W32kCreateBrushIndirect(CONST LOGBRUSH  *lb);
-HBRUSH  W32kCreateDIBPatternBrush(HGLOBAL  hDIBPacked,
-                                  UINT  ColorSpec);
-HBRUSH  W32kCreateDIBPatternBrushPt(CONST VOID  *PackedDIB,
-                                    UINT  Usage);
-HBRUSH  W32kCreateHatchBrush(INT  Style,
-                             COLORREF  Color);
-HBRUSH  W32kCreatePatternBrush(HBITMAP  hBitmap);
-HBRUSH  W32kCreateSolidBrush(COLORREF  Color);
-BOOL  W32kFixBrushOrgEx(VOID);
-BOOL  W32kPatBlt(HDC  hDC,
-                 INT  XLeft,
-                 INT  YLeft,
-                 INT  Width,
-                 INT  Height,
-                 DWORD  ROP);
-BOOL  W32kSetBrushOrgEx(HDC  hDC,
-                        INT  XOrg,
-                        INT  YOrg,
-                        LPPOINT  Point);
-
+HBRUSH
+STDCALL
+W32kCreateBrushIndirect (
+	CONST LOGBRUSH	* lb
+	);
+HBRUSH
+STDCALL
+W32kCreateDIBPatternBrush (
+	HGLOBAL	hDIBPacked,
+	UINT	ColorSpec
+	);
+HBRUSH
+STDCALL
+W32kCreateDIBPatternBrushPt (
+	CONST VOID	* PackedDIB,
+	UINT		Usage
+	);
+HBRUSH
+STDCALL
+W32kCreateHatchBrush (
+	INT		Style,
+	COLORREF	Color
+	);
+HBRUSH
+STDCALL
+W32kCreatePatternBrush (
+	HBITMAP	hBitmap
+	);
+HBRUSH
+STDCALL
+W32kCreateSolidBrush (
+	COLORREF	Color
+	);
+BOOL
+STDCALL
+W32kFixBrushOrgEx (
+	VOID
+	);
+BOOL
+STDCALL
+W32kPatBlt (
+	HDC	hDC,
+	INT	XLeft,
+	INT	YLeft,
+	INT	Width,
+	INT	Height,
+	DWORD	ROP
+	);
+BOOL
+STDCALL
+W32kSetBrushOrgEx (
+	HDC	hDC,
+	INT	XOrg,
+	INT	YOrg,
+	LPPOINT	Point
+	);
 #endif
 

reactos/include/win32k/cliprgn.h

@@ -1,47 +1,78 @@
-
-
 #ifndef _WIN32K_CLIPRGN_H
 #define _WIN32K_CLIPRGN_H
 
-int  W32kExcludeClipRect(HDC  hDC,
-                         int  LeftRect,
-                         int  TopRect,
-                         int  RightRect,
-                         int  BottomRect);
-                                    
-int  W32kExtSelectClipRgn(HDC  hDC,
-                          HRGN  hrgn,
-                          int  fnMode);
-
-int  W32kGetClipBox(HDC  hDC,
-                    LPRECT  rc);
-
-int  W32kGetMetaRgn(HDC  hDC,
-                    HRGN  hrgn);
-
-int  W32kIntersectClipRect(HDC  hDC,
-                           int  LeftRect,
-                           int  TopRect,
-                           int  RightRect,
-                           int  BottomRect);
-
-int  W32kOffsetClipRgn(HDC  hDC,
-                       int  XOffset,
-                       int  YOffset);
-
-BOOL  W32kPtVisible(HDC  hDC,
-                    int  X,
-                    int  Y);
-
-BOOL  W32kRectVisible(HDC  hDC,
-                      CONST PRECT  rc);
-
-BOOL  W32kSelectClipPath(HDC  hDC,
-                         int  Mode);
-
-int  W32kSelectClipRgn(HDC  hDC,
-                       HRGN  hrgn);
-
-int  W32kSetMetaRgn(HDC  hDC);
-
+int
+STDCALL
+W32kExcludeClipRect (
+	HDC	hDC,
+	int	LeftRect,
+	int	TopRect,
+	int	RightRect,
+	int	BottomRect
+	);
+int
+STDCALL
+W32kExtSelectClipRgn (
+	HDC	hDC,
+	HRGN	hrgn,
+	int	fnMode
+	);
+int
+STDCALL
+W32kGetClipBox (
+	HDC	hDC,
+	LPRECT	rc
+	);
+int
+STDCALL
+W32kGetMetaRgn (
+	HDC	hDC,
+	HRGN	hrgn
+	);
+int
+STDCALL
+W32kIntersectClipRect (
+	HDC	hDC,
+	int	LeftRect,
+	int	TopRect,
+	int	RightRect,
+	int	BottomRect
+	);
+int
+STDCALL
+W32kOffsetClipRgn (
+	HDC	hDC,
+	int	XOffset,
+	int	YOffset
+	);
+BOOL
+STDCALL
+W32kPtVisible (
+	HDC	hDC,
+	int	X,
+	int	Y
+	);
+BOOL
+STDCALL
+W32kRectVisible (
+	HDC		hDC,
+	CONST PRECT	rc
+	);
+BOOL
+STDCALL
+W32kSelectClipPath (
+	HDC	hDC,
+	int	Mode
+	);
+int
+STDCALL
+W32kSelectClipRgn (
+	HDC	hDC,
+	HRGN	hrgn
+	);
+int
+STDCALL
+W32kSetMetaRgn (
+	HDC	hDC
+	);
 #endif

reactos/include/win32k/color.h

@@ -1,59 +1,109 @@
-
 #ifndef __WIN32K_COLOR_H
 #define __WIN32K_COLOR_H
 
-BOOL  W32kAnimatePalette(HPALETTE  hpal,
-                         UINT  StartIndex,
-                         UINT  Entries,
-                         CONST PPALETTEENTRY  ppe);
-
-HPALETTE  W32kCreateHalftonePalette(HDC  hDC);
-
-HPALETTE  W32kCreatePalette(CONST PLOGPALETTE lgpl);
-
-BOOL  W32kGetColorAdjustment(HDC  hDC,
-                             LPCOLORADJUSTMENT  ca);
-
-COLORREF  W32kGetNearestColor(HDC  hDC,
-                              COLORREF  Color);
-
-UINT  W32kGetNearestPaletteIndex(HPALETTE  hpal,
-                                 COLORREF  Color);
-
-UINT  W32kGetPaletteEntries(HPALETTE  hpal,
-                            UINT  StartIndex,
-                            UINT  Entries,
-                            LPPALETTEENTRY  pe);
-
-UINT  W32kGetSystemPaletteEntries(HDC  hDC,
-                                  UINT  StartIndex,
-                                  UINT  Entries,
-                                  LPPALETTEENTRY  pe);
-
-UINT  W32kGetSystemPaletteUse(HDC  hDC);
-
-UINT  W32kRealizePalette(HDC  hDC);
-
-BOOL  W32kResizePalette(HPALETTE  hpal,
-                        UINT  Entries);
-
-HPALETTE  W32kSelectPalette(HDC  hDC,
-                            HPALETTE  hpal,
-                            BOOL  ForceBackground);
-
-BOOL  W32kSetColorAdjustment(HDC  hDC,
-                             CONST LPCOLORADJUSTMENT  ca);
-
-UINT  W32kSetPaletteEntries(HPALETTE  hpal,
-                            UINT  Start,
-                            UINT  Entries,
-                            CONST LPPALETTEENTRY  pe);
-
-UINT  W32kSetSystemPaletteUse(HDC  hDC,
-                              UINT  Usage);
-
-BOOL  W32kUnrealizeObject(HGDIOBJ  hgdiobj);
-
-BOOL  W32kUpdateColors(HDC  hDC);
-
+BOOL
+STDCALL
+W32kAnimatePalette (
+	HPALETTE		hpal,
+	UINT			StartIndex,
+	UINT			Entries,
+	CONST PPALETTEENTRY	ppe
+	);
+HPALETTE
+STDCALL
+W32kCreateHalftonePalette (
+	HDC	hDC
+	);
+HPALETTE
+STDCALL
+W32kCreatePalette (
+	CONST PLOGPALETTE	lgpl
+	);
+BOOL
+STDCALL
+W32kGetColorAdjustment (
+	HDC			hDC,
+	LPCOLORADJUSTMENT	ca
+	);
+COLORREF
+STDCALL
+W32kGetNearestColor (
+	HDC		hDC,
+	COLORREF	Color
+	);
+UINT
+STDCALL
+W32kGetNearestPaletteIndex (
+	HPALETTE	hpal,
+	COLORREF	Color
+	);
+UINT
+STDCALL
+W32kGetPaletteEntries (
+	HPALETTE	hpal,
+	UINT		StartIndex,
+	UINT		Entries,
+	LPPALETTEENTRY	pe
+	);
+UINT
+STDCALL
+W32kGetSystemPaletteEntries (
+	HDC		hDC,
+	UINT		StartIndex,
+	UINT		Entries,
+	LPPALETTEENTRY	pe
+	);
+UINT
+STDCALL
+W32kGetSystemPaletteUse (
+	HDC	hDC
+	);
+UINT
+STDCALL
+W32kRealizePalette (
+	HDC	hDC
+	);
+BOOL
+STDCALL
+W32kResizePalette (
+	HPALETTE	hpal,
+	UINT		Entries
+	);
+HPALETTE
+STDCALL
+W32kSelectPalette (
+	HDC		hDC,
+	HPALETTE	hpal,
+	BOOL		ForceBackground
+	);
+BOOL
+STDCALL
+W32kSetColorAdjustment (
+	HDC			hDC,
+	CONST LPCOLORADJUSTMENT	ca
+	);
+UINT
+STDCALL
+W32kSetPaletteEntries (
+	HPALETTE		hpal,
+	UINT			Start,
+	UINT			Entries,
+	CONST LPPALETTEENTRY	pe
+	);
+UINT
+STDCALL
+W32kSetSystemPaletteUse (
+	HDC	hDC,
+	UINT	Usage
+	);
+BOOL
+STDCALL
+W32kUnrealizeObject (
+	HGDIOBJ	hgdiobj
+	);
+BOOL
+STDCALL
+W32kUpdateColors (
+	HDC	hDC
+	);
 #endif

reactos/include/win32k/coord.h

@@ -1,80 +1,129 @@
-
 #ifndef __WIN32K_COORD_H
 #define __WIN32K_COORD_H
 
-BOOL  W32kCombineTransform(LPXFORM  XformResult,
-                           CONST LPXFORM  xform1,
-                           CONST LPXFORM  xform2);
-
-BOOL  W32kDPtoLP(HDC  hDC,
-                 LPPOINT  Points,
-                 int  Count);
-
-int  W32kGetGraphicsMode(HDC  hDC);
-
-BOOL  W32kGetWorldTransform(HDC  hDC,
-                            LPXFORM  Xform);
-
-BOOL  W32kLPtoDP(HDC  hDC,
-                 LPPOINT  Points,
-                 int  Count);
-
-BOOL  W32kModifyWorldTransform(HDC  hDC,
-                               CONST LPXFORM  Xform,
-                               DWORD  Mode);
-
-BOOL  W32kOffsetViewportOrgEx(HDC  hDC,
-                              int  XOffset,
-                              int  YOffset,
-                              LPPOINT  Point);
-
-BOOL  W32kOffsetWindowOrgEx(HDC  hDC,
-                            int  XOffset,
-                            int  YOffset,
-                            LPPOINT  Point);
-
-BOOL  W32kScaleViewportExtEx(HDC  hDC,
-                             int  Xnum,
-                             int  Xdenom,
-                             int  Ynum,
-                             int  Ydenom,
-                             LPSIZE  Size);
-
-BOOL  W32kScaleWindowExtEx(HDC  hDC,
-                           int  Xnum,
-                           int  Xdenom,
-                           int  Ynum,
-                           int  Ydenom,
-                           LPSIZE  Size);
-
-int  W32kSetGraphicsMode(HDC  hDC,
-                         int  Mode);
-
-int  W32kSetMapMode(HDC  hDC,
-                    int  MapMode);
-
-BOOL  W32kSetViewportExtEx(HDC  hDC,
-                           int  XExtent,
-                           int  YExtent,
-                           LPSIZE  Size);
-
-BOOL  W32kSetViewportOrgEx(HDC  hDC,
-                           int  X,
-                           int  Y,
-                           LPPOINT  Point);
-
-BOOL  W32kSetWindowExtEx(HDC  hDC,
-                         int  XExtent,
-                         int  YExtent,
-                         LPSIZE  Size);
-
-BOOL  W32kSetWindowOrgEx(HDC  hDC,
-                         int  X,
-                         int  Y,
-                         LPPOINT  Point);
-
-BOOL  W32kSetWorldTransform(HDC  hDC,
-                            CONST LPXFORM  Xform);
-
+BOOL
+STDCALL
+W32kCombineTransform (
+	LPXFORM		XformResult,
+	CONST LPXFORM	xform1,
+	CONST LPXFORM	xform2
+	);
+BOOL
+STDCALL
+W32kDPtoLP (
+	HDC	hDC,
+	LPPOINT	Points,
+	int	Count
+	);
+int
+STDCALL
+W32kGetGraphicsMode (
+	HDC	hDC
+	);
+BOOL
+STDCALL
+W32kGetWorldTransform (
+	HDC	hDC,
+	LPXFORM	Xform
+	);
+BOOL
+STDCALL
+W32kLPtoDP (
+	HDC	hDC,
+	LPPOINT	Points,
+	int	Count
+	);
+BOOL
+STDCALL
+W32kModifyWorldTransform (
+	HDC		hDC,
+	CONST LPXFORM	Xform,
+	DWORD		Mode
+	);
+BOOL
+STDCALL
+W32kOffsetViewportOrgEx (
+	HDC	hDC,
+	int	XOffset,
+	int	YOffset,
+	LPPOINT	Point
+	);
+BOOL
+STDCALL
+W32kOffsetWindowOrgEx (
+	HDC	hDC,
+	int	XOffset,
+	int	YOffset,
+	LPPOINT	Point
+	);
+BOOL
+STDCALL
+W32kScaleViewportExtEx (
+	HDC	hDC,
+	int	Xnum,
+	int	Xdenom,
+	int	Ynum,
+	int	Ydenom,
+	LPSIZE	Size
+	);
+BOOL
+STDCALL
+W32kScaleWindowExtEx (
+	HDC	hDC,
+	int	Xnum,
+	int	Xdenom,
+	int	Ynum,
+	int	Ydenom,
+	LPSIZE  Size
+	);
+int
+STDCALL
+W32kSetGraphicsMode (
+	HDC	hDC,
+	int	Mode
+	);
+int
+STDCALL
+W32kSetMapMode (
+	HDC	hDC,
+	int	MapMode
+	);
+BOOL
+STDCALL
+W32kSetViewportExtEx (
+	HDC	hDC,
+	int	XExtent,
+	int	YExtent,
+	LPSIZE	Size
+	);
+BOOL
+STDCALL
+W32kSetViewportOrgEx (
+	HDC	hDC,
+	int	X,
+	int	Y,
+	LPPOINT	Point
+	);
+BOOL
+STDCALL
+W32kSetWindowExtEx (
+	HDC	hDC,
+	int	XExtent,
+	int	YExtent,
+	LPSIZE	Size
+	);
+BOOL
+STDCALL
+W32kSetWindowOrgEx (
+	HDC	hDC,
+	int	X,
+	int	Y,
+	LPPOINT	Point
+	);
+BOOL
+STDCALL
+W32kSetWorldTransform (
+	HDC		hDC,
+	CONST LPXFORM	Xform
+	);
 #endif
-

reactos/include/win32k/fillshap.h

@@ -1,8 +1,9 @@
-
 #ifndef __WIN32K_FILLSHAP_H
 #define __WIN32K_FILLSHAP_H
 
-BOOL  W32kChord(HDC  hDC,
+BOOL
+STDCALL
+W32kChord(HDC  hDC,
                 int  LeftRect,
                 int  TopRect,
                 int  RightRect,
@@ -12,13 +13,17 @@ BOOL  W32kChord(HDC  hDC,
                 int  XRadial2,
                 int  YRadial2);
 
-BOOL  W32kEllipse(HDC  hDC,
+BOOL
+STDCALL
+W32kEllipse(HDC  hDC,
                   int  LeftRect,
                   int  TopRect,
                   int  RightRect,
                   int  BottomRect);
 
-BOOL  W32kPie(HDC  hDC,
+BOOL
+STDCALL
+W32kPie(HDC  hDC,
               int  LeftRect,
               int  TopRect,
               int  RightRect,
@@ -28,22 +33,30 @@ BOOL  W32kPie(HDC  hDC,
               int  XRadial2,
               int  YRadial2);
 
-BOOL  W32kPolygon(HDC  hDC,
+BOOL
+STDCALL
+W32kPolygon(HDC  hDC,
                   CONST PPOINT  Points,
                   int  Count);
 
-BOOL  W32kPolyPolygon(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyPolygon(HDC  hDC,
                       CONST LPPOINT  Points,
                       CONST LPINT  PolyCounts,
                       int  Count);
 
-BOOL  W32kRectangle(HDC  hDC,
+BOOL
+STDCALL
+W32kRectangle(HDC  hDC,
                     int  LeftRect,
                     int  TopRect,
                     int  RightRect,
                     int  BottomRect);
 
-BOOL  W32kRoundRect(HDC  hDC,
+BOOL
+STDCALL
+W32kRoundRect(HDC  hDC,
                     int  LeftRect,
                     int  TopRect,  
                     int  RightRect, 

reactos/include/win32k/icm.h

@@ -2,49 +2,77 @@
 #ifndef __WIN32K_ICM_H
 #define __WIN32K_ICM_H
 
-BOOL  W32kCheckColorsInGamut(HDC  hDC,
+BOOL
+STDCALL
+W32kCheckColorsInGamut(HDC  hDC,
                              LPVOID  RGBTriples,
                              LPVOID  Buffer,
                              UINT  Count);
 
-BOOL  W32kColorMatchToTarget(HDC  hDC,
+BOOL
+STDCALL
+W32kColorMatchToTarget(HDC  hDC,
                              HDC  hDCTarget, 
                              DWORD  Action);
 
-HCOLORSPACE  W32kCreateColorSpace(LPLOGCOLORSPACE  LogColorSpace);
+HCOLORSPACE
+STDCALL
+W32kCreateColorSpace(LPLOGCOLORSPACE  LogColorSpace);
 
-BOOL  W32kDeleteColorSpace(HCOLORSPACE  hColorSpace);
+BOOL
+STDCALL
+W32kDeleteColorSpace(HCOLORSPACE  hColorSpace);
 
-INT  W32kEnumICMProfiles(HDC  hDC,  
+INT
+STDCALL
+W32kEnumICMProfiles(HDC  hDC,  
                          ICMENUMPROC  EnumICMProfilesFunc,
                          LPARAM lParam);
 
-HCOLORSPACE  W32kGetColorSpace(HDC  hDC);
+HCOLORSPACE
+STDCALL
+W32kGetColorSpace(HDC  hDC);
 
-BOOL  W32kGetDeviceGammaRamp(HDC  hDC,  
+BOOL
+STDCALL
+W32kGetDeviceGammaRamp(HDC  hDC,  
                              LPVOID  Ramp);
 
-BOOL  W32kGetICMProfile(HDC  hDC,  
+BOOL
+STDCALL
+W32kGetICMProfile(HDC  hDC,  
                         LPDWORD  NameSize,  
                         LPWSTR  Filename);
 
-BOOL  W32kGetLogColorSpace(HCOLORSPACE  hColorSpace,
+BOOL
+STDCALL
+W32kGetLogColorSpace(HCOLORSPACE  hColorSpace,
                            LPLOGCOLORSPACE  Buffer,  
                            DWORD  Size);
 
-HCOLORSPACE  W32kSetColorSpace(HDC  hDC,  
+HCOLORSPACE
+STDCALL
+W32kSetColorSpace(HDC  hDC,  
                                HCOLORSPACE  hColorSpace);
 
-BOOL  W32kSetDeviceGammaRamp(HDC  hDC,
+BOOL
+STDCALL
+W32kSetDeviceGammaRamp(HDC  hDC,
                              LPVOID  Ramp);
 
-INT  W32kSetICMMode(HDC  hDC,
+INT
+STDCALL
+W32kSetICMMode(HDC  hDC,
                     INT  EnableICM);
 
-BOOL  W32kSetICMProfile(HDC  hDC,
+BOOL
+STDCALL
+W32kSetICMProfile(HDC  hDC,
                         LPWSTR  Filename);
 
-BOOL  W32kUpdateICMRegKey(DWORD  Reserved,  
+BOOL
+STDCALL
+W32kUpdateICMRegKey(DWORD  Reserved,  
                           LPWSTR  CMID, 
                           LPWSTR  Filename,
                           UINT  Command);

reactos/include/win32k/line.h

@@ -1,15 +1,18 @@
-
 #ifndef __WIN32K_LINE_H
 #define __WIN32K_LINE_H
 
-BOOL  W32kAngleArc(HDC  hDC,
+BOOL
+STDCALL
+W32kAngleArc(HDC  hDC,
                    int  X,
                    int  Y,
                    DWORD  Radius,
                    FLOAT  StartAngle,
                    FLOAT  SweepAngle);
 
-BOOL  W32kArc(HDC  hDC,
+BOOL
+STDCALL
+W32kArc(HDC  hDC,
               int  LeftRect,
               int  TopRect,
               int  RightRect, 
@@ -19,7 +22,9 @@ BOOL  W32kArc(HDC  hDC,
               int  XEndArc,  
               int  YEndArc);
 
-BOOL  W32kArcTo(HDC  hDC,
+BOOL
+STDCALL
+W32kArcTo(HDC  hDC,
                 int  LeftRect,
                 int  TopRect,
                 int  RightRect,
@@ -29,44 +34,64 @@ BOOL  W32kArcTo(HDC  hDC,
                 int  XRadial2,
                 int  YRadial2);
 
-int  W32kGetArcDirection(HDC  hDC);
+int
+STDCALL
+W32kGetArcDirection(HDC  hDC);
 
-BOOL  W32kLineTo(HDC  hDC,
+BOOL
+STDCALL
+W32kLineTo(HDC  hDC,
                  int  XEnd,
                  int  YEnd);
 
-BOOL  W32kMoveToEx(HDC  hDC,
+BOOL
+STDCALL
+W32kMoveToEx(HDC  hDC,
                    int  X,
                    int  Y,
                    LPPOINT  Point);
 
-BOOL  W32kPolyBezier(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyBezier(HDC  hDC,
                      CONST LPPOINT  pt,
                      DWORD  Count);
 
-BOOL  W32kPolyBezierTo(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyBezierTo(HDC  hDC,
                        CONST LPPOINT  pt,
                        DWORD  Count);
 
-BOOL  W32kPolyDraw(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyDraw(HDC  hDC,
                    CONST LPPOINT  pt,
                    CONST LPBYTE  Types,
                    int  Count);
 
-BOOL  W32kPolyline(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyline(HDC  hDC,
                    CONST LPPOINT  pt,
                    int  Count);
 
-BOOL  W32kPolylineTo(HDC  hDC,
+BOOL
+STDCALL
+W32kPolylineTo(HDC  hDC,
                      CONST LPPOINT  pt,
                      DWORD  Count);
 
-BOOL  W32kPolyPolyline(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyPolyline(HDC  hDC,
                        CONST LPPOINT  pt,
                        CONST LPDWORD  PolyPoints,
                        DWORD  Count);
 
-int  W32kSetArcDirection(HDC  hDC,
+int
+STDCALL
+W32kSetArcDirection(HDC  hDC,
                          int  ArcDirection);
 
 #endif

reactos/include/win32k/metafile.h

@@ -1,101 +1,179 @@
-
 #ifndef __WIN32K_METAFILE_H
 #define __WIN32K_METAFILE_H
 
-HENHMETAFILE  W32kCloseEnhMetaFile(HDC  hDC);
-
-HMETAFILE  W32kCloseMetaFile(HDC  hDC);
-
-HENHMETAFILE  W32kCopyEnhMetaFile(HENHMETAFILE  Src,
-                                  LPCWSTR  File);
-
-HMETAFILE  W32kCopyMetaFile(HMETAFILE  Src,
-                            LPCWSTR  File);
-
-HDC  W32kCreateEnhMetaFile(HDC  hDCRef,
-                           LPCWSTR  File,
-                           CONST LPRECT  Rect,
-                           LPCWSTR  Description);
-
-HDC  W32kCreateMetaFile(LPCWSTR  File);
-
-BOOL  W32kDeleteEnhMetaFile(HENHMETAFILE  emf);
-
-BOOL  W32kDeleteMetaFile(HMETAFILE  mf);
-
-BOOL  W32kEnumEnhMetaFile(HDC  hDC,
-                          HENHMETAFILE  emf,
-                          ENHMFENUMPROC  EnhMetaFunc,
-                          LPVOID  Data,
-                          CONST LPRECT  Rect);
-
-BOOL  W32kEnumMetaFile(HDC  hDC,
-                       HMETAFILE  mf,
-                       MFENUMPROC  MetaFunc,
-                       LPARAM  lParam);
-
-BOOL  W32kGdiComment(HDC  hDC,
-                     UINT  Size,
-                     CONST LPBYTE  Data);
-
-HENHMETAFILE  W32kGetEnhMetaFile(LPCWSTR  MetaFile);
-
-UINT  W32kGetEnhMetaFileBits(HENHMETAFILE  hemf,
-                             UINT  BufSize,
-                             LPBYTE  Buffer);
-
-UINT  W32kGetEnhMetaFileDescription(HENHMETAFILE  hemf,
-                                    UINT  BufSize,
-                                    LPWSTR  Description);
-
-UINT  W32kGetEnhMetaFileHeader(HENHMETAFILE  hemf,
-                               UINT  BufSize,
-                               LPENHMETAHEADER  emh);
-
-UINT  W32kGetEnhMetaFilePaletteEntries(HENHMETAFILE  hemf,
-                                       UINT  Entries,
-                                       LPPALETTEENTRY  pe);
-
-HMETAFILE  W32kGetMetaFile(LPCWSTR  MetaFile);
-
-UINT  W32kGetMetaFileBitsEx(HMETAFILE  hmf,
-                            UINT  Size,
-                            LPVOID  Data);
-
-UINT  W32kGetWinMetaFileBits(HENHMETAFILE  hemf,
-                             UINT  BufSize,
-                             LPBYTE  Buffer,
-                             INT  MapMode,
-                             HDC  Ref);
-
-BOOL  W32kPlayEnhMetaFile(HDC  hDC,
-                          HENHMETAFILE  hemf,
-                          CONST PRECT  Rect);
-
-BOOL  W32kPlayEnhMetaFileRecord(HDC  hDC,
-                                LPHANDLETABLE  Handletable,
-                                CONST ENHMETARECORD *EnhMetaRecord,
-                                UINT  Handles);
-
-BOOL  W32kPlayMetaFile(HDC  hDC,
-                       HMETAFILE  hmf);
-
-BOOL  W32kPlayMetaFileRecord(HDC  hDC,
-                             LPHANDLETABLE  Handletable,
-                             LPMETARECORD  MetaRecord,
-                             UINT  Handles);
-
-HENHMETAFILE  W32kSetEnhMetaFileBits(UINT  BufSize,
-                                     CONST PBYTE  Data);
-
-HMETAFILE  W32kSetMetaFileBitsEx(UINT  Size,
-                                 CONST PBYTE  Data);
-
+HENHMETAFILE
+STDCALL
+W32kCloseEnhMetaFile (
+	HDC	hDC
+	);
+HMETAFILE
+STDCALL
+W32kCloseMetaFile (
+	HDC	hDC
+	);
+HENHMETAFILE
+STDCALL
+W32kCopyEnhMetaFile (
+	HENHMETAFILE	Src,
+	LPCWSTR		File
+	);
+HMETAFILE
+STDCALL
+W32kCopyMetaFile (
+	HMETAFILE	Src,
+	LPCWSTR		File
+	);
+HDC
+STDCALL
+W32kCreateEnhMetaFile (
+	HDC		hDCRef,
+	LPCWSTR		File,
+	CONST LPRECT	Rect,
+	LPCWSTR		Description
+	);
+HDC
+STDCALL
+W32kCreateMetaFile (
+	LPCWSTR		File
+	);
+BOOL
+STDCALL
+W32kDeleteEnhMetaFile (
+	HENHMETAFILE	emf
+	);
+BOOL
+STDCALL
+W32kDeleteMetaFile (
+	HMETAFILE	mf
+	);
+BOOL
+STDCALL
+W32kEnumEnhMetaFile (
+	HDC		hDC,
+	HENHMETAFILE	emf,
+	ENHMFENUMPROC	EnhMetaFunc,
+	LPVOID		Data,
+	CONST LPRECT	Rect
+	);
+BOOL
+STDCALL
+W32kEnumMetaFile (
+	HDC		hDC,
+	HMETAFILE	mf,
+	MFENUMPROC	MetaFunc,
+	LPARAM		lParam
+	);
+BOOL
+STDCALL
+W32kGdiComment (
+	HDC		hDC,
+	UINT		Size,
+	CONST LPBYTE	Data
+	);
+HENHMETAFILE
+STDCALL
+W32kGetEnhMetaFile (
+	LPCWSTR	MetaFile
+	);
+UINT
+STDCALL
+W32kGetEnhMetaFileBits (
+	HENHMETAFILE	hemf,
+	UINT		BufSize,
+	LPBYTE		Buffer
+	);
+UINT
+STDCALL
+W32kGetEnhMetaFileDescription (
+	HENHMETAFILE	hemf,
+	UINT		BufSize,
+	LPWSTR		Description
+	);
+UINT
+STDCALL
+W32kGetEnhMetaFileHeader (
+	HENHMETAFILE	hemf,
+	UINT		BufSize,
+	LPENHMETAHEADER	emh
+	);
+UINT
+STDCALL
+W32kGetEnhMetaFilePaletteEntries (
+	HENHMETAFILE	hemf,
+	UINT		Entries,
+	LPPALETTEENTRY	pe
+	);
+HMETAFILE
+STDCALL
+W32kGetMetaFile (
+	LPCWSTR	MetaFile
+	);
+UINT
+STDCALL
+W32kGetMetaFileBitsEx (
+	HMETAFILE	hmf,
+	UINT		Size,
+	LPVOID		Data
+	);
+UINT
+STDCALL
+W32kGetWinMetaFileBits (
+	HENHMETAFILE	hemf,
+	UINT		BufSize,
+	LPBYTE		Buffer,
+	INT		MapMode,
+	HDC		Ref
+	);
+BOOL
+STDCALL
+W32kPlayEnhMetaFile (
+	HDC		hDC,
+	HENHMETAFILE	hemf,
+	CONST PRECT	Rect
+	);
+BOOL
+STDCALL
+W32kPlayEnhMetaFileRecord (
+	HDC			hDC,
+	LPHANDLETABLE		Handletable,
+	CONST ENHMETARECORD	* EnhMetaRecord,
+	UINT			Handles
+	);
+BOOL
+STDCALL
+W32kPlayMetaFile (
+	HDC		hDC,
+	HMETAFILE	hmf
+	);
+BOOL
+STDCALL
+W32kPlayMetaFileRecord (
+	HDC		hDC,
+	LPHANDLETABLE	Handletable,
+	LPMETARECORD	MetaRecord,
+	UINT		Handles
+	);
+HENHMETAFILE
+STDCALL
+W32kSetEnhMetaFileBits (
+	UINT		BufSize,
+	CONST PBYTE	Data
+	);
+HMETAFILE
+STDCALL
+W32kSetMetaFileBitsEx (
+	UINT		Size,
+	CONST PBYTE	Data
+	);
 #if 0
-HENHMETAFILE  W32kSetWinMetaFileBits(UINT  BufSize,
-                                     CONST PBYTE  Buffer,
-                                     HDC  Ref,
-                                     CONST METAFILEPICT *mfp);
+HENHMETAFILE
+STDCALL
+W32kSetWinMetaFileBits (
+	UINT			BufSize,
+	CONST PBYTE		Buffer,
+	HDC			Ref,
+	CONST METAFILEPICT	* mfp
+	);
 #endif
 
 #endif

reactos/include/win32k/paint.h

@@ -1,23 +1,12 @@
-
 #ifndef __WIN32K_PAINT_H
 #define __WIN32K_PAINT_H
 
-BOOL  W32kGdiFlush(VOID);
-
-DWORD  W32kGdiGetBatchLimit(VOID);
-
-DWORD  W32kGdiSetBatchLimit(DWORD  Limit);
-
-UINT  W32kGetBoundsRect(HDC  hDC,
-                        LPRECT  Bounds,
-                        UINT  Flags);
-
-COLORREF  W32kSetBkColor(HDC  hDC,
-                         COLORREF  Color);
-
-UINT  W32kSetBoundsRect(HDC  hDC,
-                        CONST PRECT  Bounds,
-                        UINT  Flags);
+BOOL STDCALL W32kGdiFlush (VOID);
+DWORD STDCALL W32kGdiGetBatchLimit (VOID);
+DWORD STDCALL W32kGdiSetBatchLimit (DWORD  Limit);
+UINT STDCALL W32kGetBoundsRect (HDC hDC, LPRECT Bounds, UINT Flags);
+COLORREF STDCALL W32kSetBkColor (HDC hDC, COLORREF Color);
+UINT STDCALL W32kSetBoundsRect (HDC hDC, CONST PRECT Bounds, UINT Flags);
 
 #endif
 

reactos/include/win32k/path.h

@@ -1,40 +1,36 @@
-
 #ifndef __WIN32K_PATH_H
 #define __WIN32K_PATH_H
 
-BOOL  W32kAbortPath(HDC  hDC);
+BOOL STDCALL W32kAbortPath(HDC  hDC);
 
-BOOL  W32kBeginPath(HDC  hDC);
+BOOL STDCALL W32kBeginPath(HDC  hDC);
 
-BOOL  W32kCloseFigure(HDC  hDC);
+BOOL STDCALL W32kCloseFigure(HDC  hDC);
 
-BOOL  W32kEndPath(HDC  hDC);
+BOOL STDCALL W32kEndPath(HDC  hDC);
 
-BOOL  W32kFillPath(HDC  hDC);
+BOOL STDCALL W32kFillPath(HDC  hDC);
 
-BOOL  W32kFlattenPath(HDC  hDC);
+BOOL STDCALL W32kFlattenPath(HDC  hDC);
 
-BOOL  W32kGetMiterLimit(HDC  hDC,
+BOOL STDCALL W32kGetMiterLimit(HDC  hDC,
                         PFLOAT  Limit);
 
-INT  W32kGetPath(HDC  hDC,
+INT STDCALL W32kGetPath(HDC  hDC,
                  LPPOINT  Points,
                  LPBYTE  Types,
                  INT  nSize);
 
-HRGN  W32kPathToRegion(HDC  hDC);
+HRGN STDCALL W32kPathToRegion(HDC  hDC);
 
-BOOL  W32kSetMiterLimit(HDC  hDC,
+BOOL STDCALL W32kSetMiterLimit(HDC  hDC,
                         FLOAT  NewLimit,
                         PFLOAT  OldLimit);
 
-BOOL  W32kStrokeAndFillPath(HDC  hDC);
-
-BOOL  W32kStrokePath(HDC  hDC);
-
-BOOL  W32kWidenPath(HDC  hDC);
+BOOL STDCALL W32kStrokeAndFillPath(HDC  hDC);
 
+BOOL STDCALL W32kStrokePath(HDC  hDC);
 
+BOOL STDCALL W32kWidenPath(HDC  hDC);
 
 #endif
-

reactos/include/win32k/pen.h

@@ -2,13 +2,13 @@
 #ifndef __WIN32K_PEN_H
 #define __WIN32K_PEN_H
 
-HPEN  W32kCreatePen(INT  PenStyle,
+HPEN STDCALL W32kCreatePen(INT  PenStyle,
                     INT  Width,
                     COLORREF  Color);
 
-HPEN  W32kCreatePenIndirect(CONST PLOGPEN  lgpn);
+HPEN STDCALL W32kCreatePenIndirect(CONST PLOGPEN  lgpn);
 
-HPEN  W32kExtCreatePen(DWORD  PenStyle,
+HPEN STDCALL W32kExtCreatePen(DWORD  PenStyle,
                        DWORD  Width,
                        CONST PLOGBRUSH  lb,
                        DWORD  StyleCount,

reactos/include/win32k/print.h

@@ -2,31 +2,47 @@
 #ifndef __WIN32K_PRINT_H
 #define __WIN32K_PRINT_H
 
-INT  W32kAbortDoc(HDC  hDC);
+INT
+STDCALL
+W32kAbortDoc(HDC  hDC);
 
-INT  W32kEndDoc(HDC  hDC);
+INT
+STDCALL
+W32kEndDoc(HDC  hDC);
 
-INT  W32kEndPage(HDC  hDC);
+INT
+STDCALL
+W32kEndPage(HDC  hDC);
 
-INT  W32kEscape(HDC  hDC,
+INT
+STDCALL
+W32kEscape(HDC  hDC,
                 INT  Escape,
                 INT  InSize,
                 LPCSTR  InData,
                 LPVOID  OutData);
 
-INT  W32kExtEscape(HDC  hDC,
+INT
+STDCALL
+W32kExtEscape(HDC  hDC,
                    INT  Escape,
                    INT  InSize,
                    LPCSTR  InData,
                    INT  OutSize,
                    LPSTR  OutData);
 
-INT  W32kSetAbortProc(HDC  hDC,
+INT
+STDCALL
+W32kSetAbortProc(HDC  hDC,
                       ABORTPROC  AbortProc);
 
-INT  W32kStartDoc(HDC  hDC,
+INT
+STDCALL
+W32kStartDoc(HDC  hDC,
                   CONST PDOCINFO  di);
 
-INT  W32kStartPage(HDC  hDC);
+INT
+STDCALL
+W32kStartPage(HDC  hDC);
 
 #endif

reactos/include/win32k/region.h

@@ -2,79 +2,117 @@
 #ifndef __WIN32K_REGION_H
 #define __WIN32K_REGION_H
 
-INT  W32kCombineRgn(HRGN  hDest,
+INT
+STDCALL
+W32kCombineRgn(HRGN  hDest,
                     HRGN  hSrc1,
                     HRGN  hSrc2,
                     INT  CombineMode);
 
-HRGN  W32kCreateEllipticRgn(INT  LeftRect,
+HRGN
+STDCALL
+W32kCreateEllipticRgn(INT  LeftRect,
                             INT  TopRect,
                             INT  RightRect,
                             INT  BottomRect);
 
-HRGN  W32kCreateEllipticRgnIndirect(CONST PRECT  rc);
+HRGN
+STDCALL
+W32kCreateEllipticRgnIndirect(CONST PRECT  rc);
 
-HRGN  W32kCreatePolygonRgn(CONST PPOINT  pt,
+HRGN
+STDCALL
+W32kCreatePolygonRgn(CONST PPOINT  pt,
                            INT  Count,
                            INT  PolyFillMode);
 
-HRGN  W32kCreatePolyPolygonRgn(CONST PPOINT  pt,
+HRGN
+STDCALL
+W32kCreatePolyPolygonRgn(CONST PPOINT  pt,
                                CONST PINT  PolyCounts,
                                INT  Count,
                                INT  PolyFillMode);
 
-HRGN  W32kCreateRectRgn(INT  LeftRect,
+HRGN
+STDCALL
+W32kCreateRectRgn(INT  LeftRect,
                         INT  TopRect,
                         INT  RightRect,
                         INT  BottomRect);
 
-HRGN  W32kCreateRectRgnIndirect(CONST PRECT  rc);
+HRGN
+STDCALL
+W32kCreateRectRgnIndirect(CONST PRECT  rc);
 
-HRGN  W32kCreateRoundRectRgn(INT  LeftRect,
+HRGN
+STDCALL
+W32kCreateRoundRectRgn(INT  LeftRect,
                              INT  TopRect,
                              INT  RightRect,
                              INT  BottomRect,
                              INT  WidthEllipse,
                              INT  HeightEllipse);
 
-BOOL  W32kEqualRgn(HRGN  hSrcRgn1,
+BOOL
+STDCALL
+W32kEqualRgn(HRGN  hSrcRgn1,
                    HRGN  hSrcRgn2);
 
-HRGN  W32kExtCreateRegion(CONST PXFORM  Xform,
+HRGN
+STDCALL
+W32kExtCreateRegion(CONST PXFORM  Xform,
                           DWORD  Count,
                           CONST PRGNDATA  RgnData);
 
-BOOL  W32kFillRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kFillRgn(HDC  hDC,
                   HRGN  hRgn,
                   HBRUSH  hBrush);
 
-BOOL  W32kFrameRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kFrameRgn(HDC  hDC,
                    HRGN  hRgn,
                    HBRUSH  hBrush,
                    INT  Width,
                    INT  Height);
 
-INT  W32kGetRgnBox(HRGN  hRgn,
+INT
+STDCALL
+W32kGetRgnBox(HRGN  hRgn,
                    LPRECT  Rect);
 
-BOOL  W32kInvertRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kInvertRgn(HDC  hDC,
                     HRGN  hRgn);
 
-INT  W32kOffsetRgn(HRGN  hRgn,
+INT
+STDCALL
+W32kOffsetRgn(HRGN  hRgn,
                    INT  XOffset,
                    INT  YOffset);
 
-BOOL  W32kPaintRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kPaintRgn(HDC  hDC,
                    HRGN  hRgn);
 
-BOOL  W32kPtInRegion(HRGN  hRgn,
+BOOL
+STDCALL
+W32kPtInRegion(HRGN  hRgn,
                      INT  X,
                      INT  Y);
 
-BOOL  W32kRectInRegion(HRGN  hRgn,
+BOOL
+STDCALL
+W32kRectInRegion(HRGN  hRgn,
                        CONST LPRECT  rc);
 
-BOOL  W32kSetRectRgn(HRGN  hRgn,
+BOOL
+STDCALL
+W32kSetRectRgn(HRGN  hRgn,
                      INT  LeftRect,
                      INT  TopRect,
                      INT  RightRect,

reactos/include/win32k/text.h

@@ -2,9 +2,13 @@
 #ifndef __WIN32K_TEXT_H
 #define __WIN32K_TEXT_H
 
-int  W32kAddFontResource(LPCWSTR  Filename);
+int
+STDCALL
+W32kAddFontResource(LPCWSTR  Filename);
 
-HFONT  W32kCreateFont(int  Height,
+HFONT
+STDCALL
+W32kCreateFont(int  Height,
                       int  Width,
                       int  Escapement,
                       int  Orientation,
@@ -19,30 +23,42 @@ HFONT  W32kCreateFont(int  Height,
                       DWORD  PitchAndFamily,
                       LPCWSTR  Face);
 
-HFONT  W32kCreateFontIndirect(CONST LPLOGFONT lf);
+HFONT
+STDCALL
+W32kCreateFontIndirect(CONST LPLOGFONT lf);
 
-BOOL  W32kCreateScalableFontResource(DWORD  Hidden,
+BOOL
+STDCALL
+W32kCreateScalableFontResource(DWORD  Hidden,
                                      LPCWSTR  FontRes,
                                      LPCWSTR  FontFile,
                                      LPCWSTR  CurrentPath);
 
-int  W32kEnumFontFamilies(HDC  hDC,
+int
+STDCALL
+W32kEnumFontFamilies(HDC  hDC,
                           LPCWSTR  Family,
                           FONTENUMPROC  EnumFontFamProc,
                           LPARAM  lParam);
 
-int  W32kEnumFontFamiliesEx(HDC  hDC,
+int
+STDCALL
+W32kEnumFontFamiliesEx(HDC  hDC,
                             LPLOGFONT  Logfont,
                             FONTENUMPROC  EnumFontFamExProc,
                             LPARAM  lParam,
                             DWORD  Flags);
 
-int  W32kEnumFonts(HDC  hDC,
+int
+STDCALL
+W32kEnumFonts(HDC  hDC,
                    LPCWSTR FaceName,
                    FONTENUMPROC  FontFunc,
                    LPARAM  lParam);
 
-BOOL  W32kExtTextOut(HDC  hDC,
+BOOL
+STDCALL
+W32kExtTextOut(HDC  hDC,
                      int  X,
                      int  Y,
                      UINT  Options,
@@ -51,44 +67,62 @@ BOOL  W32kExtTextOut(HDC  hDC,
                      UINT  Count,
                      CONST LPINT  Dx);
 
-BOOL  W32kGetAspectRatioFilterEx(HDC  hDC,
+BOOL
+STDCALL
+W32kGetAspectRatioFilterEx(HDC  hDC,
                                  LPSIZE  AspectRatio);
 
-BOOL  W32kGetCharABCWidths(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharABCWidths(HDC  hDC,
                            UINT  FirstChar,
                            UINT  LastChar,
                            LPABC  abc);
 
-BOOL  W32kGetCharABCWidthsFloat(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharABCWidthsFloat(HDC  hDC,
                                 UINT  FirstChar,
                                 UINT  LastChar,
                                 LPABCFLOAT  abcF);
 
-DWORD  W32kGetCharacterPlacement(HDC  hDC,
+DWORD
+STDCALL
+W32kGetCharacterPlacement(HDC  hDC,
                                  LPCWSTR  String,
                                  int  Count,
                                  int  MaxExtent,
                                  LPGCP_RESULTS  Results,
                                  DWORD  Flags);
 
-BOOL  W32kGetCharWidth(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharWidth(HDC  hDC,
                        UINT  FirstChar,
                        UINT  LastChar,
                        LPINT  Buffer);
 
-BOOL  W32kGetCharWidth32(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharWidth32(HDC  hDC,
                          UINT  FirstChar,
                          UINT  LastChar,
                          LPINT  Buffer);
 
-BOOL  W32kGetCharWidthFloat(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharWidthFloat(HDC  hDC,
                             UINT  FirstChar,
                             UINT  LastChar,
                             PFLOAT  Buffer);
 
-DWORD  W32kGetFontLanguageInfo(HDC  hDC);
+DWORD
+STDCALL
+W32kGetFontLanguageInfo(HDC  hDC);
 
-DWORD  W32kGetGlyphOutline(HDC  hDC,
+DWORD
+STDCALL
+W32kGetGlyphOutline(HDC  hDC,
                            UINT  Char,
                            UINT  Format,
                            LPGLYPHMETRICS  gm,
@@ -96,24 +130,36 @@ DWORD  W32kGetGlyphOutline(HDC  hDC,
                            LPVOID  Buffer,
                            CONST LPMAT2 mat2);
 
-DWORD  W32kGetKerningPairs(HDC  hDC,
+DWORD
+STDCALL
+W32kGetKerningPairs(HDC  hDC,
                            DWORD  NumPairs,
                            LPKERNINGPAIR  krnpair);
 
-UINT  W32kGetOutlineTextMetrics(HDC  hDC,
+UINT
+STDCALL
+W32kGetOutlineTextMetrics(HDC  hDC,
                                 UINT  Data,
                                 LPOUTLINETEXTMETRIC  otm);
 
-BOOL  W32kGetRasterizerCaps(LPRASTERIZER_STATUS  rs,
+BOOL
+STDCALL
+W32kGetRasterizerCaps(LPRASTERIZER_STATUS  rs,
                             UINT  Size);
 
-UINT  W32kGetTextCharset(HDC  hDC);
+UINT
+STDCALL
+W32kGetTextCharset(HDC  hDC);
 
-UINT  W32kGetTextCharsetInfo(HDC  hDC,
+UINT
+STDCALL
+W32kGetTextCharsetInfo(HDC  hDC,
                              LPFONTSIGNATURE  Sig,
                              DWORD  Flags);
 
-BOOL  W32kGetTextExtentExPoint(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextExtentExPoint(HDC  hDC,
                                LPCWSTR String,
                                int  Count,
                                int  MaxExtent,
@@ -121,49 +167,73 @@ BOOL  W32kGetTextExtentExPoint(HDC  hDC,
                                LPINT  Dx,
                                LPSIZE  Size);
 
-BOOL  W32kGetTextExtentPoint(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextExtentPoint(HDC  hDC,
                              LPCWSTR  String,
                              int  Count,
                              LPSIZE  Size);
 
-BOOL  W32kGetTextExtentPoint32(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextExtentPoint32(HDC  hDC,
                                LPCWSTR  String,
                                int  Count,
                                LPSIZE  Size);
 
-int  W32kGetTextFace(HDC  hDC,
+int
+STDCALL
+W32kGetTextFace(HDC  hDC,
                      int  Count,
                      LPWSTR  FaceName);
 
-BOOL  W32kGetTextMetrics(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextMetrics(HDC  hDC,
                          LPTEXTMETRIC  tm);
 
-BOOL  W32kPolyTextOut(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyTextOut(HDC  hDC,
                       CONST LPPOLYTEXT  txt,
                       int  Count);
 
-BOOL  W32kRemoveFontResource(LPCWSTR  FileName);
+BOOL
+STDCALL
+W32kRemoveFontResource(LPCWSTR  FileName);
 
-DWORD  W32kSetMapperFlags(HDC  hDC,
+DWORD
+STDCALL
+W32kSetMapperFlags(HDC  hDC,
                           DWORD  Flag);
 
-UINT  W32kSetTextAlign(HDC  hDC,
+UINT
+STDCALL
+W32kSetTextAlign(HDC  hDC,
                        UINT  Mode);
 
-COLORREF STDCALL W32kSetTextColor(HDC  hDC,
+COLORREF
+STDCALL
+W32kSetTextColor(HDC  hDC,
                            COLORREF  Color);
 
-BOOL  W32kSetTextJustification(HDC  hDC,
+BOOL
+STDCALL
+W32kSetTextJustification(HDC  hDC,
                                int  BreakExtra,
                                int  BreakCount);
 
-BOOL  W32kTextOut(HDC  hDC,
+BOOL
+STDCALL
+W32kTextOut(HDC  hDC,
                   int  XStart,
                   int  YStart,
                   LPCWSTR  String,
                   int  Count);
 
-UINT  W32kTranslateCharsetInfo(PDWORD  Src,
+UINT
+STDCALL
+W32kTranslateCharsetInfo(PDWORD  Src,
                                LPCHARSETINFO  CSI,   
                                DWORD  Flags);
 

reactos/include/win32k/win32k.h

@@ -1,20 +1 @@
-
-#include <win32k/bitmaps.h>
-#include <win32k/brush.h>
-#include <win32k/cliprgn.h>
-#include <win32k/color.h>
-#include <win32k/coord.h>
-#include <win32k/dc.h>
-#include <win32k/debug.h>
-#include <win32k/fillshap.h>
-#include <win32k/icm.h>
-#include <win32k/line.h>
-#include <win32k/metafile.h>
-#include <win32k/paint.h>
-#include <win32k/path.h>
-#include <win32k/pen.h>
-#include <win32k/print.h>
-#include <win32k/region.h>
-#include <win32k/text.h>
-#include <win32k/wingl.h>
-
+#include <win32k/kapi.h>

reactos/include/win32k/wingl.h

@@ -2,25 +2,37 @@
 #ifndef __WIN32K_WINGL_H
 #define __WIN32K_WINGL_H
 
-INT  W32kChoosePixelFormat(HDC  hDC,
+INT
+STDCALL
+W32kChoosePixelFormat(HDC  hDC,
                            CONST PPIXELFORMATDESCRIPTOR  pfd);
 
-INT  W32kDescribePixelFormat(HDC  hDC,
+INT
+STDCALL
+W32kDescribePixelFormat(HDC  hDC,
                              INT  PixelFormat,
                              UINT  BufSize,
                              PPIXELFORMATDESCRIPTOR  pfd);
 
-UINT  W32kGetEnhMetaFilePixelFormat(HENHMETAFILE  hEMF,
+UINT
+STDCALL
+W32kGetEnhMetaFilePixelFormat(HENHMETAFILE  hEMF,
                                     DWORD  BufSize, 
                                     CONST PPIXELFORMATDESCRIPTOR  pfd);
 
-INT  W32kGetPixelFormat(HDC  hDC);
+INT
+STDCALL
+W32kGetPixelFormat(HDC  hDC);
 
-BOOL  W32kSetPixelFormat(HDC  hDC,
+BOOL
+STDCALL
+W32kSetPixelFormat(HDC  hDC,
                          INT  PixelFormat,
                          CONST PPIXELFORMATDESCRIPTOR  pfd);
 
-BOOL  W32kSwapBuffers(HDC  hDC);
+BOOL
+STDCALL
+W32kSwapBuffers(HDC  hDC);
 
 #endif
 

reactos/lib/gdi32/makefile

@@ -1,4 +1,4 @@
-# $Id: makefile,v 1.8 1999/08/29 13:44:54 dwelch Exp $
+# $Id: makefile,v 1.9 2000/02/20 22:52:48 ea Exp $
 #
 # Makefile for ReactOS gdi32.dll
 #
@@ -20,7 +20,7 @@ all: $(DLLTARGET)
 
 MAIN_OBJECTS = main/dllmain.o
 
-MISC_OBJECTS = misc/stubs.o misc/stubsa.o misc/stubsw.o
+MISC_OBJECTS = misc/stubs.o misc/stubsa.o misc/stubsw.o misc/win32k.o
 
 RESOURCE_OBJECTS = $(TARGET).coff
 
@@ -43,6 +43,7 @@ $(TARGET).dll: $(DLLMAIN) $(OBJECTS) $(TARGET).def
 		-specs=$(TARGET)_specs \
 		-mdll \
 		-o junk.tmp \
+		-Wl,--entry,_DllMain@12 \
 		-Wl,--base-file,base.tmp 
 	- $(RM) junk.tmp
 	$(DLLTOOL) \
@@ -56,6 +57,7 @@ $(TARGET).dll: $(DLLMAIN) $(OBJECTS) $(TARGET).def
 		-specs=$(TARGET)_specs \
 		-mdll \
 		-o $(TARGET).dll \
+		-Wl,--entry,_DllMain@12 \
 		-Wl,--image-base,0x70000000 \
 		-Wl,--file-alignment,0x1000 \
 		-Wl,--section-alignment,0x1000 \

reactos/lib/gdi32/misc/stubsa.c

@@ -1,4 +1,4 @@
-/* $Id: stubsa.c,v 1.1 1999/05/24 20:04:44 ea Exp $
+/* $Id: stubsa.c,v 1.2 2000/02/20 22:52:48 ea Exp $
  *
  * reactos/lib/gdi32/misc/stubs.c
  *
@@ -13,7 +13,52 @@
 #endif
 #include <windows.h>
 
+static
+LPWSTR
+STDCALL
+AnsiStringToUnicodeString (
+	LPCSTR	AnsiString,
+	LPWSTR	UnicodeString,
+	BOOLEAN	AllocateBuffer
+	)
+{
+	int	Length;
+	LPWSTR	_UnicodeString = UnicodeString;
 
+	if (	(NULL == UnicodeString)
+		&& (FALSE == AllocateBuffer)
+		)
+	{
+		return NULL;
+	}
+	Length = (lstrlenA (AnsiString) + 1);
+	if (TRUE == AllocateBuffer)
+	{
+		_UnicodeString = LocalAlloc (
+					LMEM_ZEROINIT,
+					Length
+					);
+		if (NULL == _UnicodeString)
+		{
+			return NULL;
+		}
+	}
+	Length = MultiByteToWideChar (
+			CP_ACP,
+			0,
+			AnsiString,
+			-1,
+			_UnicodeString,
+			Length
+			);
+	if (0 == Length)
+	{
+		return NULL;
+	}
+	return _UnicodeString;
+}
+
+	
 int
 STDCALL
 AddFontResourceA(
@@ -39,15 +84,78 @@ CopyMetaFileA(
 
 HDC
 STDCALL
-CreateDCA(
-	LPCSTR		a0,
-	LPCSTR		a1,
-	LPCSTR		a2,
-	CONST DEVMODE	*a3
+CreateDCA (
+	LPCSTR		lpszDriver,
+	LPCSTR		lpszDevice,
+	LPCSTR		lpszOutput,
+	CONST DEVMODE	* lpInitData
 	)
 {
-	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-	return 0;
+	LPCWSTR	lpwszDriver = NULL;
+	LPCWSTR	lpwszDevice = NULL;
+	LPCWSTR	lpwszOutput = NULL;
+	HDC	hDC;
+
+	/*
+	 * If needed, convert to Unicode
+	 * any string parameter.
+	 */
+	if (NULL != lpszDriver)
+	{
+		lpwszDriver = AnsiStringToUnicodeString (
+				lpszDriver,
+				NULL,
+				TRUE
+				);
+		if (NULL == lpwszDriver)
+		{
+			return 0;
+		}
+	}
+	if (NULL != lpszDevice)
+	{
+		lpwszDevice = AnsiStringToUnicodeString (
+				lpszDevice,
+				NULL,
+				TRUE
+				);
+		if (NULL == lpwszDevice)
+		{
+			return 0;
+		}
+	}
+	if (NULL != lpszOutput)
+	{
+		lpwszOutput = AnsiStringToUnicodeString (
+				lpszOutput,
+				NULL,
+				TRUE
+				);
+		if (NULL == lpwszOutput)
+		{
+			return 0;
+		}
+	}
+	/*
+	 * Call the Unicode version
+	 * of CreateDC.
+	 */
+	hDC = CreateDCW (
+		lpwszDriver,
+		lpwszDevice,
+		lpwszOutput,
+		lpInitData
+		);
+	/*
+	 * Free Unicode parameters.
+	 */
+	if (NULL != lpszDriver) LocalFree (lpwszDriver);
+	if (NULL != lpszDevice) LocalFree (lpwszDevice);
+	if (NULL != lpszOutput) LocalFree (lpwszOutput);
+	/*
+	 * Return the possible DC handle.
+	 */
+	return hDC;
 }
 
 

reactos/lib/gdi32/misc/stubsw.c

@@ -1,4 +1,4 @@
-/* $Id: stubsw.c,v 1.1 1999/05/24 20:04:44 ea Exp $
+/* $Id: stubsw.c,v 1.2 2000/02/20 22:52:48 ea Exp $
  *
  * reactos/lib/gdi32/misc/stubs.c
  *
@@ -10,7 +10,7 @@
  */
 #define UNICODE
 #include <windows.h>
-
+#include <win32k/kapi.h>
 
 int
 STDCALL
@@ -38,15 +38,20 @@ CopyMetaFileW(
 
 HDC
 STDCALL
-CreateDCW(
-	LPCWSTR		a0,
-	LPCWSTR		a1,
-	LPCWSTR		a2,
-	CONST DEVMODE	*a3
+CreateDCW (
+	LPCWSTR		lpwszDriver,
+	LPCWSTR		lpwszDevice,
+	LPCWSTR		lpwszOutput,
+	CONST DEVMODE	* lpInitData
 	)
 {
-	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-	return 0;
+	/* FIXME: is this a forward-only call? */
+	return W32kCreateDC (
+			lpwszDriver,
+			lpwszDevice,
+			lpwszOutput,
+			lpInitData
+			);
 }
 
 

reactos/lib/psxdll/makefile

@@ -1,4 +1,4 @@
-# $Id: makefile,v 1.5 1999/12/26 16:36:44 ea Exp $
+# $Id: makefile,v 1.6 2000/02/20 22:52:49 ea Exp $
 #
 # ReactOS psxdll.dll makefile
 #
@@ -14,7 +14,7 @@ else
   DLLTARGET=$(TARGETNAME).dll
 endif
 
-BASE_CFLAGS = -I../../include
+BASE_CFLAGS =-Iinclude -I../../include -D__PSXDLL__
 
 all: $(DLLTARGET)
 

reactos/ntoskrnl/ob/object.c

@@ -1,4 +1,5 @@
-/*
+/* $Id: object.c,v 1.21 2000/02/20 22:52:49 ea Exp $
+ * 
  * COPYRIGHT:     See COPYING in the top level directory
  * PROJECT:       ReactOS kernel
  * FILE:          ntoskrnl/ob/object.c
@@ -23,6 +24,16 @@
 
 /* FUNCTIONS ************************************************************/
 
+/**********************************************************************
+ * NAME							PRIVATE
+ * 	ObInitializeObject
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
 VOID ObInitializeObject(POBJECT_HEADER ObjectHeader,
 			PHANDLE Handle,
 			ACCESS_MASK DesiredAccess,
@@ -52,6 +63,17 @@ VOID ObInitializeObject(POBJECT_HEADER ObjectHeader,
      }
 }
 
+
+/**********************************************************************
+ * NAME							PRIVATE
+ * 	ObFindObject@12
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
 NTSTATUS ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
 		      PVOID* ReturnedObject,
 		      PWSTR* RemainingPath)
@@ -130,6 +152,17 @@ NTSTATUS ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
    return(STATUS_SUCCESS);
 }
 
+
+/**********************************************************************
+ * NAME							EXPORTED
+ * 	ObCreateObject@36
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
 PVOID ObCreateObject(PHANDLE Handle,
 		     ACCESS_MASK DesiredAccess,
 		     POBJECT_ATTRIBUTES ObjectAttributes,
@@ -185,7 +218,7 @@ PVOID ObCreateObject(PHANDLE Handle,
    return(HEADER_TO_BODY(Header));
 }
 
-NTSTATUS ObReferenceObjectByPointer(PVOID ObjectBody,
+NTSTATUS STDCALL ObReferenceObjectByPointer(PVOID ObjectBody,
 				    ACCESS_MASK DesiredAccess,
 				    POBJECT_TYPE ObjectType,
 				    KPROCESSOR_MODE AccessMode)
@@ -285,7 +318,40 @@ ULONG ObGetHandleCount(PVOID ObjectBody)
    return(Header->HandleCount);
 }
 
-VOID ObDereferenceObject(PVOID ObjectBody)
+
+/**********************************************************************
+ * NAME							EXPORTED
+ * 	@ObfReferenceObject@0
+ *
+ * DESCRIPTION
+ *	Increments a given object's reference count and performs
+ *	retention checks.
+ *
+ * ARGUMENTS
+ *        ObjectBody
+ *        	Body of the object.
+ *
+ * RETURN VALUE
+ * 	The current value of the reference counter.
+ */
+ULONG
+FASTCALL
+ObfReferenceObject (PVOID ObjectBody)
+{
+	POBJECT_HEADER	Header = BODY_TO_HEADER(ObjectBody);
+	ULONG		ReferenceCount;
+
+	ReferenceCount = ++ Header->RefCount;
+   
+	ObPerformRetentionChecks (Header);
+
+	return (ReferenceCount);
+}
+
+
+VOID
+FASTCALL
+ObfDereferenceObject (PVOID ObjectBody)
 /*
  * FUNCTION: Decrements a given object's reference count and performs
  * retention checks
@@ -316,3 +382,14 @@ VOID ObDereferenceObject(PVOID ObjectBody)
    
    ObPerformRetentionChecks(Header);
 }
+
+
+VOID
+STDCALL
+ObDereferenceObject (PVOID ObjectBody)
+{
+	ObfDereferenceObject (ObjectBody);
+}
+
+
+/* EOF */

reactos/subsys/win32k/main/dllmain.c

@@ -1,4 +1,5 @@
-/*
+/* $Id: dllmain.c,v 1.11 2000/02/20 22:52:50 ea Exp $
+ * 
  *  Entry Point for win32k.sys
  */
 
@@ -13,313 +14,42 @@
 #include <win32k/win32k.h>
 
 /*
- * WARNING: whoever you are, do NOT rely on the order of this table.
- * I'll change it just to spite ya. 
+ * NOTE: the table is actually in the file ./svctab.c,
+ * generated by iface/addsys/mktab.c + w32ksvc.db
  */
-SERVICE_TABLE W32kServiceTable[] =
-{
-  {4, (ULONG) W32kAbortDoc},
-  {4, (ULONG) W32kAbortPath},
-  {4, (ULONG) W32kAddFontResource},
-  {24, (ULONG) W32kAngleArc},
-  {16, (ULONG) W32kAnimatePalette},
-  {36, (ULONG) W32kArc},
-  {36, (ULONG) W32kArcTo},
-  {4, (ULONG) W32kBeginPath},
-  {36, (ULONG) W32kBitBlt},
-  {4, (ULONG) W32kCancelDC},
-  {16, (ULONG) W32kCheckColorsInGamut},
-  {2, (ULONG) W32kChoosePixelFormat},
-  {36, (ULONG) W32kChord},
-  {4, (ULONG) W32kCloseEnhMetaFile},
-  {4, (ULONG) W32kCloseFigure},
-  {4, (ULONG) W32kCloseMetaFile},
-  {12, (ULONG) W32kColorMatchToTarget},
-  {16, (ULONG) W32kCombineRgn},
-  {12, (ULONG) W32kCombineTransform},
-  {8, (ULONG) W32kCopyEnhMetaFile},
-  {8, (ULONG) W32kCopyMetaFile},
-  {20, (ULONG) W32kCreateBitmap},
-  {4, (ULONG) W32kCreateBitmapIndirect},
-  {4, (ULONG) W32kCreateBrushIndirect},
-  {4, (ULONG) W32kCreateColorSpace},
-  {12, (ULONG) W32kCreateCompatibleBitmap},
-  {4, (ULONG) W32kCreateCompatableDC},
-  {16, (ULONG) W32kCreateDC},
-  {24, (ULONG) W32kCreateDIBitmap},
-  {8, (ULONG) W32kCreateDIBPatternBrush},
-  {8, (ULONG) W32kCreateDIBPatternBrushPt},
-  {24, (ULONG) W32kCreateDIBSection},
-  {12, (ULONG) W32kCreateDiscardableBitmap},
-  {16, (ULONG) W32kCreateEllipticRgn},
-  {4, (ULONG) W32kCreateEllipticRgnIndirect},
-  {16, (ULONG) W32kCreateEnhMetaFile},
-  {56, (ULONG) W32kCreateFont},
-  {4, (ULONG) W32kCreateFontIndirect},
-  {4, (ULONG) W32kCreateHalftonePalette},
-  {8, (ULONG) W32kCreateHatchBrush},
-  {16, (ULONG) W32kCreateIC},
-  {4, (ULONG) W32kCreateMetaFile},
-  {4, (ULONG) W32kCreatePalette},
-  {4, (ULONG) W32kCreatePatternBrush},
-  {12, (ULONG) W32kCreatePen},
-  {4, (ULONG) W32kCreatePenIndirect},
-  {12, (ULONG) W32kCreatePolygonRgn},
-  {16, (ULONG) W32kCreatePolyPolygonRgn},
-  {16, (ULONG) W32kCreateRectRgn},
-  {4, (ULONG) W32kCreateRectRgnIndirect},
-  {24, (ULONG) W32kCreateRoundRectRgn},
-  {16, (ULONG) W32kCreateScalableFontResource},
-  {4, (ULONG) W32kCreateSolidBrush},
-  {12, (ULONG) W32kDPtoLP},
-  {4, (ULONG) W32kDeleteColorSpace},
-  {4, (ULONG) W32kDeleteDC},
-  {4, (ULONG) W32kDeleteEnhMetaFile},
-  {4, (ULONG) W32kDeleteMetaFile},
-  {4, (ULONG) W32kDeleteObject},
-  {16, (ULONG) W32kDescribePixelFormat},
-// FIXME:  {?, (ULONG) W32kDeviceCapabilitiesEx},
-  {16, (ULONG) W32kDrawEscape},
-  {20, (ULONG) W32kEllipse},
-  {4, (ULONG) W32kEndDoc},
-  {4, (ULONG) W32kEndPage},
-  {4, (ULONG) W32kEndPath},
-  {20, (ULONG) W32kEnumEnhMetaFile},
-  {16, (ULONG) W32kEnumFontFamilies},
-  {20, (ULONG) W32kEnumFontFamiliesEx},
-  {16, (ULONG) W32kEnumFonts},
-  {12, (ULONG) W32kEnumICMProfiles},
-  {16, (ULONG) W32kEnumMetaFile},
-  {16, (ULONG) W32kEnumObjects},
-  {8, (ULONG) W32kEqualRgn},
-  {20, (ULONG) W32kEscape},
-  {20, (ULONG) W32kExcludeClipRect},
-  {20, (ULONG) W32kExtCreatePen},
-  {12, (ULONG) W32kExtCreateRegion},
-  {24, (ULONG) W32kExtEscape},
-  {20, (ULONG) W32kExtFloodFill},
-  {12, (ULONG) W32kExtSelectClipRgn},
-  {32, (ULONG) W32kExtTextOut},
-  {4, (ULONG) W32kFillPath},
-  {12, (ULONG) W32kFillRgn},
-  {0, (ULONG) W32kFixBrushOrgEx},
-  {4, (ULONG) W32kFlattenPath},
-  {16, (ULONG) W32kFloodFill},
-  {20, (ULONG) W32kFrameRgn},
-  {12, (ULONG) W32kGdiComment},
-  {0, (ULONG) W32kGdiFlush},
-  {0, (ULONG) W32kGdiGetBatchLimit},
-// FIXME:  {?, (ULONG) W32kGdiPlayDCScript},
-// FIXME:  {?, (ULONG) W32kGdiPlayJournal},
-// FIXME:  {?, (ULONG) W32kGdiPlayScript},
-// FIXME:  {?, (ULONG) W32kGdiPlaySpoolStream},
-  {4, (ULONG) W32kGdiSetBatchLimit},
-  {4, (ULONG) W32kGetArcDirection},
-  {8, (ULONG) W32kGetAspectRatioFilterEx},
-  {12, (ULONG) W32kGetBitmapBits},
-  {8, (ULONG) W32kGetBitmapDimensionEx},
-  {4, (ULONG) W32kGetBkColor},
-  {4, (ULONG) W32kGetBkMode},
-  {12, (ULONG) W32kGetBoundsRect},
-  {8, (ULONG) W32kGetBrushOrgEx},
-  {16, (ULONG) W32kGetCharABCWidths},
-  {16, (ULONG) W32kGetCharABCWidthsFloat},
-  {24, (ULONG) W32kGetCharacterPlacement},
-  {16, (ULONG) W32kGetCharWidth},
-  {16, (ULONG) W32kGetCharWidth32},
-  {16, (ULONG) W32kGetCharWidthFloat},
-  {8, (ULONG) W32kGetClipBox},
-  {4, (ULONG) W32kGetClipRgn},
-  {8, (ULONG) W32kGetColorAdjustment},
-  {4, (ULONG) W32kGetColorSpace},
-  {8, (ULONG) W32kGetCurrentObject},
-  {8, (ULONG) W32kGetCurrentPositionEx},
-  {8, (ULONG) W32kGetDCOrgEx},
-  {16, (ULONG) W32kGetDIBColorTable},
-  {28, (ULONG) W32kGetDIBits},
-  {8, (ULONG) W32kGetDeviceCaps},
-  {8, (ULONG) W32kGetDeviceGammaRamp},
-  {4, (ULONG) W32kGetEnhMetaFile},
-  {12, (ULONG) W32kGetEnhMetaFileBits},
-  {12, (ULONG) W32kGetEnhMetaFileDescription},
-  {12, (ULONG) W32kGetEnhMetaFileHeader},
-  {12, (ULONG) W32kGetEnhMetaFilePaletteEntries},
-  {12, (ULONG) W32kGetEnhMetaFilePixelFormat},
-  {4, (ULONG) W32kGetFontLanguageInfo},
-// FIXME:  {?, (ULONG) W32kGetFontResourceInfo},
-  {28, (ULONG) W32kGetGlyphOutline},
-// FIXME:  {?, (ULONG) W32kGetGlyphOutlineWow},
-  {4, (ULONG) W32kGetGraphicsMode},
-  {12, (ULONG) W32kGetICMProfile},
-  {12, (ULONG) W32kGetKerningPairs},
-  {12, (ULONG) W32kGetLogColorSpace},
-  {4, (ULONG) W32kGetMapMode},
-  {4, (ULONG) W32kGetMetaFile},
-  {12, (ULONG) W32kGetMetaFileBitsEx},
-  {8, (ULONG) W32kGetMetaRgn},
-  {8, (ULONG) W32kGetMiterLimit},
-  {8, (ULONG) W32kGetNearestColor},
-  {8, (ULONG) W32kGetNearestPaletteIndex},
-  {12, (ULONG) W32kGetObject},
-  {4, (ULONG) W32kGetObjectType},
-  {12, (ULONG) W32kGetOutlineTextMetrics},
-  {16, (ULONG) W32kGetPaletteEntries},
-  {16, (ULONG) W32kGetPath},
-  {4, (ULONG) W32kGetPixel},
-  {4, (ULONG) W32kGetPixelFormat},
-  {4, (ULONG) W32kGetPolyFillMode},
-  {4, (ULONG) W32kGetROP2},
-// FIXME:  {?, (ULONG) W32kGetRandomRgn},
-  {8, (ULONG) W32kGetRasterizerCaps},
-  {4, (ULONG) W32kGetRelAbs},
-  {8, (ULONG) W32kGetRgnBox},
-  {4, (ULONG) W32kGetStockObject},
-  {4, (ULONG) W32kGetStretchBltMode},
-  {16, (ULONG) W32kGetSystemPaletteEntries},
-  {4, (ULONG) W32kGetSystemPaletteUse},
-  {4, (ULONG) W32kGetTextAlign},
-  {4, (ULONG) W32kGetTextCharset},
-  {12, (ULONG) W32kGetTextCharsetInfo},
-  {4, (ULONG) W32kGetTextColor},
-  {28, (ULONG) W32kGetTextExtentExPoint},
-  {16, (ULONG) W32kGetTextExtentPoint},
-  {16, (ULONG) W32kGetTextExtentPoint32},
-  {12, (ULONG) W32kGetTextFace},
-  {8, (ULONG) W32kGetTextMetrics},
-  {8, (ULONG) W32kGetViewportExtEx},
-  {8, (ULONG) W32kGetViewportOrgEx},
-  {20, (ULONG) W32kGetWinMetaFileBits},
-  {8, (ULONG) W32kGetWindowExtEx},
-  {8, (ULONG) W32kGetWindowOrgEx},
-  {8, (ULONG) W32kGetWorldTransform},
-  {20, (ULONG) W32kIntersectClipRect},
-  {8, (ULONG) W32kInvertRgn},
-  {12, (ULONG) W32kLPtoDP},
-  {12, (ULONG) W32kLineTo},
-  {48, (ULONG) W32kMaskBlt},
-  {12, (ULONG) W32kModifyWorldTransform},
-  {16, (ULONG) W32kMoveToEx},
-  {12, (ULONG) W32kOffsetClipRgn},
-  {12, (ULONG) W32kOffsetRgn},
-  {16, (ULONG) W32kOffsetViewportOrgEx},
-  {16, (ULONG) W32kOffsetWindowOrgEx},
-  {8, (ULONG) W32kPaintRgn},
-  {24, (ULONG) W32kPatBlt},
-  {4, (ULONG) W32kPathToRegion},
-  {36, (ULONG) W32kPie},
-  {12, (ULONG) W32kPlayEnhMetaFile},
-  {16, (ULONG) W32kPlayEnhMetaFileRecord},
-  {8, (ULONG) W32kPlayMetaFile},
-  {16, (ULONG) W32kPlayMetaFileRecord},
-  {40, (ULONG) W32kPlgBlt},
-  {12, (ULONG) W32kPolyBezier},
-  {12, (ULONG) W32kPolyBezierTo},
-  {16, (ULONG) W32kPolyDraw},
-  {12, (ULONG) W32kPolyline},
-  {12, (ULONG) W32kPolylineTo},
-  {16, (ULONG) W32kPolyPolyline},
-  {12, (ULONG) W32kPolyTextOut},
-  {12, (ULONG) W32kPolygon},
-  {16, (ULONG) W32kPolyPolygon},
-  {12, (ULONG) W32kPtInRegion},
-  {12, (ULONG) W32kPtVisible},
-  {4, (ULONG) W32kRealizePalette},
-  {8, (ULONG) W32kRectInRegion},
-  {8, (ULONG) W32kRectVisible},
-  {20, (ULONG) W32kRectangle},
-  {4, (ULONG) W32kRemoveFontResource},
-  {8, (ULONG) W32kResetDC},
-  {8, (ULONG) W32kResizePalette},
-  {8, (ULONG) W32kRestoreDC},
-  {28, (ULONG) W32kRoundRect},
-  {4, (ULONG) W32kSaveDC},
-  {24, (ULONG) W32kScaleViewportExtEx},
-  {24, (ULONG) W32kScaleWindowExtEx},
-// FIXME:  {?, (ULONG) W32kSelectBrushLocal},
-  {8, (ULONG) W32kSelectClipPath},
-  {8, (ULONG) W32kSelectClipRgn},
-// FIXME:  {?, (ULONG) W32kSelectFontLocal},
-  {8, (ULONG) W32kSelectObject},
-  {12, (ULONG) W32kSelectPalette},
-  {8, (ULONG) W32kSetAbortProc},
-  {8, (ULONG) W32kSetArcDirection},
-  {12, (ULONG) W32kSetBitmapBits},
-  {16, (ULONG) W32kSetBitmapDimensionEx},
-  {8, (ULONG) W32kSetBkColor},
-  {8, (ULONG) W32kSetBkMode},
-  {12, (ULONG) W32kSetBoundsRect},
-  {16, (ULONG) W32kSetBrushOrgEx},
-  {8, (ULONG) W32kSetColorAdjustment},
-  {8, (ULONG) W32kSetColorSpace},
-  {16, (ULONG) W32kSetDIBColorTable},
-  {28, (ULONG) W32kSetDIBits},
-  {48, (ULONG) W32kSetDIBitsToDevice},
-  {8, (ULONG) W32kSetDeviceGammaRamp},
-  {8, (ULONG) W32kSetEnhMetaFileBits},
-// FIXME:  {?, (ULONG) W32kSetFontEnumeration},
-  {8, (ULONG) W32kSetGraphicsMode},
-  {8, (ULONG) W32kSetICMMode},
-  {8, (ULONG) W32kSetICMProfile},
-  {8, (ULONG) W32kSetMapMode},
-  {8, (ULONG) W32kSetMapperFlags},
-  {8, (ULONG) W32kSetMetaFileBitsEx},
-  {4, (ULONG) W32kSetMetaRgn},
-  {12, (ULONG) W32kSetMiterLimit},
-  {16, (ULONG) W32kSetPaletteEntries},
-  {16, (ULONG) W32kSetPixel},
-  {12, (ULONG) W32kSetPixelFormat},
-  {16, (ULONG) W32kSetPixelV},
-  {8, (ULONG) W32kSetPolyFillMode},
-  {8, (ULONG) W32kSetROP2},
-  {20, (ULONG) W32kSetRectRgn},
-//  {8, (ULONG) W32kSetRelAbs},
-  {8, (ULONG) W32kSetStretchBltMode},
-  {8, (ULONG) W32kSetSystemPaletteUse},
-  {8, (ULONG) W32kSetTextAlign},
-  {8, (ULONG) W32kSetTextColor},
-  {12, (ULONG) W32kSetTextJustification},
-  {16, (ULONG) W32kSetViewportExtEx},
-  {16, (ULONG) W32kSetViewportOrgEx},
-//  {4, (ULONG) W32kSetWinMetaFileBits},
-   {4, (ULONG)NULL},
-  {16, (ULONG) W32kSetWindowExtEx},
-  {16, (ULONG) W32kSetWindowOrgEx},
-  {8, (ULONG) W32kSetWorldTransform},
-  {8, (ULONG) W32kStartDoc},
-  {4, (ULONG) W32kStartPage},
-  {44, (ULONG) W32kStretchBlt},
-  {52, (ULONG) W32kStretchDIBits},
-  {4, (ULONG) W32kStrokeAndFillPath},
-  {4, (ULONG) W32kStrokePath},
-  {4, (ULONG) W32kSwapBuffers},
-  {20, (ULONG) W32kTextOut},
-  {12, (ULONG) W32kTranslateCharsetInfo},
-  {8, (ULONG) W32kUnrealizeObject},
-  {4, (ULONG) W32kUpdateColors},
-  {16, (ULONG) W32kUpdateICMRegKey},
-  {4, (ULONG) W32kWidenPath},
-};
+#include "svctab.c"
 
 /*
  * This definition doesn't work
  */
 // WINBOOL STDCALL DllMain(VOID)
-STDCALL NTSTATUS DllMain(IN PDRIVER_OBJECT DriverObject,
-			     IN PUNICODE_STRING RegistryPath)
+NTSTATUS
+STDCALL
+DllMain (
+	IN	PDRIVER_OBJECT	DriverObject,
+	IN	PUNICODE_STRING	RegistryPath
+	)
 {
-  NTSTATUS  Status;
+	NTSTATUS	Status;
   
-  /*  Register user mode call interface (svc mask is 0x10000000)  */
-  Status = HalRegisterServiceTable(0xF0000000, 
-                                   0x10000000, 
-                                   W32kServiceTable,
-                                   sizeof(W32kServiceTable) / 
-                                     sizeof(W32kServiceTable[0]));
-  if (!NT_SUCCESS(Status))
-    {
-      return FALSE;
-    }
+	/*
+	 * Register user mode call interface
+	 * (svc mask is 0x10000000)
+	 */
+	Status = HalRegisterServiceTable (
+			0xF0000000, 
+			0x10000000, 
+			W32kServiceTable,
+			sizeof (W32kServiceTable)
+                        / sizeof(W32kServiceTable[0])
+			);
+	if (!NT_SUCCESS(Status))
+	{
+		return FALSE;
+	}
   
-  return TRUE;
+	return TRUE;
 }
 
+
+/* EOF */

reactos/subsys/win32k/objects/bitmaps.c

@@ -9,7 +9,7 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kBitBlt(HDC  hDCDest,
+BOOL STDCALL W32kBitBlt(HDC  hDCDest,
                  INT  XDest,
                  INT  YDest,
                  INT  Width,
@@ -22,7 +22,7 @@ BOOL  W32kBitBlt(HDC  hDCDest,
   UNIMPLEMENTED;
 }
 
-HBITMAP  W32kCreateBitmap(INT  Width,
+HBITMAP STDCALL W32kCreateBitmap(INT  Width,
                           INT  Height,
                           UINT  Planes,
                           UINT  BitsPerPel,
@@ -86,7 +86,7 @@ HBITMAP  W32kCreateBitmap(INT  Width,
   return  hBitmap;
 }
 
-HBITMAP  W32kCreateCompatibleBitmap(HDC hDC,
+HBITMAP STDCALL W32kCreateCompatibleBitmap(HDC hDC,
                                     INT  Width,
                                     INT  Height)
 {
@@ -127,7 +127,7 @@ HBITMAP  W32kCreateCompatibleBitmap(HDC hDC,
   return hbmpRet;
 }
 
-HBITMAP  W32kCreateBitmapIndirect(CONST BITMAP  *BM)
+HBITMAP STDCALL W32kCreateBitmapIndirect(CONST BITMAP  *BM)
 {
   return W32kCreateBitmap (BM->bmWidth, 
                            BM->bmHeight, 
@@ -136,7 +136,7 @@ HBITMAP  W32kCreateBitmapIndirect(CONST BITMAP  *BM)
                            BM->bmBits);
 }
 
-HBITMAP  W32kCreateDIBitmap(HDC  hDC,
+HBITMAP STDCALL W32kCreateDIBitmap(HDC  hDC,
                             CONST BITMAPINFOHEADER  *bmih,
                             DWORD  Init,
                             CONST VOID  *bInit,
@@ -146,7 +146,7 @@ HBITMAP  W32kCreateDIBitmap(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-HBITMAP  W32kCreateDIBSection(HDC hDC,
+HBITMAP STDCALL W32kCreateDIBSection(HDC hDC,
                               CONST BITMAPINFO  *bmi,
                               UINT  Usage,
                               VOID  *Bits,
@@ -156,7 +156,7 @@ HBITMAP  W32kCreateDIBSection(HDC hDC,
   UNIMPLEMENTED;
 }
 
-HBITMAP  W32kCreateDiscardableBitmap(HDC  hDC,
+HBITMAP STDCALL W32kCreateDiscardableBitmap(HDC  hDC,
                                      INT  Width,
                                      INT  Height)
 {
@@ -164,7 +164,7 @@ HBITMAP  W32kCreateDiscardableBitmap(HDC  hDC,
   return  W32kCreateCompatibleBitmap(hDC, Width, Height);
 }
 
-BOOL W32kExtFloodFill(HDC  hDC,
+BOOL STDCALL W32kExtFloodFill(HDC  hDC,
                       INT  XStart,
                       INT  YStart,
                       COLORREF  Color, 
@@ -173,7 +173,7 @@ BOOL W32kExtFloodFill(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kFloodFill(HDC  hDC,
+BOOL STDCALL W32kFloodFill(HDC  hDC,
                     INT  XStart,
                     INT  YStart,
                     COLORREF  Fill)
@@ -181,7 +181,7 @@ BOOL  W32kFloodFill(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-LONG  W32kGetBitmapBits(HBITMAP  hBitmap,
+LONG STDCALL W32kGetBitmapBits(HBITMAP  hBitmap,
                         LONG  Count,
                         LPVOID  Bits)
 {
@@ -258,7 +258,7 @@ LONG  W32kGetBitmapBits(HBITMAP  hBitmap,
   return  ret;
 }
 
-BOOL  W32kGetBitmapDimensionEx(HBITMAP  hBitmap,
+BOOL STDCALL W32kGetBitmapDimensionEx(HBITMAP  hBitmap,
                                LPSIZE  Dimension)
 {
   PBITMAPOBJ  bmp;
@@ -275,7 +275,7 @@ BOOL  W32kGetBitmapDimensionEx(HBITMAP  hBitmap,
   return  TRUE;
 }
 
-UINT  W32kGetDIBColorTable(HDC  hDC,
+UINT STDCALL W32kGetDIBColorTable(HDC  hDC,
                            UINT  StartIndex,
                            UINT  Entries,
                            RGBQUAD  *Colors)
@@ -283,7 +283,7 @@ UINT  W32kGetDIBColorTable(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-INT  W32kGetDIBits(HDC  hDC,
+INT STDCALL W32kGetDIBits(HDC  hDC,
                    HBITMAP hBitmap,
                    UINT  StartScan,
                    UINT  ScanLines,
@@ -294,14 +294,14 @@ INT  W32kGetDIBits(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-COLORREF  W32kGetPixel(HDC  hDC,
+COLORREF STDCALL W32kGetPixel(HDC  hDC,
                        INT  XPos,
                        INT  YPos)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kMaskBlt(HDC  hDCDest,
+BOOL STDCALL W32kMaskBlt(HDC  hDCDest,
                   INT  XDest,
                   INT  YDest,
                   INT  Width,
@@ -317,7 +317,7 @@ BOOL  W32kMaskBlt(HDC  hDCDest,
   UNIMPLEMENTED;
 }
 
-BOOL W32kPlgBlt(HDC  hDCDest,
+BOOL STDCALL W32kPlgBlt(HDC  hDCDest,
                 CONST POINT  *Point,
                 HDC  hDCSrc, 
                 INT  XSrc,  
@@ -331,7 +331,7 @@ BOOL W32kPlgBlt(HDC  hDCDest,
   UNIMPLEMENTED;
 }
 
-LONG  W32kSetBitmapBits(HBITMAP  hBitmap,
+LONG STDCALL W32kSetBitmapBits(HBITMAP  hBitmap,
                         DWORD  Bytes,
                         CONST VOID *Bits)
 {
@@ -408,7 +408,7 @@ LONG  W32kSetBitmapBits(HBITMAP  hBitmap,
   return ret;
 }
 
-BOOL  W32kSetBitmapDimensionEx(HBITMAP  hBitmap,
+BOOL STDCALL W32kSetBitmapDimensionEx(HBITMAP  hBitmap,
                                INT  Width,
                                INT  Height,
                                LPSIZE  Size)
@@ -432,7 +432,7 @@ BOOL  W32kSetBitmapDimensionEx(HBITMAP  hBitmap,
   return TRUE;
 }
 
-UINT  W32kSetDIBColorTable(HDC  hDC,
+UINT STDCALL W32kSetDIBColorTable(HDC  hDC,
                            UINT  StartIndex,
                            UINT  Entries,
                            CONST RGBQUAD  *Colors)
@@ -440,7 +440,7 @@ UINT  W32kSetDIBColorTable(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-INT  W32kSetDIBits(HDC  hDC,
+INT STDCALL W32kSetDIBits(HDC  hDC,
                    HBITMAP  hBitmap,
                    UINT  StartScan,
                    UINT  ScanLines,
@@ -451,7 +451,7 @@ INT  W32kSetDIBits(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-INT  W32kSetDIBitsToDevice(HDC  hDC,
+INT STDCALL W32kSetDIBitsToDevice(HDC  hDC,
                            INT  XDest,
                            INT  YDest,
                            DWORD  Width,
@@ -467,7 +467,7 @@ INT  W32kSetDIBitsToDevice(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-COLORREF  W32kSetPixel(HDC  hDC,
+COLORREF STDCALL W32kSetPixel(HDC  hDC,
                        INT  X,
                        INT  Y,
                        COLORREF  Color)
@@ -475,7 +475,7 @@ COLORREF  W32kSetPixel(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetPixelV(HDC  hDC,
+BOOL STDCALL W32kSetPixelV(HDC  hDC,
                     INT  X,
                     INT  Y,
                     COLORREF  Color)
@@ -483,7 +483,7 @@ BOOL  W32kSetPixelV(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kStretchBlt(HDC  hDCDest,
+BOOL STDCALL W32kStretchBlt(HDC  hDCDest,
                      INT  XOriginDest,
                      INT  YOriginDest,
                      INT  WidthDest,
@@ -498,7 +498,7 @@ BOOL  W32kStretchBlt(HDC  hDCDest,
   UNIMPLEMENTED;
 }
 
-INT  W32kStretchDIBits(HDC  hDC,
+INT STDCALL W32kStretchDIBits(HDC  hDC,
                        INT  XDest,
                        INT  YDest,
                        INT  DestWidth,

reactos/subsys/win32k/objects/brush.c

@@ -1,4 +1,4 @@
-/* $Id: brush.c,v 1.7 1999/11/20 21:49:23 ekohl Exp $
+/* $Id: brush.c,v 1.8 2000/02/20 22:52:50 ea Exp $
  */
 
 
@@ -12,7 +12,7 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-HBRUSH  W32kCreateBrushIndirect(CONST LOGBRUSH  *lb)
+HBRUSH STDCALL W32kCreateBrushIndirect(CONST LOGBRUSH  *lb)
 {
   PBRUSHOBJ  brushPtr;
   HBRUSH  hBrush;
@@ -33,7 +33,7 @@ HBRUSH  W32kCreateBrushIndirect(CONST LOGBRUSH  *lb)
   return  hBrush;
 }
 
-HBRUSH  W32kCreateDIBPatternBrush(HGLOBAL  hDIBPacked,
+HBRUSH STDCALL W32kCreateDIBPatternBrush(HGLOBAL  hDIBPacked,
                                   UINT  ColorSpec)
 {
   UNIMPLEMENTED;
@@ -76,7 +76,7 @@ HBRUSH  W32kCreateDIBPatternBrush(HGLOBAL  hDIBPacked,
 #endif
 }
 
-HBRUSH  W32kCreateDIBPatternBrushPt(CONST VOID  *PackedDIB,
+HBRUSH STDCALL W32kCreateDIBPatternBrushPt(CONST VOID  *PackedDIB,
                                     UINT  Usage)
 {
   INT  size;
@@ -128,7 +128,7 @@ HBRUSH  W32kCreateDIBPatternBrushPt(CONST VOID  *PackedDIB,
   return  W32kCreateBrushIndirect (&logbrush);
 }
 
-HBRUSH  W32kCreateHatchBrush(INT  Style,
+HBRUSH STDCALL W32kCreateHatchBrush(INT  Style,
                              COLORREF  Color)
 {
   LOGBRUSH  logbrush;
@@ -146,7 +146,7 @@ HBRUSH  W32kCreateHatchBrush(INT  Style,
   return  W32kCreateBrushIndirect (&logbrush);
 }
 
-HBRUSH  W32kCreatePatternBrush(HBITMAP  hBitmap)
+HBRUSH STDCALL W32kCreatePatternBrush(HBITMAP  hBitmap)
 {
   LOGBRUSH  logbrush = { BS_PATTERN, 0, 0 };
 
@@ -162,17 +162,17 @@ HBRUSH  W32kCreatePatternBrush(HBITMAP  hBitmap)
     }
 }
 
-HBRUSH  W32kCreateSolidBrush(COLORREF  Color)
+HBRUSH STDCALL W32kCreateSolidBrush(COLORREF  Color)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kFixBrushOrgEx(VOID)
+BOOL STDCALL W32kFixBrushOrgEx(VOID)
 {
   return FALSE;
 }
 
-BOOL  W32kPatBlt(HDC  hDC,
+BOOL STDCALL W32kPatBlt(HDC  hDC,
                  INT  XLeft,
                  INT  YLeft,
                  INT  Width,
@@ -182,7 +182,7 @@ BOOL  W32kPatBlt(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetBrushOrgEx(HDC  hDC,
+BOOL STDCALL W32kSetBrushOrgEx(HDC  hDC,
                         INT  XOrg,
                         INT  YOrg,
                         LPPOINT  Point)

reactos/subsys/win32k/objects/cliprgn.c

@@ -8,7 +8,7 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-int  W32kExcludeClipRect(HDC  hDC,
+int STDCALL W32kExcludeClipRect(HDC  hDC,
                          int  LeftRect,
                          int  TopRect,
                          int  RightRect,
@@ -17,26 +17,26 @@ int  W32kExcludeClipRect(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kExtSelectClipRgn(HDC  hDC,
+int STDCALL W32kExtSelectClipRgn(HDC  hDC,
                           HRGN  hrgn,
                           int  fnMode)
 {
   UNIMPLEMENTED;
 }
 
-int  W32kGetClipBox(HDC  hDC,
+int STDCALL W32kGetClipBox(HDC  hDC,
                     LPRECT  rc)
 {
   UNIMPLEMENTED;
 }
 
-int  W32kGetMetaRgn(HDC  hDC,
+int STDCALL W32kGetMetaRgn(HDC  hDC,
                     HRGN  hrgn)
 {
   UNIMPLEMENTED;
 }
 
-int  W32kIntersectClipRect(HDC  hDC,
+int STDCALL W32kIntersectClipRect(HDC  hDC,
                            int  LeftRect,
                            int  TopRect,
                            int  RightRect,
@@ -45,39 +45,39 @@ int  W32kIntersectClipRect(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kOffsetClipRgn(HDC  hDC,
+int STDCALL W32kOffsetClipRgn(HDC  hDC,
                        int  XOffset,
                        int  YOffset)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPtVisible(HDC  hDC,
+BOOL STDCALL W32kPtVisible(HDC  hDC,
                     int  X,
                     int  Y)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kRectVisible(HDC  hDC,
+BOOL STDCALL W32kRectVisible(HDC  hDC,
                       CONST PRECT  rc)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSelectClipPath(HDC  hDC,
+BOOL STDCALL W32kSelectClipPath(HDC  hDC,
                          int  Mode)
 {
   UNIMPLEMENTED;
 }
 
-int  W32kSelectClipRgn(HDC  hDC,
+int STDCALL W32kSelectClipRgn(HDC  hDC,
                        HRGN  hrgn)
 {
   UNIMPLEMENTED;
 }
 
-int  W32kSetMetaRgn(HDC  hDC)
+int STDCALL W32kSetMetaRgn(HDC  hDC)
 {
   UNIMPLEMENTED;
 }

reactos/subsys/win32k/objects/color.c

@@ -7,7 +7,7 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kAnimatePalette(HPALETTE  hpal,
+BOOL STDCALL W32kAnimatePalette(HPALETTE  hpal,
                          UINT  StartIndex,
                          UINT  Entries,
                          CONST PPALETTEENTRY  ppe)
@@ -15,35 +15,35 @@ BOOL  W32kAnimatePalette(HPALETTE  hpal,
   UNIMPLEMENTED;
 }
 
-HPALETTE  W32kCreateHalftonePalette(HDC  hDC)
+HPALETTE STDCALL W32kCreateHalftonePalette(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-HPALETTE  W32kCreatePalette(CONST PLOGPALETTE lgpl)
+HPALETTE STDCALL W32kCreatePalette(CONST PLOGPALETTE lgpl)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetColorAdjustment(HDC  hDC,
+BOOL STDCALL W32kGetColorAdjustment(HDC  hDC,
                              LPCOLORADJUSTMENT  ca)
 {
   UNIMPLEMENTED;
 }
 
-COLORREF  W32kGetNearestColor(HDC  hDC,
+COLORREF STDCALL W32kGetNearestColor(HDC  hDC,
                               COLORREF  Color)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetNearestPaletteIndex(HPALETTE  hpal,
+UINT STDCALL W32kGetNearestPaletteIndex(HPALETTE  hpal,
                                  COLORREF  Color)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetPaletteEntries(HPALETTE  hpal,
+UINT STDCALL W32kGetPaletteEntries(HPALETTE  hpal,
                             UINT  StartIndex,
                             UINT  Entries,
                             LPPALETTEENTRY  pe)
@@ -51,7 +51,7 @@ UINT  W32kGetPaletteEntries(HPALETTE  hpal,
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetSystemPaletteEntries(HDC  hDC,
+UINT STDCALL W32kGetSystemPaletteEntries(HDC  hDC,
                                   UINT  StartIndex,
                                   UINT  Entries,
                                   LPPALETTEENTRY  pe)
@@ -59,36 +59,36 @@ UINT  W32kGetSystemPaletteEntries(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetSystemPaletteUse(HDC  hDC)
+UINT STDCALL W32kGetSystemPaletteUse(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kRealizePalette(HDC  hDC)
+UINT STDCALL W32kRealizePalette(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kResizePalette(HPALETTE  hpal,
+BOOL STDCALL W32kResizePalette(HPALETTE  hpal,
                         UINT  Entries)
 {
   UNIMPLEMENTED;
 }
 
-HPALETTE  W32kSelectPalette(HDC  hDC,
+HPALETTE STDCALL W32kSelectPalette(HDC  hDC,
                             HPALETTE  hpal,
                             BOOL  ForceBackground)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetColorAdjustment(HDC  hDC,
+BOOL STDCALL W32kSetColorAdjustment(HDC  hDC,
                              CONST LPCOLORADJUSTMENT  ca)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kSetPaletteEntries(HPALETTE  hpal,
+UINT STDCALL W32kSetPaletteEntries(HPALETTE  hpal,
                             UINT  Start,
                             UINT  Entries,
                             CONST LPPALETTEENTRY  pe)
@@ -96,18 +96,18 @@ UINT  W32kSetPaletteEntries(HPALETTE  hpal,
   UNIMPLEMENTED;
 }
 
-UINT  W32kSetSystemPaletteUse(HDC  hDC,
+UINT STDCALL W32kSetSystemPaletteUse(HDC  hDC,
                               UINT  Usage)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kUnrealizeObject(HGDIOBJ  hgdiobj)
+BOOL STDCALL W32kUnrealizeObject(HGDIOBJ  hgdiobj)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kUpdateColors(HDC  hDC)
+BOOL STDCALL W32kUpdateColors(HDC  hDC)
 {
   UNIMPLEMENTED;
 }

reactos/subsys/win32k/objects/coord.c

@@ -9,7 +9,7 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kCombineTransform(LPXFORM  XFormResult,
+BOOL STDCALL W32kCombineTransform(LPXFORM  XFormResult,
                            CONST LPXFORM  xform1,
                            CONST LPXFORM  xform2)
 {
@@ -41,14 +41,15 @@ BOOL  W32kCombineTransform(LPXFORM  XFormResult,
   return  TRUE;
 }
 
-BOOL  W32kDPtoLP(HDC  hDC,
+BOOL STDCALL W32kDPtoLP(HDC  hDC,
                  LPPOINT  Points,
                  int  Count)
 {
   UNIMPLEMENTED;
 }
 
-int  
+int
+STDCALL
 W32kGetGraphicsMode(HDC  hDC)
 {
   PDC  dc;
@@ -66,7 +67,8 @@ W32kGetGraphicsMode(HDC  hDC)
   return  GraphicsMode;
 }
 
-BOOL  
+BOOL
+STDCALL
 W32kGetWorldTransform(HDC  hDC,
                       LPXFORM  XForm)
 {
@@ -87,14 +89,18 @@ W32kGetWorldTransform(HDC  hDC,
   return  TRUE;
 }
 
-BOOL  W32kLPtoDP(HDC  hDC,
+BOOL
+STDCALL
+W32kLPtoDP(HDC  hDC,
                  LPPOINT  Points,
                  int  Count)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kModifyWorldTransform(HDC  hDC,
+BOOL
+STDCALL
+W32kModifyWorldTransform(HDC  hDC,
                                CONST LPXFORM  XForm,
                                DWORD  Mode)
 {
@@ -148,7 +154,9 @@ BOOL  W32kModifyWorldTransform(HDC  hDC,
   return  TRUE;
 }
 
-BOOL  W32kOffsetViewportOrgEx(HDC  hDC,
+BOOL
+STDCALL
+W32kOffsetViewportOrgEx(HDC  hDC,
                               int  XOffset,
                               int  YOffset,
                               LPPOINT  Point)
@@ -156,7 +164,9 @@ BOOL  W32kOffsetViewportOrgEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kOffsetWindowOrgEx(HDC  hDC,
+BOOL
+STDCALL
+W32kOffsetWindowOrgEx(HDC  hDC,
                             int  XOffset,
                             int  YOffset,
                             LPPOINT  Point)
@@ -164,7 +174,9 @@ BOOL  W32kOffsetWindowOrgEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kScaleViewportExtEx(HDC  hDC,
+BOOL
+STDCALL
+W32kScaleViewportExtEx(HDC  hDC,
                              int  Xnum,
                              int  Xdenom,
                              int  Ynum,
@@ -174,7 +186,9 @@ BOOL  W32kScaleViewportExtEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kScaleWindowExtEx(HDC  hDC,
+BOOL
+STDCALL
+W32kScaleWindowExtEx(HDC  hDC,
                            int  Xnum,
                            int  Xdenom,
                            int  Ynum,
@@ -184,7 +198,9 @@ BOOL  W32kScaleWindowExtEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kSetGraphicsMode(HDC  hDC,
+int
+STDCALL
+W32kSetGraphicsMode(HDC  hDC,
                          int  Mode)
 {
   INT ret;
@@ -213,13 +229,17 @@ int  W32kSetGraphicsMode(HDC  hDC,
   return  ret;
 }
 
-int  W32kSetMapMode(HDC  hDC,
+int
+STDCALL
+W32kSetMapMode(HDC  hDC,
                     int  MapMode)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetViewportExtEx(HDC  hDC,
+BOOL
+STDCALL
+W32kSetViewportExtEx(HDC  hDC,
                            int  XExtent,
                            int  YExtent,
                            LPSIZE  Size)
@@ -227,7 +247,9 @@ BOOL  W32kSetViewportExtEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetViewportOrgEx(HDC  hDC,
+BOOL
+STDCALL
+W32kSetViewportOrgEx(HDC  hDC,
                            int  X,
                            int  Y,
                            LPPOINT  Point)
@@ -235,7 +257,9 @@ BOOL  W32kSetViewportOrgEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetWindowExtEx(HDC  hDC,
+BOOL
+STDCALL
+W32kSetWindowExtEx(HDC  hDC,
                          int  XExtent,
                          int  YExtent,
                          LPSIZE  Size)
@@ -243,7 +267,9 @@ BOOL  W32kSetWindowExtEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetWindowOrgEx(HDC  hDC,
+BOOL
+STDCALL
+W32kSetWindowOrgEx(HDC  hDC,
                          int  X,
                          int  Y,
                          LPPOINT  Point)
@@ -251,7 +277,9 @@ BOOL  W32kSetWindowOrgEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetWorldTransform(HDC  hDC,
+BOOL
+STDCALL
+W32kSetWorldTransform(HDC  hDC,
                             CONST LPXFORM  XForm)
 {
   PDC  dc;

reactos/subsys/win32k/objects/fillshap.c

@@ -7,7 +7,9 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kChord(HDC  hDC,
+BOOL
+STDCALL
+W32kChord(HDC  hDC,
                 int  LeftRect,
                 int  TopRect,
                 int  RightRect,
@@ -20,7 +22,9 @@ BOOL  W32kChord(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kEllipse(HDC  hDC,
+BOOL
+STDCALL
+W32kEllipse(HDC  hDC,
                   int  LeftRect,
                   int  TopRect,
                   int  RightRect,
@@ -29,7 +33,9 @@ BOOL  W32kEllipse(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPie(HDC  hDC,
+BOOL
+STDCALL
+W32kPie(HDC  hDC,
               int  LeftRect,
               int  TopRect,
               int  RightRect,
@@ -42,14 +48,18 @@ BOOL  W32kPie(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolygon(HDC  hDC,
+BOOL
+STDCALL
+W32kPolygon(HDC  hDC,
                   CONST PPOINT  Points,
                   int  Count)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolyPolygon(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyPolygon(HDC  hDC,
                       CONST LPPOINT  Points,
                       CONST LPINT  PolyCounts,
                       int  Count)
@@ -57,7 +67,9 @@ BOOL  W32kPolyPolygon(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kRectangle(HDC  hDC,
+BOOL
+STDCALL
+W32kRectangle(HDC  hDC,
                     int  LeftRect,
                     int  TopRect,
                     int  RightRect,
@@ -66,7 +78,9 @@ BOOL  W32kRectangle(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kRoundRect(HDC  hDC,
+BOOL
+STDCALL
+W32kRoundRect(HDC  hDC,
                     int  LeftRect,
                     int  TopRect,  
                     int  RightRect, 

reactos/subsys/win32k/objects/icm.c

@@ -8,7 +8,9 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kCheckColorsInGamut(HDC  hDC,
+BOOL
+STDCALL
+W32kCheckColorsInGamut(HDC  hDC,
                              LPVOID  RGBTriples,
                              LPVOID  Buffer,
                              UINT  Count)
@@ -16,69 +18,91 @@ BOOL  W32kCheckColorsInGamut(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kColorMatchToTarget(HDC  hDC,
+BOOL
+STDCALL
+W32kColorMatchToTarget(HDC  hDC,
                              HDC  hDCTarget, 
                              DWORD  Action)
 {
   UNIMPLEMENTED;
 }
 
-HCOLORSPACE  W32kCreateColorSpace(LPLOGCOLORSPACE  LogColorSpace)
+HCOLORSPACE
+STDCALL
+W32kCreateColorSpace(LPLOGCOLORSPACE  LogColorSpace)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kDeleteColorSpace(HCOLORSPACE  hColorSpace)
+BOOL
+STDCALL
+W32kDeleteColorSpace(HCOLORSPACE  hColorSpace)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kEnumICMProfiles(HDC  hDC,  
+INT
+STDCALL
+W32kEnumICMProfiles(HDC  hDC,  
                          ICMENUMPROC  EnumICMProfilesFunc,
                          LPARAM lParam)
 {
   UNIMPLEMENTED;
 }
 
-HCOLORSPACE  W32kGetColorSpace(HDC  hDC)
+HCOLORSPACE
+STDCALL
+W32kGetColorSpace(HDC  hDC)
 {
   /* FIXME: Need to to whatever GetColorSpace actually does */
   return  0;
 }
 
-BOOL  W32kGetDeviceGammaRamp(HDC  hDC,  
+BOOL
+STDCALL
+W32kGetDeviceGammaRamp(HDC  hDC,  
                              LPVOID  Ramp)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetICMProfile(HDC  hDC,  
+BOOL
+STDCALL
+W32kGetICMProfile(HDC  hDC,  
                         LPDWORD  NameSize,  
                         LPWSTR  Filename)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetLogColorSpace(HCOLORSPACE  hColorSpace,
+BOOL
+STDCALL
+W32kGetLogColorSpace(HCOLORSPACE  hColorSpace,
                            LPLOGCOLORSPACE  Buffer,  
                            DWORD  Size)
 {
   UNIMPLEMENTED;
 }
 
-HCOLORSPACE  W32kSetColorSpace(HDC  hDC,
+HCOLORSPACE
+STDCALL
+W32kSetColorSpace(HDC  hDC,
                                HCOLORSPACE  hColorSpace)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetDeviceGammaRamp(HDC  hDC,
+BOOL
+STDCALL
+W32kSetDeviceGammaRamp(HDC  hDC,
                              LPVOID  Ramp)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kSetICMMode(HDC  hDC,
+INT
+STDCALL
+W32kSetICMMode(HDC  hDC,
                     INT  EnableICM)
 {
   /* FIXME: this should be coded someday  */
@@ -98,13 +122,17 @@ INT  W32kSetICMMode(HDC  hDC,
   return  0;
 }
 
-BOOL  W32kSetICMProfile(HDC  hDC,
+BOOL
+STDCALL
+W32kSetICMProfile(HDC  hDC,
                         LPWSTR  Filename)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kUpdateICMRegKey(DWORD  Reserved,  
+BOOL
+STDCALL
+W32kUpdateICMRegKey(DWORD  Reserved,  
                           LPWSTR  CMID, 
                           LPWSTR  Filename,
                           UINT  Command)

reactos/subsys/win32k/objects/line.c

@@ -9,7 +9,9 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kAngleArc(HDC  hDC,
+BOOL
+STDCALL
+W32kAngleArc(HDC  hDC,
                    int  X,
                    int  Y,
                    DWORD  Radius,
@@ -19,7 +21,9 @@ BOOL  W32kAngleArc(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kArc(HDC  hDC,
+BOOL
+STDCALL
+W32kArc(HDC  hDC,
               int  LeftRect,
               int  TopRect,
               int  RightRect, 
@@ -32,7 +36,9 @@ BOOL  W32kArc(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kArcTo(HDC  hDC,
+BOOL
+STDCALL
+W32kArcTo(HDC  hDC,
                 int  LeftRect,
                 int  TopRect,
                 int  RightRect,
@@ -45,7 +51,9 @@ BOOL  W32kArcTo(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kGetArcDirection(HDC  hDC)
+int
+STDCALL
+W32kGetArcDirection(HDC  hDC)
 {
   PDC  dc;
   int  ret;
@@ -62,14 +70,18 @@ int  W32kGetArcDirection(HDC  hDC)
   return ret;
 }
 
-BOOL  W32kLineTo(HDC  hDC,
+BOOL
+STDCALL
+W32kLineTo(HDC  hDC,
                  int  XEnd,
                  int  YEnd)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kMoveToEx(HDC  hDC,
+BOOL
+STDCALL
+W32kMoveToEx(HDC  hDC,
                    int  X,
                    int  Y,
                    LPPOINT  Point)
@@ -77,21 +89,27 @@ BOOL  W32kMoveToEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolyBezier(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyBezier(HDC  hDC,
                      CONST LPPOINT  pt,
                      DWORD  Count)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolyBezierTo(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyBezierTo(HDC  hDC,
                        CONST LPPOINT  pt,
                        DWORD  Count)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolyDraw(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyDraw(HDC  hDC,
                    CONST LPPOINT  pt,
                    CONST LPBYTE  Types,
                    int  Count)
@@ -99,21 +117,27 @@ BOOL  W32kPolyDraw(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolyline(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyline(HDC  hDC,
                    CONST LPPOINT  pt,
                    int  Count)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolylineTo(HDC  hDC,
+BOOL
+STDCALL
+W32kPolylineTo(HDC  hDC,
                      CONST LPPOINT  pt,
                      DWORD  Count)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolyPolyline(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyPolyline(HDC  hDC,
                        CONST LPPOINT  pt,
                        CONST LPDWORD  PolyPoints,
                        DWORD  Count)
@@ -121,7 +145,9 @@ BOOL  W32kPolyPolyline(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kSetArcDirection(HDC  hDC,
+int
+STDCALL
+W32kSetArcDirection(HDC  hDC,
                          int  ArcDirection)
 {
   PDC  dc;

reactos/subsys/win32k/objects/metafile.c

@@ -8,29 +8,39 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-HENHMETAFILE  W32kCloseEnhMetaFile(HDC  hDC)
+HENHMETAFILE
+STDCALL
+W32kCloseEnhMetaFile(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-HMETAFILE  W32kCloseMetaFile(HDC  hDC)
+HMETAFILE
+STDCALL
+W32kCloseMetaFile(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-HENHMETAFILE  W32kCopyEnhMetaFile(HENHMETAFILE  Src,
+HENHMETAFILE
+STDCALL
+W32kCopyEnhMetaFile(HENHMETAFILE  Src,
                                   LPCWSTR  File)
 {
   UNIMPLEMENTED;
 }
 
-HMETAFILE  W32kCopyMetaFile(HMETAFILE  Src,
+HMETAFILE
+STDCALL
+W32kCopyMetaFile(HMETAFILE  Src,
                             LPCWSTR  File)
 {
   UNIMPLEMENTED;
 }
 
-HDC  W32kCreateEnhMetaFile(HDC  hDCRef,
+HDC
+STDCALL
+W32kCreateEnhMetaFile(HDC  hDCRef,
                            LPCWSTR  File,
                            CONST LPRECT  Rect,
                            LPCWSTR  Description)
@@ -38,22 +48,30 @@ HDC  W32kCreateEnhMetaFile(HDC  hDCRef,
   UNIMPLEMENTED;
 }
 
-HDC  W32kCreateMetaFile(LPCWSTR  File)
+HDC
+STDCALL
+W32kCreateMetaFile(LPCWSTR  File)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kDeleteEnhMetaFile(HENHMETAFILE  emf)
+BOOL
+STDCALL
+W32kDeleteEnhMetaFile(HENHMETAFILE  emf)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kDeleteMetaFile(HMETAFILE  mf)
+BOOL
+STDCALL
+W32kDeleteMetaFile(HMETAFILE  mf)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kEnumEnhMetaFile(HDC  hDC,
+BOOL
+STDCALL
+W32kEnumEnhMetaFile(HDC  hDC,
                           HENHMETAFILE  emf,
                           ENHMFENUMPROC  EnhMetaFunc,
                           LPVOID  Data,
@@ -62,7 +80,9 @@ BOOL  W32kEnumEnhMetaFile(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kEnumMetaFile(HDC  hDC,
+BOOL
+STDCALL
+W32kEnumMetaFile(HDC  hDC,
                        HMETAFILE  mf,
                        MFENUMPROC  MetaFunc,
                        LPARAM  lParam)
@@ -70,59 +90,77 @@ BOOL  W32kEnumMetaFile(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGdiComment(HDC  hDC,
+BOOL
+STDCALL
+W32kGdiComment(HDC  hDC,
                      UINT  Size,
                      CONST LPBYTE  Data)
 {
   UNIMPLEMENTED;
 }
 
-HENHMETAFILE  W32kGetEnhMetaFile(LPCWSTR  MetaFile)
+HENHMETAFILE
+STDCALL
+W32kGetEnhMetaFile(LPCWSTR  MetaFile)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetEnhMetaFileBits(HENHMETAFILE  hemf,
+UINT
+STDCALL
+W32kGetEnhMetaFileBits(HENHMETAFILE  hemf,
                              UINT  BufSize,
                              LPBYTE  Buffer)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetEnhMetaFileDescription(HENHMETAFILE  hemf,
+UINT
+STDCALL
+W32kGetEnhMetaFileDescription(HENHMETAFILE  hemf,
                                     UINT  BufSize,
                                     LPWSTR  Description)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetEnhMetaFileHeader(HENHMETAFILE  hemf,
+UINT
+STDCALL
+W32kGetEnhMetaFileHeader(HENHMETAFILE  hemf,
                                UINT  BufSize,
                                LPENHMETAHEADER  emh)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetEnhMetaFilePaletteEntries(HENHMETAFILE  hemf,
+UINT
+STDCALL
+W32kGetEnhMetaFilePaletteEntries(HENHMETAFILE  hemf,
                                        UINT  Entries,
                                        LPPALETTEENTRY  pe)
 {
   UNIMPLEMENTED;
 }
 
-HMETAFILE  W32kGetMetaFile(LPCWSTR  MetaFile)
+HMETAFILE
+STDCALL
+W32kGetMetaFile(LPCWSTR  MetaFile)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetMetaFileBitsEx(HMETAFILE  hmf,
+UINT
+STDCALL
+W32kGetMetaFileBitsEx(HMETAFILE  hmf,
                             UINT  Size,
                             LPVOID  Data)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetWinMetaFileBits(HENHMETAFILE  hemf,
+UINT
+STDCALL
+W32kGetWinMetaFileBits(HENHMETAFILE  hemf,
                              UINT  BufSize,
                              LPBYTE  Buffer,
                              INT  MapMode,
@@ -131,14 +169,18 @@ UINT  W32kGetWinMetaFileBits(HENHMETAFILE  hemf,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPlayEnhMetaFile(HDC  hDC,
+BOOL
+STDCALL
+W32kPlayEnhMetaFile(HDC  hDC,
                           HENHMETAFILE  hemf,
                           CONST PRECT  Rect)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPlayEnhMetaFileRecord(HDC  hDC,
+BOOL
+STDCALL
+W32kPlayEnhMetaFileRecord(HDC  hDC,
                                 LPHANDLETABLE  Handletable,
                                 CONST ENHMETARECORD *EnhMetaRecord,
                                 UINT  Handles)
@@ -146,13 +188,17 @@ BOOL  W32kPlayEnhMetaFileRecord(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPlayMetaFile(HDC  hDC,
+BOOL
+STDCALL
+W32kPlayMetaFile(HDC  hDC,
                        HMETAFILE  hmf)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPlayMetaFileRecord(HDC  hDC,
+BOOL
+STDCALL
+W32kPlayMetaFileRecord(HDC  hDC,
                              LPHANDLETABLE  Handletable,
                              LPMETARECORD  MetaRecord,
                              UINT  Handles)
@@ -160,19 +206,25 @@ BOOL  W32kPlayMetaFileRecord(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-HENHMETAFILE  W32kSetEnhMetaFileBits(UINT  BufSize,
+HENHMETAFILE
+STDCALL
+W32kSetEnhMetaFileBits(UINT  BufSize,
                                      CONST PBYTE  Data)
 {
   UNIMPLEMENTED;
 }
 
-HMETAFILE  W32kSetMetaFileBitsEx(UINT  Size,
+HMETAFILE
+STDCALL
+W32kSetMetaFileBitsEx(UINT  Size,
                                  CONST PBYTE  Data)
 {
   UNIMPLEMENTED;
 }
 
-HENHMETAFILE  W32kSetWinMetaFileBits(UINT  BufSize,
+HENHMETAFILE
+STDCALL
+W32kSetWinMetaFileBits(UINT  BufSize,
                                      CONST PBYTE  Buffer,
                                      HDC  Ref,
 //                                     CONST METAFILEPICT *mfp)

reactos/subsys/win32k/objects/paint.c

@@ -9,22 +9,30 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kGdiFlush(VOID)
+BOOL
+STDCALL
+W32kGdiFlush(VOID)
 {
   UNIMPLEMENTED;
 }
 
-DWORD  W32kGdiGetBatchLimit(VOID)
+DWORD
+STDCALL
+W32kGdiGetBatchLimit(VOID)
 {
   UNIMPLEMENTED;
 }
 
-DWORD  W32kGdiSetBatchLimit(DWORD  Limit)
+DWORD
+STDCALL
+W32kGdiSetBatchLimit(DWORD  Limit)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetBoundsRect(HDC  hDC,
+UINT
+STDCALL
+W32kGetBoundsRect(HDC  hDC,
                         LPRECT  Bounds,
                         UINT  Flags)
 {
@@ -32,13 +40,9 @@ UINT  W32kGetBoundsRect(HDC  hDC,
   return  DCB_RESET;   /* bounding rectangle always empty */
 }
 
-COLORREF  W32kSetBkColor(HDC  hDC,
-                         COLORREF  Color)
-{
-  UNIMPLEMENTED;
-}
-
-UINT  W32kSetBoundsRect(HDC  hDC,
+UINT
+STDCALL
+W32kSetBoundsRect(HDC  hDC,
                         CONST PRECT  Bounds,
                         UINT  Flags)
 {

reactos/subsys/win32k/objects/path.c

@@ -8,44 +8,60 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-BOOL  W32kAbortPath(HDC  hDC)
+BOOL
+STDCALL
+W32kAbortPath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kBeginPath(HDC  hDC)
+BOOL
+STDCALL
+W32kBeginPath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kCloseFigure(HDC  hDC)
+BOOL
+STDCALL
+W32kCloseFigure(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kEndPath(HDC  hDC)
+BOOL
+STDCALL
+W32kEndPath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kFillPath(HDC  hDC)
+BOOL
+STDCALL
+W32kFillPath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kFlattenPath(HDC  hDC)
+BOOL
+STDCALL
+W32kFlattenPath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
 
-BOOL  W32kGetMiterLimit(HDC  hDC,
+BOOL
+STDCALL
+W32kGetMiterLimit(HDC  hDC,
                         PFLOAT  Limit)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kGetPath(HDC  hDC,
+INT
+STDCALL
+W32kGetPath(HDC  hDC,
                  LPPOINT  Points,
                  LPBYTE  Types,
                  INT  nSize)
@@ -53,29 +69,39 @@ INT  W32kGetPath(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-HRGN  W32kPathToRegion(HDC  hDC)
+HRGN
+STDCALL
+W32kPathToRegion(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetMiterLimit(HDC  hDC,
+BOOL
+STDCALL
+W32kSetMiterLimit(HDC  hDC,
                         FLOAT  NewLimit,
                         PFLOAT  OldLimit)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kStrokeAndFillPath(HDC  hDC)
+BOOL
+STDCALL
+W32kStrokeAndFillPath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kStrokePath(HDC  hDC)
+BOOL
+STDCALL
+W32kStrokePath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kWidenPath(HDC  hDC)
+BOOL
+STDCALL
+W32kWidenPath(HDC  hDC)
 {
   UNIMPLEMENTED;
 }

reactos/subsys/win32k/objects/pen.c

@@ -8,19 +8,25 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-HPEN  W32kCreatePen(INT  PenStyle,
+HPEN
+STDCALL
+W32kCreatePen(INT  PenStyle,
                     INT  Width,
                     COLORREF  Color)
 {
   UNIMPLEMENTED;
 }
 
-HPEN  W32kCreatePenIndirect(CONST PLOGPEN  lgpn)
+HPEN
+STDCALL
+W32kCreatePenIndirect(CONST PLOGPEN  lgpn)
 {
   UNIMPLEMENTED;
 }
 
-HPEN  W32kExtCreatePen(DWORD  PenStyle,
+HPEN
+STDCALL
+W32kExtCreatePen(DWORD  PenStyle,
                        DWORD  Width,
                        CONST PLOGBRUSH  lb,
                        DWORD  StyleCount,

reactos/subsys/win32k/objects/print.c

@@ -8,22 +8,30 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-INT  W32kAbortDoc(HDC  hDC)
+INT
+STDCALL
+W32kAbortDoc(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kEndDoc(HDC  hDC)
+INT
+STDCALL
+W32kEndDoc(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kEndPage(HDC  hDC)
+INT
+STDCALL
+W32kEndPage(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kEscape(HDC  hDC,
+INT
+STDCALL
+W32kEscape(HDC  hDC,
                 INT  Escape,
                 INT  InSize,
                 LPCSTR  InData,
@@ -32,7 +40,9 @@ INT  W32kEscape(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-INT  W32kExtEscape(HDC  hDC,
+INT
+STDCALL
+W32kExtEscape(HDC  hDC,
                    INT  Escape,
                    INT  InSize,
                    LPCSTR  InData,
@@ -42,19 +52,25 @@ INT  W32kExtEscape(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-INT  W32kSetAbortProc(HDC  hDC,
+INT
+STDCALL
+W32kSetAbortProc(HDC  hDC,
                       ABORTPROC  AbortProc)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kStartDoc(HDC  hDC,
+INT
+STDCALL
+W32kStartDoc(HDC  hDC,
                   CONST PDOCINFO  di)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kStartPage(HDC  hDC)
+INT
+STDCALL
+W32kStartPage(HDC  hDC)
 {
   UNIMPLEMENTED;
 }

reactos/subsys/win32k/objects/region.c

@@ -8,7 +8,9 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-INT  W32kCombineRgn(HRGN  hDest,
+INT
+STDCALL
+W32kCombineRgn(HRGN  hDest,
                     HRGN  hSrc1,
                     HRGN  hSrc2,
                     INT  CombineMode)
@@ -16,7 +18,9 @@ INT  W32kCombineRgn(HRGN  hDest,
   UNIMPLEMENTED;
 }
 
-HRGN  W32kCreateEllipticRgn(INT  LeftRect,
+HRGN
+STDCALL
+W32kCreateEllipticRgn(INT  LeftRect,
                             INT  TopRect,
                             INT  RightRect,
                             INT  BottomRect)
@@ -24,19 +28,25 @@ HRGN  W32kCreateEllipticRgn(INT  LeftRect,
   UNIMPLEMENTED;
 }
 
-HRGN  W32kCreateEllipticRgnIndirect(CONST PRECT  rc)
+HRGN
+STDCALL
+W32kCreateEllipticRgnIndirect(CONST PRECT  rc)
 {
   UNIMPLEMENTED;
 }
 
-HRGN  W32kCreatePolygonRgn(CONST PPOINT  pt,
+HRGN
+STDCALL
+W32kCreatePolygonRgn(CONST PPOINT  pt,
                            INT  Count,
                            INT  PolyFillMode)
 {
   UNIMPLEMENTED;
 }
 
-HRGN  W32kCreatePolyPolygonRgn(CONST PPOINT  pt,
+HRGN
+STDCALL
+W32kCreatePolyPolygonRgn(CONST PPOINT  pt,
                                CONST PINT  PolyCounts,
                                INT  Count,
                                INT  PolyFillMode)
@@ -44,7 +54,9 @@ HRGN  W32kCreatePolyPolygonRgn(CONST PPOINT  pt,
   UNIMPLEMENTED;
 }
 
-HRGN  W32kCreateRectRgn(INT  LeftRect,
+HRGN
+STDCALL
+W32kCreateRectRgn(INT  LeftRect,
                         INT  TopRect,
                         INT  RightRect,
                         INT  BottomRect)
@@ -52,12 +64,16 @@ HRGN  W32kCreateRectRgn(INT  LeftRect,
   UNIMPLEMENTED;
 }
 
-HRGN  W32kCreateRectRgnIndirect(CONST PRECT  rc)
+HRGN
+STDCALL
+W32kCreateRectRgnIndirect(CONST PRECT  rc)
 {
   UNIMPLEMENTED;
 }
 
-HRGN  W32kCreateRoundRectRgn(INT  LeftRect,
+HRGN
+STDCALL
+W32kCreateRoundRectRgn(INT  LeftRect,
                              INT  TopRect,
                              INT  RightRect,
                              INT  BottomRect,
@@ -67,27 +83,35 @@ HRGN  W32kCreateRoundRectRgn(INT  LeftRect,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kEqualRgn(HRGN  hSrcRgn1,
+BOOL
+STDCALL
+W32kEqualRgn(HRGN  hSrcRgn1,
                    HRGN  hSrcRgn2)
 {
   UNIMPLEMENTED;
 }
 
-HRGN  W32kExtCreateRegion(CONST PXFORM  Xform,
+HRGN
+STDCALL
+W32kExtCreateRegion(CONST PXFORM  Xform,
                           DWORD  Count,
                           CONST PRGNDATA  RgnData)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kFillRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kFillRgn(HDC  hDC,
                   HRGN  hRgn,
                   HBRUSH  hBrush)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kFrameRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kFrameRgn(HDC  hDC,
                    HRGN  hRgn,
                    HBRUSH  hBrush,
                    INT  Width,
@@ -96,45 +120,59 @@ BOOL  W32kFrameRgn(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-INT  W32kGetRgnBox(HRGN  hRgn,
+INT
+STDCALL
+W32kGetRgnBox(HRGN  hRgn,
                    LPRECT  hRect)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kInvertRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kInvertRgn(HDC  hDC,
                     HRGN  hRgn)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kOffsetRgn(HRGN  hRgn,
+INT
+STDCALL
+W32kOffsetRgn(HRGN  hRgn,
                    INT  XOffset,
                    INT  YOffset)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPaintRgn(HDC  hDC,
+BOOL
+STDCALL
+W32kPaintRgn(HDC  hDC,
                    HRGN  hRgn)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPtInRegion(HRGN  hRgn,
+BOOL
+STDCALL
+W32kPtInRegion(HRGN  hRgn,
                      INT  X,
                      INT  Y)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kRectInRegion(HRGN  hRgn,
+BOOL
+STDCALL
+W32kRectInRegion(HRGN  hRgn,
                        CONST LPRECT  rc)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetRectRgn(HRGN  hRgn,
+BOOL
+STDCALL
+W32kSetRectRgn(HRGN  hRgn,
                      INT  LeftRect,
                      INT  TopRect,
                      INT  RightRect,

reactos/subsys/win32k/objects/text.c

@@ -9,12 +9,16 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-int  W32kAddFontResource(LPCWSTR  Filename)
+int
+STDCALL
+W32kAddFontResource(LPCWSTR  Filename)
 {
   UNIMPLEMENTED;
 }
 
-HFONT  W32kCreateFont(int  Height,
+HFONT
+STDCALL
+W32kCreateFont(int  Height,
                       int  Width,
                       int  Escapement,
                       int  Orientation,
@@ -32,12 +36,16 @@ HFONT  W32kCreateFont(int  Height,
   UNIMPLEMENTED;
 }
 
-HFONT  W32kCreateFontIndirect(CONST LPLOGFONT  lf)
+HFONT
+STDCALL
+W32kCreateFontIndirect(CONST LPLOGFONT  lf)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kCreateScalableFontResource(DWORD  Hidden,
+BOOL
+STDCALL
+W32kCreateScalableFontResource(DWORD  Hidden,
                                      LPCWSTR  FontRes,
                                      LPCWSTR  FontFile,
                                      LPCWSTR  CurrentPath)
@@ -45,7 +53,9 @@ BOOL  W32kCreateScalableFontResource(DWORD  Hidden,
   UNIMPLEMENTED;
 }
 
-int  W32kEnumFontFamilies(HDC  hDC,
+int
+STDCALL
+W32kEnumFontFamilies(HDC  hDC,
                           LPCWSTR  Family,
                           FONTENUMPROC  EnumFontFamProc,
                           LPARAM  lParam)
@@ -53,7 +63,9 @@ int  W32kEnumFontFamilies(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kEnumFontFamiliesEx(HDC  hDC,
+int
+STDCALL
+W32kEnumFontFamiliesEx(HDC  hDC,
                             LPLOGFONT  Logfont,
                             FONTENUMPROC  EnumFontFamExProc,
                             LPARAM  lParam,
@@ -62,7 +74,9 @@ int  W32kEnumFontFamiliesEx(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kEnumFonts(HDC  hDC,
+int
+STDCALL
+W32kEnumFonts(HDC  hDC,
                    LPCWSTR FaceName,
                    FONTENUMPROC  FontFunc,
                    LPARAM  lParam)
@@ -70,7 +84,9 @@ int  W32kEnumFonts(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kExtTextOut(HDC  hDC,
+BOOL
+STDCALL
+W32kExtTextOut(HDC  hDC,
                      int  X,
                      int  Y,
                      UINT  Options,
@@ -82,13 +98,17 @@ BOOL  W32kExtTextOut(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetAspectRatioFilterEx(HDC  hDC,
+BOOL
+STDCALL
+W32kGetAspectRatioFilterEx(HDC  hDC,
                                  LPSIZE  AspectRatio)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetCharABCWidths(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharABCWidths(HDC  hDC,
                            UINT  FirstChar,
                            UINT  LastChar,
                            LPABC  abc)
@@ -96,7 +116,9 @@ BOOL  W32kGetCharABCWidths(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetCharABCWidthsFloat(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharABCWidthsFloat(HDC  hDC,
                                 UINT  FirstChar,
                                 UINT  LastChar,
                                 LPABCFLOAT  abcF)
@@ -104,7 +126,9 @@ BOOL  W32kGetCharABCWidthsFloat(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-DWORD  W32kGetCharacterPlacement(HDC  hDC,
+DWORD
+STDCALL
+W32kGetCharacterPlacement(HDC  hDC,
                                  LPCWSTR  String,
                                  int  Count,
                                  int  MaxExtent,
@@ -114,7 +138,9 @@ DWORD  W32kGetCharacterPlacement(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetCharWidth(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharWidth(HDC  hDC,
                        UINT  FirstChar,
                        UINT  LastChar,
                        LPINT  Buffer)
@@ -122,7 +148,9 @@ BOOL  W32kGetCharWidth(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetCharWidth32(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharWidth32(HDC  hDC,
                          UINT  FirstChar,
                          UINT  LastChar,
                          LPINT  Buffer)
@@ -130,7 +158,9 @@ BOOL  W32kGetCharWidth32(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetCharWidthFloat(HDC  hDC,
+BOOL
+STDCALL
+W32kGetCharWidthFloat(HDC  hDC,
                             UINT  FirstChar,
                             UINT  LastChar,
                             PFLOAT  Buffer)
@@ -138,12 +168,16 @@ BOOL  W32kGetCharWidthFloat(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-DWORD  W32kGetFontLanguageInfo(HDC  hDC)
+DWORD
+STDCALL
+W32kGetFontLanguageInfo(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-DWORD  W32kGetGlyphOutline(HDC  hDC,
+DWORD
+STDCALL
+W32kGetGlyphOutline(HDC  hDC,
                            UINT  Char,
                            UINT  Format,
                            LPGLYPHMETRICS  gm,
@@ -154,39 +188,51 @@ DWORD  W32kGetGlyphOutline(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-DWORD  W32kGetKerningPairs(HDC  hDC,
+DWORD
+STDCALL
+W32kGetKerningPairs(HDC  hDC,
                            DWORD  NumPairs,
                            LPKERNINGPAIR  krnpair)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetOutlineTextMetrics(HDC  hDC,
+UINT
+STDCALL
+W32kGetOutlineTextMetrics(HDC  hDC,
                                 UINT  Data,
                                 LPOUTLINETEXTMETRIC  otm)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetRasterizerCaps(LPRASTERIZER_STATUS  rs,
+BOOL
+STDCALL
+W32kGetRasterizerCaps(LPRASTERIZER_STATUS  rs,
                             UINT  Size)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetTextCharset(HDC  hDC)
+UINT
+STDCALL
+W32kGetTextCharset(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetTextCharsetInfo(HDC  hDC,
+UINT
+STDCALL
+W32kGetTextCharsetInfo(HDC  hDC,
                              LPFONTSIGNATURE  Sig,
                              DWORD  Flags)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetTextExtentExPoint(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextExtentExPoint(HDC  hDC,
                                LPCWSTR String,
                                int  Count,
                                int  MaxExtent,
@@ -197,7 +243,9 @@ BOOL  W32kGetTextExtentExPoint(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetTextExtentPoint(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextExtentPoint(HDC  hDC,
                              LPCWSTR  String,
                              int  Count,
                              LPSIZE  Size)
@@ -205,7 +253,9 @@ BOOL  W32kGetTextExtentPoint(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetTextExtentPoint32(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextExtentPoint32(HDC  hDC,
                                LPCWSTR  String,
                                int  Count,
                                LPSIZE  Size)
@@ -213,38 +263,50 @@ BOOL  W32kGetTextExtentPoint32(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-int  W32kGetTextFace(HDC  hDC,
+int
+STDCALL
+W32kGetTextFace(HDC  hDC,
                      int  Count,
                      LPWSTR  FaceName)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kGetTextMetrics(HDC  hDC,
+BOOL
+STDCALL
+W32kGetTextMetrics(HDC  hDC,
                          LPTEXTMETRIC  tm)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kPolyTextOut(HDC  hDC,
+BOOL
+STDCALL
+W32kPolyTextOut(HDC  hDC,
                       CONST LPPOLYTEXT  txt,
                       int  Count)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kRemoveFontResource(LPCWSTR  FileName)
+BOOL
+STDCALL
+W32kRemoveFontResource(LPCWSTR  FileName)
 {
   UNIMPLEMENTED;
 }
 
-DWORD  W32kSetMapperFlags(HDC  hDC,
+DWORD
+STDCALL
+W32kSetMapperFlags(HDC  hDC,
                           DWORD  Flag)
 {
   UNIMPLEMENTED;
 }
 
-UINT  W32kSetTextAlign(HDC  hDC,
+UINT
+STDCALL
+W32kSetTextAlign(HDC  hDC,
                        UINT  Mode)
 {
   UINT prevAlign;
@@ -262,7 +324,8 @@ UINT  W32kSetTextAlign(HDC  hDC,
   return  prevAlign;
 }
 
-COLORREF STDCALL  
+COLORREF
+STDCALL
 W32kSetTextColor(HDC hDC, 
                  COLORREF color)
 {
@@ -281,14 +344,18 @@ W32kSetTextColor(HDC hDC,
   return  oldColor;
 }
 
-BOOL  W32kSetTextJustification(HDC  hDC,
+BOOL
+STDCALL
+W32kSetTextJustification(HDC  hDC,
                                int  BreakExtra,
                                int  BreakCount)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kTextOut(HDC  hDC,
+BOOL
+STDCALL
+W32kTextOut(HDC  hDC,
                   int  XStart,
                   int  YStart,
                   LPCWSTR  String,
@@ -297,7 +364,9 @@ BOOL  W32kTextOut(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-UINT  W32kTranslateCharsetInfo(PDWORD  Src,
+UINT
+STDCALL
+W32kTranslateCharsetInfo(PDWORD  Src,
                                LPCHARSETINFO  CSI,   
                                DWORD  Flags)
 {

reactos/subsys/win32k/objects/wingl.c

@@ -7,14 +7,18 @@
 // #define NDEBUG
 #include <internal/debug.h>
 
-INT  W32kChoosePixelFormat(HDC  hDC,
+INT
+STDCALL
+W32kChoosePixelFormat(HDC  hDC,
                            CONST PPIXELFORMATDESCRIPTOR  pfd)
 {
   UNIMPLEMENTED;
 }
 
 
-INT  W32kDescribePixelFormat(HDC  hDC,
+INT
+STDCALL
+W32kDescribePixelFormat(HDC  hDC,
                              INT  PixelFormat,
                              UINT  BufSize,
                              LPPIXELFORMATDESCRIPTOR  pfd)
@@ -22,26 +26,34 @@ INT  W32kDescribePixelFormat(HDC  hDC,
   UNIMPLEMENTED;
 }
 
-UINT  W32kGetEnhMetaFilePixelFormat(HENHMETAFILE  hEMF,
+UINT
+STDCALL
+W32kGetEnhMetaFilePixelFormat(HENHMETAFILE  hEMF,
                                     DWORD  BufSize, 
                                     CONST PPIXELFORMATDESCRIPTOR  pfd)
 {
   UNIMPLEMENTED;
 }
 
-INT  W32kGetPixelFormat(HDC  hDC)
+INT
+STDCALL
+W32kGetPixelFormat(HDC  hDC)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSetPixelFormat(HDC  hDC,
+BOOL
+STDCALL
+W32kSetPixelFormat(HDC  hDC,
                          INT  PixelFormat,
                          CONST PPIXELFORMATDESCRIPTOR  pfd)
 {
   UNIMPLEMENTED;
 }
 
-BOOL  W32kSwapBuffers(HDC  hDC)
+BOOL
+STDCALL
+W32kSwapBuffers(HDC  hDC)
 {
   UNIMPLEMENTED;
 }