reactos/subsystems/win32/win32k/ntuser/class.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * PURPOSE:          Window classes
   5  * FILE:             subsystems/win32/win32k/ntuser/class.c
   6  * PROGRAMER:        Thomas Weidenmueller <w3seek@reactos.com>
   7  * REVISION HISTORY:
   8  *       06-06-2001  CSH  Created
   9  */
  10 /* INCLUDES ******************************************************************/
  11
  12 #include <w32k.h>
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16 #define TRACE DPRINT
  17 #define WARN DPRINT1
  18 #define ERR DPRINT1
  19
  20 REGISTER_SYSCLASS DefaultServerClasses[] =
  21 {
  22 /*  { ((PWSTR)((ULONG_PTR)(WORD)(0x8001))),
  23     CS_GLOBALCLASS|CS_DBLCLKS,
  24     NULL,
  25     0,
  26     IDC_ARROW,
  27     (HBRUSH)(COLOR_BACKGROUND+1),
  28     FNID_DESKTOP,
  29     ICLS_DESKTOP
  30   },*/
  31   { ((PWSTR)((ULONG_PTR)(WORD)(0x8003))),
  32     CS_VREDRAW|CS_HREDRAW|CS_SAVEBITS,
  33     NULL, // Use User32 procs
  34     sizeof(LONG),
  35     IDC_ARROW,
  36     NULL,
  37     FNID_SWITCH,
  38     ICLS_SWITCH
  39   },
  40   { ((PWSTR)((ULONG_PTR)(WORD)(0x8000))),
  41     CS_DBLCLKS|CS_SAVEBITS,
  42     NULL, // Use User32 procs
  43     sizeof(LONG),
  44     IDC_ARROW,
  45     (HBRUSH)(COLOR_MENU + 1),
  46     FNID_MENU,
  47     ICLS_MENU
  48   },
  49   { L"ScrollBar",
  50     CS_DBLCLKS|CS_VREDRAW|CS_HREDRAW|CS_PARENTDC,
  51     NULL, // Use User32 procs
  52     0,
  53     IDC_ARROW,
  54     NULL,
  55     FNID_SCROLLBAR,
  56     ICLS_SCROLLBAR
  57   },
  58   { ((PWSTR)((ULONG_PTR)(WORD)(0x8004))), // IconTitle is here for now...
  59     0,
  60     NULL, // Use User32 procs
  61     0,
  62     IDC_ARROW,
  63     0,
  64     FNID_ICONTITLE,
  65     ICLS_ICONTITLE
  66   },
  67   { L"Message",
  68     CS_GLOBALCLASS,
  69     NULL, // Use User32 procs
  70     0,
  71     IDC_ARROW,
  72     NULL,
  73     FNID_MESSAGEWND,
  74     ICLS_HWNDMESSAGE
  75   }
  76 };
  77
  78 static struct
  79 {
  80     int FnId;
  81     int ClsId;
  82 }  FnidToiCls[] =
  83 { /* Function Ids to Class indexes. */
  84  { FNID_SCROLLBAR,  ICLS_SCROLLBAR},
  85  { FNID_ICONTITLE,  ICLS_ICONTITLE},
  86  { FNID_MENU,       ICLS_MENU},
  87  { FNID_DESKTOP,    ICLS_DESKTOP},
  88  { FNID_SWITCH,     ICLS_SWITCH},
  89  { FNID_MESSAGEWND, ICLS_HWNDMESSAGE},
  90  { FNID_BUTTON,     ICLS_BUTTON},
  91  { FNID_COMBOBOX,   ICLS_COMBOBOX},
  92  { FNID_COMBOLBOX,  ICLS_COMBOLBOX},
  93  { FNID_DIALOG,     ICLS_DIALOG},
  94  { FNID_EDIT,       ICLS_EDIT},
  95  { FNID_LISTBOX,    ICLS_LISTBOX},
  96  { FNID_MDICLIENT,  ICLS_MDICLIENT},
  97  { FNID_STATIC,     ICLS_STATIC},
  98  { FNID_IME,        ICLS_IME},
  99  { FNID_GHOST,      ICLS_GHOST},
 100  { FNID_TOOLTIPS,   ICLS_TOOLTIPS}
 101 };
 102
 103 BOOL
 104 FASTCALL
 105 LookupFnIdToiCls(int FnId, int *iCls )
 106 {
 107   int i;
 108
 109   for ( i = 0; i < ARRAYSIZE(FnidToiCls); i++)
 110   {
 111      if (FnidToiCls[i].FnId == FnId)
 112      {
 113         if (iCls) *iCls = FnidToiCls[i].ClsId;
 114         return TRUE;
 115      }
 116   }
 117   if (iCls) *iCls = 0;
 118   return FALSE;
 119 }
 120
 121 /* WINDOWCLASS ***************************************************************/
 122
 123 static VOID
 124 IntFreeClassMenuName(IN OUT PCLS Class)
 125 {
 126     /* free the menu name, if it was changed and allocated */
 127     if (Class->lpszClientUnicodeMenuName != NULL && Class->MenuNameIsString)
 128     {
 129         UserHeapFree(Class->lpszClientUnicodeMenuName);
 130         Class->lpszClientUnicodeMenuName = NULL;
 131         Class->lpszClientAnsiMenuName = NULL;
 132     }
 133 }
 134
 135 static VOID
 136 IntDestroyClass(IN OUT PCLS Class)
 137 {
 138     PDESKTOP pDesk;
 139     /* there shouldn't be any clones anymore */
 140     ASSERT(Class->cWndReferenceCount == 0);
 141     ASSERT(Class->pclsClone == NULL);
 142
 143     if (Class->pclsBase == Class)
 144     {
 145         PCALLPROCDATA CallProc, NextCallProc;
 146
 147         /* Destroy allocated callproc handles */
 148         CallProc = Class->spcpdFirst;
 149         while (CallProc != NULL)
 150         {
 151             NextCallProc = CallProc->spcpdNext;
 152
 153             CallProc->spcpdNext = NULL;
 154             DestroyCallProc(NULL,
 155                             CallProc);
 156
 157             CallProc = NextCallProc;
 158         }
 159
 160         if (Class->pdce)
 161         {
 162            DceFreeClassDCE(((PDCE)Class->pdce)->hDC);
 163            Class->pdce = NULL;
 164         }
 165
 166         IntFreeClassMenuName(Class);
 167     }
 168
 169     pDesk = Class->rpdeskParent;
 170     Class->rpdeskParent = NULL;
 171
 172     /* free the structure */
 173     if (pDesk != NULL)
 174     {
 175         DesktopHeapFree(pDesk, Class);
 176     }
 177     else
 178     {
 179         UserHeapFree(Class);
 180     }
 181 }
 182
 183
 184 /* clean all process classes. all process windows must cleaned first!! */
 185 void FASTCALL DestroyProcessClasses(PPROCESSINFO Process )
 186 {
 187     PCLS Class;
 188     PPROCESSINFO pi = (PPROCESSINFO)Process;
 189
 190     if (pi != NULL)
 191     {
 192         /* free all local classes */
 193         Class = pi->pclsPrivateList;
 194         while (Class != NULL)
 195         {
 196             pi->pclsPrivateList = Class->pclsNext;
 197
 198             ASSERT(Class->pclsBase == Class);
 199             IntDestroyClass(Class);
 200
 201             Class = pi->pclsPrivateList;
 202         }
 203
 204         /* free all global classes */
 205         Class = pi->pclsPublicList;
 206         while (Class != NULL)
 207         {
 208             pi->pclsPublicList = Class->pclsNext;
 209
 210             ASSERT(Class->pclsBase == Class);
 211             IntDestroyClass(Class);
 212
 213             Class = pi->pclsPublicList;
 214         }
 215     }
 216 }
 217
 218 static BOOL
 219 IntRegisterClassAtom(IN PUNICODE_STRING ClassName,
 220                      OUT RTL_ATOM *pAtom)
 221 {
 222     WCHAR szBuf[65];
 223     PWSTR AtomName;
 224     NTSTATUS Status;
 225
 226     if (ClassName->Length != 0)
 227     {
 228         /* FIXME - Don't limit to 64 characters! use SEH when allocating memory! */
 229         if (ClassName->Length / sizeof(WCHAR) >= sizeof(szBuf) / sizeof(szBuf[0]))
 230         {
 231             SetLastWin32Error(ERROR_INVALID_PARAMETER);
 232             return (RTL_ATOM)0;
 233         }
 234
 235         RtlCopyMemory(szBuf,
 236                       ClassName->Buffer,
 237                       ClassName->Length);
 238         szBuf[ClassName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 239         AtomName = szBuf;
 240     }
 241     else
 242         AtomName = ClassName->Buffer;
 243
 244     Status = RtlAddAtomToAtomTable(gAtomTable,
 245                                    AtomName,
 246                                    pAtom);
 247
 248     if (!NT_SUCCESS(Status))
 249     {
 250         SetLastNtError(Status);
 251         return FALSE;
 252     }
 253
 254     return TRUE;
 255 }
 256
 257 static NTSTATUS
 258 IntDeregisterClassAtom(IN RTL_ATOM Atom)
 259 {
 260     return RtlDeleteAtomFromAtomTable(gAtomTable,
 261                                       Atom);
 262 }
 263
 264 VOID
 265 UserAddCallProcToClass(IN OUT PCLS Class,
 266                        IN PCALLPROCDATA CallProc)
 267 {
 268     PCLS BaseClass;
 269
 270     ASSERT(CallProc->spcpdNext == NULL);
 271
 272     BaseClass = Class->pclsBase;
 273     ASSERT(CallProc->spcpdNext == NULL);
 274     CallProc->spcpdNext = BaseClass->spcpdFirst;
 275     BaseClass->spcpdFirst = CallProc;
 276
 277     /* Update all clones */
 278     Class = Class->pclsClone;
 279     while (Class != NULL)
 280     {
 281         Class->spcpdFirst = BaseClass->spcpdFirst;
 282         Class = Class->pclsNext;
 283     }
 284 }
 285
 286 static BOOL
 287 IntSetClassAtom(IN OUT PCLS Class,
 288                 IN PUNICODE_STRING ClassName)
 289 {
 290     RTL_ATOM Atom = (RTL_ATOM)0;
 291
 292     /* update the base class first */
 293     Class = Class->pclsBase;
 294
 295     if (!IntRegisterClassAtom(ClassName,
 296                               &Atom))
 297     {
 298         return FALSE;
 299     }
 300
 301     IntDeregisterClassAtom(Class->atomClassName);
 302
 303     Class->atomClassName = Atom;
 304
 305     /* update the clones */
 306     Class = Class->pclsClone;
 307     while (Class != NULL)
 308     {
 309         Class->atomClassName = Atom;
 310
 311         Class = Class->pclsNext;
 312     }
 313
 314     return TRUE;
 315 }
 316
 317 //
 318 // Same as User32:IntGetClsWndProc.
 319 //
 320 WNDPROC FASTCALL
 321 IntGetClassWndProc(PCLS Class, BOOL Ansi)
 322 {
 323   INT i;
 324   WNDPROC gcpd = NULL, Ret = NULL;
 325
 326   if (Class->CSF_flags & CSF_SERVERSIDEPROC)
 327   {
 328      for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
 329      {
 330          if (GETPFNSERVER(i) == Class->lpfnWndProc)
 331          {
 332             if (Ansi)
 333                Ret = GETPFNCLIENTA(i);
 334             else
 335                Ret = GETPFNCLIENTW(i);
 336          }
 337      }
 338      return Ret;
 339   }
 340   Ret = Class->lpfnWndProc;
 341
 342   if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
 343   {
 344      if (Ansi)
 345      {
 346         if (GETPFNCLIENTW(Class->fnid) == Class->lpfnWndProc)
 347            Ret = GETPFNCLIENTA(Class->fnid);
 348      }
 349      else
 350      {
 351         if (GETPFNCLIENTA(Class->fnid) == Class->lpfnWndProc)
 352            Ret = GETPFNCLIENTW(Class->fnid);
 353      }
 354   }
 355
 356   if ( Ret != Class->lpfnWndProc ||
 357        Ansi == !!(Class->CSF_flags & CSF_ANSIPROC) )
 358      return Ret;
 359
 360   gcpd = (WNDPROC)UserGetCPD( Class,
 361                        (Ansi ? UserGetCPDA2U : UserGetCPDU2A )|UserGetCPDClass,
 362                        (ULONG_PTR)Ret);
 363
 364   return (gcpd ? gcpd : Ret);
 365 }
 366
 367
 368 static
 369 WNDPROC FASTCALL
 370 IntSetClassWndProc(IN OUT PCLS Class,
 371                    IN WNDPROC WndProc,
 372                    IN BOOL Ansi)
 373 {
 374    INT i;
 375    PCALLPROCDATA pcpd;
 376    WNDPROC Ret, chWndProc;
 377
 378    Ret = IntGetClassWndProc(Class, Ansi);
 379
 380    // If Server Side, downgrade to Client Side.
 381    if (Class->CSF_flags & CSF_SERVERSIDEPROC)
 382    {
 383       if (Ansi) Class->CSF_flags |= CSF_ANSIPROC;
 384       Class->CSF_flags &= ~CSF_SERVERSIDEPROC;
 385       Class->Unicode = !Ansi;
 386    }
 387
 388    if (!WndProc) WndProc = Class->lpfnWndProc;
 389
 390    chWndProc = WndProc;
 391
 392    // Check if CallProc handle and retrieve previous call proc address and set.
 393    if (IsCallProcHandle(WndProc))
 394    {
 395       pcpd = UserGetObject(gHandleTable, WndProc, otCallProc);
 396       if (pcpd) chWndProc = pcpd->pfnClientPrevious;
 397    }
 398
 399    Class->lpfnWndProc = chWndProc;
 400
 401    // Clear test proc.
 402    chWndProc = NULL;
 403
 404    // Switch from Client Side call to Server Side call if match. Ref: "deftest".
 405    for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
 406    {
 407        if (GETPFNCLIENTW(i) == Class->lpfnWndProc)
 408        {
 409           chWndProc = GETPFNSERVER(i);
 410           break;
 411        }
 412        if (GETPFNCLIENTA(i) == Class->lpfnWndProc)
 413        {
 414           chWndProc = GETPFNSERVER(i);
 415           break;
 416        }
 417    }
 418    // If match, set/reset to Server Side and clear ansi.
 419    if (chWndProc)
 420    {
 421       Class->lpfnWndProc = chWndProc;
 422       Class->Unicode = TRUE;
 423       Class->CSF_flags &= ~CSF_ANSIPROC;
 424       Class->CSF_flags |= CSF_SERVERSIDEPROC;
 425    }
 426    else
 427    {
 428       Class->Unicode = !Ansi;
 429
 430       if (Ansi)
 431          Class->CSF_flags |= CSF_ANSIPROC;
 432       else
 433          Class->CSF_flags &= ~CSF_ANSIPROC;
 434    }
 435
 436    /* update the clones */
 437    chWndProc = Class->lpfnWndProc;
 438
 439    Class = Class->pclsClone;
 440    while (Class != NULL)
 441    {
 442       Class->Unicode = !Ansi;
 443       Class->lpfnWndProc = chWndProc;
 444
 445       Class = Class->pclsNext;
 446    }
 447
 448    return Ret;
 449 }
 450
 451 static PCLS
 452 IntGetClassForDesktop(IN OUT PCLS BaseClass,
 453                       IN OUT PCLS *ClassLink,
 454                       IN PDESKTOP Desktop)
 455 {
 456     SIZE_T ClassSize;
 457     PCLS Class;
 458
 459     ASSERT(Desktop != NULL);
 460     ASSERT(BaseClass->pclsBase == BaseClass);
 461
 462     if (BaseClass->rpdeskParent == Desktop)
 463     {
 464         /* it is most likely that a window is created on the same
 465            desktop as the window class. */
 466
 467         return BaseClass;
 468     }
 469
 470     if (BaseClass->rpdeskParent == NULL)
 471     {
 472         ASSERT(BaseClass->cWndReferenceCount == 0);
 473         ASSERT(BaseClass->pclsClone == NULL);
 474
 475         /* Classes are also located in the shared heap when the class
 476            was created before the thread attached to a desktop. As soon
 477            as a window is created for such a class located on the shared
 478            heap, the class is cloned into the desktop heap on which the
 479            window is created. */
 480         Class = NULL;
 481     }
 482     else
 483     {
 484         /* The user is asking for a class object on a different desktop,
 485            try to find one! */
 486         Class = BaseClass->pclsClone;
 487         while (Class != NULL)
 488         {
 489             if (Class->rpdeskParent == Desktop)
 490             {
 491                 ASSERT(Class->pclsBase == BaseClass);
 492                 ASSERT(Class->pclsClone == NULL);
 493                 break;
 494             }
 495
 496             Class = Class->pclsNext;
 497         }
 498     }
 499
 500     if (Class == NULL)
 501     {
 502         /* The window is created on a different desktop, we need to
 503            clone the class object to the desktop heap of the window! */
 504         ClassSize = sizeof(*BaseClass) + (SIZE_T)BaseClass->cbclsExtra;
 505
 506         Class = DesktopHeapAlloc(Desktop,
 507                                  ClassSize);
 508         if (Class != NULL)
 509         {
 510             /* simply clone the class */
 511             RtlCopyMemory( Class, BaseClass, ClassSize);
 512
 513             DPRINT("Clone Class 0x%x hM 0x%x\n %S\n",Class, Class->hModule, Class->lpszClientUnicodeMenuName);
 514
 515             /* restore module address if default user class Ref: Bug 4778 */
 516             if ( Class->hModule != hModClient &&
 517                  Class->fnid <= FNID_GHOST    &&
 518                  Class->fnid >= FNID_BUTTON )
 519             {
 520                Class->hModule = hModClient;
 521                DPRINT("Clone Class 0x%x Reset hM 0x%x\n",Class, Class->hModule);
 522             }
 523
 524             /* update some pointers and link the class */
 525             Class->rpdeskParent = Desktop;
 526             Class->cWndReferenceCount = 0;
 527
 528             if (BaseClass->rpdeskParent == NULL)
 529             {
 530                 /* we don't really need the base class on the shared
 531                    heap anymore, delete it so the only class left is
 532                    the clone we just created, which now serves as the
 533                    new base class */
 534                 ASSERT(BaseClass->pclsClone == NULL);
 535                 ASSERT(Class->pclsClone == NULL);
 536                 Class->pclsBase = Class;
 537                 Class->pclsNext = BaseClass->pclsNext;
 538
 539                 /* replace the base class */
 540                 (void)InterlockedExchangePointer((PVOID*)ClassLink,
 541                                                  Class);
 542
 543                 /* destroy the obsolete copy on the shared heap */
 544                 BaseClass->pclsBase = NULL;
 545                 BaseClass->pclsClone = NULL;
 546                 IntDestroyClass(BaseClass);
 547             }
 548             else
 549             {
 550                 /* link in the clone */
 551                 Class->pclsClone = NULL;
 552                 Class->pclsBase = BaseClass;
 553                 Class->pclsNext = BaseClass->pclsClone;
 554                 (void)InterlockedExchangePointer((PVOID*)&BaseClass->pclsClone,
 555                                                  Class);
 556             }
 557         }
 558         else
 559         {
 560             SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
 561         }
 562     }
 563     return Class;
 564 }
 565
 566 PCLS
 567 IntReferenceClass(IN OUT PCLS BaseClass,
 568                   IN OUT PCLS *ClassLink,
 569                   IN PDESKTOP Desktop)
 570 {
 571     PCLS Class;
 572     ASSERT(BaseClass->pclsBase == BaseClass);
 573
 574     Class = IntGetClassForDesktop(BaseClass,
 575                                   ClassLink,
 576                                   Desktop);
 577     if (Class != NULL)
 578     {
 579         Class->cWndReferenceCount++;
 580     }
 581
 582     return Class;
 583 }
 584
 585 static
 586 VOID
 587 IntMakeCloneBaseClass(IN OUT PCLS Class,
 588                       IN OUT PCLS *BaseClassLink,
 589                       IN OUT PCLS *CloneLink)
 590 {
 591     PCLS Clone, BaseClass;
 592
 593     ASSERT(Class->pclsBase != Class);
 594     ASSERT(Class->pclsBase->pclsClone != NULL);
 595     ASSERT(Class->rpdeskParent != NULL);
 596     ASSERT(Class->cWndReferenceCount != 0);
 597     ASSERT(Class->pclsBase->rpdeskParent != NULL);
 598     ASSERT(Class->pclsBase->cWndReferenceCount == 0);
 599
 600     /* unlink the clone */
 601     *CloneLink = Class->pclsNext;
 602     Class->pclsClone = Class->pclsBase->pclsClone;
 603
 604     BaseClass = Class->pclsBase;
 605
 606     /* update the class information to make it a base class */
 607     Class->pclsBase = Class;
 608     Class->pclsNext = (*BaseClassLink)->pclsNext;
 609
 610     /* update all clones */
 611     Clone = Class->pclsClone;
 612     while (Clone != NULL)
 613     {
 614         ASSERT(Clone->pclsClone == NULL);
 615         Clone->pclsBase = Class;
 616
 617         Clone = Clone->pclsNext;
 618     }
 619
 620     /* link in the new base class */
 621     (void)InterlockedExchangePointer((PVOID*)BaseClassLink,
 622                                      Class);
 623 }
 624
 625
 626 VOID
 627 IntDereferenceClass(IN OUT PCLS Class,
 628                     IN PDESKTOPINFO Desktop,
 629                     IN PPROCESSINFO pi)
 630 {
 631     PCLS *PrevLink, BaseClass, CurrentClass;
 632
 633     BaseClass = Class->pclsBase;
 634
 635     if (--Class->cWndReferenceCount <= 0)
 636     {
 637         if (BaseClass == Class)
 638         {
 639             ASSERT(Class->pclsBase == Class);
 640
 641             DPRINT("IntDereferenceClass 0x%x\n", Class);
 642             /* check if there are clones of the class on other desktops,
 643                link the first clone in if possible. If there are no clones
 644                then leave the class on the desktop heap. It will get moved
 645                to the shared heap when the thread detaches. */
 646             if (BaseClass->pclsClone != NULL)
 647             {
 648                 if (BaseClass->Global)
 649                     PrevLink = &pi->pclsPublicList;
 650                 else
 651                     PrevLink = &pi->pclsPrivateList;
 652
 653                 CurrentClass = *PrevLink;
 654                 while (CurrentClass != BaseClass)
 655                 {
 656                     ASSERT(CurrentClass != NULL);
 657
 658                     PrevLink = &CurrentClass->pclsNext;
 659                     CurrentClass = CurrentClass->pclsNext;
 660                 }
 661
 662                 ASSERT(*PrevLink == BaseClass);
 663
 664                 /* make the first clone become the new base class */
 665                 IntMakeCloneBaseClass(BaseClass->pclsClone,
 666                                       PrevLink,
 667                                       &BaseClass->pclsClone);
 668
 669                 /* destroy the class, there's still another clone of the class
 670                    that now serves as a base class. Make sure we don't destruct
 671                    resources shared by all classes (Base = NULL)! */
 672                 BaseClass->pclsBase = NULL;
 673                 BaseClass->pclsClone = NULL;
 674                 IntDestroyClass(BaseClass);
 675             }
 676         }
 677         else
 678         {
 679             DPRINT("IntDereferenceClass1 0x%x\n", Class);
 680
 681             /* locate the cloned class and unlink it */
 682             PrevLink = &BaseClass->pclsClone;
 683             CurrentClass = BaseClass->pclsClone;
 684             while (CurrentClass != Class)
 685             {
 686                 ASSERT(CurrentClass != NULL);
 687
 688                 PrevLink = &CurrentClass->pclsNext;
 689                 CurrentClass = CurrentClass->pclsNext;
 690             }
 691
 692             ASSERT(CurrentClass == Class);
 693
 694             (void)InterlockedExchangePointer((PVOID*)PrevLink,
 695                                              Class->pclsNext);
 696
 697             ASSERT(Class->pclsBase == BaseClass);
 698             ASSERT(Class->pclsClone == NULL);
 699
 700             /* the class was just a clone, we don't need it anymore */
 701             IntDestroyClass(Class);
 702         }
 703     }
 704 }
 705
 706 static BOOL
 707 IntMoveClassToSharedHeap(IN OUT PCLS Class,
 708                          IN OUT PCLS **ClassLinkPtr)
 709 {
 710     PCLS NewClass;
 711     SIZE_T ClassSize;
 712
 713     ASSERT(Class->pclsBase == Class);
 714     ASSERT(Class->rpdeskParent != NULL);
 715     ASSERT(Class->cWndReferenceCount == 0);
 716     ASSERT(Class->pclsClone == NULL);
 717
 718     ClassSize = sizeof(*Class) + (SIZE_T)Class->cbclsExtra;
 719
 720     /* allocate the new base class on the shared heap */
 721     NewClass = UserHeapAlloc(ClassSize);
 722     if (NewClass != NULL)
 723     {
 724         RtlCopyMemory(NewClass,
 725                       Class,
 726                       ClassSize);
 727
 728         NewClass->rpdeskParent = NULL;
 729         NewClass->pclsBase = NewClass;
 730
 731         /* replace the class in the list */
 732         (void)InterlockedExchangePointer((PVOID*)*ClassLinkPtr,
 733                                          NewClass);
 734         *ClassLinkPtr = &NewClass->pclsNext;
 735
 736         /* free the obsolete class on the desktop heap */
 737         Class->pclsBase = NULL;
 738         IntDestroyClass(Class);
 739         return TRUE;
 740     }
 741
 742     return FALSE;
 743 }
 744
 745 static VOID
 746 IntCheckDesktopClasses(IN PDESKTOP Desktop,
 747                        IN OUT PCLS *ClassList,
 748                        IN BOOL FreeOnFailure,
 749                        OUT BOOL *Ret)
 750 {
 751     PCLS Class, NextClass, *Link;
 752
 753     /* NOTE: We only need to check base classes! When classes are no longer needed
 754              on a desktop, the clones will be freed automatically as soon as possible.
 755              However, we need to move base classes to the shared heap, as soon as
 756              the last desktop heap where a class is allocated on is about to be destroyed.
 757              If we didn't move the class to the shared heap, the class would become
 758              inaccessible! */
 759
 760     ASSERT(Desktop != NULL);
 761
 762     Link = ClassList;
 763     Class = *Link;
 764     while (Class != NULL)
 765     {
 766         NextClass = Class->pclsNext;
 767
 768         ASSERT(Class->pclsBase == Class);
 769
 770         if (Class->rpdeskParent == Desktop &&
 771             Class->cWndReferenceCount == 0)
 772         {
 773             /* there shouldn't be any clones around anymore! */
 774             ASSERT(Class->pclsClone == NULL);
 775
 776             /* FIXME - If process is terminating, don't move the class but rather destroy it! */
 777             /* FIXME - We could move the class to another desktop heap if there's still desktops
 778                        mapped into the process... */
 779
 780             /* move the class to the shared heap */
 781             if (IntMoveClassToSharedHeap(Class,
 782                                          &Link))
 783             {
 784                 ASSERT(*Link == NextClass);
 785             }
 786             else
 787             {
 788                 ASSERT(NextClass == Class->pclsNext);
 789
 790                 if (FreeOnFailure)
 791                 {
 792                     /* unlink the base class */
 793                     (void)InterlockedExchangePointer((PVOID*)Link,
 794                                                      Class->pclsNext);
 795
 796                     /* we can free the old base class now */
 797                     Class->pclsBase = NULL;
 798                     IntDestroyClass(Class);
 799                 }
 800                 else
 801                 {
 802                     Link = &Class->pclsNext;
 803                     *Ret = FALSE;
 804                 }
 805             }
 806         }
 807         else
 808             Link = &Class->pclsNext;
 809
 810         Class = NextClass;
 811     }
 812 }
 813
 814 BOOL
 815 IntCheckProcessDesktopClasses(IN PDESKTOP Desktop,
 816                               IN BOOL FreeOnFailure)
 817 {
 818     PPROCESSINFO pi;
 819     BOOL Ret = TRUE;
 820
 821     pi = GetW32ProcessInfo();
 822
 823     /* check all local classes */
 824     IntCheckDesktopClasses(Desktop,
 825                            &pi->pclsPrivateList,
 826                            FreeOnFailure,
 827                            &Ret);
 828
 829     /* check all global classes */
 830     IntCheckDesktopClasses(Desktop,
 831                            &pi->pclsPublicList,
 832                            FreeOnFailure,
 833                            &Ret);
 834     if (!Ret)
 835     {
 836         DPRINT1("Failed to move process classes from desktop 0x%p to the shared heap!\n", Desktop);
 837         SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
 838     }
 839
 840     return Ret;
 841 }
 842
 843 PCLS
 844 FASTCALL
 845 IntCreateClass(IN CONST WNDCLASSEXW* lpwcx,
 846                IN PUNICODE_STRING ClassName,
 847                IN PUNICODE_STRING MenuName,
 848                IN DWORD fnID,
 849                IN DWORD dwFlags,
 850                IN PDESKTOP Desktop,
 851                IN PPROCESSINFO pi)
 852 {
 853     SIZE_T ClassSize;
 854     PCLS Class = NULL;
 855     RTL_ATOM Atom;
 856     WNDPROC WndProc;
 857     PWSTR pszMenuName = NULL;
 858     NTSTATUS Status = STATUS_SUCCESS;
 859
 860     DPRINT("lpwcx=%p ClassName=%wZ MenuName=%wZ dwFlags=%08x Desktop=%p pi=%p\n",
 861         lpwcx, ClassName, MenuName, dwFlags, Desktop, pi);
 862
 863     if (!IntRegisterClassAtom(ClassName,
 864                               &Atom))
 865     {
 866         DPRINT1("Failed to register class atom!\n");
 867         return NULL;
 868     }
 869
 870     ClassSize = sizeof(*Class) + lpwcx->cbClsExtra;
 871     if (MenuName->Length != 0)
 872     {
 873         pszMenuName = UserHeapAlloc(MenuName->Length + sizeof(UNICODE_NULL) +
 874                                     RtlUnicodeStringToAnsiSize(MenuName));
 875         if (pszMenuName == NULL)
 876             goto NoMem;
 877     }
 878
 879     if (Desktop != NULL)
 880     {
 881         Class = DesktopHeapAlloc(Desktop,
 882                                  ClassSize);
 883     }
 884     else
 885     {
 886         /* FIXME - the class was created before being connected
 887                    to a desktop. It is possible for the desktop window,
 888                    but should it be allowed for any other case? */
 889         Class = UserHeapAlloc(ClassSize);
 890     }
 891
 892     if (Class != NULL)
 893     {
 894         int iCls = 0;
 895
 896         RtlZeroMemory(Class, ClassSize);
 897
 898         Class->rpdeskParent = Desktop;
 899         Class->pclsBase = Class;
 900         Class->atomClassName = Atom;
 901         Class->fnid = fnID;
 902         Class->CSF_flags = dwFlags;
 903
 904         if (LookupFnIdToiCls(Class->fnid, &iCls))
 905         {
 906             gpsi->atomSysClass[iCls] = Class->atomClassName;
 907         }
 908
 909         _SEH2_TRY
 910         {
 911             PWSTR pszMenuNameBuffer = pszMenuName;
 912
 913             /* need to protect with SEH since accessing the WNDCLASSEX structure
 914                and string buffers might raise an exception! We don't want to
 915                leak memory... */
 916             // What?! If the user interface was written correctly this would not be an issue!
 917             Class->lpfnWndProc = lpwcx->lpfnWndProc;
 918             Class->style = lpwcx->style;
 919             Class->cbclsExtra = lpwcx->cbClsExtra;
 920             Class->cbwndExtra = lpwcx->cbWndExtra;
 921             Class->hModule = lpwcx->hInstance;
 922             Class->hIcon = lpwcx->hIcon; /* FIXME */
 923             Class->hIconSm = lpwcx->hIconSm; /* FIXME */
 924             Class->hCursor = lpwcx->hCursor; /* FIXME */
 925             Class->hbrBackground = lpwcx->hbrBackground;
 926
 927             /* make a copy of the string */
 928             if (pszMenuNameBuffer != NULL)
 929             {
 930                 Class->MenuNameIsString = TRUE;
 931
 932                 Class->lpszClientUnicodeMenuName = pszMenuNameBuffer;
 933                 RtlCopyMemory(Class->lpszClientUnicodeMenuName,
 934                               MenuName->Buffer,
 935                               MenuName->Length);
 936                 Class->lpszClientUnicodeMenuName[MenuName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 937
 938                 pszMenuNameBuffer += (MenuName->Length / sizeof(WCHAR)) + 1;
 939             }
 940             else
 941                 Class->lpszClientUnicodeMenuName = MenuName->Buffer;
 942
 943             /* save an ansi copy of the string */
 944             if (pszMenuNameBuffer != NULL)
 945             {
 946                 ANSI_STRING AnsiString;
 947
 948                 Class->lpszClientAnsiMenuName = (PSTR)pszMenuNameBuffer;
 949                 AnsiString.MaximumLength = RtlUnicodeStringToAnsiSize(MenuName);
 950                 AnsiString.Buffer = Class->lpszClientAnsiMenuName;
 951                 Status = RtlUnicodeStringToAnsiString(&AnsiString,
 952                                                       MenuName,
 953                                                       FALSE);
 954                 if (!NT_SUCCESS(Status))
 955                 {
 956                     DPRINT1("Failed to convert unicode menu name to ansi!\n");
 957
 958                     /* life would've been much prettier if ntoskrnl exported RtlRaiseStatus()... */
 959                     _SEH2_LEAVE;
 960                 }
 961             }
 962             else
 963                 Class->lpszClientAnsiMenuName = (PSTR)MenuName->Buffer;
 964
 965             /* Save kernel use menu name and ansi class name */
 966             Class->lpszMenuName = Class->lpszClientUnicodeMenuName; // Fixme!
 967             //Class->lpszAnsiClassName = Fixme!
 968
 969             /* Server Side overrides class calling type (A/W)!
 970                User32 whine test_builtinproc: "deftest"
 971                   built-in winproc - window A/W type automatically detected */
 972             if (!(Class->CSF_flags & CSF_SERVERSIDEPROC))
 973             {
 974                int i;
 975                WndProc = NULL;
 976           /* Due to the wine class "deftest" and most likely no FNID to reference
 977              from, sort through the Server Side list and compare proc addresses
 978              for match. This method will be used in related code.
 979            */
 980                for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
 981                { // Open Ansi or Unicode, just match, set and break.
 982                    if (GETPFNCLIENTW(i) == Class->lpfnWndProc)
 983                    {
 984                       WndProc = GETPFNSERVER(i);
 985                       break;
 986                    }
 987                    if (GETPFNCLIENTA(i) == Class->lpfnWndProc)
 988                    {
 989                       WndProc = GETPFNSERVER(i);
 990                       break;
 991                    }
 992                }
 993                if (WndProc)
 994                {  // If a hit, we are Server Side so set the right flags and proc.
 995                   Class->CSF_flags |= CSF_SERVERSIDEPROC;
 996                   Class->CSF_flags &= ~CSF_ANSIPROC;
 997                   Class->lpfnWndProc = WndProc;
 998                }
 999             }
1000
1001             if (!(Class->CSF_flags & CSF_ANSIPROC))
1002                 Class->Unicode = TRUE;
1003
1004             if (Class->style & CS_GLOBALCLASS)
1005                 Class->Global = TRUE;
1006         }
1007         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1008         {
1009             Status = _SEH2_GetExceptionCode();
1010         }
1011         _SEH2_END;
1012
1013         if (!NT_SUCCESS(Status))
1014         {
1015             DPRINT1("Failed creating the class: 0x%x\n", Status);
1016
1017             SetLastNtError(Status);
1018
1019             if (pszMenuName != NULL)
1020                 UserHeapFree(pszMenuName);
1021
1022             DesktopHeapFree(Desktop,
1023                             Class);
1024             Class = NULL;
1025
1026             IntDeregisterClassAtom(Atom);
1027         }
1028     }
1029     else
1030     {
1031 NoMem:
1032         DPRINT1("Failed to allocate class on Desktop 0x%p\n", Desktop);
1033
1034         if (pszMenuName != NULL)
1035             UserHeapFree(pszMenuName);
1036
1037         IntDeregisterClassAtom(Atom);
1038
1039         SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1040     }
1041
1042     return Class;
1043 }
1044
1045 static PCLS
1046 IntFindClass(IN RTL_ATOM Atom,
1047              IN HINSTANCE hInstance,
1048              IN PCLS *ClassList,
1049              OUT PCLS **Link  OPTIONAL)
1050 {
1051     PCLS Class, *PrevLink = ClassList;
1052
1053     Class = *PrevLink;
1054     while (Class != NULL)
1055     {
1056         if (Class->atomClassName == Atom &&
1057             (hInstance == NULL || Class->hModule == hInstance) &&
1058             !(Class->CSF_flags & CSF_WOWDEFERDESTROY))
1059         {
1060             ASSERT(Class->pclsBase == Class);
1061
1062             if (Link != NULL)
1063                 *Link = PrevLink;
1064             break;
1065         }
1066
1067         PrevLink = &Class->pclsNext;
1068         Class = Class->pclsNext;
1069     }
1070
1071     return Class;
1072 }
1073
1074 BOOL
1075 IntGetAtomFromStringOrAtom(IN PUNICODE_STRING ClassName,
1076                            OUT RTL_ATOM *Atom)
1077 {
1078     BOOL Ret = FALSE;
1079
1080     if (ClassName->Length != 0)
1081     {
1082         WCHAR szBuf[65];
1083         PWSTR AtomName;
1084         NTSTATUS Status;
1085
1086         /* NOTE: Caller has to protect the call with SEH! */
1087
1088         if (ClassName->Length != 0)
1089         {
1090             /* FIXME - Don't limit to 64 characters! use SEH when allocating memory! */
1091             if (ClassName->Length / sizeof(WCHAR) >= sizeof(szBuf) / sizeof(szBuf[0]))
1092             {
1093                 SetLastWin32Error(ERROR_INVALID_PARAMETER);
1094                 return (RTL_ATOM)0;
1095             }
1096
1097             /* We need to make a local copy of the class name! The caller could
1098                modify the buffer and we could overflow in RtlLookupAtomInAtomTable.
1099                We're protected by SEH, but the ranges that might be accessed were
1100                not probed... */
1101             RtlCopyMemory(szBuf,
1102                           ClassName->Buffer,
1103                           ClassName->Length);
1104             szBuf[ClassName->Length / sizeof(WCHAR)] = UNICODE_NULL;
1105             AtomName = szBuf;
1106         }
1107         else
1108             AtomName = ClassName->Buffer;
1109
1110         /* lookup the atom */
1111         Status = RtlLookupAtomInAtomTable(gAtomTable,
1112                                           AtomName,
1113                                           Atom);
1114         if (NT_SUCCESS(Status))
1115         {
1116             Ret = TRUE;
1117         }
1118         else
1119         {
1120             if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
1121             {
1122                 SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
1123             }
1124             else
1125             {
1126                 SetLastNtError(Status);
1127             }
1128         }
1129     }
1130     else
1131     {
1132         ASSERT(IS_ATOM(ClassName->Buffer));
1133         *Atom = (RTL_ATOM)((ULONG_PTR)ClassName->Buffer);
1134         Ret = TRUE;
1135     }
1136
1137     return Ret;
1138 }
1139
1140 RTL_ATOM
1141 IntGetClassAtom(IN PUNICODE_STRING ClassName,
1142                 IN HINSTANCE hInstance  OPTIONAL,
1143                 IN PPROCESSINFO pi  OPTIONAL,
1144                 OUT PCLS *BaseClass  OPTIONAL,
1145                 OUT PCLS **Link  OPTIONAL)
1146 {
1147     RTL_ATOM Atom = (RTL_ATOM)0;
1148
1149     ASSERT(BaseClass != NULL);
1150
1151     if (IntGetAtomFromStringOrAtom(ClassName,
1152                                    &Atom) &&
1153         Atom != (RTL_ATOM)0)
1154     {
1155         PCLS Class;
1156
1157         /* attempt to locate the class object */
1158
1159         ASSERT(pi != NULL);
1160
1161         /* Step 1: try to find an exact match of locally registered classes */
1162         Class = IntFindClass(Atom,
1163                              hInstance,
1164                              &pi->pclsPrivateList,
1165                              Link);
1166         if (Class != NULL)
1167         {  DPRINT("Step 1: 0x%x\n",Class );
1168             goto FoundClass;
1169         }
1170
1171         /* Step 2: try to find any globally registered class. The hInstance
1172                    is not relevant for global classes */
1173         Class = IntFindClass(Atom,
1174                              NULL,
1175                              &pi->pclsPublicList,
1176                              Link);
1177         if (Class != NULL)
1178         { DPRINT("Step 2: 0x%x 0x%x\n",Class, Class->hModule);
1179             goto FoundClass;
1180         }
1181
1182         /* Step 3: try to find any local class registered by user32 */
1183         Class = IntFindClass(Atom,
1184                              hModClient,
1185                              &pi->pclsPrivateList,
1186                              Link);
1187         if (Class != NULL)
1188         { DPRINT("Step 3: 0x%x\n",Class );
1189             goto FoundClass;
1190         }
1191
1192         /* Step 4: try to find any global class registered by user32 */
1193         Class = IntFindClass(Atom,
1194                              hModClient,
1195                              &pi->pclsPublicList,
1196                              Link);
1197         if (Class == NULL)
1198         {
1199             SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
1200             return (RTL_ATOM)0;
1201         }else{DPRINT("Step 4: 0x%x\n",Class );}
1202
1203 FoundClass:
1204         *BaseClass = Class;
1205     }
1206
1207     return Atom;
1208 }
1209
1210 RTL_ATOM
1211 UserRegisterClass(IN CONST WNDCLASSEXW* lpwcx,
1212                   IN PUNICODE_STRING ClassName,
1213                   IN PUNICODE_STRING MenuName,
1214                   IN DWORD fnID,
1215                   IN DWORD dwFlags)
1216 {
1217     PTHREADINFO pti;
1218     PPROCESSINFO pi;
1219     PCLS Class;
1220     RTL_ATOM ClassAtom;
1221     RTL_ATOM Ret = (RTL_ATOM)0;
1222
1223     /* NOTE: Accessing the buffers in ClassName and MenuName may raise exceptions! */
1224
1225     pti = GetW32ThreadInfo();
1226
1227     pi = pti->ppi;
1228
1229     // Need only to test for two conditions not four....... Fix more whine tests....
1230     if ( IntGetAtomFromStringOrAtom( ClassName, &ClassAtom) &&
1231                                      ClassAtom != (RTL_ATOM)0 &&
1232                                     !(dwFlags & CSF_SERVERSIDEPROC) ) // Bypass Server Sides
1233     {
1234        Class = IntFindClass( ClassAtom,
1235                              lpwcx->hInstance,
1236                             &pi->pclsPrivateList,
1237                              NULL);
1238
1239        if (Class != NULL && !Class->Global)
1240        {
1241           // local class already exists
1242           DPRINT("Local Class 0x%p does already exist!\n", ClassAtom);
1243           SetLastWin32Error(ERROR_CLASS_ALREADY_EXISTS);
1244           return (RTL_ATOM)0;
1245        }
1246
1247        if (lpwcx->style & CS_GLOBALCLASS)
1248        {
1249           Class = IntFindClass( ClassAtom,
1250                                 NULL,
1251                                &pi->pclsPublicList,
1252                                 NULL);
1253
1254           if (Class != NULL && Class->Global)
1255           {
1256              DPRINT("Global Class 0x%p does already exist!\n", ClassAtom);
1257              SetLastWin32Error(ERROR_CLASS_ALREADY_EXISTS);
1258              return (RTL_ATOM)0;
1259           }
1260        }
1261     }
1262
1263     Class = IntCreateClass(lpwcx,
1264                            ClassName,
1265                            MenuName,
1266                            fnID,
1267                            dwFlags,
1268                            pti->rpdesk,
1269                            pi);
1270
1271     if (Class != NULL)
1272     {
1273         PCLS *List;
1274
1275         /* Register the class */
1276         if (Class->Global)
1277             List = &pi->pclsPublicList;
1278         else
1279             List = &pi->pclsPrivateList;
1280
1281         Class->pclsNext = *List;
1282         (void)InterlockedExchangePointer((PVOID*)List,
1283                                          Class);
1284
1285         Ret = Class->atomClassName;
1286     }
1287     else
1288     {
1289        DPRINT1("UserRegisterClass: Yes, that is right, you have no Class!\n");
1290     }
1291
1292     return Ret;
1293 }
1294
1295 BOOL
1296 UserUnregisterClass(IN PUNICODE_STRING ClassName,
1297                     IN HINSTANCE hInstance,
1298                     OUT PCLSMENUNAME pClassMenuName)
1299 {
1300     PCLS *Link;
1301     PPROCESSINFO pi;
1302     RTL_ATOM ClassAtom;
1303     PCLS Class;
1304
1305     pi = GetW32ProcessInfo();
1306
1307     DPRINT("UserUnregisterClass(%wZ, 0x%x)\n", ClassName, hInstance);
1308
1309     /* NOTE: Accessing the buffer in ClassName may raise an exception! */
1310     ClassAtom = IntGetClassAtom(ClassName,
1311                                 hInstance,
1312                                 pi,
1313                                 &Class,
1314                                 &Link);
1315     if (ClassAtom == (RTL_ATOM)0)
1316     {
1317         DPRINT("UserUnregisterClass: No Class found.\n");
1318         return FALSE;
1319     }
1320
1321     ASSERT(Class != NULL);
1322
1323     if (Class->cWndReferenceCount != 0 ||
1324         Class->pclsClone != NULL)
1325     {
1326         DPRINT("UserUnregisterClass: Class has a Window. Ct %d : Clone 0x%x\n", Class->cWndReferenceCount, Class->pclsClone);
1327         SetLastWin32Error(ERROR_CLASS_HAS_WINDOWS);
1328         return FALSE;
1329     }
1330
1331     /* must be a base class! */
1332     ASSERT(Class->pclsBase == Class);
1333
1334     /* unlink the class */
1335     *Link = Class->pclsNext;
1336
1337     if (NT_SUCCESS(IntDeregisterClassAtom(Class->atomClassName)))
1338     {
1339         DPRINT("Class 0x%x\n", Class);
1340         DPRINT("UserUnregisterClass: Good Exit!\n");
1341         /* finally free the resources */
1342         IntDestroyClass(Class);
1343         return TRUE;
1344     }
1345     DPRINT1("UserUnregisterClass: Can not deregister Class Atom.\n");
1346     return FALSE;
1347 }
1348
1349 INT
1350 UserGetClassName(IN PCLS Class,
1351                  IN OUT PUNICODE_STRING ClassName,
1352                  IN BOOL Ansi)
1353 {
1354     NTSTATUS Status = STATUS_SUCCESS;
1355     WCHAR szStaticTemp[32];
1356     PWSTR szTemp = NULL;
1357     ULONG BufLen = sizeof(szStaticTemp);
1358     INT Ret = 0;
1359
1360     /* Note: Accessing the buffer in ClassName may raise an exception! */
1361
1362     _SEH2_TRY
1363     {
1364         if (Ansi)
1365         {
1366             PANSI_STRING AnsiClassName = (PANSI_STRING)ClassName;
1367             UNICODE_STRING UnicodeClassName;
1368
1369             /* limit the size of the static buffer on the stack to the
1370                size of the buffer provided by the caller */
1371             if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
1372             {
1373                 BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
1374             }
1375
1376             /* find out how big the buffer needs to be */
1377             Status = RtlQueryAtomInAtomTable(gAtomTable,
1378                                              Class->atomClassName,
1379                                              NULL,
1380                                              NULL,
1381                                              szStaticTemp,
1382                                              &BufLen);
1383             if (Status == STATUS_BUFFER_TOO_SMALL)
1384             {
1385                 if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
1386                 {
1387                     /* the buffer required exceeds the ansi buffer provided,
1388                        pretend like we're using the ansi buffer and limit the
1389                        size to the buffer size provided */
1390                     BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
1391                 }
1392
1393                 /* allocate a temporary buffer that can hold the unicode class name */
1394                 szTemp = ExAllocatePool(PagedPool,
1395                                         BufLen);
1396                 if (szTemp == NULL)
1397                 {
1398                     SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1399                     _SEH2_LEAVE;
1400                 }
1401
1402                 /* query the class name */
1403                 Status = RtlQueryAtomInAtomTable(gAtomTable,
1404                                                  Class->atomClassName,
1405                                                  NULL,
1406                                                  NULL,
1407                                                  szTemp,
1408                                                  &BufLen);
1409             }
1410             else
1411                 szTemp = szStaticTemp;
1412
1413             if (NT_SUCCESS(Status))
1414             {
1415                 /* convert the atom name to ansi */
1416
1417                 RtlInitUnicodeString(&UnicodeClassName,
1418                                      szTemp);
1419
1420                 Status = RtlUnicodeStringToAnsiString(AnsiClassName,
1421                                                       &UnicodeClassName,
1422                                                       FALSE);
1423                 if (!NT_SUCCESS(Status))
1424                 {
1425                     SetLastNtError(Status);
1426                     _SEH2_LEAVE;
1427                 }
1428             }
1429
1430             Ret = BufLen / sizeof(WCHAR);
1431         }
1432         else /* !Ansi */
1433         {
1434             BufLen = ClassName->MaximumLength;
1435
1436             /* query the atom name */
1437             Status = RtlQueryAtomInAtomTable(gAtomTable,
1438                                              Class->atomClassName,
1439                                              NULL,
1440                                              NULL,
1441                                              ClassName->Buffer,
1442                                              &BufLen);
1443
1444             if (!NT_SUCCESS(Status))
1445             {
1446                 SetLastNtError(Status);
1447                 _SEH2_LEAVE;
1448             }
1449
1450             Ret = BufLen / sizeof(WCHAR);
1451         }
1452     }
1453     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1454     {
1455         SetLastNtError(_SEH2_GetExceptionCode());
1456     }
1457     _SEH2_END;
1458
1459     if (Ansi && szTemp != NULL && szTemp != szStaticTemp)
1460     {
1461         ExFreePool(szTemp);
1462     }
1463
1464     return Ret;
1465 }
1466
1467 ULONG_PTR
1468 UserGetClassLongPtr(IN PCLS Class,
1469                     IN INT Index,
1470                     IN BOOL Ansi)
1471 {
1472     ULONG_PTR Ret = 0;
1473
1474     if (Index >= 0)
1475     {
1476         PULONG_PTR Data;
1477
1478         TRACE("GetClassLong(%d)\n", Index);
1479         if (Index + sizeof(ULONG_PTR) < Index ||
1480             Index + sizeof(ULONG_PTR) > Class->cbclsExtra)
1481         {
1482             SetLastWin32Error(ERROR_INVALID_PARAMETER);
1483             return 0;
1484         }
1485
1486         Data = (PULONG_PTR)((ULONG_PTR)(Class + 1) + Index);
1487
1488         /* FIXME - Data might be a unaligned pointer! Might be a problem on
1489                    certain architectures, maybe using RtlCopyMemory is a
1490                    better choice for those architectures! */
1491
1492         TRACE("Result: %x\n", Ret);
1493         return *Data;
1494     }
1495
1496     switch (Index)
1497     {
1498         case GCL_CBWNDEXTRA:
1499             Ret = (ULONG_PTR)Class->cbwndExtra;
1500             break;
1501
1502         case GCL_CBCLSEXTRA:
1503             Ret = (ULONG_PTR)Class->cbclsExtra;
1504             break;
1505
1506         case GCLP_HBRBACKGROUND:
1507             Ret = (ULONG_PTR)Class->hbrBackground;
1508             break;
1509
1510         case GCLP_HCURSOR:
1511             /* FIXME - get handle from pointer to CURSOR object */
1512             Ret = (ULONG_PTR)Class->hCursor;
1513             break;
1514
1515         case GCLP_HICON:
1516             /* FIXME - get handle from pointer to ICON object */
1517             Ret = (ULONG_PTR)Class->hIcon;
1518             break;
1519
1520         case GCLP_HICONSM:
1521             /* FIXME - get handle from pointer to ICON object */
1522             Ret = (ULONG_PTR)Class->hIconSm;
1523             break;
1524
1525         case GCLP_HMODULE:
1526             Ret = (ULONG_PTR)Class->hModule;
1527             break;
1528
1529         case GCLP_MENUNAME:
1530             /* NOTE: Returns pointer in kernel heap! */
1531             if (Ansi)
1532                 Ret = (ULONG_PTR)Class->lpszClientAnsiMenuName;
1533             else
1534                 Ret = (ULONG_PTR)Class->lpszClientUnicodeMenuName;
1535             break;
1536
1537         case GCL_STYLE:
1538             Ret = (ULONG_PTR)Class->style;
1539             break;
1540
1541         case GCLP_WNDPROC:
1542             Ret = (ULONG_PTR)IntGetClassWndProc(Class, Ansi);
1543             break;
1544
1545         case GCW_ATOM:
1546             Ret = (ULONG_PTR)Class->atomClassName;
1547             break;
1548
1549         default:
1550             SetLastWin32Error(ERROR_INVALID_INDEX);
1551             break;
1552     }
1553
1554     return Ret;
1555 }
1556
1557 static BOOL
1558 IntSetClassMenuName(IN PCLS Class,
1559                     IN PUNICODE_STRING MenuName)
1560 {
1561     BOOL Ret = FALSE;
1562
1563     /* change the base class first */
1564     Class = Class->pclsBase;
1565
1566     if (MenuName->Length != 0)
1567     {
1568         ANSI_STRING AnsiString;
1569         PWSTR strBufW;
1570
1571         AnsiString.MaximumLength = RtlUnicodeStringToAnsiSize(MenuName);
1572
1573         strBufW = UserHeapAlloc(MenuName->Length + sizeof(UNICODE_NULL) +
1574                                 AnsiString.MaximumLength);
1575         if (strBufW != NULL)
1576         {
1577             _SEH2_TRY
1578             {
1579                 NTSTATUS Status;
1580
1581                 /* copy the unicode string */
1582                 RtlCopyMemory(strBufW,
1583                               MenuName->Buffer,
1584                               MenuName->Length);
1585                 strBufW[MenuName->Length / sizeof(WCHAR)] = UNICODE_NULL;
1586
1587                 /* create an ansi copy of the string */
1588                 AnsiString.Buffer = (PSTR)(strBufW + (MenuName->Length / sizeof(WCHAR)) + 1);
1589                 Status = RtlUnicodeStringToAnsiString(&AnsiString,
1590                                                       MenuName,
1591                                                       FALSE);
1592                 if (!NT_SUCCESS(Status))
1593                 {
1594                     SetLastNtError(Status);
1595                     _SEH2_LEAVE;
1596                 }
1597
1598                 Ret = TRUE;
1599             }
1600             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1601             {
1602                 SetLastNtError(_SEH2_GetExceptionCode());
1603             }
1604             _SEH2_END;
1605
1606             if (Ret)
1607             {
1608                 /* update the base class */
1609                 IntFreeClassMenuName(Class);
1610                 Class->lpszClientUnicodeMenuName = strBufW;
1611                 Class->lpszClientAnsiMenuName = AnsiString.Buffer;
1612                 Class->MenuNameIsString = TRUE;
1613
1614                 /* update the clones */
1615                 Class = Class->pclsClone;
1616                 while (Class != NULL)
1617                 {
1618                     Class->lpszClientUnicodeMenuName = strBufW;
1619                     Class->lpszClientAnsiMenuName = AnsiString.Buffer;
1620                     Class->MenuNameIsString = TRUE;
1621
1622                     Class = Class->pclsNext;
1623                 }
1624             }
1625             else
1626             {
1627                 DPRINT1("Failed to copy class menu name!\n");
1628                 UserHeapFree(strBufW);
1629             }
1630         }
1631         else
1632             SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1633     }
1634     else
1635     {
1636         ASSERT(IS_INTRESOURCE(MenuName->Buffer));
1637
1638         /* update the base class */
1639         IntFreeClassMenuName(Class);
1640         Class->lpszClientUnicodeMenuName = MenuName->Buffer;
1641         Class->lpszClientAnsiMenuName = (PSTR)MenuName->Buffer;
1642         Class->MenuNameIsString = FALSE;
1643
1644         /* update the clones */
1645         Class = Class->pclsClone;
1646         while (Class != NULL)
1647         {
1648             Class->lpszClientUnicodeMenuName = MenuName->Buffer;
1649             Class->lpszClientAnsiMenuName = (PSTR)MenuName->Buffer;
1650             Class->MenuNameIsString = FALSE;
1651
1652             Class = Class->pclsNext;
1653         }
1654
1655         Ret = TRUE;
1656     }
1657
1658     return Ret;
1659 }
1660
1661 ULONG_PTR
1662 UserSetClassLongPtr(IN PCLS Class,
1663                     IN INT Index,
1664                     IN ULONG_PTR NewLong,
1665                     IN BOOL Ansi)
1666 {
1667     ULONG_PTR Ret = 0;
1668
1669     /* NOTE: For GCLP_MENUNAME and GCW_ATOM this function may raise an exception! */
1670
1671     /* change the information in the base class first, then update the clones */
1672     Class = Class->pclsBase;
1673
1674     if (Index >= 0)
1675     {
1676         PULONG_PTR Data;
1677
1678         TRACE("SetClassLong(%d, %x)\n", Index, NewLong);
1679
1680         if (Index + sizeof(ULONG_PTR) < Index ||
1681             Index + sizeof(ULONG_PTR) > Class->cbclsExtra)
1682         {
1683             SetLastWin32Error(ERROR_INVALID_PARAMETER);
1684             return 0;
1685         }
1686
1687         Data = (PULONG_PTR)((ULONG_PTR)(Class + 1) + Index);
1688
1689         /* FIXME - Data might be a unaligned pointer! Might be a problem on
1690                    certain architectures, maybe using RtlCopyMemory is a
1691                    better choice for those architectures! */
1692         Ret = *Data;
1693         *Data = NewLong;
1694
1695         /* update the clones */
1696         Class = Class->pclsClone;
1697         while (Class != NULL)
1698         {
1699             *(PULONG_PTR)((ULONG_PTR)(Class + 1) + Index) = NewLong;
1700             Class = Class->pclsNext;
1701         }
1702
1703         return Ret;
1704     }
1705
1706     switch (Index)
1707     {
1708         case GCL_CBWNDEXTRA:
1709             Ret = (ULONG_PTR)Class->cbwndExtra;
1710             Class->cbwndExtra = (INT)NewLong;
1711
1712             /* update the clones */
1713             Class = Class->pclsClone;
1714             while (Class != NULL)
1715             {
1716                 Class->cbwndExtra = (INT)NewLong;
1717                 Class = Class->pclsNext;
1718             }
1719
1720             break;
1721
1722         case GCL_CBCLSEXTRA:
1723             SetLastWin32Error(ERROR_INVALID_PARAMETER);
1724             break;
1725
1726         case GCLP_HBRBACKGROUND:
1727             Ret = (ULONG_PTR)Class->hbrBackground;
1728             Class->hbrBackground = (HBRUSH)NewLong;
1729
1730             /* update the clones */
1731             Class = Class->pclsClone;
1732             while (Class != NULL)
1733             {
1734                 Class->hbrBackground = (HBRUSH)NewLong;
1735                 Class = Class->pclsNext;
1736             }
1737             break;
1738
1739         case GCLP_HCURSOR:
1740             /* FIXME - get handle from pointer to CURSOR object */
1741             Ret = (ULONG_PTR)Class->hCursor;
1742             Class->hCursor = (HANDLE)NewLong;
1743
1744             /* update the clones */
1745             Class = Class->pclsClone;
1746             while (Class != NULL)
1747             {
1748                 Class->hCursor = (HANDLE)NewLong;
1749                 Class = Class->pclsNext;
1750             }
1751             break;
1752
1753         case GCLP_HICON:
1754             /* FIXME - get handle from pointer to ICON object */
1755             Ret = (ULONG_PTR)Class->hIcon;
1756             Class->hIcon = (HANDLE)NewLong;
1757
1758             /* update the clones */
1759             Class = Class->pclsClone;
1760             while (Class != NULL)
1761             {
1762                 Class->hIcon = (HANDLE)NewLong;
1763                 Class = Class->pclsNext;
1764             }
1765             break;
1766
1767         case GCLP_HICONSM:
1768             /* FIXME - get handle from pointer to ICON object */
1769             Ret = (ULONG_PTR)Class->hIconSm;
1770             Class->hIconSm = (HANDLE)NewLong;
1771
1772             /* update the clones */
1773             Class = Class->pclsClone;
1774             while (Class != NULL)
1775             {
1776                 Class->hIconSm = (HANDLE)NewLong;
1777                 Class = Class->pclsNext;
1778             }
1779             break;
1780
1781         case GCLP_HMODULE:
1782             Ret = (ULONG_PTR)Class->hModule;
1783             Class->hModule = (HINSTANCE)NewLong;
1784
1785            /* update the clones */
1786             Class = Class->pclsClone;
1787             while (Class != NULL)
1788             {
1789                 Class->hModule = (HINSTANCE)NewLong;
1790                 Class = Class->pclsNext;
1791             }
1792             break;
1793
1794         case GCLP_MENUNAME:
1795         {
1796             PUNICODE_STRING Value = (PUNICODE_STRING)NewLong;
1797
1798             if (!IntSetClassMenuName(Class,
1799                                      Value))
1800             {
1801                 DPRINT1("Setting the class menu name failed!\n");
1802             }
1803
1804             /* FIXME - really return NULL? Wine does so... */
1805             break;
1806         }
1807
1808         case GCL_STYLE:
1809             Ret = (ULONG_PTR)Class->style;
1810             Class->style = (UINT)NewLong;
1811
1812             /* FIXME - what if the CS_GLOBALCLASS style is changed? should we
1813                        move the class to the appropriate list? For now, we save
1814                        the original value in Class->Global, so we can always
1815                        locate the appropriate list */
1816
1817            /* update the clones */
1818             Class = Class->pclsClone;
1819             while (Class != NULL)
1820             {
1821                 Class->style = (UINT)NewLong;
1822                 Class = Class->pclsNext;
1823             }
1824             break;
1825
1826         case GCLP_WNDPROC:
1827             Ret = (ULONG_PTR)IntSetClassWndProc(Class,
1828                                                 (WNDPROC)NewLong,
1829                                                 Ansi);
1830             break;
1831
1832         case GCW_ATOM:
1833         {
1834             PUNICODE_STRING Value = (PUNICODE_STRING)NewLong;
1835
1836             Ret = (ULONG_PTR)Class->atomClassName;
1837             if (!IntSetClassAtom(Class,
1838                                  Value))
1839             {
1840                 Ret = 0;
1841             }
1842             break;
1843         }
1844
1845         default:
1846             SetLastWin32Error(ERROR_INVALID_INDEX);
1847             break;
1848     }
1849
1850     return Ret;
1851 }
1852
1853 static BOOL
1854 UserGetClassInfo(IN PCLS Class,
1855                  OUT PWNDCLASSEXW lpwcx,
1856                  IN BOOL Ansi,
1857                  HINSTANCE hInstance)
1858 {
1859     PPROCESSINFO pi;
1860
1861     if (!Class) return FALSE;
1862
1863     lpwcx->style = Class->style;
1864
1865     // If fnId is set, clear the global bit. See wine class test check_style.
1866     if (Class->fnid)
1867        lpwcx->style &= ~CS_GLOBALCLASS;
1868
1869     pi = GetW32ProcessInfo();
1870
1871     lpwcx->lpfnWndProc = IntGetClassWndProc(Class, Ansi);
1872
1873     lpwcx->cbClsExtra = Class->cbclsExtra;
1874     lpwcx->cbWndExtra = Class->cbwndExtra;
1875     lpwcx->hIcon = Class->hIcon; /* FIXME - get handle from pointer */
1876     lpwcx->hCursor = Class->hCursor; /* FIXME - get handle from pointer */
1877     lpwcx->hbrBackground = Class->hbrBackground;
1878
1879     /* Copy non-string to user first. */
1880     if (Ansi)
1881        ((PWNDCLASSEXA)lpwcx)->lpszMenuName = Class->lpszClientAnsiMenuName;
1882     else
1883        lpwcx->lpszMenuName = Class->lpszClientUnicodeMenuName;
1884 /*
1885     FIXME! CLSMENUNAME has the answers! Copy the already made buffers from there!
1886     Cls: lpszMenuName and lpszAnsiClassName should be used by kernel space.
1887     lpszClientXxxMenuName should already be mapped to user space.
1888  */
1889     /* Copy string ptr to user. */
1890     if ( Class->lpszClientUnicodeMenuName != NULL &&
1891          Class->MenuNameIsString)
1892     {
1893        lpwcx->lpszMenuName = UserHeapAddressToUser(Ansi ?
1894                                  (PVOID)Class->lpszClientAnsiMenuName :
1895                                  (PVOID)Class->lpszClientUnicodeMenuName);
1896     }
1897
1898     if (hInstance == hModClient)
1899         lpwcx->hInstance = NULL;
1900     else
1901         lpwcx->hInstance = hInstance;
1902
1903     /* FIXME - return the string? Okay! This is performed in User32!*/
1904     //lpwcx->lpszClassName = (LPCWSTR)((ULONG_PTR)Class->atomClassName);
1905
1906     lpwcx->hIconSm = Class->hIconSm; /* FIXME - get handle from pointer */
1907
1908     return TRUE;
1909 }
1910
1911 //
1912 //
1913 //
1914 BOOL
1915 FASTCALL
1916 UserRegisterSystemClasses(VOID)
1917 {
1918     UINT i;
1919     UNICODE_STRING ClassName, MenuName;
1920     PPROCESSINFO ppi = GetW32ProcessInfo();
1921     WNDCLASSEXW wc;
1922     PCLS Class;
1923     BOOL Ret = TRUE;
1924     DWORD Flags = 0;
1925
1926     if (ppi->W32PF_flags & W32PF_CLASSESREGISTERED)
1927        return TRUE;
1928
1929     if ( hModClient == NULL)
1930        return FALSE;
1931
1932     RtlZeroMemory(&ClassName, sizeof(ClassName));
1933     RtlZeroMemory(&MenuName, sizeof(MenuName));
1934
1935     for (i = 0; i != ARRAYSIZE(DefaultServerClasses); i++)
1936     {
1937         if (!IS_ATOM(DefaultServerClasses[i].ClassName))
1938         {
1939            RtlInitUnicodeString(&ClassName, DefaultServerClasses[i].ClassName);
1940         }
1941         else
1942         {
1943            ClassName.Buffer = DefaultServerClasses[i].ClassName;
1944            ClassName.Length = 0;
1945            ClassName.MaximumLength = 0;
1946         }
1947
1948         wc.cbSize = sizeof(wc);
1949         wc.style = DefaultServerClasses[i].Style;
1950
1951         Flags |= CSF_SERVERSIDEPROC;
1952
1953         if (DefaultServerClasses[i].ProcW)
1954         {
1955            wc.lpfnWndProc = DefaultServerClasses[i].ProcW;
1956            wc.hInstance = hModuleWin;
1957         }
1958         else
1959         {
1960            wc.lpfnWndProc = GETPFNSERVER(DefaultServerClasses[i].fiId);
1961            wc.hInstance = hModClient;
1962         }
1963
1964         wc.cbClsExtra = 0;
1965         wc.cbWndExtra = DefaultServerClasses[i].ExtraBytes;
1966         wc.hIcon = NULL;
1967         wc.hCursor = DefaultServerClasses[i].hCursor;
1968         wc.hbrBackground = DefaultServerClasses[i].hBrush;
1969         wc.lpszMenuName = NULL;
1970         wc.lpszClassName = ClassName.Buffer;
1971         wc.hIconSm = NULL;
1972
1973         Class = IntCreateClass( &wc,
1974                                 &ClassName,
1975                                 &MenuName,
1976                                  DefaultServerClasses[i].fiId,
1977                                  Flags,
1978                                  NULL,
1979                                  ppi);
1980         if (Class != NULL)
1981         {
1982             Class->pclsNext = ppi->pclsPublicList;
1983             (void)InterlockedExchangePointer((PVOID*)&ppi->pclsPublicList,
1984                                              Class);
1985
1986             ppi->dwRegisteredClasses |= ICLASS_TO_MASK(DefaultServerClasses[i].iCls);
1987         }
1988         else
1989         {
1990             WARN("!!! Registering system class failed!\n");
1991             Ret = FALSE;
1992         }
1993     }
1994     if (Ret) ppi->W32PF_flags |= W32PF_CLASSESREGISTERED;
1995     return Ret;
1996 }
1997
1998 /* SYSCALLS *****************************************************************/
1999
2000 RTL_ATOM
2001 APIENTRY
2002 NtUserRegisterClassExWOW(
2003     WNDCLASSEXW* lpwcx,
2004     PUNICODE_STRING ClassName,
2005     PUNICODE_STRING ClsNVersion,
2006     PCLSMENUNAME pClassMenuName,
2007     DWORD fnID,
2008     DWORD Flags,
2009     LPDWORD pWow)
2010 /*
2011  * FUNCTION:
2012  *   Registers a new class with the window manager
2013  * ARGUMENTS:
2014  *   lpwcx          = Win32 extended window class structure
2015  *   bUnicodeClass = Whether to send ANSI or unicode strings
2016  *                   to window procedures
2017  * RETURNS:
2018  *   Atom identifying the new class
2019  */
2020 {
2021     WNDCLASSEXW CapturedClassInfo = {0};
2022     UNICODE_STRING CapturedName = {0}, CapturedMenuName = {0};
2023     RTL_ATOM Ret = (RTL_ATOM)0;
2024     PPROCESSINFO ppi = GetW32ProcessInfo();
2025
2026     if (Flags & ~(CSF_ANSIPROC))
2027     {
2028         DPRINT1("NtUserRegisterClassExWOW Bad Flags!\n");
2029         SetLastWin32Error(ERROR_INVALID_FLAGS);
2030         return Ret;
2031     }
2032
2033     UserEnterExclusive();
2034
2035     DPRINT("NtUserRegisterClassExWOW ClsN %wZ\n",ClassName);
2036
2037     if ( !(ppi->W32PF_flags & W32PF_CLASSESREGISTERED ))
2038     {
2039        UserRegisterSystemClasses();
2040     }
2041
2042     _SEH2_TRY
2043     {
2044         /* Probe the parameters and basic parameter checks */
2045         if (ProbeForReadUint(&lpwcx->cbSize) != sizeof(WNDCLASSEXW))
2046         {
2047             DPRINT1("NtUserRegisterClassExWOW Wrong cbSize!\n");
2048             goto InvalidParameter;
2049         }
2050
2051         ProbeForRead(lpwcx,
2052                      sizeof(WNDCLASSEXW),
2053                      sizeof(ULONG));
2054         RtlCopyMemory(&CapturedClassInfo,
2055                       lpwcx,
2056                       sizeof(WNDCLASSEXW));
2057
2058         CapturedName = ProbeForReadUnicodeString(ClassName);
2059
2060         ProbeForRead(pClassMenuName,
2061                      sizeof(CLSMENUNAME),
2062                      1);
2063
2064         CapturedMenuName = ProbeForReadUnicodeString(pClassMenuName->pusMenuName);
2065
2066         if ( CapturedName.Length & 1 ||
2067              CapturedMenuName.Length & 1 ||
2068              CapturedClassInfo.cbClsExtra < 0 ||
2069              CapturedClassInfo.cbClsExtra +
2070                 CapturedName.Length +
2071                 CapturedMenuName.Length +
2072                 sizeof(CLS) < CapturedClassInfo.cbClsExtra ||
2073              CapturedClassInfo.cbWndExtra < 0 ||
2074              CapturedClassInfo.hInstance == NULL)
2075         {
2076             DPRINT1("NtUserRegisterClassExWOW Invalid Parameter Error!\n");
2077             goto InvalidParameter;
2078         }
2079
2080         if (CapturedName.Length != 0)
2081         {
2082             ProbeForRead(CapturedName.Buffer,
2083                          CapturedName.Length,
2084                          sizeof(WCHAR));
2085         }
2086         else
2087         {
2088             if (!IS_ATOM(CapturedName.Buffer))
2089             {
2090                 DPRINT1("NtUserRegisterClassExWOW ClassName Error!\n");
2091                 goto InvalidParameter;
2092             }
2093         }
2094
2095         if (CapturedMenuName.Length != 0)
2096         {
2097             ProbeForRead(CapturedMenuName.Buffer,
2098                          CapturedMenuName.Length,
2099                          sizeof(WCHAR));
2100         }
2101         else if (CapturedMenuName.Buffer != NULL &&
2102                  !IS_INTRESOURCE(CapturedMenuName.Buffer))
2103         {
2104             DPRINT1("NtUserRegisterClassExWOW MenuName Error!\n");
2105 InvalidParameter:
2106             SetLastWin32Error(ERROR_INVALID_PARAMETER);
2107             _SEH2_LEAVE;
2108         }
2109
2110         if (IsCallProcHandle(lpwcx->lpfnWndProc))
2111         {// Never seen this yet, but I'm sure it's a little haxxy trick!
2112          // If this pops up we know what todo!
2113            DPRINT1("NtUserRegisterClassExWOW WndProc is CallProc!!\n");
2114         }
2115
2116         DPRINT("NtUserRegisterClassExWOW MnuN %wZ\n",&CapturedMenuName);
2117
2118         /* Register the class */
2119         Ret = UserRegisterClass(&CapturedClassInfo,
2120                                 &CapturedName,
2121                                 &CapturedMenuName,
2122                                 fnID,
2123                                 Flags);
2124     }
2125     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2126     {
2127         DPRINT1("NtUserRegisterClassExWOW Exception Error!\n");
2128         SetLastNtError(_SEH2_GetExceptionCode());
2129     }
2130     _SEH2_END;
2131 /*
2132     if (!Ret)
2133     {
2134        DPRINT1("NtUserRegisterClassExWOW Null Return!\n");
2135     }
2136  */
2137     UserLeave();
2138
2139     return Ret;
2140 }
2141
2142 ULONG_PTR APIENTRY
2143 NtUserGetClassLong(IN HWND hWnd,
2144                    IN INT Offset,
2145                    IN BOOL Ansi)
2146 {
2147     PWINDOW_OBJECT Window;
2148     ULONG_PTR Ret = 0;
2149
2150     if (Offset != GCLP_WNDPROC)
2151     {
2152         UserEnterShared();
2153     }
2154     else
2155     {
2156         UserEnterExclusive();
2157     }
2158
2159     Window = UserGetWindowObject(hWnd);
2160     if (Window != NULL)
2161     {
2162         Ret = UserGetClassLongPtr(Window->Wnd->pcls,
2163                                   Offset,
2164                                   Ansi);
2165
2166         if ( Ret != 0 &&
2167              Offset == GCLP_MENUNAME &&
2168              Window->Wnd->pcls->MenuNameIsString)
2169         {
2170             Ret = (ULONG_PTR)UserHeapAddressToUser((PVOID)Ret);
2171         }
2172     }
2173
2174     UserLeave();
2175
2176     return Ret;
2177 }
2178
2179
2180
2181 ULONG_PTR APIENTRY
2182 NtUserSetClassLong(HWND hWnd,
2183                    INT Offset,
2184                    ULONG_PTR dwNewLong,
2185                    BOOL Ansi)
2186 {
2187     PPROCESSINFO pi;
2188     PWINDOW_OBJECT Window;
2189     ULONG_PTR Ret = 0;
2190
2191     UserEnterExclusive();
2192
2193     pi = GetW32ProcessInfo();
2194
2195     Window = UserGetWindowObject(hWnd);
2196     if (Window != NULL)
2197     {
2198         if (Window->pti->ppi != pi)
2199         {
2200             SetLastWin32Error(ERROR_ACCESS_DENIED);
2201             goto Cleanup;
2202         }
2203
2204         _SEH2_TRY
2205         {
2206             UNICODE_STRING Value;
2207
2208             /* probe the parameters */
2209             if (Offset == GCW_ATOM || Offset == GCLP_MENUNAME)
2210             {
2211                 Value = ProbeForReadUnicodeString((PUNICODE_STRING)dwNewLong);
2212                 if (Value.Length & 1)
2213                 {
2214                     goto InvalidParameter;
2215                 }
2216
2217                 if (Value.Length != 0)
2218                 {
2219                     ProbeForRead(Value.Buffer,
2220                                  Value.Length,
2221                                  sizeof(WCHAR));
2222                 }
2223                 else
2224                 {
2225                     if (Offset == GCW_ATOM && !IS_ATOM(Value.Buffer))
2226                     {
2227                         goto InvalidParameter;
2228                     }
2229                     else if (Offset == GCLP_MENUNAME && !IS_INTRESOURCE(Value.Buffer))
2230                     {
2231 InvalidParameter:
2232                         SetLastWin32Error(ERROR_INVALID_PARAMETER);
2233                         _SEH2_LEAVE;
2234                     }
2235                 }
2236
2237                 dwNewLong = (ULONG_PTR)&Value;
2238             }
2239
2240             Ret = UserSetClassLongPtr(Window->Wnd->pcls,
2241                                       Offset,
2242                                       dwNewLong,
2243                                       Ansi);
2244         }
2245         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2246         {
2247             SetLastNtError(_SEH2_GetExceptionCode());
2248         }
2249         _SEH2_END;
2250     }
2251
2252 Cleanup:
2253     UserLeave();
2254
2255     return Ret;
2256 }
2257
2258 WORD
2259 APIENTRY
2260 NtUserSetClassWord(
2261   HWND hWnd,
2262   INT nIndex,
2263   WORD wNewWord)
2264 {
2265 /*
2266  * NOTE: Obsoleted in 32-bit windows
2267  */
2268    return(0);
2269 }
2270
2271 BOOL APIENTRY
2272 NtUserUnregisterClass(IN PUNICODE_STRING ClassNameOrAtom,
2273                       IN HINSTANCE hInstance,
2274                       OUT PCLSMENUNAME pClassMenuName)
2275 {
2276     UNICODE_STRING CapturedClassName;
2277     BOOL Ret = FALSE;
2278
2279     UserEnterExclusive();
2280
2281     _SEH2_TRY
2282     {
2283         /* probe the paramters */
2284         CapturedClassName = ProbeForReadUnicodeString(ClassNameOrAtom);
2285         if (CapturedClassName.Length & 1)
2286         {
2287             goto InvalidParameter;
2288         }
2289
2290         if (CapturedClassName.Length != 0)
2291         {
2292             ProbeForRead(CapturedClassName.Buffer,
2293                          CapturedClassName.Length,
2294                          sizeof(WCHAR));
2295         }
2296         else
2297         {
2298             if (!IS_ATOM(CapturedClassName.Buffer))
2299             {
2300 InvalidParameter:
2301                 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2302                 _SEH2_LEAVE;
2303             }
2304         }
2305
2306         /* unregister the class */
2307         Ret = UserUnregisterClass(&CapturedClassName,
2308                                   hInstance,
2309                                   NULL); // Null for now~
2310     }
2311     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2312     {
2313         SetLastNtError(_SEH2_GetExceptionCode());
2314     }
2315     _SEH2_END;
2316
2317     UserLeave();
2318     return Ret;
2319 }
2320
2321 /* NOTE: for system classes hInstance is not NULL here, but User32Instance */
2322 BOOL APIENTRY
2323 NtUserGetClassInfo(
2324    HINSTANCE hInstance,
2325    PUNICODE_STRING ClassName,
2326    LPWNDCLASSEXW lpWndClassEx,
2327    LPWSTR *ppszMenuName,
2328    BOOL Ansi)
2329 {
2330    UNICODE_STRING CapturedClassName, SafeClassName;
2331    WNDCLASSEXW Safewcexw;
2332    PCLS Class;
2333    RTL_ATOM ClassAtom = 0;
2334    PPROCESSINFO ppi;
2335    BOOL Ret = TRUE;
2336
2337    /* NOTE: need exclusive lock because getting the wndproc might require the
2338             creation of a call procedure handle */
2339    UserEnterExclusive();
2340
2341    ppi = GetW32ProcessInfo();
2342
2343    if ( !(ppi->W32PF_flags & W32PF_CLASSESREGISTERED ))
2344    {
2345       UserRegisterSystemClasses();
2346    }
2347
2348    _SEH2_TRY
2349    {
2350       /* probe the paramters */
2351       CapturedClassName = ProbeForReadUnicodeString(ClassName);
2352
2353       if (CapturedClassName.Length == 0)
2354          TRACE("hInst %p atom %04X lpWndClassEx %p Ansi %d\n", hInstance, CapturedClassName.Buffer, lpWndClassEx, Ansi);
2355       else
2356          TRACE("hInst %p class %wZ lpWndClassEx %p Ansi %d\n", hInstance, &CapturedClassName, lpWndClassEx, Ansi);
2357
2358       if (CapturedClassName.Length & 1)
2359       {
2360          goto InvalidParameter;
2361       }
2362
2363       if (CapturedClassName.Length != 0)
2364       {
2365          ProbeForRead( CapturedClassName.Buffer,
2366                        CapturedClassName.Length,
2367                        sizeof(WCHAR));
2368
2369          RtlInitUnicodeString( &SafeClassName, CapturedClassName.Buffer);
2370
2371          SafeClassName.Buffer = ExAllocatePoolWithTag( PagedPool,
2372                                                        SafeClassName.MaximumLength,
2373                                                        TAG_STRING);
2374          RtlCopyMemory( SafeClassName.Buffer,
2375                         CapturedClassName.Buffer,
2376                         SafeClassName.MaximumLength);
2377       }
2378       else
2379       {
2380          if (!IS_ATOM(CapturedClassName.Buffer))
2381          {
2382             ERR("NtUserGetClassInfo() got ClassName instead of Atom!\n");
2383             goto InvalidParameter;
2384          }
2385
2386          SafeClassName.Buffer = CapturedClassName.Buffer;
2387          SafeClassName.Length = 0;
2388          SafeClassName.MaximumLength = 0;
2389       }
2390
2391       if (ProbeForReadUint(&lpWndClassEx->cbSize) != sizeof(WNDCLASSEXW))
2392       {
2393 InvalidParameter:
2394          SetLastWin32Error(ERROR_INVALID_PARAMETER);
2395          Ret = FALSE;
2396          _SEH2_LEAVE;
2397       }
2398
2399       ProbeForWrite( lpWndClassEx, sizeof(WNDCLASSEXW), sizeof(ULONG));
2400
2401       RtlCopyMemory( &Safewcexw, lpWndClassEx, sizeof(WNDCLASSEXW));
2402    }
2403    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2404    {
2405       SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
2406       Ret = FALSE;
2407    }
2408    _SEH2_END;
2409
2410    // If null instance use client.
2411    if (!hInstance) hInstance = hModClient;
2412
2413    if (Ret)
2414    {
2415       DPRINT("GetClassInfo(%wZ, 0x%x)\n", ClassName, hInstance);
2416       ClassAtom = IntGetClassAtom( &SafeClassName,
2417                                     hInstance,
2418                                     ppi,
2419                                    &Class,
2420                                     NULL);
2421       if (ClassAtom != (RTL_ATOM)0)
2422       {
2423          if (hInstance == NULL) hInstance = hModClient;
2424
2425          Ret = UserGetClassInfo( Class,
2426                                 &Safewcexw,
2427                                  Ansi,
2428                                  hInstance);
2429       }
2430       else
2431       {
2432          SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
2433          Ret = FALSE;
2434       }
2435    }
2436    _SEH2_TRY
2437    {
2438       if (Ret)
2439       {
2440          /* Emulate Function. */
2441          if (ppszMenuName) *ppszMenuName = (LPWSTR)Safewcexw.lpszMenuName;
2442
2443          RtlCopyMemory(lpWndClassEx, &Safewcexw, sizeof(WNDCLASSEXW));
2444
2445          // From Wine:
2446          /* We must return the atom of the class here instead of just TRUE. */
2447          /* Undocumented behavior! Return the class atom as a BOOL! */
2448          Ret = (BOOL)ClassAtom;
2449       }
2450    }
2451    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2452    {
2453       SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
2454       Ret = FALSE;
2455    }
2456    _SEH2_END;
2457
2458    if (SafeClassName.Length) ExFreePoolWithTag(SafeClassName.Buffer, TAG_STRING);
2459    UserLeave();
2460    return Ret;
2461 }
2462
2463
2464 INT APIENTRY
2465 NtUserGetClassName (IN HWND hWnd,
2466                     OUT PUNICODE_STRING ClassName,
2467                     IN BOOL Ansi)
2468 {
2469     PWINDOW_OBJECT Window;
2470     UNICODE_STRING CapturedClassName;
2471     INT Ret = 0;
2472
2473     UserEnterShared();
2474
2475     Window = UserGetWindowObject(hWnd);
2476     if (Window != NULL)
2477     {
2478         _SEH2_TRY
2479         {
2480             ProbeForWriteUnicodeString(ClassName);
2481             CapturedClassName = *ClassName;
2482
2483             /* get the class name */
2484             Ret = UserGetClassName(Window->Wnd->pcls,
2485                                    &CapturedClassName,
2486                                    Ansi);
2487
2488             if (Ret != 0)
2489             {
2490                 /* update the Length field */
2491                 ClassName->Length = CapturedClassName.Length;
2492             }
2493         }
2494         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2495         {
2496             SetLastNtError(_SEH2_GetExceptionCode());
2497         }
2498         _SEH2_END;
2499     }
2500
2501     UserLeave();
2502
2503     return Ret;
2504 }
2505
2506 /* Return Pointer to Class structure. */
2507 PCLS APIENTRY
2508 NtUserGetWOWClass(HINSTANCE hInstance,
2509                   PUNICODE_STRING ClassName)
2510 {
2511   UNICODE_STRING SafeClassName;
2512   PPROCESSINFO pi;
2513   PCLS Class = NULL;
2514   RTL_ATOM ClassAtom = 0;
2515   BOOL Hit = FALSE;
2516
2517   UserEnterExclusive();
2518
2519   pi = GetW32ProcessInfo();
2520
2521   _SEH2_TRY
2522   {
2523      if (ClassName->Length != 0)
2524      {
2525         ProbeForRead( ClassName->Buffer,
2526                       ClassName->Length,
2527                       sizeof(WCHAR));
2528
2529         RtlInitUnicodeString( &SafeClassName, ClassName->Buffer);
2530
2531         SafeClassName.Buffer = ExAllocatePoolWithTag( PagedPool,
2532                                                       SafeClassName.MaximumLength,
2533                                                       TAG_STRING);
2534         RtlCopyMemory( SafeClassName.Buffer,
2535                        ClassName->Buffer,
2536                        SafeClassName.MaximumLength);
2537      }
2538      else
2539      {
2540         if (!IS_ATOM(ClassName->Buffer))
2541         {
2542            ERR("NtUserGetWOWClass() got ClassName instead of Atom!\n");
2543            Hit = TRUE;
2544         }
2545         else
2546         {
2547            SafeClassName.Buffer = ClassName->Buffer;
2548            SafeClassName.Length = 0;
2549            SafeClassName.MaximumLength = 0;
2550         }
2551      }
2552   }
2553   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2554   {
2555      SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
2556      Hit = TRUE;
2557   }
2558   _SEH2_END;
2559
2560   if (!Hit)
2561   {
2562      ClassAtom = IntGetClassAtom( &SafeClassName,
2563                                    hInstance,
2564                                    pi,
2565                                   &Class,
2566                                    NULL);
2567      if (!ClassAtom)
2568      {
2569         SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
2570      }
2571   }
2572
2573   if (SafeClassName.Length) ExFreePoolWithTag(SafeClassName.Buffer, TAG_STRING);
2574   UserLeave();
2575 //
2576 // Don't forget to use DesktopPtrToUser( ? ) with return pointer in user space.
2577 //
2578   return Class;
2579 }
2580
2581 /* EOF */