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