[WIN32SS][NTGDI] Extend PATH_FillPath as PATH_FillPathEx (#798)
[reactos.git] / win32ss / gdi / ntgdi / bitblt.c
1 /*
2 * COPYRIGHT: GNU GPL, See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Bit blit functions
5 * FILE: win32ss/gdi/ntgdi/bitblt.c
6 * PROGRAMER: Unknown
7 */
8
9 #include <win32k.h>
10 DBG_DEFAULT_CHANNEL(GdiBlt);
11
12 BOOL APIENTRY
13 NtGdiAlphaBlend(
14 HDC hDCDest,
15 LONG XOriginDest,
16 LONG YOriginDest,
17 LONG WidthDest,
18 LONG HeightDest,
19 HDC hDCSrc,
20 LONG XOriginSrc,
21 LONG YOriginSrc,
22 LONG WidthSrc,
23 LONG HeightSrc,
24 BLENDFUNCTION BlendFunc,
25 HANDLE hcmXform)
26 {
27 PDC DCDest;
28 PDC DCSrc;
29 HDC ahDC[2];
30 PGDIOBJ apObj[2];
31 SURFACE *BitmapDest, *BitmapSrc;
32 RECTL DestRect, SourceRect;
33 BOOL bResult;
34 EXLATEOBJ exlo;
35 BLENDOBJ BlendObj;
36 BlendObj.BlendFunction = BlendFunc;
37
38 if (WidthDest < 0 || HeightDest < 0 || WidthSrc < 0 || HeightSrc < 0)
39 {
40 EngSetLastError(ERROR_INVALID_PARAMETER);
41 return FALSE;
42 }
43
44 if ((hDCDest == NULL) || (hDCSrc == NULL))
45 {
46 EngSetLastError(ERROR_INVALID_PARAMETER);
47 return FALSE;
48 }
49
50 TRACE("Locking DCs\n");
51 ahDC[0] = hDCDest;
52 ahDC[1] = hDCSrc ;
53 if (!GDIOBJ_bLockMultipleObjects(2, (HGDIOBJ*)ahDC, apObj, GDIObjType_DC_TYPE))
54 {
55 WARN("Invalid dc handle (dest=0x%p, src=0x%p) passed to NtGdiAlphaBlend\n", hDCDest, hDCSrc);
56 EngSetLastError(ERROR_INVALID_HANDLE);
57 return FALSE;
58 }
59 DCDest = apObj[0];
60 DCSrc = apObj[1];
61
62 if (DCDest->dctype == DC_TYPE_INFO || DCDest->dctype == DCTYPE_INFO)
63 {
64 GDIOBJ_vUnlockObject(&DCSrc->BaseObject);
65 GDIOBJ_vUnlockObject(&DCDest->BaseObject);
66 /* Yes, Windows really returns TRUE in this case */
67 return TRUE;
68 }
69
70 DestRect.left = XOriginDest;
71 DestRect.top = YOriginDest;
72 DestRect.right = XOriginDest + WidthDest;
73 DestRect.bottom = YOriginDest + HeightDest;
74 IntLPtoDP(DCDest, (LPPOINT)&DestRect, 2);
75
76 DestRect.left += DCDest->ptlDCOrig.x;
77 DestRect.top += DCDest->ptlDCOrig.y;
78 DestRect.right += DCDest->ptlDCOrig.x;
79 DestRect.bottom += DCDest->ptlDCOrig.y;
80
81 if (DCDest->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
82 {
83 IntUpdateBoundsRect(DCDest, &DestRect);
84 }
85
86 SourceRect.left = XOriginSrc;
87 SourceRect.top = YOriginSrc;
88 SourceRect.right = XOriginSrc + WidthSrc;
89 SourceRect.bottom = YOriginSrc + HeightSrc;
90 IntLPtoDP(DCSrc, (LPPOINT)&SourceRect, 2);
91
92 SourceRect.left += DCSrc->ptlDCOrig.x;
93 SourceRect.top += DCSrc->ptlDCOrig.y;
94 SourceRect.right += DCSrc->ptlDCOrig.x;
95 SourceRect.bottom += DCSrc->ptlDCOrig.y;
96
97 if (!DestRect.right ||
98 !DestRect.bottom ||
99 !SourceRect.right ||
100 !SourceRect.bottom)
101 {
102 GDIOBJ_vUnlockObject(&DCSrc->BaseObject);
103 GDIOBJ_vUnlockObject(&DCDest->BaseObject);
104 return TRUE;
105 }
106
107 /* Prepare DCs for blit */
108 TRACE("Preparing DCs for blit\n");
109 DC_vPrepareDCsForBlit(DCDest, &DestRect, DCSrc, &SourceRect);
110
111 /* Determine surfaces to be used in the bitblt */
112 BitmapDest = DCDest->dclevel.pSurface;
113 if (!BitmapDest)
114 {
115 bResult = FALSE ;
116 goto leave ;
117 }
118
119 BitmapSrc = DCSrc->dclevel.pSurface;
120 if (!BitmapSrc)
121 {
122 bResult = FALSE;
123 goto leave;
124 }
125
126 /* Create the XLATEOBJ. */
127 EXLATEOBJ_vInitXlateFromDCs(&exlo, DCSrc, DCDest);
128
129 /* Perform the alpha blend operation */
130 TRACE("Performing the alpha blend\n");
131 bResult = IntEngAlphaBlend(&BitmapDest->SurfObj,
132 &BitmapSrc->SurfObj,
133 (CLIPOBJ *)&DCDest->co,
134 &exlo.xlo,
135 &DestRect,
136 &SourceRect,
137 &BlendObj);
138
139 EXLATEOBJ_vCleanup(&exlo);
140 leave :
141 TRACE("Finishing blit\n");
142 DC_vFinishBlit(DCDest, DCSrc);
143 GDIOBJ_vUnlockObject(&DCSrc->BaseObject);
144 GDIOBJ_vUnlockObject(&DCDest->BaseObject);
145
146 return bResult;
147 }
148
149 BOOL APIENTRY
150 NtGdiBitBlt(
151 HDC hDCDest,
152 INT XDest,
153 INT YDest,
154 INT Width,
155 INT Height,
156 HDC hDCSrc,
157 INT XSrc,
158 INT YSrc,
159 DWORD dwRop,
160 IN DWORD crBackColor,
161 IN FLONG fl)
162 {
163
164 if (dwRop & CAPTUREBLT)
165 {
166 return NtGdiStretchBlt(hDCDest,
167 XDest,
168 YDest,
169 Width,
170 Height,
171 hDCSrc,
172 XSrc,
173 YSrc,
174 Width,
175 Height,
176 dwRop,
177 crBackColor);
178 }
179
180 dwRop = dwRop & ~(NOMIRRORBITMAP|CAPTUREBLT);
181
182 /* Forward to NtGdiMaskBlt */
183 // TODO: What's fl for? LOL not to send this to MaskBit!
184 return NtGdiMaskBlt(hDCDest,
185 XDest,
186 YDest,
187 Width,
188 Height,
189 hDCSrc,
190 XSrc,
191 YSrc,
192 NULL,
193 0,
194 0,
195 MAKEROP4(dwRop, dwRop),
196 crBackColor);
197 }
198
199 BOOL APIENTRY
200 NtGdiTransparentBlt(
201 HDC hdcDst,
202 INT xDst,
203 INT yDst,
204 INT cxDst,
205 INT cyDst,
206 HDC hdcSrc,
207 INT xSrc,
208 INT ySrc,
209 INT cxSrc,
210 INT cySrc,
211 COLORREF TransColor)
212 {
213 PDC DCDest, DCSrc;
214 HDC ahDC[2];
215 PGDIOBJ apObj[2];
216 RECTL rcDest, rcSrc;
217 SURFACE *BitmapDest, *BitmapSrc = NULL;
218 ULONG TransparentColor = 0;
219 BOOL Ret = FALSE;
220 EXLATEOBJ exlo;
221
222 if ((hdcDst == NULL) || (hdcSrc == NULL))
223 {
224 EngSetLastError(ERROR_INVALID_PARAMETER);
225 return FALSE;
226 }
227
228 TRACE("Locking DCs\n");
229 ahDC[0] = hdcDst;
230 ahDC[1] = hdcSrc ;
231 if (!GDIOBJ_bLockMultipleObjects(2, (HGDIOBJ*)ahDC, apObj, GDIObjType_DC_TYPE))
232 {
233 WARN("Invalid dc handle (dest=0x%p, src=0x%p) passed to NtGdiAlphaBlend\n", hdcDst, hdcSrc);
234 EngSetLastError(ERROR_INVALID_HANDLE);
235 return FALSE;
236 }
237 DCDest = apObj[0];
238 DCSrc = apObj[1];
239
240 if (DCDest->dctype == DC_TYPE_INFO || DCDest->dctype == DCTYPE_INFO)
241 {
242 GDIOBJ_vUnlockObject(&DCSrc->BaseObject);
243 GDIOBJ_vUnlockObject(&DCDest->BaseObject);
244 /* Yes, Windows really returns TRUE in this case */
245 return TRUE;
246 }
247
248 rcDest.left = xDst;
249 rcDest.top = yDst;
250 rcDest.right = rcDest.left + cxDst;
251 rcDest.bottom = rcDest.top + cyDst;
252 IntLPtoDP(DCDest, (LPPOINT)&rcDest, 2);
253
254 rcDest.left += DCDest->ptlDCOrig.x;
255 rcDest.top += DCDest->ptlDCOrig.y;
256 rcDest.right += DCDest->ptlDCOrig.x;
257 rcDest.bottom += DCDest->ptlDCOrig.y;
258
259 rcSrc.left = xSrc;
260 rcSrc.top = ySrc;
261 rcSrc.right = rcSrc.left + cxSrc;
262 rcSrc.bottom = rcSrc.top + cySrc;
263 IntLPtoDP(DCSrc, (LPPOINT)&rcSrc, 2);
264
265 rcSrc.left += DCSrc->ptlDCOrig.x;
266 rcSrc.top += DCSrc->ptlDCOrig.y;
267 rcSrc.right += DCSrc->ptlDCOrig.x;
268 rcSrc.bottom += DCSrc->ptlDCOrig.y;
269
270 if (DCDest->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
271 {
272 IntUpdateBoundsRect(DCDest, &rcDest);
273 }
274
275 /* Prepare for blit */
276 DC_vPrepareDCsForBlit(DCDest, &rcDest, DCSrc, &rcSrc);
277
278 BitmapDest = DCDest->dclevel.pSurface;
279 if (!BitmapDest)
280 {
281 goto done;
282 }
283
284 BitmapSrc = DCSrc->dclevel.pSurface;
285 if (!BitmapSrc)
286 {
287 goto done;
288 }
289
290 /* Translate Transparent (RGB) Color to the source palette */
291 EXLATEOBJ_vInitialize(&exlo, &gpalRGB, BitmapSrc->ppal, 0, 0, 0);
292 TransparentColor = XLATEOBJ_iXlate(&exlo.xlo, (ULONG)TransColor);
293 EXLATEOBJ_vCleanup(&exlo);
294
295 EXLATEOBJ_vInitXlateFromDCs(&exlo, DCSrc, DCDest);
296
297 Ret = IntEngTransparentBlt(&BitmapDest->SurfObj, &BitmapSrc->SurfObj,
298 (CLIPOBJ *)&DCDest->co, &exlo.xlo, &rcDest, &rcSrc,
299 TransparentColor, 0);
300
301 EXLATEOBJ_vCleanup(&exlo);
302
303 done:
304 DC_vFinishBlit(DCDest, DCSrc);
305 GDIOBJ_vUnlockObject(&DCDest->BaseObject);
306 GDIOBJ_vUnlockObject(&DCSrc->BaseObject);
307
308 return Ret;
309 }
310
311 BOOL APIENTRY
312 NtGdiMaskBlt(
313 HDC hdcDest,
314 INT nXDest,
315 INT nYDest,
316 INT nWidth,
317 INT nHeight,
318 HDC hdcSrc,
319 INT nXSrc,
320 INT nYSrc,
321 HBITMAP hbmMask,
322 INT xMask,
323 INT yMask,
324 DWORD dwRop4,
325 IN DWORD crBackColor)
326 {
327 PDC DCDest;
328 PDC DCSrc = NULL;
329 HDC ahDC[2];
330 PGDIOBJ apObj[2];
331 PDC_ATTR pdcattr = NULL;
332 SURFACE *BitmapDest, *BitmapSrc = NULL, *psurfMask = NULL;
333 RECTL DestRect, SourceRect;
334 POINTL SourcePoint, MaskPoint;
335 BOOL Status = FALSE;
336 EXLATEOBJ exlo;
337 XLATEOBJ *XlateObj = NULL;
338 BOOL UsesSource;
339 ROP4 rop4;
340
341 rop4 = WIN32_ROP4_TO_ENG_ROP4(dwRop4);
342
343 UsesSource = ROP4_USES_SOURCE(rop4);
344 if (!hdcDest || (UsesSource && !hdcSrc))
345 {
346 EngSetLastError(ERROR_INVALID_PARAMETER);
347 return FALSE;
348 }
349
350 /* Check if we need a mask and have a mask bitmap */
351 if (ROP4_USES_MASK(rop4) && (hbmMask != NULL))
352 {
353 /* Reference the mask bitmap */
354 psurfMask = SURFACE_ShareLockSurface(hbmMask);
355 if (psurfMask == NULL)
356 {
357 EngSetLastError(ERROR_INVALID_HANDLE);
358 return FALSE;
359 }
360
361 /* Make sure the mask bitmap is 1 BPP */
362 if (gajBitsPerFormat[psurfMask->SurfObj.iBitmapFormat] != 1)
363 {
364 EngSetLastError(ERROR_INVALID_PARAMETER);
365 SURFACE_ShareUnlockSurface(psurfMask);
366 return FALSE;
367 }
368 }
369 else
370 {
371 /* We use NULL, if we need a mask, the Eng function will take care of
372 that and use the brushobject to get a mask */
373 psurfMask = NULL;
374 }
375
376 MaskPoint.x = xMask;
377 MaskPoint.y = yMask;
378
379 /* Take care of source and destination bitmap */
380 TRACE("Locking DCs\n");
381 ahDC[0] = hdcDest;
382 ahDC[1] = UsesSource ? hdcSrc : NULL;
383 if (!GDIOBJ_bLockMultipleObjects(2, (HGDIOBJ*)ahDC, apObj, GDIObjType_DC_TYPE))
384 {
385 WARN("Invalid dc handle (dest=0x%p, src=0x%p) passed to NtGdiMaskBlt\n", hdcDest, hdcSrc);
386 EngSetLastError(ERROR_INVALID_HANDLE);
387 return FALSE;
388 }
389 DCDest = apObj[0];
390 DCSrc = apObj[1];
391
392 ASSERT(DCDest);
393 if (NULL == DCDest)
394 {
395 if(DCSrc) DC_UnlockDc(DCSrc);
396 WARN("Invalid destination dc handle (0x%p) passed to NtGdiMaskBlt\n", hdcDest);
397 return FALSE;
398 }
399
400 if (DCDest->dctype == DC_TYPE_INFO)
401 {
402 if(DCSrc) DC_UnlockDc(DCSrc);
403 DC_UnlockDc(DCDest);
404 /* Yes, Windows really returns TRUE in this case */
405 return TRUE;
406 }
407
408 if (UsesSource)
409 {
410 ASSERT(DCSrc);
411 if (DCSrc->dctype == DC_TYPE_INFO)
412 {
413 DC_UnlockDc(DCDest);
414 DC_UnlockDc(DCSrc);
415 /* Yes, Windows really returns TRUE in this case */
416 return TRUE;
417 }
418 }
419
420 pdcattr = DCDest->pdcattr;
421
422 DestRect.left = nXDest;
423 DestRect.top = nYDest;
424 DestRect.right = nXDest + nWidth;
425 DestRect.bottom = nYDest + nHeight;
426 IntLPtoDP(DCDest, (LPPOINT)&DestRect, 2);
427
428 DestRect.left += DCDest->ptlDCOrig.x;
429 DestRect.top += DCDest->ptlDCOrig.y;
430 DestRect.right += DCDest->ptlDCOrig.x;
431 DestRect.bottom += DCDest->ptlDCOrig.y;
432
433 if (DCDest->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
434 {
435 IntUpdateBoundsRect(DCDest, &DestRect);
436 }
437
438 SourcePoint.x = nXSrc;
439 SourcePoint.y = nYSrc;
440
441 if (UsesSource)
442 {
443 IntLPtoDP(DCSrc, (LPPOINT)&SourcePoint, 1);
444
445 SourcePoint.x += DCSrc->ptlDCOrig.x;
446 SourcePoint.y += DCSrc->ptlDCOrig.y;
447 /* Calculate Source Rect */
448 SourceRect.left = SourcePoint.x;
449 SourceRect.top = SourcePoint.y;
450 SourceRect.right = SourcePoint.x + DestRect.right - DestRect.left;
451 SourceRect.bottom = SourcePoint.y + DestRect.bottom - DestRect.top ;
452 }
453 else
454 {
455 SourceRect.left = 0;
456 SourceRect.top = 0;
457 SourceRect.right = 0;
458 SourceRect.bottom = 0;
459 }
460
461 /* Prepare blit */
462 DC_vPrepareDCsForBlit(DCDest, &DestRect, DCSrc, &SourceRect);
463
464 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
465 DC_vUpdateFillBrush(DCDest);
466
467 /* Determine surfaces to be used in the bitblt */
468 BitmapDest = DCDest->dclevel.pSurface;
469 if (!BitmapDest)
470 goto cleanup;
471
472 if (UsesSource)
473 {
474 {
475 BitmapSrc = DCSrc->dclevel.pSurface;
476 if (!BitmapSrc)
477 goto cleanup;
478 }
479 }
480
481 /* Create the XLATEOBJ. */
482 if (UsesSource)
483 {
484 EXLATEOBJ_vInitXlateFromDCs(&exlo, DCSrc, DCDest);
485 XlateObj = &exlo.xlo;
486 }
487
488 /* Perform the bitblt operation */
489 Status = IntEngBitBlt(&BitmapDest->SurfObj,
490 BitmapSrc ? &BitmapSrc->SurfObj : NULL,
491 psurfMask ? &psurfMask->SurfObj : NULL,
492 (CLIPOBJ *)&DCDest->co,
493 XlateObj,
494 &DestRect,
495 &SourcePoint,
496 &MaskPoint,
497 &DCDest->eboFill.BrushObject,
498 &DCDest->dclevel.pbrFill->ptOrigin,
499 rop4);
500
501 if (UsesSource)
502 EXLATEOBJ_vCleanup(&exlo);
503 cleanup:
504 DC_vFinishBlit(DCDest, DCSrc);
505 if (UsesSource)
506 {
507 DC_UnlockDc(DCSrc);
508 }
509 DC_UnlockDc(DCDest);
510 if(psurfMask) SURFACE_ShareUnlockSurface(psurfMask);
511
512 return Status;
513 }
514
515 BOOL
516 APIENTRY
517 NtGdiPlgBlt(
518 IN HDC hdcTrg,
519 IN LPPOINT pptlTrg,
520 IN HDC hdcSrc,
521 IN INT xSrc,
522 IN INT ySrc,
523 IN INT cxSrc,
524 IN INT cySrc,
525 IN HBITMAP hbmMask,
526 IN INT xMask,
527 IN INT yMask,
528 IN DWORD crBackColor)
529 {
530 FIXME("NtGdiPlgBlt: unimplemented.\n");
531 return FALSE;
532 }
533
534 BOOL
535 NTAPI
536 GreStretchBltMask(
537 HDC hDCDest,
538 INT XOriginDest,
539 INT YOriginDest,
540 INT WidthDest,
541 INT HeightDest,
542 HDC hDCSrc,
543 INT XOriginSrc,
544 INT YOriginSrc,
545 INT WidthSrc,
546 INT HeightSrc,
547 DWORD dwRop4,
548 IN DWORD dwBackColor,
549 HDC hDCMask,
550 INT XOriginMask,
551 INT YOriginMask)
552 {
553 PDC DCDest;
554 PDC DCSrc = NULL;
555 PDC DCMask = NULL;
556 HDC ahDC[3];
557 PGDIOBJ apObj[3];
558 PDC_ATTR pdcattr;
559 SURFACE *BitmapDest, *BitmapSrc = NULL;
560 SURFACE *BitmapMask = NULL;
561 RECTL DestRect;
562 RECTL SourceRect;
563 POINTL MaskPoint;
564 BOOL Status = FALSE;
565 EXLATEOBJ exlo;
566 XLATEOBJ *XlateObj = NULL;
567 POINTL BrushOrigin;
568 BOOL UsesSource;
569 BOOL UsesMask;
570 ROP4 rop4;
571
572 rop4 = WIN32_ROP4_TO_ENG_ROP4(dwRop4);
573
574 UsesSource = ROP4_USES_SOURCE(rop4);
575 UsesMask = ROP4_USES_MASK(rop4);
576
577 if (0 == WidthDest || 0 == HeightDest || 0 == WidthSrc || 0 == HeightSrc)
578 {
579 EngSetLastError(ERROR_INVALID_PARAMETER);
580 return TRUE;
581 }
582
583 if (!hDCDest || (UsesSource && !hDCSrc) || (UsesMask && !hDCMask))
584 {
585 EngSetLastError(ERROR_INVALID_PARAMETER);
586 return FALSE;
587 }
588
589 ahDC[0] = hDCDest;
590 ahDC[1] = UsesSource ? hDCSrc : NULL;
591 ahDC[2] = UsesMask ? hDCMask : NULL;
592 if (!GDIOBJ_bLockMultipleObjects(3, (HGDIOBJ*)ahDC, apObj, GDIObjType_DC_TYPE))
593 {
594 WARN("Invalid dc handle (dest=0x%p, src=0x%p) passed to GreStretchBltMask\n", hDCDest, hDCSrc);
595 EngSetLastError(ERROR_INVALID_HANDLE);
596 return FALSE;
597 }
598 DCDest = apObj[0];
599 DCSrc = apObj[1];
600 DCMask = apObj[2];
601
602 if (DCDest->dctype == DC_TYPE_INFO)
603 {
604 if(DCSrc) GDIOBJ_vUnlockObject(&DCSrc->BaseObject);
605 if(DCMask) GDIOBJ_vUnlockObject(&DCMask->BaseObject);
606 GDIOBJ_vUnlockObject(&DCDest->BaseObject);
607 /* Yes, Windows really returns TRUE in this case */
608 return TRUE;
609 }
610
611 if (UsesSource)
612 {
613 if (DCSrc->dctype == DC_TYPE_INFO)
614 {
615 GDIOBJ_vUnlockObject(&DCDest->BaseObject);
616 GDIOBJ_vUnlockObject(&DCSrc->BaseObject);
617 if(DCMask) GDIOBJ_vUnlockObject(&DCMask->BaseObject);
618 /* Yes, Windows really returns TRUE in this case */
619 return TRUE;
620 }
621 }
622
623 pdcattr = DCDest->pdcattr;
624
625 DestRect.left = XOriginDest;
626 DestRect.top = YOriginDest;
627 DestRect.right = XOriginDest+WidthDest;
628 DestRect.bottom = YOriginDest+HeightDest;
629 IntLPtoDP(DCDest, (LPPOINT)&DestRect, 2);
630
631 DestRect.left += DCDest->ptlDCOrig.x;
632 DestRect.top += DCDest->ptlDCOrig.y;
633 DestRect.right += DCDest->ptlDCOrig.x;
634 DestRect.bottom += DCDest->ptlDCOrig.y;
635
636 if (DCDest->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
637 {
638 IntUpdateBoundsRect(DCDest, &DestRect);
639 }
640
641 SourceRect.left = XOriginSrc;
642 SourceRect.top = YOriginSrc;
643 SourceRect.right = XOriginSrc+WidthSrc;
644 SourceRect.bottom = YOriginSrc+HeightSrc;
645
646 if (UsesSource)
647 {
648 IntLPtoDP(DCSrc, (LPPOINT)&SourceRect, 2);
649
650 SourceRect.left += DCSrc->ptlDCOrig.x;
651 SourceRect.top += DCSrc->ptlDCOrig.y;
652 SourceRect.right += DCSrc->ptlDCOrig.x;
653 SourceRect.bottom += DCSrc->ptlDCOrig.y;
654 }
655
656 BrushOrigin.x = 0;
657 BrushOrigin.y = 0;
658
659 /* Only prepare Source and Dest, hdcMask represents a DIB */
660 DC_vPrepareDCsForBlit(DCDest, &DestRect, DCSrc, &SourceRect);
661
662 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
663 DC_vUpdateFillBrush(DCDest);
664
665 /* Determine surfaces to be used in the bitblt */
666 BitmapDest = DCDest->dclevel.pSurface;
667 if (BitmapDest == NULL)
668 goto failed;
669 if (UsesSource)
670 {
671 BitmapSrc = DCSrc->dclevel.pSurface;
672 if (BitmapSrc == NULL)
673 goto failed;
674
675 /* Create the XLATEOBJ. */
676 EXLATEOBJ_vInitXlateFromDCs(&exlo, DCSrc, DCDest);
677 XlateObj = &exlo.xlo;
678 }
679
680 /* Offset the brush */
681 BrushOrigin.x += DCDest->ptlDCOrig.x;
682 BrushOrigin.y += DCDest->ptlDCOrig.y;
683
684 /* Make mask surface for source surface */
685 if (BitmapSrc && DCMask)
686 {
687 BitmapMask = DCMask->dclevel.pSurface;
688 if (BitmapMask &&
689 (BitmapMask->SurfObj.sizlBitmap.cx < WidthSrc ||
690 BitmapMask->SurfObj.sizlBitmap.cy < HeightSrc))
691 {
692 WARN("%dx%d mask is smaller than %dx%d bitmap\n",
693 BitmapMask->SurfObj.sizlBitmap.cx, BitmapMask->SurfObj.sizlBitmap.cy,
694 WidthSrc, HeightSrc);
695 EXLATEOBJ_vCleanup(&exlo);
696 goto failed;
697 }
698 /* Create mask offset point */
699 MaskPoint.x = XOriginMask;
700 MaskPoint.y = YOriginMask;
701 IntLPtoDP(DCMask, &MaskPoint, 1);
702 MaskPoint.x += DCMask->ptlDCOrig.x;
703 MaskPoint.y += DCMask->ptlDCOrig.y;
704 }
705
706 /* Perform the bitblt operation */
707 Status = IntEngStretchBlt(&BitmapDest->SurfObj,
708 BitmapSrc ? &BitmapSrc->SurfObj : NULL,
709 BitmapMask ? &BitmapMask->SurfObj : NULL,
710 (CLIPOBJ *)&DCDest->co,
711 XlateObj,
712 &DCDest->dclevel.ca,
713 &DestRect,
714 &SourceRect,
715 BitmapMask ? &MaskPoint : NULL,
716 &DCDest->eboFill.BrushObject,
717 &BrushOrigin,
718 rop4);
719 if (UsesSource)
720 {
721 EXLATEOBJ_vCleanup(&exlo);
722 }
723
724 failed:
725 DC_vFinishBlit(DCDest, DCSrc);
726 if (UsesSource)
727 {
728 DC_UnlockDc(DCSrc);
729 }
730 if (DCMask)
731 {
732 DC_UnlockDc(DCMask);
733 }
734 DC_UnlockDc(DCDest);
735
736 return Status;
737 }
738
739
740 BOOL APIENTRY
741 NtGdiStretchBlt(
742 HDC hDCDest,
743 INT XOriginDest,
744 INT YOriginDest,
745 INT WidthDest,
746 INT HeightDest,
747 HDC hDCSrc,
748 INT XOriginSrc,
749 INT YOriginSrc,
750 INT WidthSrc,
751 INT HeightSrc,
752 DWORD dwRop3,
753 IN DWORD dwBackColor)
754 {
755 dwRop3 = dwRop3 & ~(NOMIRRORBITMAP|CAPTUREBLT);
756
757 return GreStretchBltMask(
758 hDCDest,
759 XOriginDest,
760 YOriginDest,
761 WidthDest,
762 HeightDest,
763 hDCSrc,
764 XOriginSrc,
765 YOriginSrc,
766 WidthSrc,
767 HeightSrc,
768 MAKEROP4(dwRop3 & 0xFF0000, dwRop3),
769 dwBackColor,
770 NULL,
771 0,
772 0);
773 }
774
775
776 BOOL FASTCALL
777 IntPatBlt(
778 PDC pdc,
779 INT XLeft,
780 INT YLeft,
781 INT Width,
782 INT Height,
783 DWORD dwRop3,
784 PEBRUSHOBJ pebo)
785 {
786 RECTL DestRect;
787 SURFACE *psurf;
788 POINTL BrushOrigin;
789 BOOL ret;
790 PBRUSH pbrush;
791
792 ASSERT(pebo);
793 pbrush = pebo->pbrush;
794 ASSERT(pbrush);
795
796 if (pbrush->flAttrs & BR_IS_NULL)
797 {
798 return TRUE;
799 }
800
801 if (Width > 0)
802 {
803 DestRect.left = XLeft;
804 DestRect.right = XLeft + Width;
805 }
806 else
807 {
808 DestRect.left = XLeft + Width + 1;
809 DestRect.right = XLeft + 1;
810 }
811
812 if (Height > 0)
813 {
814 DestRect.top = YLeft;
815 DestRect.bottom = YLeft + Height;
816 }
817 else
818 {
819 DestRect.top = YLeft + Height + 1;
820 DestRect.bottom = YLeft + 1;
821 }
822
823 IntLPtoDP(pdc, (LPPOINT)&DestRect, 2);
824
825 DestRect.left += pdc->ptlDCOrig.x;
826 DestRect.top += pdc->ptlDCOrig.y;
827 DestRect.right += pdc->ptlDCOrig.x;
828 DestRect.bottom += pdc->ptlDCOrig.y;
829
830 if (pdc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
831 {
832 IntUpdateBoundsRect(pdc, &DestRect);
833 }
834
835 #ifdef _USE_DIBLIB_
836 BrushOrigin.x = pbrush->ptOrigin.x + pdc->ptlDCOrig.x + XLeft;
837 BrushOrigin.y = pbrush->ptOrigin.y + pdc->ptlDCOrig.y + YLeft;
838 #else
839 BrushOrigin.x = pbrush->ptOrigin.x + pdc->ptlDCOrig.x;
840 BrushOrigin.y = pbrush->ptOrigin.y + pdc->ptlDCOrig.y;
841 #endif
842
843 DC_vPrepareDCsForBlit(pdc, &DestRect, NULL, NULL);
844
845 psurf = pdc->dclevel.pSurface;
846
847 ret = IntEngBitBlt(&psurf->SurfObj,
848 NULL,
849 NULL,
850 (CLIPOBJ *)&pdc->co,
851 NULL,
852 &DestRect,
853 NULL,
854 NULL,
855 &pebo->BrushObject,
856 &BrushOrigin,
857 WIN32_ROP3_TO_ENG_ROP4(dwRop3));
858
859 DC_vFinishBlit(pdc, NULL);
860
861 return ret;
862 }
863
864 BOOL FASTCALL
865 IntGdiPolyPatBlt(
866 HDC hDC,
867 DWORD dwRop,
868 PPATRECT pRects,
869 INT cRects,
870 ULONG Reserved)
871 {
872 INT i;
873 PBRUSH pbrush;
874 PDC pdc;
875 EBRUSHOBJ eboFill;
876
877 pdc = DC_LockDc(hDC);
878 if (!pdc)
879 {
880 EngSetLastError(ERROR_INVALID_HANDLE);
881 return FALSE;
882 }
883
884 if (pdc->dctype == DC_TYPE_INFO)
885 {
886 DC_UnlockDc(pdc);
887 /* Yes, Windows really returns TRUE in this case */
888 return TRUE;
889 }
890
891 for (i = 0; i < cRects; i++)
892 {
893 pbrush = BRUSH_ShareLockBrush(pRects->hBrush);
894
895 /* Check if we could lock the brush */
896 if (pbrush != NULL)
897 {
898 /* Initialize a brush object */
899 EBRUSHOBJ_vInitFromDC(&eboFill, pbrush, pdc);
900
901 IntPatBlt(
902 pdc,
903 pRects->r.left,
904 pRects->r.top,
905 pRects->r.right,
906 pRects->r.bottom,
907 dwRop,
908 &eboFill);
909
910 /* Cleanup the brush object and unlock the brush */
911 EBRUSHOBJ_vCleanup(&eboFill);
912 BRUSH_ShareUnlockBrush(pbrush);
913 }
914 pRects++;
915 }
916
917 DC_UnlockDc(pdc);
918
919 return TRUE;
920 }
921
922 BOOL
923 APIENTRY
924 NtGdiPatBlt(
925 _In_ HDC hdcDest,
926 _In_ INT x,
927 _In_ INT y,
928 _In_ INT cx,
929 _In_ INT cy,
930 _In_ DWORD dwRop)
931 {
932 BOOL bResult;
933 PDC pdc;
934
935 /* Convert the ROP3 to a ROP4 */
936 dwRop = MAKEROP4(dwRop & 0xFF0000, dwRop);
937
938 /* Check if the rop uses a source */
939 if (WIN32_ROP4_USES_SOURCE(dwRop))
940 {
941 /* This is not possible */
942 return FALSE;
943 }
944
945 /* Lock the DC */
946 pdc = DC_LockDc(hdcDest);
947 if (pdc == NULL)
948 {
949 EngSetLastError(ERROR_INVALID_HANDLE);
950 return FALSE;
951 }
952
953 /* Check if the DC has no surface (empty mem or info DC) */
954 if (pdc->dclevel.pSurface == NULL)
955 {
956 /* Nothing to do, Windows returns TRUE! */
957 DC_UnlockDc(pdc);
958 return TRUE;
959 }
960
961 /* Update the fill brush, if necessary */
962 if (pdc->pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
963 DC_vUpdateFillBrush(pdc);
964
965 /* Call the internal function */
966 bResult = IntPatBlt(pdc, x, y, cx, cy, dwRop, &pdc->eboFill);
967
968 /* Unlock the DC and return the result */
969 DC_UnlockDc(pdc);
970 return bResult;
971 }
972
973 BOOL
974 APIENTRY
975 NtGdiPolyPatBlt(
976 HDC hDC,
977 DWORD dwRop,
978 IN PPOLYPATBLT pRects,
979 IN DWORD cRects,
980 IN DWORD Mode)
981 {
982 PPATRECT rb = NULL;
983 NTSTATUS Status = STATUS_SUCCESS;
984 BOOL Ret;
985
986 if (cRects > 0)
987 {
988 rb = ExAllocatePoolWithTag(PagedPool, sizeof(PATRECT) * cRects, GDITAG_PLGBLT_DATA);
989 if (!rb)
990 {
991 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
992 return FALSE;
993 }
994 _SEH2_TRY
995 {
996 ProbeForRead(pRects,
997 cRects * sizeof(PATRECT),
998 1);
999 RtlCopyMemory(rb,
1000 pRects,
1001 cRects * sizeof(PATRECT));
1002 }
1003 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1004 {
1005 Status = _SEH2_GetExceptionCode();
1006 }
1007 _SEH2_END;
1008
1009 if (!NT_SUCCESS(Status))
1010 {
1011 ExFreePoolWithTag(rb, GDITAG_PLGBLT_DATA);
1012 SetLastNtError(Status);
1013 return FALSE;
1014 }
1015 }
1016
1017 Ret = IntGdiPolyPatBlt(hDC, dwRop, rb, cRects, Mode);
1018
1019 if (cRects > 0)
1020 ExFreePoolWithTag(rb, GDITAG_PLGBLT_DATA);
1021
1022 return Ret;
1023 }
1024
1025 static
1026 BOOL
1027 FASTCALL
1028 REGION_LPTODP(
1029 _In_ PDC pdc,
1030 _Inout_ PREGION prgnDest,
1031 _In_ PREGION prgnSrc)
1032 {
1033 if (IntGdiCombineRgn(prgnDest, prgnSrc, NULL, RGN_COPY) == ERROR)
1034 return FALSE;
1035
1036 return REGION_bXformRgn(prgnDest, DC_pmxWorldToDevice(pdc));
1037 }
1038
1039 BOOL
1040 APIENTRY
1041 IntGdiBitBltRgn(
1042 _In_ PDC pdc,
1043 _In_ PREGION prgn,
1044 _In_opt_ BRUSHOBJ *pbo,
1045 _In_opt_ POINTL *pptlBrush,
1046 _In_ ROP4 rop4)
1047 {
1048 PREGION prgnClip;
1049 XCLIPOBJ xcoClip;
1050 BOOL bResult;
1051 NT_ASSERT((pdc != NULL) && (prgn != NULL));
1052
1053 /* Check if we have a surface */
1054 if (pdc->dclevel.pSurface == NULL)
1055 {
1056 return TRUE;
1057 }
1058
1059 /* Create an empty clip region */
1060 prgnClip = IntSysCreateRectpRgn(0, 0, 0, 0);
1061 if (prgnClip == NULL)
1062 {
1063 return FALSE;
1064 }
1065
1066 /* Transform given region into device coordinates */
1067 if (!REGION_LPTODP(pdc, prgnClip, prgn))
1068 {
1069 REGION_Delete(prgnClip);
1070 return FALSE;
1071 }
1072
1073 /* Intersect with the system or RAO region (these are (atm) without DC-origin) */
1074 if (pdc->prgnRao)
1075 IntGdiCombineRgn(prgnClip, prgnClip, pdc->prgnRao, RGN_AND);
1076 else
1077 IntGdiCombineRgn(prgnClip, prgnClip, pdc->prgnVis, RGN_AND);
1078
1079 /* Now account for the DC-origin */
1080 if (!REGION_bOffsetRgn(prgnClip, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y))
1081 {
1082 REGION_Delete(prgnClip);
1083 return FALSE;
1084 }
1085
1086 if (pdc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
1087 {
1088 RECTL rcrgn;
1089 REGION_GetRgnBox(prgnClip, &rcrgn);
1090 IntUpdateBoundsRect(pdc, &rcrgn);
1091 }
1092
1093 /* Prepare the DC */
1094 DC_vPrepareDCsForBlit(pdc, &prgnClip->rdh.rcBound, NULL, NULL);
1095
1096 /* Initialize a clip object */
1097 IntEngInitClipObj(&xcoClip);
1098 IntEngUpdateClipRegion(&xcoClip,
1099 prgnClip->rdh.nCount,
1100 prgnClip->Buffer,
1101 &prgnClip->rdh.rcBound);
1102
1103 /* Call the Eng or Drv function */
1104 bResult = IntEngBitBlt(&pdc->dclevel.pSurface->SurfObj,
1105 NULL,
1106 NULL,
1107 (CLIPOBJ *)&xcoClip,
1108 NULL,
1109 &prgnClip->rdh.rcBound,
1110 NULL,
1111 NULL,
1112 pbo,
1113 pptlBrush,
1114 rop4);
1115
1116 /* Cleanup */
1117 DC_vFinishBlit(pdc, NULL);
1118 REGION_Delete(prgnClip);
1119 IntEngFreeClipResources(&xcoClip);
1120
1121 /* Return the result */
1122 return bResult;
1123 }
1124
1125 BOOL
1126 IntGdiFillRgn(
1127 _In_ PDC pdc,
1128 _In_ PREGION prgn,
1129 _In_opt_ PBRUSH pbrFill)
1130 {
1131 PREGION prgnClip;
1132 XCLIPOBJ xcoClip;
1133 EBRUSHOBJ eboFill;
1134 BRUSHOBJ *pbo;
1135 BOOL bRet;
1136 DWORD rop2Fg;
1137 MIX mix;
1138 NT_ASSERT((pdc != NULL) && (prgn != NULL));
1139
1140 if (pdc->dclevel.pSurface == NULL)
1141 {
1142 return TRUE;
1143 }
1144
1145 prgnClip = IntSysCreateRectpRgn(0, 0, 0, 0);
1146 if (prgnClip == NULL)
1147 {
1148 return FALSE;
1149 }
1150
1151 /* Transform region into device coordinates */
1152 if (!REGION_LPTODP(pdc, prgnClip, prgn))
1153 {
1154 REGION_Delete(prgnClip);
1155 return FALSE;
1156 }
1157
1158 /* Intersect with the system or RAO region (these are (atm) without DC-origin) */
1159 if (pdc->prgnRao)
1160 IntGdiCombineRgn(prgnClip, prgnClip, pdc->prgnRao, RGN_AND);
1161 else
1162 IntGdiCombineRgn(prgnClip, prgnClip, pdc->prgnVis, RGN_AND);
1163
1164 /* Now account for the DC-origin */
1165 if (!REGION_bOffsetRgn(prgnClip, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y))
1166 {
1167 REGION_Delete(prgnClip);
1168 return FALSE;
1169 }
1170
1171 if (pdc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
1172 {
1173 RECTL rcrgn;
1174 REGION_GetRgnBox(prgnClip, &rcrgn);
1175 IntUpdateBoundsRect(pdc, &rcrgn);
1176 }
1177
1178 IntEngInitClipObj(&xcoClip);
1179 IntEngUpdateClipRegion(&xcoClip,
1180 prgnClip->rdh.nCount,
1181 prgnClip->Buffer,
1182 &prgnClip->rdh.rcBound );
1183
1184 /* Get the FG rop and create a MIX based on the BK mode */
1185 rop2Fg = FIXUP_ROP2(pdc->pdcattr->jROP2);
1186 mix = rop2Fg | (pdc->pdcattr->jBkMode == OPAQUE ? rop2Fg : R2_NOP) << 8;
1187
1188 /* Prepare DC for blit */
1189 DC_vPrepareDCsForBlit(pdc, &prgnClip->rdh.rcBound, NULL, NULL);
1190
1191 /* Check if we have a fill brush */
1192 if (pbrFill != NULL)
1193 {
1194 /* Initialize the brush object */
1195 /// \todo Check parameters
1196 EBRUSHOBJ_vInit(&eboFill, pbrFill, pdc->dclevel.pSurface, 0x00FFFFFF, 0, NULL);
1197 pbo = &eboFill.BrushObject;
1198 }
1199 else
1200 {
1201 /* Update the fill brush if needed */
1202 if (pdc->pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
1203 DC_vUpdateFillBrush(pdc);
1204
1205 /* Use the DC brush object */
1206 pbo = &pdc->eboFill.BrushObject;
1207 }
1208
1209 /* Call the internal function */
1210 bRet = IntEngPaint(&pdc->dclevel.pSurface->SurfObj,
1211 (CLIPOBJ *)&xcoClip,
1212 pbo,
1213 &pdc->pdcattr->ptlBrushOrigin,
1214 mix);
1215
1216 DC_vFinishBlit(pdc, NULL);
1217 REGION_Delete(prgnClip);
1218 IntEngFreeClipResources(&xcoClip);
1219
1220 // Fill the region
1221 return bRet;
1222 }
1223
1224 BOOL
1225 FASTCALL
1226 IntGdiPaintRgn(
1227 _In_ PDC pdc,
1228 _In_ PREGION prgn)
1229 {
1230 return IntGdiFillRgn(pdc, prgn, NULL);
1231 }
1232
1233 BOOL
1234 APIENTRY
1235 NtGdiFillRgn(
1236 _In_ HDC hdc,
1237 _In_ HRGN hrgn,
1238 _In_ HBRUSH hbrush)
1239 {
1240 PDC pdc;
1241 PREGION prgn;
1242 PBRUSH pbrFill;
1243 BOOL bResult;
1244
1245 /* Lock the DC */
1246 pdc = DC_LockDc(hdc);
1247 if (pdc == NULL)
1248 {
1249 ERR("Failed to lock hdc %p\n", hdc);
1250 return FALSE;
1251 }
1252
1253 /* Check if the DC has no surface (empty mem or info DC) */
1254 if (pdc->dclevel.pSurface == NULL)
1255 {
1256 DC_UnlockDc(pdc);
1257 return TRUE;
1258 }
1259
1260 /* Lock the region */
1261 prgn = REGION_LockRgn(hrgn);
1262 if (prgn == NULL)
1263 {
1264 ERR("Failed to lock hrgn %p\n", hrgn);
1265 DC_UnlockDc(pdc);
1266 return FALSE;
1267 }
1268
1269 /* Lock the brush */
1270 pbrFill = BRUSH_ShareLockBrush(hbrush);
1271 if (pbrFill == NULL)
1272 {
1273 ERR("Failed to lock hbrush %p\n", hbrush);
1274 REGION_UnlockRgn(prgn);
1275 DC_UnlockDc(pdc);
1276 return FALSE;
1277 }
1278
1279 /* Call the internal function */
1280 bResult = IntGdiFillRgn(pdc, prgn, pbrFill);
1281
1282 /* Cleanup locks */
1283 BRUSH_ShareUnlockBrush(pbrFill);
1284 REGION_UnlockRgn(prgn);
1285 DC_UnlockDc(pdc);
1286
1287 return bResult;
1288 }
1289
1290 BOOL
1291 APIENTRY
1292 NtGdiFrameRgn(
1293 _In_ HDC hdc,
1294 _In_ HRGN hrgn,
1295 _In_ HBRUSH hbrush,
1296 _In_ INT xWidth,
1297 _In_ INT yHeight)
1298 {
1299 HRGN hrgnFrame;
1300 BOOL bResult;
1301
1302 hrgnFrame = GreCreateFrameRgn(hrgn, xWidth, yHeight);
1303 if (hrgnFrame == NULL)
1304 {
1305 return FALSE;
1306 }
1307
1308 bResult = NtGdiFillRgn(hdc, hrgnFrame, hbrush);
1309
1310 GreDeleteObject(hrgnFrame);
1311 return bResult;
1312 }
1313
1314 BOOL
1315 APIENTRY
1316 NtGdiInvertRgn(
1317 _In_ HDC hdc,
1318 _In_ HRGN hrgn)
1319 {
1320 BOOL bResult;
1321 PDC pdc;
1322 PREGION prgn;
1323
1324 /* Lock the DC */
1325 pdc = DC_LockDc(hdc);
1326 if (pdc == NULL)
1327 {
1328 EngSetLastError(ERROR_INVALID_HANDLE);
1329 return FALSE;
1330 }
1331
1332 /* Check if the DC has no surface (empty mem or info DC) */
1333 if (pdc->dclevel.pSurface == NULL)
1334 {
1335 /* Nothing to do, Windows returns TRUE! */
1336 DC_UnlockDc(pdc);
1337 return TRUE;
1338 }
1339
1340 /* Lock the region */
1341 prgn = REGION_LockRgn(hrgn);
1342 if (prgn == NULL)
1343 {
1344 DC_UnlockDc(pdc);
1345 return FALSE;
1346 }
1347
1348 /* Call the internal function */
1349 bResult = IntGdiBitBltRgn(pdc,
1350 prgn,
1351 NULL, // pbo
1352 NULL, // pptlBrush,
1353 ROP4_DSTINVERT);
1354
1355 /* Unlock the region and DC and return the result */
1356 REGION_UnlockRgn(prgn);
1357 DC_UnlockDc(pdc);
1358 return bResult;
1359 }
1360
1361 COLORREF
1362 APIENTRY
1363 NtGdiSetPixel(
1364 _In_ HDC hdc,
1365 _In_ INT x,
1366 _In_ INT y,
1367 _In_ COLORREF crColor)
1368 {
1369 PDC pdc;
1370 ULONG iOldColor, iSolidColor;
1371 BOOL bResult;
1372 PEBRUSHOBJ pebo;
1373 ULONG ulDirty;
1374 EXLATEOBJ exlo;
1375
1376 /* Lock the DC */
1377 pdc = DC_LockDc(hdc);
1378 if (!pdc)
1379 {
1380 EngSetLastError(ERROR_INVALID_HANDLE);
1381 return -1;
1382 }
1383
1384 /* Check if the DC has no surface (empty mem or info DC) */
1385 if (pdc->dclevel.pSurface == NULL)
1386 {
1387 /* Fail! */
1388 DC_UnlockDc(pdc);
1389 return -1;
1390 }
1391
1392 if (pdc->fs & (DC_ACCUM_APP|DC_ACCUM_WMGR))
1393 {
1394 RECTL rcDst;
1395
1396 RECTL_vSetRect(&rcDst, x, y, x+1, y+1);
1397
1398 IntLPtoDP(pdc, (LPPOINT)&rcDst, 2);
1399
1400 rcDst.left += pdc->ptlDCOrig.x;
1401 rcDst.top += pdc->ptlDCOrig.y;
1402 rcDst.right += pdc->ptlDCOrig.x;
1403 rcDst.bottom += pdc->ptlDCOrig.y;
1404
1405 IntUpdateBoundsRect(pdc, &rcDst);
1406 }
1407
1408 /* Translate the color to the target format */
1409 iSolidColor = TranslateCOLORREF(pdc, crColor);
1410
1411 /* Use the DC's text brush, which is always a solid brush */
1412 pebo = &pdc->eboText;
1413
1414 /* Save the old solid color and set the one for the pixel */
1415 iOldColor = EBRUSHOBJ_iSetSolidColor(pebo, iSolidColor);
1416
1417 /* Save dirty flags and reset dirty text brush flag */
1418 ulDirty = pdc->pdcattr->ulDirty_;
1419 pdc->pdcattr->ulDirty_ &= ~DIRTY_TEXT;
1420
1421 /* Call the internal function */
1422 bResult = IntPatBlt(pdc, x, y, 1, 1, PATCOPY, pebo);
1423
1424 /* Restore old text brush color and dirty flags */
1425 EBRUSHOBJ_iSetSolidColor(pebo, iOldColor);
1426 pdc->pdcattr->ulDirty_ = ulDirty;
1427
1428 /// FIXME: we shouldn't dereference pSurface while the PDEV is not locked!
1429 /* Initialize an XLATEOBJ from the target surface to RGB */
1430 EXLATEOBJ_vInitialize(&exlo,
1431 pdc->dclevel.pSurface->ppal,
1432 &gpalRGB,
1433 0,
1434 pdc->pdcattr->crBackgroundClr,
1435 pdc->pdcattr->crForegroundClr);
1436
1437 /* Translate the color back to RGB */
1438 crColor = XLATEOBJ_iXlate(&exlo.xlo, iSolidColor);
1439
1440 /* Cleanup and return the target format color */
1441 EXLATEOBJ_vCleanup(&exlo);
1442
1443 /* Unlock the DC */
1444 DC_UnlockDc(pdc);
1445
1446 /* Return the new RGB color or -1 on failure */
1447 return bResult ? crColor : -1;
1448 }
1449
1450 COLORREF
1451 APIENTRY
1452 NtGdiGetPixel(
1453 _In_ HDC hdc,
1454 _In_ INT x,
1455 _In_ INT y)
1456 {
1457 PDC pdc;
1458 ULONG ulRGBColor = CLR_INVALID;
1459 POINTL ptlSrc;
1460 RECT rcDest;
1461 PSURFACE psurfSrc, psurfDest;
1462
1463 /* Lock the DC */
1464 pdc = DC_LockDc(hdc);
1465 if (!pdc)
1466 {
1467 EngSetLastError(ERROR_INVALID_HANDLE);
1468 return CLR_INVALID;
1469 }
1470
1471 /* Check if the DC has no surface (empty mem or info DC) */
1472 if (pdc->dclevel.pSurface == NULL)
1473 {
1474 /* Fail! */
1475 goto leave;
1476 }
1477
1478 /* Get the logical coordinates */
1479 ptlSrc.x = x;
1480 ptlSrc.y = y;
1481
1482 /* Translate coordinates to device coordinates */
1483 IntLPtoDP(pdc, &ptlSrc, 1);
1484 ptlSrc.x += pdc->ptlDCOrig.x;
1485 ptlSrc.y += pdc->ptlDCOrig.y;
1486
1487 rcDest.left = x;
1488 rcDest.top = y;
1489 rcDest.right = x + 1;
1490 rcDest.bottom = y + 1;
1491
1492 /* Prepare DC for blit */
1493 DC_vPrepareDCsForBlit(pdc, &rcDest, NULL, NULL);
1494
1495 /* Check if the pixel is outside the surface */
1496 psurfSrc = pdc->dclevel.pSurface;
1497 if ((ptlSrc.x >= psurfSrc->SurfObj.sizlBitmap.cx) ||
1498 (ptlSrc.y >= psurfSrc->SurfObj.sizlBitmap.cy) ||
1499 (ptlSrc.x < 0) ||
1500 (ptlSrc.y < 0))
1501 {
1502 /* Fail! */
1503 goto leave;
1504 }
1505
1506 /* Allocate a surface */
1507 psurfDest = SURFACE_AllocSurface(STYPE_BITMAP,
1508 1,
1509 1,
1510 BMF_32BPP,
1511 0,
1512 0,
1513 0,
1514 &ulRGBColor);
1515 if (psurfDest)
1516 {
1517 RECTL rclDest = {0, 0, 1, 1};
1518 EXLATEOBJ exlo;
1519
1520 /* Translate from the source palette to RGB color */
1521 EXLATEOBJ_vInitialize(&exlo,
1522 psurfSrc->ppal,
1523 &gpalRGB,
1524 0,
1525 RGB(0xff,0xff,0xff),
1526 RGB(0,0,0));
1527
1528 /* Call the copy bits function */
1529 EngCopyBits(&psurfDest->SurfObj,
1530 &psurfSrc->SurfObj,
1531 NULL,
1532 &exlo.xlo,
1533 &rclDest,
1534 &ptlSrc);
1535
1536 /* Cleanup the XLATEOBJ */
1537 EXLATEOBJ_vCleanup(&exlo);
1538
1539 /* Delete the surface */
1540 GDIOBJ_vDeleteObject(&psurfDest->BaseObject);
1541 }
1542
1543 leave:
1544
1545 /* Unlock the DC */
1546 DC_vFinishBlit(pdc, NULL);
1547 DC_UnlockDc(pdc);
1548
1549 /* Return the new RGB color or -1 on failure */
1550 return ulRGBColor;
1551 }
1552