dlls/user32/driver.c

   1 /*
   2  * USER driver support
   3  *
   4  * Copyright 2000, 2005 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <wchar.h>
  24
  25 #include "user_private.h"
  26 #include "winnls.h"
  27 #include "wine/debug.h"
  28 #include "controls.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(user);
  31
  32 static struct user_driver_funcs null_driver, lazy_load_driver;
  33
  34 const struct user_driver_funcs *USER_Driver = &lazy_load_driver;
  35
  36 /* load the graphics driver */
  37 static const struct user_driver_funcs *load_driver(void)
  38 {
  39     wait_graphics_driver_ready();
  40     if (USER_Driver == &lazy_load_driver)
  41     {
  42         static struct user_driver_funcs empty_funcs;
  43         WARN( "failed to load the display driver, falling back to null driver\n" );
  44         __wine_set_user_driver( &empty_funcs, WINE_GDI_DRIVER_VERSION );
  45     }
  46
  47     return USER_Driver;
  48 }
  49
  50 /* unload the graphics driver on process exit */
  51 void USER_unload_driver(void)
  52 {
  53     struct user_driver_funcs *prev;
  54     __wine_set_display_driver( &null_driver, WINE_GDI_DRIVER_VERSION );
  55     /* make sure we don't try to call the driver after it has been detached */
  56     prev = InterlockedExchangePointer( (void **)&USER_Driver, &null_driver );
  57     if (prev != &lazy_load_driver && prev != &null_driver)
  58         HeapFree( GetProcessHeap(), 0, prev );
  59 }
  60
  61
  62 /**********************************************************************
  63  * Null user driver
  64  *
  65  * These are fallbacks for entry points that are not implemented in the real driver.
  66  */
  67
  68 static BOOL CDECL nulldrv_SetCursorPos( INT x, INT y )
  69 {
  70     return TRUE;
  71 }
  72
  73 static void CDECL nulldrv_UpdateClipboard(void)
  74 {
  75 }
  76
  77 static DWORD CDECL nulldrv_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles, DWORD timeout,
  78                                                         DWORD mask, DWORD flags )
  79 {
  80     if (!count && !timeout) return WAIT_TIMEOUT;
  81     return WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
  82                                      timeout, flags & MWMO_ALERTABLE );
  83 }
  84
  85 static void CDECL nulldrv_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
  86 {
  87 }
  88
  89 static void CDECL nulldrv_SetWindowText( HWND hwnd, LPCWSTR text )
  90 {
  91 }
  92
  93 static LRESULT CDECL nulldrv_SysCommand( HWND hwnd, WPARAM wparam, LPARAM lparam )
  94 {
  95     return -1;
  96 }
  97
  98
  99 /**********************************************************************
 100  * Lazy loading user driver
 101  *
 102  * Initial driver used before another driver is loaded.
 103  * Each entry point simply loads the real driver and chains to it.
 104  */
 105
 106 static BOOL CDECL loaderdrv_SetCursorPos( INT x, INT y )
 107 {
 108     return load_driver()->pSetCursorPos( x, y );
 109 }
 110
 111 static void CDECL loaderdrv_UpdateClipboard(void)
 112 {
 113     load_driver()->pUpdateClipboard();
 114 }
 115
 116 static struct user_driver_funcs lazy_load_driver =
 117 {
 118     { NULL },
 119     /* keyboard functions */
 120     NULL,
 121     NULL,
 122     NULL,
 123     NULL,
 124     NULL,
 125     NULL,
 126     NULL,
 127     NULL,
 128     NULL,
 129     /* cursor/icon functions */
 130     NULL,
 131     NULL,
 132     NULL,
 133     loaderdrv_SetCursorPos,
 134     NULL,
 135     /* clipboard functions */
 136     loaderdrv_UpdateClipboard,
 137     /* display modes */
 138     NULL,
 139     NULL,
 140     NULL,
 141     /* windowing functions */
 142     NULL,
 143     NULL,
 144     NULL,
 145     NULL,
 146     NULL,
 147     nulldrv_MsgWaitForMultipleObjectsEx,
 148     NULL,
 149     NULL,
 150     NULL,
 151     NULL,
 152     NULL,
 153     NULL,
 154     NULL,
 155     nulldrv_SetWindowIcon,
 156     NULL,
 157     nulldrv_SetWindowText,
 158     NULL,
 159     nulldrv_SysCommand,
 160     NULL,
 161     NULL,
 162     NULL,
 163     NULL,
 164     /* system parameters */
 165     NULL,
 166     /* vulkan support */
 167     NULL,
 168     /* opengl support */
 169     NULL,
 170     /* thread management */
 171     NULL,
 172 };
 173
 174 void CDECL __wine_set_user_driver( const struct user_driver_funcs *funcs, UINT version )
 175 {
 176     struct user_driver_funcs *driver, *prev;
 177
 178     if (version != WINE_GDI_DRIVER_VERSION)
 179     {
 180         ERR( "version mismatch, driver wants %u but user32 has %u\n", version, WINE_GDI_DRIVER_VERSION );
 181         return;
 182     }
 183
 184     driver = HeapAlloc( GetProcessHeap(), 0, sizeof(*driver) );
 185     *driver = *funcs;
 186
 187 #define SET_USER_FUNC(name) \
 188     do { if (!driver->p##name) driver->p##name = nulldrv_##name; } while(0)
 189
 190     SET_USER_FUNC(SetCursorPos);
 191     SET_USER_FUNC(UpdateClipboard);
 192     SET_USER_FUNC(MsgWaitForMultipleObjectsEx);
 193     SET_USER_FUNC(SetWindowIcon);
 194     SET_USER_FUNC(SetWindowText);
 195     SET_USER_FUNC(SysCommand);
 196 #undef SET_USER_FUNC
 197
 198     prev = InterlockedCompareExchangePointer( (void **)&USER_Driver, driver, &lazy_load_driver );
 199     if (prev != &lazy_load_driver)
 200     {
 201         /* another thread beat us to it */
 202         HeapFree( GetProcessHeap(), 0, driver );
 203         driver = prev;
 204     }
 205
 206     __wine_set_display_driver( driver, version );
 207 }