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