stubs.c

Go to the documentation of this file.

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS user32.dll
 * FILE:            win32ss/user/user32/misc/stubs.c
 * PURPOSE:         User32.dll stubs
 * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
 * NOTES:           If you implement a function, remove it from this file
 * UPDATE HISTORY:
 *      08-F05-2001  CSH  Created
 */
 
#include <user32.h>
 
WINE_DEFAULT_DEBUG_CHANNEL(user32);
 
/*
 * @unimplemented
 */
DWORD
WINAPI
WaitForInputIdle(
  HANDLE hProcess,
  DWORD dwMilliseconds)
{
// Need to call NtQueryInformationProcess and send ProcessId not hProcess.
  return NtUserWaitForInputIdle(hProcess, dwMilliseconds, FALSE);
}
 
/******************************************************************************
 * SetDebugErrorLevel [USER32.@]
 * Sets the minimum error level for generating debugging events
 *
 * PARAMS
 *    dwLevel [I] Debugging error level
 *
 * @unimplemented
 */
VOID
WINAPI
SetDebugErrorLevel( DWORD dwLevel )
{
    FIXME("(%lu): stub\n", dwLevel);
}
 
 
/*
 * @implemented
 */
DWORD
WINAPI
GetAppCompatFlags(HTASK hTask)
{
    PCLIENTINFO pci = GetWin32ClientInfo();
 
    return pci->dwCompatFlags;
}
 
/*
 * @implemented
 */
DWORD
WINAPI
GetAppCompatFlags2(HTASK hTask)
{
    PCLIENTINFO pci = GetWin32ClientInfo();
 
    return pci->dwCompatFlags2;
}
 
/*
 * @unimplemented
 */
VOID
WINAPI
LoadLocalFonts ( VOID )
{
  UNIMPLEMENTED;
}
 
/*
 * @unimplemented
 */
VOID
WINAPI
LoadRemoteFonts ( VOID )
{
  UNIMPLEMENTED;
}
 
/*
 * @unimplemented
 */
VOID
WINAPI
RegisterSystemThread ( DWORD flags, DWORD reserved )
{
  UNIMPLEMENTED;
}
 
 
/*
 * @implemented
 */
UINT
WINAPI
UserRealizePalette ( HDC hDC )
{
  return NtUserxRealizePalette(hDC);
}
 
 
/*************************************************************************
 *      SetSysColorsTemp (USER32.@) (Wine 10/22/2008)
 *
 * UNDOCUMENTED !!
 *
 * Called by W98SE desk.cpl Control Panel Applet:
 * handle = SetSysColorsTemp(ptr, ptr, nCount);     ("set" call)
 * result = SetSysColorsTemp(NULL, NULL, handle);   ("restore" call)
 *
 * pPens is an array of COLORREF values, which seems to be used
 * to indicate the color values to create new pens with.
 *
 * pBrushes is an array of solid brush handles (returned by a previous
 * CreateSolidBrush), which seems to contain the brush handles to set
 * for the system colors.
 *
 * n seems to be used for
 *   a) indicating the number of entries to operate on (length of pPens,
 *      pBrushes)
 *   b) passing the handle that points to the previously used color settings.
 *      I couldn't figure out in hell what kind of handle this is on
 *      Windows. I just use a heap handle instead. Shouldn't matter anyway.
 *
 * RETURNS
 *     heap handle of our own copy of the current syscolors in case of
 *                 "set" call, i.e. pPens, pBrushes != NULL.
 *     TRUE (unconditionally !) in case of "restore" call,
 *          i.e. pPens, pBrushes == NULL.
 *     FALSE in case of either pPens != NULL and pBrushes == NULL
 *          or pPens == NULL and pBrushes != NULL.
 *
 * I'm not sure whether this implementation is 100% correct. [AM]
 */
 
static HPEN SysColorPens[COLOR_MENUBAR + 1];
static HBRUSH SysColorBrushes[COLOR_MENUBAR + 1];
 
DWORD_PTR
WINAPI
SetSysColorsTemp(const COLORREF *pPens,
                 const HBRUSH *pBrushes,
                 DWORD_PTR n)
{
    DWORD i;
 
    if (pPens && pBrushes) /* "set" call */
    {
        /* allocate our structure to remember old colors */
        LPVOID pOldCol = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)+n*sizeof(HPEN)+n*sizeof(HBRUSH));
        LPVOID p = pOldCol;
        *(DWORD_PTR *)p = n; p = (char*)p + sizeof(DWORD);
        memcpy(p, SysColorPens, n*sizeof(HPEN)); p = (char*)p + n*sizeof(HPEN);
        memcpy(p, SysColorBrushes, n*sizeof(HBRUSH)); p = (char*)p + n*sizeof(HBRUSH);
 
        for (i=0; i < n; i++)
        {
            SysColorPens[i] = CreatePen( PS_SOLID, 1, pPens[i] );
            SysColorBrushes[i] = pBrushes[i];
        }
 
        return (DWORD_PTR) pOldCol;
    }
    if (!pPens && !pBrushes) /* "restore" call */
    {
        LPVOID pOldCol = (LPVOID)n;
        LPVOID p = pOldCol;
        DWORD nCount = *(DWORD *)p;
        p = (char*)p + sizeof(DWORD);
 
        for (i=0; i < nCount; i++)
        {
            DeleteObject(SysColorPens[i]);
            SysColorPens[i] = *(HPEN *)p; p = (char*)p + sizeof(HPEN);
        }
        for (i=0; i < nCount; i++)
        {
            SysColorBrushes[i] = *(HBRUSH *)p; p = (char*)p + sizeof(HBRUSH);
        }
        /* get rid of storage structure */
        HeapFree(GetProcessHeap(), 0, pOldCol);
 
        return TRUE;
    }
    return FALSE;
}
 
/*
 * @unimplemented
 */
HDESK
WINAPI
GetInputDesktop ( VOID )
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
BOOL
WINAPI
GetAccCursorInfo ( PCURSORINFO pci )
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
LONG
WINAPI
CsrBroadcastSystemMessageExW(
    DWORD dwflags,
    LPDWORD lpdwRecipients,
    UINT uiMessage,
    WPARAM wParam,
    LPARAM lParam,
    PBSMINFO pBSMInfo)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @implemented
 */
UINT
WINAPI
GetRawInputDeviceInfoA(
    _In_opt_ HANDLE hDevice,
    _In_ UINT uiCommand,
    _Inout_opt_ LPVOID pData,
    _Inout_ PUINT pcbSize)
{
    UINT Ret;
    LPVOID pDataW = pData;
    UINT cbSize = *pcbSize;
 
    if (uiCommand == RIDI_DEVICENAME && pData)
    {
        pDataW = HeapAlloc(GetProcessHeap(), 0, cbSize * sizeof(WCHAR));
        if (!pDataW)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return (UINT)-1;
        }
    }
 
    Ret = NtUserGetRawInputDeviceInfo(hDevice, uiCommand, pDataW, &cbSize);
    if (Ret >= 0 && uiCommand == RIDI_DEVICENAME && pDataW)
    {
        if (WideCharToMultiByte(CP_THREAD_ACP, 0, pDataW, cbSize, pData, *pcbSize, NULL, NULL) == 0)
            Ret = (UINT)-1;
    }
    if (pData != pDataW)
        HeapFree(GetProcessHeap(), 0, pDataW);
    *pcbSize = cbSize;
    return Ret;
}
 
/*
 * @unimplemented
 */
BOOL
WINAPI
AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @implemented
 */
LRESULT
WINAPI
DefRawInputProc(
    PRAWINPUT* paRawInput,
    INT nInput,
    UINT cbSizeHeader)
{
  if (cbSizeHeader == sizeof(RAWINPUTHEADER))
     return S_OK;
  return 1;
}
 
/*
 * @implemented
 */
UINT
WINAPI
DECLSPEC_HOTPATCH
GetRawInputBuffer(
    _In_opt_ PRAWINPUT pData,
    _Inout_ PUINT pcbSize,
    _In_ UINT cbSizeHeader)
{
    PCLIENTTHREADINFO pcti = GetWin32ClientInfo()->pClientThreadInfo;
 
    if (!pcbSize || cbSizeHeader != sizeof(RAWINPUTHEADER))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return (UINT)-1;
    }
 
    if (!pcti || !(pcti->fsWakeBits & QS_RAWINPUT))
    {
        *pcbSize = 0;
        return 0;
    }
 
    return NtUserGetRawInputBuffer(pData, pcbSize, cbSizeHeader);
}
 
/*
 * @unimplemented
 */
BOOL WINAPI DisplayExitWindowsWarnings(ULONG flags)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
BOOL WINAPI ReasonCodeNeedsBugID(ULONG reasoncode)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
BOOL WINAPI ReasonCodeNeedsComment(ULONG reasoncode)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
BOOL WINAPI CtxInitUser32(VOID)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
BOOL WINAPI EnterReaderModeHelper(HWND hwnd)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
VOID WINAPI InitializeLpkHooks(FARPROC *hookfuncs)
{
  UNIMPLEMENTED;
}
 
/*
 * @unimplemented
 */
WORD WINAPI InitializeWin32EntryTable(UCHAR* EntryTablePlus0x1000)
{
  UNIMPLEMENTED;
  return FALSE;
}
 
/*
 * @unimplemented
 */
VOID WINAPI AllowForegroundActivation(VOID)
{
  UNIMPLEMENTED;
}
 
/*
 * @unimplemented
 */
VOID WINAPI ShowStartGlass(DWORD unknown)
{
  UNIMPLEMENTED;
}
 
/*
 * @implemented
 */
DWORD WINAPI GetMenuIndex(HMENU hMenu, HMENU hSubMenu)
{
  return NtUserGetMenuIndex(hMenu, hSubMenu);
}
 
/*
 * @unimplemented
 */
DWORD WINAPI UserRegisterWowHandlers(PVOID Unknown1, PVOID Unknown2)
{
  UNIMPLEMENTED;
  return 0;
}
 
BOOL
WINAPI
BuildReasonArray(PVOID Pointer)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
VOID
WINAPI
CreateSystemThreads(DWORD Unused)
{
    /* Thread call for remote processes (non-CSRSS) only */
    NtUserxCreateSystemThreads(TRUE);
    ExitThread(0);
}
 
BOOL
WINAPI
DestroyReasons(PVOID Pointer)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
NTSTATUS
WINAPI
DeviceEventWorker(HWND hwnd, WPARAM wParam, LPARAM lParam, DWORD Data, ULONG_PTR *uResult)
{
    USER_API_MESSAGE ApiMessage;
    PUSER_DEVICE_EVENT_MSG pusem = &ApiMessage.Data.DeviceEventMsg;
 
    pusem->hwnd = hwnd;
    pusem->wParam = wParam;
    pusem->lParam = lParam;
    pusem->Data = Data;
    pusem->Result = 0;
 
    TRACE("DeviceEventWorker : hwnd %p, wParam %d, lParam %d, Data %d, uResult %p\n", hwnd, wParam, lParam, Data, uResult);
 
    if ( lParam == 0 )
    {
        CsrClientCallServer( (PCSR_API_MESSAGE)&ApiMessage,
                              NULL,
                              CSR_CREATE_API_NUMBER( USERSRV_SERVERDLL_INDEX, UserpDeviceEvent ),
                              sizeof(*pusem) );
    }
    else
    {
        PCSR_CAPTURE_BUFFER pcsrcb = NULL;
        PDEV_BROADCAST_HDR pdev_br = (PDEV_BROADCAST_HDR)lParam;
        ULONG BufferSize = pdev_br->dbch_size;
 
        pcsrcb = CsrAllocateCaptureBuffer( 1, BufferSize );
 
        if ( !pcsrcb )
        {
            return STATUS_NO_MEMORY;
        }
 
        CsrCaptureMessageBuffer( pcsrcb, (PVOID)lParam, BufferSize, (PVOID*)&pusem->lParam );
 
        CsrClientCallServer( (PCSR_API_MESSAGE)&ApiMessage,
                              pcsrcb,
                              CSR_CREATE_API_NUMBER( USERSRV_SERVERDLL_INDEX, UserpDeviceEvent ),
                              sizeof(*pusem) );
 
        CsrFreeCaptureBuffer( pcsrcb );
    }
 
    if (NT_SUCCESS(ApiMessage.Status))
    {
        *uResult = pusem->Result;
    }
 
    return ApiMessage.Status;
}
 
BOOL
WINAPI
GetReasonTitleFromReasonCode(DWORD dw1, DWORD dw2, DWORD dw3)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
BOOL
WINAPI
IsSETEnabled(VOID)
{
    /*
     * Determines whether the Shutdown Event Tracker is enabled.
     *
     * See http://undoc.airesoft.co.uk/user32.dll/IsSETEnabled.php
     * for more information.
     */
    UNIMPLEMENTED;
    return FALSE;
}
 
BOOL
WINAPI
RecordShutdownReason(DWORD dw0)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
BOOL
WINAPI
UserLpkTabbedTextOut(
    DWORD dw1,
    DWORD dw2,
    DWORD dw3,
    DWORD dw4,
    DWORD dw5,
    DWORD dw6,
    DWORD dw7,
    DWORD dw8,
    DWORD dw9,
    DWORD dw10,
    DWORD dw11,
    DWORD dw12)
{
    UNIMPLEMENTED;
    return FALSE;
}
 
BOOL
WINAPI
Win32PoolAllocationStats(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
{
    UNIMPLEMENTED;
    return FALSE;
}