return result;
}
-int STDCALL
+int WINAPI
WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
VDM_CONTROL_BLOCK VdmCB;
* NAME PRIVATE
* BaseStaticServerThread/1
*/
-VOID STDCALL BaseStaticServerThread (PVOID x)
+VOID WINAPI BaseStaticServerThread (PVOID x)
{
NTSTATUS Status = STATUS_SUCCESS;
PPORT_MESSAGE Request = (PPORT_MESSAGE) x;
}
-NTSTATUS STDCALL ServerDllInitialization (ULONG ArgumentCount, LPWSTR *Argument)
+NTSTATUS WINAPI ServerDllInitialization (ULONG ArgumentCount, LPWSTR *Argument)
{
NTSTATUS Status = STATUS_SUCCESS;
/* FUNCTIONS *****************************************************************/
-BOOL STDCALL DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
+BOOL WINAPI DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
{
if (DLL_PROCESS_ATTACH == dwReason)
{
* PUBLIC API
*===================================================================*/
-NTSTATUS STDCALL BaseSetProcessCreateNotify (BASE_PROCESS_CREATE_NOTIFY_ROUTINE ProcessCreateNotifyProc)
+NTSTATUS WINAPI BaseSetProcessCreateNotify (BASE_PROCESS_CREATE_NOTIFY_ROUTINE ProcessCreateNotifyProc)
{
NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
/* FUNCTIONS *****************************************************************/
-BOOL STDCALL DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
+BOOL WINAPI DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
{
if (DLL_PROCESS_ATTACH == dwReason)
{
* NAME PRIVATE
* ConStaticServerThread/1
*/
-VOID STDCALL ConStaticServerThread (PVOID x)
+VOID WINAPI ConStaticServerThread (PVOID x)
{
NTSTATUS Status = STATUS_SUCCESS;
PPORT_MESSAGE Request = (PPORT_MESSAGE) x;
* NAME PRIVATE
* UserStaticServerThread/1
*/
-VOID STDCALL UserStaticServerThread (PVOID x)
+VOID WINAPI UserStaticServerThread (PVOID x)
{
NTSTATUS Status = STATUS_SUCCESS;
PPORT_MESSAGE Request = (PPORT_MESSAGE) x;
* PUBLIC API
*===================================================================*/
-NTSTATUS STDCALL ConServerDllInitialization (ULONG ArgumentCount,
+NTSTATUS WINAPI ConServerDllInitialization (ULONG ArgumentCount,
LPWSTR *Argument)
{
NTSTATUS Status = STATUS_SUCCESS;
return Status;
}
-NTSTATUS STDCALL UserServerDllInitialization (ULONG ArgumentCount,
+NTSTATUS WINAPI UserServerDllInitialization (ULONG ArgumentCount,
LPWSTR *Argument)
{
NTSTATUS Status = STATUS_SUCCESS;
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object, DWORD Access )
+NTSTATUS WINAPI CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object, DWORD Access )
{
ULONG h = (ULONG)Handle >> 2;
DPRINT("CsrGetObject, Object: %x, %x, %x\n", Object, Handle, ProcessData ? ProcessData->HandleTableSize : 0);
}
-NTSTATUS STDCALL
+NTSTATUS WINAPI
CsrReleaseObjectByPointer(Object_t *Object)
{
unsigned DefIndex;
}
-NTSTATUS STDCALL
+NTSTATUS WINAPI
CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle)
{
return CsrReleaseObjectByPointer(Object);
}
-NTSTATUS STDCALL CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
+NTSTATUS WINAPI CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
Object_t *Object,
DWORD Access,
return(STATUS_SUCCESS);
}
-NTSTATUS STDCALL CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData,
+NTSTATUS WINAPI CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData,
PCSRSS_PROCESS_DATA TargetProcessData)
{
ULONG i;
return(STATUS_SUCCESS);
}
-NTSTATUS STDCALL CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle )
+NTSTATUS WINAPI CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle )
{
ULONG h = (ULONG)Handle >> 2;
/* FUNCTIONS *****************************************************************/
-VOID STDCALL CsrInitProcessData(VOID)
+VOID WINAPI CsrInitProcessData(VOID)
{
RtlZeroMemory (ProcessData, sizeof ProcessData);
NrProcess = sizeof ProcessData / sizeof ProcessData[0];
RtlInitializeCriticalSection( &ProcessDataLock );
}
-PCSRSS_PROCESS_DATA STDCALL CsrGetProcessData(HANDLE ProcessId)
+PCSRSS_PROCESS_DATA WINAPI CsrGetProcessData(HANDLE ProcessId)
{
ULONG hash;
PCSRSS_PROCESS_DATA pProcessData;
return pProcessData;
}
-PCSRSS_PROCESS_DATA STDCALL CsrCreateProcessData(HANDLE ProcessId)
+PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId)
{
ULONG hash;
PCSRSS_PROCESS_DATA pProcessData;
return pProcessData;
}
-NTSTATUS STDCALL CsrFreeProcessData(HANDLE Pid)
+NTSTATUS WINAPI CsrFreeProcessData(HANDLE Pid)
{
ULONG hash;
UINT c;
return STATUS_INVALID_PARAMETER;
}
-NTSTATUS STDCALL
+NTSTATUS WINAPI
CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc, PVOID Context)
{
UINT Hash;
(VOID)CallHardError(ProcessData, Message);
}
-NTSTATUS STDCALL
+NTSTATUS WINAPI
CsrpHandleConnectionRequest (PPORT_MESSAGE Request,
IN HANDLE hApiListenPort)
{
}
VOID
-STDCALL
+WINAPI
ClientConnectionThread(HANDLE ServerPort)
{
NTSTATUS Status;
* "\Windows\ApiPort".
*/
#if 0
-DWORD STDCALL
+DWORD WINAPI
ServerApiPortThread (HANDLE hApiListenPort)
{
NTSTATUS Status = STATUS_SUCCESS;
* "\Windows\SbApiPort". We will accept only one
* connection request (from the SM).
*/
-DWORD STDCALL
+DWORD WINAPI
ServerSbApiPortThread (HANDLE hSbApiPortListen)
{
HANDLE hConnectedPort = (HANDLE) 0;
BOOL Terminated;
} CSRSS_PROCESS_DATA, *PCSRSS_PROCESS_DATA;
-typedef VOID (STDCALL *CSR_CLEANUP_OBJECT_PROC)(Object_t *Object);
+typedef VOID (WINAPI *CSR_CLEANUP_OBJECT_PROC)(Object_t *Object);
typedef struct tagCSRSS_OBJECT_DEFINITION
{
CSR_CLEANUP_OBJECT_PROC CsrCleanupObjectProc;
} CSRSS_OBJECT_DEFINITION, *PCSRSS_OBJECT_DEFINITION;
-typedef NTSTATUS (STDCALL *CSRSS_API_PROC)(PCSRSS_PROCESS_DATA ProcessData,
+typedef NTSTATUS (WINAPI *CSRSS_API_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PCSR_API_MESSAGE Request);
typedef struct _CSRSS_API_DEFINITION
PCSRSS_API_DEFINITION *ApiDefinitions;
} CSRSS_LISTEN_DATA, *PCSRSS_LISTEN_DATA;
-#define CSR_API(n) NTSTATUS STDCALL n (\
+#define CSR_API(n) NTSTATUS WINAPI n (\
PCSRSS_PROCESS_DATA ProcessData,\
PCSR_API_MESSAGE Request)
CSR_API(CsrTerminateProcess);
/* print.c */
-VOID STDCALL DisplayString(LPCWSTR lpwString);
-VOID STDCALL PrintString (char* fmt, ...);
+VOID WINAPI DisplayString(LPCWSTR lpwString);
+VOID WINAPI PrintString (char* fmt, ...);
/* api/wapi.c */
NTSTATUS FASTCALL CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions);
VOID FASTCALL CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
PCSR_API_MESSAGE Request);
-DWORD STDCALL ServerApiPortThread (PVOID PortHandle);
-DWORD STDCALL ServerSbApiPortThread (PVOID PortHandle);
-DWORD STDCALL Console_Api( PVOID unused );
+DWORD WINAPI ServerApiPortThread (PVOID PortHandle);
+DWORD WINAPI ServerSbApiPortThread (PVOID PortHandle);
+DWORD WINAPI Console_Api( PVOID unused );
VOID
NTAPI
ClientConnectionThread(HANDLE ServerPort);
extern HANDLE CsrssApiHeap;
/* api/conio.c */
-VOID STDCALL CsrInitConsoleSupport(VOID);
+VOID WINAPI CsrInitConsoleSupport(VOID);
/* api/process.c */
-typedef NTSTATUS (STDCALL *CSRSS_ENUM_PROCESS_PROC)(PCSRSS_PROCESS_DATA ProcessData,
+typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PVOID Context);
-VOID STDCALL CsrInitProcessData(VOID);
-PCSRSS_PROCESS_DATA STDCALL CsrGetProcessData(HANDLE ProcessId);
-PCSRSS_PROCESS_DATA STDCALL CsrCreateProcessData(HANDLE ProcessId);
-NTSTATUS STDCALL CsrFreeProcessData( HANDLE Pid );
-NTSTATUS STDCALL CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc, PVOID Context);
+VOID WINAPI CsrInitProcessData(VOID);
+PCSRSS_PROCESS_DATA WINAPI CsrGetProcessData(HANDLE ProcessId);
+PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId);
+NTSTATUS WINAPI CsrFreeProcessData( HANDLE Pid );
+NTSTATUS WINAPI CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc, PVOID Context);
/* api/handle.c */
NTSTATUS FASTCALL CsrRegisterObjectDefinitions(PCSRSS_OBJECT_DEFINITION NewDefinitions);
-NTSTATUS STDCALL CsrInsertObject( PCSRSS_PROCESS_DATA ProcessData, PHANDLE Handle, Object_t *Object, DWORD Access, BOOL Inheritable );
-NTSTATUS STDCALL CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData, PCSRSS_PROCESS_DATA TargetProcessData);
-NTSTATUS STDCALL CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object, DWORD Access );
-BOOL STDCALL CsrServerInitialization (int,char**,char**);
-NTSTATUS STDCALL CsrReleaseObjectByPointer(Object_t *Object);
-NTSTATUS STDCALL CsrReleaseObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
-NTSTATUS STDCALL CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
+NTSTATUS WINAPI CsrInsertObject( PCSRSS_PROCESS_DATA ProcessData, PHANDLE Handle, Object_t *Object, DWORD Access, BOOL Inheritable );
+NTSTATUS WINAPI CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData, PCSRSS_PROCESS_DATA TargetProcessData);
+NTSTATUS WINAPI CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object, DWORD Access );
+BOOL WINAPI CsrServerInitialization (int,char**,char**);
+NTSTATUS WINAPI CsrReleaseObjectByPointer(Object_t *Object);
+NTSTATUS WINAPI CsrReleaseObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
+NTSTATUS WINAPI CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
CSR_API(CsrGetInputHandle);
CSR_API(CsrGetOutputHandle);
typedef struct tagCSRSS_CONSOLE_VTBL
{
- VOID (STDCALL *InitScreenBuffer)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
- VOID (STDCALL *WriteStream)(PCSRSS_CONSOLE Console, RECT *Block, LONG CursorStartX, LONG CursorStartY,
+ VOID (WINAPI *InitScreenBuffer)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
+ VOID (WINAPI *WriteStream)(PCSRSS_CONSOLE Console, RECT *Block, LONG CursorStartX, LONG CursorStartY,
UINT ScrolledLines, CHAR *Buffer, UINT Length);
- VOID (STDCALL *DrawRegion)(PCSRSS_CONSOLE Console, RECT *Region);
- BOOL (STDCALL *SetCursorInfo)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
- BOOL (STDCALL *SetScreenInfo)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer,
+ VOID (WINAPI *DrawRegion)(PCSRSS_CONSOLE Console, RECT *Region);
+ BOOL (WINAPI *SetCursorInfo)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
+ BOOL (WINAPI *SetScreenInfo)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer,
UINT OldCursorX, UINT OldCursorY);
- BOOL (STDCALL *UpdateScreenInfo)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
- BOOL (STDCALL *ChangeTitle)(PCSRSS_CONSOLE Console);
- VOID (STDCALL *CleanupConsole)(PCSRSS_CONSOLE Console);
- BOOL (STDCALL *ChangeIcon)(PCSRSS_CONSOLE Console, HICON hWindowIcon);
+ BOOL (WINAPI *UpdateScreenInfo)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
+ BOOL (WINAPI *ChangeTitle)(PCSRSS_CONSOLE Console);
+ VOID (WINAPI *CleanupConsole)(PCSRSS_CONSOLE Console);
+ BOOL (WINAPI *ChangeIcon)(PCSRSS_CONSOLE Console, HICON hWindowIcon);
} CSRSS_CONSOLE_VTBL, *PCSRSS_CONSOLE_VTBL;
typedef struct tagCSRSS_CONSOLE
} CSRSS_CONSOLE;
NTSTATUS FASTCALL ConioConsoleFromProcessData(PCSRSS_PROCESS_DATA ProcessData, PCSRSS_CONSOLE *Console);
-VOID STDCALL ConioDeleteConsole(Object_t *Object);
-VOID STDCALL ConioDeleteScreenBuffer(Object_t *Buffer);
-void STDCALL ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode);
+VOID WINAPI ConioDeleteConsole(Object_t *Object);
+VOID WINAPI ConioDeleteScreenBuffer(Object_t *Buffer);
+void WINAPI ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode);
PBYTE FASTCALL ConioCoordToPointer(PCSRSS_SCREEN_BUFFER Buf, ULONG X, ULONG Y);
VOID FASTCALL ConioDrawConsole(PCSRSS_CONSOLE Console);
VOID FASTCALL ConioConsoleCtrlEvent(DWORD Event, PCSRSS_PROCESS_DATA ProcessData);
#include <windows.h>
#include "api.h"
-typedef NTSTATUS (STDCALL *CSRSS_INSERT_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
+typedef NTSTATUS (WINAPI *CSRSS_INSERT_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
Object_t *Object,
DWORD Access,
BOOL Inheritable);
-typedef NTSTATUS (STDCALL *CSRSS_GET_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
+typedef NTSTATUS (WINAPI *CSRSS_GET_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
Object_t **Object,
DWORD Access);
-typedef NTSTATUS (STDCALL *CSRSS_RELEASE_OBJECT_BY_POINTER_PROC)(Object_t *Object);
-typedef NTSTATUS (STDCALL *CSRSS_RELEASE_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
+typedef NTSTATUS (WINAPI *CSRSS_RELEASE_OBJECT_BY_POINTER_PROC)(Object_t *Object);
+typedef NTSTATUS (WINAPI *CSRSS_RELEASE_OBJECT_PROC)(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Object );
-typedef NTSTATUS (STDCALL *CSRSS_ENUM_PROCESSES_PROC)(CSRSS_ENUM_PROCESS_PROC EnumProc,
+typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESSES_PROC)(CSRSS_ENUM_PROCESS_PROC EnumProc,
PVOID Context);
typedef struct tagCSRSS_EXPORTED_FUNCS
CSRSS_ENUM_PROCESSES_PROC CsrEnumProcessesProc;
} CSRSS_EXPORTED_FUNCS, *PCSRSS_EXPORTED_FUNCS;
-typedef BOOL (STDCALL *CSRPLUGIN_INIT_COMPLETE_PROC)(void);
+typedef BOOL (WINAPI *CSRPLUGIN_INIT_COMPLETE_PROC)(void);
-typedef BOOL (STDCALL *CSRPLUGIN_HARDERROR_PROC)(IN PCSRSS_PROCESS_DATA ProcessData,
+typedef BOOL (WINAPI *CSRPLUGIN_HARDERROR_PROC)(IN PCSRSS_PROCESS_DATA ProcessData,
IN PHARDERROR_MSG HardErrorMessage);
-typedef BOOL (STDCALL *CSRPLUGIN_INITIALIZE_PROC)(PCSRSS_API_DEFINITION *ApiDefinitions,
+typedef BOOL (WINAPI *CSRPLUGIN_INITIALIZE_PROC)(PCSRSS_API_DEFINITION *ApiDefinitions,
PCSRSS_OBJECT_DEFINITION *ObjectDefinitions,
CSRPLUGIN_INIT_COMPLETE_PROC *InitCompleteProc,
CSRPLUGIN_HARDERROR_PROC *HardErrorProc,
{ 0, 0, NULL }
};
-static NTSTATUS STDCALL
+static NTSTATUS WINAPI
CsrpCreateListenPort (IN LPWSTR Name,
IN OUT PHANDLE Port,
IN PTHREAD_START_ROUTINE ListenThread)
* RETURN VALUE
* TRUE: Initialization OK; otherwise FALSE.
*/
-BOOL STDCALL
+BOOL WINAPI
CsrServerInitialization (
int argc,
char ** argv,
#define NDEBUG
#include <debug.h>
-VOID STDCALL DisplayString(LPCWSTR lpwString)
+VOID WINAPI DisplayString(LPCWSTR lpwString)
{
UNICODE_STRING us;
ZwDisplayString (&us);
}
-VOID STDCALL PrintString (char* fmt, ...)
+VOID WINAPI PrintString (char* fmt, ...)
{
char buffer[512];
va_list ap;
}
VOID
-STDCALL
+WINAPI
InitializeAppSwitchHook()
{
hhk = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProc, NULL, 0);
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS WINAPI
CsrInitConsole(PCSRSS_CONSOLE Console)
{
NTSTATUS Status;
return Status;
}
-VOID STDCALL
+VOID WINAPI
ConioDeleteScreenBuffer(Object_t *Object)
{
PCSRSS_SCREEN_BUFFER Buffer = (PCSRSS_SCREEN_BUFFER) Object;
}
-VOID STDCALL
+VOID WINAPI
ConioDeleteConsole(Object_t *Object)
{
PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) Object;
HeapFree(Win32CsrApiHeap, 0, Console);
}
-VOID STDCALL
+VOID WINAPI
CsrInitConsoleSupport(VOID)
{
DPRINT("CSR: CsrInitConsoleSupport()\n");
return ssOut;
}
-VOID STDCALL
+VOID WINAPI
ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode)
{
static BYTE KeyState[256] = { 0 };
return TRUE;
}
-static DWORD STDCALL
+static DWORD WINAPI
DtbgDesktopThread(PVOID Data)
{
HWND BackgroundWnd;
#include <debug.h>
/* Not defined in any header file */
-extern VOID STDCALL PrivateCsrssManualGuiCheck(LONG Check);
-extern VOID STDCALL PrivateCsrssInitialized();
-extern VOID STDCALL InitializeAppSwitchHook();
+extern VOID WINAPI PrivateCsrssManualGuiCheck(LONG Check);
+extern VOID WINAPI PrivateCsrssInitialized();
+extern VOID WINAPI InitializeAppSwitchHook();
/* GLOBALS *******************************************************************/
/* FUNCTIONS *****************************************************************/
-BOOL STDCALL
+BOOL WINAPI
DllMain(HANDLE hDll,
DWORD dwReason,
LPVOID lpReserved)
return (CsrExports.CsrEnumProcessesProc)(EnumProc, Context);
}
-static BOOL STDCALL
+static BOOL WINAPI
Win32CsrInitComplete(void)
{
PrivateCsrssInitialized();
return TRUE;
}
-static BOOL STDCALL
+static BOOL WINAPI
Win32CsrHardError(IN PCSRSS_PROCESS_DATA ProcessData,
IN PHARDERROR_MSG HardErrorMessage)
{
}
-BOOL STDCALL
+BOOL WINAPI
Win32CsrInitialization(PCSRSS_API_DEFINITION *ApiDefinitions,
PCSRSS_OBJECT_DEFINITION *ObjectDefinitions,
CSRPLUGIN_INIT_COMPLETE_PROC *InitComplete,
return Result;
}
-typedef void (STDCALL *INITCOMMONCONTROLS_PROC)(void);
+typedef void (WINAPI *INITCOMMONCONTROLS_PROC)(void);
static void FASTCALL
CallInitCommonControls()
DWORD CsrssProcess;
} PROCESS_ENUM_CONTEXT, *PPROCESS_ENUM_CONTEXT;
-static NTSTATUS STDCALL
+static NTSTATUS WINAPI
ExitReactosProcessEnum(PCSRSS_PROCESS_DATA ProcessData, PVOID Data)
{
HANDLE Process;
#include <debug.h>
/* Not defined in any header file */
-extern VOID STDCALL PrivateCsrssManualGuiCheck(LONG Check);
+extern VOID WINAPI PrivateCsrssManualGuiCheck(LONG Check);
/* GLOBALS *******************************************************************/
InvalidateRect(Wnd, &RegionRect, FALSE);
}
-static VOID STDCALL
+static VOID WINAPI
GuiDrawRegion(PCSRSS_CONSOLE Console, RECT *Region)
{
PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA) Console->PrivateData;
GuiIntDrawRegion(Buff, GuiData, Wnd, &CellRect);
}
-static VOID STDCALL
+static VOID WINAPI
GuiWriteStream(PCSRSS_CONSOLE Console, RECT *Region, LONG CursorStartX, LONG CursorStartY,
UINT ScrolledLines, CHAR *Buffer, UINT Length)
{
}
}
-static BOOL STDCALL
+static BOOL WINAPI
GuiSetCursorInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff)
{
RECT UpdateRect;
return TRUE;
}
-static BOOL STDCALL
+static BOOL WINAPI
GuiSetScreenInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff, UINT OldCursorX, UINT OldCursorY)
{
RECT UpdateRect;
return TRUE;
}
-static BOOL STDCALL
+static BOOL WINAPI
GuiUpdateScreenInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff)
{
PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA) Console->PrivateData;
}
}
-static DWORD STDCALL
+static DWORD WINAPI
GuiConsoleGuiThread(PVOID Data)
{
MSG msg;
return TRUE;
}
-static VOID STDCALL
+static VOID WINAPI
GuiInitScreenBuffer(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buffer)
{
Buffer->DefaultAttrib = DEFAULT_ATTRIB;
}
-static BOOL STDCALL
+static BOOL WINAPI
GuiChangeTitle(PCSRSS_CONSOLE Console)
{
PWCHAR Buffer, Title;
return TRUE;
}
-static BOOL STDCALL
+static BOOL WINAPI
GuiChangeIcon(PCSRSS_CONSOLE Console, HICON hWindowIcon)
{
SendMessageW(Console->hWindow, WM_SETICON, ICON_BIG, (LPARAM)hWindowIcon);
return TRUE;
}
-static VOID STDCALL
+static VOID WINAPI
GuiCleanupConsole(PCSRSS_CONSOLE Console)
{
SendMessageW(NotifyWnd, PM_DESTROY_CONSOLE, 0, (LPARAM) Console);
return TRUE;
}
-static VOID STDCALL
+static VOID WINAPI
TuiInitScreenBuffer(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buffer)
{
Buffer->DefaultAttrib = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | BACKGROUND_BLUE;
}
}
-static VOID STDCALL
+static VOID WINAPI
TuiDrawRegion(PCSRSS_CONSOLE Console, RECT *Region)
{
DWORD BytesReturned;
HeapFree(Win32CsrApiHeap, 0, ConsoleDraw);
}
-static VOID STDCALL
+static VOID WINAPI
TuiWriteStream(PCSRSS_CONSOLE Console, RECT *Region, LONG CursorStartX, LONG CursorStartY,
UINT ScrolledLines, CHAR *Buffer, UINT Length)
{
}
}
-static BOOL STDCALL
+static BOOL WINAPI
TuiSetCursorInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff)
{
DWORD BytesReturned;
return TRUE;
}
-static BOOL STDCALL
+static BOOL WINAPI
TuiSetScreenInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff, UINT OldCursorX, UINT OldCursorY)
{
CONSOLE_SCREEN_BUFFER_INFO Info;
return TRUE;
}
-static BOOL STDCALL
+static BOOL WINAPI
TuiUpdateScreenInfo(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff)
{
return TRUE;
}
-static BOOL STDCALL
+static BOOL WINAPI
TuiChangeTitle(PCSRSS_CONSOLE Console)
{
return TRUE;
}
-static VOID STDCALL
+static VOID WINAPI
TuiCleanupConsole(PCSRSS_CONSOLE Console)
{
DestroyWindow(Console->hWindow);
}
}
-DWORD STDCALL
+DWORD WINAPI
TuiConsoleThread (PVOID Data)
{
PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) Data;
#define NDEBUG
#include <debug.h>
-typedef BOOLEAN (STDCALL *PBLTRECTFUNC)(SURFOBJ* OutputObj,
+typedef BOOLEAN (APIENTRY *PBLTRECTFUNC)(SURFOBJ* OutputObj,
SURFOBJ* InputObj,
SURFOBJ* Mask,
XLATEOBJ* ColorTranslation,
BRUSHOBJ* Brush,
POINTL* BrushOrigin,
ROP4 Rop4);
-typedef BOOLEAN (STDCALL *PSTRETCHRECTFUNC)(SURFOBJ* OutputObj,
+typedef BOOLEAN (APIENTRY *PSTRETCHRECTFUNC)(SURFOBJ* OutputObj,
SURFOBJ* InputObj,
SURFOBJ* Mask,
CLIPOBJ* ClipRegion,
POINTL* BrushOrigin,
ULONG Mode);
-BOOL STDCALL EngIntersectRect(RECTL* prcDst, RECTL* prcSrc1, RECTL* prcSrc2)
+BOOL APIENTRY EngIntersectRect(RECTL* prcDst, RECTL* prcSrc1, RECTL* prcSrc2)
{
static const RECTL rclEmpty = { 0, 0, 0, 0 };
return FALSE;
}
-static BOOLEAN STDCALL
+static BOOLEAN APIENTRY
BltMask(SURFOBJ* Dest,
SURFOBJ* Source,
SURFOBJ* Mask,
return TRUE;
}
-static BOOLEAN STDCALL
+static BOOLEAN APIENTRY
BltPatCopy(SURFOBJ* Dest,
SURFOBJ* Source,
SURFOBJ* Mask,
return TRUE;
}
-static BOOLEAN STDCALL
+static BOOLEAN APIENTRY
CallDibBitBlt(SURFOBJ* OutputObj,
SURFOBJ* InputObj,
SURFOBJ* Mask,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtGdiEngBitBlt(
IN SURFOBJ *psoTrg,
IN SURFOBJ *psoSrc,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngBitBlt(SURFOBJ *DestObj,
SURFOBJ *SourceObj,
SURFOBJ *Mask,
return Ret;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngBitBltEx(SURFOBJ *DestSurf,
SURFOBJ *SourceSurf,
SURFOBJ *MaskSurf,
return ret;
}
-static BOOLEAN STDCALL
+static BOOLEAN APIENTRY
CallDibStretchBlt(SURFOBJ* OutputObj,
SURFOBJ* InputObj,
SURFOBJ* Mask,
BOOL
-STDCALL
+APIENTRY
NtGdiEngStretchBlt(
IN SURFOBJ *DestObj,
IN SURFOBJ *SourceObj,
}
BOOL
-STDCALL
+APIENTRY
EngStretchBlt(
IN SURFOBJ *DestObj,
IN SURFOBJ *SourceObj,
return Ret;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngStretchBlt(SURFOBJ *DestSurf,
SURFOBJ *SourceSurf,
SURFOBJ *MaskSurf,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtGdiEngAlphaBlend(IN SURFOBJ *Dest,
IN SURFOBJ *Source,
IN CLIPOBJ *ClipRegion,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
EngAlphaBlend(IN SURFOBJ *Dest,
IN SURFOBJ *Source,
IN CLIPOBJ *ClipRegion,
return Ret;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngAlphaBlend(IN SURFOBJ *Dest,
IN SURFOBJ *Source,
IN CLIPOBJ *ClipRegion,
/**** REACTOS FONT RENDERING CODE *********************************************/
/* renders the alpha mask bitmap */
-static BOOLEAN STDCALL
+static BOOLEAN APIENTRY
AlphaBltMask(SURFOBJ* Dest,
SURFOBJ* Source,
SURFOBJ* Mask,
}
}
-BOOL STDCALL
+BOOL APIENTRY
EngMaskBitBlt(SURFOBJ *DestObj,
SURFOBJ *Mask,
CLIPOBJ *ClipRegion,
return Ret;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngMaskBlt(SURFOBJ *DestSurf,
SURFOBJ *Mask,
CLIPOBJ *ClipRegion,
/*
* @implemented
*/
-CLIPOBJ * STDCALL
+CLIPOBJ * APIENTRY
EngCreateClip(VOID)
{
CLIPGDI *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(CLIPGDI), TAG_CLIPOBJ);
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngDeleteClip(CLIPOBJ *ClipRegion)
{
EngFreeMem(ObjToGDI(ClipRegion, CLIP));
/*
* @implemented
*/
-ULONG STDCALL
+ULONG APIENTRY
CLIPOBJ_cEnumStart(
IN CLIPOBJ* ClipObj,
IN BOOL ShouldDoAll,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
CLIPOBJ_bEnum(
IN CLIPOBJ* ClipObj,
IN ULONG ObjSize,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngCopyBits(SURFOBJ *Dest,
SURFOBJ *Source,
CLIPOBJ *Clip,
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngDebugPrint(PCHAR StandardPrefix,
PCHAR DebugMessage,
va_list ap)
/*
* @implemented
*/
-DWORD STDCALL
+DWORD APIENTRY
EngDeviceIoControl(HANDLE hDevice,
DWORD dwIoControlCode,
LPVOID lpInBuffer,
* @implemented
*/
HDRVOBJ
-STDCALL
+APIENTRY
EngCreateDriverObj(
IN PVOID pvObj,
IN FREEOBJPROC pFreeObjProc,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
EngDeleteDriverObj(
IN HDRVOBJ hdo,
IN BOOL bCallBack,
* @implemented
*/
PDRIVEROBJ
-STDCALL
+APIENTRY
EngLockDriverObj( IN HDRVOBJ hdo )
{
PDRIVEROBJ DrvObjUser = (PDRIVEROBJ)hdo;
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
EngUnlockDriverObj ( IN HDRVOBJ hdo )
{
PDRIVERGDI DrvObjInt = ObjToGDI((PDRIVEROBJ)hdo, DRIVER);
/*
* @implemented
*/
-PVOID STDCALL
+PVOID APIENTRY
BRUSHOBJ_pvAllocRbrush(IN BRUSHOBJ *BrushObj,
IN ULONG ObjSize)
{
/*
* @implemented
*/
-PVOID STDCALL
+PVOID APIENTRY
BRUSHOBJ_pvGetRbrush(IN BRUSHOBJ *BrushObj)
{
return(BrushObj->pvRbrush);
/*
* @implemented
*/
-ULONG STDCALL
+ULONG APIENTRY
BRUSHOBJ_ulGetBrushColor(IN BRUSHOBJ *BrushObj)
{
return BrushObj->iSolidColor;
#define NDEBUG
#include <debug.h>
-BOOL STDCALL
+BOOL APIENTRY
IntEngEnter(PINTENG_ENTER_LEAVE EnterLeave,
SURFOBJ *DestSurf,
RECTL *DestRect,
return TRUE;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngLeave(PINTENG_ENTER_LEAVE EnterLeave)
{
POINTL SrcPoint;
return Result;
}
-HANDLE STDCALL
+HANDLE APIENTRY
EngGetCurrentProcessId(VOID)
{
/* http://www.osr.com/ddk/graphics/gdifncs_5ovb.htm */
return PsGetCurrentProcessId();
}
-HANDLE STDCALL
+HANDLE APIENTRY
EngGetCurrentThreadId(VOID)
{
/* http://www.osr.com/ddk/graphics/gdifncs_25rb.htm */
return PsGetCurrentThreadId();
}
-HANDLE STDCALL
+HANDLE APIENTRY
EngGetProcessHandle(VOID)
{
/* http://www.osr.com/ddk/graphics/gdifncs_3tif.htm
* @implemented
*/
WNDOBJ*
-STDCALL
+APIENTRY
EngCreateWnd(
SURFOBJ *pso,
HWND hWnd,
* @implemented
*/
VOID
-STDCALL
+APIENTRY
EngDeleteWnd(
IN WNDOBJ *pwo)
{
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
WNDOBJ_bEnum(
IN WNDOBJ *pwo,
IN ULONG cj,
* @implemented
*/
ULONG
-STDCALL
+APIENTRY
WNDOBJ_cEnumStart(
IN WNDOBJ *pwo,
IN ULONG iType,
* @implemented
*/
VOID
-STDCALL
+APIENTRY
WNDOBJ_vSetConsumer(
IN WNDOBJ *pwo,
IN PVOID pvConsumer)
* @implemented
*/
ULONG
-STDCALL
+APIENTRY
EngGetLastError ( VOID )
{
// www.osr.com/ddk/graphics/gdifncs_3non.htm
* @implemented
*/
VOID
-STDCALL
+APIENTRY
EngSetLastError ( IN ULONG iError )
{
// www.osr.com/ddk/graphics/gdifncs_95m0.htm
#include <debug.h>
BOOL
-STDCALL
+APIENTRY
EngCreateEvent ( OUT PEVENT *Event )
{
(*Event) = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_DFSM);
}
BOOL
-STDCALL
+APIENTRY
EngDeleteEvent ( IN PEVENT Event)
{
ExFreePoolWithTag(Event, TAG_DFSM);
}
PEVENT
-STDCALL
+APIENTRY
EngMapEvent(IN HDEV Dev,
IN HANDLE UserObject,
IN PVOID Reserved1,
}
LONG
-STDCALL
+APIENTRY
EngSetEvent ( IN PEVENT Event )
{
return KeSetEvent((PKEVENT)Event, IO_NO_INCREMENT, FALSE);
}
BOOL
-STDCALL
+APIENTRY
EngUnmapEvent ( IN PEVENT Event )
{
ObDereferenceObject((PVOID)Event);
}
BOOL
-STDCALL
+APIENTRY
EngWaitForSingleObject (IN PEVENT Event,
IN PLARGE_INTEGER TimeOut)
{
/* FUNCTIONS *****************************************************************/
BOOL
-STDCALL
+APIENTRY
EngRestoreFloatingPointState ( IN VOID *Buffer )
{
NTSTATUS Status;
}
ULONG
-STDCALL
+APIENTRY
EngSaveFloatingPointState(OUT VOID *Buffer,
IN ULONG BufferSize)
{
}
-BOOL STDCALL
+BOOL APIENTRY
EngGradientFill(
IN SURFOBJ *psoDest,
IN CLIPOBJ *pco,
return ret;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngGradientFill(
IN SURFOBJ *psoDest,
IN CLIPOBJ *pco,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngLineTo(SURFOBJ *DestObj,
CLIPOBJ *Clip,
BRUSHOBJ *Brush,
return IntEngLeave(&EnterLeave);
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngLineTo(SURFOBJ *DestSurf,
CLIPOBJ *ClipObj,
BRUSHOBJ *Brush,
return ret;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngPolyline(SURFOBJ *DestSurf,
CLIPOBJ *Clip,
BRUSHOBJ *Brush,
/*
* @implemented
*/
-PVOID STDCALL
+PVOID APIENTRY
EngAllocMem(ULONG Flags,
ULONG MemSize,
ULONG Tag)
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngFreeMem(PVOID Mem)
{
ExFreePool(Mem);
/*
* @implemented
*/
-PVOID STDCALL
+PVOID APIENTRY
EngAllocUserMem(SIZE_T cj, ULONG Tag)
{
PVOID NewMem = NULL;
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngFreeUserMem(PVOID pv)
{
PUSERMEMHEADER Header = ((PUSERMEMHEADER) pv) - 1;
PVOID
-NTAPI
+APIENTRY
HackSecureVirtualMemory(
IN PVOID Address,
IN SIZE_T Size,
}
VOID
-NTAPI
+APIENTRY
HackUnsecureVirtualMemory(
IN PVOID SecureHandle)
{
/*
* @implemented
*/
-HANDLE STDCALL
+HANDLE APIENTRY
EngSecureMem(PVOID Address, ULONG Length)
{
return MmSecureVirtualMemory(Address, Length, PAGE_READWRITE);
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngUnsecureMem(HANDLE Mem)
{
return MmUnsecureVirtualMemory((PVOID) Mem);
BOOL ReadOnly;
} INTENG_ENTER_LEAVE, *PINTENG_ENTER_LEAVE;
-extern BOOL STDCALL IntEngEnter(PINTENG_ENTER_LEAVE EnterLeave,
+extern BOOL APIENTRY IntEngEnter(PINTENG_ENTER_LEAVE EnterLeave,
SURFOBJ *DestObj,
RECTL *DestRect,
BOOL ReadOnly,
POINTL *Translate,
SURFOBJ **OutputObj);
-extern BOOL STDCALL IntEngLeave(PINTENG_ENTER_LEAVE EnterLeave);
+extern BOOL APIENTRY IntEngLeave(PINTENG_ENTER_LEAVE EnterLeave);
#endif
* @implemented
*/
-ULONG STDCALL
+ULONG APIENTRY
EngSetPointerShape(
IN SURFOBJ *pso,
IN SURFOBJ *psoMask,
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngMovePointer(
IN SURFOBJ *pso,
IN LONG x,
}
-VOID STDCALL
+VOID APIENTRY
IntEngMovePointer(
IN SURFOBJ *SurfObj,
IN LONG x,
PATHOBJ PathObj;
} PATHGDI;
-typedef BOOL (STDCALL *PFN_BitBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
+typedef BOOL (APIENTRY *PFN_BitBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
XLATEOBJ *, RECTL *, POINTL *, POINTL *,
BRUSHOBJ *, POINTL *, ROP4);
-typedef BOOL (STDCALL *PFN_TransparentBlt)(SURFOBJ *, SURFOBJ *, CLIPOBJ *, XLATEOBJ *, RECTL *, RECTL *, ULONG, ULONG);
+typedef BOOL (APIENTRY *PFN_TransparentBlt)(SURFOBJ *, SURFOBJ *, CLIPOBJ *, XLATEOBJ *, RECTL *, RECTL *, ULONG, ULONG);
-typedef BOOL (STDCALL *PFN_StretchBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
+typedef BOOL (APIENTRY *PFN_StretchBlt)(SURFOBJ *, SURFOBJ *, SURFOBJ *, CLIPOBJ *,
XLATEOBJ *, COLORADJUSTMENT *, POINTL *,
RECTL *, RECTL *, PPOINT, ULONG);
-typedef BOOL (STDCALL *PFN_TextOut)(SURFOBJ *, STROBJ *, FONTOBJ *, CLIPOBJ *,
+typedef BOOL (APIENTRY *PFN_TextOut)(SURFOBJ *, STROBJ *, FONTOBJ *, CLIPOBJ *,
RECTL *, RECTL *, BRUSHOBJ *, BRUSHOBJ *,
POINTL *, MIX);
-typedef BOOL (STDCALL *PFN_Paint)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *, POINTL *, MIX);
+typedef BOOL (APIENTRY *PFN_Paint)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *, POINTL *, MIX);
-typedef BOOL (STDCALL *PFN_StrokePath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, XFORMOBJ *,
+typedef BOOL (APIENTRY *PFN_StrokePath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, XFORMOBJ *,
BRUSHOBJ *, POINTL *, LINEATTRS *, MIX);
-typedef BOOL (STDCALL *PFN_FillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, BRUSHOBJ *,
+typedef BOOL (APIENTRY *PFN_FillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *, BRUSHOBJ *,
POINTL *, MIX, ULONG);
-typedef BOOL (STDCALL *PFN_StrokeAndFillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *,
+typedef BOOL (APIENTRY *PFN_StrokeAndFillPath)(SURFOBJ *, PATHOBJ *, CLIPOBJ *,
XFORMOBJ *, BRUSHOBJ *, LINEATTRS *, BRUSHOBJ *,
POINTL *, MIX, ULONG);
-typedef BOOL (STDCALL *PFN_LineTo)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *,
+typedef BOOL (APIENTRY *PFN_LineTo)(SURFOBJ *, CLIPOBJ *, BRUSHOBJ *,
LONG, LONG, LONG, LONG, RECTL *, MIX);
-typedef BOOL (STDCALL *PFN_CopyBits)(SURFOBJ *, SURFOBJ *, CLIPOBJ *,
+typedef BOOL (APIENTRY *PFN_CopyBits)(SURFOBJ *, SURFOBJ *, CLIPOBJ *,
XLATEOBJ *, RECTL *, POINTL *);
-typedef VOID (STDCALL *PFN_Synchronize)(DHPDEV, RECTL *);
+typedef VOID (APIENTRY *PFN_Synchronize)(DHPDEV, RECTL *);
-typedef VOID (STDCALL *PFN_MovePointer)(SURFOBJ *, LONG, LONG, RECTL *);
+typedef VOID (APIENTRY *PFN_MovePointer)(SURFOBJ *, LONG, LONG, RECTL *);
-typedef ULONG (STDCALL *PFN_SetPointerShape)(SURFOBJ *, SURFOBJ *, SURFOBJ *, XLATEOBJ *,
+typedef ULONG (APIENTRY *PFN_SetPointerShape)(SURFOBJ *, SURFOBJ *, SURFOBJ *, XLATEOBJ *,
LONG, LONG, LONG, LONG, RECTL *, FLONG);
-typedef HBITMAP (STDCALL *PFN_CreateDeviceBitmap)(DHPDEV, SIZEL, ULONG);
+typedef HBITMAP (APIENTRY *PFN_CreateDeviceBitmap)(DHPDEV, SIZEL, ULONG);
-typedef BOOL (STDCALL *PFN_SetPalette)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG);
+typedef BOOL (APIENTRY *PFN_SetPalette)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG);
-typedef BOOL (STDCALL *PFN_GradientFill)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);
+typedef BOOL (APIENTRY *PFN_GradientFill)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);
typedef struct _WNDGDI {
WNDOBJ WndObj;
#define NDEBUG
#include <debug.h>
-BOOL STDCALL FillSolid(SURFOBJ *Surface, PRECTL pRect, ULONG iColor)
+BOOL APIENTRY FillSolid(SURFOBJ *Surface, PRECTL pRect, ULONG iColor)
{
LONG y;
ULONG LineWidth;
return TRUE;
}
-BOOL STDCALL
+BOOL APIENTRY
EngPaintRgn(SURFOBJ *Surface, CLIPOBJ *ClipRegion, ULONG iColor, MIX Mix,
BRUSHOBJ *BrushObj, POINTL *BrushPoint)
{
/*
* @unimplemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngPaint(IN SURFOBJ *Surface,
IN CLIPOBJ *ClipRegion,
IN BRUSHOBJ *Brush,
return ret;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEngPaint(IN SURFOBJ *Surface,
IN CLIPOBJ *ClipRegion,
IN BRUSHOBJ *Brush,
/*
* @implemented
*/
-HPALETTE STDCALL
+HPALETTE APIENTRY
EngCreatePalette(ULONG Mode, ULONG NumColors, ULONG *Colors,
ULONG Red, ULONG Green, ULONG Blue)
{
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngDeletePalette(IN HPALETTE Palette)
{
GDIOBJ_SetOwnership(Palette, PsGetCurrentProcess());
/*
* @implemented
*/
-ULONG STDCALL
+ULONG APIENTRY
PALOBJ_cGetColors(PALOBJ *PalObj, ULONG Start, ULONG Colors, ULONG *PaletteEntry)
{
PALGDI *PalGDI;
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngQueryPerformanceFrequency(LONGLONG *Frequency)
{
LARGE_INTEGER Freq;
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngQueryPerformanceCounter(LONGLONG *Count)
{
LARGE_INTEGER PerfCount;
* @implemented
*/
HSEMAPHORE
-STDCALL
+APIENTRY
EngCreateSemaphore ( VOID )
{
// www.osr.com/ddk/graphics/gdifncs_95lz.htm
* @implemented
*/
VOID
-STDCALL
+APIENTRY
EngAcquireSemaphore ( IN HSEMAPHORE hsem )
{
// www.osr.com/ddk/graphics/gdifncs_14br.htm
* @implemented
*/
VOID
-STDCALL
+APIENTRY
EngReleaseSemaphore ( IN HSEMAPHORE hsem )
{
// www.osr.com/ddk/graphics/gdifncs_5u3r.htm
* @implemented
*/
VOID
-STDCALL
+APIENTRY
EngDeleteSemaphore ( IN HSEMAPHORE hsem )
{
// www.osr.com/ddk/graphics/gdifncs_13c7.htm
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
EngIsSemaphoreOwned ( IN HSEMAPHORE hsem )
{
// www.osr.com/ddk/graphics/gdifncs_6wmf.htm
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
EngIsSemaphoreOwnedByCurrentThread ( IN HSEMAPHORE hsem )
{
// www.osr.com/ddk/graphics/gdifncs_9yxz.htm
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngInitializeSafeSemaphore(
OUT ENGSAFESEMAPHORE *Semaphore)
{
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngDeleteSafeSemaphore(
IN OUT ENGSAFESEMAPHORE *Semaphore)
{
/*
* @implemented
*/
-void STDCALL
+void APIENTRY
EngSort(IN OUT PBYTE Buf, IN ULONG ElemSize, IN ULONG ElemCount, IN SORTCOMP CompFunc)
{
qsort(Buf, ElemCount, ElemSize, CompFunc);
/*
* @implemented
*/
-HBITMAP STDCALL
+HBITMAP APIENTRY
EngCreateDeviceBitmap(IN DHSURF dhsurf,
IN SIZEL Size,
IN ULONG Format)
/*
* @implemented
*/
-HBITMAP STDCALL
+HBITMAP APIENTRY
EngCreateBitmap(IN SIZEL Size,
IN LONG Width,
IN ULONG Format,
/*
* @unimplemented
*/
-HSURF STDCALL
+HSURF APIENTRY
EngCreateDeviceSurface(IN DHSURF dhsurf,
IN SIZEL Size,
IN ULONG Format)
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngAssociateSurface(IN HSURF Surface,
IN HDEV Dev,
IN ULONG Hooks)
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngModifySurface(
IN HSURF hsurf,
IN HDEV hdev,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngDeleteSurface(IN HSURF Surface)
{
GDIOBJ_SetOwnership(Surface, PsGetCurrentProcess());
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngEraseSurface(SURFOBJ *Surface,
RECTL *Rect,
ULONG iColor)
/*
* @implemented
*/
-SURFOBJ * STDCALL
+SURFOBJ * APIENTRY
NtGdiEngLockSurface(IN HSURF Surface)
{
return EngLockSurface(Surface);
/*
* @implemented
*/
-SURFOBJ * STDCALL
+SURFOBJ * APIENTRY
EngLockSurface(IN HSURF Surface)
{
BITMAPOBJ *bmp = GDIOBJ_ShareLockObj(Surface, GDI_OBJECT_TYPE_BITMAP);
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
NtGdiEngUnlockSurface(IN SURFOBJ *Surface)
{
EngUnlockSurface(Surface);
/*
* @implemented
*/
-VOID STDCALL
+VOID APIENTRY
EngUnlockSurface(IN SURFOBJ *Surface)
{
if (Surface != NULL)
#define NDEBUG
#include <debug.h>
-BOOL STDCALL
+BOOL APIENTRY
EngTransparentBlt(SURFOBJ *Dest,
SURFOBJ *Source,
CLIPOBJ *Clip,
/*
* @implemented
*/
-PULONG STDCALL
+PULONG APIENTRY
XLATEOBJ_piVector(XLATEOBJ *XlateObj)
{
if (XlateObj->iSrcType == PAL_INDEXED)
/*
* @implemented
*/
-ULONG STDCALL
+ULONG APIENTRY
XLATEOBJ_iXlate(XLATEOBJ *XlateObj, ULONG Color)
{
XLATEGDI *XlateGDI;
/*
* @implemented
*/
-ULONG STDCALL
+ULONG APIENTRY
XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj, ULONG PalOutType, ULONG cPal,
ULONG *OutPal)
{
UINT FASTCALL BITMAPOBJ_GetRealBitsPixel(UINT nBitsPixel);
HBITMAP FASTCALL BITMAPOBJ_CopyBitmap (HBITMAP hBitmap);
INT FASTCALL DIB_GetDIBWidthBytes (INT width, INT depth);
-int NTAPI DIB_GetDIBImageBytes (INT width, INT height, INT depth);
+int APIENTRY DIB_GetDIBImageBytes (INT width, INT height, INT depth);
INT FASTCALL DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse);
-INT NTAPI BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer);
+INT APIENTRY BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer);
HBITMAP FASTCALL BitmapToSurf(PBITMAPOBJ BitmapObj, HDEV GDIDevice);
#endif
#include <include/win32.h>
-LRESULT STDCALL
+LRESULT APIENTRY
co_IntCallWindowProc(WNDPROC Proc,
BOOLEAN IsAnsiProc,
HWND Wnd,
LPARAM lParam,
INT lParamBufferSize);
-VOID STDCALL
+VOID APIENTRY
co_IntCallSentMessageCallback(SENDASYNCPROC CompletionCallback,
HWND hWnd,
UINT Msg,
LRESULT Result);
-HMENU STDCALL
+HMENU APIENTRY
co_IntLoadSysMenuTemplate();
-BOOL STDCALL
+BOOL APIENTRY
co_IntLoadDefaultCursors(VOID);
-LRESULT STDCALL
+LRESULT APIENTRY
co_IntCallHookProc(INT HookId,
INT Code,
WPARAM wParam,
BOOLEAN Ansi,
PUNICODE_STRING ModuleName);
-LRESULT STDCALL
+LRESULT APIENTRY
co_IntCallEventProc(HWINEVENTHOOK hook,
DWORD event,
HWND hwnd,
VOID FASTCALL
IntClipboardFreeWindow(PWINDOW_OBJECT window);
-UINT STDCALL IntEnumClipboardFormats(UINT format);
+UINT APIENTRY IntEnumClipboardFormats(UINT format);
/*
UINT FASTCALL
extern HCOLORSPACE hStockColorSpace;
const PALETTEENTRY* FASTCALL COLOR_GetSystemPaletteTemplate (VOID);
-COLORREF STDCALL COLOR_LookupNearestColor (PALETTEENTRY* palPalEntry, INT size, COLORREF color);
-INT STDCALL COLOR_PaletteLookupExactIndex (PALETTEENTRY* palPalEntry, INT size, COLORREF col);
-INT STDCALL COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, INT size, XLATEOBJ *XlateObj, COLORREF col, BOOL skipReserved);
+COLORREF APIENTRY COLOR_LookupNearestColor (PALETTEENTRY* palPalEntry, INT size, COLORREF color);
+INT APIENTRY COLOR_PaletteLookupExactIndex (PALETTEENTRY* palPalEntry, INT size, COLORREF col);
+INT APIENTRY COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, INT size, XLATEOBJ *XlateObj, COLORREF col, BOOL skipReserved);
UINT FASTCALL IntGdiRealizePalette (HDC);
HCOLORSPACE FASTCALL IntGdiCreateColorSpace(PLOGCOLORSPACEEXW);
BOOL FASTCALL IntGdiDeleteColorSpace(HCOLORSPACE);
FASTCALL
IntGetGraphicsMode ( PDC dc );
-int STDCALL IntGdiSetMapMode(PDC, int);
+int APIENTRY IntGdiSetMapMode(PDC, int);
BOOL
FASTCALL
INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags);
PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCurIcon);
-int NTAPI UserShowCursor(BOOL bShow);
+int APIENTRY UserShowCursor(BOOL bShow);
#define IntGetSysCursorInfo(WinStaObj) \
(PSYSTEM_CURSORINFO)((WinStaObj)->SystemCursor)
COLORREF FASTCALL IntGdiSetBkColor (HDC hDC, COLORREF Color);
INT FASTCALL IntGdiSetBkMode(HDC hDC, INT backgroundMode);
-COLORREF STDCALL IntGdiGetBkColor(HDC hDC);
-INT STDCALL IntGdiGetBkMode(HDC hDC);
+COLORREF APIENTRY IntGdiGetBkColor(HDC hDC);
+INT APIENTRY IntGdiGetBkMode(HDC hDC);
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color);
UINT FASTCALL IntGdiSetTextAlign(HDC hDC, UINT Mode);
-UINT STDCALL IntGdiGetTextAlign(HDC hDC);
-COLORREF STDCALL IntGdiGetTextColor(HDC hDC);
-INT STDCALL IntGdiSetStretchBltMode(HDC hDC, INT stretchBltMode);
+UINT APIENTRY IntGdiGetTextAlign(HDC hDC);
+COLORREF APIENTRY IntGdiGetTextColor(HDC hDC);
+INT APIENTRY IntGdiSetStretchBltMode(HDC hDC, INT stretchBltMode);
VOID FASTCALL IntGdiReferencePdev(PGDIDEVICE pPDev);
VOID FASTCALL IntGdiUnreferencePdev(PGDIDEVICE pPDev, DWORD CleanUpType);
HDC FASTCALL IntGdiCreateDisplayDC(HDEV hDev, ULONG DcType, BOOL EmptyDC);
CleanupDesktopImpl(VOID);
NTSTATUS
-STDCALL
+APIENTRY
IntDesktopObjectParse(IN PVOID ParseObject,
IN PVOID ObjectType,
IN OUT PACCESS_STATE AccessState,
IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
OUT PVOID *Object);
-VOID STDCALL
+VOID APIENTRY
IntDesktopObjectDelete(PWIN32_DELETEMETHOD_PARAMETERS Parameters);
VOID FASTCALL
INT FASTCALL
DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse);
-HBITMAP STDCALL
+HBITMAP APIENTRY
DIB_CreateDIBSection (PDC dc, PBITMAPINFO bmi, UINT usage, LPVOID *bits, HANDLE section, DWORD offset, DWORD ovr_pitch);
-INT STDCALL
+INT APIENTRY
DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, PLONG width, PLONG height, PWORD planes, PWORD bpp, PLONG compr, PLONG size );
-INT STDCALL
+INT APIENTRY
DIB_GetDIBImageBytes (INT width, INT height, INT depth);
INT FASTCALL
DIB_GetDIBWidthBytes (INT width, INT depth);
#ifndef _WIN32K_ENG_H
#define _WIN32K_ENG_H
-BOOL STDCALL EngIntersectRect (PRECTL prcDst, PRECTL prcSrc1, PRECTL prcSrc2);
+BOOL APIENTRY EngIntersectRect (PRECTL prcDst, PRECTL prcSrc1, PRECTL prcSrc2);
VOID FASTCALL EngDeleteXlate (XLATEOBJ *XlateObj);
-BOOL STDCALL
+BOOL APIENTRY
IntEngMaskBlt(SURFOBJ *DestObj,
SURFOBJ *Mask,
CLIPOBJ *ClipRegion,
*/
HWND FASTCALL
IntGetThreadFocusWindow();
-HWND STDCALL IntGetCapture();
+HWND APIENTRY IntGetCapture();
HWND FASTCALL UserGetActiveWindow();
BOOL FASTCALL
/* From ddraw.c */
BOOL intEnableReactXDriver(HDC);
-NTSTATUS STDCALL DxDdStartupDxGraphics(ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS);
+NTSTATUS APIENTRY DxDdStartupDxGraphics(ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS);
extern DRVFN gpDxFuncs[];
-typedef BOOL (NTAPI* PGD_DDSETGAMMARAMP)(HANDLE, HDC, LPVOID);
-typedef BOOL (NTAPI* PGD_DDRELEASEDC)(HANDLE);
-typedef BOOL (NTAPI* PGD_DDRESTVISRGN)(HANDLE, HWND);
-typedef HANDLE (NTAPI* PGD_DDGETDXHANDLE)(HANDLE, HANDLE, BOOL);
-typedef HDC (NTAPI *PGD_DDGETDC)(HANDLE, PALETTEENTRY *);
-typedef DWORD (NTAPI *PGD_DXDDREENABLEDIRECTDRAWOBJECT)(HANDLE, BOOL*);
-typedef DWORD (NTAPI *PGD_DXDDGETDRIVERINFO)(HANDLE, PDD_GETDRIVERINFODATA);
-typedef DWORD (NTAPI *PGD_DXDDSETEXCLUSIVEMODE)(HANDLE, PDD_SETEXCLUSIVEMODEDATA);
-typedef NTSTATUS (NTAPI *PGD_DXDDSTARTUPDXGRAPHICS) (ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS);
-typedef NTSTATUS (NTAPI *PGD_DXDDCLEANUPDXGRAPHICS) (VOID);
-typedef HANDLE (NTAPI *PGD_DDCREATEDIRECTDRAWOBJECT) (HDC hdc);
-typedef DWORD (NTAPI *PGD_DDGETDRIVERSTATE)(PDD_GETDRIVERSTATEDATA);
-typedef DWORD (NTAPI *PGD_DDCOLORCONTROL)(HANDLE hSurface,PDD_COLORCONTROLDATA puColorControlData);
-typedef HANDLE (NTAPI *PGD_DXDDCREATESURFACEOBJECT)(HANDLE, HANDLE, PDD_SURFACE_LOCAL, PDD_SURFACE_MORE, PDD_SURFACE_GLOBAL, BOOL);
-typedef BOOL (NTAPI *PGD_DXDDDELETEDIRECTDRAWOBJECT)(HANDLE);
-typedef BOOL (NTAPI *PGD_DXDDDELETESURFACEOBJECT)(HANDLE);
-typedef DWORD (NTAPI *PGD_DXDDFLIPTOGDISURFACE)(HANDLE, PDD_FLIPTOGDISURFACEDATA);
-typedef DWORD (NTAPI *PGD_DXDDGETAVAILDRIVERMEMORY)(HANDLE , PDD_GETAVAILDRIVERMEMORYDATA);
-typedef BOOL (NTAPI *PGD_DXDDQUERYDIRECTDRAWOBJECT)(HANDLE, DD_HALINFO*, DWORD*, LPD3DNTHAL_CALLBACKS, LPD3DNTHAL_GLOBALDRIVERDATA,
+typedef BOOL (APIENTRY* PGD_DDSETGAMMARAMP)(HANDLE, HDC, LPVOID);
+typedef BOOL (APIENTRY* PGD_DDRELEASEDC)(HANDLE);
+typedef BOOL (APIENTRY* PGD_DDRESTVISRGN)(HANDLE, HWND);
+typedef HANDLE (APIENTRY* PGD_DDGETDXHANDLE)(HANDLE, HANDLE, BOOL);
+typedef HDC (APIENTRY *PGD_DDGETDC)(HANDLE, PALETTEENTRY *);
+typedef DWORD (APIENTRY *PGD_DXDDREENABLEDIRECTDRAWOBJECT)(HANDLE, BOOL*);
+typedef DWORD (APIENTRY *PGD_DXDDGETDRIVERINFO)(HANDLE, PDD_GETDRIVERINFODATA);
+typedef DWORD (APIENTRY *PGD_DXDDSETEXCLUSIVEMODE)(HANDLE, PDD_SETEXCLUSIVEMODEDATA);
+typedef NTSTATUS (APIENTRY *PGD_DXDDSTARTUPDXGRAPHICS) (ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS);
+typedef NTSTATUS (APIENTRY *PGD_DXDDCLEANUPDXGRAPHICS) (VOID);
+typedef HANDLE (APIENTRY *PGD_DDCREATEDIRECTDRAWOBJECT) (HDC hdc);
+typedef DWORD (APIENTRY *PGD_DDGETDRIVERSTATE)(PDD_GETDRIVERSTATEDATA);
+typedef DWORD (APIENTRY *PGD_DDCOLORCONTROL)(HANDLE hSurface,PDD_COLORCONTROLDATA puColorControlData);
+typedef HANDLE (APIENTRY *PGD_DXDDCREATESURFACEOBJECT)(HANDLE, HANDLE, PDD_SURFACE_LOCAL, PDD_SURFACE_MORE, PDD_SURFACE_GLOBAL, BOOL);
+typedef BOOL (APIENTRY *PGD_DXDDDELETEDIRECTDRAWOBJECT)(HANDLE);
+typedef BOOL (APIENTRY *PGD_DXDDDELETESURFACEOBJECT)(HANDLE);
+typedef DWORD (APIENTRY *PGD_DXDDFLIPTOGDISURFACE)(HANDLE, PDD_FLIPTOGDISURFACEDATA);
+typedef DWORD (APIENTRY *PGD_DXDDGETAVAILDRIVERMEMORY)(HANDLE , PDD_GETAVAILDRIVERMEMORYDATA);
+typedef BOOL (APIENTRY *PGD_DXDDQUERYDIRECTDRAWOBJECT)(HANDLE, DD_HALINFO*, DWORD*, LPD3DNTHAL_CALLBACKS, LPD3DNTHAL_GLOBALDRIVERDATA,
PDD_D3DBUFCALLBACKS, LPDDSURFACEDESC, DWORD *, VIDEOMEMORY *, DWORD *, DWORD *);
/* From d3d.c */
-typedef DWORD (NTAPI *PGD_DXDDDESTROYD3DBUFFER)(HANDLE);
-typedef DWORD (NTAPI *PGD_DDCANCREATED3DBUFFER)(HANDLE, PDD_CANCREATESURFACEDATA);
-typedef DWORD (NTAPI *PGD_DXDDUNLOCKD3D)(HANDLE, PDD_UNLOCKDATA);
-typedef DWORD (NTAPI *PGD_DXDDLOCKD3D)(HANDLE, PDD_LOCKDATA);
-typedef DWORD (NTAPI *PGD_D3DVALIDATETEXTURESTAGESTATE)(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA);
-typedef DWORD (NTAPI *PGD_D3DDRAWPRIMITIVES2)(HANDLE, HANDLE, LPD3DNTHAL_DRAWPRIMITIVES2DATA, FLATPTR *, DWORD *, FLATPTR *, DWORD *);
-typedef DWORD (NTAPI *PGD_DDCREATED3DBUFFER)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
-typedef BOOL (NTAPI *PGD_D3DCONTEXTCREATE)(HANDLE, HANDLE, HANDLE, LPD3DNTHAL_CONTEXTCREATEDATA);
-typedef DWORD (NTAPI *PGD_D3DCONTEXTDESTROY)(LPD3DNTHAL_CONTEXTDESTROYDATA);
-typedef DWORD (NTAPI *PGD_D3DCONTEXTDESTROYALL)(LPD3DNTHAL_CONTEXTDESTROYALLDATA);
+typedef DWORD (APIENTRY *PGD_DXDDDESTROYD3DBUFFER)(HANDLE);
+typedef DWORD (APIENTRY *PGD_DDCANCREATED3DBUFFER)(HANDLE, PDD_CANCREATESURFACEDATA);
+typedef DWORD (APIENTRY *PGD_DXDDUNLOCKD3D)(HANDLE, PDD_UNLOCKDATA);
+typedef DWORD (APIENTRY *PGD_DXDDLOCKD3D)(HANDLE, PDD_LOCKDATA);
+typedef DWORD (APIENTRY *PGD_D3DVALIDATETEXTURESTAGESTATE)(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA);
+typedef DWORD (APIENTRY *PGD_D3DDRAWPRIMITIVES2)(HANDLE, HANDLE, LPD3DNTHAL_DRAWPRIMITIVES2DATA, FLATPTR *, DWORD *, FLATPTR *, DWORD *);
+typedef DWORD (APIENTRY *PGD_DDCREATED3DBUFFER)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
+typedef BOOL (APIENTRY *PGD_D3DCONTEXTCREATE)(HANDLE, HANDLE, HANDLE, LPD3DNTHAL_CONTEXTCREATEDATA);
+typedef DWORD (APIENTRY *PGD_D3DCONTEXTDESTROY)(LPD3DNTHAL_CONTEXTDESTROYDATA);
+typedef DWORD (APIENTRY *PGD_D3DCONTEXTDESTROYALL)(LPD3DNTHAL_CONTEXTDESTROYALLDATA);
/* From dvp.c */
-typedef DWORD (NTAPI* PGD_DVPCANCREATEVIDEOPORT)(HANDLE, PDD_CANCREATEVPORTDATA);
-typedef DWORD (NTAPI* PGD_DVPCOLORCONTROL)(HANDLE, PDD_VPORTCOLORDATA);
-typedef HANDLE (NTAPI* PGD_DVPCREATEVIDEOPORT)(HANDLE, PDD_CREATEVPORTDATA);
-typedef DWORD (NTAPI* PGD_DVPDESTROYVIDEOPORT)(HANDLE, PDD_DESTROYVPORTDATA);
-typedef DWORD (NTAPI* PGD_DVPFLIPVIDEOPORT)(HANDLE,HANDLE,HANDLE,PDD_FLIPVPORTDATA);
-typedef DWORD (NTAPI* PGD_DVPGETVIDEOPORTBANDWITH)(HANDLE, PDD_GETVPORTBANDWIDTHDATA);
-typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTFLIPSTATUS)(HANDLE, PDD_GETVPORTFLIPSTATUSDATA);
-typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTINPUTFORMATS)(HANDLE, PDD_GETVPORTINPUTFORMATDATA);
-typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTLINE)(HANDLE, PDD_GETVPORTLINEDATA);
-typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS)(HANDLE, PDD_GETVPORTOUTPUTFORMATDATA);
-typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTCONNECTINFO)(HANDLE, PDD_GETVPORTCONNECTDATA);
-typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOSIGNALSTATUS)(HANDLE, PDD_GETVPORTSIGNALDATA);
-typedef DWORD (NTAPI *PGD_DXDVPUPDATEVIDEOPORT)(HANDLE, HANDLE*, HANDLE*, PDD_UPDATEVPORTDATA);
-typedef DWORD (NTAPI *PGD_DXDVPWAITFORVIDEOPORTSYNC)(HANDLE, PDD_WAITFORVPORTSYNCDATA);
-typedef DWORD (NTAPI *PGD_DXDVPACQUIRENOTIFICATION)(HANDLE, HANDLE*, LPDDVIDEOPORTNOTIFY);
-typedef DWORD (NTAPI *PGD_DXDVPRELEASENOTIFICATION)(HANDLE, HANDLE);
-typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTFIELD)(HANDLE, PDD_GETVPORTFIELDDATA);
+typedef DWORD (APIENTRY* PGD_DVPCANCREATEVIDEOPORT)(HANDLE, PDD_CANCREATEVPORTDATA);
+typedef DWORD (APIENTRY* PGD_DVPCOLORCONTROL)(HANDLE, PDD_VPORTCOLORDATA);
+typedef HANDLE (APIENTRY* PGD_DVPCREATEVIDEOPORT)(HANDLE, PDD_CREATEVPORTDATA);
+typedef DWORD (APIENTRY* PGD_DVPDESTROYVIDEOPORT)(HANDLE, PDD_DESTROYVPORTDATA);
+typedef DWORD (APIENTRY* PGD_DVPFLIPVIDEOPORT)(HANDLE,HANDLE,HANDLE,PDD_FLIPVPORTDATA);
+typedef DWORD (APIENTRY* PGD_DVPGETVIDEOPORTBANDWITH)(HANDLE, PDD_GETVPORTBANDWIDTHDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTFLIPSTATUS)(HANDLE, PDD_GETVPORTFLIPSTATUSDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTINPUTFORMATS)(HANDLE, PDD_GETVPORTINPUTFORMATDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTLINE)(HANDLE, PDD_GETVPORTLINEDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS)(HANDLE, PDD_GETVPORTOUTPUTFORMATDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTCONNECTINFO)(HANDLE, PDD_GETVPORTCONNECTDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOSIGNALSTATUS)(HANDLE, PDD_GETVPORTSIGNALDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPUPDATEVIDEOPORT)(HANDLE, HANDLE*, HANDLE*, PDD_UPDATEVPORTDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPWAITFORVIDEOPORTSYNC)(HANDLE, PDD_WAITFORVPORTSYNCDATA);
+typedef DWORD (APIENTRY *PGD_DXDVPACQUIRENOTIFICATION)(HANDLE, HANDLE*, LPDDVIDEOPORTNOTIFY);
+typedef DWORD (APIENTRY *PGD_DXDVPRELEASENOTIFICATION)(HANDLE, HANDLE);
+typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTFIELD)(HANDLE, PDD_GETVPORTFIELDDATA);
/* From mocomp.c */
-typedef DWORD (NTAPI *PGD_DDBEGINMOCOMPFRAME)(HANDLE, PDD_BEGINMOCOMPFRAMEDATA);
-typedef HANDLE (NTAPI *PGD_DXDDCREATEMOCOMP)(HANDLE, PDD_CREATEMOCOMPDATA );
-typedef DWORD (NTAPI *PGD_DXDDDESTROYMOCOMP)(HANDLE, PDD_DESTROYMOCOMPDATA);
-typedef DWORD (NTAPI *PGD_DXDDENDMOCOMPFRAME)(HANDLE, PDD_ENDMOCOMPFRAMEDATA);
-typedef DWORD (NTAPI *PGD_DXDDGETINTERNALMOCOMPINFO)(HANDLE, PDD_GETINTERNALMOCOMPDATA);
-typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPBUFFINFO)(HANDLE, PDD_GETMOCOMPCOMPBUFFDATA);
-typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPGUIDS)(HANDLE, PDD_GETMOCOMPGUIDSDATA);
-typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPFORMATS)(HANDLE, PDD_GETMOCOMPFORMATSDATA);
-typedef DWORD (NTAPI *PGD_DXDDQUERYMOCOMPSTATUS)(HANDLE, PDD_QUERYMOCOMPSTATUSDATA);
-typedef DWORD (NTAPI *PGD_DXDDRENDERMOCOMP)(HANDLE, PDD_RENDERMOCOMPDATA);
+typedef DWORD (APIENTRY *PGD_DDBEGINMOCOMPFRAME)(HANDLE, PDD_BEGINMOCOMPFRAMEDATA);
+typedef HANDLE (APIENTRY *PGD_DXDDCREATEMOCOMP)(HANDLE, PDD_CREATEMOCOMPDATA );
+typedef DWORD (APIENTRY *PGD_DXDDDESTROYMOCOMP)(HANDLE, PDD_DESTROYMOCOMPDATA);
+typedef DWORD (APIENTRY *PGD_DXDDENDMOCOMPFRAME)(HANDLE, PDD_ENDMOCOMPFRAMEDATA);
+typedef DWORD (APIENTRY *PGD_DXDDGETINTERNALMOCOMPINFO)(HANDLE, PDD_GETINTERNALMOCOMPDATA);
+typedef DWORD (APIENTRY *PGD_DXDDGETMOCOMPBUFFINFO)(HANDLE, PDD_GETMOCOMPCOMPBUFFDATA);
+typedef DWORD (APIENTRY *PGD_DXDDGETMOCOMPGUIDS)(HANDLE, PDD_GETMOCOMPGUIDSDATA);
+typedef DWORD (APIENTRY *PGD_DXDDGETMOCOMPFORMATS)(HANDLE, PDD_GETMOCOMPFORMATSDATA);
+typedef DWORD (APIENTRY *PGD_DXDDQUERYMOCOMPSTATUS)(HANDLE, PDD_QUERYMOCOMPSTATUSDATA);
+typedef DWORD (APIENTRY *PGD_DXDDRENDERMOCOMP)(HANDLE, PDD_RENDERMOCOMPDATA);
/* From dd.c */
-typedef DWORD (NTAPI *PGD_DDCREATESURFACE)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
-typedef DWORD (NTAPI *PGD_DXDDWAITFORVERTICALBLANK)(HANDLE, PDD_WAITFORVERTICALBLANKDATA);
-typedef DWORD (NTAPI *PGD_DDCANCREATESURFACE)(HANDLE hDirectDrawLocal, PDD_CANCREATESURFACEDATA puCanCreateSurfaceData);
-typedef DWORD (NTAPI *PGD_DXDDGETSCANLINE)(HANDLE, PDD_GETSCANLINEDATA);
-typedef DWORD (NTAPI *PGD_DXDDCREATESURFACEEX)(HANDLE,HANDLE,DWORD);
+typedef DWORD (APIENTRY *PGD_DDCREATESURFACE)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
+typedef DWORD (APIENTRY *PGD_DXDDWAITFORVERTICALBLANK)(HANDLE, PDD_WAITFORVERTICALBLANKDATA);
+typedef DWORD (APIENTRY *PGD_DDCANCREATESURFACE)(HANDLE hDirectDrawLocal, PDD_CANCREATESURFACEDATA puCanCreateSurfaceData);
+typedef DWORD (APIENTRY *PGD_DXDDGETSCANLINE)(HANDLE, PDD_GETSCANLINEDATA);
+typedef DWORD (APIENTRY *PGD_DXDDCREATESURFACEEX)(HANDLE,HANDLE,DWORD);
/* From ddsurf.c */
-typedef DWORD (NTAPI *PGD_DDALPHABLT)(HANDLE, HANDLE, PDD_BLTDATA);
-typedef BOOL (NTAPI *PGD_DDATTACHSURFACE)(HANDLE, HANDLE);
-typedef DWORD (NTAPI *PGD_DXDDUNATTACHSURFACE)(HANDLE, HANDLE);
-typedef DWORD (NTAPI *PGD_DXDDDESTROYSURFACE)(HANDLE, BOOL);
-typedef DWORD (NTAPI *PGD_DXDDFLIP)(HANDLE, HANDLE, HANDLE, HANDLE, PDD_FLIPDATA);
-typedef DWORD (NTAPI *PGD_DXDDLOCK)(HANDLE, PDD_LOCKDATA, HDC);
-typedef DWORD (NTAPI *PGD_DXDDUNLOCK)(HANDLE, PDD_UNLOCKDATA );
-typedef DWORD (NTAPI *PGD_DDBLT)(HANDLE, HANDLE, PDD_BLTDATA);
-typedef DWORD (NTAPI *PGD_DXDDSETCOLORKEY)(HANDLE, PDD_SETCOLORKEYDATA);
-typedef DWORD (NTAPI *PGD_DDADDATTACHEDSURFACE)(HANDLE, HANDLE,PDD_ADDATTACHEDSURFACEDATA);
-typedef DWORD (NTAPI *PGD_DXDDGETBLTSTATUS)(HANDLE, PDD_GETBLTSTATUSDATA);
-typedef DWORD (NTAPI *PGD_DXDDGETFLIPSTATUS)(HANDLE, PDD_GETFLIPSTATUSDATA);
-typedef DWORD (NTAPI *PGD_DXDDUPDATEOVERLAY)(HANDLE, HANDLE, PDD_UPDATEOVERLAYDATA);
-typedef DWORD (NTAPI *PGD_DXDDSETOVERLAYPOSITION)(HANDLE, HANDLE, PDD_SETOVERLAYPOSITIONDATA);
+typedef DWORD (APIENTRY *PGD_DDALPHABLT)(HANDLE, HANDLE, PDD_BLTDATA);
+typedef BOOL (APIENTRY *PGD_DDATTACHSURFACE)(HANDLE, HANDLE);
+typedef DWORD (APIENTRY *PGD_DXDDUNATTACHSURFACE)(HANDLE, HANDLE);
+typedef DWORD (APIENTRY *PGD_DXDDDESTROYSURFACE)(HANDLE, BOOL);
+typedef DWORD (APIENTRY *PGD_DXDDFLIP)(HANDLE, HANDLE, HANDLE, HANDLE, PDD_FLIPDATA);
+typedef DWORD (APIENTRY *PGD_DXDDLOCK)(HANDLE, PDD_LOCKDATA, HDC);
+typedef DWORD (APIENTRY *PGD_DXDDUNLOCK)(HANDLE, PDD_UNLOCKDATA );
+typedef DWORD (APIENTRY *PGD_DDBLT)(HANDLE, HANDLE, PDD_BLTDATA);
+typedef DWORD (APIENTRY *PGD_DXDDSETCOLORKEY)(HANDLE, PDD_SETCOLORKEYDATA);
+typedef DWORD (APIENTRY *PGD_DDADDATTACHEDSURFACE)(HANDLE, HANDLE,PDD_ADDATTACHEDSURFACEDATA);
+typedef DWORD (APIENTRY *PGD_DXDDGETBLTSTATUS)(HANDLE, PDD_GETBLTSTATUSDATA);
+typedef DWORD (APIENTRY *PGD_DXDDGETFLIPSTATUS)(HANDLE, PDD_GETFLIPSTATUSDATA);
+typedef DWORD (APIENTRY *PGD_DXDDUPDATEOVERLAY)(HANDLE, HANDLE, PDD_UPDATEOVERLAYDATA);
+typedef DWORD (APIENTRY *PGD_DXDDSETOVERLAYPOSITION)(HANDLE, HANDLE, PDD_SETOVERLAYPOSITIONDATA);
/* From eng.c */
-typedef FLATPTR (NTAPI *PGD_HEAPVIDMEMALLOCALIGNED)(LPVIDMEM, DWORD, DWORD, LPSURFACEALIGNMENT, LPLONG);
-typedef VOID (NTAPI *PGD_VIDMEMFREE)(LPVMEMHEAP, FLATPTR);
-typedef PVOID (NTAPI *PGD_ENGALLOCPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, SIZE_T, ULONG) ;
-typedef VOID (NTAPI *PGD_ENGFREEPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, PVOID);
-typedef PDD_SURFACE_LOCAL (NTAPI *PGD_ENGLOCKDIRECTDRAWSURFACE)(HANDLE);
-typedef BOOL (NTAPI *PGD_ENGUNLOCKDIRECTDRAWSURFACE)(PDD_SURFACE_LOCAL);
+typedef FLATPTR (APIENTRY *PGD_HEAPVIDMEMALLOCALIGNED)(LPVIDMEM, DWORD, DWORD, LPSURFACEALIGNMENT, LPLONG);
+typedef VOID (APIENTRY *PGD_VIDMEMFREE)(LPVMEMHEAP, FLATPTR);
+typedef PVOID (APIENTRY *PGD_ENGALLOCPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, SIZE_T, ULONG) ;
+typedef VOID (APIENTRY *PGD_ENGFREEPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, PVOID);
+typedef PDD_SURFACE_LOCAL (APIENTRY *PGD_ENGLOCKDIRECTDRAWSURFACE)(HANDLE);
+typedef BOOL (APIENTRY *PGD_ENGUNLOCKDIRECTDRAWSURFACE)(PDD_SURFACE_LOCAL);
/* Gammaramp internal prototype */
BOOL FASTCALL IntGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp);
IntEngCleanupDriverObjs(struct _EPROCESS *Process,
PW32PROCESS Win32Process);
-BOOL STDCALL
+BOOL APIENTRY
IntEngLineTo(SURFOBJ *Surface,
CLIPOBJ *Clip,
BRUSHOBJ *Brush,
RECTL *RectBounds,
MIX mix);
-BOOL STDCALL
+BOOL APIENTRY
IntEngBitBltEx(SURFOBJ *DestObj,
SURFOBJ *SourceObj,
SURFOBJ *Mask,
(ColorTranslation), (DestRect), (SourcePoint), \
(MaskOrigin), (Brush), (BrushOrigin), (Rop4), TRUE)
-BOOL STDCALL
+BOOL APIENTRY
IntEngStretchBlt(SURFOBJ *DestObj,
SURFOBJ *SourceObj,
SURFOBJ *Mask,
POINTL *BrushOrigin,
ULONG Mode);
-BOOL STDCALL
+BOOL APIENTRY
IntEngGradientFill(SURFOBJ *psoDest,
CLIPOBJ *pco,
XLATEOBJ *pxlo,
IntEngGetXlatePalette(XLATEOBJ *XlateObj,
ULONG Palette);
-BOOL STDCALL
+BOOL APIENTRY
IntEngPolyline(SURFOBJ *DestSurf,
CLIPOBJ *Clip,
BRUSHOBJ *Brush,
ULONG iTransColor,
ULONG Reserved);
-BOOL STDCALL
+BOOL APIENTRY
IntEngPaint(IN SURFOBJ *Surface,
IN CLIPOBJ *ClipRegion,
IN BRUSHOBJ *Brush,
IN POINTL *BrushOrigin,
IN MIX Mix);
-VOID STDCALL
+VOID APIENTRY
IntEngMovePointer(IN SURFOBJ *pso,
IN LONG x,
IN LONG y,
IN RECTL *prcl);
-BOOL STDCALL
+BOOL APIENTRY
IntEngAlphaBlend(IN SURFOBJ *Dest,
IN SURFOBJ *Source,
IN CLIPOBJ *ClipRegion,
VOID FASTCALL
IntGdiInitBrushInstance(GDIBRUSHINST *BrushInst, PGDIBRUSHOBJ BrushObj, XLATEOBJ *XlateObj);
-HBRUSH STDCALL
+HBRUSH APIENTRY
IntGdiCreateDIBBrush(
CONST BITMAPINFO *BitmapInfo,
UINT ColorSpec,
UINT BitmapInfoSize,
CONST VOID *PackedDIB);
-HBRUSH STDCALL
+HBRUSH APIENTRY
IntGdiCreateHatchBrush(
INT Style,
COLORREF Color);
-HBRUSH STDCALL
+HBRUSH APIENTRY
IntGdiCreatePatternBrush(
HBITMAP hBitmap);
-HBRUSH STDCALL
+HBRUSH APIENTRY
IntGdiCreateSolidBrush(
COLORREF Color);
-HBRUSH STDCALL
+HBRUSH APIENTRY
IntGdiCreateNullBrush(VOID);
BOOL FASTCALL
/* Pen functions */
-HPEN STDCALL
+HPEN APIENTRY
IntGdiExtCreatePen(DWORD, DWORD, IN ULONG, IN ULONG, IN ULONG_PTR, IN ULONG_PTR, DWORD, PULONG, IN ULONG, IN BOOL, IN OPTIONAL HBRUSH);
VOID FASTCALL
INT Width,
INT Height);
-HBITMAP STDCALL
+HBITMAP APIENTRY
IntGdiCreateBitmap(
INT Width,
INT Height,
UINT BitsPixel,
IN OPTIONAL LPBYTE pBits);
-HDC STDCALL IntGdiGetDCState(HDC hDC);
+HDC APIENTRY IntGdiGetDCState(HDC hDC);
-WORD STDCALL IntGdiSetHookFlags(HDC hDC, WORD Flags);
+WORD APIENTRY IntGdiSetHookFlags(HDC hDC, WORD Flags);
-VOID STDCALL IntGdiSetDCState ( HDC hDC, HDC hDCSave );
+VOID APIENTRY IntGdiSetDCState ( HDC hDC, HDC hDCSave );
-LONG STDCALL IntSetBitmapBits(PBITMAPOBJ bmp, DWORD Bytes, IN PBYTE Bits);
+LONG APIENTRY IntSetBitmapBits(PBITMAPOBJ bmp, DWORD Bytes, IN PBYTE Bits);
-LONG STDCALL IntGetBitmapBits(PBITMAPOBJ bmp, DWORD Bytes, OUT PBYTE Bits);
+LONG APIENTRY IntGetBitmapBits(PBITMAPOBJ bmp, DWORD Bytes, OUT PBYTE Bits);
-UINT STDCALL IntSetDIBColorTable(HDC hDC, UINT StartIndex, UINT Entries, CONST RGBQUAD *Colors);
+UINT APIENTRY IntSetDIBColorTable(HDC hDC, UINT StartIndex, UINT Entries, CONST RGBQUAD *Colors);
-UINT STDCALL IntGetDIBColorTable(HDC hDC, UINT StartIndex, UINT Entries, RGBQUAD *Colors);
+UINT APIENTRY IntGetDIBColorTable(HDC hDC, UINT StartIndex, UINT Entries, RGBQUAD *Colors);
-UINT STDCALL
+UINT APIENTRY
IntAnimatePalette(HPALETTE hPal, UINT StartIndex,
UINT NumEntries, CONST PPALETTEENTRY PaletteColors);
-UINT STDCALL
+UINT APIENTRY
IntGetPaletteEntries(HPALETTE hpal,
UINT StartIndex,
UINT Entries,
LPPALETTEENTRY pe);
-UINT STDCALL
+UINT APIENTRY
IntSetPaletteEntries(HPALETTE hpal,
UINT Start,
UINT Entries,
CONST LPPALETTEENTRY pe);
-UINT STDCALL
+UINT APIENTRY
IntGetSystemPaletteEntries(HDC hDC,
UINT StartIndex,
UINT Entries,
LPPALETTEENTRY pe);
-UINT STDCALL
+UINT APIENTRY
IntGetDIBColorTable(HDC hDC, UINT StartIndex, UINT Entries, RGBQUAD *Colors);
-UINT STDCALL
+UINT APIENTRY
IntSetDIBColorTable(HDC hDC, UINT StartIndex, UINT Entries, CONST RGBQUAD *Colors);
#endif /* _WIN32K_INTGDI_H */
BOOL FASTCALL
IntSetMenuItemRect(PMENU_OBJECT MenuObject, UINT Item, BOOL fByPos, RECT *rcRect);
-DWORD STDCALL UserInsertMenuItem(HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmii);
+DWORD APIENTRY UserInsertMenuItem(HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmii);
BOOL FASTCALL
IntCleanupMenus(struct _EPROCESS *Process, PW32PROCESS Win32Process);
SHORT FASTCALL IntGdiGetLanguageID();
ULONG FASTCALL IntSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni);
-DWORD STDCALL IntGetQueueStatus(BOOL ClearChanges);
+DWORD APIENTRY IntGetQueueStatus(BOOL ClearChanges);
VOID FASTCALL IntUserManualGuiCheck(LONG Check);
-PVOID NTAPI HackSecureVirtualMemory(IN PVOID,IN SIZE_T,IN ULONG,OUT PVOID *);
-VOID NTAPI HackUnsecureVirtualMemory(IN PVOID);
+PVOID APIENTRY HackSecureVirtualMemory(IN PVOID,IN SIZE_T,IN ULONG,OUT PVOID *);
+VOID APIENTRY HackUnsecureVirtualMemory(IN PVOID);
#endif /* __WIN32K_MISC_H */
MSG* Msg, BOOLEAN FreeLParam, DWORD MessageBits);
VOID FASTCALL
MsqPostQuitMessage(PUSER_MESSAGE_QUEUE MessageQueue, ULONG ExitCode);
-BOOLEAN STDCALL
+BOOLEAN APIENTRY
co_MsqFindMessage(IN PUSER_MESSAGE_QUEUE MessageQueue,
IN BOOLEAN Hardware,
IN BOOLEAN Remove,
__inline BOOL MsqIsSignaled( PUSER_MESSAGE_QUEUE queue );
__inline VOID MsqSetQueueBits( PUSER_MESSAGE_QUEUE queue, WORD bits );
__inline VOID MsqClearQueueBits( PUSER_MESSAGE_QUEUE queue, WORD bits );
-BOOL STDCALL IntInitMessagePumpHook();
-BOOL STDCALL IntUninitMessagePumpHook();
+BOOL APIENTRY IntInitMessagePumpHook();
+BOOL APIENTRY IntUninitMessagePumpHook();
#define MAKE_LONG(x, y) ((((y) & 0xFFFF) << 16) | ((x) & 0xFFFF))
PHOOKTABLE FASTCALL MsqGetHooks(PUSER_MESSAGE_QUEUE Queue);
LPARAM FASTCALL MsqSetMessageExtraInfo(LPARAM lParam);
LPARAM FASTCALL MsqGetMessageExtraInfo(VOID);
-VOID STDCALL MsqRemoveWindowMessagesFromQueue(PVOID pWindow); /* F*(&$ headers, will be gone in the rewrite! */
+VOID APIENTRY MsqRemoveWindowMessagesFromQueue(PVOID pWindow); /* F*(&$ headers, will be gone in the rewrite! */
#define IntLockHardwareMessageQueue(MsgQueue) \
KeWaitForMutexObject(&(MsgQueue)->HardwareLock, UserRequest, KernelMode, FALSE, NULL)
#ifndef _WIN32K_PAINT_H
#define _WIN32K_PAINT_H
-BOOL STDCALL FillSolid (SURFOBJ* Surface, RECTL* Dimensions, ULONG iColor);
-BOOL STDCALL FillPolygon ( DC* dc, BITMAPOBJ* SurfObj, BRUSHOBJ* BrushObj, MIX RopMode, CONST PPOINT Points, INT Count, RECTL BoundRect );
+BOOL APIENTRY FillSolid (SURFOBJ* Surface, RECTL* Dimensions, ULONG iColor);
+BOOL APIENTRY FillPolygon ( DC* dc, BITMAPOBJ* SurfObj, BRUSHOBJ* BrushObj, MIX RopMode, CONST PPOINT Points, INT Count, RECTL BoundRect );
#endif /* _WIN32K_PAINT_H */
HPALETTE FASTCALL PALETTE_Init (VOID);
VOID FASTCALL PALETTE_ValidateFlags (PALETTEENTRY* lpPalE, INT size);
#ifndef NO_MAPPING
-INT STDCALL PALETTE_SetMapping(PALOBJ* palPtr, UINT uStart, UINT uNum, BOOL mapOnly);
+INT APIENTRY PALETTE_SetMapping(PALOBJ* palPtr, UINT uStart, UINT uNum, BOOL mapOnly);
#endif
INT FASTCALL PALETTE_ToPhysical (PDC dc, COLORREF color);
PGDIBRUSHOBJ FASTCALL PENOBJ_LockPen(HGDIOBJ);
-INT STDCALL PEN_GetObject(PGDIBRUSHOBJ hPen, INT Count, PLOGPEN Buffer);
+INT APIENTRY PEN_GetObject(PGDIBRUSHOBJ hPen, INT Count, PLOGPEN Buffer);
#endif
#ifndef _WIN32K_RECT_H
#define _WIN32K_RECT_H
-BOOL STDCALL
+BOOL APIENTRY
NtGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2);
-BOOL STDCALL
+BOOL APIENTRY
NtGdiSetRect(PRECT Rect, int left, int top, int right, int bottom);
-BOOL STDCALL
+BOOL APIENTRY
NtGdiSetEmptyRect(PRECT Rect);
-BOOL STDCALL
+BOOL APIENTRY
NtGdiIsEmptyRect(const RECT* Rect);
-BOOL STDCALL
+BOOL APIENTRY
NtGdiIntersectRect(PRECT Dest, const RECT* Src1, const RECT* Src2);
-BOOL STDCALL
+BOOL APIENTRY
NtGdiOffsetRect(LPRECT Rect, int x, int y);
#endif /* _WIN32K_RECT_H */
VOID FASTCALL IntGdiReleaseRaoRgn(PDC);
VOID FASTCALL IntGdiReleaseVisRgn(PDC);
-INT STDCALL IntGdiGetRgnBox(HRGN, LPRECT);
+INT APIENTRY IntGdiGetRgnBox(HRGN, LPRECT);
BOOL FASTCALL IntGdiPaintRgn(PDC, HRGN );
HRGN FASTCALL IntCreatePolyPolygonRgn(PPOINT, PULONG, INT, INT);
/* INCLUDES ******************************************************************/
#ifndef __WIN32K_H
#define __WIN32K_H
-#define INTERNAL_CALL NTAPI
+#define INTERNAL_CALL APIENTRY
/* Internal Win32k Headers */
#include <include/accelerator.h>
CleanupWindowStationImpl(VOID);
NTSTATUS
-STDCALL
+APIENTRY
IntWinStaObjectOpen(PWIN32_OPENMETHOD_PARAMETERS Parameters);
-VOID STDCALL
+VOID APIENTRY
IntWinStaObjectDelete(PWIN32_DELETEMETHOD_PARAMETERS Parameters);
NTSTATUS
-STDCALL
+APIENTRY
IntWinStaObjectParse(PWIN32_PARSEMETHOD_PARAMETERS Parameters);
NTSTATUS FASTCALL
* Blatantly stolen from ldr/utils.c in ntdll. I can't link ntdll from
* here, though.
*/
-NTSTATUS STDCALL
+NTSTATUS APIENTRY
LdrGetProcedureAddress (IN PVOID BaseAddress,
IN PANSI_STRING Name,
IN ULONG Ordinal,
return STATUS_PROCEDURE_NOT_FOUND;
}
-PVOID STDCALL
+PVOID APIENTRY
EngFindImageProcAddress(IN HANDLE Module,
IN LPSTR ProcName)
{
* @implemented
*/
HANDLE
-STDCALL
+APIENTRY
EngLoadImage (LPWSTR DriverName)
{
HANDLE hImageHandle = NULL;
* @unimplemented
*/
HANDLE
-STDCALL
+APIENTRY
EngLoadModule(LPWSTR ModuleName)
{
SYSTEM_GDI_DRIVER_INFORMATION GdiDriverInfo;
}
VOID
-STDCALL
+APIENTRY
EngUnloadImage ( IN HANDLE hModule )
{
NTSTATUS Status;
extern ULONG Win32kNumberOfSysCalls;
NTSTATUS
-STDCALL
+APIENTRY
Win32kProcessCallback(struct _EPROCESS *Process,
BOOLEAN Create)
{
NTSTATUS
-STDCALL
+APIENTRY
Win32kThreadCallback(struct _ETHREAD *Thread,
PSW32THREADCALLOUTTYPE Type)
{
/*
* This definition doesn't work
*/
-NTSTATUS STDCALL
+NTSTATUS APIENTRY
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
}
typedef LONG VP_STATUS;
-typedef VP_STATUS (STDCALL *PMP_DRIVERENTRY)(PVOID, PVOID);
+typedef VP_STATUS (APIENTRY *PMP_DRIVERENTRY)(PVOID, PVOID);
PFILE_OBJECT DRIVER_FindMPDriver(ULONG DisplayNumber)
{
}
VOID
-NTAPI
+APIENTRY
W32kRaiseStatus(NTSTATUS Status)
{
EXCEPTION_RECORD ExceptionRecord;
*
* @implemented
*/
-INT STDCALL EngMulDiv(
+INT APIENTRY EngMulDiv(
INT nMultiplicand,
INT nMultiplier,
INT nDivisor)
#include <debug.h>
-static NTSTATUS NTAPI
+static NTSTATUS APIENTRY
IntUserHeapCommitRoutine(IN PVOID Base,
IN OUT PVOID *CommitAddress,
IN OUT PSIZE_T CommitSize)
*--*/
DWORD
-STDCALL
+APIENTRY
NtGdiDdCanCreateD3DBuffer(HANDLE hDirectDraw,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData)
{
* the correct struct is LPD3DHAL_CONTEXTCREATEDATA.
*--*/
BOOL
-STDCALL
+APIENTRY
NtGdiD3dContextCreate(HANDLE hDirectDrawLocal,
HANDLE hSurfColor,
HANDLE hSurfZ,
*
*--*/
DWORD
-STDCALL
+APIENTRY
NtGdiD3dContextDestroy(LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData)
{
PGD_D3DCONTEXTDESTROY pfnD3dContextDestroy = (PGD_D3DCONTEXTDESTROY)gpDxFuncs[DXG_INDEX_DxD3dContextDestroy].pfn;
* any parameters. Last time MSDN checked: 19/10-2007
*--*/
DWORD
-STDCALL
+APIENTRY
NtGdiD3dContextDestroyAll(LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad)
{
PGD_D3DCONTEXTDESTROYALL pfnD3dContextDestroyAll = (PGD_D3DCONTEXTDESTROYALL)gpDxFuncs[DXG_INDEX_DxD3dContextDestroyAll].pfn;
*
*--*/
DWORD
-STDCALL
+APIENTRY
NtGdiDdCreateD3DBuffer(HANDLE hDirectDraw,
HANDLE *hSurface,
DDSURFACEDESC *puSurfaceDescription,
/* NtGdiDdDestroyD3DBuffer */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdDestroyD3DBuffer(HANDLE hSurface)
{
PGD_DXDDDESTROYD3DBUFFER pfnDdDestroyD3DBuffer = (PGD_DXDDDESTROYD3DBUFFER)gpDxFuncs[DXG_INDEX_DxDdDestroyD3DBuffer].pfn;
/* NtGdiD3dDrawPrimitives2 */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiD3dDrawPrimitives2(HANDLE hCmdBuf,
HANDLE hVBuf,
LPD3DNTHAL_DRAWPRIMITIVES2DATA pded,
/* NtGdiD3dValidateTextureStageState */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdLockD3D(HANDLE hSurface,
PDD_LOCKDATA puLockData)
{
/* NtGdiD3dValidateTextureStageState */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiD3dValidateTextureStageState(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA pData)
{
PGD_D3DVALIDATETEXTURESTAGESTATE pfnD3dValidateTextureStageState = (PGD_D3DVALIDATETEXTURESTAGESTATE)gpDxFuncs[DXG_INDEX_DxD3dValidateTextureStageState].pfn;
/* NtGdiDdUnlockD3D */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdUnlockD3D(HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData)
{
/* NtGdiDdCreateSurface */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdCreateSurface(HANDLE hDirectDrawLocal,
HANDLE *hSurface,
DDSURFACEDESC *puSurfaceDescription,
/* NtGdiDdWaitForVerticalBlank */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdWaitForVerticalBlank(HANDLE hDirectDraw,
PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
{
/* NtGdiDdCanCreateSurface */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData)
{
/* NtGdiDdGetScanLine */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetScanLine(HANDLE hDirectDrawLocal,
PDD_GETSCANLINEDATA puGetScanLineData)
{
/* NtGdiDdCreateSurfaceEx */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdCreateSurfaceEx(HANDLE hDirectDraw,
HANDLE hSurface,
DWORD dwSurfaceHandle)
/* DirectX graphic/video driver loading and cleanup start here */
/************************************************************************/
NTSTATUS
-STDCALL
+APIENTRY
DxDdStartupDxGraphics( ULONG ulc1,
PDRVENABLEDATA DxEngDrvOld,
ULONG ulc2,
/* NtGdiDdCreateDirectDrawObject */
/************************************************************************/
HANDLE
-STDCALL
+APIENTRY
NtGdiDdCreateDirectDrawObject(HDC hdc)
{
PGD_DDCREATEDIRECTDRAWOBJECT pfnDdCreateDirectDrawObject;
*
*--*/
DWORD
-STDCALL
+APIENTRY
NtGdiDxgGenericThunk(ULONG_PTR ulIndex,
ULONG_PTR ulHandle,
SIZE_T *pdwSizeOfPtr1,
/* NtGdiDdGetDriverState */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetDriverState(PDD_GETDRIVERSTATEDATA pdata)
{
PGD_DDGETDRIVERSTATE pfnDdGetDriverState = (PGD_DDGETDRIVERSTATE)gpDxFuncs[DXG_INDEX_DxDdGetDriverState].pfn;
/* NtGdiDdColorControl */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdColorControl(HANDLE hSurface,
PDD_COLORCONTROLDATA puColorControlData)
{
/* NtGdiDdCreateSurfaceObject */
/************************************************************************/
HANDLE
-STDCALL
+APIENTRY
NtGdiDdCreateSurfaceObject(HANDLE hDirectDrawLocal,
HANDLE hSurface,
PDD_SURFACE_LOCAL puSurfaceLocal,
/* NtGdiDdDeleteDirectDrawObject */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdDeleteDirectDrawObject(HANDLE hDirectDrawLocal)
{
PGD_DXDDDELETEDIRECTDRAWOBJECT pfnDdDeleteDirectDrawObject = (PGD_DXDDDELETEDIRECTDRAWOBJECT)gpDxFuncs[DXG_INDEX_DxDdDeleteDirectDrawObject].pfn;
/* NtGdiDdDeleteSurfaceObject */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdDeleteSurfaceObject(HANDLE hSurface)
{
PGD_DXDDDELETESURFACEOBJECT pfnDdDeleteSurfaceObject = (PGD_DXDDDELETESURFACEOBJECT)gpDxFuncs[DXG_INDEX_DxDdDeleteSurfaceObject].pfn;
/* NtGdiDdQueryDirectDrawObject */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdQueryDirectDrawObject(HANDLE hDirectDrawLocal,
DD_HALINFO *pHalInfo,
DWORD *pCallBackFlags,
/* NtGdiDdReenableDirectDrawObject */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdReenableDirectDrawObject(HANDLE hDirectDrawLocal,
BOOL *pubNewMode)
{
/* NtGdiDdGetDriverInfo */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetDriverInfo(HANDLE hDirectDrawLocal,
PDD_GETDRIVERINFODATA puGetDriverInfoData)
/* NtGdiDdGetAvailDriverMemory */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetAvailDriverMemory(HANDLE hDirectDrawLocal,
PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData)
{
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdSetExclusiveMode(HANDLE hDirectDraw,
PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData)
{
/* NtGdiDdFlipToGDISurface */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdFlipToGDISurface(HANDLE hDirectDraw,
PDD_FLIPTOGDISURFACEDATA puFlipToGDISurfaceData)
{
/* NtGdiDdGetDC */
/************************************************************************/
HDC
-STDCALL
+APIENTRY
NtGdiDdGetDC(HANDLE hSurface,
PALETTEENTRY *puColorTable)
{
/* NtGdiDdGetDxHandle */
/************************************************************************/
HANDLE
-STDCALL
+APIENTRY
NtGdiDdGetDxHandle(HANDLE hDirectDraw,
HANDLE hSurface,
BOOL bRelease)
/* NtGdiDdReleaseDC */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdReleaseDC(HANDLE hSurface)
{
PGD_DDRELEASEDC pfnDdReleaseDC = (PGD_DDRELEASEDC)gpDxFuncs[DXG_INDEX_DxDdReleaseDC].pfn;
/* NtGdiDdResetVisrgn */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdResetVisrgn(HANDLE hSurface,
HWND hwnd)
{
/* NtGdiDdSetGammaRamp */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdSetGammaRamp(HANDLE hDirectDraw,
HDC hdc,
LPVOID lpGammaRamp)
/* NtGdiDdDestroySurface */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdDestroySurface(HANDLE hSurface, BOOL bRealDestroy)
{
PGD_DXDDDESTROYSURFACE pfnDdDestroySurface = (PGD_DXDDDESTROYSURFACE)gpDxFuncs[DXG_INDEX_DxDdDestroySurface].pfn;
/* NtGdiDdFlip */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdFlip(HANDLE hSurfaceCurrent,
HANDLE hSurfaceTarget,
HANDLE hSurfaceCurrentLeft,
/* NtGdiDdUnlock */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdLock(HANDLE hSurface,
PDD_LOCKDATA puLockData,
HDC hdcClip)
/* NtGdiDdunlock */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdUnlock(HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData)
{
/* NtGdiDdBlt */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdBlt(HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData)
/* NtGdiDdSetColorKey */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdSetColorKey(HANDLE hSurface,
PDD_SETCOLORKEYDATA puSetColorKeyData)
{
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdAddAttachedSurface(HANDLE hSurface,
HANDLE hSurfaceAttached,
PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData)
/* NtGdiDdGetBltStatus */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetBltStatus(HANDLE hSurface,
PDD_GETBLTSTATUSDATA puGetBltStatusData)
{
/* NtGdiDdGetFlipStatus */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetFlipStatus(HANDLE hSurface,
PDD_GETFLIPSTATUSDATA puGetFlipStatusData)
{
/* NtGdiDdUpdateOverlay */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdUpdateOverlay(HANDLE hSurfaceDestination,
HANDLE hSurfaceSource,
PDD_UPDATEOVERLAYDATA puUpdateOverlayData)
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdSetOverlayPosition(HANDLE hSurfaceSource,
HANDLE hSurfaceDestination,
PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData)
/* NtGdiDdAlphaBlt */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdAlphaBlt(HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData)
/* NtGdiDdAttachSurface */
/************************************************************************/
BOOL
-STDCALL
+APIENTRY
NtGdiDdAttachSurface(HANDLE hSurfaceFrom,
HANDLE hSurfaceTo
)
so I guess it is a typo in MSDN for this protypes for the info talk against it self
*/
DWORD
-STDCALL
+APIENTRY
NtGdiDdUnattachSurface(HANDLE hSurface,
HANDLE hSurfaceAttached)
{
/* NtGdiDvpCanCreateVideoPort */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpCanCreateVideoPort(HANDLE hDirectDraw,
PDD_CANCREATEVPORTDATA puCanCreateVPortData)
{
/* NtGdiDvpColorControl */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpColorControl(HANDLE hVideoPort,
PDD_VPORTCOLORDATA puVPortColorData)
{
/* NtGdiDvpCreateVideoPort */
/************************************************************************/
HANDLE
-STDCALL
+APIENTRY
NtGdiDvpCreateVideoPort(HANDLE hDirectDraw,
PDD_CREATEVPORTDATA puCreateVPortData)
{
/* NtGdiDvpDestroyVideoPort */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpDestroyVideoPort(HANDLE hVideoPort,
PDD_DESTROYVPORTDATA puDestroyVPortData)
{
/* NtGdiDvpFlipVideoPort */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpFlipVideoPort(HANDLE hVideoPort,
HANDLE hDDSurfaceCurrent,
HANDLE hDDSurfaceTarget,
/* NtGdiDvpGetVideoPortBandwidth */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoPortBandwidth(HANDLE hVideoPort,
PDD_GETVPORTBANDWIDTHDATA puGetVPortBandwidthData)
{
/* NtGdiDvpGetVideoPortFlipStatus */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoPortFlipStatus(HANDLE hDirectDraw,
PDD_GETVPORTFLIPSTATUSDATA puGetVPortFlipStatusData)
{
/* NtGdiDvpGetVideoPortInputFormats */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoPortInputFormats(HANDLE hVideoPort,
PDD_GETVPORTINPUTFORMATDATA puGetVPortInputFormatData)
{
/* NtGdiDvpGetVideoPortLine */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoPortLine(HANDLE hVideoPort,
PDD_GETVPORTLINEDATA puGetVPortLineData)
{
/* NtGdiDvpGetVideoPortOutputFormats */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoPortOutputFormats(HANDLE hVideoPort,
PDD_GETVPORTOUTPUTFORMATDATA puGetVPortOutputFormatData)
{
/* NtGdiDvpGetVideoPortConnectInfo */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoPortConnectInfo(HANDLE hDirectDraw,
PDD_GETVPORTCONNECTDATA puGetVPortConnectData)
{
/* NtGdiDvpGetVideoSignalStatus */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoSignalStatus(HANDLE hVideoPort,
PDD_GETVPORTSIGNALDATA puGetVPortSignalData)
{
/* NtGdiDvpUpdateVideoPort */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpUpdateVideoPort(HANDLE hVideoPort,
HANDLE* phSurfaceVideo,
HANDLE* phSurfaceVbi,
/* NtGdiDvpWaitForVideoPortSync */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpWaitForVideoPortSync(HANDLE hVideoPort,
PDD_WAITFORVPORTSYNCDATA puWaitForVPortSyncData)
{
/* NtGdiDvpAcquireNotification */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpAcquireNotification(HANDLE hVideoPort,
HANDLE* hEvent,
LPDDVIDEOPORTNOTIFY pNotify)
/* NtGdiDvpReleaseNotification */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpReleaseNotification(HANDLE hVideoPort,
HANDLE hEvent)
{
/* NtGdiDvpGetVideoPortField */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDvpGetVideoPortField(HANDLE hVideoPort,
PDD_GETVPORTFIELDDATA puGetVPortFieldData)
{
*
*--*/
BOOL
-STDCALL
+APIENTRY
DxEngGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp)
{
DPRINT1("ReactX Calling : DxEngGetDeviceGammaRamp\n");
*
*--*/
PDC
-STDCALL
+APIENTRY
DxEngLockDC(HDC hDC)
{
DPRINT1("ReactX Calling : DxEngLockDC\n");
*
*--*/
BOOLEAN
-STDCALL
+APIENTRY
DxEngUnlockDC(PDC pDC)
{
DPRINT1("ReactX Calling : DxEngUnlockDC\n");
*SystemResourcesList
*--*/
BOOLEAN
-STDCALL
+APIENTRY
DxEngLockShareSem()
{
DPRINT1("ReactX Calling : DxEngLockShareSem\n");
*
*--*/
BOOLEAN
-STDCALL
+APIENTRY
DxEngUnlockShareSem()
{
DPRINT1("ReactX Calling : DxEngUnlockShareSem\n");
*
*--*/
BOOLEAN
-STDCALL
+APIENTRY
DxEngSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL Test)
{
DPRINT1("ReactX Calling : DxEngSetDeviceGammaRamp\n");
*
*--*/
DWORD_PTR
-STDCALL
+APIENTRY
DxEngGetHdevData(HDEV hDev,
DXEGSHDEVDATA Type)
{
*
*--*/
BOOLEAN
-STDCALL
+APIENTRY
DxEngSetHdevData(HDEV hDev,
DXEGSHDEVDATA Type,
DWORD_PTR Data)
*
*--*/
DWORD_PTR
-STDCALL
+APIENTRY
DxEngGetDCState(HDC hDC,
DWORD type)
{
*
*--*/
BOOLEAN
-STDCALL
+APIENTRY
DxEngLockHdev(HDEV hDev)
{
PGDIDEVICE pPDev = (PGDIDEVICE)hDev;
*
*--*/
BOOLEAN
-STDCALL
+APIENTRY
DxEngUnlockHdev(HDEV hDev)
{
PGDIDEVICE pPDev = (PGDIDEVICE)hDev;
/* DxEngReferenceHdev */
/************************************************************************/
BOOLEAN
-STDCALL
+APIENTRY
DxEngReferenceHdev(HDEV hDev)
{
IntGdiReferencePdev((PGDIDEVICE) hDev);;
/* Notes : Check see if termal server got a connections or not */
BOOLEAN
-STDCALL
+APIENTRY
DxEngNUIsTermSrv()
{
/* FIXME ReactOS does not suport terminal server yet, we can not check if we got a connections or not */
/************************************************************************/
/* Enumerate all drivers in win32k */
HDEV *
-STDCALL
+APIENTRY
DxEngEnumerateHdev(HDEV *hdev)
{
/* FIXME Enumerate all drivers in win32k */
/* DxEngCreateMemoryDC */
/************************************************************************/
HDC
-STDCALL
+APIENTRY
DxEngCreateMemoryDC(HDEV hDev)
{
return IntGdiCreateDisplayDC(hDev, DC_TYPE_MEMORY, FALSE);
/************************************************************************/
/* DxEngScreenAccessCheck */
/************************************************************************/
-DWORD STDCALL DxEngScreenAccessCheck()
+DWORD APIENTRY DxEngScreenAccessCheck()
{
UNIMPLEMENTED;
/* DxEngIsHdevLockedByCurrentThread */
/************************************************************************/
BOOLEAN
-STDCALL
+APIENTRY
DxEngIsHdevLockedByCurrentThread(HDEV hDev)
{ // base on EngIsSemaphoreOwnedByCurrentThread w/o the Ex call.
PERESOURCE pSem = ((PGDIDEVICE)hDev)->hsemDevLock;
/* DxEngUnreferenceHdev */
/************************************************************************/
BOOLEAN
-STDCALL
+APIENTRY
DxEngUnreferenceHdev(HDEV hDev)
{
IntGdiUnreferencePdev((PGDIDEVICE) hDev, 0);
/* DxEngGetDesktopDC */
/************************************************************************/
HDC
-STDCALL
+APIENTRY
DxEngGetDesktopDC(ULONG DcType, BOOL EmptyDC, BOOL ValidatehWnd)
{
PWINDOW_OBJECT DesktopObject = 0;
/* DxEngDeleteDC */
/************************************************************************/
BOOLEAN
-STDCALL
+APIENTRY
DxEngDeleteDC(HDC hdc, BOOL Force)
{
return IntGdiDeleteDC(hdc, Force);
/* DxEngCleanDC */
/************************************************************************/
BOOLEAN
-STDCALL
+APIENTRY
DxEngCleanDC(HDC hdc)
{
return IntGdiCleanDC(hdc);
/************************************************************************/
/* DxEngSetDCOwner */
/************************************************************************/
-BOOL STDCALL DxEngSetDCOwner(HGDIOBJ hObject, DWORD OwnerMask)
+BOOL APIENTRY DxEngSetDCOwner(HGDIOBJ hObject, DWORD OwnerMask)
{
DPRINT1("ReactX Calling : DxEngSetDCOwner \n");
/* DxEngSetDCState */
/************************************************************************/
BOOLEAN
-STDCALL
+APIENTRY
DxEngSetDCState(HDC hDC, DWORD SetType, DWORD Set)
{
BOOLEAN Ret = FALSE;
/************************************************************************/
/* DxEngSelectBitmap */
/************************************************************************/
-DWORD STDCALL DxEngSelectBitmap(DWORD x1, DWORD x2)
+DWORD APIENTRY DxEngSelectBitmap(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngSetBitmapOwner */
/************************************************************************/
-DWORD STDCALL DxEngSetBitmapOwner(DWORD x1, DWORD x2)
+DWORD APIENTRY DxEngSetBitmapOwner(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngDeleteSurface */
/************************************************************************/
-DWORD STDCALL DxEngDeleteSurface(DWORD x1)
+DWORD APIENTRY DxEngDeleteSurface(DWORD x1)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngGetSurfaceData */
/************************************************************************/
-DWORD STDCALL DxEngGetSurfaceData(DWORD x1, DWORD x2)
+DWORD APIENTRY DxEngGetSurfaceData(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngAltLockSurface */
/************************************************************************/
-DWORD STDCALL DxEngAltLockSurface(DWORD x1)
+DWORD APIENTRY DxEngAltLockSurface(DWORD x1)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngUploadPaletteEntryToSurface */
/************************************************************************/
-DWORD STDCALL DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4)
+DWORD APIENTRY DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngMarkSurfaceAsDirectDraw */
/************************************************************************/
-DWORD STDCALL DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2)
+DWORD APIENTRY DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngSelectPaletteToSurface */
/************************************************************************/
-DWORD STDCALL DxEngSelectPaletteToSurface(DWORD x1, DWORD x2)
+DWORD APIENTRY DxEngSelectPaletteToSurface(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngSyncPaletteTableWithDevice */
/************************************************************************/
-DWORD STDCALL DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2)
+DWORD APIENTRY DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngSetPaletteState */
/************************************************************************/
-DWORD STDCALL DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3)
+DWORD APIENTRY DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
/* DxEngGetRedirectionBitmap */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
DxEngGetRedirectionBitmap(DWORD x1)
{
return FALSE; // Normal return.
/************************************************************************/
/* DxEngLoadImage */
/************************************************************************/
-DWORD STDCALL DxEngLoadImage(DWORD x1,DWORD x2)
+DWORD APIENTRY DxEngLoadImage(DWORD x1,DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngSpTearDownSprites */
/************************************************************************/
-DWORD STDCALL DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
+DWORD APIENTRY DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngSpUnTearDownSprites */
/************************************************************************/
-DWORD STDCALL DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
+DWORD APIENTRY DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
/************************************************************************/
/* DxEngSpSpritesVisible */
/************************************************************************/
-DWORD STDCALL DxEngSpSpritesVisible(DWORD x1)
+DWORD APIENTRY DxEngSpSpritesVisible(DWORD x1)
{
UNIMPLEMENTED;
return FALSE;
/* HeapVidMemAllocAligned */
/************************************************************************/
FLATPTR
-STDCALL
+APIENTRY
HeapVidMemAllocAligned(LPVIDMEM lpVidMem,
DWORD dwWidth,
DWORD dwHeight,
/* VidMemFree */
/************************************************************************/
VOID
-STDCALL
+APIENTRY
VidMemFree(LPVMEMHEAP pvmh,
FLATPTR ptr)
{
/* EngAllocPrivateUserMem */
/************************************************************************/
PVOID
-STDCALL
+APIENTRY
EngAllocPrivateUserMem(PDD_SURFACE_LOCAL psl,
SIZE_T cj,
ULONG tag)
/* EngFreePrivateUserMem */
/************************************************************************/
VOID
-STDCALL
+APIENTRY
EngFreePrivateUserMem(PDD_SURFACE_LOCAL psl,
PVOID pv)
{
*
*--*/
DWORD
-STDCALL
+APIENTRY
EngDxIoctl(ULONG ulIoctl,
PVOID pBuffer,
ULONG ulBufferSize)
*
*--*/
PDD_SURFACE_LOCAL
-STDCALL
+APIENTRY
EngLockDirectDrawSurface(HANDLE hSurface)
{
PGD_ENGLOCKDIRECTDRAWSURFACE pfnEngLockDirectDrawSurface = (PGD_ENGLOCKDIRECTDRAWSURFACE)gpDxFuncs[DXG_INDEX_DxDdLockDirectDrawSurface].pfn;
*
*--*/
BOOL
-STDCALL
+APIENTRY
EngUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface)
{
PGD_ENGUNLOCKDIRECTDRAWSURFACE pfnEngUnlockDirectDrawSurface = (PGD_ENGUNLOCKDIRECTDRAWSURFACE)gpDxFuncs[DXG_INDEX_DxDdUnlockDirectDrawSurface].pfn;
/* NtGdiDdBeginMoCompFrame */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdBeginMoCompFrame(HANDLE hMoComp,
PDD_BEGINMOCOMPFRAMEDATA puBeginFrameData)
{
/* NtGdiDdCreateMoComp */
/************************************************************************/
HANDLE
-STDCALL
+APIENTRY
NtGdiDdCreateMoComp(HANDLE hDirectDraw, PDD_CREATEMOCOMPDATA puCreateMoCompData)
{
PGD_DXDDCREATEMOCOMP pfnDdCreateMoComp = (PGD_DXDDCREATEMOCOMP)gpDxFuncs[DXG_INDEX_DxDdCreateMoComp].pfn;
/* NtGdiDdDestroyMoComp */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdDestroyMoComp(HANDLE hMoComp,
PDD_DESTROYMOCOMPDATA puBeginFrameData)
{
/* NtGdiDdEndMoCompFrame */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdEndMoCompFrame(HANDLE hMoComp,
PDD_ENDMOCOMPFRAMEDATA puEndFrameData)
{
/* NtGdiDdGetInternalMoCompInfo */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetInternalMoCompInfo(HANDLE hDirectDraw,
PDD_GETINTERNALMOCOMPDATA puGetInternalData)
{
/* NtGdiDdGetMoCompBuffInfo */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetMoCompBuffInfo(HANDLE hDirectDraw,
PDD_GETMOCOMPCOMPBUFFDATA puGetBuffData)
{
/* NtGdiDdGetMoCompFormats */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetMoCompFormats(HANDLE hDirectDraw,
PDD_GETMOCOMPFORMATSDATA puGetMoCompFormatsData)
{
/* NtGdiDdGetMoCompGuids */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdGetMoCompGuids(HANDLE hDirectDraw,
PDD_GETMOCOMPGUIDSDATA puGetMoCompGuidsData)
{
/* NtGdiDdQueryMoCompStatus */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdQueryMoCompStatus(HANDLE hMoComp,
PDD_QUERYMOCOMPSTATUSDATA puQueryMoCompStatusData)
{
/* NtGdiDdRenderMoComp */
/************************************************************************/
DWORD
-STDCALL
+APIENTRY
NtGdiDdRenderMoComp(HANDLE hMoComp,
PDD_RENDERMOCOMPDATA puRenderMoCompData)
{
int
-STDCALL
+APIENTRY
NtUserCopyAcceleratorTable(
HACCEL hAccel,
LPACCEL Entries,
}
HACCEL
-STDCALL
+APIENTRY
NtUserCreateAcceleratorTable(
LPACCEL Entries,
SIZE_T EntriesCount)
BOOLEAN
-STDCALL
+APIENTRY
NtUserDestroyAcceleratorTable(
HACCEL hAccel)
{
int
-STDCALL
+APIENTRY
NtUserTranslateAccelerator(
HWND hWnd,
HACCEL hAccel,
/* FUNCTIONS *****************************************************************/
-VOID STDCALL
+VOID APIENTRY
co_IntCallSentMessageCallback(SENDASYNCPROC CompletionCallback,
HWND hWnd,
UINT Msg,
return;
}
-LRESULT STDCALL
+LRESULT APIENTRY
co_IntCallWindowProc(WNDPROC Proc,
BOOLEAN IsAnsiProc,
HWND Wnd,
return Result;
}
-HMENU STDCALL
+HMENU APIENTRY
co_IntLoadSysMenuTemplate()
{
LRESULT Result;
return (HMENU)Result;
}
-BOOL STDCALL
+BOOL APIENTRY
co_IntLoadDefaultCursors(VOID)
{
LRESULT Result;
return TRUE;
}
-LRESULT STDCALL
+LRESULT APIENTRY
co_IntCallHookProc(INT HookId,
INT Code,
WPARAM wParam,
}
LRESULT
-STDCALL
+APIENTRY
co_IntCallEventProc(HWINEVENTHOOK hook,
DWORD event,
HWND hWnd,
/* SYSCALLS *****************************************************************/
BOOL
-STDCALL
+APIENTRY
NtUserCreateCaret(
HWND hWnd,
HBITMAP hBitmap,
}
UINT
-STDCALL
+APIENTRY
NtUserGetCaretBlinkTime(VOID)
{
DECLARE_RETURN(UINT);
}
BOOL
-STDCALL
+APIENTRY
NtUserGetCaretPos(
LPPOINT lpPoint)
{
}
BOOL
-STDCALL
+APIENTRY
NtUserShowCaret(HWND hWnd OPTIONAL)
{
PWINDOW_OBJECT Window = NULL;
}
BOOL
-STDCALL
+APIENTRY
NtUserHideCaret(HWND hWnd OPTIONAL)
{
PWINDOW_OBJECT Window = NULL;
/* SYSCALLS *****************************************************************/
-RTL_ATOM NTAPI
+RTL_ATOM APIENTRY
NtUserRegisterClassEx(IN CONST WNDCLASSEXW* lpwcx,
IN PUNICODE_STRING ClassName,
IN PUNICODE_STRING MenuName,
RTL_ATOM
-NTAPI
+APIENTRY
NtUserRegisterClassExWOW(
WNDCLASSEXW* lpwcx,
PUNICODE_STRING ClassName,
}
-ULONG_PTR NTAPI
+ULONG_PTR APIENTRY
NtUserGetClassLong(IN HWND hWnd,
IN INT Offset,
IN BOOL Ansi)
-ULONG_PTR STDCALL
+ULONG_PTR APIENTRY
NtUserSetClassLong(HWND hWnd,
INT Offset,
ULONG_PTR dwNewLong,
}
WORD
-STDCALL
+APIENTRY
NtUserSetClassWord(
HWND hWnd,
INT nIndex,
return(0);
}
-BOOL NTAPI
+BOOL APIENTRY
NtUserUnregisterClass(IN PUNICODE_STRING ClassNameOrAtom,
IN HINSTANCE hInstance,
OUT PCLSMENUNAME pClassMenuName)
}
/* NOTE: for system classes hInstance is not NULL here, but User32Instance */
-BOOL STDCALL
+BOOL APIENTRY
NtUserGetClassInfo(
HINSTANCE hInstance,
PUNICODE_STRING ClassName,
-INT NTAPI
+INT APIENTRY
NtUserGetClassName (IN HWND hWnd,
OUT PUNICODE_STRING ClassName,
IN BOOL Ansi)
return Ret;
}
-DWORD STDCALL
+DWORD APIENTRY
NtUserGetWOWClass(DWORD Unknown0,
DWORD Unknown1)
{
}
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserOpenClipboard(HWND hWnd, DWORD Unknown1)
{
return ret;
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserCloseClipboard(VOID)
{
BOOL ret = FALSE;
return ret;
}
-HWND STDCALL
+HWND APIENTRY
NtUserGetOpenClipboardWindow(VOID)
{
HWND ret = NULL;
return ret;
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserChangeClipboardChain(HWND hWndRemove, HWND hWndNewNext)
{
BOOL ret = FALSE;
return ret;
}
-DWORD STDCALL
+DWORD APIENTRY
NtUserCountClipboardFormats(VOID)
{
DWORD ret = 0;
return ret;
}
-DWORD STDCALL
+DWORD APIENTRY
NtUserEmptyClipboard(VOID)
{
BOOL ret = FALSE;
return ret;
}
-HANDLE STDCALL
+HANDLE APIENTRY
NtUserGetClipboardData(UINT uFormat, PVOID pBuffer)
{
HANDLE ret = NULL;
return ret;
}
-INT STDCALL
+INT APIENTRY
NtUserGetClipboardFormatName(UINT format, PUNICODE_STRING FormatName,
INT cchMaxCount)
{
return ret;
}
-HWND STDCALL
+HWND APIENTRY
NtUserGetClipboardOwner(VOID)
{
HWND ret = NULL;
return ret;
}
-HWND STDCALL
+HWND APIENTRY
NtUserGetClipboardViewer(VOID)
{
HWND ret = NULL;
return ret;
}
-INT STDCALL
+INT APIENTRY
NtUserGetPriorityClipboardFormat(UINT *paFormatPriorityList, INT cFormats)
{
INT i;
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserIsClipboardFormatAvailable(UINT format)
{
BOOL ret = FALSE;
-HANDLE STDCALL
+HANDLE APIENTRY
NtUserSetClipboardData(UINT uFormat, HANDLE hMem, DWORD size)
{
HANDLE hCBData = NULL;
return hMem;
}
-HWND STDCALL
+HWND APIENTRY
NtUserSetClipboardViewer(HWND hWndNewViewer)
{
HWND ret = NULL;
return ret;
}
-UINT STDCALL
+UINT APIENTRY
IntEnumClipboardFormats(UINT uFormat)
{
UINT ret = 0;
WinStaObj->Clipboard->ClipboardSequenceNumber++;
}
-DWORD STDCALL
+DWORD APIENTRY
NtUserGetClipboardSequenceNumber(VOID)
{
//windowstation sequence number
/**************** VISTA FUNCTIONS******************/
-BOOL STDCALL NtUserAddClipboardFormatListener(
+BOOL APIENTRY NtUserAddClipboardFormatListener(
HWND hwnd
)
{
return FALSE;
}
-BOOL STDCALL NtUserRemoveClipboardFormatListener(
+BOOL APIENTRY NtUserRemoveClipboardFormatListener(
HWND hwnd
)
{
return FALSE;
}
-BOOL STDCALL NtUserGetUpdatedClipboardFormats(
+BOOL APIENTRY NtUserGetUpdatedClipboardFormats(
PUINT lpuiFormats,
UINT cFormats,
PUINT pcFormatsOut
NTSTATUS
-STDCALL
+APIENTRY
CsrInsertObject(HANDLE ObjectHandle,
ACCESS_MASK DesiredAccess,
PHANDLE Handle)
* @implemented
*/
HANDLE
-STDCALL
+APIENTRY
NtUserCreateCursorIconHandle(PICONINFO IconInfo OPTIONAL, BOOL Indirect)
{
PCURICON_OBJECT CurIcon;
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserGetIconInfo(
HANDLE hCurIcon,
PICONINFO IconInfo,
* @implemented
*/
BOOL
-NTAPI
+APIENTRY
NtUserGetIconSize(
HANDLE hCurIcon,
UINT istepIfAniCur,
* @unimplemented
*/
DWORD
-STDCALL
+APIENTRY
NtUserGetCursorFrameInfo(
DWORD Unknown0,
DWORD Unknown1,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserGetCursorInfo(
PCURSORINFO pci)
{
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserClipCursor(
RECT *UnsafeRect)
{
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserDestroyCursor(
HANDLE hCurIcon,
DWORD Unknown)
* @implemented
*/
HICON
-STDCALL
+APIENTRY
NtUserFindExistingCursorIcon(
HMODULE hModule,
HRSRC hRsrc,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserGetClipCursor(
RECT *lpRect)
{
* @implemented
*/
HCURSOR
-STDCALL
+APIENTRY
NtUserSetCursor(
HCURSOR hCursor)
{
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserSetCursorContents(
HANDLE hCurIcon,
PICONINFO UnsafeIconInfo)
*/
#if 0
BOOL
-NTAPI
+APIENTRY
NtUserSetCursorIconData(
HANDLE Handle,
HMODULE hModule,
}
#else
BOOL
-STDCALL
+APIENTRY
NtUserSetCursorIconData(
HANDLE hCurIcon,
PBOOL fIcon,
* @unimplemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserSetSystemCursor(
HCURSOR hcur,
DWORD id)
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserDrawIconEx(
HDC hdc,
int xLeft,
/* Called from NtUserCallOneParam with Routine ONEPARAM_ROUTINE_SHOWCURSOR
* User32 macro NtUserShowCursor */
int
-NTAPI
+APIENTRY
UserShowCursor(BOOL bShow)
{
PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
/* OBJECT CALLBACKS **********************************************************/
NTSTATUS
-NTAPI
+APIENTRY
IntDesktopObjectParse(IN PVOID ParseObject,
IN PVOID ObjectType,
IN OUT PACCESS_STATE AccessState,
return STATUS_SUCCESS;
}
-VOID STDCALL
+VOID APIENTRY
IntDesktopObjectDelete(PWIN32_DELETEMETHOD_PARAMETERS Parameters)
{
PDESKTOP Desktop = (PDESKTOP)Parameters->Object;
* @implemented
*/
-HDESK STDCALL
+HDESK APIENTRY
NtUserCreateDesktop(
PUNICODE_STRING lpszDesktopName,
DWORD dwFlags,
* @implemented
*/
-HDESK STDCALL
+HDESK APIENTRY
NtUserOpenDesktop(
PUNICODE_STRING lpszDesktopName,
DWORD dwFlags,
* @implemented
*/
-HDESK STDCALL
+HDESK APIENTRY
NtUserOpenInputDesktop(
DWORD dwFlags,
BOOL fInherit,
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserCloseDesktop(HDESK hDesktop)
{
PDESKTOP Object;
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserPaintDesktop(HDC hDC)
{
RECT Rect;
* @unimplemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserSwitchDesktop(HDESK hDesktop)
{
PDESKTOP DesktopObject;
* @unimplemented
*/
-DWORD STDCALL
+DWORD APIENTRY
NtUserResolveDesktopForWOW(DWORD Unknown0)
{
UNIMPLEMENTED
* @implemented
*/
-HDESK STDCALL
+HDESK APIENTRY
NtUserGetThreadDesktop(DWORD dwThreadId, DWORD Unknown1)
{
NTSTATUS Status;
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserSetThreadDesktop(HDESK hDesktop)
{
PDESKTOP DesktopObject;
/* PUBLIC FUNCTIONS ***********************************************************/
NTSTATUS
-NTAPI
+APIENTRY
NtUserEnumDisplaySettings(
PUNICODE_STRING pusDeviceName,
DWORD iModeNum,
LONG
-NTAPI
+APIENTRY
NtUserChangeDisplaySettings(
PUNICODE_STRING lpszDeviceName,
LPDEVMODEW lpDevMode,
}
VOID
-STDCALL
+APIENTRY
NtUserNotifyWinEvent(
DWORD Event,
HWND hWnd,
}
HWINEVENTHOOK
-STDCALL
+APIENTRY
NtUserSetWinEventHook(
UINT eventMin,
UINT eventMax,
}
BOOL
-STDCALL
+APIENTRY
NtUserUnhookWinEvent(
HWINEVENTHOOK hWinEventHook)
{
/*
* @implemented
*/
-HWND STDCALL
+HWND APIENTRY
NtUserGetForegroundWindow(VOID)
{
DECLARE_RETURN(HWND);
}
-HWND STDCALL
+HWND APIENTRY
NtUserSetActiveWindow(HWND hWnd)
{
USER_REFERENCE_ENTRY Ref;
/*
* @implemented
*/
-HWND STDCALL
+HWND APIENTRY
IntGetCapture(VOID)
{
PTHREADINFO pti;
/*
* @implemented
*/
-HWND STDCALL
+HWND APIENTRY
NtUserSetCapture(HWND hWnd)
{
PTHREADINFO pti;
/*
* @implemented
*/
-HWND STDCALL
+HWND APIENTRY
NtUserSetFocus(HWND hWnd)
{
PWINDOW_OBJECT Window;
}
LRESULT
-STDCALL
+APIENTRY
NtUserCallNextHookEx(
int Code,
WPARAM wParam,
}
HHOOK
-STDCALL
+APIENTRY
NtUserSetWindowsHookAW(
int idHook,
HOOKPROC lpfn,
}
HHOOK
-STDCALL
+APIENTRY
NtUserSetWindowsHookEx(
HINSTANCE Mod,
PUNICODE_STRING UnsafeModuleName,
BOOL
-STDCALL
+APIENTRY
NtUserUnhookWindowsHookEx(
HHOOK Hook)
{
/* SYSCALLS *****************************************************************/
-BOOL STDCALL
+BOOL APIENTRY
NtUserRegisterHotKey(HWND hWnd,
int id,
UINT fsModifiers,
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserUnregisterHotKey(HWND hWnd, int id)
{
PHOT_KEY_ITEM HotKeyItem;
}
BOOL
-STDCALL
+APIENTRY
NtUserGetLastInputInfo(PLASTINPUTINFO plii)
{
BOOL ret = TRUE;
-VOID STDCALL
+VOID APIENTRY
MouseThreadMain(PVOID StartContext)
{
UNICODE_STRING MouseDeviceName = RTL_CONSTANT_STRING(L"\\Device\\PointerClass0");
/* Returns a value that indicates if the key is a modifier key, and
* which one.
*/
-static UINT STDCALL
+static UINT APIENTRY
IntKeyboardGetModifiers(KEYBOARD_INPUT_DATA *InputData)
{
if (InputData->Flags & KEY_E1)
/* Asks the keyboard driver to send a small table that shows which
* lights should connect with which scancodes
*/
-static NTSTATUS STDCALL
+static NTSTATUS APIENTRY
IntKeyboardGetIndicatorTrans(HANDLE KeyboardDeviceHandle,
PKEYBOARD_INDICATOR_TRANSLATION *IndicatorTrans)
{
/* Sends the keyboard commands to turn on/off the lights.
*/
-static NTSTATUS STDCALL
+static NTSTATUS APIENTRY
IntKeyboardUpdateLeds(HANDLE KeyboardDeviceHandle,
PKEYBOARD_INPUT_DATA KeyInput,
PKEYBOARD_INDICATOR_TRANSLATION IndicatorTrans)
return STATUS_SUCCESS;
}
-static VOID STDCALL
+static VOID APIENTRY
IntKeyboardSendWinKeyMsg()
{
PWINDOW_OBJECT Window;
MsqPostMessage(Window->MessageQueue, &Mesg, FALSE, QS_HOTKEY);
}
-static VOID STDCALL
+static VOID APIENTRY
co_IntKeyboardSendAltKeyMsg()
{
co_MsqPostKeyboardMessage(WM_SYSCOMMAND,SC_KEYMENU,0);
}
-static VOID STDCALL
+static VOID APIENTRY
KeyboardThreadMain(PVOID StartContext)
{
UNICODE_STRING KeyboardDeviceName = RTL_CONSTANT_STRING(L"\\Device\\KeyboardClass0");
}
BOOL
-STDCALL
+APIENTRY
NtUserDragDetect(
HWND hWnd,
POINT pt) // Just like the User call.
}
BOOL
-STDCALL
+APIENTRY
NtUserBlockInput(
BOOL BlockIt)
{
}
UINT
-STDCALL
+APIENTRY
NtUserSendInput(
UINT nInputs,
LPINPUT pInput,
PKBL KBLList = NULL; // Keyboard layout list.\r
\r
typedef PVOID (*KbdLayerDescriptor)(VOID);\r
-NTSTATUS STDCALL LdrGetProcedureAddress(PVOID module,\r
+NTSTATUS APIENTRY LdrGetProcedureAddress(PVOID module,\r
PANSI_STRING import_name,\r
DWORD flags,\r
PVOID *func_addr);\r
* Returns NTSTATUS\r
*/\r
\r
-static NTSTATUS NTAPI ReadRegistryValue( PUNICODE_STRING KeyName,\r
+static NTSTATUS APIENTRY ReadRegistryValue( PUNICODE_STRING KeyName,\r
PUNICODE_STRING ValueName,\r
PUNICODE_STRING ReturnedValue )\r
{\r
}\r
\r
UINT\r
-STDCALL\r
+APIENTRY\r
NtUserGetKeyboardLayoutList(\r
INT nItems,\r
HKL* pHklBuff)\r
}\r
\r
BOOL\r
-STDCALL\r
+APIENTRY\r
NtUserGetKeyboardLayoutName(\r
LPWSTR lpszName)\r
{\r
\r
\r
HKL\r
-STDCALL\r
+APIENTRY\r
NtUserLoadKeyboardLayoutEx(\r
IN HANDLE Handle,\r
IN DWORD offTable,\r
}\r
\r
HKL\r
-STDCALL\r
+APIENTRY\r
NtUserActivateKeyboardLayout(\r
HKL hKl,\r
ULONG Flags)\r
}\r
\r
BOOL\r
-STDCALL\r
+APIENTRY\r
NtUserUnloadKeyboardLayout(\r
HKL hKl)\r
{\r
return ret;
}
-static VOID STDCALL SetKeyState(DWORD key, DWORD vk, DWORD ext, BOOL down)
+static VOID APIENTRY SetKeyState(DWORD key, DWORD vk, DWORD ext, BOOL down)
{
ASSERT(vk <= 0xff);
}
static
-int STDCALL
+int APIENTRY
ToUnicodeInner(UINT wVirtKey,
UINT wScanCode,
PBYTE lpKeyState,
SHORT
-STDCALL
+APIENTRY
NtUserGetKeyState(
INT key)
{
SHORT
-STDCALL
+APIENTRY
NtUserGetAsyncKeyState(
INT key)
{
}
DWORD
-STDCALL
+APIENTRY
NtUserGetKeyboardState(
LPBYTE lpKeyState)
{
}
BOOL
-STDCALL
+APIENTRY
NtUserSetKeyboardState(LPBYTE lpKeyState)
{
BOOL Result = TRUE;
}
UINT
-STDCALL
+APIENTRY
NtUserMapVirtualKeyEx( UINT Code, UINT Type, DWORD keyboardId, HKL dwhkl )
{
PTHREADINFO pti;
int
-STDCALL
+APIENTRY
NtUserToUnicodeEx(
UINT wVirtKey,
UINT wScanCode,
}
DWORD
-STDCALL
+APIENTRY
NtUserGetKeyNameText( LONG lParam, LPWSTR lpString, int nSize )
{
PTHREADINFO pti;
look for wChar match.
*/
DWORD
-STDCALL
+APIENTRY
NtUserVkKeyScanEx(
WCHAR wChar,
HKL KeyboardLayout,
return TRUE;
}
-VOID STDCALL
+VOID APIENTRY
co_InflateRect(LPRECT rect, int dx, int dy)
{
rect->left -= dx;
rect->bottom += dy;
}
-BOOLEAN STDCALL
+BOOLEAN APIENTRY
intGetTitleBarInfo(PWINDOW_OBJECT pWindowObject, PTITLEBARINFO bti)
{
* @implemented
*/
DWORD
-STDCALL
+APIENTRY
NtUserBuildMenuItemList(
HMENU hMenu,
VOID* Buffer,
/*
* @implemented
*/
-DWORD STDCALL
+DWORD APIENTRY
NtUserCheckMenuItem(
HMENU hMenu,
UINT uIDCheckItem,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserDeleteMenu(
HMENU hMenu,
UINT uPosition,
/*
* @implemented
*/
-BOOLEAN STDCALL
+BOOLEAN APIENTRY
NtUserGetTitleBarInfo(
HWND hwnd,
PTITLEBARINFO bti)
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserDestroyMenu(
HMENU hMenu)
{
/*
* @implemented
*/
-UINT STDCALL
+UINT APIENTRY
NtUserEnableMenuItem(
HMENU hMenu,
UINT uIDEnableItem,
/*
* @implemented
*/
-DWORD STDCALL
+DWORD APIENTRY
UserInsertMenuItem(
HMENU hMenu,
UINT uItem,
/*
* @unimplemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserEndMenu(VOID)
{
UNIMPLEMENTED
/*
* @implemented
*/
-UINT STDCALL
+UINT APIENTRY
NtUserGetMenuDefaultItem(
HMENU hMenu,
UINT fByPos,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserGetMenuBarInfo(
HWND hwnd,
LONG idObject,
/*
* @unimplemented
*/
-UINT STDCALL
+UINT APIENTRY
NtUserGetMenuIndex(
HMENU hMenu,
UINT wID)
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserGetMenuItemRect(
HWND hWnd,
HMENU hMenu,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserHiliteMenuItem(
HWND hWnd,
HMENU hMenu,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserMenuInfo(
HMENU hMenu,
PROSMENUINFO UnsafeMenuInfo,
/*
* @implemented
*/
-int STDCALL
+int APIENTRY
NtUserMenuItemFromPoint(
HWND hWnd,
HMENU hMenu,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserMenuItemInfo(
HMENU hMenu,
UINT Item,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserRemoveMenu(
HMENU hMenu,
UINT uPosition,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserSetMenuContextHelpId(
HMENU hMenu,
DWORD dwContextHelpId)
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserSetMenuDefaultItem(
HMENU hMenu,
UINT uItem,
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserSetMenuFlagRtoL(
HMENU hMenu)
{
/*
* @unimplemented
*/
-DWORD STDCALL
+DWORD APIENTRY
NtUserThunkedMenuInfo(
HMENU hMenu,
LPCMENUINFO lpcmi)
/*
* @unimplemented
*/
-DWORD STDCALL
+DWORD APIENTRY
NtUserThunkedMenuItemInfo(
HMENU hMenu,
UINT uItem,
* @implemented
*/
/* NOTE: unused function */
-BOOL STDCALL
+BOOL APIENTRY
NtUserTrackPopupMenuEx(
HMENU hMenu,
UINT fuFlags,
BOOL
-STDCALL
+APIENTRY
NtUserCallMsgFilter(
LPMSG lpmsg,
INT code)
END_CLEANUP;
}
-LRESULT STDCALL
+LRESULT APIENTRY
NtUserDispatchMessage(PNTUSERDISPATCHMESSAGEINFO UnsafeMsgInfo)
{
NTSTATUS Status;
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserTranslateMessage(LPMSG lpMsg,
HKL dwhkl)
{
return Present;
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserPeekMessage(PNTUSERGETMESSAGEINFO UnsafeInfo,
HWND hWnd,
UINT MsgFilterMin,
return FALSE;
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserGetMessage(PNTUSERGETMESSAGEINFO UnsafeInfo,
HWND hWnd,
UINT MsgFilterMin,
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserPostMessage(HWND hWnd,
UINT Msg,
WPARAM wParam,
-BOOL STDCALL
+BOOL APIENTRY
NtUserPostThreadMessage(DWORD idThread,
UINT Msg,
WPARAM wParam,
END_CLEANUP;
}
-DWORD STDCALL
+DWORD APIENTRY
NtUserQuerySendMessage(DWORD Unknown0)
{
UNIMPLEMENTED;
return (LRESULT)Result;
}
-LRESULT STDCALL
+LRESULT APIENTRY
NtUserSendMessageTimeout(HWND hWnd,
UINT Msg,
WPARAM wParam,
END_CLEANUP;
}
-LRESULT STDCALL
+LRESULT APIENTRY
NtUserSendMessage(HWND Wnd,
UINT Msg,
WPARAM wParam,
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserSendNotifyMessage(HWND hWnd,
UINT Msg,
WPARAM wParam,
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserWaitMessage(VOID)
{
DECLARE_RETURN(BOOL);
END_CLEANUP;
}
-DWORD STDCALL
+DWORD APIENTRY
IntGetQueueStatus(BOOL ClearChanges)
{
PTHREADINFO pti;
END_CLEANUP;
}
-BOOL STDCALL
+BOOL APIENTRY
IntInitMessagePumpHook()
{
if (((PTHREADINFO)PsGetCurrentThread()->Tcb.Win32Thread)->ThreadInfo)
return FALSE;
}
-BOOL STDCALL
+BOOL APIENTRY
IntUninitMessagePumpHook()
{
if (((PTHREADINFO)PsGetCurrentThread()->Tcb.Win32Thread)->ThreadInfo)
}
-LRESULT STDCALL
+LRESULT APIENTRY
NtUserMessageCall(
HWND hWnd,
UINT Msg,
#define WAIT_FAILED ((DWORD)0xFFFFFFFF)
DWORD
-NTAPI
+APIENTRY
NtUserWaitForInputIdle(
IN HANDLE hProcess,
IN DWORD dwMilliseconds,
/*
* @unimplemented
*/
-DWORD STDCALL
+DWORD APIENTRY
NtUserGetThreadState(
DWORD Routine)
{
UINT
-STDCALL
+APIENTRY
NtUserGetDoubleClickTime(VOID)
{
UINT Result;
}
BOOL
-STDCALL
+APIENTRY
NtUserGetGUIThreadInfo(
DWORD idThread, /* if NULL use foreground thread */
LPGUITHREADINFO lpgui)
DWORD
-STDCALL
+APIENTRY
NtUserGetGuiResources(
HANDLE hProcess,
DWORD uiFlags)
* The number of monitors which intersect the specified region or -1 on failure.
*/
INT
-STDCALL
+APIENTRY
NtUserEnumDisplayMonitors(
OPTIONAL IN HDC hDC,
OPTIONAL IN LPCRECT pRect,
*
*/
BOOL
-STDCALL
+APIENTRY
NtUserGetMonitorInfo(
IN HMONITOR hMonitor,
OUT LPMONITORINFO pMonitorInfo)
* return value depends on dwFlags
*/
HMONITOR
-STDCALL
+APIENTRY
NtUserMonitorFromPoint(
IN POINT point,
IN DWORD dwFlags)
* return value depends on dwFlags
*/
HMONITOR
-STDCALL
+APIENTRY
NtUserMonitorFromRect(
IN LPCRECT pRect,
IN DWORD dwFlags)
HMONITOR
-STDCALL
+APIENTRY
NtUserMonitorFromWindow(
IN HWND hWnd,
IN DWORD dwFlags)
return Res;
}
-BOOL static STDCALL
+BOOL static APIENTRY
co_MsqTranslateMouseMessage(PUSER_MESSAGE_QUEUE MessageQueue, HWND hWnd, UINT FilterLow, UINT FilterHigh,
PUSER_MESSAGE Message, BOOL Remove, PBOOL Freed,
PWINDOW_OBJECT ScopeWin, PPOINT ScreenPoint, BOOL FromGlobalQueue, PLIST_ENTRY *Next)
return(TRUE);
}
-BOOL STDCALL
+BOOL APIENTRY
co_MsqPeekHardwareMessage(PUSER_MESSAGE_QUEUE MessageQueue, HWND hWnd,
UINT FilterLow, UINT FilterHigh, BOOL Remove,
PUSER_MESSAGE* Message)
return(TRUE);
}
-VOID STDCALL
+VOID APIENTRY
MsqRemoveWindowMessagesFromQueue(PVOID pWindow)
{
PUSER_SENT_MESSAGE SentMessage;
KeSetEvent(MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
}
-BOOLEAN STDCALL
+BOOLEAN APIENTRY
co_MsqFindMessage(IN PUSER_MESSAGE_QUEUE MessageQueue,
IN BOOLEAN Hardware,
IN BOOLEAN Remove,
#include <debug.h>
DWORD
-NTAPI
+APIENTRY
NtUserAssociateInputContext(
DWORD dwUnknown1,
DWORD dwUnknown2,
BOOL
-NTAPI
+APIENTRY
NtUserAttachThreadInput(
IN DWORD idAttach,
IN DWORD idAttachTo,
// Works like BitBlt, http://msdn.microsoft.com/en-us/library/ms532278(VS.85).aspx
//
BOOL
-NTAPI
+APIENTRY
NtUserBitBltSysBmp(
HDC hdc,
INT nXDest,
}
DWORD
-NTAPI
+APIENTRY
NtUserBuildHimcList(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-STDCALL
+APIENTRY
NtUserConvertMemHandle(
DWORD Unknown0,
DWORD Unknown1)
}
DWORD
-STDCALL
+APIENTRY
NtUserCreateLocalMemHandle(
DWORD Unknown0,
DWORD Unknown1,
}
BOOL
-NTAPI
+APIENTRY
NtUserDdeGetQualityOfService(
IN HWND hwndClient,
IN HWND hWndServer,
}
DWORD
-STDCALL
+APIENTRY
NtUserDdeInitialize(
DWORD Unknown0,
DWORD Unknown1,
}
BOOL
-NTAPI
+APIENTRY
NtUserDdeSetQualityOfService(
IN HWND hwndClient,
IN PSECURITY_QUALITY_OF_SERVICE pqosNew,
}
DWORD
-NTAPI
+APIENTRY
NtUserDragObject(
HWND hwnd1,
HWND hwnd2,
}
BOOL
-NTAPI
+APIENTRY
NtUserDrawAnimatedRects(
HWND hwnd,
INT idAni,
}
BOOL
-STDCALL
+APIENTRY
NtUserEnumDisplayDevices (
PUNICODE_STRING lpDevice, /* device name */
DWORD iDevNum, /* display device */
}
DWORD
-STDCALL
+APIENTRY
NtUserEvent(
DWORD Unknown0)
{
}
DWORD
-NTAPI
+APIENTRY
NtUserExcludeUpdateRgn(
HDC hDC,
HWND hWnd)
}
BOOL
-NTAPI
+APIENTRY
NtUserGetAltTabInfo(
HWND hwnd,
INT iItem,
}
HBRUSH
-NTAPI
+APIENTRY
NtUserGetControlBrush(
HWND hwnd,
HDC hdc,
* Called from PaintRect, works almost like wine PaintRect16 but returns hBrush.
*/
HBRUSH
-STDCALL
+APIENTRY
NtUserGetControlColor(
HWND hwndParent,
HWND hwnd,
}
DWORD
-STDCALL
+APIENTRY
NtUserGetCPD(
DWORD Unknown0,
DWORD Unknown1,
}
DWORD
-STDCALL
+APIENTRY
NtUserGetImeHotKey(
DWORD Unknown0,
DWORD Unknown1,
DWORD
-STDCALL
+APIENTRY
NtUserGetMouseMovePointsEx(
UINT cbSize,
LPMOUSEMOVEPOINT lppt,
BOOL
-NTAPI
+APIENTRY
NtUserImpersonateDdeClientWindow(
HWND hWndClient,
HWND hWndServer)
}
NTSTATUS
-STDCALL
+APIENTRY
NtUserInitializeClientPfnArrays(
PPFNCLIENT pfnClientA,
PPFNCLIENT pfnClientW,
}
DWORD
-STDCALL
+APIENTRY
NtUserInitTask(
DWORD Unknown0,
DWORD Unknown1,
}
BOOL
-NTAPI
+APIENTRY
NtUserLockWorkStation(VOID)
{
UNIMPLEMENTED
}
DWORD
-STDCALL
+APIENTRY
NtUserMNDragLeave(VOID)
{
UNIMPLEMENTED
}
DWORD
-STDCALL
+APIENTRY
NtUserMNDragOver(
DWORD Unknown0,
DWORD Unknown1)
}
DWORD
-STDCALL
+APIENTRY
NtUserModifyUserStartupInfoFlags(
DWORD Unknown0,
DWORD Unknown1)
}
DWORD
-STDCALL
+APIENTRY
NtUserNotifyIMEStatus(
DWORD Unknown0,
DWORD Unknown1,
}
DWORD
-STDCALL
+APIENTRY
NtUserQueryUserCounters(
DWORD Unknown0,
DWORD Unknown1,
DWORD
-STDCALL
+APIENTRY
NtUserRegisterTasklist(
DWORD Unknown0)
{
DWORD
-STDCALL
+APIENTRY
NtUserSBGetParms(
DWORD Unknown0,
DWORD Unknown1,
}
DWORD
-STDCALL
+APIENTRY
NtUserSetConsoleReserveKeys(
DWORD Unknown0,
DWORD Unknown1)
}
DWORD
-STDCALL
+APIENTRY
NtUserSetDbgTag(
DWORD Unknown0,
DWORD Unknown1)
}
DWORD
-STDCALL
+APIENTRY
NtUserSetImeHotKey(
DWORD Unknown0,
DWORD Unknown1,
DWORD
-STDCALL
+APIENTRY
NtUserSetRipFlags(
DWORD Unknown0,
DWORD Unknown1)
}
BOOL
-STDCALL
+APIENTRY
NtUserSetSysColors(
int cElements,
IN CONST INT *lpaElements,
}
DWORD
-STDCALL
+APIENTRY
NtUserSetThreadState(
DWORD Unknown0,
DWORD Unknown1)
}
BOOL
-NTAPI
+APIENTRY
NtUserTrackMouseEvent(
LPTRACKMOUSEEVENT lpEventTrack)
{
DWORD
-STDCALL
+APIENTRY
NtUserUpdateInputContext(
DWORD Unknown0,
DWORD Unknown1,
}
DWORD
-STDCALL
+APIENTRY
NtUserUpdateInstance(
DWORD Unknown0,
DWORD Unknown1,
}
BOOL
-NTAPI
+APIENTRY
NtUserUserHandleGrantAccess(
IN HANDLE hUserHandle,
IN HANDLE hJob,
}
DWORD
-STDCALL
+APIENTRY
NtUserWaitForMsgAndEvent(
DWORD Unknown0)
{
}
DWORD
-STDCALL
+APIENTRY
NtUserWin32PoolAllocationStats(
DWORD Unknown0,
DWORD Unknown1,
}
DWORD
-STDCALL
+APIENTRY
NtUserYieldTask(VOID)
{
UNIMPLEMENTED
DWORD
-STDCALL
+APIENTRY
NtUserCheckImeHotKey(
DWORD dwUnknown1,
DWORD dwUnknown2)
}
DWORD
-NTAPI
+APIENTRY
NtUserConsoleControl(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserCreateInputContext(
DWORD dwUnknown1)
{
}
DWORD
-NTAPI
+APIENTRY
NtUserDestroyInputContext(
DWORD dwUnknown1)
{
}
DWORD
-NTAPI
+APIENTRY
NtUserDisableThreadIme(
DWORD dwUnknown1)
{
}
DWORD
-NTAPI
+APIENTRY
NtUserGetAppImeLevel(
DWORD dwUnknown1)
{
}
DWORD
-NTAPI
+APIENTRY
NtUserGetAtomName(
ATOM nAtom,
LPWSTR lpBuffer)
}
DWORD
-NTAPI
+APIENTRY
NtUserGetImeInfoEx(
DWORD dwUnknown1,
DWORD dwUnknown2)
}
DWORD
-NTAPI
+APIENTRY
NtUserGetRawInputBuffer(
PRAWINPUT pData,
PUINT pcbSize,
}
DWORD
-NTAPI
+APIENTRY
NtUserGetRawInputData(
HRAWINPUT hRawInput,
UINT uiCommand,
}
DWORD
-NTAPI
+APIENTRY
NtUserGetRawInputDeviceInfo(
HANDLE hDevice,
UINT uiCommand,
}
DWORD
-NTAPI
+APIENTRY
NtUserGetRawInputDeviceList(
PRAWINPUTDEVICELIST pRawInputDeviceList,
PUINT puiNumDevices,
}
DWORD
-NTAPI
+APIENTRY
NtUserGetRegisteredRawInputDevices(
PRAWINPUTDEVICE pRawInputDevices,
PUINT puiNumDevices,
}
DWORD
-NTAPI
+APIENTRY
NtUserHardErrorControl(
DWORD dwUnknown1,
DWORD dwUnknown2,
Called from win32csr.
*/
NTSTATUS
-NTAPI
+APIENTRY
NtUserInitialize(
DWORD dwWinVersion,
HANDLE hPowerRequestEvent,
}
DWORD
-NTAPI
+APIENTRY
NtUserMinMaximize(
HWND hWnd,
UINT cmd, // Wine SW_ commands
}
DWORD
-NTAPI
+APIENTRY
NtUserNotifyProcessCreate(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
BOOL
-NTAPI
+APIENTRY
NtUserPrintWindow(
HWND hwnd,
HDC hdcBlt,
}
NTSTATUS
-NTAPI
+APIENTRY
NtUserProcessConnect(
HANDLE Process,
PUSERCONNECT pUserConnect,
}
DWORD
-NTAPI
+APIENTRY
NtUserQueryInformationThread(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserQueryInputContext(
DWORD dwUnknown1,
DWORD dwUnknown2)
}
DWORD
-NTAPI
+APIENTRY
NtUserRealInternalGetMessage(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserRealWaitMessageEx(
DWORD dwUnknown1,
DWORD dwUnknown2)
}
DWORD
-NTAPI
+APIENTRY
NtUserRegisterUserApiHook(
DWORD dwUnknown1,
DWORD dwUnknown2)
}
BOOL
-NTAPI
+APIENTRY
NtUserRegisterRawInputDevices(
IN PCRAWINPUTDEVICE pRawInputDevices,
IN UINT uiNumDevices,
}
DWORD
-NTAPI
+APIENTRY
NtUserResolveDesktop(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserSetAppImeLevel(
DWORD dwUnknown1,
DWORD dwUnknown2)
}
DWORD
-NTAPI
+APIENTRY
NtUserSetImeInfoEx(
DWORD dwUnknown1)
{
}
DWORD
-NTAPI
+APIENTRY
NtUserSetInformationProcess(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserSetInformationThread(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserSetThreadLayoutHandles(
DWORD dwUnknown1,
DWORD dwUnknown2)
}
BOOL
-NTAPI
+APIENTRY
NtUserSoundSentry(VOID)
{
UNIMPLEMENTED;
}
DWORD
-NTAPI
+APIENTRY
NtUserTestForInteractiveUser(
DWORD dwUnknown1)
{
/* http://www.cyber-ta.org/releases/malware-analysis/public/SOURCES/b47155634ccb2c30630da7e3666d3d07/b47155634ccb2c30630da7e3666d3d07.trace.html#NtUserGetIconSize */
DWORD
-NTAPI
+APIENTRY
NtUserCalcMenuBar(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserPaintMenuBar(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserUnregisterUserApiHook(VOID)
{
UNIMPLEMENTED;
}
BOOL
-NTAPI
+APIENTRY
NtUserGetLayeredWindowAttributes(
HWND hwnd,
COLORREF *pcrKey,
/* ValidateRect gets redirected to NtUserValidateRect:
http://blog.csdn.net/ntdll/archive/2005/10/19/509299.aspx */
BOOL
-NTAPI
+APIENTRY
NtUserValidateRect(
HWND hWnd,
CONST RECT *lpRect)
}
DWORD
-NTAPI
+APIENTRY
NtUserValidateTimerCallback(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserRemoteConnect(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserRemoteRedrawRectangle(
DWORD dwUnknown1,
DWORD dwUnknown2,
}
DWORD
-NTAPI
+APIENTRY
NtUserRemoteRedrawScreen(VOID)
{
UNIMPLEMENTED;
}
DWORD
-NTAPI
+APIENTRY
NtUserRemoteStopScreenUpdates(VOID)
{
UNIMPLEMENTED;
}
DWORD
-NTAPI
+APIENTRY
NtUserCtxDisplayIOCtl(
DWORD dwUnknown1,
DWORD dwUnknown2,
* @implemented
*/
-HDC STDCALL
+HDC APIENTRY
NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* UnsafePs)
{
PWINDOW_OBJECT Window = NULL;
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserEndPaint(HWND hWnd, CONST PAINTSTRUCT* pUnsafePs)
{
NTSTATUS Status = STATUS_SUCCESS;
* @implemented
*/
-INT STDCALL
+INT APIENTRY
NtUserGetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
{
DECLARE_RETURN(INT);
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
{
PWINDOW_OBJECT Window;
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate,
UINT flags)
{
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
NtUserScrollDC(HDC hDC, INT dx, INT dy, const RECT *prcUnsafeScroll,
const RECT *prcUnsafeClip, HRGN hrgnUpdate, LPRECT prcUnsafeUpdate)
{
* @implemented
*/
-DWORD STDCALL
+DWORD APIENTRY
NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *prcUnsafeScroll,
const RECT *prcUnsafeClip, HRGN hrgnUpdate, LPRECT prcUnsafeUpdate, UINT flags)
{
}
BOOL
-STDCALL
+APIENTRY
NtUserDrawCaptionTemp(
HWND hWnd,
HDC hDC,
}
BOOL
-STDCALL
+APIENTRY
NtUserDrawCaption(HWND hWnd,
HDC hDC,
LPCRECT lpRc,
}
BOOL
-NTAPI
+APIENTRY
NtUserInvalidateRect(
HWND hWnd,
CONST RECT *lpUnsafeRect,
}
BOOL
-NTAPI
+APIENTRY
NtUserInvalidateRgn(
HWND hWnd,
HRGN hRgn,
return(NULL);
}
-NTSTATUS STDCALL
+NTSTATUS APIENTRY
NtUserBuildPropList(HWND hWnd,
LPVOID Buffer,
DWORD BufferSize,
END_CLEANUP;
}
-HANDLE STDCALL
+HANDLE APIENTRY
NtUserRemoveProp(HWND hWnd, ATOM Atom)
{
PWINDOW_OBJECT Window;
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserSetProp(HWND hWnd, ATOM Atom, HANDLE Data)
{
PWINDOW_OBJECT Window;
return FALSE;
}
-BOOL STDCALL
+BOOL APIENTRY
IntEnableScrollBar(BOOL Horz, PSCROLLBARINFO Info, UINT wArrows)
{
BOOL Chg = FALSE;
BOOL
-STDCALL
+APIENTRY
NtUserGetScrollBarInfo(HWND hWnd, LONG idObject, PSCROLLBARINFO psbi)
{
NTSTATUS Status;
BOOL
-STDCALL
+APIENTRY
NtUserGetScrollInfo(HWND hWnd, int fnBar, LPSCROLLINFO lpsi)
{
NTSTATUS Status;
BOOL
-STDCALL
+APIENTRY
NtUserEnableScrollBar(
HWND hWnd,
UINT wSBflags,
}
BOOL
-STDCALL
+APIENTRY
NtUserSetScrollBarInfo(
HWND hWnd,
LONG idObject,
}
DWORD
-STDCALL
+APIENTRY
NtUserSetScrollInfo(
HWND hWnd,
int fnBar,
}
-DWORD STDCALL
+DWORD APIENTRY
NtUserShowScrollBar(HWND hWnd, int wBar, DWORD bShow)
{
PWINDOW_OBJECT Window;
* @unimplemented
*/
DWORD
-STDCALL
+APIENTRY
NtUserCallNoParam(DWORD Routine)
{
DWORD Result = 0;
* @implemented
*/
DWORD
-STDCALL
+APIENTRY
NtUserCallOneParam(
DWORD Param,
DWORD Routine)
* @implemented
*/
DWORD
-STDCALL
+APIENTRY
NtUserCallTwoParam(
DWORD Param1,
DWORD Param2,
* @unimplemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserCallHwndLock(
HWND hWnd,
DWORD Routine)
* @unimplemented
*/
HWND
-STDCALL
+APIENTRY
NtUserCallHwndOpt(
HWND hWnd,
DWORD Routine)
}
DWORD
-STDCALL
+APIENTRY
NtUserCallHwnd(
HWND hWnd,
DWORD Routine)
}
DWORD
-STDCALL
+APIENTRY
NtUserCallHwndParam(
HWND hWnd,
DWORD Param,
}
DWORD
-STDCALL
+APIENTRY
NtUserCallHwndParamLock(
HWND hWnd,
DWORD Param,
* @implemented
*/
BOOL
-STDCALL
+APIENTRY
NtUserSystemParametersInfo(
UINT uiAction,
UINT uiParam,
}
-BOOL STDCALL
+BOOL APIENTRY
NtUserUpdatePerUserSystemParameters(
DWORD dwReserved,
BOOL bEnable)
UINT_PTR
-STDCALL
+APIENTRY
NtUserSetTimer
(
HWND hWnd,
BOOL
-STDCALL
+APIENTRY
NtUserKillTimer
(
HWND hWnd,
UINT_PTR
-STDCALL
+APIENTRY
NtUserSetSystemTimer(
&nb
projects / reactos.git / commitdiff