AOO410/main/vcl/source/gdi/impanmvw.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  *************************************************************/


 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_vcl.hxx"

 #include "impanmvw.hxx"
 #include <vcl/virdev.hxx>
 #include <vcl/window.hxx>
 #include <vcl/salbtype.hxx>

 // ----------------
 // - ImplAnimView -
 // ----------------

 ImplAnimView::ImplAnimView( Animation* pParent, OutputDevice* pOut,
 							const Point& rPt, const Size& rSz,
 							sal_uLong nExtraData,
 							OutputDevice* pFirstFrameOutDev ) :
 		mpParent		( pParent ),
 		mpOut			( pFirstFrameOutDev ? pFirstFrameOutDev : pOut ),
 		mnExtraData		( nExtraData ),
 		maPt			( rPt ),
 		maSz			( rSz ),
 		maSzPix			( mpOut->LogicToPixel( maSz ) ),
 		maClip			( mpOut->GetClipRegion() ),
 		mpBackground	( new VirtualDevice ),
 		mpRestore		( new VirtualDevice ),
 		meLastDisposal	( DISPOSE_BACK ),
 		mbPause			( sal_False ),
 		mbMarked		( sal_False ),
 		mbHMirr			( maSz.Width() < 0L ),
 		mbVMirr			( maSz.Height() < 0L )
 {
 	mpParent->ImplIncAnimCount();

 	// mirrored horizontically?
 	if( mbHMirr )
 	{
 		maDispPt.X() = maPt.X() + maSz.Width() + 1L;
 		maDispSz.Width() = -maSz.Width();
 		maSzPix.Width() = -maSzPix.Width();
 	}
 	else
 	{
 		maDispPt.X() = maPt.X();
 		maDispSz.Width() = maSz.Width();
 	}

 	// mirrored vertically?
 	if( mbVMirr )
 	{
 		maDispPt.Y() = maPt.Y() + maSz.Height() + 1L;
 		maDispSz.Height() = -maSz.Height();
 		maSzPix.Height() = -maSzPix.Height();
 	}
 	else
 	{
 		maDispPt.Y() = maPt.Y();
 		maDispSz.Height() = maSz.Height();
 	}

 	// save background
 	mpBackground->SetOutputSizePixel( maSzPix );

 	if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
 	{
 		MapMode aTempMap( mpOut->GetMapMode() );
 		aTempMap.SetOrigin( Point() );
 		mpBackground->SetMapMode( aTempMap );
 		( (Window*) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
 		mpBackground->SetMapMode( MapMode() );
 	}
 	else
 		mpBackground->DrawOutDev( Point(), maSzPix, maDispPt, maDispSz, *mpOut );

 	// initial drawing to actual position
 	ImplDrawToPos( mpParent->ImplGetCurPos() );

 	// if first frame OutputDevice is set, update variables now for real OutputDevice
 	if( pFirstFrameOutDev )
 		maClip = ( mpOut = pOut )->GetClipRegion();
 }

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

 ImplAnimView::~ImplAnimView()
 {
 	delete mpBackground;
 	delete mpRestore;

 	mpParent->ImplDecAnimCount();
 }

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

 sal_Bool ImplAnimView::ImplMatches( OutputDevice* pOut, long nExtraData ) const
 {
 	sal_Bool bRet = sal_False;

 	if( nExtraData )
 	{
 		if( ( mnExtraData == nExtraData ) && ( !pOut || ( pOut == mpOut ) ) )
 			bRet = sal_True;
 	}
 	else if( !pOut || ( pOut == mpOut ) )
 		bRet = sal_True;

 	return bRet;
 }

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

 void ImplAnimView::ImplGetPosSize( const AnimationBitmap& rAnm, Point& rPosPix, Size& rSizePix )
 {
 	const Size& rAnmSize = mpParent->GetDisplaySizePixel();
 	Point		aPt2( rAnm.aPosPix.X() + rAnm.aSizePix.Width() - 1L,
 					  rAnm.aPosPix.Y() + rAnm.aSizePix.Height() - 1L );
 	double		fFactX, fFactY;

 	// calculate x scaling
 	if( rAnmSize.Width() > 1L )
 		fFactX = (double) ( maSzPix.Width() - 1L ) / ( rAnmSize.Width() - 1L );
 	else
 		fFactX = 1.0;

 	// calculate y scaling
 	if( rAnmSize.Height() > 1L )
 		fFactY = (double) ( maSzPix.Height() - 1L ) / ( rAnmSize.Height() - 1L );
 	else
 		fFactY = 1.0;

 	rPosPix.X() = FRound( rAnm.aPosPix.X() * fFactX );
 	rPosPix.Y() = FRound( rAnm.aPosPix.Y() * fFactY );

 	aPt2.X() = FRound( aPt2.X() * fFactX );
 	aPt2.Y() = FRound( aPt2.Y() * fFactY );

 	rSizePix.Width() = aPt2.X() - rPosPix.X() + 1L;
 	rSizePix.Height() = aPt2.Y() - rPosPix.Y() + 1L;

 	// mirrored horizontically?
 	if( mbHMirr )
 		rPosPix.X() = maSzPix.Width() - 1L - aPt2.X();

 	// mirrored vertically?
 	if( mbVMirr )
 		rPosPix.Y() = maSzPix.Height() - 1L - aPt2.Y();
 }

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

 void ImplAnimView::ImplDrawToPos( sal_uLong nPos )
 {
 	VirtualDevice	aVDev;
 	Region*			pOldClip = !maClip.IsNull() ? new Region( mpOut->GetClipRegion() ) : NULL;

 	aVDev.SetOutputSizePixel( maSzPix, sal_False );
 	nPos = Min( nPos, (sal_uLong) mpParent->Count() - 1UL );

 	for( sal_uLong i = 0UL; i <= nPos; i++ )
 		ImplDraw( i, &aVDev );

 	if( pOldClip )
 		mpOut->SetClipRegion( maClip );

 	mpOut->DrawOutDev( maDispPt, maDispSz, Point(), maSzPix, aVDev );

 	if( pOldClip )
 	{
 		mpOut->SetClipRegion( *pOldClip );
 		delete pOldClip;
 	}
 }

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

 void ImplAnimView::ImplDraw( sal_uLong nPos )
 {
 	ImplDraw( nPos, NULL );
 }

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

 void ImplAnimView::ImplDraw( sal_uLong nPos, VirtualDevice* pVDev )
 {
 	Rectangle aOutRect( mpOut->PixelToLogic( Point() ), mpOut->GetOutputSize() );

 	// check, if output lies out of display
 	if( aOutRect.Intersection( Rectangle( maDispPt, maDispSz ) ).IsEmpty() )
 		ImplSetMarked( sal_True );
 	else if( !mbPause )
 	{
 		VirtualDevice*			pDev;
 		Point					aPosPix;
 		Point					aBmpPosPix;
 		Size					aSizePix;
 		Size					aBmpSizePix;
 		const sal_uLong				nLastPos = mpParent->Count() - 1;
 		const AnimationBitmap&	rAnm = mpParent->Get( (sal_uInt16) ( mnActPos = Min( nPos, nLastPos ) ) );

 		ImplGetPosSize( rAnm, aPosPix, aSizePix );

 		// mirrored horizontically?
 		if( mbHMirr )
 		{
 			aBmpPosPix.X() = aPosPix.X() + aSizePix.Width() - 1L;
 			aBmpSizePix.Width() = -aSizePix.Width();
 		}
 		else
 		{
 			aBmpPosPix.X() = aPosPix.X();
 			aBmpSizePix.Width() = aSizePix.Width();
 		}

 		// mirrored vertically?
 		if( mbVMirr )
 		{
 			aBmpPosPix.Y() = aPosPix.Y() + aSizePix.Height() - 1L;
 			aBmpSizePix.Height() = -aSizePix.Height();
 		}
 		else
 		{
 			aBmpPosPix.Y() = aPosPix.Y();
 			aBmpSizePix.Height() = aSizePix.Height();
 		}

 		// get output device
 		if( !pVDev )
 		{
 			pDev = new VirtualDevice;
 			pDev->SetOutputSizePixel( maSzPix, sal_False );
 			pDev->DrawOutDev( Point(), maSzPix, maDispPt, maDispSz, *mpOut );
 		}
 		else
 			pDev = pVDev;

 		// restore background after each run
 		if( !nPos )
 		{
 			meLastDisposal = DISPOSE_BACK;
 			maRestPt = Point();
 			maRestSz = maSzPix;
 		}

 		// restore
 		if( ( DISPOSE_NOT != meLastDisposal ) && maRestSz.Width() && maRestSz.Height() )
 		{
 			if( DISPOSE_BACK == meLastDisposal )
 				pDev->DrawOutDev( maRestPt, maRestSz, maRestPt, maRestSz, *mpBackground );
 			else
 				pDev->DrawOutDev( maRestPt, maRestSz, Point(), maRestSz, *mpRestore );
 		}

 		meLastDisposal = rAnm.eDisposal;
 		maRestPt = aPosPix;
 		maRestSz = aSizePix;

 		// Was muessen wir beim naechsten Mal restaurieren ?
 		// ==> ggf. in eine Bitmap stecken, ansonsten SaveBitmap
 		// aus Speichergruenden loeschen
 		if( ( meLastDisposal == DISPOSE_BACK ) || ( meLastDisposal == DISPOSE_NOT ) )
 			mpRestore->SetOutputSizePixel( Size( 1, 1 ), sal_False );
 		else
 		{
 			mpRestore->SetOutputSizePixel( maRestSz, sal_False );
 			mpRestore->DrawOutDev( Point(), maRestSz, aPosPix, aSizePix, *pDev );
 		}

 		pDev->DrawBitmapEx( aBmpPosPix, aBmpSizePix, rAnm.aBmpEx );

 		if( !pVDev )
 		{
 			Region* pOldClip = !maClip.IsNull() ? new Region( mpOut->GetClipRegion() ) : NULL;

 			if( pOldClip )
 				mpOut->SetClipRegion( maClip );

 			mpOut->DrawOutDev( maDispPt, maDispSz, Point(), maSzPix, *pDev );

 			if( pOldClip )
 			{
 				mpOut->SetClipRegion( *pOldClip );
 				delete pOldClip;
 			}

 			delete pDev;

 			if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
 				( (Window*) mpOut )->Sync();
 		}
 	}
 }

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

 void ImplAnimView::ImplRepaint()
 {
 	const sal_Bool bOldPause = mbPause;

 	if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
 	{
 		MapMode aTempMap( mpOut->GetMapMode() );
 		aTempMap.SetOrigin( Point() );
 		mpBackground->SetMapMode( aTempMap );
 		( (Window*) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
 		mpBackground->SetMapMode( MapMode() );
 	}
 	else
 		mpBackground->DrawOutDev( Point(), maSzPix, maDispPt, maDispSz, *mpOut );

 	mbPause = sal_False;
 	ImplDrawToPos( mnActPos );
 	mbPause = bOldPause;
 }

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

 AInfo* ImplAnimView::ImplCreateAInfo() const
 {
 	AInfo* pAInfo = new AInfo;

 	pAInfo->aStartOrg = maPt;
 	pAInfo->aStartSize = maSz;
 	pAInfo->pOutDev = mpOut;
 	pAInfo->pViewData = (void*) this;
 	pAInfo->nExtraData = mnExtraData;
 	pAInfo->bPause = mbPause;

 	return pAInfo;
 }
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*************************************************************/



	// MARKER(update_precomp.py): autogen include statement, do not remove
	#include "precompiled_vcl.hxx"

	#include "impanmvw.hxx"
	#include <vcl/virdev.hxx>
	#include <vcl/window.hxx>
	#include <vcl/salbtype.hxx>

	// ----------------
	// - ImplAnimView -
	// ----------------

	ImplAnimView::ImplAnimView( Animation* pParent, OutputDevice* pOut,
	const Point& rPt, const Size& rSz,
	sal_uLong nExtraData,
	OutputDevice* pFirstFrameOutDev ) :
	mpParent ( pParent ),
	mpOut ( pFirstFrameOutDev ? pFirstFrameOutDev : pOut ),
	mnExtraData ( nExtraData ),
	maPt ( rPt ),
	maSz ( rSz ),
	maSzPix ( mpOut->LogicToPixel( maSz ) ),
	maClip ( mpOut->GetClipRegion() ),
	mpBackground ( new VirtualDevice ),
	mpRestore ( new VirtualDevice ),
	meLastDisposal ( DISPOSE_BACK ),
	mbPause ( sal_False ),
	mbMarked ( sal_False ),
	mbHMirr ( maSz.Width() < 0L ),
	mbVMirr ( maSz.Height() < 0L )
	{
	mpParent->ImplIncAnimCount();

	// mirrored horizontically?
	if( mbHMirr )
	{
	maDispPt.X() = maPt.X() + maSz.Width() + 1L;
	maDispSz.Width() = -maSz.Width();
	maSzPix.Width() = -maSzPix.Width();
	}
	else
	{
	maDispPt.X() = maPt.X();
	maDispSz.Width() = maSz.Width();
	}

	// mirrored vertically?
	if( mbVMirr )
	{
	maDispPt.Y() = maPt.Y() + maSz.Height() + 1L;
	maDispSz.Height() = -maSz.Height();
	maSzPix.Height() = -maSzPix.Height();
	}
	else
	{
	maDispPt.Y() = maPt.Y();
	maDispSz.Height() = maSz.Height();
	}

	// save background
	mpBackground->SetOutputSizePixel( maSzPix );

	if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
	{
	MapMode aTempMap( mpOut->GetMapMode() );
	aTempMap.SetOrigin( Point() );
	mpBackground->SetMapMode( aTempMap );
	( (Window) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), mpBackground );
	mpBackground->SetMapMode( MapMode() );
	}
	else
	mpBackground->DrawOutDev( Point(), maSzPix, maDispPt, maDispSz, *mpOut );

	// initial drawing to actual position
	ImplDrawToPos( mpParent->ImplGetCurPos() );

	// if first frame OutputDevice is set, update variables now for real OutputDevice
	if( pFirstFrameOutDev )
	maClip = ( mpOut = pOut )->GetClipRegion();
	}

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

	ImplAnimView::~ImplAnimView()
	{
	delete mpBackground;
	delete mpRestore;

	mpParent->ImplDecAnimCount();
	}

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

	sal_Bool ImplAnimView::ImplMatches( OutputDevice* pOut, long nExtraData ) const
	{
	sal_Bool bRet = sal_False;

	if( nExtraData )
	{
	if( ( mnExtraData == nExtraData ) && ( !pOut \|\| ( pOut == mpOut ) ) )
	bRet = sal_True;
	}
	else if( !pOut \|\| ( pOut == mpOut ) )
	bRet = sal_True;

	return bRet;
	}

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

	void ImplAnimView::ImplGetPosSize( const AnimationBitmap& rAnm, Point& rPosPix, Size& rSizePix )
	{
	const Size& rAnmSize = mpParent->GetDisplaySizePixel();
	Point aPt2( rAnm.aPosPix.X() + rAnm.aSizePix.Width() - 1L,
	rAnm.aPosPix.Y() + rAnm.aSizePix.Height() - 1L );
	double fFactX, fFactY;

	// calculate x scaling
	if( rAnmSize.Width() > 1L )
	fFactX = (double) ( maSzPix.Width() - 1L ) / ( rAnmSize.Width() - 1L );
	else
	fFactX = 1.0;

	// calculate y scaling
	if( rAnmSize.Height() > 1L )
	fFactY = (double) ( maSzPix.Height() - 1L ) / ( rAnmSize.Height() - 1L );
	else
	fFactY = 1.0;

	rPosPix.X() = FRound( rAnm.aPosPix.X() * fFactX );
	rPosPix.Y() = FRound( rAnm.aPosPix.Y() * fFactY );

	aPt2.X() = FRound( aPt2.X() * fFactX );
	aPt2.Y() = FRound( aPt2.Y() * fFactY );

	rSizePix.Width() = aPt2.X() - rPosPix.X() + 1L;
	rSizePix.Height() = aPt2.Y() - rPosPix.Y() + 1L;

	// mirrored horizontically?
	if( mbHMirr )
	rPosPix.X() = maSzPix.Width() - 1L - aPt2.X();

	// mirrored vertically?
	if( mbVMirr )
	rPosPix.Y() = maSzPix.Height() - 1L - aPt2.Y();
	}

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

	void ImplAnimView::ImplDrawToPos( sal_uLong nPos )
	{
	VirtualDevice aVDev;
	Region* pOldClip = !maClip.IsNull() ? new Region( mpOut->GetClipRegion() ) : NULL;

	aVDev.SetOutputSizePixel( maSzPix, sal_False );
	nPos = Min( nPos, (sal_uLong) mpParent->Count() - 1UL );

	for( sal_uLong i = 0UL; i <= nPos; i++ )
	ImplDraw( i, &aVDev );

	if( pOldClip )
	mpOut->SetClipRegion( maClip );

	mpOut->DrawOutDev( maDispPt, maDispSz, Point(), maSzPix, aVDev );

	if( pOldClip )
	{
	mpOut->SetClipRegion( *pOldClip );
	delete pOldClip;
	}
	}

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

	void ImplAnimView::ImplDraw( sal_uLong nPos )
	{
	ImplDraw( nPos, NULL );
	}

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

	void ImplAnimView::ImplDraw( sal_uLong nPos, VirtualDevice* pVDev )
	{
	Rectangle aOutRect( mpOut->PixelToLogic( Point() ), mpOut->GetOutputSize() );

	// check, if output lies out of display
	if( aOutRect.Intersection( Rectangle( maDispPt, maDispSz ) ).IsEmpty() )
	ImplSetMarked( sal_True );
	else if( !mbPause )
	{
	VirtualDevice* pDev;
	Point aPosPix;
	Point aBmpPosPix;
	Size aSizePix;
	Size aBmpSizePix;
	const sal_uLong nLastPos = mpParent->Count() - 1;
	const AnimationBitmap& rAnm = mpParent->Get( (sal_uInt16) ( mnActPos = Min( nPos, nLastPos ) ) );

	ImplGetPosSize( rAnm, aPosPix, aSizePix );

	// mirrored horizontically?
	if( mbHMirr )
	{
	aBmpPosPix.X() = aPosPix.X() + aSizePix.Width() - 1L;
	aBmpSizePix.Width() = -aSizePix.Width();
	}
	else
	{
	aBmpPosPix.X() = aPosPix.X();
	aBmpSizePix.Width() = aSizePix.Width();
	}

	// mirrored vertically?
	if( mbVMirr )
	{
	aBmpPosPix.Y() = aPosPix.Y() + aSizePix.Height() - 1L;
	aBmpSizePix.Height() = -aSizePix.Height();
	}
	else
	{
	aBmpPosPix.Y() = aPosPix.Y();
	aBmpSizePix.Height() = aSizePix.Height();
	}

	// get output device
	if( !pVDev )
	{
	pDev = new VirtualDevice;
	pDev->SetOutputSizePixel( maSzPix, sal_False );
	pDev->DrawOutDev( Point(), maSzPix, maDispPt, maDispSz, *mpOut );
	}
	else
	pDev = pVDev;

	// restore background after each run
	if( !nPos )
	{
	meLastDisposal = DISPOSE_BACK;
	maRestPt = Point();
	maRestSz = maSzPix;
	}

	// restore
	if( ( DISPOSE_NOT != meLastDisposal ) && maRestSz.Width() && maRestSz.Height() )
	{
	if( DISPOSE_BACK == meLastDisposal )
	pDev->DrawOutDev( maRestPt, maRestSz, maRestPt, maRestSz, *mpBackground );
	else
	pDev->DrawOutDev( maRestPt, maRestSz, Point(), maRestSz, *mpRestore );
	}

	meLastDisposal = rAnm.eDisposal;
	maRestPt = aPosPix;
	maRestSz = aSizePix;

	// Was muessen wir beim naechsten Mal restaurieren ?
	// ==> ggf. in eine Bitmap stecken, ansonsten SaveBitmap
	// aus Speichergruenden loeschen
	if( ( meLastDisposal == DISPOSE_BACK ) \|\| ( meLastDisposal == DISPOSE_NOT ) )
	mpRestore->SetOutputSizePixel( Size( 1, 1 ), sal_False );
	else
	{
	mpRestore->SetOutputSizePixel( maRestSz, sal_False );
	mpRestore->DrawOutDev( Point(), maRestSz, aPosPix, aSizePix, *pDev );
	}

	pDev->DrawBitmapEx( aBmpPosPix, aBmpSizePix, rAnm.aBmpEx );

	if( !pVDev )
	{
	Region* pOldClip = !maClip.IsNull() ? new Region( mpOut->GetClipRegion() ) : NULL;

	if( pOldClip )
	mpOut->SetClipRegion( maClip );

	mpOut->DrawOutDev( maDispPt, maDispSz, Point(), maSzPix, *pDev );

	if( pOldClip )
	{
	mpOut->SetClipRegion( *pOldClip );
	delete pOldClip;
	}

	delete pDev;

	if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
	( (Window*) mpOut )->Sync();
	}
	}
	}

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

	void ImplAnimView::ImplRepaint()
	{
	const sal_Bool bOldPause = mbPause;

	if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
	{
	MapMode aTempMap( mpOut->GetMapMode() );
	aTempMap.SetOrigin( Point() );
	mpBackground->SetMapMode( aTempMap );
	( (Window) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), mpBackground );
	mpBackground->SetMapMode( MapMode() );
	}
	else
	mpBackground->DrawOutDev( Point(), maSzPix, maDispPt, maDispSz, *mpOut );

	mbPause = sal_False;
	ImplDrawToPos( mnActPos );
	mbPause = bOldPause;
	}

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

	AInfo* ImplAnimView::ImplCreateAInfo() const
	{
	AInfo* pAInfo = new AInfo;

	pAInfo->aStartOrg = maPt;
	pAInfo->aStartSize = maSz;
	pAInfo->pOutDev = mpOut;
	pAInfo->pViewData = (void*) this;
	pAInfo->nExtraData = mnExtraData;
	pAInfo->bPause = mbPause;

	return pAInfo;
	}