?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update emoji autocorrect entries from po-files
[LibreOffice.git] / vcl / source / gdi / impgraph.cxx
bloba49100208a069b46af62735bb0dd2494723be41f
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 "sal/config.h"
21
22 #include <comphelper/processfactory.hxx>
23 #include <tools/fract.hxx>
24 #include <tools/vcompat.hxx>
25 #include <tools/urlobj.hxx>
26 #include <tools/debug.hxx>
27 #include <tools/stream.hxx>
28 #include <tools/helpers.hxx>
29 #include <ucbhelper/content.hxx>
30 #include <unotools/ucbstreamhelper.hxx>
31 #include <unotools/tempfile.hxx>
32 #include <vcl/outdev.hxx>
33 #include <vcl/virdev.hxx>
34 #include <vcl/gfxlink.hxx>
35 #include <vcl/cvtgrf.hxx>
36 #include <vcl/graph.hxx>
37 #include <vcl/metaact.hxx>
38 #include <impgraph.hxx>
39 #include <com/sun/star/ucb/CommandAbortedException.hpp>
40 #include <vcl/dibtools.hxx>
41 #include <memory>
42
43 #define GRAPHIC_MTFTOBMP_MAXEXT 2048
44 #define GRAPHIC_STREAMBUFSIZE 8192UL
45
46 #define SYS_WINMETAFILE 0x00000003L
47 #define SYS_WNTMETAFILE 0x00000004L
48 #define SYS_OS2METAFILE 0x00000005L
49 #define SYS_MACMETAFILE 0x00000006L
50
51 #define GRAPHIC_FORMAT_50 static_cast<sal_uInt32>(COMPAT_FORMAT( 'G', 'R', 'F', '5' ))
52 #define NATIVE_FORMAT_50 static_cast<sal_uInt32>(COMPAT_FORMAT( 'N', 'A', 'T', '5' ))
53
54 struct ImpSwapFile
55 {
56 INetURLObject aSwapURL;
57 sal_uLong nRefCount;
58 };
59
60 class ReaderData
61 {
62 public:
63 Size maPreviewSize;
64 };
65
66 GraphicReader::~GraphicReader()
67 {
68 delete mpReaderData;
69 }
70
71 void GraphicReader::DisablePreviewMode()
72 {
73 if( mpReaderData )
74 mpReaderData->maPreviewSize = Size( 0, 0 );
75 }
76
77 void GraphicReader::SetPreviewSize( const Size& rSize )
78 {
79 if( !mpReaderData )
80 mpReaderData = new ReaderData;
81 mpReaderData->maPreviewSize = rSize;
82 }
83
84 Size GraphicReader::GetPreviewSize() const
85 {
86 Size aSize( 0, 0 );
87 if( mpReaderData )
88 aSize = mpReaderData->maPreviewSize;
89 return aSize;
90 }
91
92 ImpGraphic::ImpGraphic() :
93 mpAnimation ( NULL ),
94 mpContext ( NULL ),
95 mpSwapFile ( NULL ),
96 mpGfxLink ( NULL ),
97 meType ( GRAPHIC_NONE ),
98 mnSizeBytes ( 0UL ),
99 mnRefCount ( 1UL ),
100 mbSwapOut ( false ),
101 mbSwapUnderway ( false )
102 {
103 }
104
105 ImpGraphic::ImpGraphic( const ImpGraphic& rImpGraphic ) :
106 maMetaFile ( rImpGraphic.maMetaFile ),
107 maEx ( rImpGraphic.maEx ),
108 mpContext ( NULL ),
109 mpSwapFile ( rImpGraphic.mpSwapFile ),
110 meType ( rImpGraphic.meType ),
111 mnSizeBytes ( rImpGraphic.mnSizeBytes ),
112 mnRefCount ( 1UL ),
113 mbSwapOut ( rImpGraphic.mbSwapOut ),
114 mbSwapUnderway ( false )
115 {
116 if( mpSwapFile )
117 mpSwapFile->nRefCount++;
118
119 if( rImpGraphic.mpGfxLink )
120 mpGfxLink = new GfxLink( *rImpGraphic.mpGfxLink );
121 else
122 mpGfxLink = NULL;
123
124 if( rImpGraphic.mpAnimation )
125 {
126 mpAnimation = new Animation( *rImpGraphic.mpAnimation );
127 maEx = mpAnimation->GetBitmapEx();
128 }
129 else
130 mpAnimation = NULL;
131
132 maSvgData = rImpGraphic.maSvgData;
133 }
134
135 ImpGraphic::ImpGraphic( const Bitmap& rBitmap ) :
136 maEx ( rBitmap ),
137 mpAnimation ( NULL ),
138 mpContext ( NULL ),
139 mpSwapFile ( NULL ),
140 mpGfxLink ( NULL ),
141 meType ( !rBitmap.IsEmpty() ? GRAPHIC_BITMAP : GRAPHIC_NONE ),
142 mnSizeBytes ( 0UL ),
143 mnRefCount ( 1UL ),
144 mbSwapOut ( false ),
145 mbSwapUnderway ( false )
146 {
147 }
148
149 ImpGraphic::ImpGraphic( const BitmapEx& rBitmapEx ) :
150 maEx ( rBitmapEx ),
151 mpAnimation ( NULL ),
152 mpContext ( NULL ),
153 mpSwapFile ( NULL ),
154 mpGfxLink ( NULL ),
155 meType ( !rBitmapEx.IsEmpty() ? GRAPHIC_BITMAP : GRAPHIC_NONE ),
156 mnSizeBytes ( 0UL ),
157 mnRefCount ( 1UL ),
158 mbSwapOut ( false ),
159 mbSwapUnderway ( false )
160 {
161 }
162
163 ImpGraphic::ImpGraphic(const SvgDataPtr& rSvgDataPtr)
164 : mpAnimation( NULL ),
165 mpContext( NULL ),
166 mpSwapFile( NULL ),
167 mpGfxLink( NULL ),
168 meType( rSvgDataPtr.get() ? GRAPHIC_BITMAP : GRAPHIC_NONE ),
169 mnSizeBytes( 0UL ),
170 mnRefCount( 1UL ),
171 mbSwapOut( false ),
172 mbSwapUnderway( false ),
173 maSvgData(rSvgDataPtr)
174 {
175 }
176
177 ImpGraphic::ImpGraphic( const Animation& rAnimation ) :
178 maEx ( rAnimation.GetBitmapEx() ),
179 mpAnimation ( new Animation( rAnimation ) ),
180 mpContext ( NULL ),
181 mpSwapFile ( NULL ),
182 mpGfxLink ( NULL ),
183 meType ( GRAPHIC_BITMAP ),
184 mnSizeBytes ( 0UL ),
185 mnRefCount ( 1UL ),
186 mbSwapOut ( false ),
187 mbSwapUnderway ( false )
188 {
189 }
190
191 ImpGraphic::ImpGraphic( const GDIMetaFile& rMtf ) :
192 maMetaFile ( rMtf ),
193 mpAnimation ( NULL ),
194 mpContext ( NULL ),
195 mpSwapFile ( NULL ),
196 mpGfxLink ( NULL ),
197 meType ( GRAPHIC_GDIMETAFILE ),
198 mnSizeBytes ( 0UL ),
199 mnRefCount ( 1UL ),
200 mbSwapOut ( false ),
201 mbSwapUnderway ( false )
202 {
203 }
204
205 ImpGraphic::~ImpGraphic()
206 {
207 ImplClear();
208
209 if( reinterpret_cast<sal_uLong>(mpContext) > 1UL )
210 delete mpContext;
211 }
212
213 ImpGraphic& ImpGraphic::operator=( const ImpGraphic& rImpGraphic )
214 {
215 if( &rImpGraphic != this )
216 {
217 if( !mbSwapUnderway )
218 ImplClear();
219
220 maMetaFile = rImpGraphic.maMetaFile;
221 meType = rImpGraphic.meType;
222 mnSizeBytes = rImpGraphic.mnSizeBytes;
223
224 delete mpAnimation;
225
226 if ( rImpGraphic.mpAnimation )
227 {
228 mpAnimation = new Animation( *rImpGraphic.mpAnimation );
229 maEx = mpAnimation->GetBitmapEx();
230 }
231 else
232 {
233 mpAnimation = NULL;
234 maEx = rImpGraphic.maEx;
235 }
236
237 if( !mbSwapUnderway )
238 {
239 mbSwapOut = rImpGraphic.mbSwapOut;
240 mpSwapFile = rImpGraphic.mpSwapFile;
241
242 if( mpSwapFile )
243 mpSwapFile->nRefCount++;
244 }
245
246 delete mpGfxLink;
247
248 if( rImpGraphic.mpGfxLink )
249 mpGfxLink = new GfxLink( *rImpGraphic.mpGfxLink );
250 else
251 mpGfxLink = NULL;
252
253 maSvgData = rImpGraphic.maSvgData;
254 }
255
256 return *this;
257 }
258
259 bool ImpGraphic::operator==( const ImpGraphic& rImpGraphic ) const
260 {
261 bool bRet = false;
262
263 if( this == &rImpGraphic )
264 bRet = true;
265 else if( !ImplIsSwapOut() && ( rImpGraphic.meType == meType ) )
266 {
267 switch( meType )
268 {
269 case( GRAPHIC_NONE ):
270 bRet = true;
271 break;
272
273 case( GRAPHIC_GDIMETAFILE ):
274 {
275 if( rImpGraphic.maMetaFile == maMetaFile )
276 bRet = true;
277 }
278 break;
279
280 case( GRAPHIC_BITMAP ):
281 {
282 if(maSvgData.get())
283 {
284 if(maSvgData == rImpGraphic.maSvgData)
285 {
286 bRet = true;
287 }
288 else if(rImpGraphic.maSvgData)
289 {
290 if(maSvgData->getSvgDataArrayLength() == rImpGraphic.maSvgData->getSvgDataArrayLength())
291 {
292 if(0 == memcmp(
293 maSvgData->getSvgDataArray().get(),
294 rImpGraphic.maSvgData->getSvgDataArray().get(),
295 maSvgData->getSvgDataArrayLength()))
296 {
297 bRet = true;
298 }
299 }
300 }
301 }
302 else if( mpAnimation )
303 {
304 if( rImpGraphic.mpAnimation && ( *rImpGraphic.mpAnimation == *mpAnimation ) )
305 bRet = true;
306 }
307 else if( !rImpGraphic.mpAnimation && ( rImpGraphic.maEx == maEx ) )
308 {
309 bRet = true;
310 }
311 }
312 break;
313
314 default:
315 break;
316 }
317 }
318
319 return bRet;
320 }
321
322 void ImpGraphic::ImplClearGraphics( bool bCreateSwapInfo )
323 {
324 if( bCreateSwapInfo && !ImplIsSwapOut() )
325 {
326 maSwapInfo.maPrefMapMode = ImplGetPrefMapMode();
327 maSwapInfo.maPrefSize = ImplGetPrefSize();
328 }
329
330 maEx.Clear();
331 maMetaFile.Clear();
332
333 if( mpAnimation )
334 {
335 mpAnimation->Clear();
336 delete mpAnimation;
337 mpAnimation = NULL;
338 }
339
340 if( mpGfxLink )
341 {
342 delete mpGfxLink;
343 mpGfxLink = NULL;
344 }
345
346 maSvgData.reset();
347 }
348
349 void ImpGraphic::ImplClear()
350 {
351 if( mpSwapFile )
352 {
353 if( mpSwapFile->nRefCount > 1 )
354 mpSwapFile->nRefCount--;
355 else
356 {
357 try
358 {
359 ::ucbhelper::Content aCnt( mpSwapFile->aSwapURL.GetMainURL( INetURLObject::NO_DECODE ),
360 ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >(),
361 comphelper::getProcessComponentContext() );
362
363 aCnt.executeCommand( OUString("delete"),
364 ::com::sun::star::uno::makeAny( true ) );
365 }
366 catch( const ::com::sun::star::ucb::ContentCreationException& )
367 {
368 }
369 catch( const ::com::sun::star::uno::RuntimeException& )
370 {
371 }
372 catch( const ::com::sun::star::ucb::CommandAbortedException& )
373 {
374 }
375 catch( const ::com::sun::star::uno::Exception& )
376 {
377 }
378
379 delete mpSwapFile;
380 }
381
382 mpSwapFile = NULL;
383 }
384
385 mbSwapOut = false;
386
387 // cleanup
388 ImplClearGraphics( false );
389 meType = GRAPHIC_NONE;
390 mnSizeBytes = 0;
391 }
392
393
394 void ImpGraphic::ImplSetDefaultType()
395 {
396 ImplClear();
397 meType = GRAPHIC_DEFAULT;
398 }
399
400 bool ImpGraphic::ImplIsSupportedGraphic() const
401 {
402 return( meType != GRAPHIC_NONE );
403 }
404
405 bool ImpGraphic::ImplIsTransparent() const
406 {
407 bool bRet(true);
408
409 if( meType == GRAPHIC_BITMAP && !maSvgData.get())
410 {
411 bRet = ( mpAnimation ? mpAnimation->IsTransparent() : maEx.IsTransparent() );
412 }
413
414 return bRet;
415 }
416
417 bool ImpGraphic::ImplIsAlpha() const
418 {
419 bool bRet(false);
420
421 if(maSvgData.get())
422 {
423 bRet = true;
424 }
425 else if( meType == GRAPHIC_BITMAP )
426 {
427 bRet = ( NULL == mpAnimation ) && maEx.IsAlpha();
428 }
429
430 return bRet;
431 }
432
433 bool ImpGraphic::ImplIsAnimated() const
434 {
435 return( mpAnimation != NULL );
436 }
437
438 bool ImpGraphic::ImplIsEPS() const
439 {
440 return( ( meType == GRAPHIC_GDIMETAFILE ) &&
441 ( maMetaFile.GetActionSize() > 0 ) &&
442 ( maMetaFile.GetAction( 0 )->GetType() == MetaActionType::EPS ) );
443 }
444
445 Bitmap ImpGraphic::ImplGetBitmap(const GraphicConversionParameters& rParameters) const
446 {
447 Bitmap aRetBmp;
448
449 if( meType == GRAPHIC_BITMAP )
450 {
451 if(maSvgData.get() && maEx.IsEmpty())
452 {
453 // use maEx as local buffer for rendered svg
454 const_cast< ImpGraphic* >(this)->maEx = maSvgData->getReplacement();
455 }
456
457 const BitmapEx& rRetBmpEx = ( mpAnimation ? mpAnimation->GetBitmapEx() : maEx );
458 const Color aReplaceColor( COL_WHITE );
459
460 aRetBmp = rRetBmpEx.GetBitmap( &aReplaceColor );
461
462 if(rParameters.getSizePixel().Width() || rParameters.getSizePixel().Height())
463 aRetBmp.Scale(rParameters.getSizePixel());
464 }
465 else if( ( meType != GRAPHIC_DEFAULT ) && ImplIsSupportedGraphic() )
466 {
467 if(maEx.IsEmpty())
468 {
469 // calculate size
470 ScopedVclPtrInstance< VirtualDevice > aVDev;
471 Size aDrawSize(aVDev->LogicToPixel(maMetaFile.GetPrefSize(), maMetaFile.GetPrefMapMode()));
472
473 if(rParameters.getSizePixel().Width() && rParameters.getSizePixel().Height())
474 {
475 // apply given size if exists
476 aDrawSize = rParameters.getSizePixel();
477 }
478
479 if(aDrawSize.Width() && aDrawSize.Height() && !rParameters.getUnlimitedSize()
480 && (aDrawSize.Width() > GRAPHIC_MTFTOBMP_MAXEXT || aDrawSize.Height() > GRAPHIC_MTFTOBMP_MAXEXT))
481 {
482 // limit bitmap size to a maximum of GRAPHIC_MTFTOBMP_MAXEXT x GRAPHIC_MTFTOBMP_MAXEXT
483 double fWH((double)aDrawSize.Width() / (double)aDrawSize.Height());
484
485 if(fWH <= 1.0)
486 {
487 aDrawSize.setWidth(basegfx::fround(GRAPHIC_MTFTOBMP_MAXEXT * fWH));
488 aDrawSize.setHeight(GRAPHIC_MTFTOBMP_MAXEXT);
489 }
490 else
491 {
492 aDrawSize.setWidth(GRAPHIC_MTFTOBMP_MAXEXT);
493 aDrawSize.setHeight(basegfx::fround(GRAPHIC_MTFTOBMP_MAXEXT / fWH));
494 }
495 }
496
497 // calculate pixel size. Normally, it's the same as aDrawSize, but may
498 // need to be extended when hairlines are on the right or bottom edge
499 Size aPixelSize(aDrawSize);
500
501 if(GRAPHIC_GDIMETAFILE == ImplGetType())
502 {
503 // get hairline and full bound rect
504 Rectangle aHairlineRect;
505 const Rectangle aRect(maMetaFile.GetBoundRect(*aVDev.get(), &aHairlineRect));
506
507 if(!aRect.IsEmpty() && !aHairlineRect.IsEmpty())
508 {
509 // expand if needed to allow bottom and right hairlines to be added
510 if(aRect.Right() == aHairlineRect.Right())
511 {
512 aPixelSize.setWidth(aPixelSize.getWidth() + 1);
513 }
514
515 if(aRect.Bottom() == aHairlineRect.Bottom())
516 {
517 aPixelSize.setHeight(aPixelSize.getHeight() + 1);
518 }
519 }
520 }
521
522 if(aVDev->SetOutputSizePixel(aPixelSize))
523 {
524 if(rParameters.getAntiAliase())
525 {
526 aVDev->SetAntialiasing(aVDev->GetAntialiasing() | AntialiasingFlags::EnableB2dDraw);
527 }
528
529 if(rParameters.getSnapHorVerLines())
530 {
531 aVDev->SetAntialiasing(aVDev->GetAntialiasing() | AntialiasingFlags::PixelSnapHairline);
532 }
533
534 ImplDraw( aVDev.get(), Point(), aDrawSize );
535
536 // use maEx as local buffer for rendered metafile
537 const_cast< ImpGraphic* >(this)->maEx = aVDev->GetBitmap( Point(), aVDev->GetOutputSizePixel() );
538 }
539 }
540
541 aRetBmp = maEx.GetBitmap();
542 }
543
544 if( !!aRetBmp )
545 {
546 aRetBmp.SetPrefMapMode( ImplGetPrefMapMode() );
547 aRetBmp.SetPrefSize( ImplGetPrefSize() );
548 }
549
550 return aRetBmp;
551 }
552
553 BitmapEx ImpGraphic::ImplGetBitmapEx(const GraphicConversionParameters& rParameters) const
554 {
555 BitmapEx aRetBmpEx;
556
557 if( meType == GRAPHIC_BITMAP )
558 {
559 if(maSvgData.get() && maEx.IsEmpty())
560 {
561 // use maEx as local buffer for rendered svg
562 const_cast< ImpGraphic* >(this)->maEx = maSvgData->getReplacement();
563 }
564
565 aRetBmpEx = ( mpAnimation ? mpAnimation->GetBitmapEx() : maEx );
566
567 if(rParameters.getSizePixel().Width() || rParameters.getSizePixel().Height())
568 {
569 aRetBmpEx.Scale(
570 rParameters.getSizePixel(),
571 rParameters.getScaleHighQuality() ? BmpScaleFlag::Interpolate : BmpScaleFlag::Fast);
572 }
573 }
574 else if( ( meType != GRAPHIC_DEFAULT ) && ImplIsSupportedGraphic() )
575 {
576 if(maEx.IsEmpty())
577 {
578 const ImpGraphic aMonoMask( maMetaFile.GetMonochromeMtf( COL_BLACK ) );
579
580 // use maEx as local buffer for rendered metafile
581 const_cast< ImpGraphic* >(this)->maEx = BitmapEx(ImplGetBitmap(rParameters), aMonoMask.ImplGetBitmap(rParameters));
582 }
583
584 aRetBmpEx = maEx;
585 }
586
587 return aRetBmpEx;
588 }
589
590 Animation ImpGraphic::ImplGetAnimation() const
591 {
592 Animation aAnimation;
593
594 if( mpAnimation )
595 aAnimation = *mpAnimation;
596
597 return aAnimation;
598 }
599
600 const GDIMetaFile& ImpGraphic::ImplGetGDIMetaFile() const
601 {
602 if (GRAPHIC_BITMAP == meType && !maMetaFile.GetActionSize())
603 {
604 // #i119735#
605 // Use the local maMetaFile as container for a metafile-representation
606 // of the bitmap graphic. This will be done only once, thus be buffered.
607 // I checked all usages of maMetaFile, it is only used when type is not
608 // GRAPHIC_BITMAP. In operator= it will get copied, thus buffering will
609 // survive copying (change this if not wanted)
610 ImpGraphic* pThat = const_cast< ImpGraphic* >(this);
611
612 if(maSvgData.get() && !maEx)
613 {
614 // use maEx as local buffer for rendered svg
615 pThat->maEx = maSvgData->getReplacement();
616 }
617
618 // #123983# directly create a metafile with the same PrefSize and PrefMapMode
619 // the bitmap has, this will be an always correct metafile
620 if(maEx.IsTransparent())
621 {
622 pThat->maMetaFile.AddAction(new MetaBmpExScaleAction(Point(), maEx.GetPrefSize(), maEx));
623 }
624 else
625 {
626 pThat->maMetaFile.AddAction(new MetaBmpScaleAction(Point(), maEx.GetPrefSize(), maEx.GetBitmap()));
627 }
628
629 pThat->maMetaFile.Stop();
630 pThat->maMetaFile.WindStart();
631 pThat->maMetaFile.SetPrefSize(maEx.GetPrefSize());
632 pThat->maMetaFile.SetPrefMapMode(maEx.GetPrefMapMode());
633 }
634
635 return maMetaFile;
636 }
637
638 Size ImpGraphic::ImplGetPrefSize() const
639 {
640 Size aSize;
641
642 if( ImplIsSwapOut() )
643 aSize = maSwapInfo.maPrefSize;
644 else
645 {
646 switch( meType )
647 {
648 case( GRAPHIC_NONE ):
649 case( GRAPHIC_DEFAULT ):
650 break;
651
652 case( GRAPHIC_BITMAP ):
653 {
654 if(maSvgData.get() && maEx.IsEmpty())
655 {
656 // svg not yet buffered in maEx, return size derived from range
657 const basegfx::B2DRange& rRange = maSvgData->getRange();
658
659 aSize = Size(basegfx::fround(rRange.getWidth()), basegfx::fround(rRange.getHeight()));
660 }
661 else
662 {
663 aSize = maEx.GetPrefSize();
664
665 if( !aSize.Width() || !aSize.Height() )
666 {
667 aSize = maEx.GetSizePixel();
668 }
669 }
670 }
671 break;
672
673 default:
674 {
675 if( ImplIsSupportedGraphic() )
676 aSize = maMetaFile.GetPrefSize();
677 }
678 break;
679 }
680 }
681
682 return aSize;
683 }
684
685 void ImpGraphic::ImplSetPrefSize( const Size& rPrefSize )
686 {
687 switch( meType )
688 {
689 case( GRAPHIC_NONE ):
690 case( GRAPHIC_DEFAULT ):
691 break;
692
693 case( GRAPHIC_BITMAP ):
694 {
695 //UUUU used when importing a writer FlyFrame with SVG as graphic, added conversion
696 // to allow setting the PrefSize at the BitmapEx to hold it
697 if(maSvgData.get() && maEx.IsEmpty())
698 {
699 // use maEx as local buffer for rendered svg
700 const_cast< ImpGraphic* >(this)->maEx = maSvgData->getReplacement();
701 }
702
703 // #108077# Push through pref size to animation object,
704 // will be lost on copy otherwise
705 if( ImplIsAnimated() )
706 {
707 const_cast< BitmapEx& >(mpAnimation->GetBitmapEx()).SetPrefSize( rPrefSize );
708 }
709
710 maEx.SetPrefSize( rPrefSize );
711 }
712 break;
713
714 default:
715 {
716 if( ImplIsSupportedGraphic() )
717 maMetaFile.SetPrefSize( rPrefSize );
718 }
719 break;
720 }
721 }
722
723 MapMode ImpGraphic::ImplGetPrefMapMode() const
724 {
725 MapMode aMapMode;
726
727 if( ImplIsSwapOut() )
728 aMapMode = maSwapInfo.maPrefMapMode;
729 else
730 {
731 switch( meType )
732 {
733 case( GRAPHIC_NONE ):
734 case( GRAPHIC_DEFAULT ):
735 break;
736
737 case( GRAPHIC_BITMAP ):
738 {
739 if(maSvgData.get() && maEx.IsEmpty())
740 {
741 // svg not yet buffered in maEx, return default PrefMapMode
742 aMapMode = MapMode(MAP_100TH_MM);
743 }
744 else
745 {
746 const Size aSize( maEx.GetPrefSize() );
747
748 if ( aSize.Width() && aSize.Height() )
749 aMapMode = maEx.GetPrefMapMode();
750 }
751 }
752 break;
753
754 default:
755 {
756 if( ImplIsSupportedGraphic() )
757 return maMetaFile.GetPrefMapMode();
758 }
759 break;
760 }
761 }
762
763 return aMapMode;
764 }
765
766 void ImpGraphic::ImplSetPrefMapMode( const MapMode& rPrefMapMode )
767 {
768 switch( meType )
769 {
770 case( GRAPHIC_NONE ):
771 case( GRAPHIC_DEFAULT ):
772 break;
773
774 case( GRAPHIC_BITMAP ):
775 {
776 if(maSvgData.get())
777 {
778 // ignore for Svg. If this is really used (except the grfcache)
779 // it can be extended by using maEx as buffer for maSvgData->getReplacement()
780 }
781 else
782 {
783 // #108077# Push through pref mapmode to animation object,
784 // will be lost on copy otherwise
785 if( ImplIsAnimated() )
786 {
787 const_cast< BitmapEx& >(mpAnimation->GetBitmapEx()).SetPrefMapMode( rPrefMapMode );
788 }
789
790 maEx.SetPrefMapMode( rPrefMapMode );
791 }
792 }
793 break;
794
795 default:
796 {
797 if( ImplIsSupportedGraphic() )
798 maMetaFile.SetPrefMapMode( rPrefMapMode );
799 }
800 break;
801 }
802 }
803
804 sal_uLong ImpGraphic::ImplGetSizeBytes() const
805 {
806 if( 0 == mnSizeBytes )
807 {
808 if( meType == GRAPHIC_BITMAP )
809 {
810 if(maSvgData.get())
811 {
812 mnSizeBytes = maSvgData->getSvgDataArrayLength();
813 }
814 else
815 {
816 mnSizeBytes = mpAnimation ? mpAnimation->GetSizeBytes() : maEx.GetSizeBytes();
817 }
818 }
819 else if( meType == GRAPHIC_GDIMETAFILE )
820 {
821 mnSizeBytes = maMetaFile.GetSizeBytes();
822 }
823 }
824
825 return mnSizeBytes;
826 }
827
828 void ImpGraphic::ImplDraw( OutputDevice* pOutDev, const Point& rDestPt ) const
829 {
830 if( ImplIsSupportedGraphic() && !ImplIsSwapOut() )
831 {
832 switch( meType )
833 {
834 case( GRAPHIC_DEFAULT ):
835 break;
836
837 case( GRAPHIC_BITMAP ):
838 {
839 if(maSvgData.get() && !maEx)
840 {
841 // use maEx as local buffer for rendered svg
842 const_cast< ImpGraphic* >(this)->maEx = maSvgData->getReplacement();
843 }
844
845 if ( mpAnimation )
846 {
847 mpAnimation->Draw( pOutDev, rDestPt );
848 }
849 else
850 {
851 maEx.Draw( pOutDev, rDestPt );
852 }
853 }
854 break;
855
856 default:
857 ImplDraw( pOutDev, rDestPt, maMetaFile.GetPrefSize() );
858 break;
859 }
860 }
861 }
862
863 void ImpGraphic::ImplDraw( OutputDevice* pOutDev,
864 const Point& rDestPt, const Size& rDestSize ) const
865 {
866 if( ImplIsSupportedGraphic() && !ImplIsSwapOut() )
867 {
868 switch( meType )
869 {
870 case( GRAPHIC_DEFAULT ):
871 break;
872
873 case( GRAPHIC_BITMAP ):
874 {
875 if(maSvgData.get() && maEx.IsEmpty())
876 {
877 // use maEx as local buffer for rendered svg
878 const_cast< ImpGraphic* >(this)->maEx = maSvgData->getReplacement();
879 }
880
881 if( mpAnimation )
882 {
883 mpAnimation->Draw( pOutDev, rDestPt, rDestSize );
884 }
885 else
886 {
887 maEx.Draw( pOutDev, rDestPt, rDestSize );
888 }
889 }
890 break;
891
892 default:
893 {
894 const_cast<ImpGraphic*>(this)->maMetaFile.WindStart();
895 const_cast<ImpGraphic*>(this)->maMetaFile.Play( pOutDev, rDestPt, rDestSize );
896 const_cast<ImpGraphic*>(this)->maMetaFile.WindStart();
897 }
898 break;
899 }
900 }
901 }
902
903 void ImpGraphic::ImplStartAnimation( OutputDevice* pOutDev, const Point& rDestPt,
904 const Size& rDestSize, long nExtraData,
905 OutputDevice* pFirstFrameOutDev )
906 {
907 if( ImplIsSupportedGraphic() && !ImplIsSwapOut() && mpAnimation )
908 mpAnimation->Start( pOutDev, rDestPt, rDestSize, nExtraData, pFirstFrameOutDev );
909 }
910
911 void ImpGraphic::ImplStopAnimation( OutputDevice* pOutDev, long nExtraData )
912 {
913 if( ImplIsSupportedGraphic() && !ImplIsSwapOut() && mpAnimation )
914 mpAnimation->Stop( pOutDev, nExtraData );
915 }
916
917 void ImpGraphic::ImplSetAnimationNotifyHdl( const Link<>& rLink )
918 {
919 if( mpAnimation )
920 mpAnimation->SetNotifyHdl( rLink );
921 }
922
923 Link<> ImpGraphic::ImplGetAnimationNotifyHdl() const
924 {
925 Link<> aLink;
926
927 if( mpAnimation )
928 aLink = mpAnimation->GetNotifyHdl();
929
930 return aLink;
931 }
932
933 sal_uLong ImpGraphic::ImplGetAnimationLoopCount() const
934 {
935 return( mpAnimation ? mpAnimation->GetLoopCount() : 0UL );
936 }
937
938
939 void ImpGraphic::ImplSetContext( GraphicReader* pReader )
940 {
941 mpContext = pReader;
942 }
943
944 bool ImpGraphic::ImplReadEmbedded( SvStream& rIStm )
945 {
946 MapMode aMapMode;
947 Size aSize;
948 sal_uInt32 nId;
949 sal_Int32 nType;
950 sal_Int32 nLen;
951 const SvStreamEndian nOldFormat = rIStm.GetEndian();
952 bool bRet = false;
953
954 rIStm.SetEndian( SvStreamEndian::LITTLE );
955 rIStm.ReadUInt32( nId );
956
957 // check version
958 if( GRAPHIC_FORMAT_50 == nId )
959 {
960 // read new style header
961 VersionCompat* pCompat = new VersionCompat( rIStm, StreamMode::READ );
962
963 rIStm.ReadInt32( nType );
964 rIStm.ReadInt32( nLen );
965 ReadPair( rIStm, aSize );
966 ReadMapMode( rIStm, aMapMode );
967
968 delete pCompat;
969 }
970 else
971 {
972 // read old style header
973 sal_Int32 nWidth, nHeight;
974 sal_Int32 nMapMode, nScaleNumX, nScaleDenomX;
975 sal_Int32 nScaleNumY, nScaleDenomY, nOffsX, nOffsY;
976
977 rIStm.SeekRel( -4L );
978
979 rIStm.ReadInt32( nType ).ReadInt32( nLen ).ReadInt32( nWidth ).ReadInt32( nHeight );
980 rIStm.ReadInt32( nMapMode ).ReadInt32( nScaleNumX ).ReadInt32( nScaleDenomX ).ReadInt32( nScaleNumY );
981 rIStm.ReadInt32( nScaleDenomY ).ReadInt32( nOffsX ).ReadInt32( nOffsY );
982
983 // swapped
984 if( nType > 100L )
985 {
986 nType = OSL_SWAPDWORD( nType );
987 nLen = OSL_SWAPDWORD( nLen );
988 nWidth = OSL_SWAPDWORD( nWidth );
989 nHeight = OSL_SWAPDWORD( nHeight );
990 nMapMode = OSL_SWAPDWORD( nMapMode );
991 nScaleNumX = OSL_SWAPDWORD( nScaleNumX );
992 nScaleDenomX = OSL_SWAPDWORD( nScaleDenomX );
993 nScaleNumY = OSL_SWAPDWORD( nScaleNumY );
994 nScaleDenomY = OSL_SWAPDWORD( nScaleDenomY );
995 nOffsX = OSL_SWAPDWORD( nOffsX );
996 nOffsY = OSL_SWAPDWORD( nOffsY );
997 }
998
999 aSize = Size( nWidth, nHeight );
1000 aMapMode = MapMode( (MapUnit) nMapMode, Point( nOffsX, nOffsY ),
1001 Fraction( nScaleNumX, nScaleDenomX ),
1002 Fraction( nScaleNumY, nScaleDenomY ) );
1003 }
1004
1005 meType = (GraphicType) nType;
1006
1007 if( meType )
1008 {
1009 if( meType == GRAPHIC_BITMAP )
1010 {
1011 if(maSvgData.get() && maEx.IsEmpty())
1012 {
1013 // use maEx as local buffer for rendered svg
1014 maEx = maSvgData->getReplacement();
1015 }
1016
1017 maEx.aBitmapSize = aSize;
1018
1019 if( aMapMode != MapMode() )
1020 {
1021 maEx.SetPrefMapMode( aMapMode );
1022 maEx.SetPrefSize( aSize );
1023 }
1024 }
1025 else
1026 {
1027 maMetaFile.SetPrefMapMode( aMapMode );
1028 maMetaFile.SetPrefSize( aSize );
1029 }
1030
1031 if( meType == GRAPHIC_BITMAP || meType == GRAPHIC_GDIMETAFILE )
1032 {
1033 ReadImpGraphic( rIStm, *this );
1034 bRet = ( rIStm.GetError() == 0UL );
1035 }
1036 else if( sal::static_int_cast<sal_uLong>(meType) >= SYS_WINMETAFILE
1037 && sal::static_int_cast<sal_uLong>(meType) <= SYS_MACMETAFILE )
1038 {
1039 Graphic aSysGraphic;
1040 sal_uLong nCvtType;
1041
1042 switch( sal::static_int_cast<sal_uLong>(meType) )
1043 {
1044 case( SYS_WINMETAFILE ):
1045 case( SYS_WNTMETAFILE ): nCvtType = CVT_WMF; break;
1046 case( SYS_OS2METAFILE ): nCvtType = CVT_MET; break;
1047 case( SYS_MACMETAFILE ): nCvtType = CVT_PCT; break;
1048
1049 default:
1050 nCvtType = CVT_UNKNOWN;
1051 break;
1052 }
1053
1054 if( nType && GraphicConverter::Import( rIStm, aSysGraphic, nCvtType ) == ERRCODE_NONE )
1055 {
1056 *this = ImpGraphic( aSysGraphic.GetGDIMetaFile() );
1057 bRet = ( rIStm.GetError() == 0UL );
1058 }
1059 else
1060 meType = GRAPHIC_DEFAULT;
1061 }
1062
1063 if( bRet )
1064 {
1065 ImplSetPrefMapMode( aMapMode );
1066 ImplSetPrefSize( aSize );
1067 }
1068 }
1069 else
1070 bRet = true;
1071
1072 rIStm.SetEndian( nOldFormat );
1073
1074 return bRet;
1075 }
1076
1077 bool ImpGraphic::ImplWriteEmbedded( SvStream& rOStm )
1078 {
1079 bool bRet = false;
1080
1081 if( ( meType != GRAPHIC_NONE ) && ( meType != GRAPHIC_DEFAULT ) && !ImplIsSwapOut() )
1082 {
1083 const MapMode aMapMode( ImplGetPrefMapMode() );
1084 const Size aSize( ImplGetPrefSize() );
1085 const SvStreamEndian nOldFormat = rOStm.GetEndian();
1086 sal_uLong nDataFieldPos;
1087
1088 rOStm.SetEndian( SvStreamEndian::LITTLE );
1089
1090 // write correct version ( old style/new style header )
1091 if( rOStm.GetVersion() >= SOFFICE_FILEFORMAT_50 )
1092 {
1093 // write ID for new format (5.0)
1094 rOStm.WriteUInt32( GRAPHIC_FORMAT_50 );
1095
1096 // write new style header
1097 VersionCompat* pCompat = new VersionCompat( rOStm, StreamMode::WRITE, 1 );
1098
1099 rOStm.WriteInt32( meType );
1100
1101 // data size is updated later
1102 nDataFieldPos = rOStm.Tell();
1103 rOStm.WriteInt32( 0 );
1104
1105 WritePair( rOStm, aSize );
1106 WriteMapMode( rOStm, aMapMode );
1107
1108 delete pCompat;
1109 }
1110 else
1111 {
1112 // write old style (<=4.0) header
1113 rOStm.WriteInt32( meType );
1114
1115 // data size is updated later
1116 nDataFieldPos = rOStm.Tell();
1117 rOStm.WriteInt32( 0 );
1118 rOStm.WriteInt32( aSize.Width() );
1119 rOStm.WriteInt32( aSize.Height() );
1120 rOStm.WriteInt32( aMapMode.GetMapUnit() );
1121 rOStm.WriteInt32( aMapMode.GetScaleX().GetNumerator() );
1122 rOStm.WriteInt32( aMapMode.GetScaleX().GetDenominator() );
1123 rOStm.WriteInt32( aMapMode.GetScaleY().GetNumerator() );
1124 rOStm.WriteInt32( aMapMode.GetScaleY().GetDenominator() );
1125 rOStm.WriteInt32( aMapMode.GetOrigin().X() );
1126 rOStm.WriteInt32( aMapMode.GetOrigin().Y() );
1127 }
1128
1129 // write data block
1130 if( !rOStm.GetError() )
1131 {
1132 const sal_uLong nDataStart = rOStm.Tell();
1133
1134 if( ImplIsSupportedGraphic() )
1135 WriteImpGraphic( rOStm, *this );
1136
1137 if( !rOStm.GetError() )
1138 {
1139 const sal_uLong nStmPos2 = rOStm.Tell();
1140 rOStm.Seek( nDataFieldPos );
1141 rOStm.WriteInt32( nStmPos2 - nDataStart );
1142 rOStm.Seek( nStmPos2 );
1143 bRet = true;
1144 }
1145 }
1146
1147 rOStm.SetEndian( nOldFormat );
1148 }
1149
1150 return bRet;
1151 }
1152
1153 bool ImpGraphic::ImplSwapOut()
1154 {
1155 bool bRet = false;
1156
1157 if( !ImplIsSwapOut() )
1158 {
1159 ::utl::TempFile aTempFile;
1160 const INetURLObject aTmpURL( aTempFile.GetURL() );
1161
1162 if( !aTmpURL.GetMainURL( INetURLObject::NO_DECODE ).isEmpty() )
1163 {
1164 std::unique_ptr<SvStream> xOStm;
1165 try
1166 {
1167 xOStm.reset(::utl::UcbStreamHelper::CreateStream( aTmpURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READWRITE | StreamMode::SHARE_DENYWRITE ));
1168 }
1169 catch( const ::com::sun::star::uno::Exception& )
1170 {
1171 }
1172 if( xOStm )
1173 {
1174 xOStm->SetVersion( SOFFICE_FILEFORMAT_50 );
1175 xOStm->SetCompressMode( SvStreamCompressFlags::NATIVE );
1176
1177 if( ( bRet = ImplSwapOut( xOStm.get() ) ) )
1178 {
1179 mpSwapFile = new ImpSwapFile;
1180 mpSwapFile->nRefCount = 1;
1181 mpSwapFile->aSwapURL = aTmpURL;
1182 }
1183 else
1184 {
1185 xOStm.reset();
1186
1187 try
1188 {
1189 ::ucbhelper::Content aCnt( aTmpURL.GetMainURL( INetURLObject::NO_DECODE ),
1190 ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >(),
1191 comphelper::getProcessComponentContext() );
1192
1193 aCnt.executeCommand( OUString("delete"),
1194 ::com::sun::star::uno::makeAny( true ) );
1195 }
1196 catch( const ::com::sun::star::ucb::ContentCreationException& )
1197 {
1198 }
1199 catch( const ::com::sun::star::uno::RuntimeException& )
1200 {
1201 }
1202 catch( const ::com::sun::star::ucb::CommandAbortedException& )
1203 {
1204 }
1205 catch( const ::com::sun::star::uno::Exception& )
1206 {
1207 }
1208 }
1209 }
1210 }
1211 }
1212
1213 return bRet;
1214 }
1215
1216 void ImpGraphic::ImplSwapOutAsLink()
1217 {
1218 ImplClearGraphics( true );
1219 mbSwapOut = true;
1220 }
1221
1222 bool ImpGraphic::ImplSwapOut( SvStream* xOStm )
1223 {
1224 bool bRet = false;
1225
1226 if( xOStm )
1227 {
1228 xOStm->SetBufferSize( GRAPHIC_STREAMBUFSIZE );
1229
1230 if( !xOStm->GetError() && ImplWriteEmbedded( *xOStm ) )
1231 {
1232 xOStm->Flush();
1233
1234 if( !xOStm->GetError() )
1235 {
1236 ImplClearGraphics( true );
1237 bRet = mbSwapOut = true;
1238 }
1239 }
1240 }
1241 else
1242 {
1243 SAL_WARN("vcl.gdi", "Graphic SwapOut: No stream for swap out!");
1244 }
1245
1246 return bRet;
1247 }
1248
1249 bool ImpGraphic::ImplSwapIn()
1250 {
1251 bool bRet = false;
1252
1253 if( ImplIsSwapOut() )
1254 {
1255 OUString aSwapURL;
1256
1257 if( mpSwapFile )
1258 aSwapURL = mpSwapFile->aSwapURL.GetMainURL( INetURLObject::NO_DECODE );
1259
1260 if( !aSwapURL.isEmpty() )
1261 {
1262 std::unique_ptr<SvStream> xIStm;
1263 try
1264 {
1265 xIStm.reset(::utl::UcbStreamHelper::CreateStream( aSwapURL, STREAM_READWRITE | StreamMode::SHARE_DENYWRITE ));
1266 }
1267 catch( const ::com::sun::star::uno::Exception& )
1268 {
1269 }
1270
1271 if( xIStm )
1272 {
1273 xIStm->SetVersion( SOFFICE_FILEFORMAT_50 );
1274 xIStm->SetCompressMode( SvStreamCompressFlags::NATIVE );
1275
1276 bRet = ImplSwapIn( xIStm.get() );
1277 xIStm.reset();
1278
1279 if( mpSwapFile )
1280 {
1281 if( mpSwapFile->nRefCount > 1 )
1282 mpSwapFile->nRefCount--;
1283 else
1284 {
1285 try
1286 {
1287 ::ucbhelper::Content aCnt( aSwapURL,
1288 ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >(),
1289 comphelper::getProcessComponentContext() );
1290
1291 aCnt.executeCommand( OUString("delete"),
1292 ::com::sun::star::uno::makeAny( true ) );
1293 }
1294 catch( const ::com::sun::star::ucb::ContentCreationException& )
1295 {
1296 }
1297 catch( const ::com::sun::star::uno::RuntimeException& )
1298 {
1299 }
1300 catch( const ::com::sun::star::ucb::CommandAbortedException& )
1301 {
1302 }
1303 catch( const ::com::sun::star::uno::Exception& )
1304 {
1305 }
1306
1307 delete mpSwapFile;
1308 }
1309
1310 mpSwapFile = NULL;
1311 }
1312 }
1313 }
1314 }
1315
1316 return bRet;
1317 }
1318
1319 bool ImpGraphic::ImplSwapIn( SvStream* xIStm )
1320 {
1321 bool bRet = false;
1322
1323 if( xIStm )
1324 {
1325 xIStm->SetBufferSize( GRAPHIC_STREAMBUFSIZE );
1326
1327 if( !xIStm->GetError() )
1328 {
1329 mbSwapUnderway = true;
1330 bRet = ImplReadEmbedded( *xIStm );
1331 mbSwapUnderway = false;
1332
1333 if( !bRet )
1334 ImplClear();
1335 else
1336 mbSwapOut = false;
1337 }
1338 }
1339
1340 return bRet;
1341 }
1342
1343
1344 void ImpGraphic::ImplSetLink( const GfxLink& rGfxLink )
1345 {
1346 delete mpGfxLink;
1347 mpGfxLink = new GfxLink( rGfxLink );
1348
1349 if( mpGfxLink->IsNative() )
1350 mpGfxLink->SwapOut();
1351 }
1352
1353 GfxLink ImpGraphic::ImplGetLink()
1354 {
1355 return( mpGfxLink ? *mpGfxLink : GfxLink() );
1356 }
1357
1358 bool ImpGraphic::ImplIsLink() const
1359 {
1360 return ( mpGfxLink != NULL );
1361 }
1362
1363 BitmapChecksum ImpGraphic::ImplGetChecksum() const
1364 {
1365 BitmapChecksum nRet = 0;
1366
1367 if( ImplIsSupportedGraphic() && !ImplIsSwapOut() )
1368 {
1369 switch( meType )
1370 {
1371 case( GRAPHIC_DEFAULT ):
1372 break;
1373
1374 case( GRAPHIC_BITMAP ):
1375 {
1376 if(maSvgData.get() && maEx.IsEmpty())
1377 {
1378 // use maEx as local buffer for rendered svg
1379 const_cast< ImpGraphic* >(this)->maEx = maSvgData->getReplacement();
1380 }
1381
1382 if( mpAnimation )
1383 {
1384 nRet = mpAnimation->GetChecksum();
1385 }
1386 else
1387 {
1388 nRet = maEx.GetChecksum();
1389 }
1390 }
1391 break;
1392
1393 default:
1394 nRet = maMetaFile.GetChecksum();
1395 break;
1396 }
1397 }
1398
1399 return nRet;
1400 }
1401
1402 bool ImpGraphic::ImplExportNative( SvStream& rOStm ) const
1403 {
1404 bool bResult = false;
1405
1406 if( !rOStm.GetError() )
1407 {
1408 if( !ImplIsSwapOut() )
1409 {
1410 if( mpGfxLink && mpGfxLink->IsNative() )
1411 bResult = mpGfxLink->ExportNative( rOStm );
1412 else
1413 {
1414 WriteImpGraphic( rOStm, *this );
1415 bResult = ( rOStm.GetError() == ERRCODE_NONE );
1416 }
1417 }
1418 else
1419 rOStm.SetError( SVSTREAM_GENERALERROR );
1420 }
1421
1422 return bResult;
1423 }
1424
1425
1426 SvStream& ReadImpGraphic( SvStream& rIStm, ImpGraphic& rImpGraphic )
1427 {
1428 if( !rIStm.GetError() )
1429 {
1430 const sal_uLong nStmPos1 = rIStm.Tell();
1431 sal_uInt32 nTmp;
1432
1433 if ( !rImpGraphic.mbSwapUnderway )
1434 rImpGraphic.ImplClear();
1435
1436 // read Id
1437 rIStm.ReadUInt32( nTmp );
1438
1439 // if there is no more data, avoid further expensive
1440 // reading which will create VDevs and other stuff, just to
1441 // read nothing. CAUTION: Eof is only true AFTER reading another
1442 // byte, a speciality of SvMemoryStream (!)
1443 if(!rIStm.GetError() && !rIStm.IsEof())
1444 {
1445 if( NATIVE_FORMAT_50 == nTmp )
1446 {
1447 Graphic aGraphic;
1448 GfxLink aLink;
1449 VersionCompat* pCompat;
1450
1451 // read compat info
1452 pCompat = new VersionCompat( rIStm, StreamMode::READ );
1453 delete pCompat;
1454
1455 ReadGfxLink( rIStm, aLink );
1456
1457 // set dummy link to avoid creation of additional link after filtering;
1458 // we set a default link to avoid unnecessary swapping of native data
1459 aGraphic.SetLink( GfxLink() );
1460
1461 if( !rIStm.GetError() && aLink.LoadNative( aGraphic ) )
1462 {
1463 // set link only, if no other link was set
1464 const bool bSetLink = ( rImpGraphic.mpGfxLink == NULL );
1465
1466 // assign graphic
1467 rImpGraphic = *aGraphic.ImplGetImpGraphic();
1468
1469 if( aLink.IsPrefMapModeValid() )
1470 rImpGraphic.ImplSetPrefMapMode( aLink.GetPrefMapMode() );
1471
1472 if( aLink.IsPrefSizeValid() )
1473 rImpGraphic.ImplSetPrefSize( aLink.GetPrefSize() );
1474
1475 if( bSetLink )
1476 rImpGraphic.ImplSetLink( aLink );
1477 }
1478 else
1479 {
1480 rIStm.Seek( nStmPos1 );
1481 rIStm.SetError( ERRCODE_IO_WRONGFORMAT );
1482 }
1483 }
1484 else
1485 {
1486 BitmapEx aBmpEx;
1487 const SvStreamEndian nOldFormat = rIStm.GetEndian();
1488
1489 rIStm.SeekRel( -4 );
1490 rIStm.SetEndian( SvStreamEndian::LITTLE );
1491 ReadDIBBitmapEx(aBmpEx, rIStm);
1492
1493 if( !rIStm.GetError() )
1494 {
1495 sal_uInt32 nMagic1(0), nMagic2(0);
1496 sal_uLong nActPos = rIStm.Tell();
1497
1498 rIStm.ReadUInt32( nMagic1 ).ReadUInt32( nMagic2 );
1499 rIStm.Seek( nActPos );
1500
1501 rImpGraphic = ImpGraphic( aBmpEx );
1502
1503 if( !rIStm.GetError() && ( 0x5344414e == nMagic1 ) && ( 0x494d4931 == nMagic2 ) )
1504 {
1505 delete rImpGraphic.mpAnimation;
1506 rImpGraphic.mpAnimation = new Animation;
1507 ReadAnimation( rIStm, *rImpGraphic.mpAnimation );
1508
1509 // #108077# manually set loaded BmpEx to Animation
1510 // (which skips loading its BmpEx if already done)
1511 rImpGraphic.mpAnimation->SetBitmapEx(aBmpEx);
1512 }
1513 else
1514 rIStm.ResetError();
1515 }
1516 else
1517 {
1518 GDIMetaFile aMtf;
1519
1520 rIStm.Seek( nStmPos1 );
1521 rIStm.ResetError();
1522 ReadGDIMetaFile( rIStm, aMtf );
1523
1524 if( !rIStm.GetError() )
1525 {
1526 rImpGraphic = aMtf;
1527 }
1528 else
1529 {
1530 // try to stream in Svg defining data (length, byte array and evtl. path)
1531 // See below (operator<<) for more information
1532 const sal_uInt32 nSvgMagic((sal_uInt32('s') << 24) | (sal_uInt32('v') << 16) | (sal_uInt32('g') << 8) | sal_uInt32('0'));
1533 sal_uInt32 nMagic;
1534 rIStm.Seek(nStmPos1);
1535 rIStm.ResetError();
1536 rIStm.ReadUInt32( nMagic );
1537
1538 if(nSvgMagic == nMagic)
1539 {
1540 sal_uInt32 mnSvgDataArrayLength(0);
1541 rIStm.ReadUInt32( mnSvgDataArrayLength );
1542
1543 if(mnSvgDataArrayLength)
1544 {
1545 SvgDataArray aNewData(new sal_uInt8[mnSvgDataArrayLength]);
1546 OUString aPath;
1547
1548 rIStm.Read(aNewData.get(), mnSvgDataArrayLength);
1549 aPath = rIStm.ReadUniOrByteString(rIStm.GetStreamCharSet());
1550
1551 if(!rIStm.GetError())
1552 {
1553 SvgDataPtr aSvgDataPtr(
1554 new SvgData(
1555 aNewData,
1556 mnSvgDataArrayLength,
1557 OUString(aPath)));
1558
1559 rImpGraphic = aSvgDataPtr;
1560 }
1561 }
1562 }
1563
1564 rIStm.Seek(nStmPos1);
1565 }
1566 }
1567
1568 rIStm.SetEndian( nOldFormat );
1569 }
1570 }
1571 }
1572
1573 return rIStm;
1574 }
1575
1576 SvStream& WriteImpGraphic( SvStream& rOStm, const ImpGraphic& rImpGraphic )
1577 {
1578 if( !rOStm.GetError() )
1579 {
1580 if( !rImpGraphic.ImplIsSwapOut() )
1581 {
1582 if( ( rOStm.GetVersion() >= SOFFICE_FILEFORMAT_50 ) &&
1583 ( rOStm.GetCompressMode() & SvStreamCompressFlags::NATIVE ) &&
1584 rImpGraphic.mpGfxLink && rImpGraphic.mpGfxLink->IsNative() )
1585 {
1586 VersionCompat* pCompat;
1587
1588 // native format
1589 rOStm.WriteUInt32( NATIVE_FORMAT_50 );
1590
1591 // write compat info
1592 pCompat = new VersionCompat( rOStm, StreamMode::WRITE, 1 );
1593 delete pCompat;
1594
1595 rImpGraphic.mpGfxLink->SetPrefMapMode( rImpGraphic.ImplGetPrefMapMode() );
1596 rImpGraphic.mpGfxLink->SetPrefSize( rImpGraphic.ImplGetPrefSize() );
1597 WriteGfxLink( rOStm, *rImpGraphic.mpGfxLink );
1598 }
1599 else
1600 {
1601 // own format
1602 const SvStreamEndian nOldFormat = rOStm.GetEndian();
1603 rOStm.SetEndian( SvStreamEndian::LITTLE );
1604
1605 switch( rImpGraphic.ImplGetType() )
1606 {
1607 case( GRAPHIC_NONE ):
1608 case( GRAPHIC_DEFAULT ):
1609 break;
1610
1611 case GRAPHIC_BITMAP:
1612 {
1613 if(rImpGraphic.getSvgData().get())
1614 {
1615 // stream out Svg defining data (length, byte array and evtl. path)
1616 // this is used e.g. in swapping out graphic data and in transporting it over UNO API
1617 // as sequence of bytes, but AFAIK not written anywhere to any kind of file, so it should be
1618 // no problem to extend it; only used at runtime
1619 const sal_uInt32 nSvgMagic((sal_uInt32('s') << 24) | (sal_uInt32('v') << 16) | (sal_uInt32('g') << 8) | sal_uInt32('0'));
1620
1621 rOStm.WriteUInt32( nSvgMagic );
1622 rOStm.WriteUInt32( rImpGraphic.getSvgData()->getSvgDataArrayLength() );
1623 rOStm.Write(rImpGraphic.getSvgData()->getSvgDataArray().get(), rImpGraphic.getSvgData()->getSvgDataArrayLength());
1624 rOStm.WriteUniOrByteString(rImpGraphic.getSvgData()->getPath(),
1625 rOStm.GetStreamCharSet());
1626 }
1627 else if( rImpGraphic.ImplIsAnimated())
1628 {
1629 WriteAnimation( rOStm, *rImpGraphic.mpAnimation );
1630 }
1631 else
1632 {
1633 WriteDIBBitmapEx(rImpGraphic.maEx, rOStm);
1634 }
1635 }
1636 break;
1637
1638 default:
1639 {
1640 if( rImpGraphic.ImplIsSupportedGraphic() )
1641 WriteGDIMetaFile( rOStm, rImpGraphic.maMetaFile );
1642 }
1643 break;
1644 }
1645
1646 rOStm.SetEndian( nOldFormat );
1647 }
1648 }
1649 else
1650 rOStm.SetError( SVSTREAM_GENERALERROR );
1651 }
1652
1653 return rOStm;
1654 }
1655
1656 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE