095636952d3d3f29cc5d43f395fcdd8bf9c608dd
[reactos.git] / reactos / win32ss / user / ntuser / layered.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: Layered window support
5 * FILE: win32ss/user/ntuser/layered.c
6 * PROGRAMER:
7 */
8
9 #include <win32k.h>
10 DBG_DEFAULT_CHANNEL(UserMisc);
11
12
13 typedef struct _LRD_PROP
14 {
15 COLORREF Key;
16 BYTE Alpha;
17 BYTE is_Layered;
18 BYTE NoUsed[2];
19 DWORD Flags;
20 } LRD_PROP, *PLRD_PROP;
21
22 BOOL FASTCALL
23 GetLayeredStatus(PWND pWnd)
24 {
25 PLRD_PROP pLrdProp = UserGetProp(pWnd, AtomLayer);
26 if (pLrdProp)
27 {
28 return pLrdProp->is_Layered;
29 }
30 return FALSE;
31 }
32
33 BOOL FASTCALL
34 SetLayeredStatus(PWND pWnd, BYTE set)
35 {
36 PLRD_PROP pLrdProp = UserGetProp(pWnd, AtomLayer);
37 if (pLrdProp)
38 {
39 pLrdProp->is_Layered = set;
40 return TRUE;
41 }
42 return FALSE;
43 }
44
45 BOOL FASTCALL
46 IntSetLayeredWindowAttributes(PWND pWnd,
47 COLORREF crKey,
48 BYTE bAlpha,
49 DWORD dwFlags)
50 {
51 PLRD_PROP pLrdProp;
52 INT was_Layered;
53
54 if (!(pWnd->ExStyle & WS_EX_LAYERED) )
55 {
56 ERR("Not a Layered Window!\n");
57 return FALSE;
58 }
59
60 pLrdProp = UserGetProp(pWnd, AtomLayer);
61
62 if (!pLrdProp)
63 {
64 pLrdProp = ExAllocatePoolWithTag(PagedPool, sizeof(LRD_PROP), USERTAG_REDIRECT);
65 if (pLrdProp == NULL)
66 {
67 ERR("failed to allocate LRD_PROP\n");
68 return FALSE;
69 }
70 RtlZeroMemory(pLrdProp, sizeof(LRD_PROP));
71 IntSetProp(pWnd, AtomLayer, (HANDLE)pLrdProp);
72 }
73
74 if (pLrdProp)
75 {
76 was_Layered = pLrdProp->is_Layered;
77
78 pLrdProp->Key = crKey;
79
80 if (dwFlags & LWA_ALPHA)
81 {
82 pLrdProp->Alpha = bAlpha;
83 }
84 else
85 {
86 if (!pLrdProp->is_Layered) pLrdProp->Alpha = 0;
87 }
88
89 pLrdProp->Flags = dwFlags;
90
91 pLrdProp->is_Layered = 1;
92
93 if (!was_Layered)
94 co_UserRedrawWindow(pWnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
95 }
96 // FIXME: Now set some bits to the Window DC!!!!
97 return TRUE;
98 }
99
100 BOOL FASTCALL
101 IntUpdateLayeredWindowI( PWND pWnd,
102 UPDATELAYEREDWINDOWINFO *info )
103 {
104 PWND Parent;
105 RECT Window, Client;
106 SIZE Offset;
107 BOOL ret = FALSE;
108 DWORD flags = SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW;
109
110 Window = pWnd->rcWindow;
111 Client = pWnd->rcClient;
112
113 Parent = pWnd->spwndParent;
114 if (pWnd->style & WS_CHILD && Parent)
115 {
116 RECTL_vOffsetRect(&Window, - Parent->rcClient.left, - Parent->rcClient.top);
117 RECTL_vOffsetRect(&Client, - Parent->rcClient.left, - Parent->rcClient.top);
118 }
119
120 if (info->pptDst)
121 {
122 Offset.cx = info->pptDst->x - Window.left;
123 Offset.cy = info->pptDst->y - Window.top;
124 RECTL_vOffsetRect( &Client, Offset.cx, Offset.cy );
125 RECTL_vOffsetRect( &Window, Offset.cx, Offset.cy );
126 flags &= ~SWP_NOMOVE;
127 }
128 if (info->psize)
129 {
130 Offset.cx = info->psize->cx - (Window.right - Window.left);
131 Offset.cy = info->psize->cy - (Window.bottom - Window.top);
132 if (info->psize->cx <= 0 || info->psize->cy <= 0)
133 {
134 ERR("Update Layered Invalid Parameters\n");
135 EngSetLastError( ERROR_INVALID_PARAMETER );
136 return FALSE;
137 }
138 if ((info->dwFlags & ULW_EX_NORESIZE) && (Offset.cx || Offset.cy))
139 {
140 ERR("Wrong Size\n");
141 EngSetLastError( ERROR_INCORRECT_SIZE );
142 return FALSE;
143 }
144 Client.right += Offset.cx;
145 Client.bottom += Offset.cy;
146 Window.right += Offset.cx;
147 Window.bottom += Offset.cy;
148 flags &= ~SWP_NOSIZE;
149 }
150
151 if (info->hdcSrc)
152 {
153 HDC hdc, hdcBuffer;
154 RECT Rect;
155 BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, 0 };
156 COLORREF color_key = (info->dwFlags & ULW_COLORKEY) ? info->crKey : CLR_INVALID;
157 HBITMAP hBitmapBuffer, hOldBitmap;
158
159 Rect = Window;
160
161 RECTL_vOffsetRect( &Rect, -Window.left, -Window.top );
162
163 TRACE("H %d W %d\n",Rect.bottom - Rect.top,Rect.right - Rect.left);
164
165 if (!info->hdcDst) hdc = UserGetDCEx(pWnd, NULL, DCX_USESTYLE);
166 else hdc = info->hdcDst;
167
168 hdcBuffer = NtGdiCreateCompatibleDC(hdc);
169 hBitmapBuffer = NtGdiCreateCompatibleBitmap(hdc, Rect.right - Rect.left, Rect.bottom - Rect.top);
170 hOldBitmap = (HBITMAP)NtGdiSelectBitmap(hdcBuffer, hBitmapBuffer);
171
172 NtGdiStretchBlt( hdcBuffer,
173 Rect.left,
174 Rect.top,
175 Rect.right - Rect.left,
176 Rect.bottom - Rect.top,
177 info->hdcSrc,
178 Rect.left + (info->pptSrc ? info->pptSrc->x : 0),
179 Rect.top + (info->pptSrc ? info->pptSrc->y : 0),
180 Rect.right - Rect.left,
181 Rect.bottom - Rect.top,
182 SRCCOPY,
183 color_key );
184
185 // Need to test this, Dirty before or after StretchBlt?
186 if (info->prcDirty)
187 {
188 ERR("prcDirty\n");
189 RECTL_bIntersectRect( &Rect, &Rect, info->prcDirty );
190 NtGdiPatBlt( hdc, Rect.left, Rect.top, Rect.right - Rect.left, Rect.bottom - Rect.top, BLACKNESS );
191 }
192
193 if (info->dwFlags & ULW_ALPHA)
194 {
195 blend = *info->pblend;
196 TRACE("ULW_ALPHA bop %d Alpha %d aF %d\n", blend.BlendOp, blend.SourceConstantAlpha, blend.AlphaFormat);
197 }
198
199 ret = NtGdiAlphaBlend( hdc,
200 Rect.left,
201 Rect.top,
202 Rect.right - Rect.left,
203 Rect.bottom - Rect.top,
204 hdcBuffer,
205 Rect.left + (info->pptSrc ? info->pptSrc->x : 0),
206 Rect.top + (info->pptSrc ? info->pptSrc->y : 0),
207 Rect.right - Rect.left,
208 Rect.bottom - Rect.top,
209 blend,
210 0);
211
212 NtGdiSelectBitmap(hdcBuffer, hOldBitmap);
213 if (hBitmapBuffer) GreDeleteObject(hBitmapBuffer);
214 if (hdcBuffer) IntGdiDeleteDC(hdcBuffer, FALSE);
215 if (!info->hdcDst) UserReleaseDC(pWnd, hdc, FALSE);
216 }
217 else
218 ret = TRUE;
219
220 co_WinPosSetWindowPos(pWnd, 0, Window.left, Window.top, Window.right - Window.left, Window.bottom - Window.top, flags);
221 return ret;
222 }
223
224
225 /*
226 * @implemented
227 */
228 BOOL
229 APIENTRY
230 NtUserGetLayeredWindowAttributes(
231 HWND hwnd,
232 COLORREF *pcrKey,
233 BYTE *pbAlpha,
234 DWORD *pdwFlags)
235 {
236 PLRD_PROP pLrdProp;
237 PWND pWnd;
238 BOOL Ret = FALSE;
239
240 TRACE("Enter NtUserGetLayeredWindowAttributes\n");
241 UserEnterExclusive();
242
243 if (!(pWnd = UserGetWindowObject(hwnd)) ||
244 !(pWnd->ExStyle & WS_EX_LAYERED) )
245 {
246 ERR("Not a Layered Window!\n");
247 goto Exit;
248 }
249
250 pLrdProp = UserGetProp(pWnd, AtomLayer);
251
252 if (!pLrdProp)
253 {
254 TRACE("No Prop!\n");
255 goto Exit;
256 }
257
258 if (pLrdProp->is_Layered == 0)
259 {
260 goto Exit;
261 }
262
263 _SEH2_TRY
264 {
265 if (pcrKey)
266 {
267 ProbeForWrite(pcrKey, sizeof(*pcrKey), 1);
268 *pcrKey = pLrdProp->Key;
269 }
270 if (pbAlpha)
271 {
272 ProbeForWrite(pbAlpha, sizeof(*pbAlpha), 1);
273 *pbAlpha = pLrdProp->Alpha;
274 }
275 if (pdwFlags)
276 {
277 ProbeForWrite(pdwFlags, sizeof(*pdwFlags), 1);
278 *pdwFlags = pLrdProp->Flags;
279 }
280 }
281 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
282 {
283 SetLastNtError(_SEH2_GetExceptionCode());
284 _SEH2_YIELD(goto Exit);
285 }
286 _SEH2_END;
287
288 Ret = TRUE;
289
290 Exit:
291 TRACE("Leave NtUserGetLayeredWindowAttributes, ret=%i\n", Ret);
292 UserLeave();
293 return Ret;
294 }
295
296 /*
297 * @implemented
298 */
299 BOOL APIENTRY
300 NtUserSetLayeredWindowAttributes(HWND hwnd,
301 COLORREF crKey,
302 BYTE bAlpha,
303 DWORD dwFlags)
304 {
305 PWND pWnd;
306 BOOL Ret = FALSE;
307
308 TRACE("Enter NtUserSetLayeredWindowAttributes\n");
309 UserEnterExclusive();
310
311 if (!(pWnd = UserGetWindowObject(hwnd)) ||
312 !(pWnd->ExStyle & WS_EX_LAYERED) )
313 {
314 ERR("Not a Layered Window!\n");
315 goto Exit;
316 }
317
318 Ret = IntSetLayeredWindowAttributes(pWnd, crKey, bAlpha, dwFlags);
319 Exit:
320 TRACE("Leave NtUserSetLayeredWindowAttributes, ret=%i\n", Ret);
321 UserLeave();
322 return Ret;
323 }
324
325 /*
326 * @implemented
327 */
328 BOOL
329 APIENTRY
330 NtUserUpdateLayeredWindow(
331 HWND hwnd,
332 HDC hdcDst,
333 POINT *pptDst,
334 SIZE *psize,
335 HDC hdcSrc,
336 POINT *pptSrc,
337 COLORREF crKey,
338 BLENDFUNCTION *pblend,
339 DWORD dwFlags,
340 RECT *prcDirty)
341 {
342 UPDATELAYEREDWINDOWINFO info;
343 POINT Dst, Src;
344 SIZE Size;
345 RECT Dirty;
346 BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, 0 };
347 PWND pWnd;
348 BOOL Ret = FALSE;
349
350 TRACE("Enter NtUserUpdateLayeredWindow\n");
351 UserEnterExclusive();
352
353 if (!(pWnd = UserGetWindowObject(hwnd)))
354 {
355 goto Exit;
356 }
357
358 _SEH2_TRY
359 {
360 if (pptDst)
361 {
362 ProbeForRead(pptDst, sizeof(POINT), 1);
363 Dst = *pptDst;
364 }
365 if (pptSrc)
366 {
367 ProbeForRead(pptSrc, sizeof(POINT), 1);
368 Src = *pptSrc;
369 }
370 ProbeForRead(psize, sizeof(SIZE), 1);
371 Size = *psize;
372 if (pblend)
373 {
374 ProbeForRead(pblend, sizeof(BLENDFUNCTION), 1);
375 blend = *pblend;
376 }
377 if (prcDirty)
378 {
379 ProbeForRead(prcDirty, sizeof(RECT), 1);
380 Dirty = *prcDirty;
381 }
382 }
383 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
384 {
385 EngSetLastError( ERROR_INVALID_PARAMETER );
386 _SEH2_YIELD(goto Exit);
387 }
388 _SEH2_END;
389
390 if ( GetLayeredStatus(pWnd) ||
391 dwFlags & ~(ULW_COLORKEY | ULW_ALPHA | ULW_OPAQUE | ULW_EX_NORESIZE) ||
392 !(pWnd->ExStyle & WS_EX_LAYERED) )
393 {
394 ERR("Layered Window Invalid Parameters\n");
395 EngSetLastError( ERROR_INVALID_PARAMETER );
396 goto Exit;
397 }
398
399 info.cbSize = sizeof(info);
400 info.hdcDst = hdcDst;
401 info.pptDst = pptDst? &Dst : NULL;
402 info.psize = &Size;
403 info.hdcSrc = hdcSrc;
404 info.pptSrc = pptSrc ? &Src : NULL;
405 info.crKey = crKey;
406 info.pblend = &blend;
407 info.dwFlags = dwFlags;
408 info.prcDirty = prcDirty ? &Dirty : NULL;
409 Ret = IntUpdateLayeredWindowI( pWnd, &info );
410 Exit:
411 TRACE("Leave NtUserUpdateLayeredWindow, ret=%i\n", Ret);
412 UserLeave();
413 return Ret;
414 }
415
416 /* EOF */