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