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 1553