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