xref: /aoo41x/main/vcl/source/gdi/gdimtf.cxx (revision fdbfc3c2)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_vcl.hxx"
26 #include <vos/macros.hxx>
27 #include <rtl/crc.h>
28 #include <tools/stream.hxx>
29 #include <tools/vcompat.hxx>
30 #include <vcl/metaact.hxx>
31 #include <vcl/salbtype.hxx>
32 #include <vcl/outdev.hxx>
33 #include <vcl/window.hxx>
34 #ifndef _SV_CVTSVM_HXX
35 #include <vcl/cvtsvm.hxx>
36 #endif
37 #include <vcl/virdev.hxx>
38 #include <vcl/gdimtf.hxx>
39 #include <vcl/graphictools.hxx>
40 #include <basegfx/polygon/b2dpolygon.hxx>
41 
42 // -----------
43 // - Defines -
44 // -----------
45 
46 #define GAMMA( _def_cVal, _def_InvGamma )	((sal_uInt8)MinMax(FRound(pow( _def_cVal/255.0,_def_InvGamma)*255.0),0L,255L))
47 
48 // --------------------------
49 // - Color exchange structs -
50 // --------------------------
51 
52 struct ImplColAdjustParam
53 {
54 	sal_uInt8*	pMapR;
55 	sal_uInt8*	pMapG;
56 	sal_uInt8*	pMapB;
57 };
58 
59 struct ImplBmpAdjustParam
60 {
61 	short	nLuminancePercent;
62 	short	nContrastPercent;
63 	short	nChannelRPercent;
64 	short	nChannelGPercent;
65 	short	nChannelBPercent;
66 	double	fGamma;
67 	sal_Bool	bInvert;
68 };
69 
70 // -----------------------------------------------------------------------------
71 
72 struct ImplColConvertParam
73 {
74 	MtfConversion	eConversion;
75 };
76 
77 struct ImplBmpConvertParam
78 {
79 	BmpConversion	eConversion;
80 };
81 
82 // -----------------------------------------------------------------------------
83 
84 struct ImplColMonoParam
85 {
86 	Color aColor;
87 };
88 
89 struct ImplBmpMonoParam
90 {
91 	Color aColor;
92 };
93 
94 // -----------------------------------------------------------------------------
95 
96 struct ImplColReplaceParam
97 {
98 	sal_uLong*			pMinR;
99 	sal_uLong*			pMaxR;
100 	sal_uLong*			pMinG;
101 	sal_uLong*			pMaxG;
102 	sal_uLong*			pMinB;
103 	sal_uLong*			pMaxB;
104 	const Color*	pDstCols;
105 	sal_uLong			nCount;
106 };
107 
108 struct ImplBmpReplaceParam
109 {
110 	const Color*	pSrcCols;
111 	const Color*	pDstCols;
112 	sal_uLong			nCount;
113 	const sal_uLong*	pTols;
114 };
115 
116 
117 // ---------
118 // - Label -
119 // ---------
120 
121 struct ImpLabel
122 {
123 	String	aLabelName;
124 	sal_uLong	nActionPos;
125 
126 			ImpLabel( const String& rLabelName, sal_uLong _nActionPos ) :
127 				aLabelName( rLabelName ),
128 				nActionPos( _nActionPos ) {}
129 };
130 
131 // -------------
132 // - LabelList -
133 // -------------
134 
135 class ImpLabelList : private List
136 {
137 public:
138 
139 				ImpLabelList() : List( 8, 4, 4 ) {}
140 				ImpLabelList( const ImpLabelList& rList );
141 				~ImpLabelList();
142 
143 	void		ImplInsert( ImpLabel* p ) { Insert( p, LIST_APPEND ); }
144 	ImpLabel*	ImplRemove( sal_uLong nPos ) { return (ImpLabel*) Remove( nPos ); }
145 	void		ImplReplace( ImpLabel* p ) { Replace( (void*)p ); }
146 	ImpLabel*	ImplFirst() { return (ImpLabel*) First(); }
147 	ImpLabel*	ImplNext() { return (ImpLabel*) Next(); }
148 	ImpLabel*	ImplGetLabel( sal_uLong nPos ) const { return (ImpLabel*) GetObject( nPos ); }
149 	sal_uLong		ImplGetLabelPos( const String& rLabelName );
150 	sal_uLong		ImplCount() const { return Count(); }
151 };
152 
153 // ------------------------------------------------------------------------
154 
155 ImpLabelList::ImpLabelList( const ImpLabelList& rList ) :
156 		List( rList )
157 {
158 	for( ImpLabel* pLabel = ImplFirst(); pLabel; pLabel = ImplNext() )
159 		ImplReplace( new ImpLabel( *pLabel ) );
160 }
161 
162 // ------------------------------------------------------------------------
163 
164 ImpLabelList::~ImpLabelList()
165 {
166 	for( ImpLabel* pLabel = ImplFirst(); pLabel; pLabel = ImplNext() )
167 		delete pLabel;
168 }
169 
170 // ------------------------------------------------------------------------
171 
172 sal_uLong ImpLabelList::ImplGetLabelPos( const String& rLabelName )
173 {
174 	sal_uLong nLabelPos = METAFILE_LABEL_NOTFOUND;
175 
176 	for( ImpLabel* pLabel = ImplFirst(); pLabel; pLabel = ImplNext() )
177 	{
178 		if ( rLabelName == pLabel->aLabelName )
179 		{
180 			nLabelPos = GetCurPos();
181 			break;
182 		}
183 	}
184 
185 	return nLabelPos;
186 }
187 
188 // ---------------
189 // - GDIMetaFile -
190 // ---------------
191 
192 GDIMetaFile::GDIMetaFile() :
193 	List		( 0x3EFF, 64, 64 ),
194 	aPrefSize	( 1, 1 ),
195 	pPrev		( NULL ),
196 	pNext		( NULL ),
197 	pOutDev 	( NULL ),
198 	pLabelList	( NULL ),
199 	bPause		( sal_False ),
200 	bRecord 	( sal_False )
201 {
202 }
203 
204 // ------------------------------------------------------------------------
205 
206 GDIMetaFile::GDIMetaFile( const GDIMetaFile& rMtf ) :
207 	List			( rMtf ),
208 	aPrefMapMode	( rMtf.aPrefMapMode ),
209 	aPrefSize		( rMtf.aPrefSize ),
210 	aHookHdlLink	( rMtf.aHookHdlLink ),
211 	pPrev			( rMtf.pPrev ),
212 	pNext			( rMtf.pNext ),
213 	pOutDev 		( NULL ),
214 	bPause			( sal_False ),
215 	bRecord 		( sal_False )
216 {
217 	// RefCount der MetaActions erhoehen
218 	for( void* pAct = First(); pAct; pAct = Next() )
219 		( (MetaAction*) pAct )->Duplicate();
220 
221 	if( rMtf.pLabelList )
222 		pLabelList = new ImpLabelList( *rMtf.pLabelList );
223 	else
224 		pLabelList = NULL;
225 
226 	if( rMtf.bRecord )
227 	{
228 		Record( rMtf.pOutDev );
229 
230 		if ( rMtf.bPause )
231 			Pause( sal_True );
232 	}
233 }
234 
235 // ------------------------------------------------------------------------
236 
237 GDIMetaFile::~GDIMetaFile()
238 {
239 	Clear();
240 }
241 
242 // ------------------------------------------------------------------------
243 
244 GDIMetaFile& GDIMetaFile::operator=( const GDIMetaFile& rMtf )
245 {
246 	if( this != &rMtf )
247 	{
248 		Clear();
249 
250 		List::operator=( rMtf );
251 
252 		// RefCount der MetaActions erhoehen
253 		for( void* pAct = First(); pAct; pAct = Next() )
254 			( (MetaAction*) pAct )->Duplicate();
255 
256 		if( rMtf.pLabelList )
257 			pLabelList = new ImpLabelList( *rMtf.pLabelList );
258 		else
259 		   pLabelList = NULL;
260 
261 		aPrefMapMode = rMtf.aPrefMapMode;
262 		aPrefSize = rMtf.aPrefSize;
263 		aHookHdlLink = rMtf.aHookHdlLink;
264 		pPrev = rMtf.pPrev;
265 		pNext = rMtf.pNext;
266 		pOutDev = NULL;
267 		bPause = sal_False;
268 		bRecord = sal_False;
269 
270 		if( rMtf.bRecord )
271 		{
272 			Record( rMtf.pOutDev );
273 
274 			if( rMtf.bPause )
275 				Pause( sal_True );
276 		}
277 	}
278 
279 	return *this;
280 }
281 
282 // ------------------------------------------------------------------------
283 
284 sal_Bool GDIMetaFile::operator==( const GDIMetaFile& rMtf ) const
285 {
286 	const sal_uLong nObjCount = Count();
287 	sal_Bool		bRet = sal_False;
288 
289 	if( this == &rMtf )
290 		bRet = sal_True;
291 	else if( rMtf.GetActionCount() == nObjCount &&
292 			 rMtf.GetPrefSize() == aPrefSize &&
293 			 rMtf.GetPrefMapMode() == aPrefMapMode )
294 	{
295 		bRet = sal_True;
296 
297 		for( sal_uLong n = 0UL; n < nObjCount; n++ )
298 		{
299 			if( GetObject( n ) != rMtf.GetObject( n ) )
300 			{
301 				bRet = sal_False;
302 				break;
303 			}
304 		}
305 	}
306 
307 	return bRet;
308 }
309 
310 // ------------------------------------------------------------------------
311 
312 sal_Bool GDIMetaFile::IsEqual( const GDIMetaFile& rMtf ) const
313 {
314 	const sal_uLong nObjCount = Count();
315 	sal_Bool		bRet = sal_False;
316 
317 	if( this == &rMtf )
318 		bRet = sal_True;
319 	else if( rMtf.GetActionCount() == nObjCount &&
320 			 rMtf.GetPrefSize() == aPrefSize &&
321 			 rMtf.GetPrefMapMode() == aPrefMapMode )
322 	{
323 		bRet = sal_True;
324 
325 		for( sal_uLong n = 0UL; n < nObjCount; n++ )
326 		{
327 			if(!((MetaAction*)GetObject( n ))->IsEqual(*((MetaAction*)rMtf.GetObject( n ))))
328 			{
329 				bRet = sal_False;
330 				break;
331 			}
332 		}
333 	}
334 
335 	return bRet;
336 }
337 
338 // ------------------------------------------------------------------------
339 
340 void GDIMetaFile::Clear()
341 {
342 	if( bRecord )
343 		Stop();
344 
345 	for( void* pAct = First(); pAct; pAct = Next() )
346 		( (MetaAction*) pAct )->Delete();
347 
348 	List::Clear();
349 
350 	delete pLabelList;
351 	pLabelList = NULL;
352 }
353 
354 // ------------------------------------------------------------------------
355 
356 void GDIMetaFile::Linker( OutputDevice* pOut, sal_Bool bLink )
357 {
358 	if( bLink )
359 	{
360 		pNext = NULL;
361 		pPrev = pOut->GetConnectMetaFile();
362 		pOut->SetConnectMetaFile( this );
363 
364 		if( pPrev )
365 			pPrev->pNext = this;
366 	}
367 	else
368 	{
369 		if( pNext )
370 		{
371 			pNext->pPrev = pPrev;
372 
373 			if( pPrev )
374 				pPrev->pNext = pNext;
375 		}
376 		else
377 		{
378 			if( pPrev )
379 				pPrev->pNext = NULL;
380 
381 			pOut->SetConnectMetaFile( pPrev );
382 		}
383 
384 		pPrev = NULL;
385 		pNext = NULL;
386 	}
387 }
388 
389 // ------------------------------------------------------------------------
390 
391 long GDIMetaFile::Hook()
392 {
393 	return aHookHdlLink.Call( this );
394 }
395 
396 // ------------------------------------------------------------------------
397 
398 void GDIMetaFile::Record( OutputDevice* pOut )
399 {
400 	if( bRecord )
401 		Stop();
402 
403 	Last();
404 	pOutDev = pOut;
405 	bRecord = sal_True;
406 	Linker( pOut, sal_True );
407 }
408 
409 // ------------------------------------------------------------------------
410 
411 void GDIMetaFile::Play( GDIMetaFile& rMtf, sal_uLong nPos )
412 {
413 	if ( !bRecord && !rMtf.bRecord )
414 	{
415 		MetaAction* pAction = GetCurAction();
416 		const sal_uLong nObjCount = Count();
417 
418 		if( nPos > nObjCount )
419 			nPos = nObjCount;
420 
421 		for( sal_uLong nCurPos = GetCurPos(); nCurPos < nPos; nCurPos++ )
422 		{
423 			if( !Hook() )
424 			{
425 				pAction->Duplicate();
426 				rMtf.AddAction( pAction );
427 			}
428 
429 			pAction = (MetaAction*) Next();
430 		}
431 	}
432 }
433 
434 // ------------------------------------------------------------------------
435 
436 void GDIMetaFile::Play( OutputDevice* pOut, sal_uLong nPos )
437 {
438 	if( !bRecord )
439 	{
440 		MetaAction* pAction = GetCurAction();
441 		const sal_uLong nObjCount = Count();
442 		sal_uLong		i  = 0, nSyncCount = ( pOut->GetOutDevType() == OUTDEV_WINDOW ) ? 0x000000ff : 0xffffffff;
443 
444         if( nPos > nObjCount )
445 			nPos = nObjCount;
446 
447         // #i23407# Set backwards-compatible text language and layout mode
448         // This is necessary, since old metafiles don't even know of these
449 		// recent add-ons. Newer metafiles must of course explicitely set
450         // those states.
451         pOut->Push( PUSH_TEXTLAYOUTMODE|PUSH_TEXTLANGUAGE );
452         pOut->SetLayoutMode( 0 );
453         pOut->SetDigitLanguage( 0 );
454 
455 		for( sal_uLong nCurPos = GetCurPos(); nCurPos < nPos; nCurPos++ )
456 		{
457 			if( !Hook() )
458 			{
459 				pAction->Execute( pOut );
460 
461 				// flush output from time to time
462 				if( i++ > nSyncCount )
463 					( (Window*) pOut )->Flush(), i = 0;
464 			}
465 
466 			pAction = (MetaAction*) Next();
467 		}
468 
469         pOut->Pop();
470 	}
471 }
472 
473 // ------------------------------------------------------------------------
474 
475 void GDIMetaFile::Play( OutputDevice* pOut, const Point& rPos,
476 						const Size& rSize, sal_uLong nPos )
477 {
478 	Region	aDrawClipRegion;
479 	MapMode aDrawMap( GetPrefMapMode() );
480 	Size	aDestSize( pOut->LogicToPixel( rSize ) );
481 
482 	if( aDestSize.Width() && aDestSize.Height() )
483 	{
484 		Size			aTmpPrefSize( pOut->LogicToPixel( GetPrefSize(), aDrawMap ) );
485 		GDIMetaFile*	pMtf = pOut->GetConnectMetaFile();
486 
487 		if( !aTmpPrefSize.Width() )
488 			aTmpPrefSize.Width() = aDestSize.Width();
489 
490 		if( !aTmpPrefSize.Height() )
491 			aTmpPrefSize.Height() = aDestSize.Height();
492 
493 		Fraction aScaleX( aDestSize.Width(), aTmpPrefSize.Width() );
494 		Fraction aScaleY( aDestSize.Height(), aTmpPrefSize.Height() );
495 
496 		aScaleX *= aDrawMap.GetScaleX(); aDrawMap.SetScaleX( aScaleX );
497 		aScaleY *= aDrawMap.GetScaleY(); aDrawMap.SetScaleY( aScaleY );
498 
499         // #i47260# Convert logical output position to offset within
500         // the metafile's mapmode. Therefore, disable pixel offset on
501         // outdev, it's inverse mnOutOffLogicX/Y is calculated for a
502         // different mapmode (the one currently set on pOut, that is)
503         // - thus, aDrawMap's origin would generally be wrong. And
504         // even _if_ aDrawMap is similar to pOutDev's current mapmode,
505         // it's _still_ undesirable to have pixel offset unequal zero,
506         // because one would still get round-off errors (the
507         // round-trip error for LogicToPixel( PixelToLogic() ) was the
508         // reason for having pixel offset in the first place).
509         const Size& rOldOffset( pOut->GetPixelOffset() );
510         const Size  aEmptySize;
511         pOut->SetPixelOffset( aEmptySize );
512 		aDrawMap.SetOrigin( pOut->PixelToLogic( pOut->LogicToPixel( rPos ), aDrawMap ) );
513         pOut->SetPixelOffset( rOldOffset );
514 
515 		pOut->Push();
516 
517 		if ( pMtf && pMtf->IsRecord() && ( pOut->GetOutDevType() != OUTDEV_PRINTER ) )
518 			pOut->SetRelativeMapMode( aDrawMap );
519 		else
520 			pOut->SetMapMode( aDrawMap );
521 
522         // #i23407# Set backwards-compatible text language and layout mode
523         // This is necessary, since old metafiles don't even know of these
524 		// recent add-ons. Newer metafiles must of course explicitely set
525         // those states.
526         pOut->SetLayoutMode( 0 );
527         pOut->SetDigitLanguage( 0 );
528 
529 		Play( pOut, nPos );
530 
531 		pOut->Pop();
532 	}
533 }
534 
535 // ------------------------------------------------------------------------
536 
537 void GDIMetaFile::Pause( sal_Bool _bPause )
538 {
539 	if( bRecord )
540 	{
541 		if( _bPause )
542 		{
543 			if( !bPause )
544 				Linker( pOutDev, sal_False );
545 		}
546 		else
547 		{
548 			if( bPause )
549 				Linker( pOutDev, sal_True );
550 		}
551 
552 		bPause = _bPause;
553 	}
554 }
555 
556 // ------------------------------------------------------------------------
557 
558 void GDIMetaFile::Stop()
559 {
560 	if( bRecord )
561 	{
562 		bRecord = sal_False;
563 
564 		if( !bPause )
565 			Linker( pOutDev, sal_False );
566 		else
567 			bPause = sal_False;
568 	}
569 }
570 
571 // ------------------------------------------------------------------------
572 
573 void GDIMetaFile::WindStart()
574 {
575 	if( !bRecord )
576 		First();
577 }
578 
579 // ------------------------------------------------------------------------
580 
581 void GDIMetaFile::WindEnd()
582 {
583 	if( !bRecord )
584 		Last();
585 }
586 
587 // ------------------------------------------------------------------------
588 
589 void GDIMetaFile::Wind( sal_uLong nActionPos )
590 {
591 	if( !bRecord )
592 		Seek( nActionPos );
593 }
594 
595 // ------------------------------------------------------------------------
596 
597 void GDIMetaFile::WindPrev()
598 {
599 	if( !bRecord )
600 		Prev();
601 }
602 
603 // ------------------------------------------------------------------------
604 
605 void GDIMetaFile::WindNext()
606 {
607 	if( !bRecord )
608 		Next();
609 }
610 
611 // ------------------------------------------------------------------------
612 
613 void GDIMetaFile::AddAction( MetaAction* pAction )
614 {
615 	Insert( pAction, LIST_APPEND );
616 
617 	if( pPrev )
618 	{
619 		pAction->Duplicate();
620 		pPrev->AddAction( pAction );
621 	}
622 }
623 
624 // ------------------------------------------------------------------------
625 
626 void GDIMetaFile::AddAction( MetaAction* pAction, sal_uLong nPos )
627 {
628 	Insert( pAction, nPos );
629 
630 	if( pPrev )
631 	{
632 		pAction->Duplicate();
633 		pPrev->AddAction( pAction, nPos );
634 	}
635 }
636 
637 // ------------------------------------------------------------------------
638 
639 // @since #110496#
640 void GDIMetaFile::RemoveAction( sal_uLong nPos )
641 {
642 	Remove( nPos );
643 
644 	if( pPrev )
645 		pPrev->RemoveAction( nPos );
646 }
647 
648 // ------------------------------------------------------------------------
649 
650 MetaAction* GDIMetaFile::CopyAction( sal_uLong nPos ) const
651 {
652 	return ( (MetaAction*) GetObject( nPos ) )->Clone();
653 }
654 
655 // ------------------------------------------------------------------------
656 
657 sal_uLong GDIMetaFile::GetActionPos( const String& rLabel )
658 {
659 	ImpLabel* pLabel = NULL;
660 
661 	if( pLabelList )
662 		pLabel = pLabelList->ImplGetLabel( pLabelList->ImplGetLabelPos( rLabel ) );
663 	else
664 		pLabel = NULL;
665 
666 	return( pLabel ? pLabel->nActionPos : METAFILE_LABEL_NOTFOUND );
667 }
668 
669 // ------------------------------------------------------------------------
670 
671 sal_Bool GDIMetaFile::InsertLabel( const String& rLabel, sal_uLong nActionPos )
672 {
673 	sal_Bool bRet = sal_False;
674 
675 	if( !pLabelList )
676 		pLabelList = new ImpLabelList;
677 
678 	if( pLabelList->ImplGetLabelPos( rLabel ) == METAFILE_LABEL_NOTFOUND )
679 	{
680 		pLabelList->ImplInsert( new ImpLabel( rLabel, nActionPos ) );
681 		bRet = sal_True;
682 	}
683 
684 	return bRet;
685 }
686 
687 // ------------------------------------------------------------------------
688 
689 void GDIMetaFile::RemoveLabel( const String& rLabel )
690 {
691 	if( pLabelList )
692 	{
693 		const sal_uLong nLabelPos = pLabelList->ImplGetLabelPos( rLabel );
694 
695 		if( nLabelPos != METAFILE_LABEL_NOTFOUND )
696 			delete pLabelList->ImplRemove( nLabelPos );
697 	}
698 }
699 
700 // ------------------------------------------------------------------------
701 
702 void GDIMetaFile::RenameLabel( const String& rLabel, const String& rNewLabel )
703 {
704 	if( pLabelList )
705 	{
706 		const sal_uLong nLabelPos = pLabelList->ImplGetLabelPos( rLabel );
707 
708 		if ( nLabelPos != METAFILE_LABEL_NOTFOUND )
709 			pLabelList->ImplGetLabel( nLabelPos )->aLabelName = rNewLabel;
710 	}
711 }
712 
713 // ------------------------------------------------------------------------
714 
715 sal_uLong GDIMetaFile::GetLabelCount() const
716 {
717 	return( pLabelList ? pLabelList->ImplCount() : 0UL );
718 }
719 
720 // ------------------------------------------------------------------------
721 
722 String GDIMetaFile::GetLabel( sal_uLong nLabel )
723 {
724 	String aString;
725 
726 	if( pLabelList )
727 	{
728 		const ImpLabel* pLabel = pLabelList->ImplGetLabel( nLabel );
729 
730 		if( pLabel )
731 			aString = pLabel->aLabelName;
732 	}
733 
734 	return aString;
735 }
736 
737 // ------------------------------------------------------------------------
738 
739 sal_Bool GDIMetaFile::SaveStatus()
740 {
741 	if ( bRecord )
742 	{
743 		if ( bPause )
744 			Linker( pOutDev, sal_True );
745 
746 		AddAction( new MetaLineColorAction( pOutDev->GetLineColor(),
747 											pOutDev->IsLineColor() ) );
748 		AddAction( new MetaFillColorAction( pOutDev->GetFillColor(),
749 											pOutDev->IsFillColor() ) );
750 		AddAction( new MetaFontAction( pOutDev->GetFont() ) );
751 		AddAction( new MetaTextColorAction( pOutDev->GetTextColor() ) );
752 		AddAction( new MetaTextFillColorAction( pOutDev->GetTextFillColor(),
753 												pOutDev->IsTextFillColor() ) );
754 		AddAction( new MetaTextLineColorAction( pOutDev->GetTextLineColor(),
755 												pOutDev->IsTextLineColor() ) );
756 		AddAction( new MetaOverlineColorAction( pOutDev->GetOverlineColor(),
757 												pOutDev->IsOverlineColor() ) );
758 		AddAction( new MetaTextAlignAction( pOutDev->GetTextAlign() ) );
759 		AddAction( new MetaRasterOpAction( pOutDev->GetRasterOp() ) );
760 		AddAction( new MetaMapModeAction( pOutDev->GetMapMode() ) );
761 		AddAction( new MetaClipRegionAction( pOutDev->GetClipRegion(),
762 											 pOutDev->IsClipRegion() ) );
763 
764 		if ( bPause )
765 			Linker( pOutDev, sal_False );
766 
767 		return sal_True;
768 	}
769 	else
770 		return sal_False;
771 }
772 
773 // ------------------------------------------------------------------------
774 
775 sal_Bool GDIMetaFile::Mirror( sal_uLong nMirrorFlags )
776 {
777 	const Size	aOldPrefSize( GetPrefSize() );
778 	long	    nMoveX, nMoveY;
779 	double	    fScaleX, fScaleY;
780     sal_Bool        bRet;
781 
782 	if( nMirrorFlags & MTF_MIRROR_HORZ )
783 		nMoveX = VOS_ABS( aOldPrefSize.Width() ) - 1, fScaleX = -1.0;
784 	else
785 		nMoveX = 0, fScaleX = 1.0;
786 
787 	if( nMirrorFlags & MTF_MIRROR_VERT )
788 		nMoveY = VOS_ABS( aOldPrefSize.Height() ) - 1, fScaleY = -1.0;
789 	else
790 		nMoveY = 0, fScaleY = 1.0;
791 
792     if( ( fScaleX != 1.0 ) || ( fScaleY != 1.0 ) )
793     {
794 	    Scale( fScaleX, fScaleY );
795 	    Move( nMoveX, nMoveY );
796 	    SetPrefSize( aOldPrefSize );
797         bRet = sal_True;
798     }
799     else
800         bRet = sal_False;
801 
802     return bRet;
803 }
804 
805 // ------------------------------------------------------------------------
806 
807 void GDIMetaFile::Move( long nX, long nY )
808 {
809     const Size      aBaseOffset( nX, nY );
810     Size            aOffset( aBaseOffset );
811     VirtualDevice   aMapVDev;
812 
813     aMapVDev.EnableOutput( sal_False );
814     aMapVDev.SetMapMode( GetPrefMapMode() );
815 
816 	for( MetaAction* pAct = (MetaAction*) First(); pAct; pAct = (MetaAction*) Next() )
817 	{
818 		const long  nType = pAct->GetType();
819         MetaAction* pModAct;
820 
821 		if( pAct->GetRefCount() > 1 )
822 		{
823 			Replace( pModAct = pAct->Clone(), GetCurPos() );
824 			pAct->Delete();
825 		}
826 		else
827 			pModAct = pAct;
828 
829         if( ( META_MAPMODE_ACTION == nType ) ||
830             ( META_PUSH_ACTION == nType ) ||
831             ( META_POP_ACTION == nType ) )
832         {
833             pModAct->Execute( &aMapVDev );
834             aOffset = aMapVDev.LogicToLogic( aBaseOffset, GetPrefMapMode(), aMapVDev.GetMapMode() );
835         }
836 
837 		pModAct->Move( aOffset.Width(), aOffset.Height() );
838 	}
839 }
840 
841 void GDIMetaFile::Move( long nX, long nY, long nDPIX, long nDPIY )
842 {
843     const Size      aBaseOffset( nX, nY );
844     Size            aOffset( aBaseOffset );
845     VirtualDevice   aMapVDev;
846 
847     aMapVDev.EnableOutput( sal_False );
848     aMapVDev.SetReferenceDevice( nDPIX, nDPIY );
849     aMapVDev.SetMapMode( GetPrefMapMode() );
850 
851 	for( MetaAction* pAct = (MetaAction*) First(); pAct; pAct = (MetaAction*) Next() )
852 	{
853 		const long  nType = pAct->GetType();
854         MetaAction* pModAct;
855 
856 		if( pAct->GetRefCount() > 1 )
857 		{
858 			Replace( pModAct = pAct->Clone(), GetCurPos() );
859 			pAct->Delete();
860 		}
861 		else
862 			pModAct = pAct;
863 
864         if( ( META_MAPMODE_ACTION == nType ) ||
865             ( META_PUSH_ACTION == nType ) ||
866             ( META_POP_ACTION == nType ) )
867         {
868             pModAct->Execute( &aMapVDev );
869             if( aMapVDev.GetMapMode().GetMapUnit() == MAP_PIXEL )
870             {
871                 aOffset = aMapVDev.LogicToPixel( aBaseOffset, GetPrefMapMode() );
872                 MapMode aMap( aMapVDev.GetMapMode() );
873                 aOffset.Width() = static_cast<long>(aOffset.Width() * (double)aMap.GetScaleX());
874                 aOffset.Height() = static_cast<long>(aOffset.Height() * (double)aMap.GetScaleY());
875             }
876             else
877                 aOffset = aMapVDev.LogicToLogic( aBaseOffset, GetPrefMapMode(), aMapVDev.GetMapMode() );
878         }
879 
880 		pModAct->Move( aOffset.Width(), aOffset.Height() );
881 	}
882 }
883 
884 // ------------------------------------------------------------------------
885 
886 void GDIMetaFile::Scale( double fScaleX, double fScaleY )
887 {
888 	for( MetaAction* pAct = (MetaAction*) First(); pAct; pAct = (MetaAction*) Next() )
889 	{
890 		MetaAction* pModAct;
891 
892 		if( pAct->GetRefCount() > 1 )
893 		{
894             Replace( pModAct = pAct->Clone(), GetCurPos() );
895 			pAct->Delete();
896 		}
897 		else
898 			pModAct = pAct;
899 
900 		pModAct->Scale( fScaleX, fScaleY );
901 	}
902 
903 	aPrefSize.Width() = FRound( aPrefSize.Width() * fScaleX );
904 	aPrefSize.Height() = FRound( aPrefSize.Height() * fScaleY );
905 }
906 
907 // ------------------------------------------------------------------------
908 
909 void GDIMetaFile::Scale( const Fraction& rScaleX, const Fraction& rScaleY )
910 {
911 	Scale( (double) rScaleX, (double) rScaleY );
912 }
913 
914 // ------------------------------------------------------------------------
915 
916 void GDIMetaFile::Clip( const Rectangle& i_rClipRect )
917 {
918     Rectangle aCurRect( i_rClipRect );
919     VirtualDevice   aMapVDev;
920 
921     aMapVDev.EnableOutput( sal_False );
922     aMapVDev.SetMapMode( GetPrefMapMode() );
923 
924     for( MetaAction* pAct = (MetaAction*) First(); pAct; pAct = (MetaAction*) Next() )
925     {
926         const long  nType = pAct->GetType();
927 
928         if( ( META_MAPMODE_ACTION == nType ) ||
929             ( META_PUSH_ACTION == nType ) ||
930             ( META_POP_ACTION == nType ) )
931         {
932             pAct->Execute( &aMapVDev );
933             aCurRect = aMapVDev.LogicToLogic( i_rClipRect, GetPrefMapMode(), aMapVDev.GetMapMode() );
934         }
935         else if( nType == META_CLIPREGION_ACTION )
936         {
937             MetaClipRegionAction* pOldAct = (MetaClipRegionAction*)pAct;
938             Region aNewReg( aCurRect );
939             if( pOldAct->IsClipping() )
940                 aNewReg.Intersect( pOldAct->GetRegion() );
941             MetaClipRegionAction* pNewAct = new MetaClipRegionAction( aNewReg, sal_True );
942             Replace( pNewAct, GetCurPos() );
943             pOldAct->Delete();
944         }
945     }
946 }
947 
948 // ------------------------------------------------------------------------
949 
950 Point GDIMetaFile::ImplGetRotatedPoint( const Point& rPt, const Point& rRotatePt,
951                                         const Size& rOffset, double fSin, double fCos )
952 {
953     const long nX = rPt.X() - rRotatePt.X();
954     const long nY = rPt.Y() - rRotatePt.Y();
955 
956     return Point( FRound( fCos * nX + fSin * nY ) + rRotatePt.X() + rOffset.Width(),
957                   -FRound( fSin * nX - fCos * nY ) + rRotatePt.Y() + rOffset.Height() );
958 }
959 
960 // ------------------------------------------------------------------------
961 
962 Polygon GDIMetaFile::ImplGetRotatedPolygon( const Polygon& rPoly, const Point& rRotatePt,
963                                             const Size& rOffset, double fSin, double fCos )
964 {
965     Polygon aRet( rPoly );
966 
967     aRet.Rotate( rRotatePt, fSin, fCos );
968     aRet.Move( rOffset.Width(), rOffset.Height() );
969 
970     return aRet;
971 }
972 
973 // ------------------------------------------------------------------------
974 
975 PolyPolygon GDIMetaFile::ImplGetRotatedPolyPolygon( const PolyPolygon& rPolyPoly, const Point& rRotatePt,
976                                                     const Size& rOffset, double fSin, double fCos )
977 {
978     PolyPolygon aRet( rPolyPoly );
979 
980     aRet.Rotate( rRotatePt, fSin, fCos );
981     aRet.Move( rOffset.Width(), rOffset.Height() );
982 
983     return aRet;
984 }
985 
986 // ------------------------------------------------------------------------
987 
988 void GDIMetaFile::ImplAddGradientEx( GDIMetaFile& 		  rMtf,
989                                      const OutputDevice&  rMapDev,
990                                      const PolyPolygon&   rPolyPoly,
991                                      const Gradient&	  rGrad 	)
992 {
993     // #105055# Generate comment, GradientEx and Gradient actions
994     // (within DrawGradient)
995     VirtualDevice aVDev( rMapDev, 0 );
996     aVDev.EnableOutput( sal_False );
997     GDIMetaFile	aGradMtf;
998 
999     aGradMtf.Record( &aVDev );
1000     aVDev.DrawGradient( rPolyPoly, rGrad );
1001     aGradMtf.Stop();
1002 
1003     int i, nAct( aGradMtf.GetActionCount() );
1004     for( i=0; i<nAct; ++i )
1005     {
1006         MetaAction* pMetaAct = aGradMtf.GetAction(i);
1007         pMetaAct->Duplicate();
1008         rMtf.AddAction( pMetaAct );
1009     }
1010 }
1011 
1012 // ------------------------------------------------------------------------
1013 
1014 void GDIMetaFile::Rotate( long nAngle10 )
1015 {
1016 	nAngle10 %= 3600L;
1017 	nAngle10 = ( nAngle10 < 0L ) ? ( 3599L + nAngle10 ) : nAngle10;
1018 
1019     if( nAngle10 )
1020     {
1021 	    GDIMetaFile     aMtf;
1022         VirtualDevice   aMapVDev;
1023 	    const double    fAngle = F_PI1800 * nAngle10;
1024         const double    fSin = sin( fAngle );
1025         const double    fCos = cos( fAngle );
1026 		Rectangle		aRect=Rectangle( Point(), GetPrefSize() );
1027         Polygon         aPoly( aRect );
1028 
1029         aPoly.Rotate( Point(), fSin, fCos );
1030 
1031         aMapVDev.EnableOutput( sal_False );
1032         aMapVDev.SetMapMode( GetPrefMapMode() );
1033 
1034         const Rectangle aNewBound( aPoly.GetBoundRect() );
1035 
1036         const Point aOrigin( GetPrefMapMode().GetOrigin().X(), GetPrefMapMode().GetOrigin().Y() );
1037         const Size  aOffset( -aNewBound.Left(), -aNewBound.Top() );
1038 
1039         Point     aRotAnchor( aOrigin );
1040         Size      aRotOffset( aOffset );
1041 
1042 	    for( MetaAction* pAction = (MetaAction*) First(); pAction; pAction = (MetaAction*) Next() )
1043 	    {
1044 		    const sal_uInt16 nActionType = pAction->GetType();
1045 
1046 		    switch( nActionType )
1047 		    {
1048 			    case( META_PIXEL_ACTION ):
1049 			    {
1050 				    MetaPixelAction* pAct = (MetaPixelAction*) pAction;
1051 				    aMtf.AddAction( new MetaPixelAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
1052                                                                               pAct->GetColor() ) );
1053 			    }
1054 			    break;
1055 
1056 			    case( META_POINT_ACTION ):
1057 			    {
1058 				    MetaPointAction* pAct = (MetaPointAction*) pAction;
1059 				    aMtf.AddAction( new MetaPointAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
1060 			    }
1061 			    break;
1062 
1063                 case( META_LINE_ACTION ):
1064                 {
1065 				    MetaLineAction* pAct = (MetaLineAction*) pAction;
1066                     aMtf.AddAction( new MetaLineAction( ImplGetRotatedPoint( pAct->GetStartPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
1067                                                         ImplGetRotatedPoint( pAct->GetEndPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
1068                                                         pAct->GetLineInfo() ) );
1069                 }
1070                 break;
1071 
1072                 case( META_RECT_ACTION ):
1073                 {
1074 				    MetaRectAction* pAct = (MetaRectAction*) pAction;
1075                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( pAct->GetRect(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
1076                 }
1077                 break;
1078 
1079                 case( META_ROUNDRECT_ACTION ):
1080                 {
1081 				    MetaRoundRectAction*    pAct = (MetaRoundRectAction*) pAction;
1082                     const Polygon           aRoundRectPoly( pAct->GetRect(), pAct->GetHorzRound(), pAct->GetVertRound() );
1083 
1084                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aRoundRectPoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
1085                 }
1086                 break;
1087 
1088                 case( META_ELLIPSE_ACTION ):
1089                 {
1090 				    MetaEllipseAction*      pAct = (MetaEllipseAction*) pAction;
1091                     const Polygon           aEllipsePoly( pAct->GetRect().Center(), pAct->GetRect().GetWidth() >> 1, pAct->GetRect().GetHeight() >> 1 );
1092 
1093                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aEllipsePoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
1094                 }
1095                 break;
1096 
1097                 case( META_ARC_ACTION ):
1098                 {
1099 				    MetaArcAction*  pAct = (MetaArcAction*) pAction;
1100                     const Polygon   aArcPoly( pAct->GetRect(), pAct->GetStartPoint(), pAct->GetEndPoint(), POLY_ARC );
1101 
1102                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aArcPoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
1103                 }
1104                 break;
1105 
1106                 case( META_PIE_ACTION ):
1107                 {
1108 				    MetaPieAction*  pAct = (MetaPieAction*) pAction;
1109                     const Polygon   aPiePoly( pAct->GetRect(), pAct->GetStartPoint(), pAct->GetEndPoint(), POLY_PIE );
1110 
1111                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aPiePoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
1112                 }
1113                 break;
1114 
1115                 case( META_CHORD_ACTION	):
1116                 {
1117 				    MetaChordAction*    pAct = (MetaChordAction*) pAction;
1118                     const Polygon       aChordPoly( pAct->GetRect(), pAct->GetStartPoint(), pAct->GetEndPoint(), POLY_CHORD );
1119 
1120                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( aChordPoly, aRotAnchor, aRotOffset, fSin, fCos ) ) );
1121                 }
1122                 break;
1123 
1124                 case( META_POLYLINE_ACTION ):
1125                 {
1126 				    MetaPolyLineAction* pAct = (MetaPolyLineAction*) pAction;
1127                     aMtf.AddAction( new MetaPolyLineAction( ImplGetRotatedPolygon( pAct->GetPolygon(), aRotAnchor, aRotOffset, fSin, fCos ), pAct->GetLineInfo() ) );
1128                 }
1129                 break;
1130 
1131                 case( META_POLYGON_ACTION ):
1132                 {
1133 				    MetaPolygonAction* pAct = (MetaPolygonAction*) pAction;
1134                     aMtf.AddAction( new MetaPolygonAction( ImplGetRotatedPolygon( pAct->GetPolygon(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
1135                 }
1136                 break;
1137 
1138                 case( META_POLYPOLYGON_ACTION ):
1139                 {
1140 				    MetaPolyPolygonAction* pAct = (MetaPolyPolygonAction*) pAction;
1141                     aMtf.AddAction( new MetaPolyPolygonAction( ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
1142                 }
1143                 break;
1144 
1145                 case( META_TEXT_ACTION ):
1146                 {
1147 				    MetaTextAction* pAct = (MetaTextAction*) pAction;
1148                     aMtf.AddAction( new MetaTextAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
1149                                                                              pAct->GetText(), pAct->GetIndex(), pAct->GetLen() ) );
1150                 }
1151                 break;
1152 
1153                 case( META_TEXTARRAY_ACTION	):
1154                 {
1155 				    MetaTextArrayAction* pAct = (MetaTextArrayAction*) pAction;
1156                     aMtf.AddAction( new MetaTextArrayAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
1157                                                                                   pAct->GetText(), pAct->GetDXArray(), pAct->GetIndex(), pAct->GetLen() ) );
1158                 }
1159                 break;
1160 
1161                 case( META_STRETCHTEXT_ACTION ):
1162                 {
1163 				    MetaStretchTextAction* pAct = (MetaStretchTextAction*) pAction;
1164                     aMtf.AddAction( new MetaStretchTextAction( ImplGetRotatedPoint( pAct->GetPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
1165                                                                                     pAct->GetWidth(), pAct->GetText(), pAct->GetIndex(), pAct->GetLen() ) );
1166                 }
1167                 break;
1168 
1169                 case( META_TEXTLINE_ACTION ):
1170                 {
1171 				    MetaTextLineAction* pAct = (MetaTextLineAction*) pAction;
1172                     aMtf.AddAction( new MetaTextLineAction( ImplGetRotatedPoint( pAct->GetStartPoint(), aRotAnchor, aRotOffset, fSin, fCos ),
1173                                                                                  pAct->GetWidth(), pAct->GetStrikeout(), pAct->GetUnderline(), pAct->GetOverline() ) );
1174                 }
1175                 break;
1176 
1177 			    case( META_BMPSCALE_ACTION ):
1178 			    {
1179 				    MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
1180                     Polygon             aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
1181                     Rectangle           aBmpRect( aBmpPoly.GetBoundRect() );
1182                     BitmapEx            aBmpEx( pAct->GetBitmap() );
1183 
1184                     aBmpEx.Rotate( nAngle10, Color( COL_TRANSPARENT ) );
1185                     aMtf.AddAction( new MetaBmpExScaleAction( aBmpRect.TopLeft(), aBmpRect.GetSize(),
1186                                                               aBmpEx ) );
1187 			    }
1188 			    break;
1189 
1190 			    case( META_BMPSCALEPART_ACTION ):
1191 			    {
1192 				    MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
1193                     Polygon                 aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetDestPoint(), pAct->GetDestSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
1194                     Rectangle               aBmpRect( aBmpPoly.GetBoundRect() );
1195                     BitmapEx                aBmpEx( pAct->GetBitmap() );
1196 
1197                     aBmpEx.Crop( Rectangle( pAct->GetSrcPoint(), pAct->GetSrcSize() ) );
1198                     aBmpEx.Rotate( nAngle10, Color( COL_TRANSPARENT ) );
1199 
1200                     aMtf.AddAction( new MetaBmpExScaleAction( aBmpRect.TopLeft(), aBmpRect.GetSize(), aBmpEx ) );
1201 			    }
1202 			    break;
1203 
1204 			    case( META_BMPEXSCALE_ACTION ):
1205 			    {
1206 				    MetaBmpExScaleAction*   pAct = (MetaBmpExScaleAction*) pAction;
1207                     Polygon                 aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
1208                     Rectangle               aBmpRect( aBmpPoly.GetBoundRect() );
1209                     BitmapEx                aBmpEx( pAct->GetBitmapEx() );
1210 
1211                     aBmpEx.Rotate( nAngle10, Color( COL_TRANSPARENT ) );
1212 
1213                     aMtf.AddAction( new MetaBmpExScaleAction( aBmpRect.TopLeft(), aBmpRect.GetSize(), aBmpEx ) );
1214 			    }
1215 			    break;
1216 
1217 			    case( META_BMPEXSCALEPART_ACTION ):
1218 			    {
1219 				    MetaBmpExScalePartAction*   pAct = (MetaBmpExScalePartAction*) pAction;
1220                     Polygon                     aBmpPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetDestPoint(), pAct->GetDestSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
1221                     Rectangle                   aBmpRect( aBmpPoly.GetBoundRect() );
1222                     BitmapEx                    aBmpEx( pAct->GetBitmapEx() );
1223 
1224                     aBmpEx.Crop( Rectangle( pAct->GetSrcPoint(), pAct->GetSrcSize() ) );
1225                     aBmpEx.Rotate( nAngle10, Color( COL_TRANSPARENT ) );
1226 
1227                     aMtf.AddAction( new MetaBmpExScaleAction( aBmpRect.TopLeft(), aBmpRect.GetSize(), aBmpEx ) );
1228 			    }
1229 			    break;
1230 
1231 			    case( META_GRADIENT_ACTION ):
1232 			    {
1233 				    MetaGradientAction* pAct = (MetaGradientAction*) pAction;
1234 
1235                     ImplAddGradientEx( aMtf, aMapVDev,
1236                                        ImplGetRotatedPolygon( pAct->GetRect(), aRotAnchor, aRotOffset, fSin, fCos ),
1237                                        pAct->GetGradient() );
1238 			    }
1239 			    break;
1240 
1241 			    case( META_GRADIENTEX_ACTION ):
1242 			    {
1243 				    MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
1244 				    aMtf.AddAction( new MetaGradientExAction( ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ),
1245                                                               pAct->GetGradient() ) );
1246 			    }
1247 			    break;
1248 
1249                 // #105055# Handle gradientex comment block correctly
1250                 case( META_COMMENT_ACTION ):
1251                 {
1252 				    MetaCommentAction* pCommentAct = (MetaCommentAction*) pAction;
1253                     if( pCommentAct->GetComment().Equals( "XGRAD_SEQ_BEGIN" ) )
1254                     {
1255                         int nBeginComments( 1 );
1256                         pAction = (MetaAction*) Next();
1257 
1258                         // skip everything, except gradientex action
1259                         while( pAction )
1260                         {
1261                             const sal_uInt16 nType = pAction->GetType();
1262 
1263                             if( META_GRADIENTEX_ACTION == nType )
1264                             {
1265                                 // Add rotated gradientex
1266                                 MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
1267                                 ImplAddGradientEx( aMtf, aMapVDev,
1268                                                    ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ),
1269                                                    pAct->GetGradient() );
1270                             }
1271                             else if( META_COMMENT_ACTION == nType)
1272                             {
1273                                 MetaCommentAction* pAct = (MetaCommentAction*) pAction;
1274                                 if( pAct->GetComment().Equals( "XGRAD_SEQ_END" ) )
1275                                 {
1276                                     // handle nested blocks
1277                                     --nBeginComments;
1278 
1279                                     // gradientex comment block: end reached, done.
1280                                     if( !nBeginComments )
1281                                         break;
1282                                 }
1283                                 else if( pAct->GetComment().Equals( "XGRAD_SEQ_BEGIN" ) )
1284                                 {
1285                                     // handle nested blocks
1286                                     ++nBeginComments;
1287                                 }
1288 
1289                             }
1290 
1291                             pAction = (MetaAction*) Next();
1292                         }
1293                     }
1294 					else
1295 					{
1296 						sal_Bool bPathStroke = pCommentAct->GetComment().Equals( "XPATHSTROKE_SEQ_BEGIN" );
1297 						if ( bPathStroke || pCommentAct->GetComment().Equals( "XPATHFILL_SEQ_BEGIN" ) )
1298 						{
1299 							if ( pCommentAct->GetDataSize() )
1300 							{
1301 								SvMemoryStream aMemStm( (void*)pCommentAct->GetData(), pCommentAct->GetDataSize(), STREAM_READ );
1302 								SvMemoryStream aDest;
1303 								if ( bPathStroke )
1304 								{
1305 									SvtGraphicStroke aStroke;
1306 									aMemStm >> aStroke;
1307 									Polygon aPath;
1308 									aStroke.getPath( aPath );
1309 									aStroke.setPath( ImplGetRotatedPolygon( aPath, aRotAnchor, aRotOffset, fSin, fCos ) );
1310 									aDest << aStroke;
1311 									aMtf.AddAction( new MetaCommentAction( "XPATHSTROKE_SEQ_BEGIN", 0,
1312 														static_cast<const sal_uInt8*>( aDest.GetData()), aDest.Tell() ) );
1313 								}
1314 								else
1315 								{
1316 									SvtGraphicFill aFill;
1317 									aMemStm >> aFill;
1318 									PolyPolygon aPath;
1319 									aFill.getPath( aPath );
1320 									aFill.setPath( ImplGetRotatedPolyPolygon( aPath, aRotAnchor, aRotOffset, fSin, fCos ) );
1321 									aDest << aFill;
1322 									aMtf.AddAction( new MetaCommentAction( "XPATHFILL_SEQ_BEGIN", 0,
1323 														static_cast<const sal_uInt8*>( aDest.GetData()), aDest.Tell() ) );
1324 								}
1325 							}
1326 						}
1327 						else if ( pCommentAct->GetComment().Equals( "XPATHSTROKE_SEQ_END" )
1328 							   || pCommentAct->GetComment().Equals( "XPATHFILL_SEQ_END" ) )
1329 						{
1330 						    pAction->Execute( &aMapVDev );
1331 						    pAction->Duplicate();
1332 						    aMtf.AddAction( pAction );
1333 						}
1334 					}
1335                 }
1336                 break;
1337 
1338 			    case( META_HATCH_ACTION ):
1339 			    {
1340 				    MetaHatchAction*	pAct = (MetaHatchAction*) pAction;
1341 				    Hatch				aHatch( pAct->GetHatch() );
1342 
1343                     aHatch.SetAngle( aHatch.GetAngle() + (sal_uInt16) nAngle10 );
1344 				    aMtf.AddAction( new MetaHatchAction( ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ),
1345                                                                                     aHatch ) );
1346 			    }
1347 			    break;
1348 
1349                 case( META_TRANSPARENT_ACTION ):
1350                 {
1351 				    MetaTransparentAction* pAct = (MetaTransparentAction*) pAction;
1352 				    aMtf.AddAction( new MetaTransparentAction( ImplGetRotatedPolyPolygon( pAct->GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ),
1353                                                                                           pAct->GetTransparence() ) );
1354                 }
1355                 break;
1356 
1357 			    case( META_FLOATTRANSPARENT_ACTION ):
1358 			    {
1359 				    MetaFloatTransparentAction* pAct = (MetaFloatTransparentAction*) pAction;
1360 				    GDIMetaFile					aTransMtf( pAct->GetGDIMetaFile() );
1361                     Polygon                     aMtfPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
1362                     Rectangle                   aMtfRect( aMtfPoly.GetBoundRect() );
1363 
1364                     aTransMtf.Rotate( nAngle10 );
1365 				    aMtf.AddAction( new MetaFloatTransparentAction( aTransMtf, aMtfRect.TopLeft(), aMtfRect.GetSize(),
1366                                                                     pAct->GetGradient() ) );
1367 			    }
1368 			    break;
1369 
1370 			    case( META_EPS_ACTION ):
1371 			    {
1372 				    MetaEPSAction*	pAct = (MetaEPSAction*) pAction;
1373 				    GDIMetaFile		aEPSMtf( pAct->GetSubstitute() );
1374                     Polygon         aEPSPoly( ImplGetRotatedPolygon( Rectangle( pAct->GetPoint(), pAct->GetSize() ), aRotAnchor, aRotOffset, fSin, fCos ) );
1375                     Rectangle       aEPSRect( aEPSPoly.GetBoundRect() );
1376 
1377                     aEPSMtf.Rotate( nAngle10 );
1378 				    aMtf.AddAction( new MetaEPSAction( aEPSRect.TopLeft(), aEPSRect.GetSize(),
1379 												       pAct->GetLink(), aEPSMtf ) );
1380 			    }
1381 			    break;
1382 
1383                 case( META_CLIPREGION_ACTION ):
1384                 {
1385 				    MetaClipRegionAction* pAct = (MetaClipRegionAction*) pAction;
1386 
1387                     if( pAct->IsClipping() && pAct->GetRegion().HasPolyPolygon() )
1388                         aMtf.AddAction( new MetaClipRegionAction( Region( ImplGetRotatedPolyPolygon( pAct->GetRegion().GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ) ), sal_True ) );
1389                     else
1390                     {
1391 				        pAction->Duplicate();
1392 				        aMtf.AddAction( pAction );
1393                     }
1394                 }
1395                 break;
1396 
1397                 case( META_ISECTRECTCLIPREGION_ACTION ):
1398                 {
1399 				    MetaISectRectClipRegionAction*	pAct = (MetaISectRectClipRegionAction*) pAction;
1400                     aMtf.AddAction( new MetaISectRegionClipRegionAction( ImplGetRotatedPolygon( pAct->GetRect(), aRotAnchor, aRotOffset, fSin, fCos ) ) );
1401                 }
1402                 break;
1403 
1404                 case( META_ISECTREGIONCLIPREGION_ACTION	):
1405                 {
1406 				    MetaISectRegionClipRegionAction*    pAct = (MetaISectRegionClipRegionAction*) pAction;
1407                     const Region&                       rRegion = pAct->GetRegion();
1408 
1409                     if( rRegion.HasPolyPolygon() )
1410                         aMtf.AddAction( new MetaISectRegionClipRegionAction( Region( ImplGetRotatedPolyPolygon( rRegion.GetPolyPolygon(), aRotAnchor, aRotOffset, fSin, fCos ) ) ) );
1411                     else
1412                     {
1413 				        pAction->Duplicate();
1414 				        aMtf.AddAction( pAction );
1415                     }
1416                 }
1417                 break;
1418 
1419                 case( META_REFPOINT_ACTION ):
1420                 {
1421 				    MetaRefPointAction* pAct = (MetaRefPointAction*) pAction;
1422                     aMtf.AddAction( new MetaRefPointAction( ImplGetRotatedPoint( pAct->GetRefPoint(), aRotAnchor, aRotOffset, fSin, fCos ), pAct->IsSetting() ) );
1423                 }
1424                 break;
1425 
1426 			    case( META_FONT_ACTION ):
1427 			    {
1428 				    MetaFontAction* pAct = (MetaFontAction*) pAction;
1429 				    Font			aFont( pAct->GetFont() );
1430 
1431 				    aFont.SetOrientation( aFont.GetOrientation() + (sal_uInt16) nAngle10 );
1432 				    aMtf.AddAction( new MetaFontAction( aFont ) );
1433 			    }
1434 			    break;
1435 
1436 			    case( META_BMP_ACTION ):
1437 			    case( META_BMPEX_ACTION ):
1438 			    case( META_MASK_ACTION ):
1439 			    case( META_MASKSCALE_ACTION ):
1440 			    case( META_MASKSCALEPART_ACTION ):
1441                 case( META_WALLPAPER_ACTION ):
1442                 case( META_TEXTRECT_ACTION ):
1443                 case( META_MOVECLIPREGION_ACTION ):
1444 			    {
1445 				    DBG_ERROR( "GDIMetaFile::Rotate(): unsupported action" );
1446 			    }
1447 			    break;
1448 
1449 			    default:
1450 			    {
1451                     pAction->Execute( &aMapVDev );
1452 				    pAction->Duplicate();
1453 				    aMtf.AddAction( pAction );
1454 
1455                     // update rotation point and offset, if necessary
1456                     if( ( META_MAPMODE_ACTION == nActionType ) ||
1457                         ( META_PUSH_ACTION == nActionType ) ||
1458                         ( META_POP_ACTION == nActionType ) )
1459                     {
1460                         aRotAnchor = aMapVDev.LogicToLogic( aOrigin, aPrefMapMode, aMapVDev.GetMapMode() );
1461                         aRotOffset = aMapVDev.LogicToLogic( aOffset, aPrefMapMode, aMapVDev.GetMapMode() );
1462                     }
1463 			    }
1464 			    break;
1465 		    }
1466 	    }
1467 
1468 	    aMtf.aPrefMapMode = aPrefMapMode;
1469 	    aMtf.aPrefSize = aNewBound.GetSize();
1470 
1471 	    *this = aMtf;
1472     }
1473 }
1474 
1475 // ------------------------------------------------------------------------
1476 
1477 static void ImplActionBounds( Rectangle& o_rOutBounds,
1478                               const Rectangle& i_rInBounds,
1479                               const std::vector<Rectangle>& i_rClipStack,
1480                               Rectangle* o_pHairline )
1481 {
1482     Rectangle aBounds( i_rInBounds );
1483     if( ! i_rInBounds.IsEmpty() && ! i_rClipStack.empty() && ! i_rClipStack.back().IsEmpty() )
1484         aBounds.Intersection( i_rClipStack.back() );
1485     if( ! aBounds.IsEmpty() )
1486     {
1487         if( ! o_rOutBounds.IsEmpty() )
1488             o_rOutBounds.Union( aBounds );
1489         else
1490             o_rOutBounds = aBounds;
1491 
1492         if(o_pHairline)
1493         {
1494             if( ! o_pHairline->IsEmpty() )
1495                 o_pHairline->Union( aBounds );
1496             else
1497                 *o_pHairline = aBounds;
1498         }
1499     }
1500 }
1501 
1502 Rectangle GDIMetaFile::GetBoundRect( OutputDevice& i_rReference, Rectangle* pHairline ) const
1503 {
1504     GDIMetaFile     aMtf;
1505     VirtualDevice   aMapVDev( i_rReference );
1506 
1507     aMapVDev.EnableOutput( sal_False );
1508     aMapVDev.SetMapMode( GetPrefMapMode() );
1509 
1510     std::vector<Rectangle> aClipStack( 1, Rectangle() );
1511     std::vector<sal_uInt16> aPushFlagStack;
1512 
1513     Rectangle aBound;
1514 
1515     if(pHairline)
1516     {
1517         *pHairline = Rectangle();
1518     }
1519 
1520     const sal_uLong nActionCount(GetActionCount());
1521 
1522     for(sal_uLong a(0); a < nActionCount; a++)
1523     {
1524         MetaAction* pAction = GetAction(a);
1525         const sal_uInt16 nActionType = pAction->GetType();
1526         Rectangle* pUseHairline = (pHairline && aMapVDev.IsLineColor()) ? pHairline : 0;
1527 
1528         switch( nActionType )
1529         {
1530         case( META_PIXEL_ACTION ):
1531         {
1532             MetaPixelAction* pAct = (MetaPixelAction*) pAction;
1533             ImplActionBounds( aBound,
1534                              Rectangle( aMapVDev.LogicToLogic( pAct->GetPoint(), aMapVDev.GetMapMode(), GetPrefMapMode() ),
1535                                        aMapVDev.PixelToLogic( Size( 1, 1 ), GetPrefMapMode() ) ),
1536                              aClipStack, pUseHairline );
1537         }
1538         break;
1539 
1540         case( META_POINT_ACTION ):
1541         {
1542             MetaPointAction* pAct = (MetaPointAction*) pAction;
1543             ImplActionBounds( aBound,
1544                              Rectangle( aMapVDev.LogicToLogic( pAct->GetPoint(), aMapVDev.GetMapMode(), GetPrefMapMode() ),
1545                                        aMapVDev.PixelToLogic( Size( 1, 1 ), GetPrefMapMode() ) ),
1546                              aClipStack, pUseHairline );
1547         }
1548         break;
1549 
1550         case( META_LINE_ACTION ):
1551         {
1552             MetaLineAction* pAct = (MetaLineAction*) pAction;
1553             Point aP1( pAct->GetStartPoint() ), aP2( pAct->GetEndPoint() );
1554             Rectangle aRect( aP1, aP2 );
1555             aRect.Justify();
1556 
1557             if(pUseHairline)
1558             {
1559                 const LineInfo& rLineInfo = pAct->GetLineInfo();
1560 
1561                 if(0 != rLineInfo.GetWidth())
1562                 {
1563                     pUseHairline = 0;
1564                 }
1565             }
1566 
1567             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1568         }
1569         break;
1570 
1571         case( META_RECT_ACTION ):
1572         {
1573             MetaRectAction* pAct = (MetaRectAction*) pAction;
1574             ImplActionBounds( aBound, aMapVDev.LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1575         }
1576         break;
1577 
1578         case( META_ROUNDRECT_ACTION ):
1579         {
1580             MetaRoundRectAction*    pAct = (MetaRoundRectAction*) pAction;
1581             ImplActionBounds( aBound, aMapVDev.LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1582         }
1583         break;
1584 
1585         case( META_ELLIPSE_ACTION ):
1586         {
1587             MetaEllipseAction*      pAct = (MetaEllipseAction*) pAction;
1588             ImplActionBounds( aBound, aMapVDev.LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1589         }
1590         break;
1591 
1592         case( META_ARC_ACTION ):
1593         {
1594             MetaArcAction*  pAct = (MetaArcAction*) pAction;
1595             // FIXME: this is imprecise
1596             // e.g. for small arcs the whole rectangle is WAY too large
1597             ImplActionBounds( aBound, aMapVDev.LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1598         }
1599         break;
1600 
1601         case( META_PIE_ACTION ):
1602         {
1603             MetaPieAction*  pAct = (MetaPieAction*) pAction;
1604             // FIXME: this is imprecise
1605             // e.g. for small arcs the whole rectangle is WAY too large
1606             ImplActionBounds( aBound, aMapVDev.LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1607         }
1608         break;
1609 
1610         case( META_CHORD_ACTION	):
1611         {
1612             MetaChordAction*    pAct = (MetaChordAction*) pAction;
1613             // FIXME: this is imprecise
1614             // e.g. for small arcs the whole rectangle is WAY too large
1615             ImplActionBounds( aBound, aMapVDev.LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1616         }
1617         break;
1618 
1619         case( META_POLYLINE_ACTION ):
1620         {
1621             MetaPolyLineAction* pAct = (MetaPolyLineAction*) pAction;
1622             Rectangle aRect( pAct->GetPolygon().GetBoundRect() );
1623 
1624             if(pUseHairline)
1625             {
1626                 const LineInfo& rLineInfo = pAct->GetLineInfo();
1627 
1628                 if(0 != rLineInfo.GetWidth())
1629                 {
1630                     pUseHairline = 0;
1631                 }
1632             }
1633 
1634             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1635         }
1636         break;
1637 
1638         case( META_POLYGON_ACTION ):
1639         {
1640             MetaPolygonAction* pAct = (MetaPolygonAction*) pAction;
1641             Rectangle aRect( pAct->GetPolygon().GetBoundRect() );
1642             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1643         }
1644         break;
1645 
1646         case( META_POLYPOLYGON_ACTION ):
1647         {
1648             MetaPolyPolygonAction* pAct = (MetaPolyPolygonAction*) pAction;
1649             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
1650             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, pUseHairline );
1651         }
1652         break;
1653 
1654         case( META_TEXT_ACTION ):
1655         {
1656             MetaTextAction* pAct = (MetaTextAction*) pAction;
1657             Rectangle aRect;
1658             // hdu said base = index
1659             aMapVDev.GetTextBoundRect( aRect, pAct->GetText(), pAct->GetIndex(), pAct->GetIndex(), pAct->GetLen() );
1660             Point aPt( pAct->GetPoint() );
1661             aRect.Move( aPt.X(), aPt.Y() );
1662             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1663         }
1664         break;
1665 
1666         case( META_TEXTARRAY_ACTION	):
1667         {
1668             MetaTextArrayAction* pAct = (MetaTextArrayAction*) pAction;
1669             Rectangle aRect;
1670             // hdu said base = index
1671             aMapVDev.GetTextBoundRect( aRect, pAct->GetText(), pAct->GetIndex(), pAct->GetIndex(), pAct->GetLen(),
1672                                        0, pAct->GetDXArray() );
1673             Point aPt( pAct->GetPoint() );
1674             aRect.Move( aPt.X(), aPt.Y() );
1675             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1676         }
1677         break;
1678 
1679         case( META_STRETCHTEXT_ACTION ):
1680         {
1681             MetaStretchTextAction* pAct = (MetaStretchTextAction*) pAction;
1682             Rectangle aRect;
1683             // hdu said base = index
1684             aMapVDev.GetTextBoundRect( aRect, pAct->GetText(), pAct->GetIndex(), pAct->GetIndex(), pAct->GetLen(),
1685                                        pAct->GetWidth(), NULL );
1686             Point aPt( pAct->GetPoint() );
1687             aRect.Move( aPt.X(), aPt.Y() );
1688             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1689         }
1690         break;
1691 
1692         case( META_TEXTLINE_ACTION ):
1693         {
1694             MetaTextLineAction* pAct = (MetaTextLineAction*) pAction;
1695             // measure a test string to get ascend and descent right
1696             static const sal_Unicode pStr[] = { 0xc4, 0x67, 0 };
1697             String aStr( pStr );
1698 
1699             Rectangle aRect;
1700             aMapVDev.GetTextBoundRect( aRect, aStr, 0, 0, aStr.Len(), 0, NULL );
1701             Point aPt( pAct->GetStartPoint() );
1702             aRect.Move( aPt.X(), aPt.Y() );
1703             aRect.Right() = aRect.Left() + pAct->GetWidth();
1704             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1705         }
1706         break;
1707 
1708         case( META_BMPSCALE_ACTION ):
1709         {
1710             MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
1711             Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
1712             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1713         }
1714         break;
1715 
1716         case( META_BMPSCALEPART_ACTION ):
1717         {
1718             MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
1719             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
1720             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1721         }
1722         break;
1723 
1724         case( META_BMPEXSCALE_ACTION ):
1725         {
1726             MetaBmpExScaleAction*   pAct = (MetaBmpExScaleAction*) pAction;
1727             Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
1728             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1729         }
1730         break;
1731 
1732         case( META_BMPEXSCALEPART_ACTION ):
1733         {
1734             MetaBmpExScalePartAction*   pAct = (MetaBmpExScalePartAction*) pAction;
1735             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
1736             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1737         }
1738         break;
1739 
1740         case( META_GRADIENT_ACTION ):
1741         {
1742             MetaGradientAction* pAct = (MetaGradientAction*) pAction;
1743             Rectangle aRect( pAct->GetRect() );
1744             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1745         }
1746         break;
1747 
1748         case( META_GRADIENTEX_ACTION ):
1749         {
1750             MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
1751             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
1752             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1753         }
1754         break;
1755 
1756         case( META_COMMENT_ACTION ):
1757         {
1758             // nothing to do
1759         };
1760         break;
1761 
1762         case( META_HATCH_ACTION ):
1763         {
1764             MetaHatchAction*	pAct = (MetaHatchAction*) pAction;
1765             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
1766             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1767         }
1768         break;
1769 
1770         case( META_TRANSPARENT_ACTION ):
1771         {
1772             MetaTransparentAction* pAct = (MetaTransparentAction*) pAction;
1773             Rectangle aRect( pAct->GetPolyPolygon().GetBoundRect() );
1774             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1775         }
1776         break;
1777 
1778         case( META_FLOATTRANSPARENT_ACTION ):
1779         {
1780             MetaFloatTransparentAction* pAct = (MetaFloatTransparentAction*) pAction;
1781             // MetaFloatTransparentAction is defined limiting it's content Metafile
1782             // to it's geometry definition(Point, Size), so use these directly
1783             const Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
1784             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1785         }
1786         break;
1787 
1788         case( META_EPS_ACTION ):
1789         {
1790             MetaEPSAction*	pAct = (MetaEPSAction*) pAction;
1791             Rectangle aRect( pAct->GetPoint(), pAct->GetSize() );
1792             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1793         }
1794         break;
1795 
1796         case( META_CLIPREGION_ACTION ):
1797         {
1798             MetaClipRegionAction* pAct = (MetaClipRegionAction*) pAction;
1799             if( pAct->IsClipping() )
1800                 aClipStack.back() = aMapVDev.LogicToLogic( pAct->GetRegion().GetBoundRect(), aMapVDev.GetMapMode(), GetPrefMapMode() );
1801             else
1802                 aClipStack.back() = Rectangle();
1803         }
1804         break;
1805 
1806         case( META_ISECTRECTCLIPREGION_ACTION ):
1807         {
1808             MetaISectRectClipRegionAction* pAct = (MetaISectRectClipRegionAction*) pAction;
1809             Rectangle aRect( aMapVDev.LogicToLogic( pAct->GetRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ) );
1810             if( aClipStack.back().IsEmpty() )
1811                 aClipStack.back() = aRect;
1812             else
1813                 aClipStack.back().Intersection( aRect );
1814         }
1815         break;
1816 
1817         case( META_ISECTREGIONCLIPREGION_ACTION	):
1818         {
1819             MetaISectRegionClipRegionAction*    pAct = (MetaISectRegionClipRegionAction*) pAction;
1820             Rectangle aRect( aMapVDev.LogicToLogic( pAct->GetRegion().GetBoundRect(), aMapVDev.GetMapMode(), GetPrefMapMode() ) );
1821             if( aClipStack.back().IsEmpty() )
1822                 aClipStack.back() = aRect;
1823             else
1824                 aClipStack.back().Intersection( aRect );
1825         }
1826         break;
1827 
1828         case( META_BMP_ACTION ):
1829         {
1830             MetaBmpAction* pAct = (MetaBmpAction*) pAction;
1831             Rectangle aRect( pAct->GetPoint(), aMapVDev.PixelToLogic( pAct->GetBitmap().GetSizePixel() ) );
1832             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1833         }
1834         break;
1835 
1836         case( META_BMPEX_ACTION ):
1837         {
1838             MetaBmpExAction* pAct = (MetaBmpExAction*) pAction;
1839             Rectangle aRect( pAct->GetPoint(), aMapVDev.PixelToLogic( pAct->GetBitmapEx().GetSizePixel() ) );
1840             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1841         }
1842         break;
1843 
1844         case( META_MASK_ACTION ):
1845         {
1846             MetaMaskAction* pAct = (MetaMaskAction*) pAction;
1847             Rectangle aRect( pAct->GetPoint(), aMapVDev.PixelToLogic( pAct->GetBitmap().GetSizePixel() ) );
1848             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1849         }
1850         break;
1851 
1852         case( META_MASKSCALE_ACTION ):
1853         {
1854             MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
1855             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
1856             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1857         }
1858         break;
1859 
1860         case( META_MASKSCALEPART_ACTION ):
1861         {
1862             MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
1863             Rectangle aRect( pAct->GetDestPoint(), pAct->GetDestSize() );
1864             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1865         }
1866         break;
1867 
1868         case( META_WALLPAPER_ACTION ):
1869         {
1870             MetaWallpaperAction* pAct = (MetaWallpaperAction*) pAction;
1871             Rectangle aRect( pAct->GetRect() );
1872             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1873         }
1874         break;
1875 
1876         case( META_TEXTRECT_ACTION ):
1877         {
1878             MetaTextRectAction* pAct = (MetaTextRectAction*) pAction;
1879             Rectangle aRect( pAct->GetRect() );
1880             ImplActionBounds( aBound, aMapVDev.LogicToLogic( aRect, aMapVDev.GetMapMode(), GetPrefMapMode() ), aClipStack, 0 );
1881         }
1882         break;
1883 
1884         case( META_MOVECLIPREGION_ACTION ):
1885         {
1886             MetaMoveClipRegionAction* pAct = (MetaMoveClipRegionAction*) pAction;
1887             if( ! aClipStack.back().IsEmpty() )
1888             {
1889                 Size aDelta( pAct->GetHorzMove(), pAct->GetVertMove() );
1890                 aDelta = aMapVDev.LogicToLogic( aDelta, aMapVDev.GetMapMode(), GetPrefMapMode() );
1891                 aClipStack.back().Move( aDelta.Width(), aDelta.Width() );
1892             }
1893         }
1894         break;
1895 
1896         default:
1897             {
1898                 pAction->Execute( &aMapVDev );
1899 
1900                 if( nActionType == META_PUSH_ACTION )
1901                 {
1902                     MetaPushAction* pAct = (MetaPushAction*) pAction;
1903                     aPushFlagStack.push_back( pAct->GetFlags() );
1904                     if( (aPushFlagStack.back() & PUSH_CLIPREGION) != 0 )
1905                     {
1906                         Rectangle aRect( aClipStack.back() );
1907                         aClipStack.push_back( aRect );
1908                     }
1909                 }
1910                 else if( nActionType == META_POP_ACTION )
1911                 {
1912                     // sanity check
1913                     if( ! aPushFlagStack.empty() )
1914                     {
1915                         if( (aPushFlagStack.back() & PUSH_CLIPREGION) != 0 )
1916                         {
1917                             if( aClipStack.size() > 1 )
1918                                 aClipStack.pop_back();
1919                         }
1920                         aPushFlagStack.pop_back();
1921                     }
1922                 }
1923             }
1924             break;
1925         }
1926     }
1927     return aBound;
1928 }
1929 
1930 // ------------------------------------------------------------------------
1931 
1932 Color GDIMetaFile::ImplColAdjustFnc( const Color& rColor, const void* pColParam )
1933 {
1934 	return Color( rColor.GetTransparency(),
1935 				  ( (const ImplColAdjustParam*) pColParam )->pMapR[ rColor.GetRed() ],
1936 				  ( (const ImplColAdjustParam*) pColParam )->pMapG[ rColor.GetGreen() ],
1937 				  ( (const ImplColAdjustParam*) pColParam )->pMapB[ rColor.GetBlue() ] );
1938 
1939 }
1940 
1941 // ------------------------------------------------------------------------
1942 
1943 BitmapEx GDIMetaFile::ImplBmpAdjustFnc( const BitmapEx& rBmpEx, const void* pBmpParam )
1944 {
1945 	const ImplBmpAdjustParam*	p = (const ImplBmpAdjustParam*) pBmpParam;
1946 	BitmapEx					aRet( rBmpEx );
1947 
1948 	aRet.Adjust( p->nLuminancePercent, p->nContrastPercent,
1949 				 p->nChannelRPercent, p->nChannelGPercent, p->nChannelBPercent,
1950 				 p->fGamma, p->bInvert );
1951 
1952 	return aRet;
1953 }
1954 
1955 // ------------------------------------------------------------------------
1956 
1957 Color GDIMetaFile::ImplColConvertFnc( const Color& rColor, const void* pColParam )
1958 {
1959 	sal_uInt8 cLum = rColor.GetLuminance();
1960 
1961 	if( MTF_CONVERSION_1BIT_THRESHOLD == ( (const ImplColConvertParam*) pColParam )->eConversion )
1962 		cLum = ( cLum < 128 ) ? 0 : 255;
1963 
1964 	return Color( rColor.GetTransparency(), cLum, cLum, cLum );
1965 }
1966 
1967 // ------------------------------------------------------------------------
1968 
1969 BitmapEx GDIMetaFile::ImplBmpConvertFnc( const BitmapEx& rBmpEx, const void* pBmpParam )
1970 {
1971 	BitmapEx aRet( rBmpEx );
1972 
1973 	aRet.Convert( ( (const ImplBmpConvertParam*) pBmpParam )->eConversion );
1974 
1975 	return aRet;
1976 }
1977 
1978 // ------------------------------------------------------------------------
1979 
1980 Color GDIMetaFile::ImplColMonoFnc( const Color&, const void* pColParam )
1981 {
1982 	return( ( (const ImplColMonoParam*) pColParam )->aColor );
1983 }
1984 
1985 // ------------------------------------------------------------------------
1986 
1987 BitmapEx GDIMetaFile::ImplBmpMonoFnc( const BitmapEx& rBmpEx, const void* pBmpParam )
1988 {
1989 	BitmapPalette aPal( 3 );
1990 
1991 	aPal[ 0 ] = Color( COL_BLACK );
1992 	aPal[ 1 ] = Color( COL_WHITE );
1993 	aPal[ 2 ] = ( (const ImplBmpMonoParam*) pBmpParam )->aColor;
1994 
1995 	Bitmap aBmp( rBmpEx.GetSizePixel(), 4, &aPal );
1996 	aBmp.Erase( ( (const ImplBmpMonoParam*) pBmpParam )->aColor );
1997 
1998 	if( rBmpEx.IsAlpha() )
1999 		return BitmapEx( aBmp, rBmpEx.GetAlpha() );
2000 	else if( rBmpEx.IsTransparent() )
2001 		return BitmapEx( aBmp, rBmpEx.GetMask() );
2002 	else
2003 		return aBmp;
2004 }
2005 
2006 // ------------------------------------------------------------------------
2007 
2008 Color GDIMetaFile::ImplColReplaceFnc( const Color& rColor, const void* pColParam )
2009 {
2010 	const sal_uLong nR = rColor.GetRed(), nG = rColor.GetGreen(), nB = rColor.GetBlue();
2011 
2012 	for( sal_uLong i = 0; i < ( (const ImplColReplaceParam*) pColParam )->nCount; i++ )
2013 	{
2014 		if( ( ( (const ImplColReplaceParam*) pColParam )->pMinR[ i ] <= nR ) &&
2015 			( ( (const ImplColReplaceParam*) pColParam )->pMaxR[ i ] >= nR ) &&
2016 			( ( (const ImplColReplaceParam*) pColParam )->pMinG[ i ] <= nG ) &&
2017 			( ( (const ImplColReplaceParam*) pColParam )->pMaxG[ i ] >= nG ) &&
2018 			( ( (const ImplColReplaceParam*) pColParam )->pMinB[ i ] <= nB ) &&
2019 			( ( (const ImplColReplaceParam*) pColParam )->pMaxB[ i ] >= nB ) )
2020 		{
2021 			return( ( (const ImplColReplaceParam*) pColParam )->pDstCols[ i ] );
2022 		}
2023 	}
2024 
2025 	return rColor;
2026 }
2027 
2028 // ------------------------------------------------------------------------
2029 
2030 BitmapEx GDIMetaFile::ImplBmpReplaceFnc( const BitmapEx& rBmpEx, const void* pBmpParam )
2031 {
2032 	const ImplBmpReplaceParam*	p = (const ImplBmpReplaceParam*) pBmpParam;
2033 	BitmapEx					aRet( rBmpEx );
2034 
2035 	aRet.Replace( p->pSrcCols, p->pDstCols, p->nCount, p->pTols );
2036 
2037 	return aRet;
2038 }
2039 
2040 // ------------------------------------------------------------------------
2041 
2042 void GDIMetaFile::ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pColParam,
2043 									  BmpExchangeFnc pFncBmp, const void* pBmpParam )
2044 {
2045 	GDIMetaFile aMtf;
2046 
2047 	aMtf.aPrefSize = aPrefSize;
2048 	aMtf.aPrefMapMode = aPrefMapMode;
2049 
2050 	for( MetaAction* pAction = (MetaAction*) First(); pAction; pAction = (MetaAction*) Next() )
2051 	{
2052 		const sal_uInt16 nType = pAction->GetType();
2053 
2054 		switch( nType )
2055 		{
2056 			case( META_PIXEL_ACTION ):
2057 			{
2058 				MetaPixelAction* pAct = (MetaPixelAction*) pAction;
2059 				aMtf.Insert( new MetaPixelAction( pAct->GetPoint(), pFncCol( pAct->GetColor(), pColParam ) ), LIST_APPEND );
2060 			}
2061 			break;
2062 
2063 			case( META_LINECOLOR_ACTION ):
2064 			{
2065 				MetaLineColorAction* pAct = (MetaLineColorAction*) pAction;
2066 
2067 				if( !pAct->IsSetting() )
2068 					pAct->Duplicate();
2069 				else
2070 					pAct = new MetaLineColorAction( pFncCol( pAct->GetColor(), pColParam ), sal_True );
2071 
2072 				aMtf.Insert( pAct, LIST_APPEND );
2073 			}
2074 			break;
2075 
2076 			case( META_FILLCOLOR_ACTION ):
2077 			{
2078 				MetaFillColorAction* pAct = (MetaFillColorAction*) pAction;
2079 
2080 				if( !pAct->IsSetting() )
2081 					pAct->Duplicate();
2082 				else
2083 					pAct = new MetaFillColorAction( pFncCol( pAct->GetColor(), pColParam ), sal_True );
2084 
2085 				aMtf.Insert( pAct, LIST_APPEND );
2086 			}
2087 			break;
2088 
2089 			case( META_TEXTCOLOR_ACTION ):
2090 			{
2091 				MetaTextColorAction* pAct = (MetaTextColorAction*) pAction;
2092 				aMtf.Insert( new MetaTextColorAction( pFncCol( pAct->GetColor(), pColParam ) ), LIST_APPEND );
2093 			}
2094 			break;
2095 
2096 			case( META_TEXTFILLCOLOR_ACTION ):
2097 			{
2098 				MetaTextFillColorAction* pAct = (MetaTextFillColorAction*) pAction;
2099 
2100 				if( !pAct->IsSetting() )
2101 					pAct->Duplicate();
2102 				else
2103 					pAct = new MetaTextFillColorAction( pFncCol( pAct->GetColor(), pColParam ), sal_True );
2104 
2105 				aMtf.Insert( pAct, LIST_APPEND );
2106 			}
2107 			break;
2108 
2109 			case( META_TEXTLINECOLOR_ACTION ):
2110 			{
2111 				MetaTextLineColorAction* pAct = (MetaTextLineColorAction*) pAction;
2112 
2113 				if( !pAct->IsSetting() )
2114 					pAct->Duplicate();
2115 				else
2116 					pAct = new MetaTextLineColorAction( pFncCol( pAct->GetColor(), pColParam ), sal_True );
2117 
2118 				aMtf.Insert( pAct, LIST_APPEND );
2119 			}
2120 			break;
2121 
2122 			case( META_OVERLINECOLOR_ACTION ):
2123 			{
2124 				MetaOverlineColorAction* pAct = (MetaOverlineColorAction*) pAction;
2125 
2126 				if( !pAct->IsSetting() )
2127 					pAct->Duplicate();
2128 				else
2129 					pAct = new MetaOverlineColorAction( pFncCol( pAct->GetColor(), pColParam ), sal_True );
2130 
2131 				aMtf.Insert( pAct, LIST_APPEND );
2132 			}
2133 			break;
2134 
2135 			case( META_FONT_ACTION ):
2136 			{
2137 				MetaFontAction* pAct = (MetaFontAction*) pAction;
2138 				Font			aFont( pAct->GetFont() );
2139 
2140 				aFont.SetColor( pFncCol( aFont.GetColor(), pColParam ) );
2141 				aFont.SetFillColor( pFncCol( aFont.GetFillColor(), pColParam ) );
2142 				aMtf.Insert( new MetaFontAction( aFont ), LIST_APPEND );
2143 			}
2144 			break;
2145 
2146 			case( META_WALLPAPER_ACTION ):
2147 			{
2148 				MetaWallpaperAction*	pAct = (MetaWallpaperAction*) pAction;
2149 				Wallpaper				aWall( pAct->GetWallpaper() );
2150 				const Rectangle&		rRect = pAct->GetRect();
2151 
2152 				aWall.SetColor( pFncCol( aWall.GetColor(), pColParam ) );
2153 
2154 				if( aWall.IsBitmap() )
2155 					aWall.SetBitmap( pFncBmp( aWall.GetBitmap(), pBmpParam ) );
2156 
2157 				if( aWall.IsGradient() )
2158 				{
2159 					Gradient aGradient( aWall.GetGradient() );
2160 
2161 					aGradient.SetStartColor( pFncCol( aGradient.GetStartColor(), pColParam ) );
2162 					aGradient.SetEndColor( pFncCol( aGradient.GetEndColor(), pColParam ) );
2163 					aWall.SetGradient( aGradient );
2164 				}
2165 
2166 				aMtf.Insert( new MetaWallpaperAction( rRect, aWall ), LIST_APPEND );
2167 			}
2168 			break;
2169 
2170 			case( META_BMP_ACTION ):
2171 			case( META_BMPEX_ACTION ):
2172 			case( META_MASK_ACTION ):
2173 			{
2174 				DBG_ERROR( "Don't use bitmap actions of this type in metafiles!" );
2175 			}
2176 			break;
2177 
2178 			case( META_BMPSCALE_ACTION ):
2179 			{
2180 				MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
2181 				aMtf.Insert( new MetaBmpScaleAction( pAct->GetPoint(), pAct->GetSize(),
2182 													 pFncBmp( pAct->GetBitmap(), pBmpParam ).GetBitmap() ),
2183 													 LIST_APPEND );
2184 			}
2185 			break;
2186 
2187 			case( META_BMPSCALEPART_ACTION ):
2188 			{
2189 				MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
2190 				aMtf.Insert( new MetaBmpScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(),
2191 														 pAct->GetSrcPoint(), pAct->GetSrcSize(),
2192 														 pFncBmp( pAct->GetBitmap(), pBmpParam ).GetBitmap() ),
2193 														 LIST_APPEND );
2194 			}
2195 			break;
2196 
2197 			case( META_BMPEXSCALE_ACTION ):
2198 			{
2199 				MetaBmpExScaleAction* pAct = (MetaBmpExScaleAction*) pAction;
2200 				aMtf.Insert( new MetaBmpExScaleAction( pAct->GetPoint(), pAct->GetSize(),
2201 													   pFncBmp( pAct->GetBitmapEx(), pBmpParam ) ),
2202 													   LIST_APPEND );
2203 			}
2204 			break;
2205 
2206 			case( META_BMPEXSCALEPART_ACTION ):
2207 			{
2208 				MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction;
2209 				aMtf.Insert( new MetaBmpExScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(),
2210 														   pAct->GetSrcPoint(), pAct->GetSrcSize(),
2211 														   pFncBmp( pAct->GetBitmapEx(), pBmpParam ) ),
2212 														   LIST_APPEND );
2213 			}
2214 			break;
2215 
2216 			case( META_MASKSCALE_ACTION ):
2217 			{
2218 				MetaMaskScaleAction* pAct = (MetaMaskScaleAction*) pAction;
2219 				aMtf.Insert( new MetaMaskScaleAction( pAct->GetPoint(), pAct->GetSize(),
2220 													  pAct->GetBitmap(),
2221 													  pFncCol( pAct->GetColor(), pColParam ) ),
2222 													  LIST_APPEND );
2223 			}
2224 			break;
2225 
2226 			case( META_MASKSCALEPART_ACTION ):
2227 			{
2228 				MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
2229 				aMtf.Insert( new MetaMaskScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(),
2230 														  pAct->GetSrcPoint(), pAct->GetSrcSize(),
2231 														  pAct->GetBitmap(),
2232 														  pFncCol( pAct->GetColor(), pColParam ) ),
2233 														  LIST_APPEND );
2234 			}
2235 			break;
2236 
2237 			case( META_GRADIENT_ACTION ):
2238 			{
2239 				MetaGradientAction* pAct = (MetaGradientAction*) pAction;
2240 				Gradient			aGradient( pAct->GetGradient() );
2241 
2242 				aGradient.SetStartColor( pFncCol( aGradient.GetStartColor(), pColParam ) );
2243 				aGradient.SetEndColor( pFncCol( aGradient.GetEndColor(), pColParam ) );
2244 				aMtf.Insert( new MetaGradientAction( pAct->GetRect(), aGradient ), LIST_APPEND );
2245 			}
2246 			break;
2247 
2248 			case( META_GRADIENTEX_ACTION ):
2249 			{
2250 				MetaGradientExAction* pAct = (MetaGradientExAction*) pAction;
2251 				Gradient			  aGradient( pAct->GetGradient() );
2252 
2253 				aGradient.SetStartColor( pFncCol( aGradient.GetStartColor(), pColParam ) );
2254 				aGradient.SetEndColor( pFncCol( aGradient.GetEndColor(), pColParam ) );
2255 				aMtf.Insert( new MetaGradientExAction( pAct->GetPolyPolygon(), aGradient ), LIST_APPEND );
2256 			}
2257 			break;
2258 
2259 			case( META_HATCH_ACTION ):
2260 			{
2261 				MetaHatchAction*	pAct = (MetaHatchAction*) pAction;
2262 				Hatch				aHatch( pAct->GetHatch() );
2263 
2264 				aHatch.SetColor( pFncCol( aHatch.GetColor(), pColParam ) );
2265 				aMtf.Insert( new MetaHatchAction( pAct->GetPolyPolygon(), aHatch ), LIST_APPEND );
2266 			}
2267 			break;
2268 
2269 			case( META_FLOATTRANSPARENT_ACTION ):
2270 			{
2271 				MetaFloatTransparentAction* pAct = (MetaFloatTransparentAction*) pAction;
2272 				GDIMetaFile					aTransMtf( pAct->GetGDIMetaFile() );
2273 
2274 				aTransMtf.ImplExchangeColors( pFncCol, pColParam, pFncBmp, pBmpParam );
2275 				aMtf.Insert( new MetaFloatTransparentAction( aTransMtf,
2276 															 pAct->GetPoint(), pAct->GetSize(),
2277 															 pAct->GetGradient() ),
2278 															 LIST_APPEND );
2279 			}
2280 			break;
2281 
2282 			case( META_EPS_ACTION ):
2283 			{
2284 				MetaEPSAction*	pAct = (MetaEPSAction*) pAction;
2285 				GDIMetaFile		aSubst( pAct->GetSubstitute() );
2286 
2287 				aSubst.ImplExchangeColors( pFncCol, pColParam, pFncBmp, pBmpParam );
2288 				aMtf.Insert( new MetaEPSAction( pAct->GetPoint(), pAct->GetSize(),
2289 												pAct->GetLink(), aSubst ),
2290 												LIST_APPEND );
2291 			}
2292 			break;
2293 
2294 			default:
2295 			{
2296 				pAction->Duplicate();
2297 				aMtf.Insert( pAction, LIST_APPEND );
2298 			}
2299 			break;
2300 		}
2301 	}
2302 
2303 	*this = aMtf;
2304 }
2305 
2306 // ------------------------------------------------------------------------
2307 
2308 void GDIMetaFile::Adjust( short nLuminancePercent, short nContrastPercent,
2309 						  short nChannelRPercent, short nChannelGPercent,
2310 						  short nChannelBPercent, double fGamma, sal_Bool bInvert )
2311 {
2312 	// nothing to do? => return quickly
2313 	if( nLuminancePercent || nContrastPercent ||
2314 		nChannelRPercent || nChannelGPercent || nChannelBPercent ||
2315 		( fGamma != 1.0 ) || bInvert )
2316 	{
2317 		double				fM, fROff, fGOff, fBOff, fOff;
2318 		ImplColAdjustParam	aColParam;
2319 		ImplBmpAdjustParam	aBmpParam;
2320 
2321 		aColParam.pMapR = new sal_uInt8[ 256 ];
2322 		aColParam.pMapG = new sal_uInt8[ 256 ];
2323 		aColParam.pMapB = new sal_uInt8[ 256 ];
2324 
2325 		// calculate slope
2326 		if( nContrastPercent >= 0 )
2327 			fM = 128.0 / ( 128.0 - 1.27 * MinMax( nContrastPercent, 0L, 100L ) );
2328 		else
2329 			fM = ( 128.0 + 1.27 * MinMax( nContrastPercent, -100L, 0L ) ) / 128.0;
2330 
2331 		// total offset = luminance offset + contrast offset
2332 		fOff = MinMax( nLuminancePercent, -100L, 100L ) * 2.55 + 128.0 - fM * 128.0;
2333 
2334 		// channel offset = channel offset	+ total offset
2335 		fROff = nChannelRPercent * 2.55 + fOff;
2336 		fGOff = nChannelGPercent * 2.55 + fOff;
2337 		fBOff = nChannelBPercent * 2.55 + fOff;
2338 
2339 		// calculate gamma value
2340 		fGamma = ( fGamma <= 0.0 || fGamma > 10.0 ) ? 1.0 : ( 1.0 / fGamma );
2341 		const sal_Bool bGamma = ( fGamma != 1.0 );
2342 
2343 		// create mapping table
2344 		for( long nX = 0L; nX < 256L; nX++ )
2345 		{
2346 			aColParam.pMapR[ nX ] = (sal_uInt8) MinMax( FRound( nX * fM + fROff ), 0L, 255L );
2347 			aColParam.pMapG[ nX ] = (sal_uInt8) MinMax( FRound( nX * fM + fGOff ), 0L, 255L );
2348 			aColParam.pMapB[ nX ] = (sal_uInt8) MinMax( FRound( nX * fM + fBOff ), 0L, 255L );
2349 
2350 			if( bGamma )
2351 			{
2352 				aColParam.pMapR[ nX ] = GAMMA( aColParam.pMapR[ nX ], fGamma );
2353 				aColParam.pMapG[ nX ] = GAMMA( aColParam.pMapG[ nX ], fGamma );
2354 				aColParam.pMapB[ nX ] = GAMMA( aColParam.pMapB[ nX ], fGamma );
2355 			}
2356 
2357 			if( bInvert )
2358 			{
2359 				aColParam.pMapR[ nX ] = ~aColParam.pMapR[ nX ];
2360 				aColParam.pMapG[ nX ] = ~aColParam.pMapG[ nX ];
2361 				aColParam.pMapB[ nX ] = ~aColParam.pMapB[ nX ];
2362 			}
2363 		}
2364 
2365 		aBmpParam.nLuminancePercent = nLuminancePercent;
2366 		aBmpParam.nContrastPercent = nContrastPercent;
2367 		aBmpParam.nChannelRPercent = nChannelRPercent;
2368 		aBmpParam.nChannelGPercent = nChannelGPercent;
2369 		aBmpParam.nChannelBPercent = nChannelBPercent;
2370 		aBmpParam.fGamma = fGamma;
2371 		aBmpParam.bInvert = bInvert;
2372 
2373 		// do color adjustment
2374 		ImplExchangeColors( ImplColAdjustFnc, &aColParam, ImplBmpAdjustFnc, &aBmpParam );
2375 
2376 		delete[] aColParam.pMapR;
2377 		delete[] aColParam.pMapG;
2378 		delete[] aColParam.pMapB;
2379 	}
2380 }
2381 
2382 // ------------------------------------------------------------------------
2383 
2384 void GDIMetaFile::Convert( MtfConversion eConversion )
2385 {
2386 	// nothing to do? => return quickly
2387 	if( eConversion != MTF_CONVERSION_NONE )
2388 	{
2389 		ImplColConvertParam	aColParam;
2390 		ImplBmpConvertParam	aBmpParam;
2391 
2392 		aColParam.eConversion = eConversion;
2393 		aBmpParam.eConversion = ( MTF_CONVERSION_1BIT_THRESHOLD == eConversion ) ? BMP_CONVERSION_1BIT_THRESHOLD : BMP_CONVERSION_8BIT_GREYS;
2394 
2395 		ImplExchangeColors( ImplColConvertFnc, &aColParam, ImplBmpConvertFnc, &aBmpParam );
2396 	}
2397 }
2398 
2399 // ------------------------------------------------------------------------
2400 
2401 void GDIMetaFile::ReplaceColors( const Color& rSearchColor, const Color& rReplaceColor, sal_uLong nTol )
2402 {
2403 	ReplaceColors( &rSearchColor, &rReplaceColor, 1, &nTol );
2404 }
2405 
2406 // ------------------------------------------------------------------------
2407 
2408 void GDIMetaFile::ReplaceColors( const Color* pSearchColors, const Color* pReplaceColors, sal_uLong nColorCount, sal_uLong* pTols )
2409 {
2410 	ImplColReplaceParam aColParam;
2411 	ImplBmpReplaceParam aBmpParam;
2412 
2413 	aColParam.pMinR = new sal_uLong[ nColorCount ];
2414 	aColParam.pMaxR = new sal_uLong[ nColorCount ];
2415 	aColParam.pMinG = new sal_uLong[ nColorCount ];
2416 	aColParam.pMaxG = new sal_uLong[ nColorCount ];
2417 	aColParam.pMinB = new sal_uLong[ nColorCount ];
2418 	aColParam.pMaxB = new sal_uLong[ nColorCount ];
2419 
2420 	for( sal_uLong i = 0; i < nColorCount; i++ )
2421 	{
2422 		const long	nTol = pTols ? ( pTols[ i ] * 255 ) / 100 : 0;
2423 		long		nVal;
2424 
2425 		nVal = pSearchColors[ i ].GetRed();
2426 		aColParam.pMinR[ i ] = (sal_uLong) Max( nVal - nTol, 0L );
2427 		aColParam.pMaxR[ i ] = (sal_uLong) Min( nVal + nTol, 255L );
2428 
2429 		nVal = pSearchColors[ i ].GetGreen();
2430 		aColParam.pMinG[ i ] = (sal_uLong) Max( nVal - nTol, 0L );
2431 		aColParam.pMaxG[ i ] = (sal_uLong) Min( nVal + nTol, 255L );
2432 
2433 		nVal = pSearchColors[ i ].GetBlue();
2434 		aColParam.pMinB[ i ] = (sal_uLong) Max( nVal - nTol, 0L );
2435 		aColParam.pMaxB[ i ] = (sal_uLong) Min( nVal + nTol, 255L );
2436 	}
2437 
2438 	aColParam.pDstCols = pReplaceColors;
2439 	aColParam.nCount = nColorCount;
2440 
2441 	aBmpParam.pSrcCols = pSearchColors;
2442 	aBmpParam.pDstCols = pReplaceColors;
2443 	aBmpParam.nCount = nColorCount;
2444 	aBmpParam.pTols = pTols;
2445 
2446 	ImplExchangeColors( ImplColReplaceFnc, &aColParam, ImplBmpReplaceFnc, &aBmpParam );
2447 
2448 	delete[] aColParam.pMinR;
2449 	delete[] aColParam.pMaxR;
2450 	delete[] aColParam.pMinG;
2451 	delete[] aColParam.pMaxG;
2452 	delete[] aColParam.pMinB;
2453 	delete[] aColParam.pMaxB;
2454 };
2455 
2456 // ------------------------------------------------------------------------
2457 
2458 GDIMetaFile GDIMetaFile::GetMonochromeMtf( const Color& rColor ) const
2459 {
2460 	GDIMetaFile aRet( *this );
2461 
2462 	ImplColMonoParam	aColParam;
2463 	ImplBmpMonoParam	aBmpParam;
2464 
2465 	aColParam.aColor = rColor;
2466 	aBmpParam.aColor = rColor;
2467 
2468 	aRet.ImplExchangeColors( ImplColMonoFnc, &aColParam, ImplBmpMonoFnc, &aBmpParam );
2469 
2470 	return aRet;
2471 }
2472 
2473 // ------------------------------------------------------------------------
2474 
2475 sal_uLong GDIMetaFile::GetChecksum() const
2476 {
2477 	GDIMetaFile			aMtf;
2478 	SvMemoryStream		aMemStm( 65535, 65535 );
2479 	ImplMetaWriteData	aWriteData;
2480 	SVBT16				aBT16;
2481 	SVBT32				aBT32;
2482 	sal_uLong				nCrc = 0;
2483 
2484 	aWriteData.meActualCharSet = aMemStm.GetStreamCharSet();
2485 
2486 	for( sal_uLong i = 0, nObjCount = GetActionCount(); i < nObjCount; i++ )
2487 	{
2488 		MetaAction* pAction = GetAction( i );
2489 
2490 		switch( pAction->GetType() )
2491 		{
2492 			case( META_BMP_ACTION ):
2493 			{
2494 				MetaBmpAction* pAct = (MetaBmpAction*) pAction;
2495 
2496 				ShortToSVBT16( pAct->GetType(), aBT16 );
2497 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2498 
2499 				UInt32ToSVBT32( pAct->GetBitmap().GetChecksum(), aBT32 );
2500 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2501 
2502 				UInt32ToSVBT32( pAct->GetPoint().X(), aBT32 );
2503 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2504 
2505 				UInt32ToSVBT32( pAct->GetPoint().Y(), aBT32 );
2506 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2507 			}
2508 			break;
2509 
2510 			case( META_BMPSCALE_ACTION ):
2511 			{
2512 				MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
2513 
2514 				ShortToSVBT16( pAct->GetType(), aBT16 );
2515 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2516 
2517 				UInt32ToSVBT32( pAct->GetBitmap().GetChecksum(), aBT32 );
2518 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2519 
2520 				UInt32ToSVBT32( pAct->GetPoint().X(), aBT32 );
2521 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2522 
2523 				UInt32ToSVBT32( pAct->GetPoint().Y(), aBT32 );
2524 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2525 
2526 				UInt32ToSVBT32( pAct->GetSize().Width(), aBT32 );
2527 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2528 
2529 				UInt32ToSVBT32( pAct->GetSize().Height(), aBT32 );
2530 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2531 			}
2532 			break;
2533 
2534 			case( META_BMPSCALEPART_ACTION ):
2535 			{
2536 				MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
2537 
2538 				ShortToSVBT16( pAct->GetType(), aBT16 );
2539 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2540 
2541 				UInt32ToSVBT32( pAct->GetBitmap().GetChecksum(), aBT32 );
2542 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2543 
2544 				UInt32ToSVBT32( pAct->GetDestPoint().X(), aBT32 );
2545 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2546 
2547 				UInt32ToSVBT32( pAct->GetDestPoint().Y(), aBT32 );
2548 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2549 
2550 				UInt32ToSVBT32( pAct->GetDestSize().Width(), aBT32 );
2551 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2552 
2553 				UInt32ToSVBT32( pAct->GetDestSize().Height(), aBT32 );
2554 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2555 
2556 				UInt32ToSVBT32( pAct->GetSrcPoint().X(), aBT32 );
2557 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2558 
2559 				UInt32ToSVBT32( pAct->GetSrcPoint().Y(), aBT32 );
2560 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2561 
2562 				UInt32ToSVBT32( pAct->GetSrcSize().Width(), aBT32 );
2563 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2564 
2565 				UInt32ToSVBT32( pAct->GetSrcSize().Height(), aBT32 );
2566 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2567 			}
2568 			break;
2569 
2570 			case( META_BMPEX_ACTION ):
2571 			{
2572 				MetaBmpExAction* pAct = (MetaBmpExAction*) pAction;
2573 
2574 				ShortToSVBT16( pAct->GetType(), aBT16 );
2575 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2576 
2577 				UInt32ToSVBT32( pAct->GetBitmapEx().GetChecksum(), aBT32 );
2578 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2579 
2580 				UInt32ToSVBT32( pAct->GetPoint().X(), aBT32 );
2581 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2582 
2583 				UInt32ToSVBT32( pAct->GetPoint().Y(), aBT32 );
2584 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2585 			}
2586 			break;
2587 
2588 			case( META_BMPEXSCALE_ACTION ):
2589 			{
2590 				MetaBmpExScaleAction* pAct = (MetaBmpExScaleAction*) pAction;
2591 
2592 				ShortToSVBT16( pAct->GetType(), aBT16 );
2593 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2594 
2595 				UInt32ToSVBT32( pAct->GetBitmapEx().GetChecksum(), aBT32 );
2596 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2597 
2598 				UInt32ToSVBT32( pAct->GetPoint().X(), aBT32 );
2599 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2600 
2601 				UInt32ToSVBT32( pAct->GetPoint().Y(), aBT32 );
2602 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2603 
2604 				UInt32ToSVBT32( pAct->GetSize().Width(), aBT32 );
2605 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2606 
2607 				UInt32ToSVBT32( pAct->GetSize().Height(), aBT32 );
2608 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2609 			}
2610 			break;
2611 
2612 			case( META_BMPEXSCALEPART_ACTION ):
2613 			{
2614 				MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction;
2615 
2616 				ShortToSVBT16( pAct->GetType(), aBT16 );
2617 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2618 
2619 				UInt32ToSVBT32( pAct->GetBitmapEx().GetChecksum(), aBT32 );
2620 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2621 
2622 				UInt32ToSVBT32( pAct->GetDestPoint().X(), aBT32 );
2623 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2624 
2625 				UInt32ToSVBT32( pAct->GetDestPoint().Y(), aBT32 );
2626 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2627 
2628 				UInt32ToSVBT32( pAct->GetDestSize().Width(), aBT32 );
2629 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2630 
2631 				UInt32ToSVBT32( pAct->GetDestSize().Height(), aBT32 );
2632 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2633 
2634 				UInt32ToSVBT32( pAct->GetSrcPoint().X(), aBT32 );
2635 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2636 
2637 				UInt32ToSVBT32( pAct->GetSrcPoint().Y(), aBT32 );
2638 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2639 
2640 				UInt32ToSVBT32( pAct->GetSrcSize().Width(), aBT32 );
2641 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2642 
2643 				UInt32ToSVBT32( pAct->GetSrcSize().Height(), aBT32 );
2644 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2645 			}
2646 			break;
2647 
2648 			case( META_MASK_ACTION ):
2649 			{
2650 				MetaMaskAction* pAct = (MetaMaskAction*) pAction;
2651 
2652 				ShortToSVBT16( pAct->GetType(), aBT16 );
2653 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2654 
2655 				UInt32ToSVBT32( pAct->GetBitmap().GetChecksum(), aBT32 );
2656 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2657 
2658 				UInt32ToSVBT32( pAct->GetColor().GetColor(), aBT32 );
2659 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2660 
2661 				UInt32ToSVBT32( pAct->GetPoint().X(), aBT32 );
2662 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2663 
2664 				UInt32ToSVBT32( pAct->GetPoint().Y(), aBT32 );
2665 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2666 			}
2667 			break;
2668 
2669 			case( META_MASKSCALE_ACTION ):
2670 			{
2671 				MetaMaskScaleAction* pAct = (MetaMaskScaleAction*) pAction;
2672 
2673 				ShortToSVBT16( pAct->GetType(), aBT16 );
2674 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2675 
2676 				UInt32ToSVBT32( pAct->GetBitmap().GetChecksum(), aBT32 );
2677 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2678 
2679 				UInt32ToSVBT32( pAct->GetColor().GetColor(), aBT32 );
2680 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2681 
2682 				UInt32ToSVBT32( pAct->GetPoint().X(), aBT32 );
2683 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2684 
2685 				UInt32ToSVBT32( pAct->GetPoint().Y(), aBT32 );
2686 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2687 
2688 				UInt32ToSVBT32( pAct->GetSize().Width(), aBT32 );
2689 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2690 
2691 				UInt32ToSVBT32( pAct->GetSize().Height(), aBT32 );
2692 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2693 			}
2694 			break;
2695 
2696 			case( META_MASKSCALEPART_ACTION ):
2697 			{
2698 				MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
2699 
2700 				ShortToSVBT16( pAct->GetType(), aBT16 );
2701 				nCrc = rtl_crc32( nCrc, aBT16, 2 );
2702 
2703 				UInt32ToSVBT32( pAct->GetBitmap().GetChecksum(), aBT32 );
2704 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2705 
2706 				UInt32ToSVBT32( pAct->GetColor().GetColor(), aBT32 );
2707 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2708 
2709 				UInt32ToSVBT32( pAct->GetDestPoint().X(), aBT32 );
2710 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2711 
2712 				UInt32ToSVBT32( pAct->GetDestPoint().Y(), aBT32 );
2713 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2714 
2715 				UInt32ToSVBT32( pAct->GetDestSize().Width(), aBT32 );
2716 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2717 
2718 				UInt32ToSVBT32( pAct->GetDestSize().Height(), aBT32 );
2719 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2720 
2721 				UInt32ToSVBT32( pAct->GetSrcPoint().X(), aBT32 );
2722 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2723 
2724 				UInt32ToSVBT32( pAct->GetSrcPoint().Y(), aBT32 );
2725 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2726 
2727 				UInt32ToSVBT32( pAct->GetSrcSize().Width(), aBT32 );
2728 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2729 
2730 				UInt32ToSVBT32( pAct->GetSrcSize().Height(), aBT32 );
2731 				nCrc = rtl_crc32( nCrc, aBT32, 4 );
2732 			}
2733 			break;
2734 
2735 			case META_EPS_ACTION :
2736 			{
2737 				MetaEPSAction* pAct = (MetaEPSAction*) pAction;
2738 				nCrc = rtl_crc32( nCrc, pAct->GetLink().GetData(), pAct->GetLink().GetDataSize() );
2739 			}
2740 			break;
2741 
2742             case META_CLIPREGION_ACTION :
2743             {
2744                 MetaClipRegionAction* pAct = dynamic_cast< MetaClipRegionAction* >(pAction);
2745                 const Region& rRegion = pAct->GetRegion();
2746 
2747                 if(rRegion.HasPolyPolygon())
2748                 {
2749                     // It has shown that this is a possible bottleneck for checksum calculation.
2750                     // In worst case a very expensive RegionHandle representation gets created.
2751                     // In this case it's cheaper to use the PolyPolygon
2752                     const basegfx::B2DPolyPolygon aPolyPolygon(rRegion.GetB2DPolyPolygon());
2753                     const sal_uInt32 nPolyCount(aPolyPolygon.count());
2754                     SVBT64 aSVBT64;
2755 
2756                     for(sal_uInt32 a(0); a < nPolyCount; a++)
2757                     {
2758                         const basegfx::B2DPolygon aPolygon(aPolyPolygon.getB2DPolygon(a));
2759                         const sal_uInt32 nPointCount(aPolygon.count());
2760                         const bool bControl(aPolygon.areControlPointsUsed());
2761 
2762                         for(sal_uInt32 b(0); b < nPointCount; b++)
2763                         {
2764                             const basegfx::B2DPoint aPoint(aPolygon.getB2DPoint(b));
2765 
2766                             DoubleToSVBT64(aPoint.getX(), aSVBT64);
2767                             nCrc = rtl_crc32(nCrc, aSVBT64, 8);
2768                             DoubleToSVBT64(aPoint.getY(), aSVBT64);
2769                             nCrc = rtl_crc32(nCrc, aSVBT64, 8);
2770 
2771                             if(bControl)
2772                             {
2773                                 if(aPolygon.isPrevControlPointUsed(b))
2774                                 {
2775                                     const basegfx::B2DPoint aCtrl(aPolygon.getPrevControlPoint(b));
2776 
2777                                     DoubleToSVBT64(aCtrl.getX(), aSVBT64);
2778                                     nCrc = rtl_crc32(nCrc, aSVBT64, 8);
2779                                     DoubleToSVBT64(aCtrl.getY(), aSVBT64);
2780                                     nCrc = rtl_crc32(nCrc, aSVBT64, 8);
2781                                 }
2782 
2783                                 if(aPolygon.isNextControlPointUsed(b))
2784                                 {
2785                                     const basegfx::B2DPoint aCtrl(aPolygon.getNextControlPoint(b));
2786 
2787                                     DoubleToSVBT64(aCtrl.getX(), aSVBT64);
2788                                     nCrc = rtl_crc32(nCrc, aSVBT64, 8);
2789                                     DoubleToSVBT64(aCtrl.getY(), aSVBT64);
2790                                     nCrc = rtl_crc32(nCrc, aSVBT64, 8);
2791                                 }
2792                             }
2793                         }
2794                     }
2795 
2796                     SVBT8 aSVBT8;
2797                     ByteToSVBT8((sal_uInt8)pAct->IsClipping(), aSVBT8);
2798                     nCrc = rtl_crc32(nCrc, aSVBT8, 1);
2799                 }
2800                 else
2801                 {
2802                     pAction->Write( aMemStm, &aWriteData );
2803                     nCrc = rtl_crc32( nCrc, aMemStm.GetData(), aMemStm.Tell() );
2804                     aMemStm.Seek( 0 );
2805                 }
2806             }
2807             break;
2808 
2809 			default:
2810 			{
2811 				pAction->Write( aMemStm, &aWriteData );
2812 				nCrc = rtl_crc32( nCrc, aMemStm.GetData(), aMemStm.Tell() );
2813 				aMemStm.Seek( 0 );
2814 			}
2815 			break;
2816 		}
2817 	}
2818 
2819 	return nCrc;
2820 }
2821 
2822 // ------------------------------------------------------------------------
2823 
2824 sal_uLong GDIMetaFile::GetSizeBytes() const
2825 {
2826     sal_uLong nSizeBytes = 0;
2827 
2828     for( sal_uLong i = 0, nObjCount = GetActionCount(); i < nObjCount; ++i )
2829     {
2830         MetaAction* pAction = GetAction( i );
2831 
2832         // default action size is set to 32 (=> not the exact value)
2833         nSizeBytes += 32;
2834 
2835         // add sizes for large action content
2836         switch( pAction->GetType() )
2837         {
2838             case( META_BMP_ACTION ): nSizeBytes += ( (MetaBmpAction*) pAction )->GetBitmap().GetSizeBytes(); break;
2839             case( META_BMPSCALE_ACTION ): nSizeBytes += ( (MetaBmpScaleAction*) pAction )->GetBitmap().GetSizeBytes(); break;
2840             case( META_BMPSCALEPART_ACTION ): nSizeBytes += ( (MetaBmpScalePartAction*) pAction )->GetBitmap().GetSizeBytes(); break;
2841 
2842             case( META_BMPEX_ACTION ): nSizeBytes += ( (MetaBmpExAction*) pAction )->GetBitmapEx().GetSizeBytes(); break;
2843             case( META_BMPEXSCALE_ACTION ): nSizeBytes += ( (MetaBmpExScaleAction*) pAction )->GetBitmapEx().GetSizeBytes(); break;
2844             case( META_BMPEXSCALEPART_ACTION ): nSizeBytes += ( (MetaBmpExScalePartAction*) pAction )->GetBitmapEx().GetSizeBytes(); break;
2845 
2846             case( META_MASK_ACTION ): nSizeBytes += ( (MetaMaskAction*) pAction )->GetBitmap().GetSizeBytes(); break;
2847             case( META_MASKSCALE_ACTION ): nSizeBytes += ( (MetaMaskScaleAction*) pAction )->GetBitmap().GetSizeBytes(); break;
2848             case( META_MASKSCALEPART_ACTION ): nSizeBytes += ( (MetaMaskScalePartAction*) pAction )->GetBitmap().GetSizeBytes(); break;
2849 
2850             case( META_POLYLINE_ACTION ): nSizeBytes += ( ( (MetaPolyLineAction*) pAction )->GetPolygon().GetSize() * sizeof( Point ) ); break;
2851             case( META_POLYGON_ACTION ): nSizeBytes += ( ( (MetaPolygonAction*) pAction )->GetPolygon().GetSize() * sizeof( Point ) ); break;
2852             case( META_POLYPOLYGON_ACTION ):
2853             {
2854                 const PolyPolygon& rPolyPoly = ( (MetaPolyPolygonAction*) pAction )->GetPolyPolygon();
2855 
2856                 for( sal_uInt16 n = 0; n < rPolyPoly.Count(); ++n )
2857                     nSizeBytes += ( rPolyPoly[ n ].GetSize() * sizeof( Point ) );
2858             }
2859             break;
2860 
2861             case( META_TEXT_ACTION ): nSizeBytes += ( ( (MetaTextAction*) pAction )->GetText().Len() * sizeof( sal_Unicode ) ); break;
2862             case( META_STRETCHTEXT_ACTION ): nSizeBytes += ( ( (MetaStretchTextAction*) pAction )->GetText().Len() * sizeof( sal_Unicode ) ); break;
2863             case( META_TEXTRECT_ACTION ): nSizeBytes += ( ( (MetaTextRectAction*) pAction )->GetText().Len() * sizeof( sal_Unicode ) ); break;
2864             case( META_TEXTARRAY_ACTION ):
2865             {
2866                 MetaTextArrayAction* pTextArrayAction = (MetaTextArrayAction*) pAction;
2867 
2868                 nSizeBytes += ( pTextArrayAction->GetText().Len() * sizeof( sal_Unicode ) );
2869 
2870                 if( pTextArrayAction->GetDXArray() )
2871                     nSizeBytes += ( pTextArrayAction->GetLen() << 2 );
2872             }
2873             break;
2874         }
2875     }
2876 
2877     return( nSizeBytes );
2878 }
2879 
2880 // ------------------------------------------------------------------------
2881 
2882 SvStream& operator>>( SvStream& rIStm, GDIMetaFile& rGDIMetaFile )
2883 {
2884 	if( !rIStm.GetError() )
2885 	{
2886 		char	aId[ 7 ];
2887 		sal_uLong	nStmPos = rIStm.Tell();
2888 		sal_uInt16	nOldFormat = rIStm.GetNumberFormatInt();
2889 
2890 		rIStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
2891 
2892 		aId[ 0 ] = 0;
2893 		aId[ 6 ] = 0;
2894 		rIStm.Read( aId, 6 );
2895 
2896 		if ( !strcmp( aId, "VCLMTF" ) )
2897 		{
2898 			// new format
2899 			VersionCompat*	pCompat;
2900 			MetaAction* 	pAction;
2901 			sal_uInt32			nStmCompressMode = 0;
2902 			sal_uInt32			nCount = 0;
2903 
2904 			pCompat = new VersionCompat( rIStm, STREAM_READ );
2905 
2906 			rIStm >> nStmCompressMode;
2907 			rIStm >> rGDIMetaFile.aPrefMapMode;
2908 			rIStm >> rGDIMetaFile.aPrefSize;
2909 			rIStm >> nCount;
2910 
2911 			delete pCompat;
2912 
2913 			ImplMetaReadData aReadData;
2914 			aReadData.meActualCharSet = rIStm.GetStreamCharSet();
2915 
2916 			for( sal_uInt32 nAction = 0UL; ( nAction < nCount ) && !rIStm.IsEof(); nAction++ )
2917 			{
2918 				pAction = MetaAction::ReadMetaAction( rIStm, &aReadData );
2919 
2920 				if( pAction )
2921 					rGDIMetaFile.AddAction( pAction );
2922 			}
2923 		}
2924 		else
2925 		{
2926 			// to avoid possible compiler optimizations => new/delete
2927 			rIStm.Seek( nStmPos );
2928 			delete( new SVMConverter( rIStm, rGDIMetaFile, CONVERT_FROM_SVM1 ) );
2929 		}
2930 
2931 		// check for errors
2932 		if( rIStm.GetError() )
2933 		{
2934 			rGDIMetaFile.Clear();
2935 			rIStm.Seek( nStmPos );
2936 		}
2937 
2938 		rIStm.SetNumberFormatInt( nOldFormat );
2939 	}
2940 
2941 	return rIStm;
2942 }
2943 
2944 // ------------------------------------------------------------------------
2945 
2946 SvStream& operator<<( SvStream& rOStm, const GDIMetaFile& rGDIMetaFile )
2947 {
2948 	if( !rOStm.GetError() )
2949 	{
2950         static const char*  pEnableSVM1 = getenv( "SAL_ENABLE_SVM1" );
2951         static const bool   bNoSVM1 = (NULL == pEnableSVM1 ) || ( '0' == *pEnableSVM1 );
2952 
2953         if( bNoSVM1 || rOStm.GetVersion() >= SOFFICE_FILEFORMAT_50  )
2954         {
2955             const_cast< GDIMetaFile& >( rGDIMetaFile ).Write( rOStm );
2956         }
2957         else
2958         {
2959             delete( new SVMConverter( rOStm, const_cast< GDIMetaFile& >( rGDIMetaFile ), CONVERT_TO_SVM1 ) );
2960         }
2961 
2962 #ifdef DEBUG
2963         if( !bNoSVM1 && rOStm.GetVersion() < SOFFICE_FILEFORMAT_50 )
2964         {
2965 OSL_TRACE( \
2966 "GDIMetaFile would normally be written in old SVM1 format by this call. \
2967 The current implementation always writes in VCLMTF format. \
2968 Please set environment variable SAL_ENABLE_SVM1 to '1' to reenable old behavior" );
2969 		}
2970 #endif // DEBUG
2971 	}
2972 
2973 	return rOStm;
2974 }
2975 
2976 // ------------------------------------------------------------------------
2977 
2978 SvStream& GDIMetaFile::Read( SvStream& rIStm )
2979 {
2980 	Clear();
2981 	rIStm >> *this;
2982 
2983 	return rIStm;
2984 }
2985 
2986 // ------------------------------------------------------------------------
2987 
2988 SvStream& GDIMetaFile::Write( SvStream& rOStm )
2989 {
2990 	VersionCompat*	pCompat;
2991 	const sal_uInt32	nStmCompressMode = rOStm.GetCompressMode();
2992 	sal_uInt16			nOldFormat = rOStm.GetNumberFormatInt();
2993 
2994 	rOStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
2995 	rOStm.Write( "VCLMTF", 6 );
2996 
2997 	pCompat = new VersionCompat( rOStm, STREAM_WRITE, 1 );
2998 
2999 	rOStm << nStmCompressMode;
3000 	rOStm << aPrefMapMode;
3001 	rOStm << aPrefSize;
3002 	rOStm << (sal_uInt32) GetActionCount();
3003 
3004 	delete pCompat;
3005 
3006 	ImplMetaWriteData aWriteData;
3007 	aWriteData.meActualCharSet = rOStm.GetStreamCharSet();
3008 
3009 	MetaAction* pAct = (MetaAction*)First();
3010 	while ( pAct )
3011 	{
3012 		pAct->Write( rOStm, &aWriteData );
3013 		pAct = (MetaAction*)Next();
3014 	}
3015 
3016 	rOStm.SetNumberFormatInt( nOldFormat );
3017 
3018 	return rOStm;
3019 }
3020 
3021 // ------------------------------------------------------------------------
3022 
3023 sal_Bool GDIMetaFile::CreateThumbnail( sal_uInt32 nMaximumExtent,
3024 									BitmapEx& rBmpEx,
3025 									const BitmapEx* pOverlay,
3026 									const Rectangle* pOverlayRect ) const
3027 {
3028 	// the implementation is provided by KA
3029 
3030 	// initialization seems to be complicated but is used to avoid rounding errors
3031 	VirtualDevice	aVDev;
3032 	const Point     aNullPt;
3033 	const Point     aTLPix( aVDev.LogicToPixel( aNullPt, GetPrefMapMode() ) );
3034 	const Point     aBRPix( aVDev.LogicToPixel( Point( GetPrefSize().Width() - 1, GetPrefSize().Height() - 1 ), GetPrefMapMode() ) );
3035 	Size            aDrawSize( aVDev.LogicToPixel( GetPrefSize(), GetPrefMapMode() ) );
3036 	Size			aSizePix( labs( aBRPix.X() - aTLPix.X() ) + 1, labs( aBRPix.Y() - aTLPix.Y() ) + 1 );
3037 	Point			aPosPix;
3038 
3039 	if ( !rBmpEx.IsEmpty() )
3040 		rBmpEx.SetEmpty();
3041 
3042 	// determine size that has the same aspect ratio as image size and
3043 	// fits into the rectangle determined by nMaximumExtent
3044 	if ( aSizePix.Width() && aSizePix.Height()
3045 	  && ( sal::static_int_cast< unsigned long >(aSizePix.Width()) >
3046                nMaximumExtent ||
3047            sal::static_int_cast< unsigned long >(aSizePix.Height()) >
3048                nMaximumExtent ) )
3049 	{
3050 		const Size  aOldSizePix( aSizePix );
3051 		double      fWH = static_cast< double >( aSizePix.Width() ) / aSizePix.Height();
3052 
3053 		if ( fWH <= 1.0 )
3054 		{
3055 			aSizePix.Width() = FRound( nMaximumExtent * fWH );
3056 			aSizePix.Height() = nMaximumExtent;
3057 		}
3058 		else
3059 		{
3060 			aSizePix.Width() = nMaximumExtent;
3061 			aSizePix.Height() = FRound(  nMaximumExtent / fWH );
3062 		}
3063 
3064 		aDrawSize.Width() = FRound( ( static_cast< double >( aDrawSize.Width() ) * aSizePix.Width() ) / aOldSizePix.Width() );
3065 		aDrawSize.Height() = FRound( ( static_cast< double >( aDrawSize.Height() ) * aSizePix.Height() ) / aOldSizePix.Height() );
3066 	}
3067 
3068 	Size 		aFullSize;
3069 	Point		aBackPosPix;
3070 	Rectangle 	aOverlayRect;
3071 
3072 	// calculate addigtional positions and sizes if an overlay image is used
3073 	if (  pOverlay )
3074 	{
3075 		aFullSize = Size( nMaximumExtent, nMaximumExtent );
3076 		aOverlayRect = Rectangle( aNullPt, aFullSize  );
3077 
3078 		aOverlayRect.Intersection( pOverlayRect ? *pOverlayRect : Rectangle( aNullPt, pOverlay->GetSizePixel() ) );
3079 
3080 		if ( !aOverlayRect.IsEmpty() )
3081 			aBackPosPix = Point( ( nMaximumExtent - aSizePix.Width() ) >> 1, ( nMaximumExtent - aSizePix.Height() ) >> 1 );
3082 		else
3083 			pOverlay = NULL;
3084 	}
3085 	else
3086 	{
3087 		aFullSize = aSizePix;
3088 		pOverlay = NULL;
3089 	}
3090 
3091 	// draw image(s) into VDev and get resulting image
3092 	if ( aVDev.SetOutputSizePixel( aFullSize ) )
3093 	{
3094 		// draw metafile into VDev
3095 		const_cast<GDIMetaFile *>(this)->WindStart();
3096 		const_cast<GDIMetaFile *>(this)->Play( &aVDev, aBackPosPix, aDrawSize );
3097 
3098 		// draw overlay if neccessary
3099 		if ( pOverlay )
3100 			aVDev.DrawBitmapEx( aOverlayRect.TopLeft(), aOverlayRect.GetSize(), *pOverlay );
3101 
3102 		// get paint bitmap
3103 		Bitmap aBmp( aVDev.GetBitmap( aNullPt, aVDev.GetOutputSizePixel() ) );
3104 
3105 		// assure that we have a true color image
3106 		if ( aBmp.GetBitCount() != 24 )
3107 			aBmp.Convert( BMP_CONVERSION_24BIT );
3108 
3109 		// create resulting mask bitmap with metafile output set to black
3110 		GDIMetaFile aMonchromeMtf( GetMonochromeMtf( COL_BLACK ) );
3111 		aVDev.DrawWallpaper( Rectangle( aNullPt, aSizePix ), Wallpaper( Color( COL_WHITE ) ) );
3112 		aMonchromeMtf.WindStart();
3113 		aMonchromeMtf.Play( &aVDev, aBackPosPix, aDrawSize );
3114 
3115 		// watch for overlay mask
3116 		if ( pOverlay  )
3117 		{
3118 			Bitmap aOverlayMergeBmp( aVDev.GetBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize() ) );
3119 
3120 			// create ANDed resulting mask at overlay area
3121 			if ( pOverlay->IsTransparent() )
3122 				aVDev.DrawBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize(), pOverlay->GetMask() );
3123 			else
3124 			{
3125 				aVDev.SetLineColor( COL_BLACK );
3126 				aVDev.SetFillColor( COL_BLACK );
3127 				aVDev.DrawRect( aOverlayRect);
3128 			}
3129 
3130 			aOverlayMergeBmp.CombineSimple( aVDev.GetBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize() ), BMP_COMBINE_AND );
3131 			aVDev.DrawBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize(), aOverlayMergeBmp );
3132 		}
3133 
3134 		rBmpEx = BitmapEx( aBmp, aVDev.GetBitmap( aNullPt, aVDev.GetOutputSizePixel() ) );
3135 	}
3136 
3137 	return !rBmpEx.IsEmpty();
3138 }
3139