xref: /reactos/win32ss/user/ntuser/layered.c (revision 1734f297) 
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, TRUE);
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, TRUE);
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, TRUE);
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       UserSetProp(pWnd, AtomLayer, (HANDLE)pLrdProp, TRUE);
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 hOldBitmap, hOldBitmap1, hbmSrc, hbmDst;
158       DIBSECTION dibs;
159 
160       Rect = Window;
161 
162       RECTL_vOffsetRect( &Rect, -Window.left, -Window.top );
163 
164       TRACE("H %d W %d\n",Rect.bottom - Rect.top,Rect.right - Rect.left);
165 
166       if (!info->hdcDst) hdc = UserGetDCEx(pWnd, NULL, DCX_USESTYLE);
167       else hdc = info->hdcDst;
168 
169       hbmSrc = NtGdiCreateCompatibleBitmap(info->hdcSrc, Rect.right - Rect.left, Rect.bottom - Rect.top);
170       hbmDst = NtGdiCreateCompatibleBitmap(info->hdcSrc, Rect.right - Rect.left, Rect.bottom - Rect.top);
171 
172       GreGetObject(hbmSrc, sizeof(DIBSECTION), &dibs);
173 
174       TRACE("Source Bitmap bc %d\n",dibs.dsBmih.biBitCount);
175 
176       hdcBuffer = NtGdiCreateCompatibleDC(hdc);
177 
178       hOldBitmap = (HBITMAP)NtGdiSelectBitmap(hdcBuffer, hbmSrc);
179       hOldBitmap1 = (HBITMAP)NtGdiSelectBitmap(hdc, hbmDst);
180 
181       NtGdiStretchBlt( hdcBuffer,
182                        Rect.left,
183                        Rect.top,
184                        Rect.right - Rect.left,
185                        Rect.bottom - Rect.top,
186                        info->hdcSrc,
187                        Rect.left + (info->pptSrc ? info->pptSrc->x : 0),
188                        Rect.top  + (info->pptSrc ? info->pptSrc->y : 0),
189                        Rect.right - Rect.left,
190                        Rect.bottom - Rect.top,
191                        SRCCOPY,
192                        color_key );
193 
194       // Need to test this, Dirty before or after StretchBlt?
195       if (info->prcDirty)
196       {
197          ERR("prcDirty\n");
198          RECTL_bIntersectRect( &Rect, &Rect, info->prcDirty );
199          NtGdiPatBlt( hdc, Rect.left, Rect.top, Rect.right - Rect.left, Rect.bottom - Rect.top, BLACKNESS );
200       }
201 
202       if (info->dwFlags & ULW_ALPHA)
203       {
204          blend = *info->pblend;
205          TRACE("ULW_ALPHA bop %d Alpha %d aF %d\n", blend.BlendOp, blend.SourceConstantAlpha, blend.AlphaFormat);
206       }
207 
208       ret = NtGdiAlphaBlend( hdc,
209                              Rect.left,
210                              Rect.top,
211                              Rect.right - Rect.left,
212                              Rect.bottom - Rect.top,
213                              hdcBuffer,
214                              Rect.left + (info->pptSrc ? info->pptSrc->x : 0),
215                              Rect.top  + (info->pptSrc ? info->pptSrc->y : 0),
216                              Rect.right - Rect.left,
217                              Rect.bottom - Rect.top,
218                              blend,
219                              0);
220 
221       NtGdiSelectBitmap(hdc, hOldBitmap1);
222       NtGdiSelectBitmap(hdcBuffer, hOldBitmap);
223       if (hbmSrc) GreDeleteObject(hbmSrc);
224       if (hbmDst) GreDeleteObject(hbmDst);
225       if (hdcBuffer) IntGdiDeleteDC(hdcBuffer, FALSE);
226       if (!info->hdcDst) UserReleaseDC(pWnd, hdc, FALSE);
227    }
228    else
229       ret = TRUE;
230 
231    co_WinPosSetWindowPos(pWnd, 0, Window.left, Window.top, Window.right - Window.left, Window.bottom - Window.top, flags);
232    return ret;
233 }
234 
235 
236 /*
237  * @implemented
238  */
239 BOOL
240 APIENTRY
241 NtUserGetLayeredWindowAttributes(
242     HWND hwnd,
243     COLORREF *pcrKey,
244     BYTE *pbAlpha,
245     DWORD *pdwFlags)
246 {
247    PLRD_PROP pLrdProp;
248    PWND pWnd;
249    BOOL Ret = FALSE;
250 
251    TRACE("Enter NtUserGetLayeredWindowAttributes\n");
252    UserEnterExclusive();
253 
254    if (!(pWnd = UserGetWindowObject(hwnd)) ||
255        !(pWnd->ExStyle & WS_EX_LAYERED) )
256    {
257       ERR("Not a Layered Window!\n");
258       goto Exit;
259    }
260 
261    pLrdProp = UserGetProp(pWnd, AtomLayer, TRUE);
262 
263    if (!pLrdProp)
264    {
265       TRACE("No Prop!\n");
266       goto Exit;
267    }
268 
269    if (pLrdProp->is_Layered == 0)
270    {
271       goto Exit;
272    }
273 
274    _SEH2_TRY
275    {
276       if (pcrKey)
277       {
278           ProbeForWrite(pcrKey, sizeof(*pcrKey), 1);
279           *pcrKey = pLrdProp->Key;
280       }
281       if (pbAlpha)
282       {
283           ProbeForWrite(pbAlpha, sizeof(*pbAlpha), 1);
284           *pbAlpha = pLrdProp->Alpha;
285       }
286       if (pdwFlags)
287       {
288           ProbeForWrite(pdwFlags, sizeof(*pdwFlags), 1);
289           *pdwFlags = pLrdProp->Flags;
290       }
291    }
292    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
293    {
294       SetLastNtError(_SEH2_GetExceptionCode());
295       _SEH2_YIELD(goto Exit);
296    }
297    _SEH2_END;
298 
299    Ret = TRUE;
300 
301 Exit:
302    TRACE("Leave NtUserGetLayeredWindowAttributes, ret=%i\n", Ret);
303    UserLeave();
304    return Ret;
305 }
306 
307 /*
308  * @implemented
309  */
310 BOOL APIENTRY
311 NtUserSetLayeredWindowAttributes(HWND hwnd,
312 			   COLORREF crKey,
313 			   BYTE bAlpha,
314 			   DWORD dwFlags)
315 {
316    PWND pWnd;
317    BOOL Ret = FALSE;
318 
319    TRACE("Enter NtUserSetLayeredWindowAttributes\n");
320    UserEnterExclusive();
321 
322    if (!(pWnd = UserGetWindowObject(hwnd)) ||
323        !(pWnd->ExStyle & WS_EX_LAYERED) )
324    {
325       ERR("Not a Layered Window!\n");
326       goto Exit;
327    }
328 
329    Ret = IntSetLayeredWindowAttributes(pWnd, crKey, bAlpha, dwFlags);
330 Exit:
331    TRACE("Leave NtUserSetLayeredWindowAttributes, ret=%i\n", Ret);
332    UserLeave();
333    return Ret;
334 }
335 
336 /*
337  * @implemented
338  */
339 BOOL
340 APIENTRY
341 NtUserUpdateLayeredWindow(
342    HWND hwnd,
343    HDC hdcDst,
344    POINT *pptDst,
345    SIZE *psize,
346    HDC hdcSrc,
347    POINT *pptSrc,
348    COLORREF crKey,
349    BLENDFUNCTION *pblend,
350    DWORD dwFlags,
351    RECT *prcDirty)
352 {
353    UPDATELAYEREDWINDOWINFO info;
354    POINT Dst, Src;
355    SIZE Size;
356    RECT Dirty;
357    BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, 0 };
358    PWND pWnd;
359    BOOL Ret = FALSE;
360 
361    TRACE("Enter NtUserUpdateLayeredWindow\n");
362    UserEnterExclusive();
363 
364    if (!(pWnd = UserGetWindowObject(hwnd)))
365    {
366       goto Exit;
367    }
368 
369    _SEH2_TRY
370    {
371       if (pptDst)
372       {
373          ProbeForRead(pptDst, sizeof(POINT), 1);
374          Dst = *pptDst;
375       }
376       if (pptSrc)
377       {
378          ProbeForRead(pptSrc, sizeof(POINT), 1);
379          Src = *pptSrc;
380       }
381       ProbeForRead(psize, sizeof(SIZE), 1);
382       Size = *psize;
383       if (pblend)
384       {
385          ProbeForRead(pblend, sizeof(BLENDFUNCTION), 1);
386          blend = *pblend;
387       }
388       if (prcDirty)
389       {
390          ProbeForRead(prcDirty, sizeof(RECT), 1);
391          Dirty = *prcDirty;
392       }
393    }
394    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
395    {
396       EngSetLastError( ERROR_INVALID_PARAMETER );
397       _SEH2_YIELD(goto Exit);
398    }
399    _SEH2_END;
400 
401    if ( GetLayeredStatus(pWnd) ||
402         dwFlags & ~(ULW_COLORKEY | ULW_ALPHA | ULW_OPAQUE | ULW_EX_NORESIZE) ||
403        !(pWnd->ExStyle & WS_EX_LAYERED) )
404    {
405       ERR("Layered Window Invalid Parameters\n");
406       EngSetLastError( ERROR_INVALID_PARAMETER );
407       goto Exit;
408    }
409 
410    info.cbSize   = sizeof(info);
411    info.hdcDst   = hdcDst;
412    info.pptDst   = pptDst? &Dst : NULL;
413    info.psize    = &Size;
414    info.hdcSrc   = hdcSrc;
415    info.pptSrc   = pptSrc ? &Src : NULL;
416    info.crKey    = crKey;
417    info.pblend   = &blend;
418    info.dwFlags  = dwFlags;
419    info.prcDirty = prcDirty ? &Dirty : NULL;
420    Ret = IntUpdateLayeredWindowI( pWnd, &info );
421 Exit:
422    TRACE("Leave NtUserUpdateLayeredWindow, ret=%i\n", Ret);
423    UserLeave();
424    return Ret;
425 }
426 
427 /* EOF */
428