reactos/subsys/win32k/ntuser/class.c

   1 /* $Id: class.c,v 1.7 2002/06/14 20:56:17 jfilby 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   W32kGuiCheck();
 192
 193   DPRINT("About to open window station handle (0x%X)\n",
 194          PROCESS_WINDOW_STATION());
 195
 196   Status = ValidateWindowStationHandle(PROCESS_WINDOW_STATION(),
 197                                        KernelMode,
 198                                        0,
 199                                        &WinStaObject);
 200   if (!NT_SUCCESS(Status))
 201     {
 202       DPRINT("Validation of window station handle (0x%X) failed\n",
 203              PROCESS_WINDOW_STATION());
 204       return((RTL_ATOM)0);
 205     }
 206
 207   Status = RtlAddAtomToAtomTable(WinStaObject->AtomTable,
 208                                  (LPWSTR)lpwcx->lpszClassName,
 209                                  &Atom);
 210   if (!NT_SUCCESS(Status))
 211     {
 212       ObDereferenceObject(WinStaObject);
 213       DPRINT("Failed adding class name (%wS) to atom table\n",
 214              lpwcx->lpszClassName);
 215       SetLastNtError(Status);
 216
 217       return((RTL_ATOM)0);
 218   }
 219
 220   objectSize = sizeof(WNDCLASS_OBJECT) +
 221     (lpwcx->lpszMenuName != 0 ? ((wcslen (lpwcx->lpszMenuName) + 1) * 2) : 0) +
 222     ((wcslen (lpwcx->lpszClassName) + 1) * 2);
 223   ClassObject = ObmCreateObject(NULL, NULL, otClass, objectSize);
 224   if (ClassObject == 0)
 225     {
 226       RtlDeleteAtomFromAtomTable(WinStaObject->AtomTable, Atom);
 227       ObDereferenceObject(WinStaObject);
 228       DPRINT("Failed creating window class object\n");
 229       SetLastNtError(STATUS_INSUFFICIENT_RESOURCES);
 230
 231       return((RTL_ATOM)0);
 232     }
 233
 234   ClassObject->Class = *lpwcx;
 235   ClassObject->Unicode = bUnicodeClass;
 236   namePtr = (LPTSTR)(((PCHAR)ClassObject) + sizeof (WNDCLASS_OBJECT));
 237   if (lpwcx->lpszMenuName != 0)
 238     {
 239       ClassObject->Class.lpszMenuName = namePtr;
 240       wcscpy (namePtr, lpwcx->lpszMenuName);
 241       namePtr += wcslen (lpwcx->lpszMenuName + 1);
 242     }
 243   ClassObject->Class.lpszClassName = namePtr;
 244   wcscpy (namePtr, lpwcx->lpszClassName);
 245   ExAcquireFastMutex(&PsGetWin32Process()->ClassListLock);
 246   InsertTailList(&PsGetWin32Process()->ClassListHead, &ClassObject->ListEntry);
 247   ExReleaseFastMutex(&PsGetWin32Process()->ClassListLock);
 248
 249   ObDereferenceObject(WinStaObject);
 250
 251   return(Atom);
 252 }
 253
 254 DWORD STDCALL
 255 NtUserSetClassLong(DWORD Unknown0,
 256                    DWORD Unknown1,
 257                    DWORD Unknown2,
 258                    DWORD Unknown3)
 259 {
 260   UNIMPLEMENTED;
 261
 262   return(0);
 263 }
 264
 265 DWORD STDCALL
 266 NtUserSetClassWord(DWORD Unknown0,
 267                    DWORD Unknown1,
 268                    DWORD Unknown2)
 269 {
 270   UNIMPLEMENTED;
 271
 272   return(0);
 273 }
 274
 275 DWORD STDCALL
 276 NtUserUnregisterClass(DWORD Unknown0,
 277                       DWORD Unknown1,
 278                       DWORD Unknown2)
 279 {
 280   UNIMPLEMENTED;
 281
 282   return(0);
 283 }
 284
 285 /* EOF */