dlls/user/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 "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "wine/debug.h"
  27
  28 #include "user_private.h"
  29
  30 static const USER_DRIVER null_driver, lazy_load_driver;
  31
  32 const USER_DRIVER *USER_Driver = &lazy_load_driver;
  33 static DWORD driver_load_error;
  34
  35 /* load the graphics driver */
  36 static const USER_DRIVER *load_driver(void)
  37 {
  38     char buffer[MAX_PATH], libname[32], *name, *next;
  39     HKEY hkey;
  40     void *ptr;
  41     HMODULE graphics_driver;
  42     USER_DRIVER *driver, *prev;
  43
  44     strcpy( buffer, "x11" );  /* default value */
  45     /* @@ Wine registry key: HKCU\Software\Wine\Drivers */
  46     if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Drivers", &hkey ))
  47     {
  48         DWORD type, count = sizeof(buffer);
  49         RegQueryValueExA( hkey, "Graphics", 0, &type, (LPBYTE) buffer, &count );
  50         RegCloseKey( hkey );
  51     }
  52
  53     name = buffer;
  54     while (name)
  55     {
  56         next = strchr( name, ',' );
  57         if (next) *next++ = 0;
  58
  59         snprintf( libname, sizeof(libname), "wine%s.drv", name );
  60         if ((graphics_driver = LoadLibraryA( libname )) != 0) break;
  61         name = next;
  62     }
  63
  64     if (!graphics_driver)
  65         driver_load_error = GetLastError();
  66
  67     driver = HeapAlloc( GetProcessHeap(), 0, sizeof(*driver) );
  68     memcpy( driver, &null_driver, sizeof(*driver) );
  69
  70     if (graphics_driver)
  71     {
  72 #define GET_USER_FUNC(name) \
  73     do { if ((ptr = GetProcAddress( graphics_driver, #name ))) driver->p##name = ptr; } while(0)
  74
  75         GET_USER_FUNC(ActivateKeyboardLayout);
  76         GET_USER_FUNC(Beep);
  77         GET_USER_FUNC(GetAsyncKeyState);
  78         GET_USER_FUNC(GetKeyNameText);
  79         GET_USER_FUNC(GetKeyboardLayout);
  80         GET_USER_FUNC(GetKeyboardLayoutList);
  81         GET_USER_FUNC(GetKeyboardLayoutName);
  82         GET_USER_FUNC(LoadKeyboardLayout);
  83         GET_USER_FUNC(MapVirtualKeyEx);
  84         GET_USER_FUNC(SendInput);
  85         GET_USER_FUNC(ToUnicodeEx);
  86         GET_USER_FUNC(UnloadKeyboardLayout);
  87         GET_USER_FUNC(VkKeyScanEx);
  88         GET_USER_FUNC(SetCursor);
  89         GET_USER_FUNC(GetCursorPos);
  90         GET_USER_FUNC(SetCursorPos);
  91         GET_USER_FUNC(GetScreenSaveActive);
  92         GET_USER_FUNC(SetScreenSaveActive);
  93         GET_USER_FUNC(AcquireClipboard);
  94         GET_USER_FUNC(EmptyClipboard);
  95         GET_USER_FUNC(SetClipboardData);
  96         GET_USER_FUNC(GetClipboardData);
  97         GET_USER_FUNC(CountClipboardFormats);
  98         GET_USER_FUNC(EnumClipboardFormats);
  99         GET_USER_FUNC(IsClipboardFormatAvailable);
 100         GET_USER_FUNC(RegisterClipboardFormat);
 101         GET_USER_FUNC(GetClipboardFormatName);
 102         GET_USER_FUNC(EndClipboardUpdate);
 103         GET_USER_FUNC(ChangeDisplaySettingsEx);
 104         GET_USER_FUNC(EnumDisplaySettingsEx);
 105         GET_USER_FUNC(CreateDesktopWindow);
 106         GET_USER_FUNC(CreateWindow);
 107         GET_USER_FUNC(DestroyWindow);
 108         GET_USER_FUNC(GetDCEx);
 109         GET_USER_FUNC(MsgWaitForMultipleObjectsEx);
 110         GET_USER_FUNC(ReleaseDC);
 111         GET_USER_FUNC(ScrollDC);
 112         GET_USER_FUNC(SetFocus);
 113         GET_USER_FUNC(SetParent);
 114         GET_USER_FUNC(SetWindowPos);
 115         GET_USER_FUNC(SetWindowRgn);
 116         GET_USER_FUNC(SetWindowIcon);
 117         GET_USER_FUNC(SetWindowStyle);
 118         GET_USER_FUNC(SetWindowText);
 119         GET_USER_FUNC(ShowWindow);
 120         GET_USER_FUNC(SysCommandSizeMove);
 121         GET_USER_FUNC(WindowFromDC);
 122         GET_USER_FUNC(WindowMessage);
 123 #undef GET_USER_FUNC
 124     }
 125
 126     prev = InterlockedCompareExchangePointer( (void **)&USER_Driver, driver, (void *)&lazy_load_driver );
 127     if (prev != &lazy_load_driver)
 128     {
 129         /* another thread beat us to it */
 130         HeapFree( GetProcessHeap(), 0, driver );
 131         FreeLibrary( graphics_driver );
 132         driver = prev;
 133     }
 134     return driver;
 135 }
 136
 137 /* unload the graphics driver on process exit */
 138 void USER_unload_driver(void)
 139 {
 140     /* make sure we don't try to call the driver after it has been detached */
 141     USER_Driver = &null_driver;
 142 }
 143
 144
 145 /**********************************************************************
 146  * Null user driver
 147  *
 148  * These are fallbacks for entry points that are not implemented in the real driver.
 149  */
 150
 151 static HKL nulldrv_ActivateKeyboardLayout( HKL layout, UINT flags )
 152 {
 153     return 0;
 154 }
 155
 156 static void nulldrv_Beep(void)
 157 {
 158 }
 159
 160 static SHORT nulldrv_GetAsyncKeyState( INT key )
 161 {
 162     return 0;
 163 }
 164
 165 static INT nulldrv_GetKeyNameText( LONG lparam, LPWSTR buffer, INT size )
 166 {
 167     return 0;
 168 }
 169
 170 static HKL nulldrv_GetKeyboardLayout( DWORD layout )
 171 {
 172     return 0;
 173 }
 174
 175 static UINT nulldrv_GetKeyboardLayoutList( INT count, HKL *layouts )
 176 {
 177     return 0;
 178 }
 179
 180 static BOOL nulldrv_GetKeyboardLayoutName( LPWSTR name )
 181 {
 182     return FALSE;
 183 }
 184
 185 static HKL nulldrv_LoadKeyboardLayout( LPCWSTR name, UINT flags )
 186 {
 187     return 0;
 188 }
 189
 190 static UINT nulldrv_MapVirtualKeyEx( UINT code, UINT type, HKL layout )
 191 {
 192     return 0;
 193 }
 194
 195 static UINT nulldrv_SendInput( UINT count, LPINPUT inputs, int size )
 196 {
 197     return 0;
 198 }
 199
 200 static INT nulldrv_ToUnicodeEx( UINT virt, UINT scan, LPBYTE state, LPWSTR str,
 201                                 int size, UINT flags, HKL layout )
 202 {
 203     return 0;
 204 }
 205
 206 static BOOL nulldrv_UnloadKeyboardLayout( HKL layout )
 207 {
 208     return 0;
 209 }
 210
 211 static SHORT nulldrv_VkKeyScanEx( WCHAR ch, HKL layout )
 212 {
 213     return -1;
 214 }
 215
 216 static void nulldrv_SetCursor( struct tagCURSORICONINFO *info )
 217 {
 218 }
 219
 220 static BOOL nulldrv_GetCursorPos( LPPOINT pt )
 221 {
 222     return FALSE;
 223 }
 224
 225 static BOOL nulldrv_SetCursorPos( INT x, INT y )
 226 {
 227     return FALSE;
 228 }
 229
 230 static BOOL nulldrv_GetScreenSaveActive(void)
 231 {
 232     return FALSE;
 233 }
 234
 235 static void nulldrv_SetScreenSaveActive( BOOL on )
 236 {
 237 }
 238
 239 static INT nulldrv_AcquireClipboard( HWND hwnd )
 240 {
 241     return 0;
 242 }
 243
 244 static BOOL nulldrv_CountClipboardFormats(void)
 245 {
 246     return 0;
 247 }
 248
 249 static void nulldrv_EmptyClipboard( BOOL keepunowned )
 250 {
 251 }
 252
 253 static void nulldrv_EndClipboardUpdate(void)
 254 {
 255 }
 256
 257 static UINT nulldrv_EnumClipboardFormats( UINT format )
 258 {
 259     return 0;
 260 }
 261
 262 static BOOL nulldrv_GetClipboardData( UINT format, HANDLE16 *h16, HANDLE *h32 )
 263 {
 264     return FALSE;
 265 }
 266
 267 static INT nulldrv_GetClipboardFormatName( UINT format, LPWSTR buffer, UINT len )
 268 {
 269     return FALSE;
 270 }
 271
 272 static BOOL nulldrv_IsClipboardFormatAvailable( UINT format )
 273 {
 274     return FALSE;
 275 }
 276
 277 static UINT nulldrv_RegisterClipboardFormat( LPCWSTR name )
 278 {
 279     return 0;
 280 }
 281
 282 static BOOL nulldrv_SetClipboardData( UINT format, HANDLE16 h16, HANDLE h32, BOOL owner )
 283 {
 284     return FALSE;
 285 }
 286
 287 static LONG nulldrv_ChangeDisplaySettingsEx( LPCWSTR name, LPDEVMODEW mode, HWND hwnd,
 288                                              DWORD flags, LPVOID lparam )
 289 {
 290     return DISP_CHANGE_FAILED;
 291 }
 292
 293 static BOOL nulldrv_EnumDisplaySettingsEx( LPCWSTR name, DWORD num, LPDEVMODEW mode, DWORD flags )
 294 {
 295     return FALSE;
 296 }
 297
 298 static BOOL nulldrv_CreateDesktopWindow( HWND hwnd )
 299 {
 300     return TRUE;
 301 }
 302
 303 static BOOL nulldrv_CreateWindow( HWND hwnd, CREATESTRUCTA *cs, BOOL unicode )
 304 {
 305     static int warned;
 306     if (warned++)
 307         return FALSE;
 308
 309     MESSAGE( "Application tried to create a window, but no driver could be loaded.\n");
 310     switch (driver_load_error)
 311     {
 312     case ERROR_MOD_NOT_FOUND:
 313         MESSAGE( "The X11 driver is missing.  Check your build!\n" );
 314         break;
 315     case ERROR_DLL_INIT_FAILED:
 316         MESSAGE( "Make sure that your X server is running and that $DISPLAY is set correctly.\n" );
 317         break;
 318     default:
 319         MESSAGE( "Unknown error (%d).\n", driver_load_error );
 320     }
 321
 322     return FALSE;
 323 }
 324
 325 static void nulldrv_DestroyWindow( HWND hwnd )
 326 {
 327 }
 328
 329 static HDC nulldrv_GetDCEx( HWND hwnd, HRGN hrgn, DWORD flags )
 330 {
 331     return 0;
 332 }
 333
 334 static DWORD nulldrv_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles, DWORD timeout,
 335                                                   DWORD mask, DWORD flags )
 336 {
 337     return WaitForMultipleObjectsEx( count, handles, flags & MWMO_WAITALL,
 338                                      timeout, flags & MWMO_ALERTABLE );
 339 }
 340
 341 static INT nulldrv_ReleaseDC( HWND hwnd, HDC hdc, BOOL end_paint )
 342 {
 343     return 0;
 344 }
 345
 346 static BOOL nulldrv_ScrollDC( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip,
 347                               HRGN hrgn, LPRECT update )
 348 {
 349     return FALSE;
 350 }
 351
 352 static void nulldrv_SetFocus( HWND hwnd )
 353 {
 354 }
 355
 356 static HWND nulldrv_SetParent( HWND hwnd, HWND parent )
 357 {
 358     return 0;
 359 }
 360
 361 static BOOL nulldrv_SetWindowPos( WINDOWPOS *pos )
 362 {
 363     return FALSE;
 364 }
 365
 366 static int nulldrv_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
 367 {
 368     return 1;
 369 }
 370
 371 static void nulldrv_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
 372 {
 373 }
 374
 375 static void nulldrv_SetWindowStyle( HWND hwnd, DWORD old_style )
 376 {
 377 }
 378
 379 static void nulldrv_SetWindowText( HWND hwnd, LPCWSTR text )
 380 {
 381 }
 382
 383 static BOOL nulldrv_ShowWindow( HWND hwnd, INT cmd )
 384 {
 385     return FALSE;
 386 }
 387
 388 static void nulldrv_SysCommandSizeMove( HWND hwnd, WPARAM wparam )
 389 {
 390 }
 391
 392 static HWND nulldrv_WindowFromDC( HDC hdc )
 393 {
 394     return 0;
 395 }
 396
 397 static LRESULT nulldrv_WindowMessage( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 398 {
 399     return 0;
 400 }
 401
 402 static const USER_DRIVER null_driver =
 403 {
 404     /* keyboard functions */
 405     nulldrv_ActivateKeyboardLayout,
 406     nulldrv_Beep,
 407     nulldrv_GetAsyncKeyState,
 408     nulldrv_GetKeyNameText,
 409     nulldrv_GetKeyboardLayout,
 410     nulldrv_GetKeyboardLayoutList,
 411     nulldrv_GetKeyboardLayoutName,
 412     nulldrv_LoadKeyboardLayout,
 413     nulldrv_MapVirtualKeyEx,
 414     nulldrv_SendInput,
 415     nulldrv_ToUnicodeEx,
 416     nulldrv_UnloadKeyboardLayout,
 417     nulldrv_VkKeyScanEx,
 418     /* mouse functions */
 419     nulldrv_SetCursor,
 420     nulldrv_GetCursorPos,
 421     nulldrv_SetCursorPos,
 422     /* screen saver functions */
 423     nulldrv_GetScreenSaveActive,
 424     nulldrv_SetScreenSaveActive,
 425     /* clipboard functions */
 426     nulldrv_AcquireClipboard,
 427     nulldrv_CountClipboardFormats,
 428     nulldrv_EmptyClipboard,
 429     nulldrv_EndClipboardUpdate,
 430     nulldrv_EnumClipboardFormats,
 431     nulldrv_GetClipboardData,
 432     nulldrv_GetClipboardFormatName,
 433     nulldrv_IsClipboardFormatAvailable,
 434     nulldrv_RegisterClipboardFormat,
 435     nulldrv_SetClipboardData,
 436     /* display modes */
 437     nulldrv_ChangeDisplaySettingsEx,
 438     nulldrv_EnumDisplaySettingsEx,
 439     /* windowing functions */
 440     nulldrv_CreateDesktopWindow,
 441     nulldrv_CreateWindow,
 442     nulldrv_DestroyWindow,
 443     nulldrv_GetDCEx,
 444     nulldrv_MsgWaitForMultipleObjectsEx,
 445     nulldrv_ReleaseDC,
 446     nulldrv_ScrollDC,
 447     nulldrv_SetFocus,
 448     nulldrv_SetParent,
 449     nulldrv_SetWindowPos,
 450     nulldrv_SetWindowRgn,
 451     nulldrv_SetWindowIcon,
 452     nulldrv_SetWindowStyle,
 453     nulldrv_SetWindowText,
 454     nulldrv_ShowWindow,
 455     nulldrv_SysCommandSizeMove,
 456     nulldrv_WindowFromDC,
 457     nulldrv_WindowMessage
 458 };
 459
 460
 461 /**********************************************************************
 462  * Lazy loading user driver
 463  *
 464  * Initial driver used before another driver is loaded.
 465  * Each entry point simply loads the real driver and chains to it.
 466  */
 467
 468 static HKL loaderdrv_ActivateKeyboardLayout( HKL layout, UINT flags )
 469 {
 470     return load_driver()->pActivateKeyboardLayout( layout, flags );
 471 }
 472
 473 static void loaderdrv_Beep(void)
 474 {
 475     load_driver()->pBeep();
 476 }
 477
 478 static SHORT loaderdrv_GetAsyncKeyState( INT key )
 479 {
 480     return load_driver()->pGetAsyncKeyState( key );
 481 }
 482
 483 static INT loaderdrv_GetKeyNameText( LONG lparam, LPWSTR buffer, INT size )
 484 {
 485     return load_driver()->pGetKeyNameText( lparam, buffer, size );
 486 }
 487
 488 static HKL loaderdrv_GetKeyboardLayout( DWORD layout )
 489 {
 490     return load_driver()->pGetKeyboardLayout( layout );
 491 }
 492
 493 static UINT loaderdrv_GetKeyboardLayoutList( INT count, HKL *layouts )
 494 {
 495     return load_driver()->pGetKeyboardLayoutList( count, layouts );
 496 }
 497
 498 static BOOL loaderdrv_GetKeyboardLayoutName( LPWSTR name )
 499 {
 500     return load_driver()->pGetKeyboardLayoutName( name );
 501 }
 502
 503 static HKL loaderdrv_LoadKeyboardLayout( LPCWSTR name, UINT flags )
 504 {
 505     return load_driver()->pLoadKeyboardLayout( name, flags );
 506 }
 507
 508 static UINT loaderdrv_MapVirtualKeyEx( UINT code, UINT type, HKL layout )
 509 {
 510     return load_driver()->pMapVirtualKeyEx( code, type, layout );
 511 }
 512
 513 static UINT loaderdrv_SendInput( UINT count, LPINPUT inputs, int size )
 514 {
 515     return load_driver()->pSendInput( count, inputs, size );
 516 }
 517
 518 static INT loaderdrv_ToUnicodeEx( UINT virt, UINT scan, LPBYTE state, LPWSTR str,
 519                                   int size, UINT flags, HKL layout )
 520 {
 521     return load_driver()->pToUnicodeEx( virt, scan, state, str, size, flags, layout );
 522 }
 523
 524 static BOOL loaderdrv_UnloadKeyboardLayout( HKL layout )
 525 {
 526     return load_driver()->pUnloadKeyboardLayout( layout );
 527 }
 528
 529 static SHORT loaderdrv_VkKeyScanEx( WCHAR ch, HKL layout )
 530 {
 531     return load_driver()->pVkKeyScanEx( ch, layout );
 532 }
 533
 534 static void loaderdrv_SetCursor( struct tagCURSORICONINFO *info )
 535 {
 536     load_driver()->pSetCursor( info );
 537 }
 538
 539 static BOOL loaderdrv_GetCursorPos( LPPOINT pt )
 540 {
 541     return load_driver()->pGetCursorPos( pt );
 542 }
 543
 544 static BOOL loaderdrv_SetCursorPos( INT x, INT y )
 545 {
 546     return load_driver()->pSetCursorPos( x, y );
 547 }
 548
 549 static BOOL loaderdrv_GetScreenSaveActive(void)
 550 {
 551     return load_driver()->pGetScreenSaveActive();
 552 }
 553
 554 static void loaderdrv_SetScreenSaveActive( BOOL on )
 555 {
 556     load_driver()->pSetScreenSaveActive( on );
 557 }
 558
 559 static INT loaderdrv_AcquireClipboard( HWND hwnd )
 560 {
 561     return load_driver()->pAcquireClipboard( hwnd );
 562 }
 563
 564 static BOOL loaderdrv_CountClipboardFormats(void)
 565 {
 566     return load_driver()->pCountClipboardFormats();
 567 }
 568
 569 static void loaderdrv_EmptyClipboard( BOOL keepunowned )
 570 {
 571     load_driver()->pEmptyClipboard( keepunowned );
 572 }
 573
 574 static void loaderdrv_EndClipboardUpdate(void)
 575 {
 576     load_driver()->pEndClipboardUpdate();
 577 }
 578
 579 static UINT loaderdrv_EnumClipboardFormats( UINT format )
 580 {
 581     return load_driver()->pEnumClipboardFormats( format );
 582 }
 583
 584 static BOOL loaderdrv_GetClipboardData( UINT format, HANDLE16 *h16, HANDLE *h32 )
 585 {
 586     return load_driver()->pGetClipboardData( format, h16, h32 );
 587 }
 588
 589 static INT loaderdrv_GetClipboardFormatName( UINT format, LPWSTR buffer, UINT len )
 590 {
 591     return load_driver()->pGetClipboardFormatName( format, buffer, len );
 592 }
 593
 594 static BOOL loaderdrv_IsClipboardFormatAvailable( UINT format )
 595 {
 596     return load_driver()->pIsClipboardFormatAvailable( format );
 597 }
 598
 599 static UINT loaderdrv_RegisterClipboardFormat( LPCWSTR name )
 600 {
 601     return load_driver()->pRegisterClipboardFormat( name );
 602 }
 603
 604 static BOOL loaderdrv_SetClipboardData( UINT format, HANDLE16 h16, HANDLE h32, BOOL owner )
 605 {
 606     return load_driver()->pSetClipboardData( format, h16, h32, owner );
 607 }
 608
 609 static LONG loaderdrv_ChangeDisplaySettingsEx( LPCWSTR name, LPDEVMODEW mode, HWND hwnd,
 610                                                DWORD flags, LPVOID lparam )
 611 {
 612     return load_driver()->pChangeDisplaySettingsEx( name, mode, hwnd, flags, lparam );
 613 }
 614
 615 static BOOL loaderdrv_EnumDisplaySettingsEx( LPCWSTR name, DWORD num, LPDEVMODEW mode, DWORD flags )
 616 {
 617     return load_driver()->pEnumDisplaySettingsEx( name, num, mode, flags );
 618 }
 619
 620 static BOOL loaderdrv_CreateDesktopWindow( HWND hwnd )
 621 {
 622     return load_driver()->pCreateDesktopWindow( hwnd );
 623 }
 624
 625 static BOOL loaderdrv_CreateWindow( HWND hwnd, CREATESTRUCTA *cs, BOOL unicode )
 626 {
 627     return load_driver()->pCreateWindow( hwnd, cs, unicode );
 628 }
 629
 630 static void loaderdrv_DestroyWindow( HWND hwnd )
 631 {
 632     load_driver()->pDestroyWindow( hwnd );
 633 }
 634
 635 static HDC loaderdrv_GetDCEx( HWND hwnd, HRGN hrgn, DWORD flags )
 636 {
 637     return load_driver()->pGetDCEx( hwnd, hrgn, flags );
 638 }
 639
 640 static DWORD loaderdrv_MsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles, DWORD timeout,
 641                                                     DWORD mask, DWORD flags )
 642 {
 643     return load_driver()->pMsgWaitForMultipleObjectsEx( count, handles, timeout, mask, flags );
 644 }
 645
 646 static INT loaderdrv_ReleaseDC( HWND hwnd, HDC hdc, BOOL end_paint )
 647 {
 648     return load_driver()->pReleaseDC( hwnd, hdc, end_paint );
 649 }
 650
 651 static BOOL loaderdrv_ScrollDC( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip,
 652                                 HRGN hrgn, LPRECT update )
 653 {
 654     return load_driver()->pScrollDC( hdc, dx, dy, scroll, clip, hrgn, update );
 655 }
 656
 657 static void loaderdrv_SetFocus( HWND hwnd )
 658 {
 659     load_driver()->pSetFocus( hwnd );
 660 }
 661
 662 static HWND loaderdrv_SetParent( HWND hwnd, HWND parent )
 663 {
 664     return load_driver()->pSetParent( hwnd, parent );
 665 }
 666
 667 static BOOL loaderdrv_SetWindowPos( WINDOWPOS *pos )
 668 {
 669     return load_driver()->pSetWindowPos( pos );
 670 }
 671
 672 static int loaderdrv_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
 673 {
 674     return load_driver()->pSetWindowRgn( hwnd, hrgn, redraw );
 675 }
 676
 677 static void loaderdrv_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
 678 {
 679     load_driver()->pSetWindowIcon( hwnd, type, icon );
 680 }
 681
 682 static void loaderdrv_SetWindowStyle( HWND hwnd, DWORD old_style )
 683 {
 684     load_driver()->pSetWindowStyle( hwnd, old_style );
 685 }
 686
 687 static void loaderdrv_SetWindowText( HWND hwnd, LPCWSTR text )
 688 {
 689     load_driver()->pSetWindowText( hwnd, text );
 690 }
 691
 692 static BOOL loaderdrv_ShowWindow( HWND hwnd, INT cmd )
 693 {
 694     return load_driver()->pShowWindow( hwnd, cmd );
 695 }
 696
 697 static void loaderdrv_SysCommandSizeMove( HWND hwnd, WPARAM wparam )
 698 {
 699     load_driver()->pSysCommandSizeMove( hwnd, wparam );
 700 }
 701
 702 static HWND loaderdrv_WindowFromDC( HDC hdc )
 703 {
 704     return load_driver()->pWindowFromDC( hdc );
 705 }
 706
 707 static LRESULT loaderdrv_WindowMessage( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 708 {
 709     return load_driver()->pWindowMessage( hwnd, msg, wparam, lparam );
 710 }
 711
 712 static const USER_DRIVER lazy_load_driver =
 713 {
 714     /* keyboard functions */
 715     loaderdrv_ActivateKeyboardLayout,
 716     loaderdrv_Beep,
 717     loaderdrv_GetAsyncKeyState,
 718     loaderdrv_GetKeyNameText,
 719     loaderdrv_GetKeyboardLayout,
 720     loaderdrv_GetKeyboardLayoutList,
 721     loaderdrv_GetKeyboardLayoutName,
 722     loaderdrv_LoadKeyboardLayout,
 723     loaderdrv_MapVirtualKeyEx,
 724     loaderdrv_SendInput,
 725     loaderdrv_ToUnicodeEx,
 726     loaderdrv_UnloadKeyboardLayout,
 727     loaderdrv_VkKeyScanEx,
 728     /* mouse functions */
 729     loaderdrv_SetCursor,
 730     loaderdrv_GetCursorPos,
 731     loaderdrv_SetCursorPos,
 732     /* screen saver functions */
 733     loaderdrv_GetScreenSaveActive,
 734     loaderdrv_SetScreenSaveActive,
 735     /* clipboard functions */
 736     loaderdrv_AcquireClipboard,
 737     loaderdrv_CountClipboardFormats,
 738     loaderdrv_EmptyClipboard,
 739     loaderdrv_EndClipboardUpdate,
 740     loaderdrv_EnumClipboardFormats,
 741     loaderdrv_GetClipboardData,
 742     loaderdrv_GetClipboardFormatName,
 743     loaderdrv_IsClipboardFormatAvailable,
 744     loaderdrv_RegisterClipboardFormat,
 745     loaderdrv_SetClipboardData,
 746     /* display modes */
 747     loaderdrv_ChangeDisplaySettingsEx,
 748     loaderdrv_EnumDisplaySettingsEx,
 749     /* windowing functions */
 750     loaderdrv_CreateDesktopWindow,
 751     loaderdrv_CreateWindow,
 752     loaderdrv_DestroyWindow,
 753     loaderdrv_GetDCEx,
 754     loaderdrv_MsgWaitForMultipleObjectsEx,
 755     loaderdrv_ReleaseDC,
 756     loaderdrv_ScrollDC,
 757     loaderdrv_SetFocus,
 758     loaderdrv_SetParent,
 759     loaderdrv_SetWindowPos,
 760     loaderdrv_SetWindowRgn,
 761     loaderdrv_SetWindowIcon,
 762     loaderdrv_SetWindowStyle,
 763     loaderdrv_SetWindowText,
 764     loaderdrv_ShowWindow,
 765     loaderdrv_SysCommandSizeMove,
 766     loaderdrv_WindowFromDC,
 767     loaderdrv_WindowMessage
 768 };