/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"
#include "vcl/pdfextoutdevdata.hxx"
#include "vcl/graph.hxx"
#include "vcl/outdev.hxx"
#include "vcl/gfxlink.hxx"
#include "vcl/dllapi.h"
#include "basegfx/polygon/b2dpolygon.hxx"
#include "basegfx/polygon/b2dpolygontools.hxx"


#include <boost/shared_ptr.hpp>
#include <set>
#include <map>

namespace vcl
{
struct SAL_DLLPRIVATE PDFExtOutDevDataSync
{
    enum Action{    CreateNamedDest,
                    CreateDest,
					CreateLink,
					SetLinkDest,
					SetLinkURL,
                    RegisterDest,
					CreateOutlineItem,
					SetOutlineItemParent,
					SetOutlineItemText,
					SetOutlineItemDest,
					CreateNote,
					SetAutoAdvanceTime,
					SetPageTransition,

					BeginStructureElement,
					EndStructureElement,
                    SetCurrentStructureElement,
					SetStructureAttribute,
					SetStructureAttributeNumerical,
					SetStructureBoundingBox,
					SetActualText,
					SetAlternateText,
                    CreateControl,
					BeginGroup,
					EndGroup,
					EndGroupGfxLink
	};

	sal_uInt32	nIdx;
	Action		eAct;
};

struct SAL_DLLPRIVATE PDFLinkDestination
{
    Rectangle               mRect;
    MapMode                 mMapMode;
    sal_Int32               mPageNr;
    PDFWriter::DestAreaType mAreaType;
};

struct SAL_DLLPRIVATE GlobalSyncData
{
	std::deque< PDFExtOutDevDataSync::Action >	mActions;
	std::deque< MapMode >						mParaMapModes;
	std::deque< Rectangle >						mParaRects;
	std::deque< sal_Int32 >						mParaInts;
	std::deque< sal_uInt32 >					mParauInts;
	std::deque< rtl::OUString >					mParaOUStrings;
	std::deque< PDFWriter::DestAreaType >		mParaDestAreaTypes;
	std::deque< PDFNote >						mParaPDFNotes;
	std::deque< PDFWriter::PageTransition >		mParaPageTransitions;
    ::std::map< sal_Int32, PDFLinkDestination > mFutureDestinations;

	sal_Int32 GetMappedId();
    sal_Int32 GetMappedStructId( sal_Int32 );

	sal_Int32					mCurId;
	std::vector< sal_Int32 >	mParaIds;
    std::vector< sal_Int32 >	mStructIdMap;

    sal_Int32					mCurrentStructElement;
    std::vector< sal_Int32 >	mStructParents;
	GlobalSyncData() :
            mCurId ( 0 ),
            mCurrentStructElement( 0 )
    {
        mStructParents.push_back( 0 );
        mStructIdMap.push_back( 0 );
    }
	void PlayGlobalActions( PDFWriter& rWriter );
};

sal_Int32 GlobalSyncData::GetMappedId()
{
	sal_Int32 nLinkId = mParaInts.front();
	mParaInts.pop_front();

    /*  negative values are intentionally passed as invalid IDs
     *  e.g. to create a new top level outline item
     */
    if( nLinkId >= 0 )
    {
        if ( (sal_uInt32)nLinkId < mParaIds.size() )
            nLinkId = mParaIds[ nLinkId ];
        else
            nLinkId = -1;
    
        DBG_ASSERT( nLinkId >= 0, "unmapped id in GlobalSyncData" );
    }

	return nLinkId;
}

sal_Int32 GlobalSyncData::GetMappedStructId( sal_Int32 nStructId )
{
	if ( (sal_uInt32)nStructId < mStructIdMap.size() )
		nStructId = mStructIdMap[ nStructId ];
	else
		nStructId = -1;

    DBG_ASSERT( nStructId >= 0, "unmapped structure id in GlobalSyncData" );

	return nStructId;
}

void GlobalSyncData::PlayGlobalActions( PDFWriter& rWriter )
{
	std::deque< PDFExtOutDevDataSync::Action >::iterator aIter( mActions.begin() );
	std::deque< PDFExtOutDevDataSync::Action >::iterator aEnd( mActions.end() );
	while( aIter != aEnd )
	{
		switch( *aIter )
		{
            case PDFExtOutDevDataSync::CreateNamedDest : //i56629
			{
 				rWriter.Push( PUSH_MAPMODE );
				rWriter.SetMapMode( mParaMapModes.front() );
				mParaMapModes.pop_front();
				mParaIds.push_back( rWriter.CreateNamedDest( mParaOUStrings.front(), mParaRects.front(), mParaInts.front(), mParaDestAreaTypes.front() ) );
                mParaOUStrings.pop_front();
				mParaRects.pop_front();
				mParaInts.pop_front();
				mParaDestAreaTypes.pop_front();
				rWriter.Pop();
			}
			break;
			case PDFExtOutDevDataSync::CreateDest :
			{
				rWriter.Push( PUSH_MAPMODE );
				rWriter.SetMapMode( mParaMapModes.front() );
				mParaMapModes.pop_front();
				mParaIds.push_back( rWriter.CreateDest( mParaRects.front(), mParaInts.front(), mParaDestAreaTypes.front() ) );
				mParaRects.pop_front();
				mParaInts.pop_front();
				mParaDestAreaTypes.pop_front();
				rWriter.Pop();
			}
			break;
			case PDFExtOutDevDataSync::CreateLink :
			{
				rWriter.Push( PUSH_MAPMODE );
				rWriter.SetMapMode( mParaMapModes.front() );
				mParaMapModes.pop_front();
				mParaIds.push_back( rWriter.CreateLink( mParaRects.front(), mParaInts.front() ) );
                // resolve LinkAnnotation structural attribute
                rWriter.SetLinkPropertyID( mParaIds.back(), sal_Int32(mParaIds.size()-1) );
				mParaRects.pop_front();
				mParaInts.pop_front();
				rWriter.Pop();
			}
			break;
			case PDFExtOutDevDataSync::SetLinkDest :
			{
				sal_Int32 nLinkId = GetMappedId();
				sal_Int32 nDestId = GetMappedId();
				rWriter.SetLinkDest( nLinkId, nDestId );
			}
			break;
			case PDFExtOutDevDataSync::SetLinkURL :
			{
				sal_Int32 nLinkId = GetMappedId();
				rWriter.SetLinkURL( nLinkId, mParaOUStrings.front() );
				mParaOUStrings.pop_front();
			}
			break;
            case PDFExtOutDevDataSync::RegisterDest :
            {
				const sal_Int32 nDestId = mParaInts.front();
                mParaInts.pop_front();
                OSL_ENSURE( mFutureDestinations.find( nDestId ) != mFutureDestinations.end(),
                    "GlobalSyncData::PlayGlobalActions: DescribeRegisteredRequest has not been called for that destination!" );

                PDFLinkDestination& rDest = mFutureDestinations[ nDestId ];

                rWriter.Push( PUSH_MAPMODE );
				rWriter.SetMapMode( rDest.mMapMode );
				mParaIds.push_back( rWriter.RegisterDestReference( nDestId, rDest.mRect, rDest.mPageNr, rDest.mAreaType ) );
				rWriter.Pop();
            }
            break;
			case PDFExtOutDevDataSync::CreateOutlineItem :
			{
				sal_Int32 nParent = GetMappedId();
				sal_Int32 nLinkId = GetMappedId();
				mParaIds.push_back( rWriter.CreateOutlineItem( nParent, mParaOUStrings.front(), nLinkId ) );
				mParaOUStrings.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetOutlineItemParent :
			{
				sal_Int32 nItem = GetMappedId();
				sal_Int32 nNewParent = GetMappedId();
				rWriter.SetOutlineItemParent( nItem, nNewParent );
			}
			break;
			case PDFExtOutDevDataSync::SetOutlineItemText :
			{
				sal_Int32 nItem = GetMappedId();
				rWriter.SetOutlineItemText( nItem, mParaOUStrings.front() );
				mParaOUStrings.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetOutlineItemDest :
			{
				sal_Int32 nItem = GetMappedId();
				sal_Int32 nDestId = GetMappedId();
				rWriter.SetOutlineItemDest( nItem, nDestId );
			}
			break;
			case PDFExtOutDevDataSync::CreateNote :
			{
				rWriter.Push( PUSH_MAPMODE );
				rWriter.SetMapMode( mParaMapModes.front() );
				rWriter.CreateNote( mParaRects.front(), mParaPDFNotes.front(), mParaInts.front() );
				mParaMapModes.pop_front();
				mParaRects.pop_front();
				mParaPDFNotes.pop_front();
				mParaInts.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetAutoAdvanceTime :
			{
				rWriter.SetAutoAdvanceTime( mParauInts.front(), mParaInts.front() );
				mParauInts.pop_front();
				mParaInts.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetPageTransition :
			{
				rWriter.SetPageTransition( mParaPageTransitions.front(), mParauInts.front(), mParaInts.front() );
				mParaPageTransitions.pop_front();
				mParauInts.pop_front();
				mParaInts.pop_front();
			}
			break;
            case PDFExtOutDevDataSync::BeginStructureElement:
            case PDFExtOutDevDataSync::EndStructureElement:
            case PDFExtOutDevDataSync::SetCurrentStructureElement:
            case PDFExtOutDevDataSync::SetStructureAttribute:
            case PDFExtOutDevDataSync::SetStructureAttributeNumerical:
            case PDFExtOutDevDataSync::SetStructureBoundingBox:
            case PDFExtOutDevDataSync::SetActualText:
            case PDFExtOutDevDataSync::SetAlternateText:
            case PDFExtOutDevDataSync::CreateControl:
            case PDFExtOutDevDataSync::BeginGroup:
            case PDFExtOutDevDataSync::EndGroup:
            case PDFExtOutDevDataSync::EndGroupGfxLink:
                break;
		}
		aIter++;
	}
}

struct PageSyncData
{
	std::deque< PDFExtOutDevDataSync >				mActions;
	std::deque< Rectangle >							mParaRects;
	std::deque< sal_Int32 >							mParaInts;
	std::deque< rtl::OUString >						mParaOUStrings;
	std::deque< PDFWriter::StructElement >			mParaStructElements;
	std::deque< PDFWriter::StructAttribute >		mParaStructAttributes;
	std::deque< PDFWriter::StructAttributeValue >	mParaStructAttributeValues;
	std::deque< Graphic >							mGraphics;
    std::deque< ::boost::shared_ptr< PDFWriter::AnyWidget > >
                                                    mControls;
    GlobalSyncData*									mpGlobalData;

	sal_Bool										mbGroupIgnoreGDIMtfActions;

	PageSyncData( GlobalSyncData* pGlobal ) : mbGroupIgnoreGDIMtfActions ( sal_False ) { mpGlobalData = pGlobal; }

	void PushAction( const OutputDevice& rOutDev, const PDFExtOutDevDataSync::Action eAct );
	sal_Bool PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rCurGDIMtfAction, const PDFExtOutDevData& rOutDevData );
};
void PageSyncData::PushAction( const OutputDevice& rOutDev, const PDFExtOutDevDataSync::Action eAct )
{
	GDIMetaFile* pMtf = rOutDev.GetConnectMetaFile();
	DBG_ASSERT( pMtf, "PageSyncData::PushAction -> no ConnectMetaFile !!!" );

	PDFExtOutDevDataSync aSync;
	aSync.eAct = eAct;
	if ( pMtf )
		aSync.nIdx = pMtf->GetActionCount();
	else
		aSync.nIdx = 0x7fffffff;	// sync not possible
	mActions.push_back( aSync );
}
sal_Bool PageSyncData::PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rCurGDIMtfAction, const PDFExtOutDevData& rOutDevData )
{
	sal_Bool bRet = sal_False;
	if ( mActions.size() && ( mActions.front().nIdx == rCurGDIMtfAction ) )
	{
		bRet = sal_True;
		PDFExtOutDevDataSync aDataSync = mActions.front();
		mActions.pop_front();
		switch( aDataSync.eAct )
		{
			case PDFExtOutDevDataSync::BeginStructureElement :
			{
                sal_Int32 nNewEl = rWriter.BeginStructureElement( mParaStructElements.front(), mParaOUStrings.front() ) ;
				mParaStructElements.pop_front();
                mParaOUStrings.pop_front();
				mpGlobalData->mStructIdMap.push_back( nNewEl );
			}
			break;
			case PDFExtOutDevDataSync::EndStructureElement :
			{
				rWriter.EndStructureElement();
			}
			break;
            case PDFExtOutDevDataSync::SetCurrentStructureElement:
            {
                rWriter.SetCurrentStructureElement( mpGlobalData->GetMappedStructId( mParaInts.front() ) );
                mParaInts.pop_front();
            }
            break;
			case PDFExtOutDevDataSync::SetStructureAttribute :
			{
				rWriter.SetStructureAttribute( mParaStructAttributes.front(), mParaStructAttributeValues.front() );
				mParaStructAttributeValues.pop_front();
				mParaStructAttributes.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetStructureAttributeNumerical :
			{
				rWriter.SetStructureAttributeNumerical( mParaStructAttributes.front(), mParaInts.front() );
				mParaStructAttributes.pop_front();
				mParaInts.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetStructureBoundingBox :
			{
				rWriter.SetStructureBoundingBox( mParaRects.front() );
				mParaRects.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetActualText :
			{
				rWriter.SetActualText( mParaOUStrings.front() );
				mParaOUStrings.pop_front();
			}
			break;
			case PDFExtOutDevDataSync::SetAlternateText :
			{
				rWriter.SetAlternateText( mParaOUStrings.front() );
				mParaOUStrings.pop_front();
			}
			break;
            case PDFExtOutDevDataSync::CreateControl:
            {
                ::boost::shared_ptr< PDFWriter::AnyWidget > pControl( mControls.front() );
                DBG_ASSERT( pControl.get(), "PageSyncData::PlaySyncPageAct: invalid widget!" );
                if ( pControl.get() )
                    rWriter.CreateControl( *pControl );
				mControls.pop_front();
            }
            break;
			case PDFExtOutDevDataSync::BeginGroup :
			{
				/* first determining if this BeginGroup is starting a GfxLink, 
				   by searching for a EndGroup or a EndGroupGfxLink */
				mbGroupIgnoreGDIMtfActions = sal_False;
				std::deque< PDFExtOutDevDataSync >::iterator aBeg = mActions.begin();
				std::deque< PDFExtOutDevDataSync >::iterator aEnd = mActions.end();
				while ( aBeg != aEnd )
				{
					if ( aBeg->eAct == PDFExtOutDevDataSync::EndGroup )
					{
						break;
					}
					else if ( aBeg->eAct == PDFExtOutDevDataSync::EndGroupGfxLink )
					{
						if ( rOutDevData.GetIsLosslessCompression() && !rOutDevData.GetIsReduceImageResolution() )
						{
							Graphic& rGraphic = mGraphics.front();
							if ( rGraphic.IsLink() && rGraphic.GetLink().GetType() == GFX_LINK_TYPE_NATIVE_JPG )
							{
								mbGroupIgnoreGDIMtfActions = sal_True;
							}
						}
						break;
					}
					aBeg++;
				}
			}
			break;
			case PDFExtOutDevDataSync::EndGroup :
			{
				mbGroupIgnoreGDIMtfActions = sal_False;
			}
			break;
			case PDFExtOutDevDataSync::EndGroupGfxLink :
			{
                sal_Int32 nTransparency;
                Rectangle aOutputRect, aVisibleOutputRect;
                Graphic   aGraphic( mGraphics.front() );

                mGraphics.pop_front();
                nTransparency = mParaInts.front();
                mParaInts.pop_front();
                aOutputRect = mParaRects.front();
                mParaRects.pop_front();
                aVisibleOutputRect = mParaRects.front();
                mParaRects.pop_front();

				if ( mbGroupIgnoreGDIMtfActions )
				{
					sal_Bool bClippingNeeded = ( aOutputRect != aVisibleOutputRect ) && !aVisibleOutputRect.IsEmpty();

					GfxLink	  aGfxLink( aGraphic.GetLink() );
					if ( aGfxLink.GetType() == GFX_LINK_TYPE_NATIVE_JPG )
					{
						if ( bClippingNeeded )
						{
							rWriter.Push();
                            basegfx::B2DPolyPolygon aRect( basegfx::tools::createPolygonFromRect(
                                basegfx::B2DRectangle( aVisibleOutputRect.Left(), aVisibleOutputRect.Top(),
                                                       aVisibleOutputRect.Right(), aVisibleOutputRect.Bottom() ) ) );
							rWriter.SetClipRegion( aRect);
						}
						Bitmap aMask;
						SvMemoryStream aTmp;
                        const sal_uInt8* pData = aGfxLink.GetData();
                        sal_uInt32 nBytes = aGfxLink.GetDataSize();
                        if( pData && nBytes )
                        {
                            aTmp.Write( pData, nBytes );
                            rWriter.DrawJPGBitmap( aTmp, aGraphic.GetBitmap().GetBitCount() > 8, aGraphic.GetSizePixel(), aOutputRect, aMask );
                        }

						if ( bClippingNeeded )
							rWriter.Pop();
					}
					mbGroupIgnoreGDIMtfActions = sal_False;
				}
			}
			break;
            case PDFExtOutDevDataSync::CreateNamedDest:
            case PDFExtOutDevDataSync::CreateDest:
            case PDFExtOutDevDataSync::CreateLink:
            case PDFExtOutDevDataSync::SetLinkDest:
            case PDFExtOutDevDataSync::SetLinkURL:
            case PDFExtOutDevDataSync::RegisterDest:
            case PDFExtOutDevDataSync::CreateOutlineItem:
            case PDFExtOutDevDataSync::SetOutlineItemParent:
            case PDFExtOutDevDataSync::SetOutlineItemText:
            case PDFExtOutDevDataSync::SetOutlineItemDest:
            case PDFExtOutDevDataSync::CreateNote:
            case PDFExtOutDevDataSync::SetAutoAdvanceTime:
            case PDFExtOutDevDataSync::SetPageTransition:
                break;
		}
	}
	else if ( mbGroupIgnoreGDIMtfActions )
	{
		rCurGDIMtfAction++;
		bRet = sal_True;
	}
	return bRet;
}

TYPEINIT1(PDFExtOutDevData,ExtOutDevData);
PDFExtOutDevData::PDFExtOutDevData( const OutputDevice& rOutDev ) :
	mrOutDev				( rOutDev ),
	mbTaggedPDF				( sal_False ),
	mbExportNotes			( sal_True ),
	mbExportNotesPages		( sal_False ),
	mbTransitionEffects		( sal_True ),
	mbUseLosslessCompression( sal_True ),
	mbReduceImageResolution	( sal_False ),
    mbExportNDests          ( sal_False ),
	mnFormsFormat			( 0 ),
	mnPage					( -1 ),
	mpPageSyncData			( NULL ),
	mpGlobalSyncData		( new GlobalSyncData() )
{
    mpPageSyncData = new PageSyncData( mpGlobalSyncData );
}

PDFExtOutDevData::~PDFExtOutDevData()
{
	delete mpPageSyncData;
	delete mpGlobalSyncData;
}

const com::sun::star::lang::Locale& PDFExtOutDevData::GetDocumentLocale() const
{
    return maDocLocale;
}
void PDFExtOutDevData::SetDocumentLocale( const com::sun::star::lang::Locale& rLoc )
{
    maDocLocale = rLoc;
}
sal_Int32 PDFExtOutDevData::GetCurrentPageNumber() const
{
	return mnPage;
}
void PDFExtOutDevData::SetCurrentPageNumber( const sal_Int32 nPage )
{
	mnPage = nPage;
}
sal_Bool PDFExtOutDevData::GetIsLosslessCompression() const
{
	return mbUseLosslessCompression;
}
void PDFExtOutDevData::SetIsLosslessCompression( const sal_Bool bUseLosslessCompression )
{
	mbUseLosslessCompression = bUseLosslessCompression;
}
sal_Bool PDFExtOutDevData::GetIsReduceImageResolution() const
{
	return mbReduceImageResolution;
}
void PDFExtOutDevData::SetIsReduceImageResolution( const sal_Bool bReduceImageResolution )
{
	mbReduceImageResolution = bReduceImageResolution;
}
sal_Bool PDFExtOutDevData::GetIsExportNotes() const
{
	return mbExportNotes;
}
void PDFExtOutDevData::SetIsExportNotes( const sal_Bool bExportNotes )
{
	mbExportNotes = bExportNotes;
}
sal_Bool PDFExtOutDevData::GetIsExportNotesPages() const
{
	return mbExportNotesPages;
}
void PDFExtOutDevData::SetIsExportNotesPages( const sal_Bool bExportNotesPages )
{
	mbExportNotesPages = bExportNotesPages;
}
sal_Bool PDFExtOutDevData::GetIsExportTaggedPDF() const
{
	return mbTaggedPDF;
}
void PDFExtOutDevData::SetIsExportTaggedPDF( const sal_Bool bTaggedPDF )
{
	mbTaggedPDF = bTaggedPDF;
}
sal_Bool PDFExtOutDevData::GetIsExportTransitionEffects() const
{
	return mbTransitionEffects;
}
void PDFExtOutDevData::SetIsExportTransitionEffects( const sal_Bool bTransitionEffects )
{
	mbTransitionEffects = bTransitionEffects;
}
sal_Bool PDFExtOutDevData::GetIsExportFormFields() const
{
    return mbExportFormFields;
}
void PDFExtOutDevData::SetIsExportFormFields( const sal_Bool bExportFomtFields )
{
    mbExportFormFields = bExportFomtFields;
}
sal_Int32 PDFExtOutDevData::GetFormsFormat() const
{
	return mnFormsFormat;
}
void PDFExtOutDevData::SetFormsFormat( const sal_Int32 nFormsFormat )
{
	mnFormsFormat = nFormsFormat;
}
sal_Bool PDFExtOutDevData::GetIsExportBookmarks() const
{
    return mbExportBookmarks;
}
void PDFExtOutDevData::SetIsExportBookmarks( const sal_Bool bExportBookmarks )
{
    mbExportBookmarks = bExportBookmarks;
}
std::vector< PDFExtOutDevBookmarkEntry >& PDFExtOutDevData::GetBookmarks()
{
	return maBookmarks;
}
sal_Bool PDFExtOutDevData::GetIsExportNamedDestinations() const
{
    return mbExportNDests;
}
void PDFExtOutDevData::SetIsExportNamedDestinations( const sal_Bool bExportNDests )
{
    mbExportNDests = bExportNDests;
}
void PDFExtOutDevData::ResetSyncData()
{
	*mpPageSyncData = PageSyncData( mpGlobalSyncData );
}
sal_Bool PDFExtOutDevData::PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rIdx )
{
	return mpPageSyncData->PlaySyncPageAct( rWriter, rIdx, *this );
}
void PDFExtOutDevData::PlayGlobalActions( PDFWriter& rWriter )
{
	mpGlobalSyncData->PlayGlobalActions( rWriter );
}

/* global actions, syncronisation to the recorded metafile isn't needed,
   all actions will be played after the last page was recorded
*/
//--->i56629
sal_Int32 PDFExtOutDevData::CreateNamedDest(const String& sDestName,  const Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType )
{
    mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateNamedDest );    
    mpGlobalSyncData->mParaOUStrings.push_back( sDestName );
    mpGlobalSyncData->mParaRects.push_back( rRect );
    mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
    mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
    mpGlobalSyncData->mParaDestAreaTypes.push_back( eType );

    return mpGlobalSyncData->mCurId++;
}
//<---i56629
sal_Int32 PDFExtOutDevData::RegisterDest()
{
    const sal_Int32 nLinkDestID = mpGlobalSyncData->mCurId++;
    mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::RegisterDest );
    mpGlobalSyncData->mParaInts.push_back( nLinkDestID );

    return nLinkDestID;
}
void PDFExtOutDevData::DescribeRegisteredDest( sal_Int32 nDestId, const Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType )
{
    OSL_PRECOND( nDestId != -1, "PDFExtOutDevData::DescribeRegisteredDest: invalid destination Id!" );
    PDFLinkDestination aLinkDestination;
    aLinkDestination.mRect = rRect;
    aLinkDestination.mMapMode = mrOutDev.GetMapMode();
    aLinkDestination.mPageNr = nPageNr == -1 ? mnPage : nPageNr;
    aLinkDestination.mAreaType = eType;
    mpGlobalSyncData->mFutureDestinations[ nDestId ] = aLinkDestination;
}
sal_Int32 PDFExtOutDevData::CreateDest( const Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateDest );
	mpGlobalSyncData->mParaRects.push_back( rRect );
	mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
	mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
	mpGlobalSyncData->mParaDestAreaTypes.push_back( eType );
	return mpGlobalSyncData->mCurId++;
}
sal_Int32 PDFExtOutDevData::CreateLink( const Rectangle& rRect, sal_Int32 nPageNr )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateLink );
	mpGlobalSyncData->mParaRects.push_back( rRect );
	mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
	mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
	return mpGlobalSyncData->mCurId++;
}
sal_Int32 PDFExtOutDevData::SetLinkDest( sal_Int32 nLinkId, sal_Int32 nDestId )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetLinkDest );
	mpGlobalSyncData->mParaInts.push_back( nLinkId );
	mpGlobalSyncData->mParaInts.push_back( nDestId );
	return 0;
}
sal_Int32 PDFExtOutDevData::SetLinkURL( sal_Int32 nLinkId, const rtl::OUString& rURL )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetLinkURL );
	mpGlobalSyncData->mParaInts.push_back( nLinkId );
	mpGlobalSyncData->mParaOUStrings.push_back( rURL );
	return 0;
}
sal_Int32 PDFExtOutDevData::CreateOutlineItem( sal_Int32 nParent, const rtl::OUString& rText, sal_Int32 nDestID )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateOutlineItem );
	mpGlobalSyncData->mParaInts.push_back( nParent );
	mpGlobalSyncData->mParaOUStrings.push_back( rText );
	mpGlobalSyncData->mParaInts.push_back( nDestID );
	return mpGlobalSyncData->mCurId++;
}
sal_Int32 PDFExtOutDevData::SetOutlineItemParent( sal_Int32 nItem, sal_Int32 nNewParent )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetOutlineItemParent );
	mpGlobalSyncData->mParaInts.push_back( nItem );
	mpGlobalSyncData->mParaInts.push_back( nNewParent );
	return 0;
}
sal_Int32 PDFExtOutDevData::SetOutlineItemText( sal_Int32 nItem, const rtl::OUString& rText )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetOutlineItemText );
	mpGlobalSyncData->mParaInts.push_back( nItem );
	mpGlobalSyncData->mParaOUStrings.push_back( rText );
	return 0;
}
sal_Int32 PDFExtOutDevData::SetOutlineItemDest( sal_Int32 nItem, sal_Int32 nDestID )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetOutlineItemDest );
	mpGlobalSyncData->mParaInts.push_back( nItem );
	mpGlobalSyncData->mParaInts.push_back( nDestID );
	return 0;
}
void PDFExtOutDevData::CreateNote( const Rectangle& rRect, const PDFNote& rNote, sal_Int32 nPageNr )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::CreateNote );
	mpGlobalSyncData->mParaRects.push_back( rRect );
	mpGlobalSyncData->mParaMapModes.push_back( mrOutDev.GetMapMode() );
	mpGlobalSyncData->mParaPDFNotes.push_back( rNote );
	mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
}
void PDFExtOutDevData::SetAutoAdvanceTime( sal_uInt32 nSeconds, sal_Int32 nPageNr )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetAutoAdvanceTime );
	mpGlobalSyncData->mParauInts.push_back( nSeconds );
	mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
}
void PDFExtOutDevData::SetPageTransition( PDFWriter::PageTransition eType, sal_uInt32 nMilliSec, sal_Int32 nPageNr )
{
	mpGlobalSyncData->mActions.push_back( PDFExtOutDevDataSync::SetPageTransition );
	mpGlobalSyncData->mParaPageTransitions.push_back( eType );
	mpGlobalSyncData->mParauInts.push_back( nMilliSec );
	mpGlobalSyncData->mParaInts.push_back( nPageNr == -1 ? mnPage : nPageNr );
}

/* local (page), actions have to be played synchroniously to the actions of
   of the recorded metafile (created by each xRenderable->render()) */
   sal_Int32 PDFExtOutDevData::BeginStructureElement( PDFWriter::StructElement eType, const rtl::OUString& rAlias )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::BeginStructureElement );
	mpPageSyncData->mParaStructElements.push_back( eType );
    mpPageSyncData->mParaOUStrings.push_back( rAlias );
    // need a global id
    sal_Int32 nNewId = mpGlobalSyncData->mStructParents.size();
    mpGlobalSyncData->mStructParents.push_back( mpGlobalSyncData->mCurrentStructElement );
    mpGlobalSyncData->mCurrentStructElement = nNewId;
    return nNewId;
}
void PDFExtOutDevData::EndStructureElement()
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::EndStructureElement );
    mpGlobalSyncData->mCurrentStructElement = mpGlobalSyncData->mStructParents[ mpGlobalSyncData->mCurrentStructElement ];
}
bool PDFExtOutDevData::SetCurrentStructureElement( sal_Int32 nStructId )
{
    bool bSuccess = false;
    if( sal_uInt32(nStructId) < mpGlobalSyncData->mStructParents.size() )
    {
        mpGlobalSyncData->mCurrentStructElement = nStructId;
        mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetCurrentStructureElement );
        mpPageSyncData->mParaInts.push_back( nStructId );
        bSuccess = true;
    }
    return bSuccess;
}
sal_Int32 PDFExtOutDevData::GetCurrentStructureElement()
{
    return mpGlobalSyncData->mCurrentStructElement;
}
bool PDFExtOutDevData::SetStructureAttribute( PDFWriter::StructAttribute eAttr, PDFWriter::StructAttributeValue eVal )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureAttribute );
	mpPageSyncData->mParaStructAttributes.push_back( eAttr );
	mpPageSyncData->mParaStructAttributeValues.push_back( eVal );
	return true;
}
bool PDFExtOutDevData::SetStructureAttributeNumerical( PDFWriter::StructAttribute eAttr, sal_Int32 nValue )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureAttributeNumerical );
	mpPageSyncData->mParaStructAttributes.push_back( eAttr );
	mpPageSyncData->mParaInts.push_back( nValue );
	return true;
}
void PDFExtOutDevData::SetStructureBoundingBox( const Rectangle& rRect )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetStructureBoundingBox );
	mpPageSyncData->mParaRects.push_back( rRect );
}
void PDFExtOutDevData::SetActualText( const String& rText )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetActualText );
	mpPageSyncData->mParaOUStrings.push_back( rText );
}
void PDFExtOutDevData::SetAlternateText( const String& rText )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::SetAlternateText );
	mpPageSyncData->mParaOUStrings.push_back( rText );
}

void PDFExtOutDevData::CreateControl( const PDFWriter::AnyWidget& rControlType, sal_Int32 /*nPageNr*/ )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::CreateControl );

    ::boost::shared_ptr< PDFWriter::AnyWidget > pClone( rControlType.Clone() );
    mpPageSyncData->mControls.push_back( pClone );
}

void PDFExtOutDevData::BeginGroup()
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::BeginGroup );
}

void PDFExtOutDevData::EndGroup()
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::EndGroup );
}
void PDFExtOutDevData::EndGroup( const Graphic& 	rGraphic,
                                 sal_uInt8				nTransparency,
                                 const Rectangle& 	rOutputRect,
                                 const Rectangle& 	rVisibleOutputRect )
{
	mpPageSyncData->PushAction( mrOutDev, PDFExtOutDevDataSync::EndGroupGfxLink );
	mpPageSyncData->mGraphics.push_back( rGraphic );
	mpPageSyncData->mParaInts.push_back( nTransparency );
	mpPageSyncData->mParaRects.push_back( rOutputRect );
	mpPageSyncData->mParaRects.push_back( rVisibleOutputRect );
}

}