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