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