vcl/source/gdi/impgraph.cxx

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