reactos/subsys/win32k/ntuser/class.c

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