reactos/subsys/win32k/ntuser/class.c

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