Attachment #70688 for issue #100888

View | Details | Raw Unified | Return to issue 100888
Collapse All | Expand All




        if(mpAlpha)
		{
			mpAlpha->EnableMapMode(false);
			const AlphaMask aAlphaMask(mpAlpha->GetBitmap(aEmptyPoint, aSizePixel));
		    
            if(bDoSaveForVisualControl)
		    {
			    SvFileStream aNew((const String&)String(ByteString( "c:\\transparence.bmp" ), RTL_TEXTENCODING_UTF8), STREAM_WRITE|STREAM_TRUNC);
			    aNew << aAlphaMask.GetBitmap();
		    }

			mrOutDev.DrawOutDevMasked( maDestPixel.TopLeft(), aSizePixel, aEmptyPoint, aSizePixel, maContent, *mpAlpha );
		}
		else if(mpMask)
		{

	{ 
		if(!mpAlpha)
		{
			mpAlpha = new VirtualDevice(mrOutDev, 8);
			mpAlpha->SetOutputSizePixel(maDestPixel.GetSize(), true);
			mpAlpha->SetMapMode(maContent.GetMapMode());


Lines 200-205 Link Here

(-)a/vcl/aqua/inc/salgdi.h (+1 lines)
200	// CopyBits and DrawBitmap --> RasterOp and ClipRegion	200	// CopyBits and DrawBitmap --> RasterOp and ClipRegion
201	// CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics	201	// CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics
202	virtual void copyBits( const SalTwoRect* pPosAry, SalGraphics* pSrcGraphics );	202	virtual void copyBits( const SalTwoRect* pPosAry, SalGraphics* pSrcGraphics );
		203	virtual bool blendBits( const SalTwoRect&, const SalGraphics& rSrcG, const SalGraphics& rMaskG );
203	virtual void drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap );	204	virtual void drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap );
204	virtual void drawBitmap( const SalTwoRect* pPosAry,	205	virtual void drawBitmap( const SalTwoRect* pPosAry,
205	const SalBitmap& rSalBitmap,	206	const SalBitmap& rSalBitmap,




    }
}

// --------------------------------------------------------------------------

bool AquaSalGraphics::blendBits( const SalTwoRect& rTR,
	const SalGraphics& rSrcGraphics, const SalGraphics& rMaskGraphics )
{
	ApplyXorContext();
	static_cast<AquaSalGraphics&>(const_cast<SalGraphics&>(rSrcGraphics)).ApplyXorContext();
	static_cast<AquaSalGraphics&>(const_cast<SalGraphics&>(rMaskGraphics)).ApplyXorContext();

	//#### TODO: implement blending fully
	return false;
}

// -----------------------------------------------------------------------

void AquaSalGraphics::copyArea( long nDstX, long nDstY,long nSrcX, long nSrcY, long nSrcWidth, long nSrcHeight, USHORT nFlags )

Lines 749-754 Link Here

(-)a/vcl/inc/vcl/outdev.hxx (+4 lines)
749	void DrawOutDev( const Point& rDestPt, const Size& rDestSize,	749	void DrawOutDev( const Point& rDestPt, const Size& rDestSize,
750	const Point& rSrcPt, const Size& rSrcSize,	750	const Point& rSrcPt, const Size& rSrcSize,
751	const OutputDevice& rOutDev );	751	const OutputDevice& rOutDev );
		752	void DrawOutDevMasked( const Point& rDestPt, const Size& rDestSize,
		753	const Point& rSrcPt, const Size& rSrcSize,
		754	const OutputDevice& rOutDev,
		755	const OutputDevice& rMaskOutDev );
752	void CopyArea( const Point& rDestPt,	756	void CopyArea( const Point& rDestPt,
753	const Point& rSrcPt, const Size& rSrcSize,	757	const Point& rSrcPt, const Size& rSrcSize,
754	USHORT nFlags = 0 );	758	USHORT nFlags = 0 );

Lines 136-142 Link Here

(-)a/vcl/inc/vcl/salgdi.hxx (-1 / +4 lines)
136		136
137	// CopyBits and DrawBitmap --> RasterOp and ClipRegion	137	// CopyBits and DrawBitmap --> RasterOp and ClipRegion
138	// CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics	138	// CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics
139	virtual void copyBits( const SalTwoRect* pPosAry, SalGraphics* pSrcGraphics ) = 0;	139	virtual void copyBits( const SalTwoRect, SalGraphics pSrcGraphics ) = 0;
		140	virtual bool blendBits( const SalTwoRect&, const SalGraphics& rSrc, const SalGraphics& rMask );
140	virtual void drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap ) = 0;	141	virtual void drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap ) = 0;
141	virtual void drawBitmap( const SalTwoRect* pPosAry,	142	virtual void drawBitmap( const SalTwoRect* pPosAry,
142	const SalBitmap& rSalBitmap,	143	const SalBitmap& rSalBitmap,
Lines 404-409 Link Here
404	SalGraphics* pSrcGraphics,	405	SalGraphics* pSrcGraphics,
405	const OutputDevice *pOutDev,	406	const OutputDevice *pOutDev,
406	const OutputDevice *pSrcOutDev );	407	const OutputDevice *pSrcOutDev );
		408	bool BlendBits( const SalTwoRect&, const SalGraphics& rSrcG, const SalGraphics& rMaskG,
		409	const OutputDevice* pDstDev, const OutputDevice* pSrcDev, const OutputDevice* pMaskDev );
407	void DrawBitmap( const SalTwoRect* pPosAry,	410	void DrawBitmap( const SalTwoRect* pPosAry,
408	const SalBitmap& rSalBitmap,	411	const SalBitmap& rSalBitmap,
409	const OutputDevice *pOutDev );	412	const OutputDevice *pOutDev );




#include <vcl/image.h>
#include <vcl/image.hxx>
#include <vcl/bmpfast.hxx>
#include <tools/debug.hxx>

#define BAND_MAX_SIZE 512000



// ------------------------------------------------------------------

void OutputDevice::DrawOutDevMasked( const Point& rDstPt, const Size& rDstSize,
    const Point& rSrcPt, const Size& rSrcSize,
    const OutputDevice& rSrcOutDev,
    const OutputDevice& rMaskOutDev )
{
	DBG_TRACE( "OutputDevice::DrawOutDev()" );
	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
	DBG_CHKOBJ( &rSrcOutDev, OutputDevice, ImplDbgCheckOutputDevice );
	DBG_CHKOBJ( &rMaskOutDev, OutputDevice, ImplDbgCheckOutputDevice );
	DBG_ASSERT( rDstSize == rSrcSize, "DrawOutDevMasked() only matched sizes implemented"); // not implemented
	DBG_ASSERT( !IsMapModeEnabled(), "DrawOutDevMasked() only pixel mapmode supported");
	DBG_ASSERT( !rSrcOutDev.IsMapModeEnabled(), "DrawOutDevMasked() only pixel mapmode supported");
	DBG_ASSERT( !rMaskOutDev.IsMapModeEnabled(), "DrawOutDevMasked() only pixel mapmode supported");

	OUTDEV_INIT();

	bool bDrawn = false;

	// #i112730# try fast SalGraphics method first
	if( !rSrcOutDev.mpGraphics )
		rSrcOutDev.ImplGetGraphics();
	if( !rMaskOutDev.mpGraphics )
		rMaskOutDev.ImplGetGraphics();
	if( !mpMetaFile
	&&  (meRasterOp == ROP_OVERPAINT)
	&&  (mpGraphics && rSrcOutDev.mpGraphics && rMaskOutDev.mpGraphics) )
	{
		SalTwoRect aPosAry;
		aPosAry.mnSrcX       = rSrcOutDev.ImplLogicXToDevicePixel( rSrcPt.X() );
		aPosAry.mnSrcY       = rSrcOutDev.ImplLogicYToDevicePixel( rSrcPt.Y() );
		aPosAry.mnSrcWidth   = rSrcOutDev.ImplLogicWidthToDevicePixel( rSrcSize.Width() );
		aPosAry.mnSrcHeight  = rSrcOutDev.ImplLogicHeightToDevicePixel( rSrcSize.Height() );
		aPosAry.mnDestX      = ImplLogicXToDevicePixel( rDstPt.X() );
		aPosAry.mnDestY      = ImplLogicYToDevicePixel( rDstPt.Y() );
		aPosAry.mnDestWidth  = ImplLogicWidthToDevicePixel( rDstSize.Width() );
		aPosAry.mnDestHeight = ImplLogicHeightToDevicePixel( rDstSize.Height() );

		bDrawn = mpGraphics->BlendBits( aPosAry, *rSrcOutDev.mpGraphics, *rMaskOutDev.mpGraphics,
										this, &rSrcOutDev, &rMaskOutDev );
	}

	if( !bDrawn ) // fallback to canonical method if needed
	{
		const Bitmap aSourceBmp = rSrcOutDev.GetBitmap( rSrcPt, rSrcSize );
		const AlphaMask aAlphaMask = rMaskOutDev.GetBitmap( rSrcPt, rSrcSize );
		const BitmapEx aBlendedBmp( aSourceBmp, aAlphaMask );
		DrawBitmapEx( rDstPt, aBlendedBmp );
	}
}

// ------------------------------------------------------------------

void OutputDevice::CopyArea( const Point& rDestPt,
							 const Point& rSrcPt,  const Size& rSrcSize,
							 USHORT nFlags )




	else
		copyBits( pPosAry, pSrcGraphics );
}

bool SalGraphics::BlendBits( const SalTwoRect& rPosAry,
	const SalGraphics& rSrcGraphics, const SalGraphics& rMaskGraphics,
	const OutputDevice* pDstOutDev, const OutputDevice* pSrcOutDev, const OutputDevice* pMaskOutDev )
{
	// fancy mirroring not yet implemented => request fallback
	if( (pDstOutDev && pDstOutDev->IsRTLEnabled())
	||  (pSrcOutDev && pSrcOutDev->IsRTLEnabled())
	||  (pMaskOutDev && pMaskOutDev->IsRTLEnabled()) )
		return false;
	if( (SAL_LAYOUT_BIDI_RTL & this->m_nLayout)
	||  (SAL_LAYOUT_BIDI_RTL & rSrcGraphics.m_nLayout)
	||  (SAL_LAYOUT_BIDI_RTL & rMaskGraphics.m_nLayout) )
		return false;

	bool bDrawn = blendBits( rPosAry, rSrcGraphics, rMaskGraphics );
	return bDrawn;
}

// default implementation for blending graphics
// to be overridden by derived classes
bool SalGraphics::blendBits( const SalTwoRect&, const SalGraphics&, const SalGraphics& )
{
	return false;
}

void	SalGraphics::DrawBitmap( const SalTwoRect* pPosAry,
									const SalBitmap& rSalBitmap, const OutputDevice *pOutDev )
{

Lines 89-95 Link Here

(-)a/vcl/unx/inc/salgdi.h (-2 / +5 lines)
89	Drawable hDrawable_; // use	89	Drawable hDrawable_; // use
90	int m_nScreen;	90	int m_nScreen;
91	void* m_pRenderFormat;	91	void* m_pRenderFormat;
92	XID m_aRenderPicture;	92	mutable XID m_aRenderPicture;
93	CairoFontsCache m_aCairoFontsCache;	93	CairoFontsCache m_aCairoFontsCache;
94		94
95	XLIB_Region pPaintRegion_;	95	XLIB_Region pPaintRegion_;
Lines 219-225 Link Here
219	inline const SalVisual& GetVisual() const;	219	inline const SalVisual& GetVisual() const;
220	inline Drawable GetDrawable() const { return hDrawable_; }	220	inline Drawable GetDrawable() const { return hDrawable_; }
221	void SetDrawable( Drawable d, int nScreen );	221	void SetDrawable( Drawable d, int nScreen );
222	XID GetXRenderPicture();	222	XID GetXRenderPicture() const;
223	void* GetXRenderFormat() const { return m_pRenderFormat; }	223	void* GetXRenderFormat() const { return m_pRenderFormat; }
224	inline void SetXRenderFormat( void* pRenderFormat ) { m_pRenderFormat = pRenderFormat; }	224	inline void SetXRenderFormat( void* pRenderFormat ) { m_pRenderFormat = pRenderFormat; }
225	inline const SalColormap& GetColormap() const { return *m_pColormap; }	225	inline const SalColormap& GetColormap() const { return *m_pColormap; }
Lines 319-324 Link Here
319	USHORT nFlags );	320	USHORT nFlags );
320	virtual void copyBits( const SalTwoRect* pPosAry,	321	virtual void copyBits( const SalTwoRect* pPosAry,
321	SalGraphics* pSrcGraphics );	322	SalGraphics* pSrcGraphics );
		323	virtual bool blendBits( const SalTwoRect&,
		324	const SalGraphics& rSrcG,
		325	const SalGraphics& rMaskG );
322	virtual void drawBitmap( const SalTwoRect* pPosAry,	326	virtual void drawBitmap( const SalTwoRect* pPosAry,
323	const SalBitmap& rSalBitmap );	327	const SalBitmap& rSalBitmap );
324	virtual void drawBitmap( const SalTwoRect* pPosAry,	328	virtual void drawBitmap( const SalTwoRect* pPosAry,





// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

XID X11SalGraphics::GetXRenderPicture( void) const
{
	XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();


			if( !pVisualFormat )
				return 0;
			// cache the XRenderPictFormat
			const_cast<X11SalGraphics&>(*this).SetXRenderFormat( static_cast<void*>(pVisualFormat) );
		}

		// cache the matching xrender target for drawable
		m_aRenderPicture = rRenderPeer.CreatePicture( hDrawable_, pVisualFormat, 0, NULL );
	}





    copyBits ( &aPosAry, 0 );
}

// --------------------------------------------------------------------------

bool X11SalGraphics::blendBits( const SalTwoRect& rTR,
	const SalGraphics& rSrcGraphics, const SalGraphics& rMaskGraphics )
{
    XRenderPeer& rPeer = XRenderPeer::GetInstance();
    if( rPeer.GetVersion() < 0x02 )
        return false;

	// TODO: use scoped RENDER-Pictures
    Picture aDstPic = GetXRenderPicture();
    if( !aDstPic )
        return false;

    Picture aSrcPic = static_cast<const X11SalGraphics&>(rSrcGraphics).GetXRenderPicture();
    if( !aSrcPic )
        return false;

    Picture aMaskPic = static_cast<const X11SalGraphics&>(rMaskGraphics).GetXRenderPicture();
    if( !aMaskPic )
        return false;

    // the GSL's transparency values are inverse to XRender's alpha values
    // TODO: make upper layers use standard alpha
    const XRenderColor aRenderColor = { 0, 0, 0, 0xFFFF };//GetXRenderColor( 0x000000 , 0 );
    rPeer.FillRectangle( PictOpOut, aMaskPic, &aRenderColor,
    	rTR.mnSrcX, rTR.mnSrcY, rTR.mnSrcWidth, rTR.mnSrcHeight );

    // set clipping
    if( pClipRegion_ && !XEmptyRegion( pClipRegion_ ) )
        rPeer.SetPictureClipRegion( aDstPic, pClipRegion_ );

    // TODO: eventually use XRenderSetPictureTransform() to scale the pictures

    // paint source * mask over destination picture
    rPeer.CompositePicture( PictOpOver, aSrcPic, aMaskPic, aDstPic,
        rTR.mnSrcX, rTR.mnSrcY, /*0,0,//#########*/rTR.mnSrcX, rTR.mnSrcY,
        rTR.mnDestX, rTR.mnDestY, rTR.mnDestWidth, rTR.mnDestHeight );

	return true;
}

// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
void X11SalGraphics::drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap )
{

Lines 40-45 Link Here

(-)a/vcl/unx/source/gdi/salvd.cxx (+31 lines)
40	#include <salvd.h>	40	#include <salvd.h>
41	#include <vcl/sysdata.hxx>	41	#include <vcl/sysdata.hxx>
42		42
		43	#include <xrender_peer.hxx>
		44
43	// -=-= SalInstance =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	45	// -=-= SalInstance =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
44	// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	46	// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
45	SalVirtualDevice* X11SalInstance::CreateVirtualDevice( SalGraphics* pGraphics,	47	SalVirtualDevice* X11SalInstance::CreateVirtualDevice( SalGraphics* pGraphics,
Lines 126-131 Link Here
126		128
127	bWindow_ = pDisplay->IsDisplay();	129	bWindow_ = pDisplay->IsDisplay();
128	bVirDev_ = TRUE;	130	bVirDev_ = TRUE;
		131
		132	// find a render format matching to the requested depth
		133	if( nDeviceDepth != nVisualDepth ) {
		134	int nRenderStdFmt = -1;
		135	switch( nDeviceDepth )
		136	{
		137	case 1: nRenderStdFmt = PictStandardA1; break;
		138	case 4: nRenderStdFmt = PictStandardA4; break;
		139	case 8: nRenderStdFmt = PictStandardA8; break;
		140	}
		141	if( nRenderStdFmt >= 0 )
		142	{
		143	XRenderPictFormat* pRenderFormat = XRenderPeer::GetInstance().FindStandardFormat( nRenderStdFmt );
		144	SetXRenderFormat( pRenderFormat );
		145	}
		146	}
129	}	147	}
130		148
131	// -=-= SalVirDevData / SalVirtualDevice -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	149	// -=-= SalVirDevData / SalVirtualDevice -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Lines 143-148 Link Here
143	pDisplay_ = pDisplay;	161	pDisplay_ = pDisplay;
144	pGraphics_ = new X11SalGraphics();	162	pGraphics_ = new X11SalGraphics();
145	m_nScreen = nScreen;	163	m_nScreen = nScreen;
		164	// find a render format matching to the requested depth
		165	if( !pRenderFormatVoid ) {
		166	int nRenderStdFmt = -1;
		167	switch( nBitCount )
		168	{
		169	case 1: nRenderStdFmt = PictStandardA1; break;
		170	case 4: nRenderStdFmt = PictStandardA4; break;
		171	case 8: nRenderStdFmt = PictStandardA8; break;
		172	}
		173	if( nRenderStdFmt >= 0 )
		174	pRenderFormatVoid = (void*)XRenderPeer::GetInstance().FindStandardFormat( nRenderStdFmt );
		175	}
		176	// set the render format
146	if( pRenderFormatVoid ) {	177	if( pRenderFormatVoid ) {
147	XRenderPictFormat pRenderFormat = ( XRenderPictFormat )pRenderFormatVoid;	178	XRenderPictFormat pRenderFormat = ( XRenderPictFormat )pRenderFormatVoid;
148	pGraphics_->SetXRenderFormat( pRenderFormat );	179	pGraphics_->SetXRenderFormat( pRenderFormat );

Lines 206-211 Link Here

(-)a/vcl/win/inc/salgdi.h (+1 lines)
206	// CopyBits and DrawBitmap --> RasterOp and ClipRegion	206	// CopyBits and DrawBitmap --> RasterOp and ClipRegion
207	// CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics	207	// CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics
208	virtual void copyBits( const SalTwoRect* pPosAry, SalGraphics* pSrcGraphics );	208	virtual void copyBits( const SalTwoRect* pPosAry, SalGraphics* pSrcGraphics );
		209	virtual bool blendBits( const SalTwoRect&, const SalGraphics& rSrcG, const SalGraphics& rMaskG );
209	virtual void drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap );	210	virtual void drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap );
210	virtual void drawBitmap( const SalTwoRect* pPosAry,	211	virtual void drawBitmap( const SalTwoRect* pPosAry,
211	const SalBitmap& rSalBitmap,	212	const SalBitmap& rSalBitmap,

Lines 99-104 Link Here

(-)a/vcl/win/source/gdi/salgdi2.cxx (+9 lines)
99	}	99	}
100	}	100	}
101		101
		102	// --------------------------------------------------------------------------
		103
		104	bool WinSalGraphics::blendBits( const SalTwoRect& rTR,
		105	const SalGraphics& rSrcGraphics, const SalGraphics& rMaskGraphics )
		106	{
		107	//#### TODO: implement
		108	return false;
		109	}
		110
102	// -----------------------------------------------------------------------	111	// -----------------------------------------------------------------------
103		112
104	void ImplCalcOutSideRgn( const RECT& rSrcRect,	113	void ImplCalcOutSideRgn( const RECT& rSrcRect,

Return to issue 100888

Lines 1147-1152 Link Here

(-)a/vcl/aqua/source/gdi/salgdi.cxx (+13 lines)
1147	}	1147	}
1148	}	1148	}
1149		1149
		1150	// --------------------------------------------------------------------------
		1151
		1152	bool AquaSalGraphics::blendBits( const SalTwoRect& rTR,
		1153	const SalGraphics& rSrcGraphics, const SalGraphics& rMaskGraphics )
		1154	{
		1155	ApplyXorContext();
		1156	static_cast<AquaSalGraphics&>(const_cast<SalGraphics&>(rSrcGraphics)).ApplyXorContext();
		1157	static_cast<AquaSalGraphics&>(const_cast<SalGraphics&>(rMaskGraphics)).ApplyXorContext();
		1158
		1159	//#### TODO: implement blending fully
		1160	return false;
		1161	}
		1162
1150	// -----------------------------------------------------------------------	1163	// -----------------------------------------------------------------------
1151		1164
1152	void AquaSalGraphics::copyArea( long nDstX, long nDstY,long nSrcX, long nSrcY, long nSrcWidth, long nSrcHeight, USHORT nFlags )	1165	void AquaSalGraphics::copyArea( long nDstX, long nDstY,long nSrcX, long nSrcY, long nSrcWidth, long nSrcHeight, USHORT nFlags )

Lines 579-584 Link Here

(-)a/vcl/source/gdi/salgdilayout.cxx (+26 lines)
579	else	579	else
580	copyBits( pPosAry, pSrcGraphics );	580	copyBits( pPosAry, pSrcGraphics );
581	}	581	}
		582
		583	bool SalGraphics::BlendBits( const SalTwoRect& rPosAry,
		584	const SalGraphics& rSrcGraphics, const SalGraphics& rMaskGraphics,
		585	const OutputDevice* pDstOutDev, const OutputDevice* pSrcOutDev, const OutputDevice* pMaskOutDev )
		586	{
		587	// fancy mirroring not yet implemented => request fallback
		588	if( (pDstOutDev && pDstOutDev->IsRTLEnabled())
		589	\|\| (pSrcOutDev && pSrcOutDev->IsRTLEnabled())
		590	\|\| (pMaskOutDev && pMaskOutDev->IsRTLEnabled()) )
		591	return false;
		592	if( (SAL_LAYOUT_BIDI_RTL & this->m_nLayout)
		593	\|\| (SAL_LAYOUT_BIDI_RTL & rSrcGraphics.m_nLayout)
		594	\|\| (SAL_LAYOUT_BIDI_RTL & rMaskGraphics.m_nLayout) )
		595	return false;
		596
		597	bool bDrawn = blendBits( rPosAry, rSrcGraphics, rMaskGraphics );
		598	return bDrawn;
		599	}
		600
		601	// default implementation for blending graphics
		602	// to be overridden by derived classes
		603	bool SalGraphics::blendBits( const SalTwoRect&, const SalGraphics&, const SalGraphics& )
		604	{
		605	return false;
		606	}
		607
582	void SalGraphics::DrawBitmap( const SalTwoRect* pPosAry,	608	void SalGraphics::DrawBitmap( const SalTwoRect* pPosAry,
583	const SalBitmap& rSalBitmap, const OutputDevice *pOutDev )	609	const SalBitmap& rSalBitmap, const OutputDevice *pOutDev )
584	{	610	{

Lines 1028-1034 Link Here

(-)a/vcl/unx/source/gdi/salgdi.cxx (-3 / +3 lines)
1028		1028
1029	// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	1029	// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
1030		1030
1031	XID X11SalGraphics::GetXRenderPicture()	1031	XID X11SalGraphics::GetXRenderPicture( void) const
1032	{	1032	{
1033	XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();	1033	XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();
1034		1034
Lines 1044-1053 Link Here
1044	if( !pVisualFormat )	1044	if( !pVisualFormat )
1045	return 0;	1045	return 0;
1046	// cache the XRenderPictFormat	1046	// cache the XRenderPictFormat
1047	SetXRenderFormat( static_cast<void*>(pVisualFormat) );	1047	const_cast<X11SalGraphics&>(this).SetXRenderFormat( static_cast<void>(pVisualFormat) );
1048	}	1048	}
1049		1049
1050	// get the matching xrender target for drawable	1050	// cache the matching xrender target for drawable
1051	m_aRenderPicture = rRenderPeer.CreatePicture( hDrawable_, pVisualFormat, 0, NULL );	1051	m_aRenderPicture = rRenderPeer.CreatePicture( hDrawable_, pVisualFormat, 0, NULL );
1052	}	1052	}
1053		1053

Lines 625-630 Link Here

(-)a/vcl/unx/source/gdi/salgdi2.cxx (+42 lines)
625	copyBits ( &aPosAry, 0 );	625	copyBits ( &aPosAry, 0 );
626	}	626	}
627		627
		628	// --------------------------------------------------------------------------
		629
		630	bool X11SalGraphics::blendBits( const SalTwoRect& rTR,
		631	const SalGraphics& rSrcGraphics, const SalGraphics& rMaskGraphics )
		632	{
		633	XRenderPeer& rPeer = XRenderPeer::GetInstance();
		634	if( rPeer.GetVersion() < 0x02 )
		635	return false;
		636
		637	// TODO: use scoped RENDER-Pictures
		638	Picture aDstPic = GetXRenderPicture();
		639	if( !aDstPic )
		640	return false;
		641
		642	Picture aSrcPic = static_cast<const X11SalGraphics&>(rSrcGraphics).GetXRenderPicture();
		643	if( !aSrcPic )
		644	return false;
		645
		646	Picture aMaskPic = static_cast<const X11SalGraphics&>(rMaskGraphics).GetXRenderPicture();
		647	if( !aMaskPic )
		648	return false;
		649
		650	// the GSL's transparency values are inverse to XRender's alpha values
		651	// TODO: make upper layers use standard alpha
		652	const XRenderColor aRenderColor = { 0, 0, 0, 0xFFFF };//GetXRenderColor( 0x000000 , 0 );
		653	rPeer.FillRectangle( PictOpOut, aMaskPic, &aRenderColor,
		654	rTR.mnSrcX, rTR.mnSrcY, rTR.mnSrcWidth, rTR.mnSrcHeight );
		655
		656	// set clipping
		657	if( pClipRegion_ && !XEmptyRegion( pClipRegion_ ) )
		658	rPeer.SetPictureClipRegion( aDstPic, pClipRegion_ );
		659
		660	// TODO: eventually use XRenderSetPictureTransform() to scale the pictures
		661
		662	// paint source * mask over destination picture
		663	rPeer.CompositePicture( PictOpOver, aSrcPic, aMaskPic, aDstPic,
		664	rTR.mnSrcX, rTR.mnSrcY, /0,0,//#########/rTR.mnSrcX, rTR.mnSrcY,
		665	rTR.mnDestX, rTR.mnDestY, rTR.mnDestWidth, rTR.mnDestHeight );
		666
		667	return true;
		668	}
		669
628	// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	670	// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
629	void X11SalGraphics::drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap )	671	void X11SalGraphics::drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap )
630	{	672	{

Lines 111-125 Link Here

(-)a/drawinglayer/source/processor2d/vclhelperbufferdevice.cxx (-4 / +3 lines)
111	if(mpAlpha)	111	if(mpAlpha)
112	{	112	{
113	mpAlpha->EnableMapMode(false);	113	mpAlpha->EnableMapMode(false);
114	const AlphaMask aAlphaMask(mpAlpha->GetBitmap(aEmptyPoint, aSizePixel));
115		114
116	if(bDoSaveForVisualControl)	115	if(bDoSaveForVisualControl)
117	{	116	{
118	SvFileStream aNew((const String&)String(ByteString( "c:\\transparence.bmp" ), RTL_TEXTENCODING_UTF8), STREAM_WRITE\|STREAM_TRUNC);	117	SvFileStream aNew((const String&)String(ByteString( "c:\\transparence.bmp" ), RTL_TEXTENCODING_UTF8), STREAM_WRITE\|STREAM_TRUNC);
119	aNew << aAlphaMask.GetBitmap();	118	aNew << aAlphaMask.GetBitmap();
120	}	119	}
121		120
122	mrOutDev.DrawBitmapEx(maDestPixel.TopLeft(), BitmapEx(aContent, aAlphaMask));	121	mrOutDev.DrawOutDevMasked( maDestPixel.TopLeft(), aSizePixel, aEmptyPoint, aSizePixel, maContent, *mpAlpha );
123	}	122	}
124	else if(mpMask)	123	else if(mpMask)
125	{	124	{
Lines 166-172 Link Here
166	{	165	{
167	if(!mpAlpha)	166	if(!mpAlpha)
168	{	167	{
169	mpAlpha = new VirtualDevice();	168	mpAlpha = new VirtualDevice(mrOutDev, 8);
170	mpAlpha->SetOutputSizePixel(maDestPixel.GetSize(), true);	169	mpAlpha->SetOutputSizePixel(maDestPixel.GetSize(), true);
171	mpAlpha->SetMapMode(maContent.GetMapMode());	170	mpAlpha->SetMapMode(maContent.GetMapMode());
172		171

Lines 52-57 Link Here

(-)a/vcl/source/gdi/outdev2.cxx (+53 lines)
52	#include <vcl/image.h>	52	#include <vcl/image.h>
53	#include <vcl/image.hxx>	53	#include <vcl/image.hxx>
54	#include <vcl/bmpfast.hxx>	54	#include <vcl/bmpfast.hxx>
		55	#include <tools/debug.hxx>
55		56
56	#define BAND_MAX_SIZE 512000	57	#define BAND_MAX_SIZE 512000
57		58
Lines 387-392 Link Here
387		388
388	// ------------------------------------------------------------------	389	// ------------------------------------------------------------------
389		390
		391	void OutputDevice::DrawOutDevMasked( const Point& rDstPt, const Size& rDstSize,
		392	const Point& rSrcPt, const Size& rSrcSize,
		393	const OutputDevice& rSrcOutDev,
		394	const OutputDevice& rMaskOutDev )
		395	{
		396	DBG_TRACE( "OutputDevice::DrawOutDev()" );
		397	DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
		398	DBG_CHKOBJ( &rSrcOutDev, OutputDevice, ImplDbgCheckOutputDevice );
		399	DBG_CHKOBJ( &rMaskOutDev, OutputDevice, ImplDbgCheckOutputDevice );
		400	DBG_ASSERT( rDstSize == rSrcSize, "DrawOutDevMasked() only matched sizes implemented"); // not implemented
		401	DBG_ASSERT( !IsMapModeEnabled(), "DrawOutDevMasked() only pixel mapmode supported");
		402	DBG_ASSERT( !rSrcOutDev.IsMapModeEnabled(), "DrawOutDevMasked() only pixel mapmode supported");
		403	DBG_ASSERT( !rMaskOutDev.IsMapModeEnabled(), "DrawOutDevMasked() only pixel mapmode supported");
		404
		405	OUTDEV_INIT();
		406
		407	bool bDrawn = false;
		408
		409	// #i112730# try fast SalGraphics method first
		410	if( !rSrcOutDev.mpGraphics )
		411	rSrcOutDev.ImplGetGraphics();
		412	if( !rMaskOutDev.mpGraphics )
		413	rMaskOutDev.ImplGetGraphics();
		414	if( !mpMetaFile
		415	&& (meRasterOp == ROP_OVERPAINT)
		416	&& (mpGraphics && rSrcOutDev.mpGraphics && rMaskOutDev.mpGraphics) )
		417	{
		418	SalTwoRect aPosAry;
		419	aPosAry.mnSrcX = rSrcOutDev.ImplLogicXToDevicePixel( rSrcPt.X() );
		420	aPosAry.mnSrcY = rSrcOutDev.ImplLogicYToDevicePixel( rSrcPt.Y() );
		421	aPosAry.mnSrcWidth = rSrcOutDev.ImplLogicWidthToDevicePixel( rSrcSize.Width() );
		422	aPosAry.mnSrcHeight = rSrcOutDev.ImplLogicHeightToDevicePixel( rSrcSize.Height() );
		423	aPosAry.mnDestX = ImplLogicXToDevicePixel( rDstPt.X() );
		424	aPosAry.mnDestY = ImplLogicYToDevicePixel( rDstPt.Y() );
		425	aPosAry.mnDestWidth = ImplLogicWidthToDevicePixel( rDstSize.Width() );
		426	aPosAry.mnDestHeight = ImplLogicHeightToDevicePixel( rDstSize.Height() );
		427
		428	bDrawn = mpGraphics->BlendBits( aPosAry, rSrcOutDev.mpGraphics, rMaskOutDev.mpGraphics,
		429	this, &rSrcOutDev, &rMaskOutDev );
		430	}
		431
		432	if( !bDrawn ) // fallback to canonical method if needed
		433	{
		434	const Bitmap aSourceBmp = rSrcOutDev.GetBitmap( rSrcPt, rSrcSize );
		435	const AlphaMask aAlphaMask = rMaskOutDev.GetBitmap( rSrcPt, rSrcSize );
		436	const BitmapEx aBlendedBmp( aSourceBmp, aAlphaMask );
		437	DrawBitmapEx( rDstPt, aBlendedBmp );
		438	}
		439	}
		440
		441	// ------------------------------------------------------------------
		442
390	void OutputDevice::CopyArea( const Point& rDestPt,	443	void OutputDevice::CopyArea( const Point& rDestPt,
391	const Point& rSrcPt, const Size& rSrcSize,	444	const Point& rSrcPt, const Size& rSrcSize,
392	USHORT nFlags )	445	USHORT nFlags )