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