git.oblomov.eu Git - wine/blob - dlls/user/class.c

   1 /*
   2  * Window classes functions
   3  *
   4  * Copyright 1993, 1996, 2003 Alexandre Julliard
   5  * Copyright 1998 Juergen Schmied (jsch)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "winerror.h"
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wingdi.h"
  34 #include "wine/winuser16.h"
  35 #include "wine/unicode.h"
  36 #include "win.h"
  37 #include "user_private.h"
  38 #include "controls.h"
  39 #include "winproc.h"
  40 #include "wine/server.h"
  41 #include "wine/list.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(class);
  45
  46 typedef struct tagCLASS
  47 {
  48     struct list      entry;         /* Entry in class list */
  49     UINT             style;         /* Class style */
  50     BOOL             local;         /* Local class? */
  51     WNDPROC          winprocA;      /* Window procedure (ASCII) */
  52     WNDPROC          winprocW;      /* Window procedure (Unicode) */
  53     INT              cbClsExtra;    /* Class extra bytes */
  54     INT              cbWndExtra;    /* Window extra bytes */
  55     LPWSTR           menuName;      /* Default menu name (Unicode followed by ASCII) */
  56     SEGPTR           segMenuName;   /* Default menu name as SEGPTR */
  57     HINSTANCE        hInstance;     /* Module that created the task */
  58     HICON            hIcon;         /* Default icon */
  59     HICON            hIconSm;       /* Default small icon */
  60     HCURSOR          hCursor;       /* Default cursor */
  61     HBRUSH           hbrBackground; /* Default background */
  62     ATOM             atomName;      /* Name of the class */
  63 } CLASS;
  64
  65 static struct list class_list = LIST_INIT( class_list );
  66
  67 #define CLASS_OTHER_PROCESS ((CLASS *)1)
  68
  69 /***********************************************************************
  70  *           get_class_ptr
  71  */
  72 static CLASS *get_class_ptr( HWND hwnd, BOOL write_access )
  73 {
  74     WND *ptr = WIN_GetPtr( hwnd );
  75
  76     if (ptr)
  77     {
  78         if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP) return ptr->class;
  79         if (!write_access) return CLASS_OTHER_PROCESS;
  80
  81         /* modifying classes in other processes is not allowed */
  82         if (ptr == WND_DESKTOP || IsWindow( hwnd ))
  83         {
  84             SetLastError( ERROR_ACCESS_DENIED );
  85             return NULL;
  86         }
  87     }
  88     SetLastError( ERROR_INVALID_WINDOW_HANDLE );
  89     return NULL;
  90 }
  91
  92
  93 /***********************************************************************
  94  *           release_class_ptr
  95  */
  96 inline static void release_class_ptr( CLASS *ptr )
  97 {
  98     USER_Unlock();
  99 }
 100
 101
 102 /***********************************************************************
 103  *           set_server_info
 104  *
 105  * Set class info with the wine server.
 106  */
 107 static BOOL set_server_info( HWND hwnd, INT offset, LONG newval )
 108 {
 109     BOOL ret;
 110
 111     SERVER_START_REQ( set_class_info )
 112     {
 113         req->window = hwnd;
 114         req->extra_offset = -1;
 115         switch(offset)
 116         {
 117         case GCW_ATOM:
 118             req->flags = SET_CLASS_ATOM;
 119             req->atom = newval;
 120         case GCL_STYLE:
 121             req->flags = SET_CLASS_STYLE;
 122             req->style = newval;
 123             break;
 124         case GCL_CBWNDEXTRA:
 125             req->flags = SET_CLASS_WINEXTRA;
 126             req->win_extra = newval;
 127             break;
 128         case GCLP_HMODULE:
 129             req->flags = SET_CLASS_INSTANCE;
 130             req->instance = (void *)newval;
 131             break;
 132         default:
 133             assert( offset >= 0 );
 134             req->flags = SET_CLASS_EXTRA;
 135             req->extra_offset = offset;
 136             req->extra_size = sizeof(newval);
 137             memcpy( &req->extra_value, &newval, sizeof(newval) );
 138             break;
 139         }
 140         ret = !wine_server_call_err( req );
 141     }
 142     SERVER_END_REQ;
 143     return ret;
 144 }
 145
 146
 147 /***********************************************************************
 148  *           CLASS_GetProc
 149  *
 150  * Get the class winproc for a given proc type
 151  */
 152 static WNDPROC16 CLASS_GetProc16( CLASS *classPtr )
 153 {
 154     if (classPtr->winprocA) return WINPROC_GetProc16( classPtr->winprocA, FALSE );
 155     else return WINPROC_GetProc16( classPtr->winprocW, TRUE );
 156 }
 157
 158
 159 /***********************************************************************
 160  *           CLASS_GetProc
 161  *
 162  * Get the class winproc for a given proc type
 163  */
 164 static WNDPROC CLASS_GetProc( CLASS *classPtr, BOOL unicode )
 165 {
 166     WNDPROC proc = classPtr->winprocA;
 167
 168     if (classPtr->winprocW)
 169     {
 170         /* if we have a Unicode proc, use it if we have no ASCII proc
 171          * or if we have both and Unicode was requested
 172          */
 173         if (!proc || unicode) proc = classPtr->winprocW;
 174     }
 175     return WINPROC_GetProc( proc, unicode );
 176 }
 177
 178
 179 /***********************************************************************
 180  *           CLASS_SetProc16
 181  *
 182  * Set the class winproc for a given proc type.
 183  * Returns the previous window proc.
 184  */
 185 static void CLASS_SetProc16( CLASS *classPtr, WNDPROC16 newproc )
 186 {
 187     WNDPROC proc = WINPROC_AllocProc16( newproc );
 188
 189     if (WINPROC_IsUnicode( proc, FALSE ))
 190     {
 191         classPtr->winprocA = 0;
 192         classPtr->winprocW = proc;
 193     }
 194     else
 195     {
 196         classPtr->winprocA = proc;
 197         classPtr->winprocW = 0;
 198     }
 199 }
 200
 201
 202 /***********************************************************************
 203  *           CLASS_SetProc
 204  *
 205  * Set the class winproc for a given proc type.
 206  * Returns the previous window proc.
 207  */
 208 static void CLASS_SetProc( CLASS *classPtr, WNDPROC newproc, BOOL unicode )
 209 {
 210     WNDPROC proc = WINPROC_AllocProc( newproc, unicode );
 211
 212     if (WINPROC_IsUnicode( proc, unicode ))
 213     {
 214         classPtr->winprocA = 0;
 215         classPtr->winprocW = proc;
 216     }
 217     else
 218     {
 219         classPtr->winprocA = proc;
 220         classPtr->winprocW = 0;
 221     }
 222 }
 223
 224
 225 /***********************************************************************
 226  *           CLASS_GetMenuNameA
 227  *
 228  * Get the menu name as a ASCII string.
 229  */
 230 inline static LPSTR CLASS_GetMenuNameA( CLASS *classPtr )
 231 {
 232     if (!HIWORD(classPtr->menuName)) return (LPSTR)classPtr->menuName;
 233     return (LPSTR)(classPtr->menuName + strlenW(classPtr->menuName) + 1);
 234 }
 235
 236
 237 /***********************************************************************
 238  *           CLASS_GetMenuName16
 239  *
 240  * Get the menu name as a SEGPTR.
 241  */
 242 inline static SEGPTR CLASS_GetMenuName16( CLASS *classPtr )
 243 {
 244     if (!HIWORD(classPtr->menuName)) return (SEGPTR)classPtr->menuName;
 245     if (!classPtr->segMenuName)
 246         classPtr->segMenuName = MapLS( CLASS_GetMenuNameA(classPtr) );
 247     return classPtr->segMenuName;
 248 }
 249
 250
 251 /***********************************************************************
 252  *           CLASS_GetMenuNameW
 253  *
 254  * Get the menu name as a Unicode string.
 255  */
 256 inline static LPWSTR CLASS_GetMenuNameW( CLASS *classPtr )
 257 {
 258     return classPtr->menuName;
 259 }
 260
 261
 262 /***********************************************************************
 263  *           CLASS_SetMenuNameA
 264  *
 265  * Set the menu name in a class structure by copying the string.
 266  */
 267 static void CLASS_SetMenuNameA( CLASS *classPtr, LPCSTR name )
 268 {
 269     UnMapLS( classPtr->segMenuName );
 270     classPtr->segMenuName = 0;
 271     if (HIWORD(classPtr->menuName)) HeapFree( GetProcessHeap(), 0, classPtr->menuName );
 272     if (HIWORD(name))
 273     {
 274         DWORD lenA = strlen(name) + 1;
 275         DWORD lenW = MultiByteToWideChar( CP_ACP, 0, name, lenA, NULL, 0 );
 276         classPtr->menuName = HeapAlloc( GetProcessHeap(), 0, lenA + lenW*sizeof(WCHAR) );
 277         MultiByteToWideChar( CP_ACP, 0, name, lenA, classPtr->menuName, lenW );
 278         memcpy( classPtr->menuName + lenW, name, lenA );
 279     }
 280     else classPtr->menuName = (LPWSTR)name;
 281 }
 282
 283
 284 /***********************************************************************
 285  *           CLASS_SetMenuNameW
 286  *
 287  * Set the menu name in a class structure by copying the string.
 288  */
 289 static void CLASS_SetMenuNameW( CLASS *classPtr, LPCWSTR name )
 290 {
 291     UnMapLS( classPtr->segMenuName );
 292     classPtr->segMenuName = 0;
 293     if (HIWORD(classPtr->menuName)) HeapFree( GetProcessHeap(), 0, classPtr->menuName );
 294     if (HIWORD(name))
 295     {
 296         DWORD lenW = strlenW(name) + 1;
 297         DWORD lenA = WideCharToMultiByte( CP_ACP, 0, name, lenW, NULL, 0, NULL, NULL );
 298         classPtr->menuName = HeapAlloc( GetProcessHeap(), 0, lenA + lenW*sizeof(WCHAR) );
 299         memcpy( classPtr->menuName, name, lenW*sizeof(WCHAR) );
 300         WideCharToMultiByte( CP_ACP, 0, name, lenW,
 301                              (char *)(classPtr->menuName + lenW), lenA, NULL, NULL );
 302     }
 303     else classPtr->menuName = (LPWSTR)name;
 304 }
 305
 306
 307 /***********************************************************************
 308  *           CLASS_FreeClass
 309  *
 310  * Free a class structure.
 311  */
 312 static void CLASS_FreeClass( CLASS *classPtr )
 313 {
 314     TRACE("%p\n", classPtr);
 315
 316     USER_Lock();
 317
 318     list_remove( &classPtr->entry );
 319     if (classPtr->hbrBackground > (HBRUSH)(COLOR_GRADIENTINACTIVECAPTION + 1))
 320         DeleteObject( classPtr->hbrBackground );
 321     UnMapLS( classPtr->segMenuName );
 322     HeapFree( GetProcessHeap(), 0, classPtr->menuName );
 323     HeapFree( GetProcessHeap(), 0, classPtr );
 324     USER_Unlock();
 325 }
 326
 327
 328 /***********************************************************************
 329  *           CLASS_FreeModuleClasses
 330  */
 331 void CLASS_FreeModuleClasses( HMODULE16 hModule )
 332 {
 333     struct list *ptr, *next;
 334
 335     TRACE("0x%08x\n", hModule);
 336
 337     USER_Lock();
 338     for (ptr = list_head( &class_list ); ptr; ptr = next)
 339     {
 340         CLASS *class = LIST_ENTRY( ptr, CLASS, entry );
 341         next = list_next( &class_list, ptr );
 342         if (class->hInstance == HINSTANCE_32(hModule))
 343         {
 344             BOOL ret;
 345
 346             SERVER_START_REQ( destroy_class )
 347             {
 348                 req->atom = class->atomName;
 349                 req->instance = class->hInstance;
 350                 ret = !wine_server_call_err( req );
 351             }
 352             SERVER_END_REQ;
 353             if (ret) CLASS_FreeClass( class );
 354         }
 355     }
 356     USER_Unlock();
 357 }
 358
 359
 360 /***********************************************************************
 361  *           CLASS_FindClassByAtom
 362  *
 363  * Return a pointer to the class.
 364  * hinstance has been normalized by the caller.
 365  */
 366 static CLASS *CLASS_FindClassByAtom( ATOM atom, HINSTANCE hinstance )
 367 {
 368     struct list *ptr;
 369
 370     USER_Lock();
 371
 372     LIST_FOR_EACH( ptr, &class_list )
 373     {
 374         CLASS *class = LIST_ENTRY( ptr, CLASS, entry );
 375         if (class->atomName != atom) continue;
 376         if (!hinstance || !class->local || class->hInstance == hinstance)
 377         {
 378             TRACE("0x%04x %p -> %p\n", atom, hinstance, class);
 379             return class;
 380         }
 381     }
 382     USER_Unlock();
 383     TRACE("0x%04x %p -> not found\n", atom, hinstance);
 384     return NULL;
 385 }
 386
 387
 388 /***********************************************************************
 389  *           CLASS_RegisterClass
 390  *
 391  * The real RegisterClass() functionality.
 392  * The atom is deleted no matter what.
 393  */
 394 static CLASS *CLASS_RegisterClass( ATOM atom, HINSTANCE hInstance, BOOL local,
 395                                    DWORD style, INT classExtra, INT winExtra )
 396 {
 397     CLASS *classPtr;
 398     BOOL ret;
 399
 400     TRACE("atom=0x%x hinst=%p style=0x%lx clExtr=0x%x winExtr=0x%x\n",
 401           atom, hInstance, style, classExtra, winExtra );
 402
 403     /* Fix the extra bytes value */
 404
 405     if (classExtra < 0 || winExtra < 0)
 406     {
 407          SetLastError( ERROR_INVALID_PARAMETER );
 408          return NULL;
 409     }
 410     if (classExtra > 40)  /* Extra bytes are limited to 40 in Win32 */
 411         WARN("Class extra bytes %d is > 40\n", classExtra);
 412     if (winExtra > 40)    /* Extra bytes are limited to 40 in Win32 */
 413         WARN("Win extra bytes %d is > 40\n", winExtra );
 414
 415     classPtr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLASS) + classExtra );
 416     if (!classPtr)
 417     {
 418         GlobalDeleteAtom( atom );
 419         return NULL;
 420     }
 421
 422     SERVER_START_REQ( create_class )
 423     {
 424         req->local      = local;
 425         req->atom       = atom;
 426         req->style      = style;
 427         req->instance   = hInstance;
 428         req->extra      = classExtra;
 429         req->win_extra  = winExtra;
 430         req->client_ptr = classPtr;
 431         ret = !wine_server_call_err( req );
 432     }
 433     SERVER_END_REQ;
 434     GlobalDeleteAtom( atom );  /* the server increased the atom ref count */
 435     if (!ret)
 436     {
 437         HeapFree( GetProcessHeap(), 0, classPtr );
 438         return NULL;
 439     }
 440
 441     classPtr->style       = style;
 442     classPtr->local       = local;
 443     classPtr->cbWndExtra  = winExtra;
 444     classPtr->cbClsExtra  = classExtra;
 445     classPtr->hInstance   = hInstance;
 446     classPtr->atomName    = atom;
 447
 448     /* Other non-null values must be set by caller */
 449
 450     USER_Lock();
 451     if (local) list_add_head( &class_list, &classPtr->entry );
 452     else list_add_tail( &class_list, &classPtr->entry );
 453     return classPtr;
 454 }
 455
 456
 457 /***********************************************************************
 458  *           register_builtin
 459  *
 460  * Register a builtin control class.
 461  * This allows having both ASCII and Unicode winprocs for the same class.
 462  */
 463 static CLASS *register_builtin( const struct builtin_class_descr *descr )
 464 {
 465     ATOM atom;
 466     CLASS *classPtr;
 467
 468     if (!(atom = GlobalAddAtomA( descr->name ))) return 0;
 469
 470     if (!(classPtr = CLASS_RegisterClass( atom, user32_module, FALSE,
 471                                           descr->style, 0, descr->extra ))) return 0;
 472
 473     classPtr->hCursor       = LoadCursorA( 0, (LPSTR)descr->cursor );
 474     classPtr->hbrBackground = descr->brush;
 475
 476     if (descr->procA) classPtr->winprocA = WINPROC_AllocProc( descr->procA, FALSE );
 477     if (descr->procW) classPtr->winprocW = WINPROC_AllocProc( descr->procW, TRUE );
 478     release_class_ptr( classPtr );
 479     return classPtr;
 480 }
 481
 482
 483 /***********************************************************************
 484  *           CLASS_RegisterBuiltinClasses
 485  */
 486 void CLASS_RegisterBuiltinClasses(void)
 487 {
 488     extern const struct builtin_class_descr BUTTON_builtin_class;
 489     extern const struct builtin_class_descr COMBO_builtin_class;
 490     extern const struct builtin_class_descr COMBOLBOX_builtin_class;
 491     extern const struct builtin_class_descr DIALOG_builtin_class;
 492     extern const struct builtin_class_descr DESKTOP_builtin_class;
 493     extern const struct builtin_class_descr EDIT_builtin_class;
 494     extern const struct builtin_class_descr ICONTITLE_builtin_class;
 495     extern const struct builtin_class_descr LISTBOX_builtin_class;
 496     extern const struct builtin_class_descr MDICLIENT_builtin_class;
 497     extern const struct builtin_class_descr MENU_builtin_class;
 498     extern const struct builtin_class_descr SCROLL_builtin_class;
 499     extern const struct builtin_class_descr STATIC_builtin_class;
 500
 501     register_builtin( &DESKTOP_builtin_class );
 502     register_builtin( &BUTTON_builtin_class );
 503     register_builtin( &COMBO_builtin_class );
 504     register_builtin( &COMBOLBOX_builtin_class );
 505     register_builtin( &DIALOG_builtin_class );
 506     register_builtin( &EDIT_builtin_class );
 507     register_builtin( &ICONTITLE_builtin_class );
 508     register_builtin( &LISTBOX_builtin_class );
 509     register_builtin( &MDICLIENT_builtin_class );
 510     register_builtin( &MENU_builtin_class );
 511     register_builtin( &SCROLL_builtin_class );
 512     register_builtin( &STATIC_builtin_class );
 513 }
 514
 515
 516 /***********************************************************************
 517  *           CLASS_AddWindow
 518  *
 519  * Add a new window using this class, and set the necessary
 520  * information inside the window structure.
 521  */
 522 void CLASS_AddWindow( CLASS *class, WND *win, BOOL unicode )
 523 {
 524     if (unicode)
 525     {
 526         if (!(win->winproc = class->winprocW)) win->winproc = class->winprocA;
 527     }
 528     else
 529     {
 530         if (!(win->winproc = class->winprocA)) win->winproc = class->winprocW;
 531     }
 532     win->class    = class;
 533     win->clsStyle = class->style;
 534     if (WINPROC_IsUnicode( win->winproc, unicode )) win->flags |= WIN_ISUNICODE;
 535 }
 536
 537
 538 /***********************************************************************
 539  *              RegisterClassA (USER32.@)
 540  *
 541  * Register a window class.
 542  *
 543  * RETURNS
 544  *      >0: Unique identifier
 545  *      0: Failure
 546  */
 547 ATOM WINAPI RegisterClassA( const WNDCLASSA* wc ) /* [in] Address of structure with class data */
 548 {
 549     WNDCLASSEXA wcex;
 550
 551     wcex.cbSize        = sizeof(wcex);
 552     wcex.style         = wc->style;
 553     wcex.lpfnWndProc   = wc->lpfnWndProc;
 554     wcex.cbClsExtra    = wc->cbClsExtra;
 555     wcex.cbWndExtra    = wc->cbWndExtra;
 556     wcex.hInstance     = wc->hInstance;
 557     wcex.hIcon         = wc->hIcon;
 558     wcex.hCursor       = wc->hCursor;
 559     wcex.hbrBackground = wc->hbrBackground;
 560     wcex.lpszMenuName  = wc->lpszMenuName;
 561     wcex.lpszClassName = wc->lpszClassName;
 562     wcex.hIconSm       = 0;
 563     return RegisterClassExA( &wcex );
 564 }
 565
 566
 567 /***********************************************************************
 568  *              RegisterClassW (USER32.@)
 569  *
 570  * See RegisterClassA.
 571  */
 572 ATOM WINAPI RegisterClassW( const WNDCLASSW* wc )
 573 {
 574     WNDCLASSEXW wcex;
 575
 576     wcex.cbSize        = sizeof(wcex);
 577     wcex.style         = wc->style;
 578     wcex.lpfnWndProc   = wc->lpfnWndProc;
 579     wcex.cbClsExtra    = wc->cbClsExtra;
 580     wcex.cbWndExtra    = wc->cbWndExtra;
 581     wcex.hInstance     = wc->hInstance;
 582     wcex.hIcon         = wc->hIcon;
 583     wcex.hCursor       = wc->hCursor;
 584     wcex.hbrBackground = wc->hbrBackground;
 585     wcex.lpszMenuName  = wc->lpszMenuName;
 586     wcex.lpszClassName = wc->lpszClassName;
 587     wcex.hIconSm       = 0;
 588     return RegisterClassExW( &wcex );
 589 }
 590
 591
 592 /***********************************************************************
 593  *              RegisterClassExA (USER32.@)
 594  */
 595 ATOM WINAPI RegisterClassExA( const WNDCLASSEXA* wc )
 596 {
 597     ATOM atom;
 598     CLASS *classPtr;
 599     HINSTANCE instance;
 600
 601     if (wc->hInstance == user32_module)
 602     {
 603         /* we can't register a class for user32 */
 604         SetLastError( ERROR_INVALID_PARAMETER );
 605         return 0;
 606     }
 607     if (!(instance = wc->hInstance)) instance = GetModuleHandleW( NULL );
 608
 609     if (!(atom = GlobalAddAtomA( wc->lpszClassName ))) return 0;
 610
 611     if (!(classPtr = CLASS_RegisterClass( atom, instance, !(wc->style & CS_GLOBALCLASS),
 612                                           wc->style, wc->cbClsExtra, wc->cbWndExtra )))
 613         return 0;
 614
 615     TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
 616           atom, wc->lpfnWndProc, instance, wc->hbrBackground,
 617           wc->style, wc->cbClsExtra, wc->cbWndExtra, classPtr );
 618
 619     classPtr->hIcon         = wc->hIcon;
 620     classPtr->hIconSm       = wc->hIconSm;
 621     classPtr->hCursor       = wc->hCursor;
 622     classPtr->hbrBackground = wc->hbrBackground;
 623     classPtr->winprocA      = WINPROC_AllocProc( wc->lpfnWndProc, FALSE );
 624     CLASS_SetMenuNameA( classPtr, wc->lpszMenuName );
 625     release_class_ptr( classPtr );
 626     return atom;
 627 }
 628
 629
 630 /***********************************************************************
 631  *              RegisterClassExW (USER32.@)
 632  */
 633 ATOM WINAPI RegisterClassExW( const WNDCLASSEXW* wc )
 634 {
 635     ATOM atom;
 636     CLASS *classPtr;
 637     HINSTANCE instance;
 638
 639     if (wc->hInstance == user32_module)
 640     {
 641         /* we can't register a class for user32 */
 642         SetLastError( ERROR_INVALID_PARAMETER );
 643         return 0;
 644     }
 645     if (!(instance = wc->hInstance)) instance = GetModuleHandleW( NULL );
 646
 647     if (!(atom = GlobalAddAtomW( wc->lpszClassName ))) return 0;
 648
 649     if (!(classPtr = CLASS_RegisterClass( atom, instance, !(wc->style & CS_GLOBALCLASS),
 650                                           wc->style, wc->cbClsExtra, wc->cbWndExtra )))
 651         return 0;
 652
 653     TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
 654           atom, wc->lpfnWndProc, instance, wc->hbrBackground,
 655           wc->style, wc->cbClsExtra, wc->cbWndExtra, classPtr );
 656
 657     classPtr->hIcon         = wc->hIcon;
 658     classPtr->hIconSm       = wc->hIconSm;
 659     classPtr->hCursor       = wc->hCursor;
 660     classPtr->hbrBackground = wc->hbrBackground;
 661     classPtr->winprocW      = WINPROC_AllocProc( wc->lpfnWndProc, TRUE );
 662     CLASS_SetMenuNameW( classPtr, wc->lpszMenuName );
 663     release_class_ptr( classPtr );
 664     return atom;
 665 }
 666
 667
 668 /***********************************************************************
 669  *              UnregisterClassA (USER32.@)
 670  */
 671 BOOL WINAPI UnregisterClassA( LPCSTR className, HINSTANCE hInstance )
 672 {
 673     ATOM atom = HIWORD(className) ? GlobalFindAtomA( className ) : LOWORD(className);
 674     return UnregisterClassW( MAKEINTATOMW(atom), hInstance );
 675 }
 676
 677 /***********************************************************************
 678  *              UnregisterClassW (USER32.@)
 679  */
 680 BOOL WINAPI UnregisterClassW( LPCWSTR className, HINSTANCE hInstance )
 681 {
 682     CLASS *classPtr = NULL;
 683     ATOM atom = HIWORD(className) ? GlobalFindAtomW( className ) : LOWORD(className);
 684
 685     TRACE("%s %p %x\n",debugstr_w(className), hInstance, atom);
 686
 687     if (!atom)
 688     {
 689         SetLastError( ERROR_CLASS_DOES_NOT_EXIST );
 690         return FALSE;
 691     }
 692
 693     SERVER_START_REQ( destroy_class )
 694     {
 695         req->atom = atom;
 696         req->instance = hInstance;
 697         if (!wine_server_call_err( req )) classPtr = reply->client_ptr;
 698     }
 699     SERVER_END_REQ;
 700
 701     if (classPtr) CLASS_FreeClass( classPtr );
 702     return (classPtr != NULL);
 703 }
 704
 705
 706 /***********************************************************************
 707  *              GetClassWord (USER32.@)
 708  */
 709 WORD WINAPI GetClassWord( HWND hwnd, INT offset )
 710 {
 711     CLASS *class;
 712     WORD retvalue = 0;
 713
 714     if (offset < 0) return GetClassLongA( hwnd, offset );
 715
 716     TRACE("%p %x\n",hwnd, offset);
 717
 718     if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
 719
 720     if (class == CLASS_OTHER_PROCESS)
 721     {
 722         SERVER_START_REQ( set_class_info )
 723         {
 724             req->window = hwnd;
 725             req->flags = 0;
 726             req->extra_offset = offset;
 727             req->extra_size = sizeof(retvalue);
 728             if (!wine_server_call_err( req ))
 729                 memcpy( &retvalue, &reply->old_extra_value, sizeof(retvalue) );
 730         }
 731         SERVER_END_REQ;
 732         return retvalue;
 733     }
 734
 735     if (offset <= class->cbClsExtra - sizeof(WORD))
 736         memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
 737     else
 738         SetLastError( ERROR_INVALID_INDEX );
 739     release_class_ptr( class );
 740     return retvalue;
 741 }
 742
 743
 744 /***********************************************************************
 745  *              GetClassLong (USER.131)
 746  */
 747 LONG WINAPI GetClassLong16( HWND16 hwnd16, INT16 offset )
 748 {
 749     CLASS *class;
 750     LONG ret;
 751     HWND hwnd = (HWND)(ULONG_PTR)hwnd16;  /* no need for full handle */
 752
 753     TRACE("%p %d\n",hwnd, offset);
 754
 755     switch( offset )
 756     {
 757     case GCLP_WNDPROC:
 758         if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
 759         if (class == CLASS_OTHER_PROCESS) break;
 760         ret = (LONG)CLASS_GetProc16( class );
 761         release_class_ptr( class );
 762         return ret;
 763     case GCLP_MENUNAME:
 764         if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
 765         if (class == CLASS_OTHER_PROCESS) break;
 766         ret = (LONG)CLASS_GetMenuName16( class );
 767         release_class_ptr( class );
 768         return ret;
 769     default:
 770         return GetClassLongA( hwnd, offset );
 771     }
 772     FIXME( "offset %d not supported on other process window %p\n", offset, hwnd );
 773     SetLastError( ERROR_INVALID_HANDLE );
 774     return 0;
 775 }
 776
 777
 778 /***********************************************************************
 779  *              GetClassLongW (USER32.@)
 780  */
 781 DWORD WINAPI GetClassLongW( HWND hwnd, INT offset )
 782 {
 783     CLASS *class;
 784     DWORD retvalue = 0;
 785
 786     TRACE("%p %d\n", hwnd, offset);
 787
 788     if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
 789
 790     if (class == CLASS_OTHER_PROCESS)
 791     {
 792         SERVER_START_REQ( set_class_info )
 793         {
 794             req->window = hwnd;
 795             req->flags = 0;
 796             req->extra_offset = (offset >= 0) ? offset : -1;
 797             req->extra_size = (offset >= 0) ? sizeof(retvalue) : 0;
 798             if (!wine_server_call_err( req ))
 799             {
 800                 switch(offset)
 801                 {
 802                 case GCLP_HBRBACKGROUND:
 803                 case GCLP_HCURSOR:
 804                 case GCLP_HICON:
 805                 case GCLP_HICONSM:
 806                 case GCLP_WNDPROC:
 807                 case GCLP_MENUNAME:
 808                     FIXME( "offset %d not supported on other process window %p\n", offset, hwnd );
 809                     SetLastError( ERROR_INVALID_HANDLE );
 810                     break;
 811                 case GCL_STYLE:
 812                     retvalue = reply->old_style;
 813                     break;
 814                 case GCL_CBWNDEXTRA:
 815                     retvalue = reply->old_win_extra;
 816                     break;
 817                 case GCL_CBCLSEXTRA:
 818                     retvalue = reply->old_extra;
 819                     break;
 820                 case GCLP_HMODULE:
 821                     retvalue = (DWORD)reply->old_instance;
 822                     break;
 823                 case GCW_ATOM:
 824                     retvalue = reply->old_atom;
 825                     break;
 826                 default:
 827                     if (offset >= 0) memcpy( &retvalue, &reply->old_extra_value, sizeof(retvalue) );
 828                     else SetLastError( ERROR_INVALID_INDEX );
 829                     break;
 830                 }
 831             }
 832         }
 833         SERVER_END_REQ;
 834         return retvalue;
 835     }
 836
 837     if (offset >= 0)
 838     {
 839         if (offset <= class->cbClsExtra - sizeof(LONG))
 840             memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
 841         else
 842             SetLastError( ERROR_INVALID_INDEX );
 843         release_class_ptr( class );
 844         return retvalue;
 845     }
 846
 847     switch(offset)
 848     {
 849     case GCLP_HBRBACKGROUND:
 850         retvalue = (DWORD)class->hbrBackground;
 851         break;
 852     case GCLP_HCURSOR:
 853         retvalue = (DWORD)class->hCursor;
 854         break;
 855     case GCLP_HICON:
 856         retvalue = (DWORD)class->hIcon;
 857         break;
 858     case GCLP_HICONSM:
 859         retvalue = (DWORD)class->hIconSm;
 860         break;
 861     case GCL_STYLE:
 862         retvalue = (DWORD)class->style;
 863         break;
 864     case GCL_CBWNDEXTRA:
 865         retvalue = (DWORD)class->cbWndExtra;
 866         break;
 867     case GCL_CBCLSEXTRA:
 868         retvalue = (DWORD)class->cbClsExtra;
 869         break;
 870     case GCLP_HMODULE:
 871         retvalue = (DWORD)class->hInstance;
 872         break;
 873     case GCLP_WNDPROC:
 874         retvalue = (DWORD)CLASS_GetProc( class, TRUE );
 875         break;
 876     case GCLP_MENUNAME:
 877         retvalue = (DWORD)CLASS_GetMenuNameW( class );
 878         break;
 879     case GCW_ATOM:
 880         retvalue = (DWORD)class->atomName;
 881         break;
 882     default:
 883         SetLastError( ERROR_INVALID_INDEX );
 884         break;
 885     }
 886     release_class_ptr( class );
 887     return retvalue;
 888 }
 889
 890
 891 /***********************************************************************
 892  *              GetClassLongA (USER32.@)
 893  */
 894 DWORD WINAPI GetClassLongA( HWND hwnd, INT offset )
 895 {
 896     CLASS *class;
 897     DWORD retvalue;
 898
 899     if (offset != GCLP_WNDPROC && offset != GCLP_MENUNAME)
 900         return GetClassLongW( hwnd, offset );
 901
 902     TRACE("%p %d\n", hwnd, offset);
 903
 904     if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
 905
 906     if (class == CLASS_OTHER_PROCESS)
 907     {
 908         FIXME( "offset %d not supported on other process window %p\n", offset, hwnd );
 909         SetLastError( ERROR_INVALID_HANDLE );
 910         return 0;
 911     }
 912
 913     if (offset == GCLP_WNDPROC)
 914         retvalue = (DWORD)CLASS_GetProc( class, FALSE );
 915     else  /* GCL_MENUNAME */
 916         retvalue = (DWORD)CLASS_GetMenuNameA( class );
 917
 918     release_class_ptr( class );
 919     return retvalue;
 920 }
 921
 922
 923 /***********************************************************************
 924  *              SetClassWord (USER32.@)
 925  */
 926 WORD WINAPI SetClassWord( HWND hwnd, INT offset, WORD newval )
 927 {
 928     CLASS *class;
 929     WORD retval = 0;
 930
 931     if (offset < 0) return SetClassLongA( hwnd, offset, (DWORD)newval );
 932
 933     TRACE("%p %d %x\n", hwnd, offset, newval);
 934
 935     if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
 936
 937     SERVER_START_REQ( set_class_info )
 938     {
 939         req->window = hwnd;
 940         req->flags = SET_CLASS_EXTRA;
 941         req->extra_offset = offset;
 942         req->extra_size = sizeof(newval);
 943         memcpy( &req->extra_value, &newval, sizeof(newval) );
 944         if (!wine_server_call_err( req ))
 945         {
 946             void *ptr = (char *)(class + 1) + offset;
 947             memcpy( &retval, ptr, sizeof(retval) );
 948             memcpy( ptr, &newval, sizeof(newval) );
 949         }
 950     }
 951     SERVER_END_REQ;
 952     release_class_ptr( class );
 953     return retval;
 954 }
 955
 956
 957 /***********************************************************************
 958  *              SetClassLong (USER.132)
 959  */
 960 LONG WINAPI SetClassLong16( HWND16 hwnd16, INT16 offset, LONG newval )
 961 {
 962     CLASS *class;
 963     LONG retval;
 964     HWND hwnd = (HWND)(ULONG_PTR)hwnd16;  /* no need for full handle */
 965
 966     TRACE("%p %d %lx\n", hwnd, offset, newval);
 967
 968     switch(offset)
 969     {
 970     case GCLP_WNDPROC:
 971         if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
 972         retval = (LONG)CLASS_GetProc16( class );
 973         CLASS_SetProc16( class, (WNDPROC16)newval );
 974         release_class_ptr( class );
 975         return retval;
 976     case GCLP_MENUNAME:
 977         newval = (LONG)MapSL( newval );
 978         /* fall through */
 979     default:
 980         return SetClassLongA( hwnd, offset, newval );
 981     }
 982 }
 983
 984
 985 /***********************************************************************
 986  *              SetClassLongW (USER32.@)
 987  */
 988 DWORD WINAPI SetClassLongW( HWND hwnd, INT offset, LONG newval )
 989 {
 990     CLASS *class;
 991     DWORD retval = 0;
 992
 993     TRACE("%p %d %lx\n", hwnd, offset, newval);
 994
 995     if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
 996
 997     if (offset >= 0)
 998     {
 999         if (set_server_info( hwnd, offset, newval ))
1000         {
1001             void *ptr = (char *)(class + 1) + offset;
1002             memcpy( &retval, ptr, sizeof(retval) );
1003             memcpy( ptr, &newval, sizeof(newval) );
1004         }
1005     }
1006     else switch(offset)
1007     {
1008     case GCLP_MENUNAME:
1009         CLASS_SetMenuNameW( class, (LPCWSTR)newval );
1010         retval = 0;  /* Old value is now meaningless anyway */
1011         break;
1012     case GCLP_WNDPROC:
1013         retval = (DWORD)CLASS_GetProc( class, TRUE );
1014         CLASS_SetProc( class, (WNDPROC)newval, TRUE );
1015         break;
1016     case GCLP_HBRBACKGROUND:
1017         retval = (DWORD)class->hbrBackground;
1018         class->hbrBackground = (HBRUSH)newval;
1019         break;
1020     case GCLP_HCURSOR:
1021         retval = (DWORD)class->hCursor;
1022         class->hCursor = (HCURSOR)newval;
1023         break;
1024     case GCLP_HICON:
1025         retval = (DWORD)class->hIcon;
1026         class->hIcon = (HICON)newval;
1027         break;
1028     case GCLP_HICONSM:
1029         retval = (DWORD)class->hIconSm;
1030         class->hIconSm = (HICON)newval;
1031         break;
1032     case GCL_STYLE:
1033         if (!set_server_info( hwnd, offset, newval )) break;
1034         retval = (DWORD)class->style;
1035         class->style = newval;
1036         break;
1037     case GCL_CBWNDEXTRA:
1038         if (!set_server_info( hwnd, offset, newval )) break;
1039         retval = (DWORD)class->cbWndExtra;
1040         class->cbWndExtra = newval;
1041         break;
1042     case GCLP_HMODULE:
1043         if (!set_server_info( hwnd, offset, newval )) break;
1044         retval = (DWORD)class->hInstance;
1045         class->hInstance = (HINSTANCE)newval;
1046         break;
1047     case GCW_ATOM:
1048         if (!set_server_info( hwnd, offset, newval )) break;
1049         retval = (DWORD)class->atomName;
1050         class->atomName = newval;
1051         break;
1052     case GCL_CBCLSEXTRA:  /* cannot change this one */
1053         SetLastError( ERROR_INVALID_PARAMETER );
1054         break;
1055     default:
1056         SetLastError( ERROR_INVALID_INDEX );
1057         break;
1058     }
1059     release_class_ptr( class );
1060     return retval;
1061 }
1062
1063
1064 /***********************************************************************
1065  *              SetClassLongA (USER32.@)
1066  */
1067 DWORD WINAPI SetClassLongA( HWND hwnd, INT offset, LONG newval )
1068 {
1069     CLASS *class;
1070     DWORD retval;
1071
1072     if (offset != GCLP_WNDPROC && offset != GCLP_MENUNAME)
1073         return SetClassLongW( hwnd, offset, newval );
1074
1075     TRACE("%p %d %lx\n", hwnd, offset, newval);
1076
1077     if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
1078
1079     if (offset == GCLP_WNDPROC)
1080     {
1081         retval = (DWORD)CLASS_GetProc( class, FALSE );
1082         CLASS_SetProc( class, (WNDPROC)newval, FALSE );
1083     }
1084     else  /* GCL_MENUNAME */
1085     {
1086         CLASS_SetMenuNameA( class, (LPCSTR)newval );
1087         retval = 0;  /* Old value is now meaningless anyway */
1088     }
1089     release_class_ptr( class );
1090     return retval;
1091 }
1092
1093
1094 /***********************************************************************
1095  *              GetClassNameA (USER32.@)
1096  */
1097 INT WINAPI GetClassNameA( HWND hwnd, LPSTR buffer, INT count )
1098 {
1099     INT ret = GlobalGetAtomNameA( GetClassLongA( hwnd, GCW_ATOM ), buffer, count );
1100
1101     TRACE("%p %s %x\n",hwnd, debugstr_a(buffer), count);
1102     return ret;
1103 }
1104
1105
1106 /***********************************************************************
1107  *              GetClassNameW (USER32.@)
1108  */
1109 INT WINAPI GetClassNameW( HWND hwnd, LPWSTR buffer, INT count )
1110 {
1111     INT ret = GlobalGetAtomNameW( GetClassLongW( hwnd, GCW_ATOM ), buffer, count );
1112
1113     TRACE("%p %s %x\n",hwnd, debugstr_w(buffer), count);
1114     return ret;
1115 }
1116
1117
1118 /***********************************************************************
1119  *              RealGetWindowClassA (USER32.@)
1120  */
1121 UINT WINAPI RealGetWindowClassA( HWND hwnd, LPSTR buffer, UINT count )
1122 {
1123     return GetClassNameA( hwnd, buffer, count );
1124 }
1125
1126
1127 /***********************************************************************
1128  *              RealGetWindowClassW (USER32.@)
1129  */
1130 UINT WINAPI RealGetWindowClassW( HWND hwnd, LPWSTR buffer, UINT count )
1131 {
1132     return GetClassNameW( hwnd, buffer, count );
1133 }
1134
1135
1136 /***********************************************************************
1137  *              GetClassInfoA (USER32.@)
1138  */
1139 BOOL WINAPI GetClassInfoA( HINSTANCE hInstance, LPCSTR name, WNDCLASSA *wc )
1140 {
1141     WNDCLASSEXA wcex;
1142     UINT ret = GetClassInfoExA( hInstance, name, &wcex );
1143
1144     if (ret)
1145     {
1146         wc->style         = wcex.style;
1147         wc->lpfnWndProc   = wcex.lpfnWndProc;
1148         wc->cbClsExtra    = wcex.cbClsExtra;
1149         wc->cbWndExtra    = wcex.cbWndExtra;
1150         wc->hInstance     = wcex.hInstance;
1151         wc->hIcon         = wcex.hIcon;
1152         wc->hCursor       = wcex.hCursor;
1153         wc->hbrBackground = wcex.hbrBackground;
1154         wc->lpszMenuName  = wcex.lpszMenuName;
1155         wc->lpszClassName = wcex.lpszClassName;
1156     }
1157     return ret;
1158 }
1159
1160
1161 /***********************************************************************
1162  *              GetClassInfoW (USER32.@)
1163  */
1164 BOOL WINAPI GetClassInfoW( HINSTANCE hInstance, LPCWSTR name, WNDCLASSW *wc )
1165 {
1166     WNDCLASSEXW wcex;
1167     UINT ret = GetClassInfoExW( hInstance, name, &wcex );
1168
1169     if (ret)
1170     {
1171         wc->style         = wcex.style;
1172         wc->lpfnWndProc   = wcex.lpfnWndProc;
1173         wc->cbClsExtra    = wcex.cbClsExtra;
1174         wc->cbWndExtra    = wcex.cbWndExtra;
1175         wc->hInstance     = wcex.hInstance;
1176         wc->hIcon         = wcex.hIcon;
1177         wc->hCursor       = wcex.hCursor;
1178         wc->hbrBackground = wcex.hbrBackground;
1179         wc->lpszMenuName  = wcex.lpszMenuName;
1180         wc->lpszClassName = wcex.lpszClassName;
1181     }
1182     return ret;
1183 }
1184
1185
1186 /***********************************************************************
1187  *              GetClassInfoExA (USER32.@)
1188  */
1189 BOOL WINAPI GetClassInfoExA( HINSTANCE hInstance, LPCSTR name, WNDCLASSEXA *wc )
1190 {
1191     ATOM atom = HIWORD(name) ? GlobalFindAtomA( name ) : LOWORD(name);
1192     CLASS *classPtr;
1193
1194     TRACE("%p %s %x %p\n", hInstance, debugstr_a(name), atom, wc);
1195
1196     if (!hInstance) hInstance = user32_module;
1197
1198     if (!atom || !(classPtr = CLASS_FindClassByAtom( atom, hInstance )))
1199     {
1200         SetLastError( ERROR_CLASS_DOES_NOT_EXIST );
1201         return FALSE;
1202     }
1203     wc->style         = classPtr->style;
1204     wc->lpfnWndProc   = (WNDPROC)CLASS_GetProc( classPtr, FALSE );
1205     wc->cbClsExtra    = classPtr->cbClsExtra;
1206     wc->cbWndExtra    = classPtr->cbWndExtra;
1207     wc->hInstance     = (hInstance == user32_module) ? 0 : hInstance;
1208     wc->hIcon         = (HICON)classPtr->hIcon;
1209     wc->hIconSm       = (HICON)classPtr->hIconSm;
1210     wc->hCursor       = (HCURSOR)classPtr->hCursor;
1211     wc->hbrBackground = (HBRUSH)classPtr->hbrBackground;
1212     wc->lpszMenuName  = CLASS_GetMenuNameA( classPtr );
1213     wc->lpszClassName = name;
1214     release_class_ptr( classPtr );
1215
1216     /* We must return the atom of the class here instead of just TRUE. */
1217     return atom;
1218 }
1219
1220
1221 /***********************************************************************
1222  *              GetClassInfoExW (USER32.@)
1223  */
1224 BOOL WINAPI GetClassInfoExW( HINSTANCE hInstance, LPCWSTR name, WNDCLASSEXW *wc )
1225 {
1226     ATOM atom = HIWORD(name) ? GlobalFindAtomW( name ) : LOWORD(name);
1227     CLASS *classPtr;
1228
1229     TRACE("%p %s %x %p\n", hInstance, debugstr_w(name), atom, wc);
1230
1231     if (!hInstance) hInstance = user32_module;
1232
1233     if (!atom || !(classPtr = CLASS_FindClassByAtom( atom, hInstance )))
1234     {
1235         SetLastError( ERROR_CLASS_DOES_NOT_EXIST );
1236         return FALSE;
1237     }
1238     wc->style         = classPtr->style;
1239     wc->lpfnWndProc   = (WNDPROC)CLASS_GetProc( classPtr, TRUE );
1240     wc->cbClsExtra    = classPtr->cbClsExtra;
1241     wc->cbWndExtra    = classPtr->cbWndExtra;
1242     wc->hInstance     = (hInstance == user32_module) ? 0 : hInstance;
1243     wc->hIcon         = (HICON)classPtr->hIcon;
1244     wc->hIconSm       = (HICON)classPtr->hIconSm;
1245     wc->hCursor       = (HCURSOR)classPtr->hCursor;
1246     wc->hbrBackground = (HBRUSH)classPtr->hbrBackground;
1247     wc->lpszMenuName  = CLASS_GetMenuNameW( classPtr );
1248     wc->lpszClassName = name;
1249     release_class_ptr( classPtr );
1250
1251     /* We must return the atom of the class here instead of just TRUE. */
1252     return atom;
1253 }
1254
1255
1256 #if 0  /* toolhelp is in kernel, so this cannot work */
1257
1258 /***********************************************************************
1259  *              ClassFirst (TOOLHELP.69)
1260  */
1261 BOOL16 WINAPI ClassFirst16( CLASSENTRY *pClassEntry )
1262 {
1263     TRACE("%p\n",pClassEntry);
1264     pClassEntry->wNext = 1;
1265     return ClassNext16( pClassEntry );
1266 }
1267
1268
1269 /***********************************************************************
1270  *              ClassNext (TOOLHELP.70)
1271  */
1272 BOOL16 WINAPI ClassNext16( CLASSENTRY *pClassEntry )
1273 {
1274     int i;
1275     CLASS *class = firstClass;
1276
1277     TRACE("%p\n",pClassEntry);
1278
1279     if (!pClassEntry->wNext) return FALSE;
1280     for (i = 1; (i < pClassEntry->wNext) && class; i++) class = class->next;
1281     if (!class)
1282     {
1283         pClassEntry->wNext = 0;
1284         return FALSE;
1285     }
1286     pClassEntry->hInst = class->hInstance;
1287     pClassEntry->wNext++;
1288     GlobalGetAtomNameA( class->atomName, pClassEntry->szClassName,
1289                           sizeof(pClassEntry->szClassName) );
1290     return TRUE;
1291 }
1292 #endif