vcl/source/gdi/pdfextoutdevdata.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: pdfextoutdevdata.cxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33 #include <vcl/pdfextoutdevdata.hxx>
  34 #include <vcl/graph.hxx>
  35 #include <vcl/outdev.hxx>
  36 #include <vcl/gfxlink.hxx>
  37
  38
  39 #include <boost/shared_ptr.hpp>
  40 #include <set>
  41
  42 namespace vcl
  43 {
  44 struct PDFExtOutDevDataSync
  45 {
  46     enum Action{    CreateNamedDest,
  47                     CreateDest,
  48                     CreateLink,
  49                     SetLinkDest,
  50                     SetLinkURL,
  51                     CreateOutlineItem,
  52                     SetOutlineItemParent,
  53                     SetOutlineItemText,
  54                     SetOutlineItemDest,
  55                     CreateNote,
  56                     SetAutoAdvanceTime,
  57                     SetPageTransition,
  58
  59                     BeginStructureElement,
  60                     EndStructureElement,
  61                     SetCurrentStructureElement,
  62                     SetStructureAttribute,
  63                     SetStructureAttributeNumerical,
  64                     SetStructureBoundingBox,
  65                     SetActualText,
  66                     SetAlternateText,
  67                     CreateControl,
  68                     BeginGroup,
  69                     EndGroup,
  70                     EndGroupGfxLink
  71     };
  72
  73     sal_uInt32  nIdx;
  74     Action              eAct;
  75 };
  76
  77 struct 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< rtl::OUString >                                 mParaOUStrings;
  85     std::deque< PDFWriter::DestAreaType >               mParaDestAreaTypes;
  86     std::deque< PDFNote >                                               mParaPDFNotes;
  87     std::deque< PDFWriter::PageTransition >             mParaPageTransitions;
  88
  89     sal_Int32 GetMappedId();
  90     sal_Int32 GetMappedStructId( sal_Int32 );
  91
  92     sal_Int32                                   mCurId;
  93     std::vector< sal_Int32 >    mParaIds;
  94     std::vector< sal_Int32 >    mStructIdMap;
  95
  96     sal_Int32                                   mCurrentStructElement;
  97     std::vector< sal_Int32 >    mStructParents;
  98     GlobalSyncData() :
  99             mCurId ( 0 ),
 100             mCurrentStructElement( 0 )
 101     {
 102         mStructParents.push_back( 0 );
 103         mStructIdMap.push_back( 0 );
 104     }
 105     void PlayGlobalActions( PDFWriter& rWriter );
 106 };
 107
 108 sal_Int32 GlobalSyncData::GetMappedId()
 109 {
 110     sal_Int32 nLinkId = mParaInts.front();
 111     mParaInts.pop_front();
 112
 113     /*  negative values are intentionally passed as invalid IDs
 114      *  e.g. to create a new top level outline item
 115      */
 116     if( nLinkId >= 0 )
 117     {
 118         if ( (sal_uInt32)nLinkId < mParaIds.size() )
 119             nLinkId = mParaIds[ nLinkId ];
 120         else
 121             nLinkId = -1;
 122
 123         DBG_ASSERT( nLinkId >= 0, "unmapped id in GlobalSyncData" );
 124     }
 125
 126     return nLinkId;
 127 }
 128
 129 sal_Int32 GlobalSyncData::GetMappedStructId( sal_Int32 nStructId )
 130 {
 131     if ( (sal_uInt32)nStructId < mStructIdMap.size() )
 132         nStructId = mStructIdMap[ nStructId ];
 133     else
 134         nStructId = -1;
 135
 136     DBG_ASSERT( nStructId >= 0, "unmapped structure id in GlobalSyncData" );
 137
 138     return nStructId;
 139 }
 140
 141 void GlobalSyncData::PlayGlobalActions( PDFWriter& rWriter )
 142 {
 143     std::deque< PDFExtOutDevDataSync::Action >::iterator aIter( mActions.begin() );
 144     std::deque< PDFExtOutDevDataSync::Action >::iterator aEnd( mActions.end() );
 145     while( aIter != aEnd )
 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::CreateOutlineItem :
 202             {
 203                 sal_Int32 nParent = GetMappedId();
 204                 sal_Int32 nLinkId = GetMappedId();
 205                 mParaIds.push_back( rWriter.CreateOutlineItem( nParent, mParaOUStrings.front(), nLinkId ) );
 206                 mParaOUStrings.pop_front();
 207             }
 208             break;
 209             case PDFExtOutDevDataSync::SetOutlineItemParent :
 210             {
 211                 sal_Int32 nItem = GetMappedId();
 212                 sal_Int32 nNewParent = GetMappedId();
 213                 rWriter.SetOutlineItemParent( nItem, nNewParent );
 214             }
 215             break;
 216             case PDFExtOutDevDataSync::SetOutlineItemText :
 217             {
 218                 sal_Int32 nItem = GetMappedId();
 219                 rWriter.SetOutlineItemText( nItem, mParaOUStrings.front() );
 220                 mParaOUStrings.pop_front();
 221             }
 222             break;
 223             case PDFExtOutDevDataSync::SetOutlineItemDest :
 224             {
 225                 sal_Int32 nItem = GetMappedId();
 226                 sal_Int32 nDestId = GetMappedId();
 227                 rWriter.SetOutlineItemDest( nItem, nDestId );
 228             }
 229             break;
 230             case PDFExtOutDevDataSync::CreateNote :
 231             {
 232                 rWriter.Push( PUSH_MAPMODE );
 233                 rWriter.SetMapMode( mParaMapModes.front() );
 234                 rWriter.CreateNote( mParaRects.front(), mParaPDFNotes.front(), mParaInts.front() );
 235                 mParaMapModes.pop_front();
 236                 mParaRects.pop_front();
 237                 mParaPDFNotes.pop_front();
 238                 mParaInts.pop_front();
 239             }
 240             break;
 241             case PDFExtOutDevDataSync::SetAutoAdvanceTime :
 242             {
 243                 rWriter.SetAutoAdvanceTime( mParauInts.front(), mParaInts.front() );
 244                 mParauInts.pop_front();
 245                 mParaInts.pop_front();
 246             }
 247             break;
 248             case PDFExtOutDevDataSync::SetPageTransition :
 249             {
 250                 rWriter.SetPageTransition( mParaPageTransitions.front(), mParauInts.front(), mParaInts.front() );
 251                 mParaPageTransitions.pop_front();
 252                 mParauInts.pop_front();
 253                 mParaInts.pop_front();
 254             }
 255             break;
 256             case PDFExtOutDevDataSync::BeginStructureElement:
 257             case PDFExtOutDevDataSync::EndStructureElement:
 258             case PDFExtOutDevDataSync::SetCurrentStructureElement:
 259             case PDFExtOutDevDataSync::SetStructureAttribute:
 260             case PDFExtOutDevDataSync::SetStructureAttributeNumerical:
 261             case PDFExtOutDevDataSync::SetStructureBoundingBox:
 262             case PDFExtOutDevDataSync::SetActualText:
 263             case PDFExtOutDevDataSync::SetAlternateText:
 264             case PDFExtOutDevDataSync::CreateControl:
 265             case PDFExtOutDevDataSync::BeginGroup:
 266             case PDFExtOutDevDataSync::EndGroup:
 267             case PDFExtOutDevDataSync::EndGroupGfxLink:
 268                 break;
 269         }
 270         aIter++;
 271     }
 272 }
 273
 274 struct PageSyncData
 275 {
 276     std::deque< PDFExtOutDevDataSync >                          mActions;
 277     std::deque< Rectangle >                                                     mParaRects;
 278     std::deque< sal_Int32 >                                                     mParaInts;
 279     std::deque< rtl::OUString >                                         mParaOUStrings;
 280     std::deque< PDFWriter::StructElement >                      mParaStructElements;
 281     std::deque< PDFWriter::StructAttribute >            mParaStructAttributes;
 282     std::deque< PDFWriter::StructAttributeValue >       mParaStructAttributeValues;
 283     std::deque< Graphic >                                                       mGraphics;
 284     std::deque< ::boost::shared_ptr< PDFWriter::AnyWidget > >
 285                                                     mControls;
 286     std::set< ::rtl::OUString >                     mControlNames;
 287
 288     GlobalSyncData*                                                                     mpGlobalData;
 289
 290     sal_Bool                                                                            mbGroupIgnoreGDIMtfActions;
 291
 292     PageSyncData( GlobalSyncData* pGlobal ) : mbGroupIgnoreGDIMtfActions ( sal_False ) { mpGlobalData = pGlobal; }
 293
 294     void PushAction( const OutputDevice& rOutDev, const PDFExtOutDevDataSync::Action eAct );
 295     sal_Bool PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rCurGDIMtfAction, const PDFExtOutDevData& rOutDevData );
 296 };
 297 void PageSyncData::PushAction( const OutputDevice& rOutDev, const PDFExtOutDevDataSync::Action eAct )
 298 {
 299     GDIMetaFile* pMtf = rOutDev.GetConnectMetaFile();
 300     DBG_ASSERT( pMtf, "PageSyncData::PushAction -> no ConnectMetaFile !!!" );
 301
 302     PDFExtOutDevDataSync aSync;
 303     aSync.eAct = eAct;
 304     if ( pMtf )
 305         aSync.nIdx = pMtf->GetActionCount();
 306     else
 307         aSync.nIdx = 0x7fffffff;        // sync not possible
 308     mActions.push_back( aSync );
 309 }
 310 sal_Bool PageSyncData::PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rCurGDIMtfAction, const PDFExtOutDevData& rOutDevData )
 311 {
 312     sal_Bool bRet = sal_False;
 313     if ( mActions.size() && ( mActions.front().nIdx == rCurGDIMtfAction ) )
 314     {
 315         bRet = sal_True;
 316         PDFExtOutDevDataSync aDataSync = mActions.front();
 317         mActions.pop_front();
 318         switch( aDataSync.eAct )
 319         {
 320             case PDFExtOutDevDataSync::BeginStructureElement :
 321             {
 322                 sal_Int32 nNewEl = rWriter.BeginStructureElement( mParaStructElements.front(), mParaOUStrings.front() ) ;
 323                 mParaStructElements.pop_front();
 324                 mParaOUStrings.pop_front();
 325                 mpGlobalData->mStructIdMap.push_back( nNewEl );
 326             }
 327             break;
 328             case PDFExtOutDevDataSync::EndStructureElement :
 329             {
 330                 rWriter.EndStructureElement();
 331             }
 332             break;
 333             case PDFExtOutDevDataSync::SetCurrentStructureElement:
 334             {
 335                 rWriter.SetCurrentStructureElement( mpGlobalData->GetMappedStructId( mParaInts.front() ) );
 336                 mParaInts.pop_front();
 337             }
 338             break;
 339             case PDFExtOutDevDataSync::SetStructureAttribute :
 340             {
 341                 rWriter.SetStructureAttribute( mParaStructAttributes.front(), mParaStructAttributeValues.front() );
 342                 mParaStructAttributeValues.pop_front();
 343                 mParaStructAttributes.pop_front();
 344             }
 345             break;
 346             case PDFExtOutDevDataSync::SetStructureAttributeNumerical :
 347             {
 348                 rWriter.SetStructureAttributeNumerical( mParaStructAttributes.front(), mParaInts.front() );
 349                 mParaStructAttributes.pop_front();
 350                 mParaInts.pop_front();
 351             }
 352             break;
 353             case PDFExtOutDevDataSync::SetStructureBoundingBox :
 354             {
 355                 rWriter.SetStructureBoundingBox( mParaRects.front() );
 356                 mParaRects.pop_front();
 357             }
 358             break;
 359             case PDFExtOutDevDataSync::SetActualText :
 360             {
 361                 rWriter.SetActualText( mParaOUStrings.front() );
 362                 mParaOUStrings.pop_front();
 363             }
 364             break;
 365             case PDFExtOutDevDataSync::SetAlternateText :
 366             {
 367                 rWriter.SetAlternateText( mParaOUStrings.front() );
 368                 mParaOUStrings.pop_front();
 369             }
 370             break;
 371             case PDFExtOutDevDataSync::CreateControl:
 372             {
 373                 ::boost::shared_ptr< PDFWriter::AnyWidget > pControl( mControls.front() );
 374                 DBG_ASSERT( pControl.get(), "PageSyncData::PlaySyncPageAct: invalid widget!" );
 375                 if ( pControl.get() )
 376                     rWriter.CreateControl( *pControl );
 377                 mControls.pop_front();
 378                 mControlNames.erase( pControl->Name );
 379             }
 380             break;
 381             case PDFExtOutDevDataSync::BeginGroup :
 382             {
 383                 /* first determining if this BeginGroup is starting a GfxLink,
 384                    by searching for a EndGroup or a EndGroupGfxLink */
 385                 mbGroupIgnoreGDIMtfActions = sal_False;
 386                 std::deque< PDFExtOutDevDataSync >::iterator aBeg = mActions.begin();
 387                 std::deque< PDFExtOutDevDataSync >::iterator aEnd = mActions.end();
 388                 while ( aBeg != aEnd )
 389                 {
 390                     if ( aBeg->eAct == PDFExtOutDevDataSync::EndGroup )
 391                     {
 392                         break;
 393                     }
 394                     else if ( aBeg->eAct == PDFExtOutDevDataSync::EndGroupGfxLink )
 395                     {
 396                         if ( rOutDevData.GetIsLosslessCompression() && !rOutDevData.GetIsReduceImageResolution() )
 397                         {
 398                             Graphic& rGraphic = mGraphics.front();
 399                             if ( rGraphic.IsLink() && rGraphic.GetLink().GetType() == GFX_LINK_TYPE_NATIVE_JPG )
 400                             {
 401                                 mbGroupIgnoreGDIMtfActions = sal_True;
 402                             }
 403                         }
 404                         break;
 405                     }
 406                     aBeg++;
 407                 }
 408             }
 409             break;
 410             case PDFExtOutDevDataSync::EndGroup :
 411             {
 412                 mbGroupIgnoreGDIMtfActions = sal_False;
 413             }
 414             break;
 415             case PDFExtOutDevDataSync::EndGroupGfxLink :
 416             {
 417                 sal_Int32 nTransparency;
 418                 Rectangle aOutputRect, aVisibleOutputRect;
 419                 Graphic   aGraphic( mGraphics.front() );
 420
 421                 mGraphics.pop_front();
 422                 nTransparency = mParaInts.front();
 423                 mParaInts.pop_front();
 424                 aOutputRect = mParaRects.front();
 425                 mParaRects.pop_front();
 426                 aVisibleOutputRect = mParaRects.front();
 427                 mParaRects.pop_front();
 428
 429                 if ( mbGroupIgnoreGDIMtfActions )
 430                 {
 431                     sal_Bool bClippingNeeded = ( aOutputRect != aVisibleOutputRect ) && !aVisibleOutputRect.IsEmpty();
 432
 433                     GfxLink       aGfxLink( aGraphic.GetLink() );
 434                     if ( aGfxLink.GetType() == GFX_LINK_TYPE_NATIVE_JPG )
 435                     {
 436                         if ( bClippingNeeded )
 437                         {
 438                             rWriter.Push();
 439                             rWriter.SetClipRegion( aVisibleOutputRect );
 440                         }
 441                         Bitmap aMask;
 442                         SvMemoryStream aTmp;
 443                         const sal_uInt8* pData = aGfxLink.GetData();
 444                         sal_uInt32 nBytes = aGfxLink.GetDataSize();
 445                         if( pData && nBytes )
 446                         {
 447                             aTmp.Write( pData, nBytes );
 448                             rWriter.DrawJPGBitmap( aTmp, aGraphic.GetBitmap().GetBitCount() > 8, aGraphic.GetSizePixel(), aOutputRect, aMask );
 449                         }
 450
 451                         if ( bClippingNeeded )
 452                             rWriter.Pop();
 453                     }
 454                     mbGroupIgnoreGDIMtfActions = sal_False;
 455                 }
 456             }
 457             break;
 458             case PDFExtOutDevDataSync::CreateNamedDest:
 459             case PDFExtOutDevDataSync::CreateDest:
 460             case PDFExtOutDevDataSync::CreateLink:
 461             case PDFExtOutDevDataSync::SetLinkDest:
 462             case PDFExtOutDevDataSync::SetLinkURL:
 463             case PDFExtOutDevDataSync::CreateOutlineItem:
 464             case PDFExtOutDevDataSync::SetOutlineItemParent:
 465             case PDFExtOutDevDataSync::SetOutlineItemText:
 466             case PDFExtOutDevDataSync::SetOutlineItemDest:
 467             case PDFExtOutDevDataSync::CreateNote:
 468             case PDFExtOutDevDataSync::SetAutoAdvanceTime:
 469             case PDFExtOutDevDataSync::SetPageTransition:
 470                 break;
 471         }
 472     }
 473     else if ( mbGroupIgnoreGDIMtfActions )
 474     {
 475         rCurGDIMtfAction++;
 476         bRet = sal_True;
 477     }
 478     return bRet;
 479 }
 480
 481 TYPEINIT1(PDFExtOutDevData,ExtOutDevData);
 482 PDFExtOutDevData::PDFExtOutDevData( const OutputDevice& rOutDev ) :
 483     mrOutDev                            ( rOutDev ),
 484     mbTaggedPDF                         ( sal_False ),
 485     mbExportNotes                       ( sal_True ),
 486     mbTransitionEffects         ( sal_True ),
 487     mbUseLosslessCompression( sal_True ),
 488     mbReduceImageResolution     ( sal_False ),
 489     mbExportNDests          ( sal_False ),
 490     mnFormsFormat                       ( 0 ),
 491     mnPage                                      ( -1 ),
 492     mpPageSyncData                      ( NULL ),
 493     mpGlobalSyncData            ( new GlobalSyncData() )
 494 {
 495     mpPageSyncData = new PageSyncData( mpGlobalSyncData );
 496 }
 497
 498 PDFExtOutDevData::~PDFExtOutDevData()
 499 {
 500     delete mpPageSyncData;
 501     delete mpGlobalSyncData;
 502 }
 503
 504 const com::sun::star::lang::Locale& PDFExtOutDevData::GetDocumentLocale() const
 505 {
 506     return maDocLocale;
 507 }
 508 void PDFExtOutDevData::SetDocumentLocale( const com::sun::star::lang::Locale& rLoc )
 509 {
 510     maDocLocale = rLoc;
 511 }
 512 sal_Int32 PDFExtOutDevData::GetCurrentPageNumber() const
 513 {
 514     return mnPage;
 515 }
 516 void PDFExtOutDevData::SetCurrentPageNumber( const sal_Int32 nPage )
 517 {
 518     mnPage = nPage;
 519 }
 520 sal_Bool PDFExtOutDevData::GetIsLosslessCompression() const
 521 {
 522     return mbUseLosslessCompression;
 523 }
 524 void PDFExtOutDevData::SetIsLosslessCompression( const sal_Bool bUseLosslessCompression )
 525 {
 526     mbUseLosslessCompression = bUseLosslessCompression;
 527 }
 528 sal_Bool PDFExtOutDevData::GetIsReduceImageResolution() const
 529 {
 530     return mbReduceImageResolution;
 531 }
 532 void PDFExtOutDevData::SetIsReduceImageResolution( const sal_Bool bReduceImageResolution )
 533 {
 534     mbReduceImageResolution = bReduceImageResolution;
 535 }
 536 sal_Bool PDFExtOutDevData::GetIsExportNotes() const
 537 {
 538     return mbExportNotes;
 539 }
 540 void PDFExtOutDevData::SetIsExportNotes( const sal_Bool bExportNotes )
 541 {
 542     mbExportNotes = bExportNotes;
 543 }
 544 sal_Bool PDFExtOutDevData::GetIsExportTaggedPDF() const
 545 {
 546     return mbTaggedPDF;
 547 }
 548 void PDFExtOutDevData::SetIsExportTaggedPDF( const sal_Bool bTaggedPDF )
 549 {
 550     mbTaggedPDF = bTaggedPDF;
 551 }
 552 sal_Bool PDFExtOutDevData::GetIsExportTransitionEffects() const
 553 {
 554     return mbTransitionEffects;
 555 }
 556 void PDFExtOutDevData::SetIsExportTransitionEffects( const sal_Bool bTransitionEffects )
 557 {
 558     mbTransitionEffects = bTransitionEffects;
 559 }
 560 sal_Bool PDFExtOutDevData::GetIsExportFormFields() const
 561 {
 562     return mbExportFormFields;
 563 }
 564 void PDFExtOutDevData::SetIsExportFormFields( const sal_Bool bExportFomtFields )
 565 {
 566     mbExportFormFields = bExportFomtFields;
 567 }
 568 sal_Int32 PDFExtOutDevData::GetFormsFormat() const
 569 {
 570     return mnFormsFormat;
 571 }
 572 void PDFExtOutDevData::SetFormsFormat( const sal_Int32 nFormsFormat )
 573 {
 574     mnFormsFormat = nFormsFormat;
 575 }
 576 sal_Bool PDFExtOutDevData::GetIsExportBookmarks() const
 577 {
 578     return mbExportBookmarks;
 579 }
 580 void PDFExtOutDevData::SetIsExportBookmarks( const sal_Bool bExportBookmarks )
 581 {
 582     mbExportBookmarks = bExportBookmarks;
 583 }
 584 std::vector< PDFExtOutDevBookmarkEntry >& PDFExtOutDevData::GetBookmarks()
 585 {
 586     return maBookmarks;
 587 }
 588 sal_Bool PDFExtOutDevData::GetIsExportNamedDestinations() const
 589 {
 590     return mbExportNDests;
 591 }
 592 void PDFExtOutDevData::SetIsExportNamedDestinations( const sal_Bool bExportNDests )
 593 {
 594     mbExportNDests = bExportNDests;
 595 }
 596 void PDFExtOutDevData::ResetSyncData()
 597 {
 598     *mpPageSyncData = PageSyncData( mpGlobalSyncData );
 599 }
 600 sal_Bool PDFExtOutDevData::PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rIdx )
 601 {
 602     return mpPageSyncData->PlaySyncPageAct( rWriter, rIdx, *this );
 603 }
 604 void PDFExtOutDevData::PlayGlobalActions( PDFWriter& rWriter )
 605 {
 606     mpGlobalSyncData->PlayGlobalActions( rWriter );
 607 }
 608
 609 /* global actions, syncronisation to the recorded metafile isn't needed,
 610    all actions will be played after the last page was recorded
 611 */
 612 //--->i56629
 613 sal_Int32 PDFExtOutDevData::CreateNamedDest(const String& sDestName,  const Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType )
 614 {
 615     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateNamedDest );
 616     mpGlobalSyncData->mParaOUStrings.push_back( sDestName );
 617     mpGlobalSyncData->mParaRects.push_back( rRect );
 618     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 619     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 620     mpGlobalSyncData->mParaDestAreaTypes.push_back( eType );
 621     return mpGlobalSyncData->mCurId++;
 622 }
 623 //<---i56629
 624 sal_Int32 PDFExtOutDevData::CreateDest( const Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType )
 625 {
 626     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateDest );
 627     mpGlobalSyncData->mParaRects.push_back( rRect );
 628     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 629     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 630     mpGlobalSyncData->mParaDestAreaTypes.push_back( eType );
 631     return mpGlobalSyncData->mCurId++;
 632 }
 633 sal_Int32 PDFExtOutDevData::CreateLink( const Rectangle& rRect, sal_Int32 nPageNr )
 634 {
 635     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateLink );
 636     mpGlobalSyncData->mParaRects.push_back( rRect );
 637     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 638     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 639     return mpGlobalSyncData->mCurId++;
 640 }
 641 sal_Int32 PDFExtOutDevData::SetLinkDest( sal_Int32 nLinkId, sal_Int32 nDestId )
 642 {
 643     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetLinkDest );
 644     mpGlobalSyncData->mParaInts.push_back( nLinkId );
 645     mpGlobalSyncData->mParaInts.push_back( nDestId );
 646     return 0;
 647 }
 648 sal_Int32 PDFExtOutDevData::SetLinkURL( sal_Int32 nLinkId, const rtl::OUString& rURL )
 649 {
 650     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetLinkURL );
 651     mpGlobalSyncData->mParaInts.push_back( nLinkId );
 652     mpGlobalSyncData->mParaOUStrings.push_back( rURL );
 653     return 0;
 654 }
 655 sal_Int32 PDFExtOutDevData::CreateOutlineItem( sal_Int32 nParent, const rtl::OUString& rText, sal_Int32 nDestID )
 656 {
 657     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateOutlineItem );
 658     mpGlobalSyncData->mParaInts.push_back( nParent );
 659     mpGlobalSyncData->mParaOUStrings.push_back( rText );
 660     mpGlobalSyncData->mParaInts.push_back( nDestID );
 661     return mpGlobalSyncData->mCurId++;
 662 }
 663 sal_Int32 PDFExtOutDevData::SetOutlineItemParent( sal_Int32 nItem, sal_Int32 nNewParent )
 664 {
 665     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetOutlineItemParent );
 666     mpGlobalSyncData->mParaInts.push_back( nItem );
 667     mpGlobalSyncData->mParaInts.push_back( nNewParent );
 668     return 0;
 669 }
 670 sal_Int32 PDFExtOutDevData::SetOutlineItemText( sal_Int32 nItem, const rtl::OUString& rText )
 671 {
 672     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetOutlineItemText );
 673     mpGlobalSyncData->mParaInts.push_back( nItem );
 674     mpGlobalSyncData->mParaOUStrings.push_back( rText );
 675     return 0;
 676 }
 677 sal_Int32 PDFExtOutDevData::SetOutlineItemDest( sal_Int32 nItem, sal_Int32 nDestID )
 678 {
 679     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetOutlineItemDest );
 680     mpGlobalSyncData->mParaInts.push_back( nItem );
 681     mpGlobalSyncData->mParaInts.push_back( nDestID );
 682     return 0;
 683 }
 684 void PDFExtOutDevData::CreateNote( const Rectangle& rRect, const PDFNote& rNote, sal_Int32 nPageNr )
 685 {
 686     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateNote );
 687     mpGlobalSyncData->mParaRects.push_back( rRect );
 688     mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
 689     mpGlobalSyncData->mParaPDFNotes.push_back( rNote );
 690     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 691 }
 692 void PDFExtOutDevData::SetAutoAdvanceTime( sal_uInt32 nSeconds, sal_Int32 nPageNr )
 693 {
 694     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetAutoAdvanceTime );
 695     mpGlobalSyncData->mParauInts.push_back( nSeconds );
 696     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 697 }
 698 void PDFExtOutDevData::SetPageTransition( PDFWriter::PageTransition eType, sal_uInt32 nMilliSec, sal_Int32 nPageNr )
 699 {
 700     mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetPageTransition );
 701     mpGlobalSyncData->mParaPageTransitions.push_back( eType );
 702     mpGlobalSyncData->mParauInts.push_back( nMilliSec );
 703     mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
 704 }
 705
 706 /* local (page), actions have to be played synchroniously to the actions of
 707    of the recorded metafile (created by each xRenderable->render()) */
 708    sal_Int32 PDFExtOutDevData::BeginStructureElement( PDFWriter::StructElement eType, const rtl::OUString& rAlias )
 709 {
 710     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::BeginStructureElement );
 711     mpPageSyncData->mParaStructElements.push_back( eType );
 712     mpPageSyncData->mParaOUStrings.push_back( rAlias );
 713     // need a global id
 714     sal_Int32 nNewId = mpGlobalSyncData->mStructParents.size();
 715     mpGlobalSyncData->mStructParents.push_back( mpGlobalSyncData->mCurrentStructElement );
 716     mpGlobalSyncData->mCurrentStructElement = nNewId;
 717     return nNewId;
 718 }
 719 void PDFExtOutDevData::EndStructureElement()
 720 {
 721     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::EndStructureElement );
 722     mpGlobalSyncData->mCurrentStructElement = mpGlobalSyncData->mStructParents[ mpGlobalSyncData->mCurrentStructElement ];
 723 }
 724 bool PDFExtOutDevData::SetCurrentStructureElement( sal_Int32 nStructId )
 725 {
 726     bool bSuccess = false;
 727     if( sal_uInt32(nStructId) < mpGlobalSyncData->mStructParents.size() )
 728     {
 729         mpGlobalSyncData->mCurrentStructElement = nStructId;
 730         mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetCurrentStructureElement );
 731         mpPageSyncData->mParaInts.push_back( nStructId );
 732         bSuccess = true;
 733     }
 734     return bSuccess;
 735 }
 736 sal_Int32 PDFExtOutDevData::GetCurrentStructureElement()
 737 {
 738     return mpGlobalSyncData->mCurrentStructElement;
 739 }
 740 bool PDFExtOutDevData::SetStructureAttribute( PDFWriter::StructAttribute eAttr, PDFWriter::StructAttributeValue eVal )
 741 {
 742     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureAttribute );
 743     mpPageSyncData->mParaStructAttributes.push_back( eAttr );
 744     mpPageSyncData->mParaStructAttributeValues.push_back( eVal );
 745     return true;
 746 }
 747 bool PDFExtOutDevData::SetStructureAttributeNumerical( PDFWriter::StructAttribute eAttr, sal_Int32 nValue )
 748 {
 749     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureAttributeNumerical );
 750     mpPageSyncData->mParaStructAttributes.push_back( eAttr );
 751     mpPageSyncData->mParaInts.push_back( nValue );
 752     return true;
 753 }
 754 void PDFExtOutDevData::SetStructureBoundingBox( const Rectangle& rRect )
 755 {
 756     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureBoundingBox );
 757     mpPageSyncData->mParaRects.push_back( rRect );
 758 }
 759 void PDFExtOutDevData::SetActualText( const String& rText )
 760 {
 761     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetActualText );
 762     mpPageSyncData->mParaOUStrings.push_back( rText );
 763 }
 764 void PDFExtOutDevData::SetAlternateText( const String& rText )
 765 {
 766     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetAlternateText );
 767     mpPageSyncData->mParaOUStrings.push_back( rText );
 768 }
 769
 770 void PDFExtOutDevData::CreateControl( const PDFWriter::AnyWidget& rControlType, sal_Int32 /*nPageNr*/ )
 771 {
 772     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::CreateControl );
 773
 774     ::boost::shared_ptr< PDFWriter::AnyWidget > pClone( rControlType.Clone() );
 775     // ensure a unique name
 776     ::rtl::OUString sUniqueName( pClone->Name );
 777     sal_Int32 nUniqueNumber( 0 );
 778     while ( mpPageSyncData->mControlNames.find( sUniqueName ) != mpPageSyncData->mControlNames.end() )
 779     {
 780         sUniqueName = pClone->Name + ::rtl::OUString::valueOf( ++nUniqueNumber );
 781     }
 782     pClone->Name = sUniqueName;
 783     mpPageSyncData->mControlNames.insert( pClone->Name );
 784
 785     mpPageSyncData->mControls.push_back( pClone );
 786 }
 787
 788 void PDFExtOutDevData::BeginGroup()
 789 {
 790     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::BeginGroup );
 791 }
 792
 793 void PDFExtOutDevData::EndGroup()
 794 {
 795     mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::EndGroup );
 796 }
 797 void PDFExtOutDevData::EndGroup( const Graphic&         rGraphic,
 798                                  BYTE                           nTransparency,
 799                                  const Rectangle&       rOutputRect,
 800                                  const 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 }