reactos/subsys/win32k/ntuser/class.c

   1 /* $Id: class.c,v 1.13 2002/09/08 10:23:52 chorns Exp $
   2  *
   3  * COPYRIGHT:        See COPYING in the top level directory
   4  * PROJECT:          ReactOS kernel
   5  * PURPOSE:          Window classes
   6  * FILE:             subsys/win32k/ntuser/class.c
   7  * PROGRAMER:        Casper S. Hornstrup (chorns@users.sourceforge.net)
   8  * REVISION HISTORY:
   9  *       06-06-2001  CSH  Created
  10  */
  11 /* INCLUDES ******************************************************************/
  12
  13 #include <ddk/ntddk.h>
  14 #include <win32k/win32k.h>
  15 #include <napi/win32.h>
  16 #include <include/class.h>
  17 #include <include/error.h>
  18 #include <include/winsta.h>
  19 #include <include/object.h>
  20 #include <include/guicheck.h>
  21 #include <include/window.h>
  22
  23 //#define NDEBUG
  24 #include <debug.h>
  25
  26 /* FUNCTIONS *****************************************************************/
  27
  28 NTSTATUS
  29 InitClassImpl(VOID)
  30 {
  31   return(STATUS_SUCCESS);
  32 }
  33
  34 NTSTATUS
  35 CleanupClassImpl(VOID)
  36 {
  37   return(STATUS_SUCCESS);
  38 }
  39
  40
  41 NTSTATUS
  42 ClassReferenceClassByName(PW32PROCESS Process,
  43                           PWNDCLASS_OBJECT* Class,
  44                           LPWSTR ClassName)
  45 {
  46   PWNDCLASS_OBJECT Current;
  47   PLIST_ENTRY CurrentEntry;
  48
  49   ExAcquireFastMutexUnsafe (&Process->ClassListLock);
  50   CurrentEntry = Process->ClassListHead.Flink;
  51   while (CurrentEntry != &Process->ClassListHead)
  52     {
  53       Current = CONTAINING_RECORD(CurrentEntry, WNDCLASS_OBJECT, ListEntry);
  54
  55       if (_wcsicmp(ClassName, Current->Class.lpszClassName) == 0)
  56         {
  57           *Class = Current;
  58           ObmReferenceObject(Current);
  59           ExReleaseFastMutexUnsafe (&Process->ClassListLock);
  60           return(STATUS_SUCCESS);
  61         }
  62
  63       CurrentEntry = CurrentEntry->Flink;
  64     }
  65   ExReleaseFastMutexUnsafe (&Process->ClassListLock);
  66
  67   return(STATUS_NOT_FOUND);
  68 }
  69
  70 NTSTATUS
  71 ClassReferenceClassByAtom(PWNDCLASS_OBJECT *Class,
  72                           RTL_ATOM ClassAtom)
  73 {
  74   PWINSTATION_OBJECT WinStaObject;
  75   ULONG ClassNameLength;
  76   WCHAR ClassName[256];
  77   NTSTATUS Status;
  78
  79   if (!ClassAtom)
  80     {
  81       return(STATUS_INVALID_PARAMETER);
  82     }
  83
  84   Status = ValidateWindowStationHandle(PROCESS_WINDOW_STATION(),
  85                                        KernelMode,
  86                                        0,
  87                                        &WinStaObject);
  88   if (!NT_SUCCESS(Status))
  89     {
  90       DPRINT("Validation of window station handle (0x%X) failed\n",
  91              PROCESS_WINDOW_STATION());
  92       return(STATUS_UNSUCCESSFUL);
  93     }
  94
  95   ClassNameLength = sizeof(ClassName);
  96   Status = RtlQueryAtomInAtomTable(WinStaObject->AtomTable,
  97                                    ClassAtom,
  98                                    NULL,
  99                                    NULL,
 100                                    &ClassName[0],
 101                                    &ClassNameLength);
 102
 103   Status = ClassReferenceClassByName(PsGetWin32Process(),
 104                                      Class,
 105                                      &ClassName[0]);
 106
 107   ObDereferenceObject(WinStaObject);
 108
 109   return(Status);
 110 }
 111
 112 NTSTATUS
 113 ClassReferenceClassByNameOrAtom(PWNDCLASS_OBJECT *Class,
 114                                 LPWSTR ClassNameOrAtom)
 115 {
 116   NTSTATUS Status;
 117
 118   if (IS_ATOM(ClassNameOrAtom))
 119     {
 120       Status = ClassReferenceClassByAtom(Class,
 121                                   (RTL_ATOM)((ULONG_PTR)ClassNameOrAtom));
 122   }
 123   else
 124     {
 125       Status = ClassReferenceClassByName(PsGetWin32Process(), Class,
 126                                          ClassNameOrAtom);
 127     }
 128
 129   if (!NT_SUCCESS(Status))
 130     {
 131       SetLastNtError(Status);
 132     }
 133
 134   return(Status);
 135 }
 136
 137 DWORD STDCALL
 138 NtUserGetClassInfo(IN LPWSTR ClassName,
 139                    IN ULONG InfoClass,
 140                    OUT PVOID Info,
 141                    IN ULONG InfoLength,
 142                    OUT PULONG ReturnedLength)
 143 {
 144   UNIMPLEMENTED;
 145
 146   return(0);
 147 }
 148
 149 DWORD STDCALL
 150 NtUserGetClassName(DWORD Unknown0,
 151                    DWORD Unknown1,
 152                    DWORD Unknown2)
 153 {
 154   UNIMPLEMENTED;
 155
 156   return(0);
 157 }
 158
 159 DWORD STDCALL
 160 NtUserGetWOWClass(DWORD Unknown0,
 161                   DWORD Unknown1)
 162 {
 163   UNIMPLEMENTED;
 164
 165   return(0);
 166 }
 167
 168 PWNDCLASS_OBJECT
 169 W32kCreateClass(LPWNDCLASSEX lpwcx,
 170                 BOOL bUnicodeClass)
 171 {
 172   PWNDCLASS_OBJECT ClassObject;
 173   WORD  objectSize;
 174   LPTSTR  namePtr;
 175
 176   objectSize = sizeof(WNDCLASS_OBJECT) +
 177     (lpwcx->lpszMenuName != 0 ? ((wcslen (lpwcx->lpszMenuName) + 1) * 2) : 0) +
 178     ((wcslen (lpwcx->lpszClassName) + 1) * 2);
 179   ClassObject = ObmCreateObject(NULL, NULL, otClass, objectSize);
 180   if (ClassObject == 0)
 181     {
 182       return(NULL);
 183     }
 184
 185   ClassObject->Class = *lpwcx;
 186   ClassObject->Unicode = bUnicodeClass;
 187   namePtr = (LPTSTR)(((PCHAR)ClassObject) + sizeof (WNDCLASS_OBJECT));
 188   if (lpwcx->lpszMenuName != 0)
 189     {
 190       ClassObject->Class.lpszMenuName = namePtr;
 191       wcscpy (namePtr, lpwcx->lpszMenuName);
 192       namePtr += wcslen (lpwcx->lpszMenuName) + 1;
 193     }
 194   ClassObject->Class.lpszClassName = namePtr;
 195   wcscpy (namePtr, lpwcx->lpszClassName);
 196   return(ClassObject);
 197 }
 198
 199 RTL_ATOM STDCALL
 200 NtUserRegisterClassExWOW(LPWNDCLASSEX lpwcx,
 201                          BOOL bUnicodeClass,
 202                          DWORD Unknown2,
 203                          DWORD Unknown3,
 204                          DWORD Unknown4,
 205                          DWORD Unknown5)
 206 /*
 207  * FUNCTION:
 208  *   Registers a new class with the window manager
 209  * ARGUMENTS:
 210  *   lpcx          = Win32 extended window class structure
 211  *   bUnicodeClass = Wether to send ANSI or unicode strings
 212  *                   to window procedures
 213  * RETURNS:
 214  *   Atom identifying the new class
 215  */
 216 {
 217   PWINSTATION_OBJECT WinStaObject;
 218   PWNDCLASS_OBJECT ClassObject;
 219   NTSTATUS Status;
 220   RTL_ATOM Atom;
 221
 222   W32kGuiCheck();
 223
 224   DPRINT("About to open window station handle (0x%X)\n",
 225          PROCESS_WINDOW_STATION());
 226
 227   Status = ValidateWindowStationHandle(PROCESS_WINDOW_STATION(),
 228                                        KernelMode,
 229                                        0,
 230                                        &WinStaObject);
 231   if (!NT_SUCCESS(Status))
 232     {
 233       DPRINT("Validation of window station handle (0x%X) failed\n",
 234              PROCESS_WINDOW_STATION());
 235       return((RTL_ATOM)0);
 236     }
 237
 238   Status = RtlAddAtomToAtomTable(WinStaObject->AtomTable,
 239                                  (LPWSTR)lpwcx->lpszClassName,
 240                                  &Atom);
 241   if (!NT_SUCCESS(Status))
 242     {
 243       ObDereferenceObject(WinStaObject);
 244       DPRINT("Failed adding class name (%wS) to atom table\n",
 245              lpwcx->lpszClassName);
 246       SetLastNtError(Status);
 247
 248       return((RTL_ATOM)0);
 249     }
 250   ClassObject = W32kCreateClass(lpwcx, bUnicodeClass);
 251   if (ClassObject == NULL)
 252     {
 253       RtlDeleteAtomFromAtomTable(WinStaObject->AtomTable, Atom);
 254       ObDereferenceObject(WinStaObject);
 255       DPRINT("Failed creating window class object\n");
 256       SetLastNtError(STATUS_INSUFFICIENT_RESOURCES);
 257       return((RTL_ATOM)0);
 258     }
 259   ExAcquireFastMutex(&PsGetWin32Process()->ClassListLock);
 260   InsertTailList(&PsGetWin32Process()->ClassListHead, &ClassObject->ListEntry);
 261   ExReleaseFastMutex(&PsGetWin32Process()->ClassListLock);
 262
 263   ObDereferenceObject(WinStaObject);
 264
 265   return(Atom);
 266 }
 267
 268 DWORD STDCALL
 269 NtUserGetClassLong(HWND hWnd, DWORD Offset)
 270 {
 271   PWINDOW_OBJECT WindowObject;
 272   LONG Ret;
 273
 274   WindowObject = W32kGetWindowObject(hWnd);
 275   if (WindowObject == NULL)
 276     {
 277       return(0);
 278     }
 279   switch (Offset)
 280     {
 281     case GCL_STYLE:
 282       Ret = WindowObject->Class->Class.style;
 283       break;
 284     case GCL_CBWNDEXTRA:
 285       Ret = WindowObject->Class->Class.cbWndExtra;
 286       break;
 287     case GCL_CBCLSEXTRA:
 288       Ret = WindowObject->Class->Class.cbClsExtra;
 289       break;
 290     case GCL_HMODULE:
 291       Ret = WindowObject->Class->Class.hInstance;
 292       break;
 293     case GCL_HBRBACKGROUND:
 294       Ret = WindowObject->Class->Class.hbrBackground;
 295       break;
 296     default:
 297       Ret = 0;
 298       break;
 299     }
 300   W32kReleaseWindowObject(WindowObject);
 301   return(Ret);
 302 }
 303
 304 DWORD STDCALL
 305 NtUserSetClassLong(DWORD Unknown0,
 306                    DWORD Unknown1,
 307                    DWORD Unknown2,
 308                    DWORD Unknown3)
 309 {
 310   UNIMPLEMENTED;
 311
 312   return(0);
 313 }
 314
 315 DWORD STDCALL
 316 NtUserSetClassWord(DWORD Unknown0,
 317                    DWORD Unknown1,
 318                    DWORD Unknown2)
 319 {
 320   UNIMPLEMENTED;
 321
 322   return(0);
 323 }
 324
 325 DWORD STDCALL
 326 NtUserUnregisterClass(DWORD Unknown0,
 327                       DWORD Unknown1,
 328                       DWORD Unknown2)
 329 {
 330   UNIMPLEMENTED;
 331
 332   return(0);
 333 }
 334
 335 /* EOF */