vcl/source/gdi/pdfextoutdevdata.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 <vcl/pdfextoutdevdata.hxx>
  21 #include <vcl/graph.hxx>
  22 #include <vcl/outdev.hxx>
  23 #include <vcl/gfxlink.hxx>
  24 #include "vcl/dllapi.h"
  25 #include "basegfx/polygon/b2dpolygon.hxx"
  26 #include "basegfx/polygon/b2dpolygontools.hxx"
  27
  28 #include <set>
  29 #include <memory>
  30 #include <map>
  31
  32 namespace vcl
  33 {
  34 struct PDFExtOutDevDataSync
  35 {
  36     enum Action{    CreateNamedDest,
  37                     CreateDest,
  38                     CreateLink,
  39                     CreateScreen,
  40                     SetLinkDest,
  41                     SetLinkURL,
  42                     SetScreenURL,
  43                     SetScreenStream,
  44                     RegisterDest,
  45                     CreateOutlineItem,
  46                     CreateNote,
  47                     SetPageTransition,
  48
  49                     BeginStructureElement,
  50                     EndStructureElement,
  51                     SetCurrentStructureElement,
  52                     SetStructureAttribute,
  53                     SetStructureAttributeNumerical,
  54                     SetStructureBoundingBox,
  55                     SetActualText,
  56                     SetAlternateText,
  57                     CreateControl,
  58                     BeginGroup,
  59                     EndGroupGfxLink
  60     };
  61
  62     sal_uInt32  nIdx;
  63     Action      eAct;
  64 };
  65
  66 struct PDFLinkDestination
  67 {
  68     tools::Rectangle               mRect;
  69     MapMode                 mMapMode;
  70     sal_Int32               mPageNr;
  71     PDFWriter::DestAreaType mAreaType;
  72 };
  73
  74 struct GlobalSyncData
  75 {
  76     std::deque< PDFExtOutDevDataSync::Action >  mActions;
  77     std::deque< MapMode >                       mParaMapModes;
  78     std::deque< tools::Rectangle >                     mParaRects;
  79     std::deque< sal_Int32 >                     mParaInts;
  80     std::deque< sal_uInt32 >                    mParauInts;
  81     std::deque< OUString >                 mParaOUStrings;
  82     std::deque< PDFWriter::DestAreaType >       mParaDestAreaTypes;
  83     std::deque< PDFNote >                       mParaPDFNotes;
  84     std::deque< PDFWriter::PageTransition >     mParaPageTransitions;
  85     ::std::map< sal_Int32, PDFLinkDestination > mFutureDestinations;
  86
  87     sal_Int32 GetMappedId();
  88     sal_Int32 GetMappedStructId( sal_Int32 );
  89
  90     sal_Int32                   mCurId;
  91     std::vector< sal_Int32 >    mParaIds;
  92     std::vector< sal_Int32 >    mStructIdMap;
  93
  94     sal_Int32                   mCurrentStructElement;
  95     std::vector< sal_Int32 >    mStructParents;
  96     GlobalSyncData() :
  97             mCurId ( 0 ),
  98             mCurrentStructElement( 0 )
  99     {
 100         mStructParents.push_back( 0 );
 101         mStructIdMap.push_back( 0 );
 102     }
 103     void PlayGlobalActions( PDFWriter& rWriter );
 104 };
 105
 106 sal_Int32 GlobalSyncData::GetMappedId()
 107 {
 108     sal_Int32 nLinkId = mParaInts.front();
 109     mParaInts.pop_front();
 110
 111     /*  negative values are intentionally passed as invalid IDs
 112      *  e.g. to create a new top level outline item
 113      */
 114     if( nLinkId >= 0 )
 115     {
 116         if ( (sal_uInt32)nLinkId < mParaIds.size() )
 117             nLinkId = mParaIds[ nLinkId ];
 118         else
 119             nLinkId = -1;
 120
 121         SAL_WARN_IF( nLinkId < 0, "vcl", "unmapped id in GlobalSyncData" );
 122     }
 123
 124     return nLinkId;
 125 }
 126
 127 sal_Int32 GlobalSyncData::GetMappedStructId( sal_Int32 nStructId )
 128 {
 129     if ( (sal_uInt32)nStructId < mStructIdMap.size() )
 130         nStructId = mStructIdMap[ nStructId ];
 131     else
 132         nStructId = -1;
 133
 134     SAL_WARN_IF( nStructId < 0, "vcl", "unmapped structure id in GlobalSyncData" );
 135
 136     return nStructId;
 137 }
 138
 139 void GlobalSyncData::PlayGlobalActions( PDFWriter& rWriter )
 140 {
 141     for (std::deque< PDFExtOutDevDataSync::Action >::const_iterator aIter( mActions.begin() ), aEnd( mActions.end() ) ;
 142          aIter != aEnd ; ++aIter)
 143     {
 144         switch( *aIter )
 145         {
 146             case PDFExtOutDevDataSync::CreateNamedDest : //i56629
 147             {
 148                  rWriter.Push( PushFlags::MAPMODE );
 149                 rWriter.SetMapMode( mParaMapModes.front() );
 150                 mParaMapModes.pop_front();
 151                 mParaIds.push_back( rWriter.CreateNamedDest( mParaOUStrings.front(), mParaRects.front(), mParaInts.front(), mParaDestAreaTypes.front() ) );
 152                 mParaOUStrings.pop_front();
 153                 mParaRects.pop_front();
 154                 mParaInts.pop_front();
 155                 mParaDestAreaTypes.pop_front();
 156                 rWriter.Pop();
 157             }
 158             break;
 159             case PDFExtOutDevDataSync::CreateDest :
 160             {
 161                 rWriter.Push( PushFlags::MAPMODE );
 162                 rWriter.SetMapMode( mParaMapModes.front() );
 163                 mParaMapModes.pop_front();
 164                 mParaIds.push_back( rWriter.CreateDest( mParaRects.front(), mParaInts.front(), mParaDestAreaTypes.front() ) );
 165                 mParaRects.pop_front();
 166                 mParaInts.pop_front();
 167                 mParaDestAreaTypes.pop_front();
 168                 rWriter.Pop();
 169             }
 170             break;
 171             case PDFExtOutDevDataSync::CreateLink :
 172             {
 173                 rWriter.Push( PushFlags::MAPMODE );
 174                 rWriter.SetMapMode( mParaMapModes.front() );
 175                 mParaMapModes.pop_front();
 176                 mParaIds.push_back( rWriter.CreateLink( mParaRects.front(), mParaInts.front() ) );
 177                 // resolve LinkAnnotation structural attribute
 178                 rWriter.SetLinkPropertyID( mParaIds.back(), sal_Int32(mParaIds.size()-1) );
 179                 mParaRects.pop_front();
 180                 mParaInts.pop_front();
 181                 rWriter.Pop();
 182             }
 183             break;
 184             case PDFExtOutDevDataSync::CreateScreen:
 185             {
 186                 rWriter.Push(PushFlags::MAPMODE);
 187                 rWriter.SetMapMode(mParaMapModes.front());
 188                 mParaMapModes.pop_front();
 189                 mParaIds.push_back(rWriter.CreateScreen(mParaRects.front(), mParaInts.front()));
 190                 mParaRects.pop_front();
 191                 mParaInts.pop_front();
 192                 rWriter.Pop();
 193             }
 194             break;
 195             case PDFExtOutDevDataSync::SetLinkDest :
 196             {
 197                 sal_Int32 nLinkId = GetMappedId();
 198                 sal_Int32 nDestId = GetMappedId();
 199                 rWriter.SetLinkDest( nLinkId, nDestId );
 200             }
 201             break;
 202             case PDFExtOutDevDataSync::SetLinkURL :
 203             {
 204                 sal_Int32 nLinkId = GetMappedId();
 205                 rWriter.SetLinkURL( nLinkId, mParaOUStrings.front() );
 206                 mParaOUStrings.pop_front();
 207             }
 208             break;
 209             case PDFExtOutDevDataSync::SetScreenURL:
 210             {
 211                 sal_Int32 nScreenId = GetMappedId();
 212                 rWriter.SetScreenURL(nScreenId, mParaOUStrings.front());
 213                 mParaOUStrings.pop_front();
 214             }
 215             break;
 216             case PDFExtOutDevDataSync::SetScreenStream:
 217             {
 218                 sal_Int32 nScreenId = GetMappedId();
 219                 rWriter.SetScreenStream(nScreenId, mParaOUStrings.front());
 220                 mParaOUStrings.pop_front();
 221             }
 222             break;
 223             case PDFExtOutDevDataSync::RegisterDest :
 224             {
 225                 const sal_Int32 nDestId = mParaInts.front();
 226                 mParaInts.pop_front();
 227                 OSL_ENSURE( mFutureDestinations.find( nDestId ) != mFutureDestinations.end(),
 228                     "GlobalSyncData::PlayGlobalActions: DescribeRegisteredRequest has not been called for that destination!" );
 229
 230                 PDFLinkDestination& rDest = mFutureDestinations[ nDestId ];
 231
 232                 rWriter.Push( PushFlags::MAPMODE );
 233                 rWriter.SetMapMode( rDest.mMapMode );
 234                 mParaIds.push_back( rWriter.RegisterDestReference( nDestId, rDest.mRect, rDest.mPageNr, rDest.mAreaType ) );
 235                 rWriter.Pop();
 236             }
 237             break;
 238             case PDFExtOutDevDataSync::CreateOutlineItem :
 239             {
 240                 sal_Int32 nParent = GetMappedId();
 241                 sal_Int32 nLinkId = GetMappedId();
 242                 mParaIds.push_back( rWriter.CreateOutlineItem( nParent, mParaOUStrings.front(), nLinkId ) );
 243                 mParaOUStrings.pop_front();
 244             }
 245             break;
 246             case PDFExtOutDevDataSync::CreateNote :
 247             {
 248                 rWriter.Push( PushFlags::MAPMODE );
 249                 rWriter.SetMapMode( mParaMapModes.front() );
 250                 rWriter.CreateNote( mParaRects.front(), mParaPDFNotes.front(), mParaInts.front() );
 251                 mParaMapModes.pop_front();
 252                 mParaRects.pop_front();
 253                 mParaPDFNotes.pop_front();
 254                 mParaInts.pop_front();
 255             }
 256             break;
 257             case PDFExtOutDevDataSync::SetPageTransition :
 258             {
 259                 rWriter.SetPageTransition( mParaPageTransitions.front(), mParauInts.front(), mParaInts.front() );
 260                 mParaPageTransitions.pop_front();
 261                 mParauInts.pop_front();
 262                 mParaInts.pop_front();
 263             }
 264             break;
 265             case PDFExtOutDevDataSync::BeginStructureElement:
 266             case PDFExtOutDevDataSync::EndStructureElement:
 267             case PDFExtOutDevDataSync::SetCurrentStructureElement:
 268             case PDFExtOutDevDataSync::SetStructureAttribute:
 269             case PDFExtOutDevDataSync::SetStructureAttributeNumerical:
 270             case PDFExtOutDevDataSync::SetStructureBoundingBox:
 271             case PDFExtOutDevDataSync::SetActualText:
 272             case PDFExtOutDevDataSync::SetAlternateText:
 273             case PDFExtOutDevDataSync::CreateControl:
 274             case PDFExtOutDevDataSync::BeginGroup:
 275             case PDFExtOutDevDataSync::EndGroupGfxLink:
 276                 break;
 277         }
 278     }
 279 }
 280
 281 struct PageSyncData
 282 {
 283     std::deque< PDFExtOutDevDataSync >              mActions;
 284     std::deque< tools::Rectangle >                         mParaRects;
 285     std::deque< sal_Int32 >                         mParaInts;
 286     std::deque< OUString >                     mParaOUStrings;
 287     std::deque< PDFWriter::StructElement >          mParaStructElements;
 288     std::deque< PDFWriter::StructAttribute >        mParaStructAttributes;
 289     std::deque< PDFWriter::StructAttributeValue >   mParaStructAttributeValues;
 290     std::deque< Graphic >                           mGraphics;
 291     Graphic                                         mCurrentGraphic;
 292     std::deque< std::shared_ptr< PDFWriter::AnyWidget > >
 293                                                     mControls;
 294     GlobalSyncData*                                 mpGlobalData;
 295
 296     bool                                        mbGroupIgnoreGDIMtfActions;
 297
 298
 299     explicit PageSyncData( GlobalSyncData* pGlobal )
 300         : mbGroupIgnoreGDIMtfActions ( false )
 301     { mpGlobalData = pGlobal; }
 302
 303     void PushAction( const OutputDevice& rOutDev, const PDFExtOutDevDataSync::Action eAct );
 304     bool PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rCurGDIMtfAction, const PDFExtOutDevData& rOutDevData );
 305 };
 306
 307 void PageSyncData::PushAction( const OutputDevice& rOutDev, const PDFExtOutDevDataSync::Action eAct )
 308 {
 309     GDIMetaFile* pMtf = rOutDev.GetConnectMetaFile();
 310     SAL_WARN_IF( !pMtf, "vcl", "PageSyncData::PushAction -> no ConnectMetaFile !!!" );
 311
 312     PDFExtOutDevDataSync aSync;
 313     aSync.eAct = eAct;
 314     if ( pMtf )
 315         aSync.nIdx = pMtf->GetActionSize();
 316     else
 317         aSync.nIdx = 0x7fffffff;    // sync not possible
 318     mActions.push_back( aSync );
 319 }
 320 bool PageSyncData::PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rCurGDIMtfAction, const PDFExtOutDevData& rOutDevData )
 321 {
 322     bool bRet = false;
 323     if ( mActions.size() && ( mActions.front().nIdx == rCurGDIMtfAction ) )
 324     {
 325         bRet = true;
 326         PDFExtOutDevDataSync aDataSync = mActions.front();
 327         mActions.pop_front();
 328         switch( aDataSync.eAct )
 329         {
 330             case PDFExtOutDevDataSync::BeginStructureElement :
 331             {
 332                 sal_Int32 nNewEl = rWriter.BeginStructureElement( mParaStructElements.front(), mParaOUStrings.front() ) ;
 333                 mParaStructElements.pop_front();
 334                 mParaOUStrings.pop_front();
 335                 mpGlobalData->mStructIdMap.push_back( nNewEl );
 336             }
 337             break;
 338             case PDFExtOutDevDataSync::EndStructureElement :
 339             {
 340                 rWriter.EndStructureElement();
 341             }
 342             break;
 343             case PDFExtOutDevDataSync::SetCurrentStructureElement:
 344             {
 345                 rWriter.SetCurrentStructureElement( mpGlobalData->GetMappedStructId( mParaInts.front() ) );
 346                 mParaInts.pop_front();
 347             }
 348             break;
 349             case PDFExtOutDevDataSync::SetStructureAttribute :
 350             {
 351                 rWriter.SetStructureAttribute( mParaStructAttributes.front(), mParaStructAttributeValues.front() );
 352                 mParaStructAttributeValues.pop_front();
 353                 mParaStructAttributes.pop_front();
 354             }
 355             break;
 356             case PDFExtOutDevDataSync::SetStructureAttributeNumerical :
 357             {
 358                 rWriter.SetStructureAttributeNumerical( mParaStructAttributes.front(), mParaInts.front() );
 359                 mParaStructAttributes.pop_front();
 360                 mParaInts.pop_front();
 361             }
 362             break;
 363             case PDFExtOutDevDataSync::SetStructureBoundingBox :
 364             {
 365                 rWriter.SetStructureBoundingBox( mParaRects.front() );
 366                 mParaRects.pop_front();
 367             }
 368             break;
 369             case PDFExtOutDevDataSync::SetActualText :
 370             {
 371                 rWriter.SetActualText( mParaOUStrings.front() );
 372                 mParaOUStrings.pop_front();
 373             }
 374             break;
 375             case PDFExtOutDevDataSync::SetAlternateText :
 376             {
 377                 rWriter.SetAlternateText( mParaOUStrings.front() );
 378                 mParaOUStrings.pop_front();
 379             }
 380             break;
 381             case PDFExtOutDevDataSync::CreateControl:
 382             {
 383                 std::shared_ptr< PDFWriter::AnyWidget > pControl( mControls.front() );
 384                 SAL_WARN_IF( !pControl.get(), "vcl", "PageSyncData::PlaySyncPageAct: invalid widget!" );
 385                 if ( pControl.get() )
 386                     rWriter.CreateControl( *pControl );
 387                 mControls.pop_front();
 388             }
 389             break;
 390             case PDFExtOutDevDataSync::BeginGroup :
 391             {
 392                 /* first determining if this BeginGroup is starting a GfxLink,
 393                    by searching for a EndGroup or a EndGroupGfxLink */
 394                 mbGroupIgnoreGDIMtfActions = false;
 395                 std::deque< PDFExtOutDevDataSync >::iterator aBeg = mActions.begin();
 396                 std::deque< PDFExtOutDevDataSync >::iterator aEnd = mActions.end();
 397                 while ( aBeg != aEnd )
 398                 {
 399                     if ( aBeg->eAct == PDFExtOutDevDataSync::EndGroupGfxLink )
 400                     {
 401                         Graphic& rGraphic = mGraphics.front();
 402                         if ( rGraphic.IsLink() )
 403                         {
 404                             GfxLinkType eType = rGraphic.GetLink().GetType();
 405                             if ( eType == GfxLinkType::NativeJpg && mParaRects.size() >= 2 )
 406                             {
 407                                 mbGroupIgnoreGDIMtfActions = rOutDevData.HasAdequateCompression(rGraphic);
 408                                 if ( !mbGroupIgnoreGDIMtfActions )
 409                                     mCurrentGraphic = rGraphic;
 410                             }
 411                             else if ((eType == GfxLinkType::NativePng || eType == GfxLinkType::NativePdf) && mParaRects.size() >= 2)
 412                             {
 413                                 if ( rOutDevData.HasAdequateCompression(rGraphic) || eType == GfxLinkType::NativePdf )
 414                                     mCurrentGraphic = rGraphic;
 415                             }
 416                         }
 417                         break;
 418                     }
 419                     ++aBeg;
 420                 }
 421             }
 422             break;
 423             case PDFExtOutDevDataSync::EndGroupGfxLink :
 424             {
 425                 tools::Rectangle aOutputRect, aVisibleOutputRect;
 426                 Graphic   aGraphic( mGraphics.front() );
 427
 428                 mGraphics.pop_front();
 429                 sal_Int32 nTransparency = mParaInts.front();
 430                 mParaInts.pop_front();
 431                 aOutputRect = mParaRects.front();
 432                 mParaRects.pop_front();
 433                 aVisibleOutputRect = mParaRects.front();
 434                 mParaRects.pop_front();
 435
 436                 if ( mbGroupIgnoreGDIMtfActions )
 437                 {
 438                     bool bClippingNeeded = ( aOutputRect != aVisibleOutputRect ) && !aVisibleOutputRect.IsEmpty();
 439
 440                     GfxLink   aGfxLink( aGraphic.GetLink() );
 441                     if ( aGfxLink.GetType() == GfxLinkType::NativeJpg )
 442                     {
 443                         if ( bClippingNeeded )
 444                         {
 445                             rWriter.Push();
 446                             basegfx::B2DPolyPolygon aRect( basegfx::tools::createPolygonFromRect(
 447                                 basegfx::B2DRectangle( aVisibleOutputRect.Left(), aVisibleOutputRect.Top(),
 448                                                        aVisibleOutputRect.Right(), aVisibleOutputRect.Bottom() ) ) );
 449                             rWriter.SetClipRegion( aRect);
 450                         }
 451
 452                         Bitmap aMask;
 453                         if (nTransparency)
 454                         {
 455                             AlphaMask aAlphaMask(aGraphic.GetSizePixel());
 456                             aAlphaMask.Erase(nTransparency);
 457                             aMask = aAlphaMask.GetBitmap();
 458                         }
 459
 460                         SvMemoryStream aTmp;
 461                         const sal_uInt8* pData = aGfxLink.GetData();
 462                         sal_uInt32 nBytes = aGfxLink.GetDataSize();
 463                         if( pData && nBytes )
 464                         {
 465                             aTmp.WriteBytes( pData, nBytes );
 466                             rWriter.DrawJPGBitmap( aTmp, aGraphic.GetBitmap().GetBitCount() > 8, aGraphic.GetSizePixel(), aOutputRect, aMask, aGraphic );
 467                         }
 468
 469                         if ( bClippingNeeded )
 470                             rWriter.Pop();
 471                     }
 472                     mbGroupIgnoreGDIMtfActions = false;
 473                 }
 474                 mCurrentGraphic.Clear();
 475             }
 476             break;
 477             case PDFExtOutDevDataSync::CreateNamedDest:
 478             case PDFExtOutDevDataSync::CreateDest:
 479             case PDFExtOutDevDataSync::CreateLink:
 480             case PDFExtOutDevDataSync::CreateScreen:
 481             case PDFExtOutDevDataSync::SetLinkDest:
 482             case PDFExtOutDevDataSync::SetLinkURL:
 483             case PDFExtOutDevDataSync::SetScreenURL:
 484             case PDFExtOutDevDataSync::SetScreenStream:
 485             case PDFExtOutDevDataSync::RegisterDest:
 486             case PDFExtOutDevDataSync::CreateOutlineItem:
 487             case PDFExtOutDevDataSync::CreateNote:
 488             case PDFExtOutDevDataSync::SetPageTransition:
 489                 break;
 490         }
 491     }
 492     else if ( mbGroupIgnoreGDIMtfActions )
 493     {
 494         rCurGDIMtfAction++;
 495         bRet = true;
 496     }
 497     return bRet;
 498 }
 499
 500 PDFExtOutDevData::PDFExtOutDevData( const OutputDevice& rOutDev ) :
 501     mrOutDev                ( rOutDev ),
 502     mbTaggedPDF             ( false ),
 503     mbExportNotes           ( true ),
 504     mbExportNotesPages      ( false ),
 505     mbTransitionEffects     ( true ),
 506     mbUseLosslessCompression( true ),
 507     mbReduceImageResolution ( false ),
 508     mbExportFormFields      ( false ),
 509     mbExportBookmarks       ( false ),
 510     mbExportHiddenSlides    ( false ),
 511     mbExportNDests          ( false ),
 512     mnFormsFormat           ( 0 ),
 513     mnPage                  ( -1 ),
 514     mnCompressionQuality    ( 90 ),
 515     mnMaxImageResolution    ( 300 ),
 516     mpPageSyncData          ( nullptr ),
 517     mpGlobalSyncData        ( new GlobalSyncData() )
 518 {
 519     mpPageSyncData = new PageSyncData( mpGlobalSyncData );
 520 }
 521
 522 PDFExtOutDevData::~PDFExtOutDevData()
 523 {
 524     delete mpPageSyncData;
 525     delete mpGlobalSyncData;
 526 }
 527
 528 const Graphic& PDFExtOutDevData::GetCurrentGraphic() const
 529 {
 530     return mpPageSyncData->mCurrentGraphic;
 531 }
 532
 533 void PDFExtOutDevData::SetDocumentLocale( const css::lang::Locale& rLoc )
 534 {
 535     maDocLocale = rLoc;
 536 }
 537 void PDFExtOutDevData::SetCurrentPageNumber( const sal_Int32 nPage )
 538 {
 539     mnPage = nPage;
 540 }
 541 void PDFExtOutDevData::SetIsLosslessCompression( const bool bUseLosslessCompression )
 542 {
 543     mbUseLosslessCompression = bUseLosslessCompression;
 544 }
 545 void PDFExtOutDevData::SetCompressionQuality( const sal_Int32 nQuality )
 546 {
 547     mnCompressionQuality = nQuality;
 548 }
 549 void PDFExtOutDevData::SetMaxImageResolution( const sal_Int32 nMaxImageResolution )
 550 {
 551     mnMaxImageResolution = nMaxImageResolution;
 552 }
 553 void PDFExtOutDevData::SetIsReduceImageResolution( const bool bReduceImageResolution )
 554 {
 555     mbReduceImageResolution = bReduceImageResolution;
 556 }
 557 void PDFExtOutDevData::SetIsExportNotes( const bool bExportNotes )
 558 {
 559     mbExportNotes = bExportNotes;
 560 }
 561 void PDFExtOutDevData::SetIsExportNotesPages( const bool bExportNotesPages )
 562 {
 563     mbExportNotesPages = bExportNotesPages;
 564 }
 565 void PDFExtOutDevData::SetIsExportTaggedPDF( const bool bTaggedPDF )
 566 {
 567     mbTaggedPDF = bTaggedPDF;
 568 }
 569 void PDFExtOutDevData::SetIsExportTransitionEffects( const bool bTransitionEffects )
 570 {
 571     mbTransitionEffects = bTransitionEffects;
 572 }
 573 void PDFExtOutDevData::SetIsExportFormFields( const bool bExportFomtFields )
 574 {
 575     mbExportFormFields = bExportFomtFields;
 576 }
 577 void PDFExtOutDevData::SetFormsFormat( const sal_Int32 nFormsFormat )
 578 {
 579     mnFormsFormat = nFormsFormat;
 580 }
 581 void PDFExtOutDevData::SetIsExportBookmarks( const bool bExportBookmarks )
 582 {
 583     mbExportBookmarks = bExportBookmarks;
 584 }
 585 void PDFExtOutDevData::SetIsExportHiddenSlides( const bool bExportHiddenSlides )
 586 {
 587     mbExportHiddenSlides = bExportHiddenSlides;
 588 }
 589 void PDFExtOutDevData::SetIsExportNamedDestinations( const bool bExportNDests )
 590 {
 591     mbExportNDests = bExportNDests;
 592 }
 593 void PDFExtOutDevData::ResetSyncData()
 594 {
 595     *mpPageSyncData = PageSyncData( mpGlobalSyncData );
 596 }
 597 bool PDFExtOutDevData::PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rIdx )
 598 {
 599     return mpPageSyncData->PlaySyncPageAct( rWriter, rIdx, *this );
 600 }
 601 void PDFExtOutDevData::PlayGlobalActions( PDFWriter& rWriter )
 602 {
 603     mpGlobalSyncData->PlayGlobalActions( rWriter );
 604 }
 605
 606 /* global actions, synchronisation to the recorded metafile isn't needed,
 607    all actions will be played after the last page was recorded
 608 */
 609 //--->i56629
 610 sal_Int32 PDFExtOutDevData::CreateNamedDest(const OUString& sDestName,  const tools::Rectangle& rRect, sal_Int32 nPageNr )
 611 {
 612     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateNamedDest );
 613     mpGlobalSyncData->mParaOUStrings.push_back( sDestName );
 614     mpGlobalSyncData->mParaRects.push_back( rRect );
 615     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 616     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 617     mpGlobalSyncData->mParaDestAreaTypes.push_back( PDFWriter::DestAreaType::XYZ );
 618
 619     return mpGlobalSyncData->mCurId++;
 620 }
 621 //<---i56629
 622 sal_Int32 PDFExtOutDevData::RegisterDest()
 623 {
 624     const sal_Int32 nLinkDestID = mpGlobalSyncData->mCurId++;
 625     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::RegisterDest );
 626     mpGlobalSyncData->mParaInts.push_back( nLinkDestID );
 627
 628     return nLinkDestID;
 629 }
 630 void PDFExtOutDevData::DescribeRegisteredDest( sal_Int32 nDestId, const tools::Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType )
 631 {
 632     OSL_PRECOND( nDestId != -1, "PDFExtOutDevData::DescribeRegisteredDest: invalid destination Id!" );
 633     PDFLinkDestination aLinkDestination;
 634     aLinkDestination.mRect = rRect;
 635     aLinkDestination.mMapMode = mrOutDev.GetMapMode();
 636     aLinkDestination.mPageNr = nPageNr == -1 ? mnPage : nPageNr;
 637     aLinkDestination.mAreaType = eType;
 638     mpGlobalSyncData->mFutureDestinations[ nDestId ] = aLinkDestination;
 639 }
 640 sal_Int32 PDFExtOutDevData::CreateDest( const tools::Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType )
 641 {
 642     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateDest );
 643     mpGlobalSyncData->mParaRects.push_back( rRect );
 644     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 645     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 646     mpGlobalSyncData->mParaDestAreaTypes.push_back( eType );
 647     return mpGlobalSyncData->mCurId++;
 648 }
 649 sal_Int32 PDFExtOutDevData::CreateLink( const tools::Rectangle& rRect, sal_Int32 nPageNr )
 650 {
 651     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateLink );
 652     mpGlobalSyncData->mParaRects.push_back( rRect );
 653     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 654     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 655     return mpGlobalSyncData->mCurId++;
 656 }
 657
 658 sal_Int32 PDFExtOutDevData::CreateScreen(const tools::Rectangle& rRect, sal_Int32 nPageNr)
 659 {
 660     mpGlobalSyncData->mActions.push_back(PDFExtOutDevDataSync::CreateScreen);
 661     mpGlobalSyncData->mParaRects.push_back(rRect);
 662     mpGlobalSyncData->mParaMapModes.push_back(mrOutDev.GetMapMode());
 663     mpGlobalSyncData->mParaInts.push_back(nPageNr);
 664     return mpGlobalSyncData->mCurId++;
 665 }
 666
 667 sal_Int32 PDFExtOutDevData::SetLinkDest( sal_Int32 nLinkId, sal_Int32 nDestId )
 668 {
 669     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetLinkDest );
 670     mpGlobalSyncData->mParaInts.push_back( nLinkId );
 671     mpGlobalSyncData->mParaInts.push_back( nDestId );
 672     return 0;
 673 }
 674 sal_Int32 PDFExtOutDevData::SetLinkURL( sal_Int32 nLinkId, const OUString& rURL )
 675 {
 676     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetLinkURL );
 677     mpGlobalSyncData->mParaInts.push_back( nLinkId );
 678     mpGlobalSyncData->mParaOUStrings.push_back( rURL );
 679     return 0;
 680 }
 681
 682 void PDFExtOutDevData::SetScreenURL(sal_Int32 nScreenId, const OUString& rURL)
 683 {
 684     mpGlobalSyncData->mActions.push_back(PDFExtOutDevDataSync::SetScreenURL);
 685     mpGlobalSyncData->mParaInts.push_back(nScreenId);
 686     mpGlobalSyncData->mParaOUStrings.push_back(rURL);
 687 }
 688
 689 void PDFExtOutDevData::SetScreenStream(sal_Int32 nScreenId, const OUString& rURL)
 690 {
 691     mpGlobalSyncData->mActions.push_back(PDFExtOutDevDataSync::SetScreenStream);
 692     mpGlobalSyncData->mParaInts.push_back(nScreenId);
 693     mpGlobalSyncData->mParaOUStrings.push_back(rURL);
 694 }
 695
 696 sal_Int32 PDFExtOutDevData::CreateOutlineItem( sal_Int32 nParent, const OUString& rText, sal_Int32 nDestID )
 697 {
 698     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateOutlineItem );
 699     mpGlobalSyncData->mParaInts.push_back( nParent );
 700     mpGlobalSyncData->mParaOUStrings.push_back( rText );
 701     mpGlobalSyncData->mParaInts.push_back( nDestID );
 702     return mpGlobalSyncData->mCurId++;
 703 }
 704 void PDFExtOutDevData::CreateNote( const tools::Rectangle& rRect, const PDFNote& rNote, sal_Int32 nPageNr )
 705 {
 706     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateNote );
 707     mpGlobalSyncData->mParaRects.push_back( rRect );
 708     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 709     mpGlobalSyncData->mParaPDFNotes.push_back( rNote );
 710     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 711 }
 712 void PDFExtOutDevData::SetPageTransition( PDFWriter::PageTransition eType, sal_uInt32 nMilliSec )
 713 {
 714     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetPageTransition );
 715     mpGlobalSyncData->mParaPageTransitions.push_back( eType );
 716     mpGlobalSyncData->mParauInts.push_back( nMilliSec );
 717     mpGlobalSyncData->mParaInts.push_back( mnPage );
 718 }
 719
 720 /* local (page), actions have to be played synchronously to the actions of
 721    of the recorded metafile (created by each xRenderable->render()) */
 722    sal_Int32 PDFExtOutDevData::BeginStructureElement( PDFWriter::StructElement eType, const OUString& rAlias )
 723 {
 724     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::BeginStructureElement );
 725     mpPageSyncData->mParaStructElements.push_back( eType );
 726     mpPageSyncData->mParaOUStrings.push_back( rAlias );
 727     // need a global id
 728     sal_Int32 nNewId = mpGlobalSyncData->mStructParents.size();
 729     mpGlobalSyncData->mStructParents.push_back( mpGlobalSyncData->mCurrentStructElement );
 730     mpGlobalSyncData->mCurrentStructElement = nNewId;
 731     return nNewId;
 732 }
 733 void PDFExtOutDevData::EndStructureElement()
 734 {
 735     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::EndStructureElement );
 736     mpGlobalSyncData->mCurrentStructElement = mpGlobalSyncData->mStructParents[ mpGlobalSyncData->mCurrentStructElement ];
 737 }
 738 bool PDFExtOutDevData::SetCurrentStructureElement( sal_Int32 nStructId )
 739 {
 740     bool bSuccess = false;
 741     if( sal_uInt32(nStructId) < mpGlobalSyncData->mStructParents.size() )
 742     {
 743         mpGlobalSyncData->mCurrentStructElement = nStructId;
 744         mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetCurrentStructureElement );
 745         mpPageSyncData->mParaInts.push_back( nStructId );
 746         bSuccess = true;
 747     }
 748     return bSuccess;
 749 }
 750 sal_Int32 PDFExtOutDevData::GetCurrentStructureElement()
 751 {
 752     return mpGlobalSyncData->mCurrentStructElement;
 753 }
 754 bool PDFExtOutDevData::SetStructureAttribute( PDFWriter::StructAttribute eAttr, PDFWriter::StructAttributeValue eVal )
 755 {
 756     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureAttribute );
 757     mpPageSyncData->mParaStructAttributes.push_back( eAttr );
 758     mpPageSyncData->mParaStructAttributeValues.push_back( eVal );
 759     return true;
 760 }
 761 bool PDFExtOutDevData::SetStructureAttributeNumerical( PDFWriter::StructAttribute eAttr, sal_Int32 nValue )
 762 {
 763     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureAttributeNumerical );
 764     mpPageSyncData->mParaStructAttributes.push_back( eAttr );
 765     mpPageSyncData->mParaInts.push_back( nValue );
 766     return true;
 767 }
 768 void PDFExtOutDevData::SetStructureBoundingBox( const tools::Rectangle& rRect )
 769 {
 770     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureBoundingBox );
 771     mpPageSyncData->mParaRects.push_back( rRect );
 772 }
 773 void PDFExtOutDevData::SetActualText( const OUString& rText )
 774 {
 775     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetActualText );
 776     mpPageSyncData->mParaOUStrings.push_back( rText );
 777 }
 778 void PDFExtOutDevData::SetAlternateText( const OUString& rText )
 779 {
 780     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetAlternateText );
 781     mpPageSyncData->mParaOUStrings.push_back( rText );
 782 }
 783
 784 void PDFExtOutDevData::CreateControl( const PDFWriter::AnyWidget& rControlType )
 785 {
 786     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::CreateControl );
 787
 788     std::shared_ptr< PDFWriter::AnyWidget > pClone( rControlType.Clone() );
 789     mpPageSyncData->mControls.push_back( pClone );
 790 }
 791
 792 void PDFExtOutDevData::BeginGroup()
 793 {
 794     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::BeginGroup );
 795 }
 796
 797 void PDFExtOutDevData::EndGroup( const Graphic&     rGraphic,
 798                                  sal_uInt8          nTransparency,
 799                                  const tools::Rectangle&   rOutputRect,
 800                                  const tools::Rectangle&   rVisibleOutputRect )
 801 {
 802     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::EndGroupGfxLink );
 803     mpPageSyncData->mGraphics.push_back( rGraphic );
 804     mpPageSyncData->mParaInts.push_back( nTransparency );
 805     mpPageSyncData->mParaRects.push_back( rOutputRect );
 806     mpPageSyncData->mParaRects.push_back( rVisibleOutputRect );
 807 }
 808
 809 // Avoids expensive de-compression and re-compression of large images.
 810 bool PDFExtOutDevData::HasAdequateCompression( const Graphic &rGraphic ) const
 811 {
 812     bool bReduceResolution = false;
 813
 814     assert(rGraphic.IsLink() &&
 815            (rGraphic.GetLink().GetType() == GfxLinkType::NativeJpg ||
 816             rGraphic.GetLink().GetType() == GfxLinkType::NativePng ||
 817             rGraphic.GetLink().GetType() == GfxLinkType::NativePdf));
 818
 819     // small items better off as PNG anyway
 820     if ( rGraphic.GetSizePixel().Width() < 32 &&
 821          rGraphic.GetSizePixel().Height() < 32 )
 822         return false;
 823
 824     // FIXME: ideally we'd also pre-empt the DPI related scaling too.
 825
 826     Size aSize = rGraphic.GetSizePixel();
 827     if (rGraphic.GetLink().GetDataSize() == 0)
 828         return false;
 829     sal_Int32 nCurrentRatio = (100 * aSize.Width() * aSize.Height() * 4) /
 830                                rGraphic.GetLink().GetDataSize();
 831
 832     if ( GetIsLosslessCompression() )
 833         return !bReduceResolution && !GetIsReduceImageResolution();
 834     else
 835     {
 836         static const struct {
 837             sal_Int32 mnQuality;
 838             sal_Int32 mnRatio;
 839         } aRatios[] = { // minimum tolerable compression ratios
 840             { 100, 400 }, { 95, 700 }, { 90, 1000 }, { 85, 1200 },
 841             { 80, 1500 }, { 75, 1700 }
 842         };
 843         sal_Int32 nTargetRatio = 10000;
 844         bool bIsTargetRatioReached = false;
 845         for (auto & rRatio : aRatios)
 846         {
 847             if ( mnCompressionQuality > rRatio.mnQuality )
 848             {
 849                 bIsTargetRatioReached = true;
 850                 break;
 851             }
 852             nTargetRatio = rRatio.mnRatio;
 853         }
 854
 855         return ((nCurrentRatio > nTargetRatio) && bIsTargetRatioReached);
 856     }
 857 }
 858
 859 }
 860
 861 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */