[CMAKE]
[reactos.git] / subsystems / win32 / win32k / eng / engwindow.c
1 /*
2 * ReactOS W32 Subsystem
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 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 along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19 /*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS kernel
22 * PURPOSE: GDI WNDOBJ Functions
23 * FILE: subsystems/win32/win32k/eng/engwindow.c
24 * PROGRAMER: Gregor Anich
25 * REVISION HISTORY:
26 * 16/11/2004: Created
27 */
28
29 /* TODO: Check how the WNDOBJ implementation should behave with a driver on windows.
30 */
31
32 #include <win32k.h>
33
34 #define NDEBUG
35 #include <debug.h>
36
37 INT gcountPWO = 0;
38
39 /*
40 * Calls the WNDOBJCHANGEPROC of the given WNDOBJ
41 */
42 VOID
43 FASTCALL
44 IntEngWndCallChangeProc(
45 IN WNDOBJ *pwo,
46 IN FLONG flChanged)
47 {
48 WNDGDI *WndObjInt = ObjToGDI(pwo, WND);
49
50 if (WndObjInt->ChangeProc == NULL)
51 {
52 return;
53 }
54
55 /* check flags of the WNDOBJ */
56 flChanged &= WndObjInt->Flags;
57 if (flChanged == 0)
58 {
59 return;
60 }
61
62 /* Call the WNDOBJCHANGEPROC */
63 if (flChanged == WOC_CHANGED)
64 {
65 pwo = NULL;
66 }
67
68 DPRINT("Calling WNDOBJCHANGEPROC (0x%x), Changed = 0x%x\n",
69 WndObjInt->ChangeProc, flChanged);
70 WndObjInt->ChangeProc(pwo, flChanged);
71 }
72
73 /*
74 * Fills the CLIPOBJ and client rect of the WNDOBJ with the data from the given WND
75 */
76 BOOLEAN
77 FASTCALL
78 IntEngWndUpdateClipObj(
79 WNDGDI *WndObjInt,
80 PWND Window)
81 {
82 HRGN hVisRgn;
83 PROSRGNDATA visRgn;
84 CLIPOBJ *ClipObj = NULL;
85 CLIPOBJ *OldClipObj;
86
87 DPRINT("IntEngWndUpdateClipObj\n");
88
89 hVisRgn = VIS_ComputeVisibleRegion(Window, TRUE, TRUE, TRUE);
90 if (hVisRgn != NULL)
91 {
92 NtGdiOffsetRgn(hVisRgn, Window->rcClient.left, Window->rcClient.top);
93 visRgn = RGNOBJAPI_Lock(hVisRgn, NULL);
94 if (visRgn != NULL)
95 {
96 if (visRgn->rdh.nCount > 0)
97 {
98 ClipObj = IntEngCreateClipRegion(visRgn->rdh.nCount, visRgn->Buffer,
99 &visRgn->rdh.rcBound);
100 DPRINT("Created visible region with %d rects\n", visRgn->rdh.nCount);
101 DPRINT(" BoundingRect: %d, %d %d, %d\n",
102 visRgn->rdh.rcBound.left, visRgn->rdh.rcBound.top,
103 visRgn->rdh.rcBound.right, visRgn->rdh.rcBound.bottom);
104 {
105 INT i;
106 for (i = 0; i < visRgn->rdh.nCount; i++)
107 {
108 DPRINT(" Rect #%d: %d,%d %d,%d\n", i+1,
109 visRgn->Buffer[i].left, visRgn->Buffer[i].top,
110 visRgn->Buffer[i].right, visRgn->Buffer[i].bottom);
111 }
112 }
113 }
114 RGNOBJAPI_Unlock(visRgn);
115 }
116 else
117 {
118 DPRINT1("Warning: Couldn't lock visible region of window DC\n");
119 }
120 GreDeleteObject(hVisRgn);
121 }
122 else
123 {
124 DPRINT1("Warning: VIS_ComputeVisibleRegion failed!\n");
125 }
126
127 if (ClipObj == NULL)
128 {
129 /* Fall back to client rect */
130 ClipObj = IntEngCreateClipRegion(1, &Window->rcClient,
131 &Window->rcClient);
132 }
133
134 if (ClipObj == NULL)
135 {
136 DPRINT1("Warning: IntEngCreateClipRegion() failed!\n");
137 return FALSE;
138 }
139
140 RtlCopyMemory(&WndObjInt->WndObj.coClient, ClipObj, sizeof (CLIPOBJ));
141 RtlCopyMemory(&WndObjInt->WndObj.rclClient, &Window->rcClient, sizeof (RECT));
142 OldClipObj = InterlockedExchangePointer((PVOID*)&WndObjInt->ClientClipObj, ClipObj);
143 if (OldClipObj != NULL)
144 IntEngDeleteClipRegion(OldClipObj);
145
146 return TRUE;
147 }
148
149 /*
150 * Updates all WNDOBJs of the given WND and calls the change-procs.
151 */
152 VOID
153 FASTCALL
154 IntEngWindowChanged(
155 PWND Window,
156 FLONG flChanged)
157 {
158 WNDGDI *Current;
159 HWND hWnd;
160
161 ASSERT_IRQL_LESS_OR_EQUAL(PASSIVE_LEVEL);
162
163 hWnd = Window->head.h;
164 Current = (WNDGDI *)IntGetProp(Window, AtomWndObj);
165
166 if ( gcountPWO &&
167 Current &&
168 Current->Hwnd == hWnd &&
169 Current->WndObj.pvConsumer != NULL )
170 {
171 /* Update the WNDOBJ */
172 switch (flChanged)
173 {
174 case WOC_RGN_CLIENT:
175 /* Update the clipobj and client rect of the WNDOBJ */
176 IntEngWndUpdateClipObj(Current, Window);
177 break;
178
179 case WOC_DELETE:
180 /* FIXME: Should the WNDOBJs be deleted by win32k or by the driver? */
181 break;
182 }
183
184 /* Call the change proc */
185 IntEngWndCallChangeProc(&Current->WndObj, flChanged);
186
187 /* HACK: Send WOC_CHANGED after WOC_RGN_CLIENT */
188 if (flChanged == WOC_RGN_CLIENT)
189 {
190 IntEngWndCallChangeProc(&Current->WndObj, WOC_CHANGED);
191 }
192 }
193 }
194
195 /*
196 * @implemented
197 */
198 WNDOBJ*
199 APIENTRY
200 EngCreateWnd(
201 SURFOBJ *pso,
202 HWND hWnd,
203 WNDOBJCHANGEPROC pfn,
204 FLONG fl,
205 int iPixelFormat)
206 {
207 WNDGDI *WndObjInt = NULL;
208 WNDOBJ *WndObjUser = NULL;
209 PWND Window;
210 BOOL calledFromUser;
211 DECLARE_RETURN(WNDOBJ*);
212
213 DPRINT("EngCreateWnd: pso = 0x%x, hwnd = 0x%x, pfn = 0x%x, fl = 0x%x, pixfmt = %d\n",
214 pso, hWnd, pfn, fl, iPixelFormat);
215
216 calledFromUser = UserIsEntered();
217 if (!calledFromUser){
218 UserEnterShared();
219 }
220
221 /* Get window object */
222 Window = UserGetWindowObject(hWnd);
223 if (Window == NULL)
224 {
225 RETURN( NULL);
226 }
227
228 /* Create WNDOBJ */
229 WndObjInt = EngAllocMem(0, sizeof (WNDGDI), GDITAG_WNDOBJ);
230 if (WndObjInt == NULL)
231 {
232 DPRINT1("Failed to allocate memory for a WND structure!\n");
233 RETURN( NULL);
234 }
235
236 /* Fill the clipobj */
237 WndObjInt->ClientClipObj = NULL;
238 if (!IntEngWndUpdateClipObj(WndObjInt, Window))
239 {
240 EngFreeMem(WndObjInt);
241 RETURN( NULL);
242 }
243
244 /* Fill user object */
245 WndObjUser = GDIToObj(WndObjInt, WND);
246 WndObjUser->psoOwner = pso;
247 WndObjUser->pvConsumer = NULL;
248
249 /* Fill internal object */
250 WndObjInt->Hwnd = hWnd;
251 WndObjInt->ChangeProc = pfn;
252 WndObjInt->Flags = fl;
253 WndObjInt->PixelFormat = iPixelFormat;
254
255 /* associate object with window */
256 IntSetProp(Window, AtomWndObj, WndObjInt);
257 ++gcountPWO;
258
259 DPRINT("EngCreateWnd: SUCCESS!\n");
260
261 RETURN( WndObjUser);
262
263 CLEANUP:
264
265 if (!calledFromUser){
266 UserLeave();
267 }
268
269 END_CLEANUP;
270 }
271
272
273 /*
274 * @implemented
275 */
276 VOID
277 APIENTRY
278 EngDeleteWnd(
279 IN WNDOBJ *pwo)
280 {
281 WNDGDI *WndObjInt = ObjToGDI(pwo, WND);
282 PWND Window;
283 BOOL calledFromUser;
284
285 DPRINT("EngDeleteWnd: pwo = 0x%x\n", pwo);
286
287 calledFromUser = UserIsEntered();
288 if (!calledFromUser){
289 UserEnterExclusive();
290 }
291
292 /* Get window object */
293 Window = UserGetWindowObject(WndObjInt->Hwnd);
294 if (Window == NULL)
295 {
296 DPRINT1("Warning: Couldnt get window object for WndObjInt->Hwnd!!!\n");
297 }
298 else
299 {
300 /* Remove object from window */
301 IntRemoveProp(Window, AtomWndObj);
302 --gcountPWO;
303 }
304
305 if (!calledFromUser){
306 UserLeave();
307 }
308
309 /* Free resources */
310 IntEngDeleteClipRegion(WndObjInt->ClientClipObj);
311 EngFreeMem(WndObjInt);
312 }
313
314
315 /*
316 * @implemented
317 */
318 BOOL
319 APIENTRY
320 WNDOBJ_bEnum(
321 IN WNDOBJ *pwo,
322 IN ULONG cj,
323 OUT ULONG *pul)
324 {
325 WNDGDI *WndObjInt = ObjToGDI(pwo, WND);
326 BOOL Ret;
327
328 DPRINT("WNDOBJ_bEnum: pwo = 0x%x, cj = %d, pul = 0x%x\n", pwo, cj, pul);
329 Ret = CLIPOBJ_bEnum(WndObjInt->ClientClipObj, cj, pul);
330
331 DPRINT("WNDOBJ_bEnum: Returning %s\n", Ret ? "True" : "False");
332 return Ret;
333 }
334
335
336 /*
337 * @implemented
338 */
339 ULONG
340 APIENTRY
341 WNDOBJ_cEnumStart(
342 IN WNDOBJ *pwo,
343 IN ULONG iType,
344 IN ULONG iDirection,
345 IN ULONG cLimit)
346 {
347 WNDGDI *WndObjInt = ObjToGDI(pwo, WND);
348 ULONG Ret;
349
350 DPRINT("WNDOBJ_cEnumStart: pwo = 0x%x, iType = %d, iDirection = %d, cLimit = %d\n",
351 pwo, iType, iDirection, cLimit);
352
353 /* FIXME: Should we enumerate all rectangles or not? */
354 Ret = CLIPOBJ_cEnumStart(WndObjInt->ClientClipObj, FALSE, iType, iDirection, cLimit);
355
356 DPRINT("WNDOBJ_cEnumStart: Returning 0x%x\n", Ret);
357 return Ret;
358 }
359
360
361 /*
362 * @implemented
363 */
364 VOID
365 APIENTRY
366 WNDOBJ_vSetConsumer(
367 IN WNDOBJ *pwo,
368 IN PVOID pvConsumer)
369 {
370 BOOL Hack;
371
372 DPRINT("WNDOBJ_vSetConsumer: pwo = 0x%x, pvConsumer = 0x%x\n", pwo, pvConsumer);
373
374 Hack = (pwo->pvConsumer == NULL);
375 pwo->pvConsumer = pvConsumer;
376
377 /* HACKHACKHACK
378 *
379 * MSDN says that the WNDOBJCHANGEPROC will be called with the most recent state
380 * when a WNDOBJ is created - we do it here because most drivers will need pvConsumer
381 * in the callback to identify the WNDOBJ I think.
382 *
383 * - blight
384 */
385 if (Hack)
386 {
387 IntEngWndCallChangeProc(pwo, WOC_RGN_CLIENT);
388 IntEngWndCallChangeProc(pwo, WOC_CHANGED);
389 IntEngWndCallChangeProc(pwo, WOC_DRAWN);
390 }
391 }
392
393 /* EOF */
394