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 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  32
  33 static struct user_driver_funcs null_driver, lazy_load_driver;
  34
  35 const struct user_driver_funcs *USER_Driver = &lazy_load_driver;
  36 static char driver_load_error[80];
  37
  38 static BOOL CDECL nodrv_CreateWindow( HWND hwnd );
  39
  40 static BOOL load_desktop_driver( HWND hwnd )
  41 {
  42     BOOL ret = FALSE;
  43     HKEY hkey;
  44     DWORD size;
  45     WCHAR path[MAX_PATH];
  46     WCHAR key[ARRAY_SIZE(L"System\\CurrentControlSet\\Control\\Video\\{}\\0000") + 40];
  47     UINT guid_atom;
  48
  49     USER_CheckNotLock();
  50
  51     strcpy( driver_load_error, "The explorer process failed to start." );  /* default error */
  52     wait_graphics_driver_ready();
  53
  54     guid_atom = HandleToULong( GetPropW( hwnd, L"__wine_display_device_guid" ));
  55     lstrcpyW( key, L"System\\CurrentControlSet\\Control\\Video\\{" );
  56     if (!GlobalGetAtomNameW( guid_atom, key + lstrlenW(key), 40 )) return 0;
  57     lstrcatW( key, L"}\\0000" );
  58     if (RegOpenKeyW( HKEY_LOCAL_MACHINE, key, &hkey )) return 0;
  59     size = sizeof(path);
  60     if (!RegQueryValueExW( hkey, L"GraphicsDriver", NULL, NULL, (BYTE *)path, &size ))
  61     {
  62         if (wcscmp( path, L"null" ))
  63         {
  64             ret = LoadLibraryW( path ) != NULL;
  65             if (!ret) ERR( "failed to load %s\n", debugstr_w(path) );
  66         }
  67         else
  68         {
  69             __wine_set_user_driver( &null_driver, WINE_GDI_DRIVER_VERSION );
  70             ret = TRUE;
  71         }
  72         TRACE( "%s\n", debugstr_w(path) );
  73     }
  74     else
  75     {
  76         size = sizeof(driver_load_error);
  77         RegQueryValueExA( hkey, "DriverError", NULL, NULL, (BYTE *)driver_load_error, &size );
  78     }
  79     RegCloseKey( hkey );
  80     return ret;
  81 }
  82
  83 /* load the graphics driver */
  84 static const struct user_driver_funcs *load_driver(void)
  85 {
  86     struct user_driver_funcs driver;
  87     USEROBJECTFLAGS flags;
  88     HWINSTA winstation;
  89
  90     if (!load_desktop_driver( GetDesktopWindow() ) || USER_Driver == &lazy_load_driver)
  91     {
  92         memset( &driver, 0, sizeof(driver) );
  93         winstation = NtUserGetProcessWindowStation();
  94         if (!NtUserGetObjectInformation( winstation, UOI_FLAGS, &flags, sizeof(flags), NULL )
  95             || (flags.dwFlags & WSF_VISIBLE))
  96             driver.pCreateWindow = nodrv_CreateWindow;
  97
  98         __wine_set_user_driver( &driver, WINE_GDI_DRIVER_VERSION );
  99     }
 100
 101     return USER_Driver;
 102 }
 103
 104 /* unload the graphics driver on process exit */
 105 void USER_unload_driver(void)
 106 {
 107     struct user_driver_funcs *prev;
 108     __wine_set_display_driver( &null_driver, WINE_GDI_DRIVER_VERSION );
 109     /* make sure we don't try to call the driver after it has been detached */
 110     prev = InterlockedExchangePointer( (void **)&USER_Driver, &null_driver );
 111     if (prev != &lazy_load_driver && prev != &null_driver)
 112         HeapFree( GetProcessHeap(), 0, prev );
 113 }
 114
 115
 116 /**********************************************************************
 117  * Null user driver
 118  *
 119  * These are fallbacks for entry points that are not implemented in the real driver.
 120  */
 121
 122 static void CDECL nulldrv_Beep(void)
 123 {
 124 }
 125
 126 static BOOL CDECL nulldrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk )
 127 {
 128     return TRUE;
 129 }
 130
 131 static void CDECL nulldrv_UnregisterHotKey( HWND hwnd, UINT modifiers, UINT vk )
 132 {
 133 }
 134
 135 static void CDECL nulldrv_DestroyCursorIcon( HCURSOR cursor )
 136 {
 137 }
 138
 139 static void CDECL nulldrv_SetCursor( HCURSOR cursor )
 140 {
 141 }
 142
 143 static BOOL CDECL nulldrv_GetCursorPos( LPPOINT pt )
 144 {
 145     return TRUE;
 146 }
 147
 148 static BOOL CDECL nulldrv_SetCursorPos( INT x, INT y )
 149 {
 150     return TRUE;
 151 }
 152
 153 static BOOL CDECL nulldrv_ClipCursor( LPCRECT clip )
 154 {
 155     return TRUE;
 156 }
 157
 158 static void CDECL nulldrv_UpdateClipboard(void)
 159 {
 160 }
 161
 162 static BOOL CDECL nodrv_CreateWindow( HWND hwnd )
 163 {
 164     static int warned;
 165     HWND parent = GetAncestor( hwnd, GA_PARENT );
 166
 167     /* HWND_MESSAGE windows don't need a graphics driver */
 168     if (!parent || parent == get_user_thread_info()->msg_window) return TRUE;
 169     if (warned++) return FALSE;
 170
 171     ERR_(winediag)( "Application tried to create a window, but no driver could be loaded.\n" );
 172     if (driver_load_error[0]) ERR_(winediag)( "%s\n", driver_load_error );
 173     return FALSE;
 174 }
 175
 176 static BOOL CDECL nulldrv_CreateDesktopWindow( HWND hwnd )
 177 {
 178     return TRUE;
 179 }
 180
 181 static BOOL CDECL nulldrv_CreateWindow( HWND hwnd )
 182 {
 183     return TRUE;
 184 }
 185
 186 static void CDECL nulldrv_DestroyWindow( HWND hwnd )
 187 {
 188 }
 189
 190 static void CDECL nulldrv_FlashWindowEx( FLASHWINFO *info )
 191 {
 192 }
 193
 194 static void CDECL nulldrv_GetDC( HDC hdc, HWND hwnd, HWND top_win, const RECT *win_rect,
 195                                  const RECT *top_rect, DWORD flags )
 196 {
 197 }
 198
 199 static DWORD CDECL nulldrv_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles, DWORD timeout,
 200                                                         DWORD mask, DWORD flags )
 201 {
 202     if (!count && !timeout) return WAIT_TIMEOUT;
 203     return WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
 204                                      timeout, flags & MWMO_ALERTABLE );
 205 }
 206
 207 static void CDECL nulldrv_ReleaseDC( HWND hwnd, HDC hdc )
 208 {
 209 }
 210
 211 static void CDECL nulldrv_SetCapture( HWND hwnd, UINT flags )
 212 {
 213 }
 214
 215 static void CDECL nulldrv_SetFocus( HWND hwnd )
 216 {
 217 }
 218
 219 static void CDECL nulldrv_SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
 220 {
 221 }
 222
 223 static void CDECL nulldrv_SetParent( HWND hwnd, HWND parent, HWND old_parent )
 224 {
 225 }
 226
 227 static void CDECL nulldrv_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
 228 {
 229 }
 230
 231 static void CDECL nulldrv_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
 232 {
 233 }
 234
 235 static void CDECL nulldrv_SetWindowStyle( HWND hwnd, INT offset, STYLESTRUCT *style )
 236 {
 237 }
 238
 239 static void CDECL nulldrv_SetWindowText( HWND hwnd, LPCWSTR text )
 240 {
 241 }
 242
 243 static UINT CDECL nulldrv_ShowWindow( HWND hwnd, INT cmd, RECT *rect, UINT swp )
 244 {
 245     return ~0; /* use default implementation */
 246 }
 247
 248 static LRESULT CDECL nulldrv_SysCommand( HWND hwnd, WPARAM wparam, LPARAM lparam )
 249 {
 250     return -1;
 251 }
 252
 253 static BOOL CDECL nulldrv_UpdateLayeredWindow( HWND hwnd, const UPDATELAYEREDWINDOWINFO *info,
 254                                                const RECT *window_rect )
 255 {
 256     return TRUE;
 257 }
 258
 259 static LRESULT CDECL nulldrv_WindowMessage( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 260 {
 261     return 0;
 262 }
 263
 264 static BOOL CDECL nulldrv_WindowPosChanging( HWND hwnd, HWND insert_after, UINT swp_flags,
 265                                              const RECT *window_rect, const RECT *client_rect,
 266                                              RECT *visible_rect, struct window_surface **surface )
 267 {
 268     return FALSE;
 269 }
 270
 271 static void CDECL nulldrv_WindowPosChanged( HWND hwnd, HWND insert_after, UINT swp_flags,
 272                                             const RECT *window_rect, const RECT *client_rect,
 273                                             const RECT *visible_rect, const RECT *valid_rects,
 274                                             struct window_surface *surface )
 275 {
 276 }
 277
 278 static void CDECL nulldrv_ThreadDetach( void )
 279 {
 280 }
 281
 282
 283 /**********************************************************************
 284  * Lazy loading user driver
 285  *
 286  * Initial driver used before another driver is loaded.
 287  * Each entry point simply loads the real driver and chains to it.
 288  */
 289
 290 static void CDECL loaderdrv_Beep(void)
 291 {
 292     load_driver()->pBeep();
 293 }
 294
 295 static BOOL CDECL loaderdrv_RegisterHotKey( HWND hwnd, UINT modifiers, UINT vk )
 296 {
 297     return load_driver()->pRegisterHotKey( hwnd, modifiers, vk );
 298 }
 299
 300 static void CDECL loaderdrv_UnregisterHotKey( HWND hwnd, UINT modifiers, UINT vk )
 301 {
 302     load_driver()->pUnregisterHotKey( hwnd, modifiers, vk );
 303 }
 304
 305 static void CDECL loaderdrv_SetCursor( HCURSOR cursor )
 306 {
 307     load_driver()->pSetCursor( cursor );
 308 }
 309
 310 static BOOL CDECL loaderdrv_GetCursorPos( LPPOINT pt )
 311 {
 312     return load_driver()->pGetCursorPos( pt );
 313 }
 314
 315 static BOOL CDECL loaderdrv_SetCursorPos( INT x, INT y )
 316 {
 317     return load_driver()->pSetCursorPos( x, y );
 318 }
 319
 320 static BOOL CDECL loaderdrv_ClipCursor( LPCRECT clip )
 321 {
 322     return load_driver()->pClipCursor( clip );
 323 }
 324
 325 static void CDECL loaderdrv_UpdateClipboard(void)
 326 {
 327     load_driver()->pUpdateClipboard();
 328 }
 329
 330 static BOOL CDECL loaderdrv_CreateDesktopWindow( HWND hwnd )
 331 {
 332     return load_driver()->pCreateDesktopWindow( hwnd );
 333 }
 334
 335 static BOOL CDECL loaderdrv_CreateWindow( HWND hwnd )
 336 {
 337     return load_driver()->pCreateWindow( hwnd );
 338 }
 339
 340 static void CDECL loaderdrv_FlashWindowEx( FLASHWINFO *info )
 341 {
 342     load_driver()->pFlashWindowEx( info );
 343 }
 344
 345 static void CDECL loaderdrv_GetDC( HDC hdc, HWND hwnd, HWND top_win, const RECT *win_rect,
 346                                    const RECT *top_rect, DWORD flags )
 347 {
 348     load_driver()->pGetDC( hdc, hwnd, top_win, win_rect, top_rect, flags );
 349 }
 350
 351 static void CDECL loaderdrv_SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
 352 {
 353     load_driver()->pSetLayeredWindowAttributes( hwnd, key, alpha, flags );
 354 }
 355
 356 static void CDECL loaderdrv_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
 357 {
 358     load_driver()->pSetWindowRgn( hwnd, hrgn, redraw );
 359 }
 360
 361 static BOOL CDECL loaderdrv_UpdateLayeredWindow( HWND hwnd, const UPDATELAYEREDWINDOWINFO *info,
 362                                                  const RECT *window_rect )
 363 {
 364     return load_driver()->pUpdateLayeredWindow( hwnd, info, window_rect );
 365 }
 366
 367 static struct user_driver_funcs lazy_load_driver =
 368 {
 369     { NULL },
 370     /* keyboard functions */
 371     NULL,
 372     loaderdrv_Beep,
 373     NULL,
 374     NULL,
 375     NULL,
 376     loaderdrv_RegisterHotKey,
 377     NULL,
 378     loaderdrv_UnregisterHotKey,
 379     NULL,
 380     /* cursor/icon functions */
 381     nulldrv_DestroyCursorIcon,
 382     loaderdrv_SetCursor,
 383     loaderdrv_GetCursorPos,
 384     loaderdrv_SetCursorPos,
 385     loaderdrv_ClipCursor,
 386     /* clipboard functions */
 387     loaderdrv_UpdateClipboard,
 388     /* display modes */
 389     NULL,
 390     NULL,
 391     NULL,
 392     /* windowing functions */
 393     loaderdrv_CreateDesktopWindow,
 394     loaderdrv_CreateWindow,
 395     nulldrv_DestroyWindow,
 396     loaderdrv_FlashWindowEx,
 397     loaderdrv_GetDC,
 398     nulldrv_MsgWaitForMultipleObjectsEx,
 399     nulldrv_ReleaseDC,
 400     NULL,
 401     nulldrv_SetCapture,
 402     nulldrv_SetFocus,
 403     loaderdrv_SetLayeredWindowAttributes,
 404     nulldrv_SetParent,
 405     loaderdrv_SetWindowRgn,
 406     nulldrv_SetWindowIcon,
 407     nulldrv_SetWindowStyle,
 408     nulldrv_SetWindowText,
 409     nulldrv_ShowWindow,
 410     nulldrv_SysCommand,
 411     loaderdrv_UpdateLayeredWindow,
 412     nulldrv_WindowMessage,
 413     nulldrv_WindowPosChanging,
 414     nulldrv_WindowPosChanged,
 415     /* system parameters */
 416     NULL,
 417     /* vulkan support */
 418     NULL,
 419     /* thread management */
 420     nulldrv_ThreadDetach
 421 };
 422
 423 void CDECL __wine_set_user_driver( const struct user_driver_funcs *funcs, UINT version )
 424 {
 425     struct user_driver_funcs *driver, *prev;
 426
 427     if (version != WINE_GDI_DRIVER_VERSION)
 428     {
 429         ERR( "version mismatch, driver wants %u but user32 has %u\n", version, WINE_GDI_DRIVER_VERSION );
 430         return;
 431     }
 432
 433     driver = HeapAlloc( GetProcessHeap(), 0, sizeof(*driver) );
 434     *driver = *funcs;
 435
 436 #define SET_USER_FUNC(name) \
 437     do { if (!driver->p##name) driver->p##name = nulldrv_##name; } while(0)
 438
 439     SET_USER_FUNC(Beep);
 440     SET_USER_FUNC(RegisterHotKey);
 441     SET_USER_FUNC(UnregisterHotKey);
 442     SET_USER_FUNC(DestroyCursorIcon);
 443     SET_USER_FUNC(SetCursor);
 444     SET_USER_FUNC(GetCursorPos);
 445     SET_USER_FUNC(SetCursorPos);
 446     SET_USER_FUNC(ClipCursor);
 447     SET_USER_FUNC(UpdateClipboard);
 448     SET_USER_FUNC(CreateDesktopWindow);
 449     SET_USER_FUNC(CreateWindow);
 450     SET_USER_FUNC(DestroyWindow);
 451     SET_USER_FUNC(FlashWindowEx);
 452     SET_USER_FUNC(GetDC);
 453     SET_USER_FUNC(MsgWaitForMultipleObjectsEx);
 454     SET_USER_FUNC(ReleaseDC);
 455     SET_USER_FUNC(SetCapture);
 456     SET_USER_FUNC(SetFocus);
 457     SET_USER_FUNC(SetLayeredWindowAttributes);
 458     SET_USER_FUNC(SetParent);
 459     SET_USER_FUNC(SetWindowRgn);
 460     SET_USER_FUNC(SetWindowIcon);
 461     SET_USER_FUNC(SetWindowStyle);
 462     SET_USER_FUNC(SetWindowText);
 463     SET_USER_FUNC(ShowWindow);
 464     SET_USER_FUNC(SysCommand);
 465     SET_USER_FUNC(UpdateLayeredWindow);
 466     SET_USER_FUNC(WindowMessage);
 467     SET_USER_FUNC(WindowPosChanging);
 468     SET_USER_FUNC(WindowPosChanged);
 469     SET_USER_FUNC(ThreadDetach);
 470 #undef SET_USER_FUNC
 471
 472     prev = InterlockedCompareExchangePointer( (void **)&USER_Driver, driver, &lazy_load_driver );
 473     if (prev != &lazy_load_driver)
 474     {
 475         /* another thread beat us to it */
 476         HeapFree( GetProcessHeap(), 0, driver );
 477         driver = prev;
 478     }
 479
 480     __wine_set_display_driver( driver, version );
 481 }