reactos/subsys/win32k/ntuser/class.c

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