diff --git a/reactos/subsystems/win32/win32k/eng/bitblt.c b/reactos/subsystems/win32/win32k/eng/bitblt.c index 4592cc71564..efdf51d4bc1 100644 --- a/reactos/subsystems/win32/win32k/eng/bitblt.c +++ b/reactos/subsystems/win32/win32k/eng/bitblt.c @@ -55,133 +55,133 @@ typedef BOOLEAN (STDCALL *PSTRETCHRECTFUNC)(SURFOBJ* OutputObj, BOOL STDCALL EngIntersectRect(RECTL* prcDst, RECTL* prcSrc1, RECTL* prcSrc2) { - static const RECTL rclEmpty = { 0, 0, 0, 0 }; + static const RECTL rclEmpty = { 0, 0, 0, 0 }; - prcDst->left = max(prcSrc1->left, prcSrc2->left); - prcDst->right = min(prcSrc1->right, prcSrc2->right); + prcDst->left = max(prcSrc1->left, prcSrc2->left); + prcDst->right = min(prcSrc1->right, prcSrc2->right); - if (prcDst->left < prcDst->right) + if (prcDst->left < prcDst->right) { - prcDst->top = max(prcSrc1->top, prcSrc2->top); - prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom); + prcDst->top = max(prcSrc1->top, prcSrc2->top); + prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom); - if (prcDst->top < prcDst->bottom) - { - return TRUE; - } + if (prcDst->top < prcDst->bottom) + { + return TRUE; + } } - *prcDst = rclEmpty; + *prcDst = rclEmpty; - return FALSE; + return FALSE; } static BOOLEAN STDCALL BltMask(SURFOBJ* Dest, - SURFOBJ* Source, - SURFOBJ* Mask, - XLATEOBJ* ColorTranslation, - RECTL* DestRect, - POINTL* SourcePoint, - POINTL* MaskPoint, - BRUSHOBJ* Brush, - POINTL* BrushPoint, - ROP4 Rop4) + SURFOBJ* Source, + SURFOBJ* Mask, + XLATEOBJ* ColorTranslation, + RECTL* DestRect, + POINTL* SourcePoint, + POINTL* MaskPoint, + BRUSHOBJ* Brush, + POINTL* BrushPoint, + ROP4 Rop4) { - LONG i, j, dx, dy, c8; - BYTE *tMask, *lMask; - static BYTE maskbit[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; - /* Pattern brushes */ - PGDIBRUSHINST GdiBrush = NULL; - SURFOBJ *PatternObj = NULL; - PBITMAPOBJ PatternBitmap; - ULONG PatternWidth = 0, PatternHeight = 0, PatternY = 0; + LONG i, j, dx, dy, c8; + BYTE *tMask, *lMask; + static BYTE maskbit[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; + /* Pattern brushes */ + PGDIBRUSHINST GdiBrush = NULL; + SURFOBJ *PatternObj = NULL; + PBITMAPOBJ PatternBitmap; + ULONG PatternWidth = 0, PatternHeight = 0, PatternY = 0; - if (Mask == NULL) - { - return FALSE; - } + if (Mask == NULL) + { + return FALSE; + } - dx = DestRect->right - DestRect->left; - dy = DestRect->bottom - DestRect->top; + dx = DestRect->right - DestRect->left; + dy = DestRect->bottom - DestRect->top; - if (Brush->iSolidColor == 0xFFFFFFFF) - { - GdiBrush = CONTAINING_RECORD( - Brush, - GDIBRUSHINST, - BrushObject); + if (Brush->iSolidColor == 0xFFFFFFFF) + { + GdiBrush = CONTAINING_RECORD( + Brush, + GDIBRUSHINST, + BrushObject); - PatternBitmap = BITMAPOBJ_LockBitmap(GdiBrush->GdiBrushObject->hbmPattern); - if(PatternBitmap != NULL) - { - PatternObj = &PatternBitmap->SurfObj; - PatternWidth = PatternObj->sizlBitmap.cx; - PatternHeight = PatternObj->sizlBitmap.cy; - } - } - else - PatternBitmap = NULL; + PatternBitmap = BITMAPOBJ_LockBitmap(GdiBrush->GdiBrushObject->hbmPattern); + if (PatternBitmap != NULL) + { + PatternObj = &PatternBitmap->SurfObj; + PatternWidth = PatternObj->sizlBitmap.cx; + PatternHeight = PatternObj->sizlBitmap.cy; + } + } + else + PatternBitmap = NULL; - tMask = (PBYTE)Mask->pvScan0 + SourcePoint->y * Mask->lDelta + (SourcePoint->x >> 3); - for (j = 0; j < dy; j++) - { - lMask = tMask; - c8 = SourcePoint->x & 0x07; + tMask = (PBYTE)Mask->pvScan0 + SourcePoint->y * Mask->lDelta + (SourcePoint->x >> 3); + for (j = 0; j < dy; j++) + { + lMask = tMask; + c8 = SourcePoint->x & 0x07; - if(PatternBitmap != NULL) - PatternY = (DestRect->top + j) % PatternHeight; + if (PatternBitmap != NULL) + PatternY = (DestRect->top + j) % PatternHeight; - for (i = 0; i < dx; i++) - { - if (0 != (*lMask & maskbit[c8])) - { - if (PatternBitmap == NULL) + for (i = 0; i < dx; i++) + { + if (0 != (*lMask & maskbit[c8])) { - DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( - Dest, DestRect->left + i, DestRect->top + j, Brush->iSolidColor); + if (PatternBitmap == NULL) + { + DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( + Dest, DestRect->left + i, DestRect->top + j, Brush->iSolidColor); + } + else + { + DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( + Dest, DestRect->left + i, DestRect->top + j, + DIB_GetSource(PatternObj, (DestRect->left + i) % PatternWidth, PatternY, GdiBrush->XlateObject)); + } } - else + c8++; + if (8 == c8) { - DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( - Dest, DestRect->left + i, DestRect->top + j, - DIB_GetSource(PatternObj, (DestRect->left + i) % PatternWidth, PatternY, GdiBrush->XlateObject)); + lMask++; + c8 = 0; } - } - c8++; - if (8 == c8) - { - lMask++; - c8 = 0; - } - } - tMask += Mask->lDelta; - } + } + tMask += Mask->lDelta; + } - if (PatternBitmap != NULL) - BITMAPOBJ_UnlockBitmap(PatternBitmap); + if (PatternBitmap != NULL) + BITMAPOBJ_UnlockBitmap(PatternBitmap); - return TRUE; + return TRUE; } static BOOLEAN STDCALL BltPatCopy(SURFOBJ* Dest, - SURFOBJ* Source, - SURFOBJ* Mask, - XLATEOBJ* ColorTranslation, - RECTL* DestRect, - POINTL* SourcePoint, - POINTL* MaskPoint, - BRUSHOBJ* Brush, - POINTL* BrushPoint, - ROP4 Rop4) + SURFOBJ* Source, + SURFOBJ* Mask, + XLATEOBJ* ColorTranslation, + RECTL* DestRect, + POINTL* SourcePoint, + POINTL* MaskPoint, + BRUSHOBJ* Brush, + POINTL* BrushPoint, + ROP4 Rop4) { - // These functions are assigned if we're working with a DIB - // The assigned functions depend on the bitsPerPixel of the DIB + // These functions are assigned if we're working with a DIB + // The assigned functions depend on the bitsPerPixel of the DIB - DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_ColorFill(Dest, DestRect, Brush->iSolidColor); + DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_ColorFill(Dest, DestRect, Brush->iSolidColor); - return TRUE; + return TRUE; } static BOOLEAN STDCALL @@ -196,54 +196,54 @@ CallDibBitBlt(SURFOBJ* OutputObj, POINTL* BrushOrigin, ROP4 Rop4) { - BLTINFO BltInfo; - PGDIBRUSHINST GdiBrush = NULL; - BITMAPOBJ *bmPattern; - BOOLEAN Result; + BLTINFO BltInfo; + PGDIBRUSHINST GdiBrush = NULL; + BITMAPOBJ *bmPattern; + BOOLEAN Result; - BltInfo.DestSurface = OutputObj; - BltInfo.SourceSurface = InputObj; - BltInfo.PatternSurface = NULL; - BltInfo.XlateSourceToDest = ColorTranslation; - BltInfo.DestRect = *OutputRect; - BltInfo.SourcePoint = *InputPoint; + BltInfo.DestSurface = OutputObj; + BltInfo.SourceSurface = InputObj; + BltInfo.PatternSurface = NULL; + BltInfo.XlateSourceToDest = ColorTranslation; + BltInfo.DestRect = *OutputRect; + BltInfo.SourcePoint = *InputPoint; - if (ROP3_TO_ROP4(SRCCOPY) == Rop4) - return DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBltSrcCopy(&BltInfo); + if (ROP3_TO_ROP4(SRCCOPY) == Rop4) + return DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBltSrcCopy(&BltInfo); - BltInfo.XlatePatternToDest = NULL; - BltInfo.Brush = Brush; - BltInfo.BrushOrigin = *BrushOrigin; - BltInfo.Rop4 = Rop4; + BltInfo.XlatePatternToDest = NULL; + BltInfo.Brush = Brush; + BltInfo.BrushOrigin = *BrushOrigin; + BltInfo.Rop4 = Rop4; - /* Pattern brush */ - if (ROP4_USES_PATTERN(Rop4) && Brush->iSolidColor == 0xFFFFFFFF) - { - GdiBrush = CONTAINING_RECORD(Brush, GDIBRUSHINST, BrushObject); - if((bmPattern = BITMAPOBJ_LockBitmap(GdiBrush->GdiBrushObject->hbmPattern))) - { - BltInfo.PatternSurface = &bmPattern->SurfObj; - } - else - { - /* FIXME - What to do here? */ - } - BltInfo.XlatePatternToDest = GdiBrush->XlateObject; - } - else - { - bmPattern = NULL; - } + /* Pattern brush */ + if (ROP4_USES_PATTERN(Rop4) && Brush->iSolidColor == 0xFFFFFFFF) + { + GdiBrush = CONTAINING_RECORD(Brush, GDIBRUSHINST, BrushObject); + if ((bmPattern = BITMAPOBJ_LockBitmap(GdiBrush->GdiBrushObject->hbmPattern))) + { + BltInfo.PatternSurface = &bmPattern->SurfObj; + } + else + { + /* FIXME - What to do here? */ + } + BltInfo.XlatePatternToDest = GdiBrush->XlateObject; + } + else + { + bmPattern = NULL; + } - Result = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBlt(&BltInfo); + Result = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBlt(&BltInfo); - /* Pattern brush */ - if (bmPattern != NULL) - { - BITMAPOBJ_UnlockBitmap(bmPattern); - } + /* Pattern brush */ + if (bmPattern != NULL) + { + BITMAPOBJ_UnlockBitmap(bmPattern); + } - return Result; + return Result; } INT __cdecl abs(INT nm); @@ -253,280 +253,280 @@ INT __cdecl abs(INT nm); */ BOOL STDCALL EngBitBlt(SURFOBJ *DestObj, - SURFOBJ *SourceObj, - SURFOBJ *Mask, - CLIPOBJ *ClipRegion, - XLATEOBJ *ColorTranslation, - RECTL *DestRect, - POINTL *SourcePoint, - POINTL *MaskOrigin, - BRUSHOBJ *Brush, - POINTL *BrushOrigin, - ROP4 Rop4) + SURFOBJ *SourceObj, + SURFOBJ *Mask, + CLIPOBJ *ClipRegion, + XLATEOBJ *ColorTranslation, + RECTL *DestRect, + POINTL *SourcePoint, + POINTL *MaskOrigin, + BRUSHOBJ *Brush, + POINTL *BrushOrigin, + ROP4 Rop4) { - BYTE clippingType; - RECTL CombinedRect; - RECT_ENUM RectEnum; - BOOL EnumMore; - POINTL InputPoint; - RECTL InputRect; - RECTL OutputRect; - POINTL Translate; - INTENG_ENTER_LEAVE EnterLeaveSource; - INTENG_ENTER_LEAVE EnterLeaveDest; - SURFOBJ* InputObj; - SURFOBJ* OutputObj; - PBLTRECTFUNC BltRectFunc; - BOOLEAN Ret = TRUE; - RECTL ClipRect; - unsigned i; - POINTL Pt; - ULONG Direction; - BOOL UsesSource; - BOOL UsesPattern; - POINTL AdjustedBrushOrigin; + BYTE clippingType; + RECTL CombinedRect; + RECT_ENUM RectEnum; + BOOL EnumMore; + POINTL InputPoint; + RECTL InputRect; + RECTL OutputRect; + POINTL Translate; + INTENG_ENTER_LEAVE EnterLeaveSource; + INTENG_ENTER_LEAVE EnterLeaveDest; + SURFOBJ* InputObj; + SURFOBJ* OutputObj; + PBLTRECTFUNC BltRectFunc; + BOOLEAN Ret = TRUE; + RECTL ClipRect; + unsigned i; + POINTL Pt; + ULONG Direction; + BOOL UsesSource; + BOOL UsesPattern; + POINTL AdjustedBrushOrigin; - UsesSource = ROP4_USES_SOURCE(Rop4); - UsesPattern = ROP4_USES_PATTERN(Rop4); - if (R4_NOOP == Rop4) + UsesSource = ROP4_USES_SOURCE(Rop4); + UsesPattern = ROP4_USES_PATTERN(Rop4); + if (R4_NOOP == Rop4) { - /* Copy destination onto itself: nop */ - return TRUE; + /* Copy destination onto itself: nop */ + return TRUE; } - OutputRect = *DestRect; - if (OutputRect.right < OutputRect.left) + OutputRect = *DestRect; + if (OutputRect.right < OutputRect.left) { - OutputRect.left = DestRect->right; - OutputRect.right = DestRect->left; + OutputRect.left = DestRect->right; + OutputRect.right = DestRect->left; } - if (OutputRect.bottom < OutputRect.top) + if (OutputRect.bottom < OutputRect.top) { - OutputRect.left = DestRect->right; - OutputRect.right = DestRect->left; + OutputRect.left = DestRect->right; + OutputRect.right = DestRect->left; } - if (UsesSource) - { - if (NULL == SourcePoint) - { - return FALSE; - } - - /* Make sure we don't try to copy anything outside the valid source - region */ - InputPoint = *SourcePoint; - if (InputPoint.x < 0) - { - OutputRect.left -= InputPoint.x; - InputPoint.x = 0; - } - if (InputPoint.y < 0) - { - OutputRect.top -= InputPoint.y; - InputPoint.y = 0; - } - if (SourceObj->sizlBitmap.cx < InputPoint.x + - OutputRect.right - OutputRect.left) - { - OutputRect.right = OutputRect.left + - SourceObj->sizlBitmap.cx - InputPoint.x; - } - if (SourceObj->sizlBitmap.cy < InputPoint.y + - OutputRect.bottom - OutputRect.top) - { - OutputRect.bottom = OutputRect.top + - SourceObj->sizlBitmap.cy - InputPoint.y; - } - - InputRect.left = InputPoint.x; - InputRect.right = InputPoint.x + (OutputRect.right - OutputRect.left); - InputRect.top = InputPoint.y; - InputRect.bottom = InputPoint.y + (OutputRect.bottom - OutputRect.top); - - if (! IntEngEnter(&EnterLeaveSource, SourceObj, &InputRect, TRUE, - &Translate, &InputObj)) - { - return FALSE; - } - - InputPoint.x += Translate.x; - InputPoint.y += Translate.y; - } - else - { - InputRect.left = 0; - InputRect.right = DestRect->right - DestRect->left; - InputRect.top = 0; - InputRect.bottom = DestRect->bottom - DestRect->top; - } - - if (NULL != ClipRegion) - { - if (OutputRect.left < ClipRegion->rclBounds.left) - { - InputRect.left += ClipRegion->rclBounds.left - OutputRect.left; - InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left; - OutputRect.left = ClipRegion->rclBounds.left; - } - if (ClipRegion->rclBounds.right < OutputRect.right) - { - InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right; - OutputRect.right = ClipRegion->rclBounds.right; - } - if (OutputRect.top < ClipRegion->rclBounds.top) - { - InputRect.top += ClipRegion->rclBounds.top - OutputRect.top; - InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top; - OutputRect.top = ClipRegion->rclBounds.top; - } - if (ClipRegion->rclBounds.bottom < OutputRect.bottom) - { - InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom; - OutputRect.bottom = ClipRegion->rclBounds.bottom; - } - } - - /* Check for degenerate case: if height or width of OutputRect is 0 pixels - there's nothing to do */ - if (OutputRect.right <= OutputRect.left || - OutputRect.bottom <= OutputRect.top) - { if (UsesSource) - { - IntEngLeave(&EnterLeaveSource); - } - return TRUE; - } - - if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, - &OutputObj)) { - if (UsesSource) - { - IntEngLeave(&EnterLeaveSource); - } - return FALSE; - } - - OutputRect.left += Translate.x; - OutputRect.right += Translate.x; - OutputRect.top += Translate.y; - OutputRect.bottom += Translate.y; - - if(BrushOrigin) - { - AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x; - AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y; - } - else - { - AdjustedBrushOrigin = Translate; - } - - /* Determine clipping type */ - if (ClipRegion == (CLIPOBJ *) NULL) - { - clippingType = DC_TRIVIAL; - } - else - { - clippingType = ClipRegion->iDComplexity; - } - - if (R4_MASK == Rop4) - { - BltRectFunc = BltMask; - } - else if (ROP3_TO_ROP4(PATCOPY) == Rop4) - { - if (Brush->iSolidColor == 0xFFFFFFFF) - BltRectFunc = CallDibBitBlt; - else - BltRectFunc = BltPatCopy; - } - else - { - BltRectFunc = CallDibBitBlt; - } - - - switch(clippingType) - { - case DC_TRIVIAL: - Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation, - &OutputRect, &InputPoint, MaskOrigin, Brush, - &AdjustedBrushOrigin, Rop4); - break; - case DC_RECT: - /* Clip the blt to the clip rectangle */ - ClipRect.left = ClipRegion->rclBounds.left + Translate.x; - ClipRect.right = ClipRegion->rclBounds.right + Translate.x; - ClipRect.top = ClipRegion->rclBounds.top + Translate.y; - ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y; - if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + if (NULL == SourcePoint) { - Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; - Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; - Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation, - &CombinedRect, &Pt, MaskOrigin, Brush, - &AdjustedBrushOrigin, Rop4); + return FALSE; } - break; - case DC_COMPLEX: - Ret = TRUE; - if (OutputObj == InputObj) - { - if (OutputRect.top < InputPoint.y) - { - Direction = OutputRect.left < InputPoint.x ? - CD_RIGHTDOWN : CD_LEFTDOWN; - } - else - { - Direction = OutputRect.left < InputPoint.x ? - CD_RIGHTUP : CD_LEFTUP; - } - } - else - { - Direction = CD_ANY; - } - CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0); - do - { - EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), - (PVOID) &RectEnum); - for (i = 0; i < RectEnum.c; i++) - { - ClipRect.left = RectEnum.arcl[i].left + Translate.x; - ClipRect.right = RectEnum.arcl[i].right + Translate.x; - ClipRect.top = RectEnum.arcl[i].top + Translate.y; - ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y; - if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) - { - Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; - Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; - Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, - ColorTranslation, &CombinedRect, &Pt, - MaskOrigin, Brush, &AdjustedBrushOrigin, - Rop4) && Ret; - } - } - } - while(EnumMore); - break; - } + /* Make sure we don't try to copy anything outside the valid source + region */ + InputPoint = *SourcePoint; + if (InputPoint.x < 0) + { + OutputRect.left -= InputPoint.x; + InputPoint.x = 0; + } + if (InputPoint.y < 0) + { + OutputRect.top -= InputPoint.y; + InputPoint.y = 0; + } + if (SourceObj->sizlBitmap.cx < InputPoint.x + + OutputRect.right - OutputRect.left) + { + OutputRect.right = OutputRect.left + + SourceObj->sizlBitmap.cx - InputPoint.x; + } + if (SourceObj->sizlBitmap.cy < InputPoint.y + + OutputRect.bottom - OutputRect.top) + { + OutputRect.bottom = OutputRect.top + + SourceObj->sizlBitmap.cy - InputPoint.y; + } + InputRect.left = InputPoint.x; + InputRect.right = InputPoint.x + (OutputRect.right - OutputRect.left); + InputRect.top = InputPoint.y; + InputRect.bottom = InputPoint.y + (OutputRect.bottom - OutputRect.top); - IntEngLeave(&EnterLeaveDest); - if (UsesSource) + if (! IntEngEnter(&EnterLeaveSource, SourceObj, &InputRect, TRUE, + &Translate, &InputObj)) + { + return FALSE; + } + + InputPoint.x += Translate.x; + InputPoint.y += Translate.y; + } + else { - IntEngLeave(&EnterLeaveSource); + InputRect.left = 0; + InputRect.right = DestRect->right - DestRect->left; + InputRect.top = 0; + InputRect.bottom = DestRect->bottom - DestRect->top; } - return Ret; + if (NULL != ClipRegion) + { + if (OutputRect.left < ClipRegion->rclBounds.left) + { + InputRect.left += ClipRegion->rclBounds.left - OutputRect.left; + InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left; + OutputRect.left = ClipRegion->rclBounds.left; + } + if (ClipRegion->rclBounds.right < OutputRect.right) + { + InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right; + OutputRect.right = ClipRegion->rclBounds.right; + } + if (OutputRect.top < ClipRegion->rclBounds.top) + { + InputRect.top += ClipRegion->rclBounds.top - OutputRect.top; + InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top; + OutputRect.top = ClipRegion->rclBounds.top; + } + if (ClipRegion->rclBounds.bottom < OutputRect.bottom) + { + InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom; + OutputRect.bottom = ClipRegion->rclBounds.bottom; + } + } + + /* Check for degenerate case: if height or width of OutputRect is 0 pixels + there's nothing to do */ + if (OutputRect.right <= OutputRect.left || + OutputRect.bottom <= OutputRect.top) + { + if (UsesSource) + { + IntEngLeave(&EnterLeaveSource); + } + return TRUE; + } + + if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, + &OutputObj)) + { + if (UsesSource) + { + IntEngLeave(&EnterLeaveSource); + } + return FALSE; + } + + OutputRect.left += Translate.x; + OutputRect.right += Translate.x; + OutputRect.top += Translate.y; + OutputRect.bottom += Translate.y; + + if (BrushOrigin) + { + AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x; + AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y; + } + else + { + AdjustedBrushOrigin = Translate; + } + + /* Determine clipping type */ + if (ClipRegion == (CLIPOBJ *) NULL) + { + clippingType = DC_TRIVIAL; + } + else + { + clippingType = ClipRegion->iDComplexity; + } + + if (R4_MASK == Rop4) + { + BltRectFunc = BltMask; + } + else if (ROP3_TO_ROP4(PATCOPY) == Rop4) + { + if (Brush->iSolidColor == 0xFFFFFFFF) + BltRectFunc = CallDibBitBlt; + else + BltRectFunc = BltPatCopy; + } + else + { + BltRectFunc = CallDibBitBlt; + } + + + switch (clippingType) + { + case DC_TRIVIAL: + Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation, + &OutputRect, &InputPoint, MaskOrigin, Brush, + &AdjustedBrushOrigin, Rop4); + break; + case DC_RECT: + /* Clip the blt to the clip rectangle */ + ClipRect.left = ClipRegion->rclBounds.left + Translate.x; + ClipRect.right = ClipRegion->rclBounds.right + Translate.x; + ClipRect.top = ClipRegion->rclBounds.top + Translate.y; + ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + { + Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; + Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; + Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation, + &CombinedRect, &Pt, MaskOrigin, Brush, + &AdjustedBrushOrigin, Rop4); + } + break; + case DC_COMPLEX: + Ret = TRUE; + if (OutputObj == InputObj) + { + if (OutputRect.top < InputPoint.y) + { + Direction = OutputRect.left < InputPoint.x ? + CD_RIGHTDOWN : CD_LEFTDOWN; + } + else + { + Direction = OutputRect.left < InputPoint.x ? + CD_RIGHTUP : CD_LEFTUP; + } + } + else + { + Direction = CD_ANY; + } + CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0); + do + { + EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), + (PVOID) &RectEnum); + + for (i = 0; i < RectEnum.c; i++) + { + ClipRect.left = RectEnum.arcl[i].left + Translate.x; + ClipRect.right = RectEnum.arcl[i].right + Translate.x; + ClipRect.top = RectEnum.arcl[i].top + Translate.y; + ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + { + Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; + Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; + Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, + ColorTranslation, &CombinedRect, &Pt, + MaskOrigin, Brush, &AdjustedBrushOrigin, + Rop4) && Ret; + } + } + } + while (EnumMore); + break; + } + + + IntEngLeave(&EnterLeaveDest); + if (UsesSource) + { + IntEngLeave(&EnterLeaveSource); + } + + return Ret; } BOOL STDCALL @@ -543,154 +543,154 @@ IntEngBitBltEx(SURFOBJ *DestSurf, ROP4 Rop4, BOOL RemoveMouse) { - BOOLEAN ret; - RECTL InputClippedRect; - RECTL OutputRect; - POINTL InputPoint; - BOOLEAN UsesSource; - BITMAPOBJ *DestObj; - BITMAPOBJ *SourceObj = NULL; + BOOLEAN ret; + RECTL InputClippedRect; + RECTL OutputRect; + POINTL InputPoint; + BOOLEAN UsesSource; + BITMAPOBJ *DestObj; + BITMAPOBJ *SourceObj = NULL; - if (DestSurf == NULL) - return FALSE; + if (DestSurf == NULL) + return FALSE; - ASSERT(DestSurf); - DestObj = CONTAINING_RECORD(DestSurf, BITMAPOBJ, SurfObj); - ASSERT(DestObj); + ASSERT(DestSurf); + DestObj = CONTAINING_RECORD(DestSurf, BITMAPOBJ, SurfObj); + ASSERT(DestObj); - InputClippedRect = *DestRect; - if (InputClippedRect.right < InputClippedRect.left) + InputClippedRect = *DestRect; + if (InputClippedRect.right < InputClippedRect.left) { - InputClippedRect.left = DestRect->right; - InputClippedRect.right = DestRect->left; + InputClippedRect.left = DestRect->right; + InputClippedRect.right = DestRect->left; } - if (InputClippedRect.bottom < InputClippedRect.top) + if (InputClippedRect.bottom < InputClippedRect.top) { - InputClippedRect.top = DestRect->bottom; - InputClippedRect.bottom = DestRect->top; + InputClippedRect.top = DestRect->bottom; + InputClippedRect.bottom = DestRect->top; } - UsesSource = ROP4_USES_SOURCE(Rop4); - if (UsesSource) - { - if (NULL == SourcePoint || NULL == SourceSurf) - { - return FALSE; - } - InputPoint = *SourcePoint; - - /* Make sure we don't try to copy anything outside the valid source - region */ - if (InputPoint.x < 0) - { - InputClippedRect.left -= InputPoint.x; - InputPoint.x = 0; - } - if (InputPoint.y < 0) - { - InputClippedRect.top -= InputPoint.y; - InputPoint.y = 0; - } - if (SourceSurf->sizlBitmap.cx < InputPoint.x + - InputClippedRect.right - - InputClippedRect.left) - { - InputClippedRect.right = InputClippedRect.left + - SourceSurf->sizlBitmap.cx - InputPoint.x; - } - if (SourceSurf->sizlBitmap.cy < InputPoint.y + - InputClippedRect.bottom - - InputClippedRect.top) - { - InputClippedRect.bottom = InputClippedRect.top + - SourceSurf->sizlBitmap.cy - InputPoint.y; - } - - if (InputClippedRect.right < InputClippedRect.left || - InputClippedRect.bottom < InputClippedRect.top) - { - /* Everything clipped away, nothing to do */ - return TRUE; - } - } - - /* Clip against the bounds of the clipping region so we won't try to write - * outside the surface */ - if (NULL != ClipRegion) - { - if (! EngIntersectRect(&OutputRect, &InputClippedRect, - &ClipRegion->rclBounds)) - { - return TRUE; - } - InputPoint.x += OutputRect.left - InputClippedRect.left; - InputPoint.y += OutputRect.top - InputClippedRect.top; - } - else - { - OutputRect = InputClippedRect; - } - - if (RemoveMouse) - { - BITMAPOBJ_LockBitmapBits(DestObj); - + UsesSource = ROP4_USES_SOURCE(Rop4); if (UsesSource) - { - if (SourceSurf != DestSurf) + { + if (NULL == SourcePoint || NULL == SourceSurf) { - SourceObj = CONTAINING_RECORD(SourceSurf, BITMAPOBJ, SurfObj); - BITMAPOBJ_LockBitmapBits(SourceObj); + return FALSE; } - MouseSafetyOnDrawStart(SourceSurf, InputPoint.x, InputPoint.y, - (InputPoint.x + abs(DestRect->right - DestRect->left)), - (InputPoint.y + abs(DestRect->bottom - DestRect->top))); - } - MouseSafetyOnDrawStart(DestSurf, OutputRect.left, OutputRect.top, - OutputRect.right, OutputRect.bottom); - } + InputPoint = *SourcePoint; - /* No success yet */ - ret = FALSE; - - /* Call the driver's DrvBitBlt if available */ - if (DestObj->flHooks & HOOK_BITBLT) - { - ret = GDIDEVFUNCS(DestSurf).BitBlt( - DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, - &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin, - Rop4); - } - - if (! ret) - { - ret = EngBitBlt(DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, - &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin, - Rop4); - } - - if (RemoveMouse) - { - MouseSafetyOnDrawEnd(DestSurf); - if (UsesSource) - { - MouseSafetyOnDrawEnd(SourceSurf); - if (SourceSurf != DestSurf) + /* Make sure we don't try to copy anything outside the valid source + region */ + if (InputPoint.x < 0) { - BITMAPOBJ_UnlockBitmapBits(SourceObj); + InputClippedRect.left -= InputPoint.x; + InputPoint.x = 0; + } + if (InputPoint.y < 0) + { + InputClippedRect.top -= InputPoint.y; + InputPoint.y = 0; + } + if (SourceSurf->sizlBitmap.cx < InputPoint.x + + InputClippedRect.right - + InputClippedRect.left) + { + InputClippedRect.right = InputClippedRect.left + + SourceSurf->sizlBitmap.cx - InputPoint.x; + } + if (SourceSurf->sizlBitmap.cy < InputPoint.y + + InputClippedRect.bottom - + InputClippedRect.top) + { + InputClippedRect.bottom = InputClippedRect.top + + SourceSurf->sizlBitmap.cy - InputPoint.y; } - } - BITMAPOBJ_UnlockBitmapBits(DestObj); + if (InputClippedRect.right < InputClippedRect.left || + InputClippedRect.bottom < InputClippedRect.top) + { + /* Everything clipped away, nothing to do */ + return TRUE; + } } - return ret; + /* Clip against the bounds of the clipping region so we won't try to write + * outside the surface */ + if (NULL != ClipRegion) + { + if (! EngIntersectRect(&OutputRect, &InputClippedRect, + &ClipRegion->rclBounds)) + { + return TRUE; + } + InputPoint.x += OutputRect.left - InputClippedRect.left; + InputPoint.y += OutputRect.top - InputClippedRect.top; + } + else + { + OutputRect = InputClippedRect; + } + + if (RemoveMouse) + { + BITMAPOBJ_LockBitmapBits(DestObj); + + if (UsesSource) + { + if (SourceSurf != DestSurf) + { + SourceObj = CONTAINING_RECORD(SourceSurf, BITMAPOBJ, SurfObj); + BITMAPOBJ_LockBitmapBits(SourceObj); + } + MouseSafetyOnDrawStart(SourceSurf, InputPoint.x, InputPoint.y, + (InputPoint.x + abs(DestRect->right - DestRect->left)), + (InputPoint.y + abs(DestRect->bottom - DestRect->top))); + } + MouseSafetyOnDrawStart(DestSurf, OutputRect.left, OutputRect.top, + OutputRect.right, OutputRect.bottom); + } + + /* No success yet */ + ret = FALSE; + + /* Call the driver's DrvBitBlt if available */ + if (DestObj->flHooks & HOOK_BITBLT) + { + ret = GDIDEVFUNCS(DestSurf).BitBlt( + DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, + &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin, + Rop4); + } + + if (! ret) + { + ret = EngBitBlt(DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, + &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin, + Rop4); + } + + if (RemoveMouse) + { + MouseSafetyOnDrawEnd(DestSurf); + if (UsesSource) + { + MouseSafetyOnDrawEnd(SourceSurf); + if (SourceSurf != DestSurf) + { + BITMAPOBJ_UnlockBitmapBits(SourceObj); + } + } + + BITMAPOBJ_UnlockBitmapBits(DestObj); + } + + return ret; } static BOOLEAN STDCALL CallDibStretchBlt(SURFOBJ* OutputObj, SURFOBJ* InputObj, SURFOBJ* Mask, - CLIPOBJ* ClipRegion, + CLIPOBJ* ClipRegion, XLATEOBJ* ColorTranslation, RECTL* OutputRect, RECTL* InputRect, @@ -698,117 +698,117 @@ CallDibStretchBlt(SURFOBJ* OutputObj, POINTL* BrushOrigin, ULONG Mode) { - POINTL RealBrushOrigin; - if (BrushOrigin == NULL) + POINTL RealBrushOrigin; + if (BrushOrigin == NULL) { - RealBrushOrigin.x = RealBrushOrigin.y = 0; + RealBrushOrigin.x = RealBrushOrigin.y = 0; } - else + else { - RealBrushOrigin = *BrushOrigin; + RealBrushOrigin = *BrushOrigin; } - return DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_StretchBlt( - OutputObj, InputObj, OutputRect, InputRect, MaskOrigin, RealBrushOrigin, ClipRegion, ColorTranslation, Mode); + return DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_StretchBlt( + OutputObj, InputObj, OutputRect, InputRect, MaskOrigin, RealBrushOrigin, ClipRegion, ColorTranslation, Mode); } BOOL STDCALL EngStretchBlt( - IN SURFOBJ *DestObj, - IN SURFOBJ *SourceObj, - IN SURFOBJ *Mask, - IN CLIPOBJ *ClipRegion, - IN XLATEOBJ *ColorTranslation, - IN COLORADJUSTMENT *pca, - IN POINTL *BrushOrigin, - IN RECTL *prclDest, - IN RECTL *prclSrc, - IN POINTL *MaskOrigin, - IN ULONG Mode - ) + IN SURFOBJ *DestObj, + IN SURFOBJ *SourceObj, + IN SURFOBJ *Mask, + IN CLIPOBJ *ClipRegion, + IN XLATEOBJ *ColorTranslation, + IN COLORADJUSTMENT *pca, + IN POINTL *BrushOrigin, + IN RECTL *prclDest, + IN RECTL *prclSrc, + IN POINTL *MaskOrigin, + IN ULONG Mode +) { - // www.osr.com/ddk/graphics/gdifncs_0bs7.htm + // www.osr.com/ddk/graphics/gdifncs_0bs7.htm - POINTL InputPoint; - RECTL InputRect; - RECTL OutputRect; - POINTL Translate; - INTENG_ENTER_LEAVE EnterLeaveSource; - INTENG_ENTER_LEAVE EnterLeaveDest; - SURFOBJ* InputObj; - SURFOBJ* OutputObj; - PSTRETCHRECTFUNC BltRectFunc; - BOOLEAN Ret; - POINTL AdjustedBrushOrigin; + POINTL InputPoint; + RECTL InputRect; + RECTL OutputRect; + POINTL Translate; + INTENG_ENTER_LEAVE EnterLeaveSource; + INTENG_ENTER_LEAVE EnterLeaveDest; + SURFOBJ* InputObj; + SURFOBJ* OutputObj; + PSTRETCHRECTFUNC BltRectFunc; + BOOLEAN Ret; + POINTL AdjustedBrushOrigin; - InputRect.left = prclSrc->left; - InputRect.right = prclSrc->right; - InputRect.top = prclSrc->top; - InputRect.bottom = prclSrc->bottom; + InputRect.left = prclSrc->left; + InputRect.right = prclSrc->right; + InputRect.top = prclSrc->top; + InputRect.bottom = prclSrc->bottom; - if (! IntEngEnter(&EnterLeaveSource, SourceObj, &InputRect, TRUE, &Translate, &InputObj)) + if (! IntEngEnter(&EnterLeaveSource, SourceObj, &InputRect, TRUE, &Translate, &InputObj)) { - return FALSE; + return FALSE; } - InputPoint.x = InputRect.left + Translate.x; - InputPoint.y = InputRect.top + Translate.y; + InputPoint.x = InputRect.left + Translate.x; + InputPoint.y = InputRect.top + Translate.y; - OutputRect = *prclDest; + OutputRect = *prclDest; - /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's - nothing to do */ - if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top) + /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's + nothing to do */ + if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top) { - IntEngLeave(&EnterLeaveSource); - return TRUE; + IntEngLeave(&EnterLeaveSource); + return TRUE; } - if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, &OutputObj)) + if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, &OutputObj)) { - IntEngLeave(&EnterLeaveSource); - return FALSE; + IntEngLeave(&EnterLeaveSource); + return FALSE; } - OutputRect.left = prclDest->left + Translate.x; - OutputRect.right = prclDest->right + Translate.x; - OutputRect.top = prclDest->top + Translate.y; - OutputRect.bottom = prclDest->bottom + Translate.y; + OutputRect.left = prclDest->left + Translate.x; + OutputRect.right = prclDest->right + Translate.x; + OutputRect.top = prclDest->top + Translate.y; + OutputRect.bottom = prclDest->bottom + Translate.y; - if (NULL != BrushOrigin) + if (NULL != BrushOrigin) { - AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x; - AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y; + AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x; + AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y; } - else + else { - AdjustedBrushOrigin = Translate; + AdjustedBrushOrigin = Translate; } - if (Mask != NULL) + if (Mask != NULL) { - //BltRectFunc = BltMask; - DPRINT("EngStretchBlt isn't capable of handling mask yet.\n"); - IntEngLeave(&EnterLeaveDest); - IntEngLeave(&EnterLeaveSource); + //BltRectFunc = BltMask; + DPRINT("EngStretchBlt isn't capable of handling mask yet.\n"); + IntEngLeave(&EnterLeaveDest); + IntEngLeave(&EnterLeaveSource); - return FALSE; + return FALSE; } - else + else { - BltRectFunc = CallDibStretchBlt; + BltRectFunc = CallDibStretchBlt; } - Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ClipRegion, - ColorTranslation, &OutputRect, &InputRect, MaskOrigin, - &AdjustedBrushOrigin, Mode); + Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ClipRegion, + ColorTranslation, &OutputRect, &InputRect, MaskOrigin, + &AdjustedBrushOrigin, Mode); - IntEngLeave(&EnterLeaveDest); - IntEngLeave(&EnterLeaveSource); + IntEngLeave(&EnterLeaveDest); + IntEngLeave(&EnterLeaveSource); - return Ret; + return Ret; } BOOL STDCALL @@ -824,72 +824,72 @@ IntEngStretchBlt(SURFOBJ *DestSurf, POINTL *BrushOrigin, ULONG Mode) { - BOOLEAN ret; - COLORADJUSTMENT ca; - POINT MaskOrigin; - BITMAPOBJ *DestObj; - BITMAPOBJ *SourceObj = NULL; + BOOLEAN ret; + COLORADJUSTMENT ca; + POINT MaskOrigin; + BITMAPOBJ *DestObj; + BITMAPOBJ *SourceObj = NULL; - ASSERT(DestSurf); - DestObj = CONTAINING_RECORD(DestSurf, BITMAPOBJ, SurfObj); - ASSERT(DestObj); + ASSERT(DestSurf); + DestObj = CONTAINING_RECORD(DestSurf, BITMAPOBJ, SurfObj); + ASSERT(DestObj); - if (pMaskOrigin != NULL) + if (pMaskOrigin != NULL) { - MaskOrigin.x = pMaskOrigin->x; MaskOrigin.y = pMaskOrigin->y; + MaskOrigin.x = pMaskOrigin->x; MaskOrigin.y = pMaskOrigin->y; } - /* No success yet */ - ret = FALSE; - ASSERT(DestRect); - BITMAPOBJ_LockBitmapBits(DestObj); - MouseSafetyOnDrawStart(DestSurf, DestRect->left, DestRect->top, - DestRect->right, DestRect->bottom); + /* No success yet */ + ret = FALSE; + ASSERT(DestRect); + BITMAPOBJ_LockBitmapBits(DestObj); + MouseSafetyOnDrawStart(DestSurf, DestRect->left, DestRect->top, + DestRect->right, DestRect->bottom); - if (NULL != SourceSurf) + if (NULL != SourceSurf) { - SourceObj = CONTAINING_RECORD(SourceSurf, BITMAPOBJ, SurfObj); - ASSERT(SourceRect); - if (SourceSurf != DestSurf) - { - BITMAPOBJ_LockBitmapBits(SourceObj); - } - MouseSafetyOnDrawStart(SourceSurf, SourceRect->left, SourceRect->top, - SourceRect->right, SourceRect->bottom); + SourceObj = CONTAINING_RECORD(SourceSurf, BITMAPOBJ, SurfObj); + ASSERT(SourceRect); + if (SourceSurf != DestSurf) + { + BITMAPOBJ_LockBitmapBits(SourceObj); + } + MouseSafetyOnDrawStart(SourceSurf, SourceRect->left, SourceRect->top, + SourceRect->right, SourceRect->bottom); } - /* Prepare color adjustment */ + /* Prepare color adjustment */ - /* Call the driver's DrvStretchBlt if available */ - if (DestObj->flHooks & HOOK_STRETCHBLT) + /* Call the driver's DrvStretchBlt if available */ + if (DestObj->flHooks & HOOK_STRETCHBLT) { - /* Drv->StretchBlt (look at http://www.osr.com/ddk/graphics/ddifncs_3ew7.htm ) - SURFOBJ *psoMask // optional, if it exists, then rop4=0xCCAA, otherwise rop4=0xCCCC */ - // FIXME: MaskOrigin is always NULL ! - ret = GDIDEVFUNCS(DestSurf).StretchBlt( - DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, + /* Drv->StretchBlt (look at http://www.osr.com/ddk/graphics/ddifncs_3ew7.htm ) + SURFOBJ *psoMask // optional, if it exists, then rop4=0xCCAA, otherwise rop4=0xCCCC */ + // FIXME: MaskOrigin is always NULL ! + ret = GDIDEVFUNCS(DestSurf).StretchBlt( + DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, + &ca, BrushOrigin, DestRect, SourceRect, NULL, Mode); + } + + if (! ret) + { + // FIXME: see previous fixme + ret = EngStretchBlt(DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, &ca, BrushOrigin, DestRect, SourceRect, NULL, Mode); } - if (! ret) + if (NULL != SourceSurf) { - // FIXME: see previous fixme - ret = EngStretchBlt(DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation, - &ca, BrushOrigin, DestRect, SourceRect, NULL, Mode); + MouseSafetyOnDrawEnd(SourceSurf); + if (SourceSurf != DestSurf) + { + BITMAPOBJ_UnlockBitmapBits(SourceObj); + } } + MouseSafetyOnDrawEnd(DestSurf); + BITMAPOBJ_UnlockBitmapBits(DestObj); - if (NULL != SourceSurf) - { - MouseSafetyOnDrawEnd(SourceSurf); - if (SourceSurf != DestSurf) - { - BITMAPOBJ_UnlockBitmapBits(SourceObj); - } - } - MouseSafetyOnDrawEnd(DestSurf); - BITMAPOBJ_UnlockBitmapBits(DestObj); - - return ret; + return ret; } BOOL @@ -902,245 +902,245 @@ EngAlphaBlend(IN SURFOBJ *Dest, IN PRECTL SourceRect, IN BLENDOBJ *BlendObj) { - RECTL SourceStretchedRect; - SIZEL SourceStretchedSize; - HBITMAP SourceStretchedBitmap = 0; - SURFOBJ* SourceStretchedObj = NULL; - RECTL InputRect; - RECTL OutputRect; - RECTL ClipRect; - RECTL CombinedRect; - RECTL Rect; - POINTL Translate; - INTENG_ENTER_LEAVE EnterLeaveSource; - INTENG_ENTER_LEAVE EnterLeaveDest; - SURFOBJ* InputObj; - SURFOBJ* OutputObj; - LONG Width; - LONG ClippingType; - RECT_ENUM RectEnum; - BOOL EnumMore; - INT i; - BOOLEAN Ret; + RECTL SourceStretchedRect; + SIZEL SourceStretchedSize; + HBITMAP SourceStretchedBitmap = 0; + SURFOBJ* SourceStretchedObj = NULL; + RECTL InputRect; + RECTL OutputRect; + RECTL ClipRect; + RECTL CombinedRect; + RECTL Rect; + POINTL Translate; + INTENG_ENTER_LEAVE EnterLeaveSource; + INTENG_ENTER_LEAVE EnterLeaveDest; + SURFOBJ* InputObj; + SURFOBJ* OutputObj; + LONG Width; + LONG ClippingType; + RECT_ENUM RectEnum; + BOOL EnumMore; + INT i; + BOOLEAN Ret; - DPRINT("EngAlphaBlend(Dest:0x%p, Source:0x%p, ClipRegion:0x%p, ColorTranslation:0x%p,\n", Dest, Source, ClipRegion, ColorTranslation); - DPRINT(" DestRect:{0x%x, 0x%x, 0x%x, 0x%x}, SourceRect:{0x%x, 0x%x, 0x%x, 0x%x},\n", - DestRect->left, DestRect->top, DestRect->right, DestRect->bottom, - SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom); - DPRINT(" BlendObj:{0x%x, 0x%x, 0x%x, 0x%x}\n", BlendObj->BlendFunction.BlendOp, - BlendObj->BlendFunction.BlendFlags, BlendObj->BlendFunction.SourceConstantAlpha, - BlendObj->BlendFunction.AlphaFormat); + DPRINT("EngAlphaBlend(Dest:0x%p, Source:0x%p, ClipRegion:0x%p, ColorTranslation:0x%p,\n", Dest, Source, ClipRegion, ColorTranslation); + DPRINT(" DestRect:{0x%x, 0x%x, 0x%x, 0x%x}, SourceRect:{0x%x, 0x%x, 0x%x, 0x%x},\n", + DestRect->left, DestRect->top, DestRect->right, DestRect->bottom, + SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom); + DPRINT(" BlendObj:{0x%x, 0x%x, 0x%x, 0x%x}\n", BlendObj->BlendFunction.BlendOp, + BlendObj->BlendFunction.BlendFlags, BlendObj->BlendFunction.SourceConstantAlpha, + BlendObj->BlendFunction.AlphaFormat); - /* Validate input */ - if (DestRect->left >= DestRect->right || DestRect->top >= DestRect->bottom) + /* Validate input */ + if (DestRect->left >= DestRect->right || DestRect->top >= DestRect->bottom) { - DPRINT1("Empty destination rectangle!\n"); - return FALSE; + DPRINT1("Empty destination rectangle!\n"); + return FALSE; } - if (SourceRect->left >= SourceRect->right || SourceRect->top >= SourceRect->bottom) + if (SourceRect->left >= SourceRect->right || SourceRect->top >= SourceRect->bottom) { - DPRINT1("Empty source rectangle!\n"); - return FALSE; + DPRINT1("Empty source rectangle!\n"); + return FALSE; } - if (Dest == Source && - !(DestRect->left >= SourceRect->right || SourceRect->left >= DestRect->right || - DestRect->top >= SourceRect->bottom || SourceRect->top >= DestRect->bottom)) + if (Dest == Source && + !(DestRect->left >= SourceRect->right || SourceRect->left >= DestRect->right || + DestRect->top >= SourceRect->bottom || SourceRect->top >= DestRect->bottom)) { - DPRINT1("Source and destination rectangles overlap!\n"); - return FALSE; + DPRINT1("Source and destination rectangles overlap!\n"); + return FALSE; } - if (BlendObj->BlendFunction.BlendOp != AC_SRC_OVER) + if (BlendObj->BlendFunction.BlendOp != AC_SRC_OVER) { - DPRINT1("BlendOp != AC_SRC_OVER (0x%x)\n", BlendObj->BlendFunction.BlendOp); - return FALSE; + DPRINT1("BlendOp != AC_SRC_OVER (0x%x)\n", BlendObj->BlendFunction.BlendOp); + return FALSE; } - if (BlendObj->BlendFunction.BlendFlags != 0) + if (BlendObj->BlendFunction.BlendFlags != 0) { - DPRINT1("BlendFlags != 0 (0x%x)\n", BlendObj->BlendFunction.BlendFlags); - return FALSE; + DPRINT1("BlendFlags != 0 (0x%x)\n", BlendObj->BlendFunction.BlendFlags); + return FALSE; } - if ((BlendObj->BlendFunction.AlphaFormat & ~AC_SRC_ALPHA) != 0) + if ((BlendObj->BlendFunction.AlphaFormat & ~AC_SRC_ALPHA) != 0) { - DPRINT1("Unsupported AlphaFormat (0x%x)\n", BlendObj->BlendFunction.AlphaFormat); - return FALSE; + DPRINT1("Unsupported AlphaFormat (0x%x)\n", BlendObj->BlendFunction.AlphaFormat); + return FALSE; } - /* Check if there is anything to draw */ - if (ClipRegion != NULL && - (ClipRegion->rclBounds.left >= ClipRegion->rclBounds.right || - ClipRegion->rclBounds.top >= ClipRegion->rclBounds.bottom)) + /* Check if there is anything to draw */ + if (ClipRegion != NULL && + (ClipRegion->rclBounds.left >= ClipRegion->rclBounds.right || + ClipRegion->rclBounds.top >= ClipRegion->rclBounds.bottom)) { - /* Nothing to do */ - return TRUE; + /* Nothing to do */ + return TRUE; } - /* Stretch source if needed */ - if (DestRect->right - DestRect->left != SourceRect->right - SourceRect->left || - DestRect->bottom - DestRect->top != SourceRect->bottom - SourceRect->top) + /* Stretch source if needed */ + if (DestRect->right - DestRect->left != SourceRect->right - SourceRect->left || + DestRect->bottom - DestRect->top != SourceRect->bottom - SourceRect->top) { - SourceStretchedSize.cx = DestRect->right - DestRect->left; - SourceStretchedSize.cy = DestRect->bottom - DestRect->top; - Width = DIB_GetDIBWidthBytes(SourceStretchedSize.cx, BitsPerFormat(Source->iBitmapFormat)); - /* FIXME: Maybe it is a good idea to use EngCreateDeviceBitmap and IntEngStretchBlt - if possible to get a HW accelerated stretch. */ - SourceStretchedBitmap = EngCreateBitmap(SourceStretchedSize, Width, Source->iBitmapFormat, - BMF_TOPDOWN | BMF_NOZEROINIT, NULL); - if (SourceStretchedBitmap == 0) + SourceStretchedSize.cx = DestRect->right - DestRect->left; + SourceStretchedSize.cy = DestRect->bottom - DestRect->top; + Width = DIB_GetDIBWidthBytes(SourceStretchedSize.cx, BitsPerFormat(Source->iBitmapFormat)); + /* FIXME: Maybe it is a good idea to use EngCreateDeviceBitmap and IntEngStretchBlt + if possible to get a HW accelerated stretch. */ + SourceStretchedBitmap = EngCreateBitmap(SourceStretchedSize, Width, Source->iBitmapFormat, + BMF_TOPDOWN | BMF_NOZEROINIT, NULL); + if (SourceStretchedBitmap == 0) { - DPRINT1("EngCreateBitmap failed!\n"); - return FALSE; + DPRINT1("EngCreateBitmap failed!\n"); + return FALSE; } - SourceStretchedObj = EngLockSurface((HSURF)SourceStretchedBitmap); - if (SourceStretchedObj == NULL) + SourceStretchedObj = EngLockSurface((HSURF)SourceStretchedBitmap); + if (SourceStretchedObj == NULL) { - DPRINT1("EngLockSurface failed!\n"); - EngDeleteSurface((HSURF)SourceStretchedBitmap); - return FALSE; + DPRINT1("EngLockSurface failed!\n"); + EngDeleteSurface((HSURF)SourceStretchedBitmap); + return FALSE; } - SourceStretchedRect.left = 0; - SourceStretchedRect.right = SourceStretchedSize.cx; - SourceStretchedRect.top = 0; - SourceStretchedRect.bottom = SourceStretchedSize.cy; - /* FIXME: IntEngStretchBlt isn't used here atm because it results in a - try to acquire an already acquired mutex (lock the already locked source surface) */ - /*if (!IntEngStretchBlt(SourceStretchedObj, Source, NULL, NULL, - NULL, &SourceStretchedRect, SourceRect, NULL, - NULL, NULL, COLORONCOLOR))*/ - if (!EngStretchBlt(SourceStretchedObj, Source, NULL, NULL, NULL, - NULL, NULL, &SourceStretchedRect, SourceRect, - NULL, COLORONCOLOR)) + SourceStretchedRect.left = 0; + SourceStretchedRect.right = SourceStretchedSize.cx; + SourceStretchedRect.top = 0; + SourceStretchedRect.bottom = SourceStretchedSize.cy; + /* FIXME: IntEngStretchBlt isn't used here atm because it results in a + try to acquire an already acquired mutex (lock the already locked source surface) */ + /*if (!IntEngStretchBlt(SourceStretchedObj, Source, NULL, NULL, + NULL, &SourceStretchedRect, SourceRect, NULL, + NULL, NULL, COLORONCOLOR))*/ + if (!EngStretchBlt(SourceStretchedObj, Source, NULL, NULL, NULL, + NULL, NULL, &SourceStretchedRect, SourceRect, + NULL, COLORONCOLOR)) { - DPRINT1("EngStretchBlt failed!\n"); - EngFreeMem(SourceStretchedObj->pvBits); - EngUnlockSurface(SourceStretchedObj); - EngDeleteSurface((HSURF)SourceStretchedBitmap); - return FALSE; + DPRINT1("EngStretchBlt failed!\n"); + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); + EngDeleteSurface((HSURF)SourceStretchedBitmap); + return FALSE; } - SourceRect = &SourceStretchedRect; - Source = SourceStretchedObj; + SourceRect = &SourceStretchedRect; + Source = SourceStretchedObj; } - /* Now call the DIB function */ - InputRect.left = SourceRect->left; - InputRect.right = SourceRect->right; - InputRect.top = SourceRect->top; - InputRect.bottom = SourceRect->bottom; - if (!IntEngEnter(&EnterLeaveSource, Source, &InputRect, TRUE, &Translate, &InputObj)) + /* Now call the DIB function */ + InputRect.left = SourceRect->left; + InputRect.right = SourceRect->right; + InputRect.top = SourceRect->top; + InputRect.bottom = SourceRect->bottom; + if (!IntEngEnter(&EnterLeaveSource, Source, &InputRect, TRUE, &Translate, &InputObj)) { - if (SourceStretchedObj != NULL) + if (SourceStretchedObj != NULL) { - EngFreeMem(SourceStretchedObj->pvBits); - EngUnlockSurface(SourceStretchedObj); + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); } - if (SourceStretchedBitmap != 0) + if (SourceStretchedBitmap != 0) { - EngDeleteSurface((HSURF)SourceStretchedBitmap); + EngDeleteSurface((HSURF)SourceStretchedBitmap); } - return FALSE; + return FALSE; } - InputRect.left = SourceRect->left + Translate.x; - InputRect.right = SourceRect->right + Translate.x; - InputRect.top = SourceRect->top + Translate.y; - InputRect.bottom = SourceRect->bottom + Translate.y; + InputRect.left = SourceRect->left + Translate.x; + InputRect.right = SourceRect->right + Translate.x; + InputRect.top = SourceRect->top + Translate.y; + InputRect.bottom = SourceRect->bottom + Translate.y; - OutputRect.left = DestRect->left; - OutputRect.right = DestRect->right; - OutputRect.top = DestRect->top; - OutputRect.bottom = DestRect->bottom; - if (!IntEngEnter(&EnterLeaveDest, Dest, &OutputRect, FALSE, &Translate, &OutputObj)) + OutputRect.left = DestRect->left; + OutputRect.right = DestRect->right; + OutputRect.top = DestRect->top; + OutputRect.bottom = DestRect->bottom; + if (!IntEngEnter(&EnterLeaveDest, Dest, &OutputRect, FALSE, &Translate, &OutputObj)) { - IntEngLeave(&EnterLeaveSource); - if (SourceStretchedObj != NULL) + IntEngLeave(&EnterLeaveSource); + if (SourceStretchedObj != NULL) { - EngFreeMem(SourceStretchedObj->pvBits); - EngUnlockSurface(SourceStretchedObj); + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); } - if (SourceStretchedBitmap != 0) + if (SourceStretchedBitmap != 0) { - EngDeleteSurface((HSURF)SourceStretchedBitmap); + EngDeleteSurface((HSURF)SourceStretchedBitmap); } - return FALSE; + return FALSE; } - OutputRect.left = DestRect->left + Translate.x; - OutputRect.right = DestRect->right + Translate.x; - OutputRect.top = DestRect->top + Translate.y; - OutputRect.bottom = DestRect->bottom + Translate.y; + OutputRect.left = DestRect->left + Translate.x; + OutputRect.right = DestRect->right + Translate.x; + OutputRect.top = DestRect->top + Translate.y; + OutputRect.bottom = DestRect->bottom + Translate.y; - Ret = FALSE; - ClippingType = (ClipRegion == NULL) ? DC_TRIVIAL : ClipRegion->iDComplexity; - switch(ClippingType) + Ret = FALSE; + ClippingType = (ClipRegion == NULL) ? DC_TRIVIAL : ClipRegion->iDComplexity; + switch (ClippingType) { - case DC_TRIVIAL: - Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( - OutputObj, InputObj, &OutputRect, &InputRect, ClipRegion, ColorTranslation, BlendObj); - break; + case DC_TRIVIAL: + Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( + OutputObj, InputObj, &OutputRect, &InputRect, ClipRegion, ColorTranslation, BlendObj); + break; - case DC_RECT: - ClipRect.left = ClipRegion->rclBounds.left + Translate.x; - ClipRect.right = ClipRegion->rclBounds.right + Translate.x; - ClipRect.top = ClipRegion->rclBounds.top + Translate.y; - ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y; - if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) - { - Rect.left = InputRect.left + CombinedRect.left - OutputRect.left; - Rect.right = InputRect.right + CombinedRect.right - OutputRect.right; - Rect.top = InputRect.top + CombinedRect.top - OutputRect.top; - Rect.bottom = InputRect.bottom + CombinedRect.bottom - OutputRect.bottom; - Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( - OutputObj, InputObj, &CombinedRect, &Rect, ClipRegion, ColorTranslation, BlendObj); - } - break; - - case DC_COMPLEX: - Ret = TRUE; - CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, CD_ANY, 0); - do - { - EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), - (PVOID) &RectEnum); - - for (i = 0; i < RectEnum.c; i++) + case DC_RECT: + ClipRect.left = ClipRegion->rclBounds.left + Translate.x; + ClipRect.right = ClipRegion->rclBounds.right + Translate.x; + ClipRect.top = ClipRegion->rclBounds.top + Translate.y; + ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) { - ClipRect.left = RectEnum.arcl[i].left + Translate.x; - ClipRect.right = RectEnum.arcl[i].right + Translate.x; - ClipRect.top = RectEnum.arcl[i].top + Translate.y; - ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y; - if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + Rect.left = InputRect.left + CombinedRect.left - OutputRect.left; + Rect.right = InputRect.right + CombinedRect.right - OutputRect.right; + Rect.top = InputRect.top + CombinedRect.top - OutputRect.top; + Rect.bottom = InputRect.bottom + CombinedRect.bottom - OutputRect.bottom; + Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( + OutputObj, InputObj, &CombinedRect, &Rect, ClipRegion, ColorTranslation, BlendObj); + } + break; + + case DC_COMPLEX: + Ret = TRUE; + CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, CD_ANY, 0); + do + { + EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), + (PVOID) &RectEnum); + + for (i = 0; i < RectEnum.c; i++) { - Rect.left = InputRect.left + CombinedRect.left - OutputRect.left; - Rect.right = InputRect.right + CombinedRect.right - OutputRect.right; - Rect.top = InputRect.top + CombinedRect.top - OutputRect.top; - Rect.bottom = InputRect.bottom + CombinedRect.bottom - OutputRect.bottom; - Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( - OutputObj, InputObj, &CombinedRect, &Rect, ClipRegion, ColorTranslation, BlendObj) && Ret; + ClipRect.left = RectEnum.arcl[i].left + Translate.x; + ClipRect.right = RectEnum.arcl[i].right + Translate.x; + ClipRect.top = RectEnum.arcl[i].top + Translate.y; + ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + { + Rect.left = InputRect.left + CombinedRect.left - OutputRect.left; + Rect.right = InputRect.right + CombinedRect.right - OutputRect.right; + Rect.top = InputRect.top + CombinedRect.top - OutputRect.top; + Rect.bottom = InputRect.bottom + CombinedRect.bottom - OutputRect.bottom; + Ret = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_AlphaBlend( + OutputObj, InputObj, &CombinedRect, &Rect, ClipRegion, ColorTranslation, BlendObj) && Ret; + } } } - } - while(EnumMore); - break; + while (EnumMore); + break; - default: - UNIMPLEMENTED; - ASSERT(FALSE); - break; + default: + UNIMPLEMENTED; + ASSERT(FALSE); + break; } - IntEngLeave(&EnterLeaveDest); - IntEngLeave(&EnterLeaveSource); + IntEngLeave(&EnterLeaveDest); + IntEngLeave(&EnterLeaveSource); - if (SourceStretchedObj != NULL) + if (SourceStretchedObj != NULL) { - EngFreeMem(SourceStretchedObj->pvBits); - EngUnlockSurface(SourceStretchedObj); + EngFreeMem(SourceStretchedObj->pvBits); + EngUnlockSurface(SourceStretchedObj); } - if (SourceStretchedBitmap != 0) + if (SourceStretchedBitmap != 0) { - EngDeleteSurface((HSURF)SourceStretchedBitmap); + EngDeleteSurface((HSURF)SourceStretchedBitmap); } - return Ret; + return Ret; } BOOL STDCALL @@ -1152,60 +1152,60 @@ IntEngAlphaBlend(IN SURFOBJ *Dest, IN PRECTL SourceRect, IN BLENDOBJ *BlendObj) { - BOOL ret = FALSE; - BITMAPOBJ *DestObj; - BITMAPOBJ *SourceObj; + BOOL ret = FALSE; + BITMAPOBJ *DestObj; + BITMAPOBJ *SourceObj; - ASSERT(Dest); - DestObj = CONTAINING_RECORD(Dest, BITMAPOBJ, SurfObj); - ASSERT(DestObj); + ASSERT(Dest); + DestObj = CONTAINING_RECORD(Dest, BITMAPOBJ, SurfObj); + ASSERT(DestObj); - ASSERT(Source); - SourceObj = CONTAINING_RECORD(Source, BITMAPOBJ, SurfObj); - ASSERT(SourceObj); + ASSERT(Source); + SourceObj = CONTAINING_RECORD(Source, BITMAPOBJ, SurfObj); + ASSERT(SourceObj); - ASSERT(DestRect); - ASSERT(SourceRect); + ASSERT(DestRect); + ASSERT(SourceRect); - /* Check if there is anything to draw */ - if (ClipRegion != NULL && - (ClipRegion->rclBounds.left >= ClipRegion->rclBounds.right || - ClipRegion->rclBounds.top >= ClipRegion->rclBounds.bottom)) + /* Check if there is anything to draw */ + if (ClipRegion != NULL && + (ClipRegion->rclBounds.left >= ClipRegion->rclBounds.right || + ClipRegion->rclBounds.top >= ClipRegion->rclBounds.bottom)) { - /* Nothing to do */ - return TRUE; + /* Nothing to do */ + return TRUE; } - BITMAPOBJ_LockBitmapBits(DestObj); - MouseSafetyOnDrawStart(Dest, DestRect->left, DestRect->top, - DestRect->right, DestRect->bottom); + BITMAPOBJ_LockBitmapBits(DestObj); + MouseSafetyOnDrawStart(Dest, DestRect->left, DestRect->top, + DestRect->right, DestRect->bottom); - if (Source != Dest) - BITMAPOBJ_LockBitmapBits(SourceObj); - MouseSafetyOnDrawStart(Source, SourceRect->left, SourceRect->top, - SourceRect->right, SourceRect->bottom); + if (Source != Dest) + BITMAPOBJ_LockBitmapBits(SourceObj); + MouseSafetyOnDrawStart(Source, SourceRect->left, SourceRect->top, + SourceRect->right, SourceRect->bottom); - /* Call the driver's DrvAlphaBlend if available */ - if (DestObj->flHooks & HOOK_ALPHABLEND) + /* Call the driver's DrvAlphaBlend if available */ + if (DestObj->flHooks & HOOK_ALPHABLEND) { - ret = GDIDEVFUNCS(Dest).AlphaBlend( - Dest, Source, ClipRegion, ColorTranslation, - DestRect, SourceRect, BlendObj); + ret = GDIDEVFUNCS(Dest).AlphaBlend( + Dest, Source, ClipRegion, ColorTranslation, + DestRect, SourceRect, BlendObj); } - if (! ret) + if (! ret) { - ret = EngAlphaBlend(Dest, Source, ClipRegion, ColorTranslation, - DestRect, SourceRect, BlendObj); + ret = EngAlphaBlend(Dest, Source, ClipRegion, ColorTranslation, + DestRect, SourceRect, BlendObj); } - MouseSafetyOnDrawEnd(Source); - if (Source != Dest) - BITMAPOBJ_UnlockBitmapBits(SourceObj); - MouseSafetyOnDrawEnd(Dest); - BITMAPOBJ_UnlockBitmapBits(DestObj); + MouseSafetyOnDrawEnd(Source); + if (Source != Dest) + BITMAPOBJ_UnlockBitmapBits(SourceObj); + MouseSafetyOnDrawEnd(Dest); + BITMAPOBJ_UnlockBitmapBits(DestObj); - return ret; + return ret; } /**** REACTOS FONT RENDERING CODE *********************************************/ @@ -1213,289 +1213,289 @@ IntEngAlphaBlend(IN SURFOBJ *Dest, /* renders the alpha mask bitmap */ static BOOLEAN STDCALL AlphaBltMask(SURFOBJ* Dest, - SURFOBJ* Source, - SURFOBJ* Mask, - XLATEOBJ* ColorTranslation, - XLATEOBJ* SrcColorTranslation, - RECTL* DestRect, - POINTL* SourcePoint, - POINTL* MaskPoint, - BRUSHOBJ* Brush, - POINTL* BrushPoint) + SURFOBJ* Source, + SURFOBJ* Mask, + XLATEOBJ* ColorTranslation, + XLATEOBJ* SrcColorTranslation, + RECTL* DestRect, + POINTL* SourcePoint, + POINTL* MaskPoint, + BRUSHOBJ* Brush, + POINTL* BrushPoint) { - LONG i, j, dx, dy; - int r, g, b; - ULONG Background, BrushColor, NewColor; - BYTE *tMask, *lMask; + LONG i, j, dx, dy; + int r, g, b; + ULONG Background, BrushColor, NewColor; + BYTE *tMask, *lMask; - dx = DestRect->right - DestRect->left; - dy = DestRect->bottom - DestRect->top; + dx = DestRect->right - DestRect->left; + dy = DestRect->bottom - DestRect->top; - if (Mask != NULL) + if (Mask != NULL) { - BrushColor = XLATEOBJ_iXlate(SrcColorTranslation, Brush->iSolidColor); - r = (int)GetRValue(BrushColor); - g = (int)GetGValue(BrushColor); - b = (int)GetBValue(BrushColor); + BrushColor = XLATEOBJ_iXlate(SrcColorTranslation, Brush->iSolidColor); + r = (int)GetRValue(BrushColor); + g = (int)GetGValue(BrushColor); + b = (int)GetBValue(BrushColor); - tMask = (PBYTE)Mask->pvScan0 + (SourcePoint->y * Mask->lDelta) + SourcePoint->x; - for (j = 0; j < dy; j++) + tMask = (PBYTE)Mask->pvScan0 + (SourcePoint->y * Mask->lDelta) + SourcePoint->x; + for (j = 0; j < dy; j++) { - lMask = tMask; - for (i = 0; i < dx; i++) + lMask = tMask; + for (i = 0; i < dx; i++) { - if (*lMask > 0) + if (*lMask > 0) { - if (*lMask == 0xff) + if (*lMask == 0xff) { - DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( - Dest, DestRect->left + i, DestRect->top + j, Brush->iSolidColor); + DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( + Dest, DestRect->left + i, DestRect->top + j, Brush->iSolidColor); } - else + else { - Background = DIB_GetSource(Dest, DestRect->left + i, DestRect->top + j, - SrcColorTranslation); + Background = DIB_GetSource(Dest, DestRect->left + i, DestRect->top + j, + SrcColorTranslation); - NewColor = - RGB((*lMask * (r - GetRValue(Background)) >> 8) + GetRValue(Background), - (*lMask * (g - GetGValue(Background)) >> 8) + GetGValue(Background), - (*lMask * (b - GetBValue(Background)) >> 8) + GetBValue(Background)); + NewColor = + RGB((*lMask * (r - GetRValue(Background)) >> 8) + GetRValue(Background), + (*lMask * (g - GetGValue(Background)) >> 8) + GetGValue(Background), + (*lMask * (b - GetBValue(Background)) >> 8) + GetBValue(Background)); - Background = XLATEOBJ_iXlate(ColorTranslation, NewColor); - DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( - Dest, DestRect->left + i, DestRect->top + j, Background); + Background = XLATEOBJ_iXlate(ColorTranslation, NewColor); + DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( + Dest, DestRect->left + i, DestRect->top + j, Background); } } - lMask++; + lMask++; } - tMask += Mask->lDelta; + tMask += Mask->lDelta; } - return TRUE; + return TRUE; } - else + else { - return FALSE; + return FALSE; } } BOOL STDCALL EngMaskBitBlt(SURFOBJ *DestObj, - SURFOBJ *Mask, - CLIPOBJ *ClipRegion, - XLATEOBJ *DestColorTranslation, - XLATEOBJ *SourceColorTranslation, - RECTL *DestRect, - POINTL *SourcePoint, - POINTL *MaskOrigin, - BRUSHOBJ *Brush, - POINTL *BrushOrigin) + SURFOBJ *Mask, + CLIPOBJ *ClipRegion, + XLATEOBJ *DestColorTranslation, + XLATEOBJ *SourceColorTranslation, + RECTL *DestRect, + POINTL *SourcePoint, + POINTL *MaskOrigin, + BRUSHOBJ *Brush, + POINTL *BrushOrigin) { - BYTE clippingType; - RECTL CombinedRect; - RECT_ENUM RectEnum; - BOOL EnumMore; - POINTL InputPoint; - RECTL InputRect; - RECTL OutputRect; - POINTL Translate; - INTENG_ENTER_LEAVE EnterLeaveSource; - INTENG_ENTER_LEAVE EnterLeaveDest; - SURFOBJ* InputObj; - SURFOBJ* OutputObj; - BOOLEAN Ret = TRUE; - RECTL ClipRect; - unsigned i; - POINTL Pt; - ULONG Direction; - POINTL AdjustedBrushOrigin; + BYTE clippingType; + RECTL CombinedRect; + RECT_ENUM RectEnum; + BOOL EnumMore; + POINTL InputPoint; + RECTL InputRect; + RECTL OutputRect; + POINTL Translate; + INTENG_ENTER_LEAVE EnterLeaveSource; + INTENG_ENTER_LEAVE EnterLeaveDest; + SURFOBJ* InputObj; + SURFOBJ* OutputObj; + BOOLEAN Ret = TRUE; + RECTL ClipRect; + unsigned i; + POINTL Pt; + ULONG Direction; + POINTL AdjustedBrushOrigin; - ASSERT ( Mask ); + ASSERT ( Mask ); - if (NULL != SourcePoint) + if (NULL != SourcePoint) { - InputRect.left = SourcePoint->x; - InputRect.right = SourcePoint->x + (DestRect->right - DestRect->left); - InputRect.top = SourcePoint->y; - InputRect.bottom = SourcePoint->y + (DestRect->bottom - DestRect->top); + InputRect.left = SourcePoint->x; + InputRect.right = SourcePoint->x + (DestRect->right - DestRect->left); + InputRect.top = SourcePoint->y; + InputRect.bottom = SourcePoint->y + (DestRect->bottom - DestRect->top); } - else + else { - InputRect.left = 0; - InputRect.right = DestRect->right - DestRect->left; - InputRect.top = 0; - InputRect.bottom = DestRect->bottom - DestRect->top; + InputRect.left = 0; + InputRect.right = DestRect->right - DestRect->left; + InputRect.top = 0; + InputRect.bottom = DestRect->bottom - DestRect->top; } - if (! IntEngEnter(&EnterLeaveSource, DestObj, &InputRect, TRUE, &Translate, &InputObj)) + if (! IntEngEnter(&EnterLeaveSource, DestObj, &InputRect, TRUE, &Translate, &InputObj)) { - return FALSE; + return FALSE; } - if (NULL != SourcePoint) + if (NULL != SourcePoint) { - InputPoint.x = SourcePoint->x + Translate.x; - InputPoint.y = SourcePoint->y + Translate.y; + InputPoint.x = SourcePoint->x + Translate.x; + InputPoint.y = SourcePoint->y + Translate.y; } - else + else { - InputPoint.x = 0; - InputPoint.y = 0; + InputPoint.x = 0; + InputPoint.y = 0; } - OutputRect = *DestRect; - if (NULL != ClipRegion) + OutputRect = *DestRect; + if (NULL != ClipRegion) { - if (OutputRect.left < ClipRegion->rclBounds.left) - { - InputRect.left += ClipRegion->rclBounds.left - OutputRect.left; - InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left; - OutputRect.left = ClipRegion->rclBounds.left; - } - if (ClipRegion->rclBounds.right < OutputRect.right) - { - InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right; - OutputRect.right = ClipRegion->rclBounds.right; - } - if (OutputRect.top < ClipRegion->rclBounds.top) - { - InputRect.top += ClipRegion->rclBounds.top - OutputRect.top; - InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top; - OutputRect.top = ClipRegion->rclBounds.top; - } - if (ClipRegion->rclBounds.bottom < OutputRect.bottom) - { - InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom; - OutputRect.bottom = ClipRegion->rclBounds.bottom; - } - } - - /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's - nothing to do */ - if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top) - { - IntEngLeave(&EnterLeaveSource); - return TRUE; - } - - if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, &OutputObj)) - { - IntEngLeave(&EnterLeaveSource); - return FALSE; - } - - OutputRect.left = DestRect->left + Translate.x; - OutputRect.right = DestRect->right + Translate.x; - OutputRect.top = DestRect->top + Translate.y; - OutputRect.bottom = DestRect->bottom + Translate.y; - - if(BrushOrigin) - { - AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x; - AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y; - } - else - AdjustedBrushOrigin = Translate; - - // Determine clipping type - if (ClipRegion == (CLIPOBJ *) NULL) - { - clippingType = DC_TRIVIAL; - } else { - clippingType = ClipRegion->iDComplexity; - } - - switch(clippingType) - { - case DC_TRIVIAL: - if(Mask->iBitmapFormat == BMF_8BPP) - Ret = AlphaBltMask(OutputObj, InputObj, Mask, DestColorTranslation, SourceColorTranslation, - &OutputRect, &InputPoint, MaskOrigin, Brush, &AdjustedBrushOrigin); - else - Ret = BltMask(OutputObj, InputObj, Mask, DestColorTranslation, - &OutputRect, &InputPoint, MaskOrigin, Brush, &AdjustedBrushOrigin, - R4_MASK); - break; - case DC_RECT: - // Clip the blt to the clip rectangle - ClipRect.left = ClipRegion->rclBounds.left + Translate.x; - ClipRect.right = ClipRegion->rclBounds.right + Translate.x; - ClipRect.top = ClipRegion->rclBounds.top + Translate.y; - ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y; - if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + if (OutputRect.left < ClipRegion->rclBounds.left) { - Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; - Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; - if(Mask->iBitmapFormat == BMF_8BPP) - { - Ret = AlphaBltMask(OutputObj, InputObj, Mask, DestColorTranslation, SourceColorTranslation, - &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin); - } - else - { - Ret = BltMask(OutputObj, InputObj, Mask, DestColorTranslation, - &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin, R4_MASK); - } + InputRect.left += ClipRegion->rclBounds.left - OutputRect.left; + InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left; + OutputRect.left = ClipRegion->rclBounds.left; } - break; - case DC_COMPLEX: - Ret = TRUE; - if (OutputObj == InputObj) - { - if (OutputRect.top < InputPoint.y) - { - Direction = OutputRect.left < InputPoint.x ? CD_RIGHTDOWN : CD_LEFTDOWN; - } - else - { - Direction = OutputRect.left < InputPoint.x ? CD_RIGHTUP : CD_LEFTUP; - } - } - else - { - Direction = CD_ANY; - } - CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0); - do - { - EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + if (ClipRegion->rclBounds.right < OutputRect.right) + { + InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right; + OutputRect.right = ClipRegion->rclBounds.right; + } + if (OutputRect.top < ClipRegion->rclBounds.top) + { + InputRect.top += ClipRegion->rclBounds.top - OutputRect.top; + InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top; + OutputRect.top = ClipRegion->rclBounds.top; + } + if (ClipRegion->rclBounds.bottom < OutputRect.bottom) + { + InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom; + OutputRect.bottom = ClipRegion->rclBounds.bottom; + } + } - for (i = 0; i < RectEnum.c; i++) - { - ClipRect.left = RectEnum.arcl[i].left + Translate.x; - ClipRect.right = RectEnum.arcl[i].right + Translate.x; - ClipRect.top = RectEnum.arcl[i].top + Translate.y; - ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y; - if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's + nothing to do */ + if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top) + { + IntEngLeave(&EnterLeaveSource); + return TRUE; + } + + if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, &OutputObj)) + { + IntEngLeave(&EnterLeaveSource); + return FALSE; + } + + OutputRect.left = DestRect->left + Translate.x; + OutputRect.right = DestRect->right + Translate.x; + OutputRect.top = DestRect->top + Translate.y; + OutputRect.bottom = DestRect->bottom + Translate.y; + + if (BrushOrigin) + { + AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x; + AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y; + } + else + AdjustedBrushOrigin = Translate; + + // Determine clipping type + if (ClipRegion == (CLIPOBJ *) NULL) + { + clippingType = DC_TRIVIAL; + } else { + clippingType = ClipRegion->iDComplexity; + } + + switch (clippingType) + { + case DC_TRIVIAL: + if (Mask->iBitmapFormat == BMF_8BPP) + Ret = AlphaBltMask(OutputObj, InputObj, Mask, DestColorTranslation, SourceColorTranslation, + &OutputRect, &InputPoint, MaskOrigin, Brush, &AdjustedBrushOrigin); + else + Ret = BltMask(OutputObj, InputObj, Mask, DestColorTranslation, + &OutputRect, &InputPoint, MaskOrigin, Brush, &AdjustedBrushOrigin, + R4_MASK); + break; + case DC_RECT: + // Clip the blt to the clip rectangle + ClipRect.left = ClipRegion->rclBounds.left + Translate.x; + ClipRect.right = ClipRegion->rclBounds.right + Translate.x; + ClipRect.top = ClipRegion->rclBounds.top + Translate.y; + ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) + { + Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; + Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; + if (Mask->iBitmapFormat == BMF_8BPP) { - Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; - Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; - if(Mask->iBitmapFormat == BMF_8BPP) + Ret = AlphaBltMask(OutputObj, InputObj, Mask, DestColorTranslation, SourceColorTranslation, + &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin); + } + else + { + Ret = BltMask(OutputObj, InputObj, Mask, DestColorTranslation, + &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin, R4_MASK); + } + } + break; + case DC_COMPLEX: + Ret = TRUE; + if (OutputObj == InputObj) + { + if (OutputRect.top < InputPoint.y) + { + Direction = OutputRect.left < InputPoint.x ? CD_RIGHTDOWN : CD_LEFTDOWN; + } + else + { + Direction = OutputRect.left < InputPoint.x ? CD_RIGHTUP : CD_LEFTUP; + } + } + else + { + Direction = CD_ANY; + } + CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0); + do + { + EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), (PVOID) &RectEnum); + + for (i = 0; i < RectEnum.c; i++) + { + ClipRect.left = RectEnum.arcl[i].left + Translate.x; + ClipRect.right = RectEnum.arcl[i].right + Translate.x; + ClipRect.top = RectEnum.arcl[i].top + Translate.y; + ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y; + if (EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect)) { - Ret = AlphaBltMask(OutputObj, InputObj, Mask, - DestColorTranslation, - SourceColorTranslation, - &CombinedRect, &Pt, MaskOrigin, Brush, - &AdjustedBrushOrigin) && Ret; - } - else - { - Ret = BltMask(OutputObj, InputObj, Mask, - DestColorTranslation, &CombinedRect, &Pt, - MaskOrigin, Brush, &AdjustedBrushOrigin, - R4_MASK) && Ret; + Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left; + Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top; + if (Mask->iBitmapFormat == BMF_8BPP) + { + Ret = AlphaBltMask(OutputObj, InputObj, Mask, + DestColorTranslation, + SourceColorTranslation, + &CombinedRect, &Pt, MaskOrigin, Brush, + &AdjustedBrushOrigin) && Ret; + } + else + { + Ret = BltMask(OutputObj, InputObj, Mask, + DestColorTranslation, &CombinedRect, &Pt, + MaskOrigin, Brush, &AdjustedBrushOrigin, + R4_MASK) && Ret; + } } } - } - } - while(EnumMore); - break; - } + } + while (EnumMore); + break; + } - IntEngLeave(&EnterLeaveDest); - IntEngLeave(&EnterLeaveSource); + IntEngLeave(&EnterLeaveDest); + IntEngLeave(&EnterLeaveSource); - return Ret; + return Ret; } BOOL STDCALL @@ -1510,61 +1510,61 @@ IntEngMaskBlt(SURFOBJ *DestSurf, BRUSHOBJ *Brush, POINTL *BrushOrigin) { - BOOLEAN ret; - RECTL OutputRect; - POINTL InputPoint; - BITMAPOBJ *DestObj; + BOOLEAN ret; + RECTL OutputRect; + POINTL InputPoint; + BITMAPOBJ *DestObj; - ASSERT(Mask); + ASSERT(Mask); - if (NULL != SourcePoint) + if (NULL != SourcePoint) { - InputPoint = *SourcePoint; + InputPoint = *SourcePoint; } - /* Clip against the bounds of the clipping region so we won't try to write - * outside the surface */ - if (NULL != ClipRegion) + /* Clip against the bounds of the clipping region so we won't try to write + * outside the surface */ + if (NULL != ClipRegion) { - if (! EngIntersectRect(&OutputRect, DestRect, &ClipRegion->rclBounds)) - { - return TRUE; - } - InputPoint.x += OutputRect.left - DestRect->left; - InputPoint.y += OutputRect.top - DestRect->top; + if (! EngIntersectRect(&OutputRect, DestRect, &ClipRegion->rclBounds)) + { + return TRUE; + } + InputPoint.x += OutputRect.left - DestRect->left; + InputPoint.y += OutputRect.top - DestRect->top; } - else + else { - OutputRect = *DestRect; + OutputRect = *DestRect; } - /* No success yet */ - ret = FALSE; - ASSERT(DestSurf); - DestObj = CONTAINING_RECORD(DestSurf, BITMAPOBJ, SurfObj); + /* No success yet */ + ret = FALSE; + ASSERT(DestSurf); + DestObj = CONTAINING_RECORD(DestSurf, BITMAPOBJ, SurfObj); - BITMAPOBJ_LockBitmapBits(DestObj); - MouseSafetyOnDrawStart(DestSurf, OutputRect.left, OutputRect.top, - OutputRect.right, OutputRect.bottom); + BITMAPOBJ_LockBitmapBits(DestObj); + MouseSafetyOnDrawStart(DestSurf, OutputRect.left, OutputRect.top, + OutputRect.right, OutputRect.bottom); - /* Dummy BitBlt to let driver know that it should flush its changes. - This should really be done using a call to DrvSynchronizeSurface, - but the VMware driver doesn't hook that call. */ - IntEngBitBltEx(DestSurf, NULL, Mask, ClipRegion, DestColorTranslation, - DestRect, SourcePoint, MaskOrigin, Brush, BrushOrigin, - R4_NOOP, FALSE); + /* Dummy BitBlt to let driver know that it should flush its changes. + This should really be done using a call to DrvSynchronizeSurface, + but the VMware driver doesn't hook that call. */ + IntEngBitBltEx(DestSurf, NULL, Mask, ClipRegion, DestColorTranslation, + DestRect, SourcePoint, MaskOrigin, Brush, BrushOrigin, + R4_NOOP, FALSE); - ret = EngMaskBitBlt(DestSurf, Mask, ClipRegion, DestColorTranslation, SourceColorTranslation, - &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin); + ret = EngMaskBitBlt(DestSurf, Mask, ClipRegion, DestColorTranslation, SourceColorTranslation, + &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin); - /* Dummy BitBlt to let driver know that something has changed. */ - IntEngBitBltEx(DestSurf, NULL, Mask, ClipRegion, DestColorTranslation, - DestRect, SourcePoint, MaskOrigin, Brush, BrushOrigin, - R4_NOOP, FALSE); + /* Dummy BitBlt to let driver know that something has changed. */ + IntEngBitBltEx(DestSurf, NULL, Mask, ClipRegion, DestColorTranslation, + DestRect, SourcePoint, MaskOrigin, Brush, BrushOrigin, + R4_NOOP, FALSE); - MouseSafetyOnDrawEnd(DestSurf); - BITMAPOBJ_UnlockBitmapBits(DestObj); + MouseSafetyOnDrawEnd(DestSurf); + BITMAPOBJ_UnlockBitmapBits(DestObj); - return ret; + return ret; } /* EOF */