vcl/source/graphic/GraphicObject.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 <algorithm>
  23
  24 #include <o3tl/string_view.hxx>
  25 #include <osl/diagnose.h>
  26 #include <tools/fract.hxx>
  27 #include <tools/helpers.hxx>
  28 #include <utility>
  29 #include <vcl/svapp.hxx>
  30 #include <vcl/metaact.hxx>
  31 #include <vcl/GraphicObject.hxx>
  32 #include <vcl/GraphicLoader.hxx>
  33 #include <vcl/outdev.hxx>
  34
  35 #include <com/sun/star/container/XNameContainer.hpp>
  36 #include <com/sun/star/beans/XPropertySet.hpp>
  37 #include <com/sun/star/graphic/XGraphic.hpp>
  38 #include <memory>
  39
  40
  41 using namespace css;
  42 using com::sun::star::uno::Reference;
  43 using com::sun::star::uno::XInterface;
  44 using com::sun::star::uno::UNO_QUERY;
  45 using com::sun::star::uno::Sequence;
  46 using com::sun::star::container::XNameContainer;
  47 using com::sun::star::beans::XPropertySet;
  48
  49 #define WATERMARK_LUM_OFFSET        50
  50 #define WATERMARK_CON_OFFSET        -70
  51
  52 namespace vcl::graphic
  53 {
  54
  55 void SearchForGraphics(uno::Reference<uno::XInterface> const & xInterface,
  56                        std::vector<uno::Reference<css::graphic::XGraphic>> & raGraphicList)
  57 {
  58     uno::Reference<beans::XPropertySet> xPropertySet(xInterface, UNO_QUERY);
  59     if (xPropertySet.is())
  60     {
  61         if (xPropertySet->getPropertySetInfo()->hasPropertyByName(u"ImageURL"_ustr))
  62         {
  63             OUString sURL;
  64             xPropertySet->getPropertyValue(u"ImageURL"_ustr) >>= sURL;
  65             if (!sURL.isEmpty() && !GraphicObject::isGraphicObjectUniqueIdURL(sURL))
  66             {
  67                 Graphic aGraphic = vcl::graphic::loadFromURL(sURL);
  68                 if (!aGraphic.IsNone())
  69                 {
  70                     raGraphicList.push_back(aGraphic.GetXGraphic());
  71                 }
  72             }
  73         } else if (xPropertySet->getPropertySetInfo()->hasPropertyByName(u"Graphic"_ustr))
  74         {
  75             uno::Reference<css::graphic::XGraphic> xGraphic;
  76             xPropertySet->getPropertyValue(u"Graphic"_ustr) >>= xGraphic;
  77             if (xGraphic.is())
  78             {
  79                 raGraphicList.push_back(xGraphic);
  80             }
  81         }
  82     }
  83     Reference<XNameContainer> xContainer(xInterface, UNO_QUERY);
  84     if (xContainer.is())
  85     {
  86         const css::uno::Sequence<OUString> aElementNames = xContainer->getElementNames();
  87         for (OUString const & rName : aElementNames)
  88         {
  89             uno::Reference<XInterface> xInnerInterface;
  90             xContainer->getByName(rName) >>= xInnerInterface;
  91             SearchForGraphics(xInnerInterface, raGraphicList);
  92         }
  93     }
  94 }
  95
  96 } // end namespace vcl::graphic
  97
  98 namespace
  99 {
 100
 101 bool lclDrawObj(OutputDevice& rOut, const Point& rPt, const Size& rSz,
 102                 GraphicObject const & rObj, const GraphicAttr& rAttr)
 103 {
 104     Point   aPt( rPt );
 105     Size    aSz( rSz );
 106     bool    bRet = false;
 107
 108     if( ( rObj.GetType() == GraphicType::Bitmap ) || ( rObj.GetType() == GraphicType::GdiMetafile ) )
 109     {
 110         // simple output of transformed graphic
 111         const Graphic aGraphic( rObj.GetTransformedGraphic( &rAttr ) );
 112
 113         if( aGraphic.IsSupportedGraphic() )
 114         {
 115             const Degree10 nRot10 = rAttr.GetRotation() % 3600_deg10;
 116
 117             if( nRot10 )
 118             {
 119                 tools::Polygon aPoly( tools::Rectangle( aPt, aSz ) );
 120
 121                 aPoly.Rotate( aPt, nRot10 );
 122                 const tools::Rectangle aRotBoundRect( aPoly.GetBoundRect() );
 123                 aPt = aRotBoundRect.TopLeft();
 124                 aSz = aRotBoundRect.GetSize();
 125             }
 126
 127             aGraphic.Draw(rOut, aPt, aSz);
 128         }
 129
 130         bRet = true;
 131     }
 132
 133     return bRet;
 134 }
 135
 136 void lclImplAdjust( BitmapEx& rBmpEx, const GraphicAttr& rAttr, GraphicAdjustmentFlags nAdjustmentFlags )
 137 {
 138     GraphicAttr aAttr( rAttr );
 139
 140     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::DRAWMODE ) && aAttr.IsSpecialDrawMode() )
 141     {
 142         switch( aAttr.GetDrawMode() )
 143         {
 144             case GraphicDrawMode::Mono:
 145                 rBmpEx.Convert( BmpConversion::N1BitThreshold );
 146             break;
 147
 148             case GraphicDrawMode::Greys:
 149                 rBmpEx.Convert( BmpConversion::N8BitGreys );
 150             break;
 151
 152             case GraphicDrawMode::Watermark:
 153             {
 154                 aAttr.SetLuminance( aAttr.GetLuminance() + WATERMARK_LUM_OFFSET );
 155                 aAttr.SetContrast( aAttr.GetContrast() + WATERMARK_CON_OFFSET );
 156             }
 157             break;
 158
 159             default:
 160             break;
 161         }
 162     }
 163
 164     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::COLORS ) && aAttr.IsAdjusted() )
 165     {
 166         rBmpEx.Adjust( aAttr.GetLuminance(), aAttr.GetContrast(),
 167                        aAttr.GetChannelR(), aAttr.GetChannelG(), aAttr.GetChannelB(),
 168                        aAttr.GetGamma(), aAttr.IsInvert() );
 169     }
 170
 171     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::MIRROR ) && aAttr.IsMirrored() )
 172     {
 173         rBmpEx.Mirror( aAttr.GetMirrorFlags() );
 174     }
 175
 176     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::ROTATE ) && aAttr.IsRotated() )
 177     {
 178         rBmpEx.Rotate( aAttr.GetRotation(), COL_TRANSPARENT );
 179     }
 180
 181     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::TRANSPARENCY ) && aAttr.IsTransparent() )
 182     {
 183         rBmpEx.AdjustTransparency(255 - aAttr.GetAlpha());
 184     }
 185 }
 186
 187 void lclImplAdjust( GDIMetaFile& rMtf, const GraphicAttr& rAttr, GraphicAdjustmentFlags nAdjustmentFlags )
 188 {
 189     GraphicAttr aAttr( rAttr );
 190
 191     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::DRAWMODE ) && aAttr.IsSpecialDrawMode() )
 192     {
 193         switch( aAttr.GetDrawMode() )
 194         {
 195             case GraphicDrawMode::Mono:
 196                 rMtf.Convert( MtfConversion::N1BitThreshold );
 197             break;
 198
 199             case GraphicDrawMode::Greys:
 200                 rMtf.Convert( MtfConversion::N8BitGreys );
 201             break;
 202
 203             case GraphicDrawMode::Watermark:
 204             {
 205                 aAttr.SetLuminance( aAttr.GetLuminance() + WATERMARK_LUM_OFFSET );
 206                 aAttr.SetContrast( aAttr.GetContrast() + WATERMARK_CON_OFFSET );
 207             }
 208             break;
 209
 210             default:
 211             break;
 212         }
 213     }
 214
 215     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::COLORS ) && aAttr.IsAdjusted() )
 216     {
 217         rMtf.Adjust( aAttr.GetLuminance(), aAttr.GetContrast(),
 218                      aAttr.GetChannelR(), aAttr.GetChannelG(), aAttr.GetChannelB(),
 219                      aAttr.GetGamma(), aAttr.IsInvert() );
 220     }
 221
 222     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::MIRROR ) && aAttr.IsMirrored() )
 223     {
 224         rMtf.Mirror( aAttr.GetMirrorFlags() );
 225     }
 226
 227     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::ROTATE ) && aAttr.IsRotated() )
 228     {
 229         rMtf.Rotate( aAttr.GetRotation() );
 230     }
 231
 232     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::TRANSPARENCY ) && aAttr.IsTransparent() )
 233     {
 234         OSL_FAIL( "Missing implementation: Mtf-Transparency" );
 235     }
 236 }
 237
 238 void lclImplAdjust( Animation& rAnimation, const GraphicAttr& rAttr, GraphicAdjustmentFlags nAdjustmentFlags )
 239 {
 240     GraphicAttr aAttr( rAttr );
 241
 242     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::DRAWMODE ) && aAttr.IsSpecialDrawMode() )
 243     {
 244         switch( aAttr.GetDrawMode() )
 245         {
 246             case GraphicDrawMode::Mono:
 247                 rAnimation.Convert( BmpConversion::N1BitThreshold );
 248             break;
 249
 250             case GraphicDrawMode::Greys:
 251                 rAnimation.Convert( BmpConversion::N8BitGreys );
 252             break;
 253
 254             case GraphicDrawMode::Watermark:
 255             {
 256                 aAttr.SetLuminance( aAttr.GetLuminance() + WATERMARK_LUM_OFFSET );
 257                 aAttr.SetContrast( aAttr.GetContrast() + WATERMARK_CON_OFFSET );
 258             }
 259             break;
 260
 261             default:
 262             break;
 263         }
 264     }
 265
 266     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::COLORS ) && aAttr.IsAdjusted() )
 267     {
 268         rAnimation.Adjust( aAttr.GetLuminance(), aAttr.GetContrast(),
 269                            aAttr.GetChannelR(), aAttr.GetChannelG(), aAttr.GetChannelB(),
 270                            aAttr.GetGamma(), aAttr.IsInvert() );
 271     }
 272
 273     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::MIRROR ) && aAttr.IsMirrored() )
 274     {
 275         rAnimation.Mirror( aAttr.GetMirrorFlags() );
 276     }
 277
 278     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::ROTATE ) && aAttr.IsRotated() )
 279     {
 280         OSL_FAIL( "Missing implementation: Animation-Rotation" );
 281     }
 282
 283     if( ( nAdjustmentFlags & GraphicAdjustmentFlags::TRANSPARENCY ) && aAttr.IsTransparent() )
 284     {
 285         OSL_FAIL( "Missing implementation: Animation-Transparency" );
 286     }
 287 }
 288
 289 } // end anonymous namespace
 290
 291 struct GrfSimpleCacheObj
 292 {
 293     Graphic     maGraphic;
 294     GraphicAttr maAttr;
 295
 296                 GrfSimpleCacheObj( Graphic aGraphic, const GraphicAttr& rAttr ) :
 297                     maGraphic(std::move( aGraphic )), maAttr( rAttr ) {}
 298 };
 299
 300 GraphicObject::GraphicObject()
 301 {
 302 }
 303
 304 GraphicObject::GraphicObject(Graphic aGraphic)
 305     : maGraphic(std::move(aGraphic))
 306 {
 307 }
 308
 309 GraphicObject::GraphicObject(const GraphicObject& rGraphicObj)
 310     : maGraphic(rGraphicObj.GetGraphic())
 311     , maAttr(rGraphicObj.maAttr)
 312     , maUserData(rGraphicObj.maUserData)
 313 {
 314 }
 315
 316 GraphicObject::~GraphicObject()
 317 {
 318 }
 319
 320 GraphicType GraphicObject::GetType() const
 321 {
 322     return maGraphic.GetType();
 323 }
 324
 325 Size GraphicObject::GetPrefSize() const
 326 {
 327     return maGraphic.GetPrefSize();
 328 }
 329
 330 MapMode GraphicObject::GetPrefMapMode() const
 331 {
 332     return maGraphic.GetPrefMapMode();
 333 }
 334
 335 bool GraphicObject::IsTransparent() const
 336 {
 337     return maGraphic.IsTransparent();
 338 }
 339
 340 bool GraphicObject::IsAnimated() const
 341 {
 342     return maGraphic.IsAnimated();
 343 }
 344
 345 bool GraphicObject::IsEPS() const
 346 {
 347     return maGraphic.IsEPS();
 348 }
 349
 350 bool GraphicObject::ImplGetCropParams(const OutputDevice& rOut, Point& rPt, Size& rSz, const GraphicAttr* pAttr,
 351                                       tools::PolyPolygon& rClipPolyPoly, bool& bRectClipRegion) const
 352 {
 353     bool bRet = false;
 354
 355     if( GetType() != GraphicType::NONE )
 356     {
 357         tools::Polygon aClipPoly( tools::Rectangle( rPt, rSz ) );
 358         const Degree10  nRot10 = pAttr->GetRotation() % 3600_deg10;
 359         const Point     aOldOrigin( rPt );
 360         const MapMode   aMap100( MapUnit::Map100thMM );
 361         Size            aSize100;
 362         tools::Long            nTotalWidth, nTotalHeight;
 363
 364         if( nRot10 )
 365         {
 366             aClipPoly.Rotate( rPt, nRot10 );
 367             bRectClipRegion = false;
 368         }
 369         else
 370             bRectClipRegion = true;
 371
 372         rClipPolyPoly = tools::PolyPolygon(aClipPoly);
 373
 374         if (maGraphic.GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel)
 375             aSize100 = Application::GetDefaultDevice()->PixelToLogic( maGraphic.GetPrefSize(), aMap100 );
 376         else
 377         {
 378             MapMode m(maGraphic.GetPrefMapMode());
 379             aSize100 = rOut.LogicToLogic( maGraphic.GetPrefSize(), &m, &aMap100 );
 380         }
 381
 382         nTotalWidth = aSize100.Width() - pAttr->GetLeftCrop() - pAttr->GetRightCrop();
 383         nTotalHeight = aSize100.Height() - pAttr->GetTopCrop() - pAttr->GetBottomCrop();
 384
 385         if( !aSize100.IsEmpty() && nTotalWidth > 0 && nTotalHeight > 0 )
 386         {
 387             double fScale = static_cast<double>(aSize100.Width()) / nTotalWidth;
 388             const tools::Long nNewLeft = basegfx::fround<tools::Long>( ( ( pAttr->GetMirrorFlags() & BmpMirrorFlags::Horizontal ) ? pAttr->GetRightCrop() : pAttr->GetLeftCrop() ) * -fScale );
 389             const tools::Long nNewRight = nNewLeft + basegfx::fround<tools::Long>( aSize100.Width() * fScale ) - 1;
 390
 391             fScale = static_cast<double>(rSz.Width()) / aSize100.Width();
 392             rPt.AdjustX(basegfx::fround<tools::Long>(nNewLeft * fScale));
 393             rSz.setWidth(basegfx::fround<tools::Long>((nNewRight - nNewLeft + 1) * fScale));
 394
 395             fScale = static_cast<double>(aSize100.Height()) / nTotalHeight;
 396             const tools::Long nNewTop = basegfx::fround<tools::Long>( ( ( pAttr->GetMirrorFlags() & BmpMirrorFlags::Vertical ) ? pAttr->GetBottomCrop() : pAttr->GetTopCrop() ) * -fScale );
 397             const tools::Long nNewBottom = nNewTop + basegfx::fround<tools::Long>( aSize100.Height() * fScale ) - 1;
 398
 399             fScale = static_cast<double>(rSz.Height()) / aSize100.Height();
 400             rPt.AdjustY(basegfx::fround<tools::Long>(nNewTop * fScale));
 401             rSz.setHeight(basegfx::fround<tools::Long>((nNewBottom - nNewTop + 1) * fScale));
 402
 403             if( nRot10 )
 404             {
 405                 tools::Polygon aOriginPoly( 1 );
 406
 407                 aOriginPoly[ 0 ] = rPt;
 408                 aOriginPoly.Rotate( aOldOrigin, nRot10 );
 409                 rPt = aOriginPoly[ 0 ];
 410             }
 411
 412             bRet = true;
 413         }
 414     }
 415
 416     return bRet;
 417 }
 418
 419 GraphicObject& GraphicObject::operator=( const GraphicObject& rGraphicObj )
 420 {
 421     if( &rGraphicObj != this )
 422     {
 423         mxSimpleCache.reset();
 424         maGraphic = rGraphicObj.GetGraphic();
 425         maAttr = rGraphicObj.maAttr;
 426         maUserData = rGraphicObj.maUserData;
 427     }
 428
 429     return *this;
 430 }
 431
 432 bool GraphicObject::operator==( const GraphicObject& rGraphicObj ) const
 433 {
 434     return rGraphicObj.maGraphic == maGraphic
 435         && rGraphicObj.maAttr == maAttr;
 436 }
 437
 438 OString GraphicObject::GetUniqueID() const
 439 {
 440     return GetGraphic().getUniqueID();
 441 }
 442
 443 void GraphicObject::SetAttr( const GraphicAttr& rAttr )
 444 {
 445     maAttr = rAttr;
 446
 447     if (mxSimpleCache && (mxSimpleCache->maAttr != rAttr))
 448         mxSimpleCache.reset();
 449 }
 450
 451 void GraphicObject::SetUserData()
 452 {
 453     maUserData.clear();
 454 }
 455
 456 void GraphicObject::SetUserData( const OUString& rUserData )
 457 {
 458     maUserData = rUserData;
 459 }
 460
 461 bool GraphicObject::Draw(OutputDevice& rOut, const Point& rPt, const Size& rSz,
 462                          const GraphicAttr* pAttr) const
 463 {
 464     GraphicAttr         aAttr( pAttr ? *pAttr : GetAttr() );
 465     Point               aPt( rPt );
 466     Size                aSz( rSz );
 467     const DrawModeFlags nOldDrawMode = rOut.GetDrawMode();
 468     bool                bCropped = aAttr.IsCropped();
 469     bool bRet;
 470
 471     rOut.SetDrawMode(nOldDrawMode & ~DrawModeFlags( DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient ));
 472
 473     // mirrored horizontally
 474     if( aSz.Width() < 0 )
 475     {
 476         aPt.AdjustX(aSz.Width() + 1 );
 477         aSz.setWidth( -aSz.Width() );
 478         aAttr.SetMirrorFlags( aAttr.GetMirrorFlags() ^ BmpMirrorFlags::Horizontal );
 479     }
 480
 481     // mirrored vertically
 482     if( aSz.Height() < 0 )
 483     {
 484         aPt.AdjustY(aSz.Height() + 1 );
 485         aSz.setHeight( -aSz.Height() );
 486         aAttr.SetMirrorFlags( aAttr.GetMirrorFlags() ^ BmpMirrorFlags::Vertical );
 487     }
 488
 489     if( bCropped )
 490     {
 491         tools::PolyPolygon aClipPolyPoly;
 492         bool        bRectClip;
 493         const bool  bCrop = ImplGetCropParams(rOut, aPt, aSz, &aAttr, aClipPolyPoly, bRectClip);
 494
 495         rOut.Push(vcl::PushFlags::CLIPREGION);
 496
 497         if( bCrop )
 498         {
 499             if( bRectClip )
 500             {
 501                 // #i29534# Store crop rect for later forwarding to
 502                 // PDF writer
 503                 tools::Rectangle aCropRect = aClipPolyPoly.GetBoundRect();
 504                 rOut.IntersectClipRegion(aCropRect);
 505             }
 506             else
 507             {
 508                 rOut.IntersectClipRegion(vcl::Region(aClipPolyPoly));
 509             }
 510         }
 511     }
 512
 513     bRet = lclDrawObj(rOut, aPt, aSz, *this, aAttr);
 514
 515     if( bCropped )
 516         rOut.Pop();
 517
 518     rOut.SetDrawMode( nOldDrawMode );
 519
 520     return bRet;
 521 }
 522
 523 void GraphicObject::DrawTiled(OutputDevice& rOut, const tools::Rectangle& rArea, const Size& rSize,
 524                               const Size& rOffset, int nTileCacheSize1D)
 525 {
 526     if (rSize.IsEmpty())
 527         return;
 528
 529     const MapMode   aOutMapMode(rOut.GetMapMode());
 530     // #106258# Clamp size to 1 for zero values. This is okay, since
 531     // logical size of zero is handled above already
 532     const Size      aOutTileSize( ::std::max( tools::Long(1), rOut.LogicToPixel( rSize, aOutMapMode ).Width() ),
 533                                   ::std::max( tools::Long(1), rOut.LogicToPixel( rSize, aOutMapMode ).Height() ) );
 534
 535     //#i69780 clip final tile size to a sane max size
 536     while ((static_cast<sal_Int64>(rSize.Width()) * nTileCacheSize1D) > SAL_MAX_UINT16)
 537         nTileCacheSize1D /= 2;
 538     while ((static_cast<sal_Int64>(rSize.Height()) * nTileCacheSize1D) > SAL_MAX_UINT16)
 539         nTileCacheSize1D /= 2;
 540
 541     ImplDrawTiled(rOut, rArea, aOutTileSize, rOffset, nullptr, nTileCacheSize1D);
 542 }
 543
 544 bool GraphicObject::StartAnimation(OutputDevice& rOut, const Point& rPt, const Size& rSz,
 545                                    tools::Long nRendererId,
 546                                    OutputDevice* pFirstFrameOutDev)
 547 {
 548     bool bRet = false;
 549
 550     GetGraphic();
 551
 552     const GraphicAttr aAttr( GetAttr() );
 553
 554     if (IsAnimated())
 555     {
 556         Point   aPt( rPt );
 557         Size    aSz( rSz );
 558         bool    bCropped = aAttr.IsCropped();
 559
 560         if( bCropped )
 561         {
 562             tools::PolyPolygon aClipPolyPoly;
 563             bool        bRectClip;
 564             const bool  bCrop = ImplGetCropParams(rOut, aPt, aSz, &aAttr, aClipPolyPoly, bRectClip);
 565
 566             rOut.Push(vcl::PushFlags::CLIPREGION);
 567
 568             if( bCrop )
 569             {
 570                 if( bRectClip )
 571                     rOut.IntersectClipRegion(aClipPolyPoly.GetBoundRect());
 572                 else
 573                     rOut.IntersectClipRegion(vcl::Region(aClipPolyPoly));
 574             }
 575         }
 576
 577         if (!mxSimpleCache || (mxSimpleCache->maAttr != aAttr) || pFirstFrameOutDev)
 578         {
 579             mxSimpleCache.reset(new GrfSimpleCacheObj(GetTransformedGraphic(&aAttr), aAttr));
 580             mxSimpleCache->maGraphic.SetAnimationNotifyHdl(GetGraphic().GetAnimationNotifyHdl());
 581         }
 582
 583         mxSimpleCache->maGraphic.StartAnimation(rOut, aPt, aSz, nRendererId, pFirstFrameOutDev);
 584
 585         if( bCropped )
 586             rOut.Pop();
 587
 588         bRet = true;
 589     }
 590     else
 591         bRet = Draw(rOut, rPt, rSz, &aAttr);
 592
 593     return bRet;
 594 }
 595
 596 void GraphicObject::StopAnimation( const OutputDevice* pOut, tools::Long nRendererId )
 597 {
 598     if (mxSimpleCache)
 599         mxSimpleCache->maGraphic.StopAnimation(pOut, nRendererId);
 600 }
 601
 602 const Graphic& GraphicObject::GetGraphic() const
 603 {
 604     return maGraphic;
 605 }
 606
 607 void GraphicObject::SetGraphic( const Graphic& rGraphic)
 608 {
 609     maGraphic = rGraphic;
 610 }
 611
 612 Graphic GraphicObject::GetTransformedGraphic( const Size& rDestSize, const MapMode& rDestMap, const GraphicAttr& rAttr ) const
 613 {
 614     // #104550# Extracted from svx/source/svdraw/svdograf.cxx
 615     Graphic             aTransGraphic( GetGraphic() );
 616     const GraphicType   eType = GetType();
 617     const Size          aSrcSize( aTransGraphic.GetPrefSize() );
 618
 619     // #104115# Convert the crop margins to graphic object mapmode
 620     const MapMode aMapGraph( aTransGraphic.GetPrefMapMode() );
 621     const MapMode aMap100( MapUnit::Map100thMM );
 622
 623     Size aCropLeftTop;
 624     Size aCropRightBottom;
 625
 626     if( GraphicType::GdiMetafile == eType )
 627     {
 628         GDIMetaFile aMtf( aTransGraphic.GetGDIMetaFile() );
 629
 630         if (aMapGraph.GetMapUnit() == MapUnit::MapPixel)
 631         {
 632             // crops are in 1/100th mm -> to aMapGraph -> to MapUnit::MapPixel
 633             aCropLeftTop = Application::GetDefaultDevice()->LogicToPixel(
 634                 Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 635                 aMap100);
 636             aCropRightBottom = Application::GetDefaultDevice()->LogicToPixel(
 637                 Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 638                 aMap100);
 639         }
 640         else
 641         {
 642             // crops are in GraphicObject units -> to aMapGraph
 643             aCropLeftTop = OutputDevice::LogicToLogic(
 644                 Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 645                 aMap100,
 646                 aMapGraph);
 647             aCropRightBottom = OutputDevice::LogicToLogic(
 648                 Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 649                 aMap100,
 650                 aMapGraph);
 651         }
 652
 653         // #104115# If the metafile is cropped, give it a special
 654         // treatment: clip against the remaining area, scale up such
 655         // that this area later fills the desired size, and move the
 656         // origin to the upper left edge of that area.
 657         if( rAttr.IsCropped() )
 658         {
 659             const MapMode aMtfMapMode( aMtf.GetPrefMapMode() );
 660
 661             tools::Rectangle aClipRect( aMtfMapMode.GetOrigin().X() + aCropLeftTop.Width(),
 662                                  aMtfMapMode.GetOrigin().Y() + aCropLeftTop.Height(),
 663                                  aMtfMapMode.GetOrigin().X() + aSrcSize.Width() - aCropRightBottom.Width(),
 664                                  aMtfMapMode.GetOrigin().Y() + aSrcSize.Height() - aCropRightBottom.Height() );
 665
 666             // #104115# To correctly crop rotated metafiles, clip by view rectangle
 667             aMtf.AddAction( new MetaISectRectClipRegionAction( aClipRect ), 0 );
 668
 669             // #104115# To crop the metafile, scale larger than the output rectangle
 670             aMtf.Scale( static_cast<double>(rDestSize.Width()) / (aSrcSize.Width() - aCropLeftTop.Width() - aCropRightBottom.Width()),
 671                         static_cast<double>(rDestSize.Height()) / (aSrcSize.Height() - aCropLeftTop.Height() - aCropRightBottom.Height()) );
 672
 673             // #104115# Adapt the pref size by hand (scale changes it
 674             // proportionally, but we want it to be smaller than the
 675             // former size, to crop the excess out)
 676             aMtf.SetPrefSize( Size( static_cast<tools::Long>(static_cast<double>(rDestSize.Width()) *  (1.0 + (aCropLeftTop.Width() + aCropRightBottom.Width()) / aSrcSize.Width())  + .5),
 677                                     static_cast<tools::Long>(static_cast<double>(rDestSize.Height()) * (1.0 + (aCropLeftTop.Height() + aCropRightBottom.Height()) / aSrcSize.Height()) + .5) ) );
 678
 679             // #104115# Adapt the origin of the new mapmode, such that it
 680             // is shifted to the place where the cropped output starts
 681             Point aNewOrigin( static_cast<tools::Long>(static_cast<double>(aMtfMapMode.GetOrigin().X()) + rDestSize.Width() * aCropLeftTop.Width() / (aSrcSize.Width() - aCropLeftTop.Width() - aCropRightBottom.Width()) + .5),
 682                               static_cast<tools::Long>(static_cast<double>(aMtfMapMode.GetOrigin().Y()) + rDestSize.Height() * aCropLeftTop.Height() / (aSrcSize.Height() - aCropLeftTop.Height() - aCropRightBottom.Height()) + .5) );
 683             MapMode aNewMap( rDestMap );
 684             aNewMap.SetOrigin( OutputDevice::LogicToLogic(aNewOrigin, aMtfMapMode, rDestMap) );
 685             aMtf.SetPrefMapMode( aNewMap );
 686         }
 687         else
 688         {
 689             aMtf.Scale( Fraction( rDestSize.Width(), aSrcSize.Width() ), Fraction( rDestSize.Height(), aSrcSize.Height() ) );
 690             aMtf.SetPrefMapMode( rDestMap );
 691         }
 692
 693         aTransGraphic = aMtf;
 694     }
 695     else if( GraphicType::Bitmap == eType )
 696     {
 697         BitmapEx aBitmapEx( aTransGraphic.GetBitmapEx() );
 698         tools::Rectangle aCropRect;
 699
 700         // convert crops to pixel
 701         if(rAttr.IsCropped())
 702         {
 703             if (aMapGraph.GetMapUnit() == MapUnit::MapPixel)
 704             {
 705                 // crops are in 1/100th mm -> to MapUnit::MapPixel
 706                 aCropLeftTop = Application::GetDefaultDevice()->LogicToPixel(
 707                     Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 708                     aMap100);
 709                 aCropRightBottom = Application::GetDefaultDevice()->LogicToPixel(
 710                     Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 711                     aMap100);
 712             }
 713             else
 714             {
 715                 // crops are in GraphicObject units -> to MapUnit::MapPixel
 716                 aCropLeftTop = Application::GetDefaultDevice()->LogicToPixel(
 717                     Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 718                     aMapGraph);
 719                 aCropRightBottom = Application::GetDefaultDevice()->LogicToPixel(
 720                     Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 721                     aMapGraph);
 722             }
 723
 724             // convert from prefmapmode to pixel
 725             Size aSrcSizePixel(
 726                 Application::GetDefaultDevice()->LogicToPixel(
 727                     aSrcSize,
 728                     aMapGraph));
 729
 730             if(rAttr.IsCropped()
 731                 && (aSrcSizePixel.Width() != aBitmapEx.GetSizePixel().Width() || aSrcSizePixel.Height() != aBitmapEx.GetSizePixel().Height())
 732                 && aSrcSizePixel.Width())
 733             {
 734                 // the size in pixels calculated from Graphic's internal MapMode (aTransGraphic.GetPrefMapMode())
 735                 // and its internal size (aTransGraphic.GetPrefSize()) is different from its real pixel size.
 736                 // This can be interpreted as this values to be set wrong, but needs to be corrected since e.g.
 737                 // existing cropping is calculated based on this logic values already.
 738                 // aBitmapEx.Scale(aSrcSizePixel);
 739
 740                 // another possibility is to adapt the values created so far with a factor; this
 741                 // will keep the original Bitmap untouched and thus quality will not change
 742                 // caution: convert to double first, else pretty big errors may occur
 743                 const double fFactorX(static_cast<double>(aBitmapEx.GetSizePixel().Width()) / aSrcSizePixel.Width());
 744                 const double fFactorY(static_cast<double>(aBitmapEx.GetSizePixel().Height()) / aSrcSizePixel.Height());
 745
 746                 aCropLeftTop.setWidth( basegfx::fround<tools::Long>(aCropLeftTop.Width() * fFactorX) );
 747                 aCropLeftTop.setHeight( basegfx::fround<tools::Long>(aCropLeftTop.Height() * fFactorY) );
 748                 aCropRightBottom.setWidth( basegfx::fround<tools::Long>(aCropRightBottom.Width() * fFactorX) );
 749                 aCropRightBottom.setHeight( basegfx::fround<tools::Long>(aCropRightBottom.Height() * fFactorY) );
 750
 751                 aSrcSizePixel = aBitmapEx.GetSizePixel();
 752             }
 753
 754             // setup crop rectangle in pixel
 755             aCropRect = tools::Rectangle( aCropLeftTop.Width(), aCropLeftTop.Height(),
 756                                  aSrcSizePixel.Width() - aCropRightBottom.Width(),
 757                                  aSrcSizePixel.Height() - aCropRightBottom.Height() );
 758         }
 759
 760         // #105641# Also crop animations
 761         if( aTransGraphic.IsAnimated() )
 762         {
 763             Animation aAnim( aTransGraphic.GetAnimation() );
 764
 765             for( size_t nFrame=0; nFrame<aAnim.Count(); ++nFrame )
 766             {
 767                 AnimationFrame aAnimationFrame( aAnim.Get( nFrame ) );
 768
 769                 if( !aCropRect.Contains( tools::Rectangle(aAnimationFrame.maPositionPixel, aAnimationFrame.maSizePixel) ) )
 770                 {
 771                     // setup actual cropping (relative to frame position)
 772                     tools::Rectangle aCropRectRel( aCropRect );
 773                     aCropRectRel.Move( -aAnimationFrame.maPositionPixel.X(),
 774                                        -aAnimationFrame.maPositionPixel.Y() );
 775
 776                     // cropping affects this frame, apply it then
 777                     // do _not_ apply enlargement, this is done below
 778                     ImplTransformBitmap( aAnimationFrame.maBitmapEx, rAttr, Size(), Size(),
 779                                          aCropRectRel, rDestSize, false );
 780
 781                     aAnim.Replace( aAnimationFrame, nFrame );
 782                 }
 783                 // else: bitmap completely within crop area,
 784                 // i.e. nothing is cropped away
 785             }
 786
 787             // now, apply enlargement (if any) through global animation size
 788             if( aCropLeftTop.Width() < 0 ||
 789                 aCropLeftTop.Height() < 0 ||
 790                 aCropRightBottom.Width() < 0 ||
 791                 aCropRightBottom.Height() < 0 )
 792             {
 793                 Size aNewSize( aAnim.GetDisplaySizePixel() );
 794                 aNewSize.AdjustWidth(aCropRightBottom.Width() < 0 ? -aCropRightBottom.Width() : 0 );
 795                 aNewSize.AdjustWidth(aCropLeftTop.Width() < 0 ? -aCropLeftTop.Width() : 0 );
 796                 aNewSize.AdjustHeight(aCropRightBottom.Height() < 0 ? -aCropRightBottom.Height() : 0 );
 797                 aNewSize.AdjustHeight(aCropLeftTop.Height() < 0 ? -aCropLeftTop.Height() : 0 );
 798                 aAnim.SetDisplaySizePixel( aNewSize );
 799             }
 800
 801             // if topleft has changed, we must move all frames to the
 802             // right and bottom, resp.
 803             if( aCropLeftTop.Width() < 0 ||
 804                 aCropLeftTop.Height() < 0 )
 805             {
 806                 Point aPosOffset( aCropLeftTop.Width() < 0 ? -aCropLeftTop.Width() : 0,
 807                                   aCropLeftTop.Height() < 0 ? -aCropLeftTop.Height() : 0 );
 808
 809                 for( size_t nFrame=0; nFrame<aAnim.Count(); ++nFrame )
 810                 {
 811                     AnimationFrame aAnimationFrame( aAnim.Get( nFrame ) );
 812
 813                     aAnimationFrame.maPositionPixel += aPosOffset;
 814
 815                     aAnim.Replace( aAnimationFrame, nFrame );
 816                 }
 817             }
 818
 819             aTransGraphic = aAnim;
 820         }
 821         else
 822         {
 823             ImplTransformBitmap( aBitmapEx, rAttr, aCropLeftTop, aCropRightBottom,
 824                                  aCropRect, rDestSize, true );
 825
 826             aTransGraphic = aBitmapEx;
 827         }
 828
 829         aTransGraphic.SetPrefSize( rDestSize );
 830         aTransGraphic.SetPrefMapMode( rDestMap );
 831     }
 832
 833     GraphicObject aGrfObj( aTransGraphic );
 834     aTransGraphic = aGrfObj.GetTransformedGraphic( &rAttr );
 835
 836     return aTransGraphic;
 837 }
 838
 839 Graphic GraphicObject::GetTransformedGraphic( const GraphicAttr* pAttr ) const
 840 {
 841     GetGraphic();
 842
 843     Graphic     aGraphic;
 844     GraphicAttr aAttr( pAttr ? *pAttr : GetAttr() );
 845
 846     if (maGraphic.IsSupportedGraphic())
 847     {
 848         if( aAttr.IsSpecialDrawMode() || aAttr.IsAdjusted() || aAttr.IsMirrored() || aAttr.IsRotated() || aAttr.IsTransparent() )
 849         {
 850             if( GetType() == GraphicType::Bitmap )
 851             {
 852                 if( IsAnimated() )
 853                 {
 854                     Animation aAnimation( maGraphic.GetAnimation() );
 855                     lclImplAdjust( aAnimation, aAttr, GraphicAdjustmentFlags::ALL );
 856                     aAnimation.SetLoopCount(maGraphic.GetAnimationLoopCount());
 857                     aGraphic = aAnimation;
 858                 }
 859                 else
 860                 {
 861                     BitmapEx aBmpEx( maGraphic.GetBitmapEx() );
 862                     lclImplAdjust( aBmpEx, aAttr, GraphicAdjustmentFlags::ALL );
 863                     aGraphic = aBmpEx;
 864                 }
 865             }
 866             else
 867             {
 868                 GDIMetaFile aMtf( maGraphic.GetGDIMetaFile() );
 869                 lclImplAdjust( aMtf, aAttr, GraphicAdjustmentFlags::ALL );
 870                 aGraphic = aMtf;
 871             }
 872         }
 873         else
 874         {
 875             if( ( GetType() == GraphicType::Bitmap ) && IsAnimated() )
 876             {
 877                 Animation aAnimation( maGraphic.GetAnimation() );
 878                 aAnimation.SetLoopCount(maGraphic.GetAnimationLoopCount());
 879                 aGraphic = aAnimation;
 880             }
 881             else
 882                 aGraphic = maGraphic;
 883         }
 884     }
 885
 886     return aGraphic;
 887 }
 888
 889 bool GraphicObject::isGraphicObjectUniqueIdURL(std::u16string_view rURL)
 890 {
 891     return o3tl::starts_with(rURL, u"vnd.sun.star.GraphicObject:");
 892 }
 893
 894 // calculate scalings between real image size and logic object size. This
 895 // is necessary since the crop values are relative to original bitmap size
 896 basegfx::B2DVector GraphicObject::calculateCropScaling(
 897     double fWidth,
 898     double fHeight,
 899     double fLeftCrop,
 900     double fTopCrop,
 901     double fRightCrop,
 902     double fBottomCrop) const
 903 {
 904     const MapMode aMapMode100thmm(MapUnit::Map100thMM);
 905     Size aBitmapSize(GetPrefSize());
 906     double fFactorX(1.0);
 907     double fFactorY(1.0);
 908
 909     if(MapUnit::MapPixel == GetPrefMapMode().GetMapUnit())
 910     {
 911         aBitmapSize = Application::GetDefaultDevice()->PixelToLogic(aBitmapSize, aMapMode100thmm);
 912     }
 913     else
 914     {
 915         aBitmapSize = OutputDevice::LogicToLogic(aBitmapSize, GetPrefMapMode(), aMapMode100thmm);
 916     }
 917
 918     const double fDivX(aBitmapSize.Width() - fLeftCrop - fRightCrop);
 919     const double fDivY(aBitmapSize.Height() - fTopCrop - fBottomCrop);
 920
 921     if(!basegfx::fTools::equalZero(fDivX))
 922     {
 923         fFactorX = fabs(fWidth) / fDivX;
 924     }
 925
 926     if(!basegfx::fTools::equalZero(fDivY))
 927     {
 928         fFactorY = fabs(fHeight) / fDivY;
 929     }
 930
 931     return basegfx::B2DVector(fFactorX,fFactorY);
 932 }
 933
 934
 935 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */