3040 lines
115 KiB
C++
3040 lines
115 KiB
C++
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2008 by Sun Microsystems, Inc.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: unomodel.cxx,v $
|
|
* $Revision: 1.114 $
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_sd.hxx"
|
|
|
|
#include <com/sun/star/presentation/XPresentation2.hpp>
|
|
|
|
#include <com/sun/star/lang/DisposedException.hpp>
|
|
#include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
|
|
#include <com/sun/star/lang/Locale.hpp>
|
|
#include <com/sun/star/style/XStyle.hpp>
|
|
#include <com/sun/star/awt/XDevice.hpp>
|
|
|
|
#include <com/sun/star/embed/Aspects.hpp>
|
|
#include <com/sun/star/presentation/XPresentation2.hpp>
|
|
|
|
#include <osl/mutex.hxx>
|
|
|
|
#include <comphelper/sequence.hxx>
|
|
|
|
#include <rtl/uuid.h>
|
|
#include <rtl/memory.h>
|
|
#include <svx/unofield.hxx>
|
|
#include <unomodel.hxx>
|
|
#include <sfx2/dispatch.hxx>
|
|
#include <sfx2/bindings.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <svx/UnoForbiddenCharsTable.hxx>
|
|
#include <svx/svdoutl.hxx>
|
|
#include <svx/forbiddencharacterstable.hxx>
|
|
#include <svx/UnoNamespaceMap.hxx>
|
|
#include <svx/svdlayer.hxx>
|
|
#include <svx/svdsob.hxx>
|
|
#include <svx/unoapi.hxx>
|
|
#include <svx/unofill.hxx>
|
|
#include <svx/unopool.hxx>
|
|
#include <svx/svdorect.hxx>
|
|
#include <vos/mutex.hxx>
|
|
#include <toolkit/awt/vclxdevice.hxx>
|
|
#include <svx/svdpool.hxx>
|
|
#include <svx/unolingu.hxx>
|
|
#include <svx/svdpagv.hxx>
|
|
#include <svtools/unoimap.hxx>
|
|
#include <svx/unoshape.hxx>
|
|
#include <svx/unonrule.hxx>
|
|
#include <svx/eeitem.hxx>
|
|
|
|
// #99870# Support creation of GraphicObjectResolver and EmbeddedObjectResolver
|
|
#include <svx/xmleohlp.hxx>
|
|
#include <svx/xmlgrhlp.hxx>
|
|
#include "DrawDocShell.hxx"
|
|
#include "ViewShellBase.hxx"
|
|
#include <UnoDocumentSettings.hxx>
|
|
|
|
#include <drawdoc.hxx>
|
|
#include <glob.hrc>
|
|
#include <sdresid.hxx>
|
|
#include <sdpage.hxx>
|
|
|
|
#include <strings.hrc>
|
|
#include "unohelp.hxx"
|
|
#include <unolayer.hxx>
|
|
#include <unoprnms.hxx>
|
|
#include <unopage.hxx>
|
|
#include <unocpres.hxx>
|
|
#include <unoobj.hxx>
|
|
#include <stlpool.hxx>
|
|
#include <unopback.hxx>
|
|
#include <unokywds.hxx>
|
|
#include "FrameView.hxx"
|
|
#include "ClientView.hxx"
|
|
#include "ViewShell.hxx"
|
|
#include "app.hrc"
|
|
#include <vcl/pdfextoutdevdata.hxx>
|
|
#include <com/sun/star/presentation/AnimationEffect.hpp>
|
|
#include <com/sun/star/presentation/AnimationSpeed.hpp>
|
|
#include <com/sun/star/presentation/ClickAction.hpp>
|
|
#include <tools/urlobj.hxx>
|
|
#include <svx/sdr/contact/viewobjectcontact.hxx>
|
|
#include <svx/sdr/contact/viewcontact.hxx>
|
|
#include <svx/sdr/contact/displayinfo.hxx>
|
|
|
|
using ::rtl::OUString;
|
|
|
|
#include <drawinglayer/primitive2d/structuretagprimitive2d.hxx>
|
|
|
|
using namespace ::osl;
|
|
using namespace ::vos;
|
|
using namespace ::cppu;
|
|
using namespace ::com::sun::star;
|
|
|
|
extern uno::Reference< uno::XInterface > SdUnoCreatePool( SdDrawDocument* pDrawModel );
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
class SdUnoForbiddenCharsTable : public SvxUnoForbiddenCharsTable,
|
|
public SfxListener
|
|
{
|
|
public:
|
|
SdUnoForbiddenCharsTable( SdrModel* pModel );
|
|
~SdUnoForbiddenCharsTable();
|
|
|
|
// SfxListener
|
|
virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) throw ();
|
|
protected:
|
|
virtual void onChange();
|
|
|
|
private:
|
|
SdrModel* mpModel;
|
|
};
|
|
|
|
SdUnoForbiddenCharsTable::SdUnoForbiddenCharsTable( SdrModel* pModel )
|
|
: SvxUnoForbiddenCharsTable( pModel->GetForbiddenCharsTable() ), mpModel( pModel )
|
|
{
|
|
StartListening( *pModel );
|
|
}
|
|
|
|
void SdUnoForbiddenCharsTable::onChange()
|
|
{
|
|
if( mpModel )
|
|
{
|
|
mpModel->ReformatAllTextObjects();
|
|
}
|
|
}
|
|
|
|
SdUnoForbiddenCharsTable::~SdUnoForbiddenCharsTable()
|
|
{
|
|
if( mpModel )
|
|
EndListening( *mpModel );
|
|
}
|
|
|
|
void SdUnoForbiddenCharsTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
|
|
{
|
|
const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
|
|
|
|
if( pSdrHint )
|
|
{
|
|
if( HINT_MODELCLEARED == pSdrHint->GetKind() )
|
|
{
|
|
mpModel = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
const sal_Int32 WID_MODEL_LANGUAGE = 1;
|
|
const sal_Int32 WID_MODEL_TABSTOP = 2;
|
|
const sal_Int32 WID_MODEL_VISAREA = 3;
|
|
const sal_Int32 WID_MODEL_MAPUNIT = 4;
|
|
const sal_Int32 WID_MODEL_FORBCHARS= 5;
|
|
const sal_Int32 WID_MODEL_CONTFOCUS = 6;
|
|
const sal_Int32 WID_MODEL_DSGNMODE = 7;
|
|
const sal_Int32 WID_MODEL_BASICLIBS = 8;
|
|
const sal_Int32 WID_MODEL_RUNTIMEUID = 9;
|
|
const sal_Int32 WID_MODEL_BUILDID = 10;
|
|
const sal_Int32 WID_MODEL_HASVALIDSIGNATURES = 11;
|
|
const sal_Int32 WID_MODEL_DIALOGLIBS = 12;
|
|
|
|
const SvxItemPropertySet* ImplGetDrawModelPropertySet()
|
|
{
|
|
// Achtung: Der erste Parameter MUSS sortiert vorliegen !!!
|
|
const static SfxItemPropertyMapEntry aDrawModelPropertyMap_Impl[] =
|
|
{
|
|
{ MAP_CHAR_LEN("BuildId"), WID_MODEL_BUILDID, &::getCppuType(static_cast< const rtl::OUString * >(0)), 0, 0},
|
|
{ MAP_CHAR_LEN(sUNO_Prop_CharLocale), WID_MODEL_LANGUAGE, &::getCppuType((const lang::Locale*)0), 0, 0},
|
|
{ MAP_CHAR_LEN(sUNO_Prop_TabStop), WID_MODEL_TABSTOP, &::getCppuType((const sal_Int32*)0), 0, 0},
|
|
{ MAP_CHAR_LEN(sUNO_Prop_VisibleArea), WID_MODEL_VISAREA, &::getCppuType((const awt::Rectangle*)0), 0, 0},
|
|
{ MAP_CHAR_LEN(sUNO_Prop_MapUnit), WID_MODEL_MAPUNIT, &::getCppuType((const sal_Int16*)0), beans::PropertyAttribute::READONLY, 0},
|
|
{ MAP_CHAR_LEN(sUNO_Prop_ForbiddenCharacters), WID_MODEL_FORBCHARS,&::getCppuType((const uno::Reference< i18n::XForbiddenCharacters > *)0), beans::PropertyAttribute::READONLY, 0 },
|
|
{ MAP_CHAR_LEN(sUNO_Prop_AutomContFocus ), WID_MODEL_CONTFOCUS, &::getBooleanCppuType(), 0, 0},
|
|
{ MAP_CHAR_LEN(sUNO_Prop_ApplyFrmDsgnMode), WID_MODEL_DSGNMODE, &::getBooleanCppuType(), 0, 0},
|
|
{ MAP_CHAR_LEN("BasicLibraries"), WID_MODEL_BASICLIBS,&::getCppuType((const uno::Reference< script::XLibraryContainer > *)0), beans::PropertyAttribute::READONLY, 0 },
|
|
{ MAP_CHAR_LEN("DialogLibraries"), WID_MODEL_DIALOGLIBS, &::getCppuType((const uno::Reference< script::XLibraryContainer > *)0), beans::PropertyAttribute::READONLY, 0 },
|
|
{ MAP_CHAR_LEN(sUNO_Prop_RuntimeUID), WID_MODEL_RUNTIMEUID, &::getCppuType(static_cast< const rtl::OUString * >(0)), beans::PropertyAttribute::READONLY, 0 },
|
|
{ MAP_CHAR_LEN(sUNO_Prop_HasValidSignatures), WID_MODEL_HASVALIDSIGNATURES, &::getCppuType(static_cast< const sal_Bool * >(0)), beans::PropertyAttribute::READONLY, 0 },
|
|
{ 0,0,0,0,0,0 }
|
|
};
|
|
static SvxItemPropertySet aDrawModelPropertySet_Impl( aDrawModelPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
|
|
return &aDrawModelPropertySet_Impl;
|
|
}
|
|
|
|
// this ctor is used from the DocShell
|
|
SdXImpressDocument::SdXImpressDocument (::sd::DrawDocShell* pShell, bool bClipBoard ) throw()
|
|
: SfxBaseModel( pShell ),
|
|
mpDocShell( pShell ),
|
|
mpDoc( pShell ? pShell->GetDoc() : NULL ),
|
|
mbDisposed(false),
|
|
mbImpressDoc( pShell && pShell->GetDoc() && pShell->GetDoc()->GetDocumentType() == DOCUMENT_TYPE_IMPRESS ),
|
|
mbClipBoard( bClipBoard ),
|
|
mpPropSet( ImplGetDrawModelPropertySet() )
|
|
{
|
|
if( mpDoc )
|
|
{
|
|
StartListening( *mpDoc );
|
|
}
|
|
else
|
|
{
|
|
DBG_ERROR("DocShell is invalid");
|
|
}
|
|
}
|
|
|
|
SdXImpressDocument::SdXImpressDocument( SdDrawDocument* pDoc, bool bClipBoard ) throw()
|
|
: SfxBaseModel( NULL ),
|
|
mpDocShell( NULL ),
|
|
mpDoc( pDoc ),
|
|
mbDisposed(false),
|
|
mbImpressDoc( pDoc && pDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS ),
|
|
mbClipBoard( bClipBoard ),
|
|
mpPropSet( ImplGetDrawModelPropertySet() )
|
|
{
|
|
if( mpDoc )
|
|
{
|
|
StartListening( *mpDoc );
|
|
}
|
|
else
|
|
{
|
|
DBG_ERROR("SdDrawDocument is invalid");
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* *
|
|
***********************************************************************/
|
|
SdXImpressDocument::~SdXImpressDocument() throw()
|
|
{
|
|
}
|
|
|
|
// uno helper
|
|
|
|
|
|
/******************************************************************************
|
|
* Erzeugt anhand der uebergebennen SdPage eine SdDrawPage. Wurde fuer diese *
|
|
* SdPage bereits eine SdDrawPage erzeugt, wird keine neue SdDrawPage erzeug. *
|
|
******************************************************************************/
|
|
/*
|
|
uno::Reference< drawing::XDrawPage > SdXImpressDocument::CreateXDrawPage( SdPage* pPage ) throw()
|
|
{
|
|
DBG_ASSERT(pPage,"SdXImpressDocument::CreateXDrawPage( NULL? )");
|
|
|
|
uno::Reference< drawing::XDrawPage > xDrawPage;
|
|
|
|
if(pPage)
|
|
{
|
|
xDrawPage = SvxDrawPage::GetPageForSdrPage(pPage);
|
|
|
|
if(!xDrawPage.is())
|
|
{
|
|
if(pPage->IsMasterPage())
|
|
{
|
|
xDrawPage = (presentation::XPresentationPage*)new SdMasterPage( this, pPage );
|
|
}
|
|
else
|
|
{
|
|
xDrawPage = (SvxDrawPage*)new SdDrawPage( this, pPage );
|
|
}
|
|
}
|
|
}
|
|
|
|
return xDrawPage;
|
|
}
|
|
*/
|
|
|
|
// XInterface
|
|
uno::Any SAL_CALL SdXImpressDocument::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException)
|
|
{
|
|
uno::Any aAny;
|
|
|
|
QUERYINT(lang::XServiceInfo);
|
|
else QUERYINT(beans::XPropertySet);
|
|
else QUERYINT(lang::XMultiServiceFactory);
|
|
else QUERYINT(drawing::XDrawPageDuplicator);
|
|
else QUERYINT(drawing::XLayerSupplier);
|
|
else QUERYINT(drawing::XMasterPagesSupplier);
|
|
else QUERYINT(drawing::XDrawPagesSupplier);
|
|
else QUERYINT(presentation::XHandoutMasterSupplier);
|
|
else QUERYINT(document::XLinkTargetSupplier);
|
|
else QUERYINT(style::XStyleFamiliesSupplier);
|
|
else QUERYINT(com::sun::star::ucb::XAnyCompareFactory);
|
|
else QUERYINT(view::XRenderable);
|
|
else if( mbImpressDoc && rType == ITYPE(presentation::XPresentationSupplier) )
|
|
aAny <<= uno::Reference< presentation::XPresentationSupplier >(this);
|
|
else if( mbImpressDoc && rType == ITYPE(presentation::XCustomPresentationSupplier) )
|
|
aAny <<= uno::Reference< presentation::XCustomPresentationSupplier >(this);
|
|
else
|
|
return SfxBaseModel::queryInterface( rType );
|
|
|
|
return aAny;
|
|
}
|
|
|
|
void SAL_CALL SdXImpressDocument::acquire() throw ( )
|
|
{
|
|
SfxBaseModel::acquire();
|
|
}
|
|
|
|
void SAL_CALL SdXImpressDocument::release() throw ( )
|
|
{
|
|
if (osl_decrementInterlockedCount( &m_refCount ) == 0)
|
|
{
|
|
// restore reference count:
|
|
osl_incrementInterlockedCount( &m_refCount );
|
|
if(!mbDisposed)
|
|
{
|
|
try
|
|
{
|
|
dispose();
|
|
}
|
|
catch (uno::RuntimeException const& exc)
|
|
{ // don't break throw ()
|
|
OSL_ENSURE(
|
|
false, OUStringToOString(
|
|
exc.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
|
|
static_cast<void>(exc);
|
|
}
|
|
}
|
|
SfxBaseModel::release();
|
|
}
|
|
}
|
|
|
|
// XUnoTunnel
|
|
const ::com::sun::star::uno::Sequence< sal_Int8 > & SdXImpressDocument::getUnoTunnelId() throw()
|
|
{
|
|
static ::com::sun::star::uno::Sequence< sal_Int8 > * pSeq = 0;
|
|
if( !pSeq )
|
|
{
|
|
::osl::Guard< ::osl::Mutex > aGuard( ::osl::Mutex::getGlobalMutex() );
|
|
if( !pSeq )
|
|
{
|
|
static ::com::sun::star::uno::Sequence< sal_Int8 > aSeq( 16 );
|
|
rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
|
|
pSeq = &aSeq;
|
|
}
|
|
}
|
|
return *pSeq;
|
|
}
|
|
|
|
SdXImpressDocument* SdXImpressDocument::getImplementation( const uno::Reference< uno::XInterface >& xInt )
|
|
{
|
|
::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xUT( xInt, ::com::sun::star::uno::UNO_QUERY );
|
|
if( xUT.is() )
|
|
return reinterpret_cast<SdXImpressDocument*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething( SdXImpressDocument::getUnoTunnelId() )));
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
sal_Int64 SAL_CALL SdXImpressDocument::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rIdentifier ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
if( rIdentifier.getLength() == 16 )
|
|
{
|
|
if( (0 == rtl_compareMemory( SdXImpressDocument::getUnoTunnelId().getConstArray(), rIdentifier.getConstArray(), 16 )) )
|
|
return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
|
|
|
|
if( (0 == rtl_compareMemory( SdrModel::getUnoTunnelImplementationId().getConstArray(), rIdentifier.getConstArray(), 16 )) )
|
|
return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(mpDoc));
|
|
}
|
|
|
|
return SfxBaseModel::getSomething( rIdentifier );
|
|
}
|
|
|
|
// XTypeProvider
|
|
uno::Sequence< uno::Type > SAL_CALL SdXImpressDocument::getTypes( ) throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( maTypeSequence.getLength() == 0 )
|
|
{
|
|
const uno::Sequence< uno::Type > aBaseTypes( SfxBaseModel::getTypes() );
|
|
const sal_Int32 nBaseTypes = aBaseTypes.getLength();
|
|
const uno::Type* pBaseTypes = aBaseTypes.getConstArray();
|
|
|
|
const sal_Int32 nOwnTypes = mbImpressDoc ? 14 : 11; // !DANGER! Keep this updated!
|
|
|
|
maTypeSequence.realloc( nBaseTypes + nOwnTypes );
|
|
uno::Type* pTypes = maTypeSequence.getArray();
|
|
|
|
*pTypes++ = ITYPE(beans::XPropertySet);
|
|
*pTypes++ = ITYPE(lang::XServiceInfo);
|
|
*pTypes++ = ITYPE(lang::XMultiServiceFactory);
|
|
*pTypes++ = ITYPE(drawing::XDrawPageDuplicator);
|
|
*pTypes++ = ITYPE(drawing::XLayerSupplier);
|
|
*pTypes++ = ITYPE(drawing::XMasterPagesSupplier);
|
|
*pTypes++ = ITYPE(drawing::XDrawPagesSupplier);
|
|
*pTypes++ = ITYPE(document::XLinkTargetSupplier);
|
|
*pTypes++ = ITYPE(style::XStyleFamiliesSupplier);
|
|
*pTypes++ = ITYPE(com::sun::star::ucb::XAnyCompareFactory);
|
|
*pTypes++ = ITYPE(view::XRenderable);
|
|
if( mbImpressDoc )
|
|
{
|
|
*pTypes++ = ITYPE(presentation::XPresentationSupplier);
|
|
*pTypes++ = ITYPE(presentation::XCustomPresentationSupplier);
|
|
*pTypes++ = ITYPE(presentation::XHandoutMasterSupplier);
|
|
}
|
|
|
|
for( sal_Int32 nType = 0; nType < nBaseTypes; nType++ )
|
|
*pTypes++ = *pBaseTypes++;
|
|
}
|
|
|
|
return maTypeSequence;
|
|
}
|
|
|
|
uno::Sequence< sal_Int8 > SAL_CALL SdXImpressDocument::getImplementationId( ) throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
static uno::Sequence< sal_Int8 > aId;
|
|
if( aId.getLength() == 0 )
|
|
{
|
|
aId.realloc( 16 );
|
|
rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
|
|
}
|
|
return aId;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* *
|
|
***********************************************************************/
|
|
void SdXImpressDocument::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
|
|
{
|
|
if( mpDoc )
|
|
{
|
|
const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
|
|
|
|
if( pSdrHint )
|
|
{
|
|
if( hasEventListeners() )
|
|
{
|
|
|
|
bool bBackgroundShape = false;
|
|
|
|
// the background shape itself has no api representation, so filter all notifies for it
|
|
const SdrObject* pSdrObj = pSdrHint->GetObject();
|
|
if( pSdrObj && (pSdrObj->GetObjInventor() == SdrInventor) && (pSdrObj->GetObjIdentifier() == OBJ_RECT) )
|
|
{
|
|
SdPage* pPage = (SdPage*)pSdrObj->GetPage();
|
|
bBackgroundShape = pPage && (pPage->GetPresObjKind(const_cast<SdrObject*>(pSdrObj)) == PRESOBJ_BACKGROUND);
|
|
}
|
|
|
|
if( !bBackgroundShape )
|
|
{
|
|
document::EventObject aEvent;
|
|
if( SvxUnoDrawMSFactory::createEvent( mpDoc, pSdrHint, aEvent ) )
|
|
notifyEvent( aEvent );
|
|
}
|
|
}
|
|
|
|
if( pSdrHint->GetKind() == HINT_MODELCLEARED )
|
|
{
|
|
if( mpDoc )
|
|
EndListening( *mpDoc );
|
|
mpDoc = NULL;
|
|
mpDocShell = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const SfxSimpleHint* pSfxHint = PTR_CAST(SfxSimpleHint, &rHint );
|
|
|
|
// ist unser SdDrawDocument gerade gestorben?
|
|
if(pSfxHint && pSfxHint->GetId() == SFX_HINT_DYING)
|
|
{
|
|
// yup, also schnell ein neues erfragen
|
|
if( mpDocShell )
|
|
{
|
|
SdDrawDocument *pNewDoc = mpDocShell->GetDoc();
|
|
|
|
// ist ueberhaupt ein neues da?
|
|
if( pNewDoc != mpDoc )
|
|
{
|
|
mpDoc = pNewDoc;
|
|
if(mpDoc)
|
|
StartListening( *mpDoc );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SfxBaseModel::Notify( rBC, rHint );
|
|
}
|
|
|
|
/******************************************************************************
|
|
* *
|
|
******************************************************************************/
|
|
SdPage* SdXImpressDocument::InsertSdPage( sal_uInt16 nPage, sal_Bool bDuplicate ) throw()
|
|
{
|
|
sal_uInt16 nPageCount = mpDoc->GetSdPageCount( PK_STANDARD );
|
|
SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin();
|
|
BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), sal_False);
|
|
BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False);
|
|
|
|
SdPage* pStandardPage = NULL;
|
|
|
|
if( 0 == nPageCount )
|
|
{
|
|
// this is only used for clipboard where we only have one page
|
|
pStandardPage = (SdPage*) mpDoc->AllocPage(sal_False);
|
|
|
|
Size aDefSize(21000, 29700); // A4-Hochformat
|
|
pStandardPage->SetSize( aDefSize );
|
|
mpDoc->InsertPage(pStandardPage, 0);
|
|
}
|
|
else
|
|
{
|
|
// Hier wird die Seite ermittelt, hinter der eingefuegt werden soll
|
|
SdPage* pPreviousStandardPage = mpDoc->GetSdPage( Min( (sal_uInt16)(nPageCount - 1), nPage ), PK_STANDARD );
|
|
SetOfByte aVisibleLayers = pPreviousStandardPage->TRG_GetMasterPageVisibleLayers();
|
|
sal_Bool bIsPageBack = aVisibleLayers.IsSet( aBckgrnd );
|
|
sal_Bool bIsPageObj = aVisibleLayers.IsSet( aBckgrndObj );
|
|
|
|
// AutoLayouts muessen fertig sein
|
|
mpDoc->StopWorkStartupDelay();
|
|
|
|
/**************************************************************
|
|
* Es wird stets zuerst eine Standardseite und dann eine
|
|
* Notizseite erzeugt. Es ist sichergestellt, dass auf eine
|
|
* Standardseite stets die zugehoerige Notizseite folgt.
|
|
**************************************************************/
|
|
|
|
sal_uInt16 nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
|
|
SdPage* pPreviousNotesPage = (SdPage*) mpDoc->GetPage( nStandardPageNum - 1 );
|
|
sal_uInt16 nNotesPageNum = nStandardPageNum + 1;
|
|
String aStandardPageName;
|
|
String aNotesPageName;
|
|
|
|
/**************************************************************
|
|
* Standardseite
|
|
**************************************************************/
|
|
if( bDuplicate )
|
|
pStandardPage = (SdPage*) pPreviousStandardPage->Clone();
|
|
else
|
|
pStandardPage = (SdPage*) mpDoc->AllocPage(sal_False);
|
|
|
|
pStandardPage->SetSize( pPreviousStandardPage->GetSize() );
|
|
pStandardPage->SetBorder( pPreviousStandardPage->GetLftBorder(),
|
|
pPreviousStandardPage->GetUppBorder(),
|
|
pPreviousStandardPage->GetRgtBorder(),
|
|
pPreviousStandardPage->GetLwrBorder() );
|
|
pStandardPage->SetOrientation( pPreviousStandardPage->GetOrientation() );
|
|
pStandardPage->SetName(aStandardPageName);
|
|
|
|
// Seite hinter aktueller Seite einfuegen
|
|
mpDoc->InsertPage(pStandardPage, nStandardPageNum);
|
|
|
|
if( !bDuplicate )
|
|
{
|
|
// MasterPage der aktuellen Seite verwenden
|
|
pStandardPage->TRG_SetMasterPage(pPreviousStandardPage->TRG_GetMasterPage());
|
|
pStandardPage->SetLayoutName( pPreviousStandardPage->GetLayoutName() );
|
|
pStandardPage->SetAutoLayout(AUTOLAYOUT_NONE, sal_True );
|
|
}
|
|
|
|
aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), sal_False);
|
|
aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False);
|
|
aVisibleLayers.Set(aBckgrnd, bIsPageBack);
|
|
aVisibleLayers.Set(aBckgrndObj, bIsPageObj);
|
|
pStandardPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
|
|
|
|
/**************************************************************
|
|
* Notizseite
|
|
**************************************************************/
|
|
SdPage* pNotesPage = NULL;
|
|
|
|
if( bDuplicate )
|
|
pNotesPage = (SdPage*) pPreviousNotesPage->Clone();
|
|
else
|
|
pNotesPage = (SdPage*) mpDoc->AllocPage(sal_False);
|
|
|
|
pNotesPage->SetSize( pPreviousNotesPage->GetSize() );
|
|
pNotesPage->SetBorder( pPreviousNotesPage->GetLftBorder(),
|
|
pPreviousNotesPage->GetUppBorder(),
|
|
pPreviousNotesPage->GetRgtBorder(),
|
|
pPreviousNotesPage->GetLwrBorder() );
|
|
pNotesPage->SetOrientation( pPreviousNotesPage->GetOrientation() );
|
|
pNotesPage->SetName(aNotesPageName);
|
|
pNotesPage->SetPageKind(PK_NOTES);
|
|
|
|
// Seite hinter aktueller Seite einfuegen
|
|
mpDoc->InsertPage(pNotesPage, nNotesPageNum);
|
|
|
|
if( !bDuplicate )
|
|
{
|
|
// MasterPage der aktuellen Seite verwenden
|
|
pNotesPage->TRG_SetMasterPage(pPreviousNotesPage->TRG_GetMasterPage());
|
|
pNotesPage->SetLayoutName( pPreviousNotesPage->GetLayoutName() );
|
|
pNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, sal_True );
|
|
}
|
|
}
|
|
|
|
SetModified();
|
|
|
|
return( pStandardPage );
|
|
}
|
|
|
|
void SdXImpressDocument::SetModified( sal_Bool bModified /* = sal_True */ ) throw()
|
|
{
|
|
if( mpDoc )
|
|
mpDoc->SetChanged( bModified );
|
|
}
|
|
|
|
// XModel
|
|
void SAL_CALL SdXImpressDocument ::lockControllers( )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
mpDoc->setLock( sal_True );
|
|
}
|
|
|
|
void SAL_CALL SdXImpressDocument::unlockControllers( )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
if( mpDoc->isLocked() )
|
|
{
|
|
mpDoc->setLock( sal_False );
|
|
}
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdXImpressDocument::hasControllersLocked( )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
return mpDoc && mpDoc->isLocked();
|
|
}
|
|
|
|
#ifndef _UNOTOOLS_PROCESSFACTORY_HXX
|
|
#include <comphelper/processfactory.hxx>
|
|
#endif
|
|
|
|
uno::Reference < container::XIndexAccess > SAL_CALL SdXImpressDocument::getViewData() throw( uno::RuntimeException )
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference < container::XIndexAccess > xRet( SfxBaseModel::getViewData() );
|
|
|
|
if( !xRet.is() )
|
|
{
|
|
List* pFrameViewList = mpDoc->GetFrameViewList();
|
|
|
|
if( pFrameViewList && pFrameViewList->Count() )
|
|
{
|
|
xRet = uno::Reference < container::XIndexAccess >::query(::comphelper::getProcessServiceFactory()->createInstance(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.IndexedPropertyValues"))));
|
|
|
|
|
|
uno::Reference < container::XIndexContainer > xCont( xRet, uno::UNO_QUERY );
|
|
DBG_ASSERT( xCont.is(), "SdXImpressDocument::getViewData() failed for OLE object" );
|
|
if( xCont.is() )
|
|
{
|
|
sal_uInt32 i;
|
|
for( i = 0; i < pFrameViewList->Count(); i++ )
|
|
{
|
|
::sd::FrameView* pFrameView =
|
|
static_cast< ::sd::FrameView*>(
|
|
pFrameViewList->GetObject(i));
|
|
|
|
if(pFrameView)
|
|
{
|
|
uno::Sequence< beans::PropertyValue > aSeq;
|
|
pFrameView->WriteUserDataSequence( aSeq );
|
|
xCont->insertByIndex( i, uno::makeAny( aSeq ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return xRet;
|
|
}
|
|
|
|
void SAL_CALL SdXImpressDocument::setViewData( const uno::Reference < container::XIndexAccess >& xData ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
SfxBaseModel::setViewData( xData );
|
|
if( mpDocShell && (mpDocShell->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED) && xData.is() )
|
|
{
|
|
const sal_Int32 nCount = xData->getCount();
|
|
|
|
List* pFrameViewList = mpDoc->GetFrameViewList();
|
|
|
|
DBG_ASSERT( pFrameViewList, "No FrameViewList?" );
|
|
if( pFrameViewList )
|
|
{
|
|
::sd::FrameView* pFrameView;
|
|
|
|
sal_uInt32 i;
|
|
for ( i = 0; i < pFrameViewList->Count(); i++)
|
|
{
|
|
// Ggf. FrameViews loeschen
|
|
pFrameView = static_cast< ::sd::FrameView*>(
|
|
pFrameViewList->GetObject(i));
|
|
|
|
if (pFrameView)
|
|
delete pFrameView;
|
|
}
|
|
|
|
pFrameViewList->Clear();
|
|
|
|
uno::Sequence< beans::PropertyValue > aSeq;
|
|
sal_Int32 nIndex;
|
|
for( nIndex = 0; nIndex < nCount; nIndex++ )
|
|
{
|
|
if( xData->getByIndex( nIndex ) >>= aSeq )
|
|
{
|
|
pFrameView = new ::sd::FrameView( mpDoc );
|
|
pFrameView->ReadUserDataSequence( aSeq );
|
|
pFrameViewList->Insert( pFrameView );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// XDrawPageDuplicator
|
|
uno::Reference< drawing::XDrawPage > SAL_CALL SdXImpressDocument::duplicate( const uno::Reference< drawing::XDrawPage >& xPage )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
// pPage von xPage besorgen und dann die Id (nPos )ermitteln
|
|
SvxDrawPage* pSvxPage = SvxDrawPage::getImplementation( xPage );
|
|
if( pSvxPage )
|
|
{
|
|
SdPage* pPage = (SdPage*) pSvxPage->GetSdrPage();
|
|
sal_uInt16 nPos = pPage->GetPageNum();
|
|
nPos = ( nPos - 1 ) / 2;
|
|
pPage = InsertSdPage( nPos, sal_True );
|
|
if( pPage )
|
|
{
|
|
uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
|
|
return xDrawPage;
|
|
}
|
|
}
|
|
|
|
uno::Reference< drawing::XDrawPage > xDrawPage;
|
|
return xDrawPage;
|
|
}
|
|
|
|
|
|
// XDrawPagesSupplier
|
|
uno::Reference< drawing::XDrawPages > SAL_CALL SdXImpressDocument::getDrawPages()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< drawing::XDrawPages > xDrawPages( mxDrawPagesAccess );
|
|
|
|
if( !xDrawPages.is() )
|
|
{
|
|
initializeDocument();
|
|
mxDrawPagesAccess = xDrawPages = (drawing::XDrawPages*)new SdDrawPagesAccess(*this);
|
|
}
|
|
|
|
return xDrawPages;
|
|
}
|
|
|
|
// XMasterPagesSupplier
|
|
uno::Reference< drawing::XDrawPages > SAL_CALL SdXImpressDocument::getMasterPages()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< drawing::XDrawPages > xMasterPages( mxMasterPagesAccess );
|
|
|
|
if( !xMasterPages.is() )
|
|
{
|
|
initializeDocument();
|
|
mxMasterPagesAccess = xMasterPages = new SdMasterPagesAccess(*this);
|
|
}
|
|
|
|
return xMasterPages;
|
|
}
|
|
|
|
// XLayerManagerSupplier
|
|
uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getLayerManager( )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< container::XNameAccess > xLayerManager( mxLayerManager );
|
|
|
|
if( !xLayerManager.is() )
|
|
mxLayerManager = xLayerManager = new SdLayerManager(*this);
|
|
|
|
return xLayerManager;
|
|
}
|
|
|
|
// XCustomPresentationSupplier
|
|
uno::Reference< container::XNameContainer > SAL_CALL SdXImpressDocument::getCustomPresentations()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< container::XNameContainer > xCustomPres( mxCustomPresentationAccess );
|
|
|
|
if( !xCustomPres.is() )
|
|
mxCustomPresentationAccess = xCustomPres = new SdXCustomPresentationAccess(*this);
|
|
|
|
return xCustomPres;
|
|
}
|
|
|
|
extern uno::Reference< presentation::XPresentation > createPresentation( SdXImpressDocument& rModel );
|
|
|
|
// XPresentationSupplier
|
|
uno::Reference< presentation::XPresentation > SAL_CALL SdXImpressDocument::getPresentation()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
return uno::Reference< presentation::XPresentation >( mpDoc->getPresentation().get() );
|
|
}
|
|
|
|
// XHandoutMasterSupplier
|
|
uno::Reference< drawing::XDrawPage > SAL_CALL SdXImpressDocument::getHandoutMasterPage()
|
|
throw (uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< drawing::XDrawPage > xPage;
|
|
|
|
if( mpDoc )
|
|
{
|
|
initializeDocument();
|
|
SdPage* pPage = mpDoc->GetMasterSdPage( 0, PK_HANDOUT );
|
|
if( pPage )
|
|
xPage = uno::Reference< drawing::XDrawPage >::query( pPage->getUnoPage() );
|
|
}
|
|
return xPage;
|
|
}
|
|
|
|
// XMultiServiceFactory ( SvxFmMSFactory )
|
|
uno::Reference< uno::XInterface > SAL_CALL SdXImpressDocument::createInstance( const OUString& aServiceSpecifier )
|
|
throw(uno::Exception, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.DashTable") ) )
|
|
{
|
|
if( !mxDashTable.is() )
|
|
mxDashTable = SvxUnoDashTable_createInstance( mpDoc );
|
|
|
|
return mxDashTable;
|
|
}
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.GradientTable") ) )
|
|
{
|
|
if( !mxGradientTable.is() )
|
|
mxGradientTable = SvxUnoGradientTable_createInstance( mpDoc );
|
|
|
|
return mxGradientTable;
|
|
}
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.HatchTable") ) )
|
|
{
|
|
if( !mxHatchTable.is() )
|
|
mxHatchTable = SvxUnoHatchTable_createInstance( mpDoc );
|
|
|
|
return mxHatchTable;
|
|
}
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.BitmapTable") ) )
|
|
{
|
|
if( !mxBitmapTable.is() )
|
|
mxBitmapTable = SvxUnoBitmapTable_createInstance( mpDoc );
|
|
|
|
return mxBitmapTable;
|
|
}
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.TransparencyGradientTable") ) )
|
|
{
|
|
if( !mxTransGradientTable.is() )
|
|
mxTransGradientTable = SvxUnoTransGradientTable_createInstance( mpDoc );
|
|
|
|
return mxTransGradientTable;
|
|
}
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.MarkerTable") ) )
|
|
{
|
|
if( !mxMarkerTable.is() )
|
|
mxMarkerTable = SvxUnoMarkerTable_createInstance( mpDoc );
|
|
|
|
return mxMarkerTable;
|
|
}
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.NumberingRules" ) ) )
|
|
{
|
|
return uno::Reference< uno::XInterface >( SvxCreateNumRule( mpDoc ), uno::UNO_QUERY );
|
|
}
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.Background" ) ) )
|
|
{
|
|
return uno::Reference< uno::XInterface >(
|
|
static_cast<uno::XWeak*>(new SdUnoPageBackground( mpDoc )));
|
|
}
|
|
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.Defaults") ) )
|
|
{
|
|
if( !mxDrawingPool.is() )
|
|
mxDrawingPool = SdUnoCreatePool( mpDoc );
|
|
|
|
return mxDrawingPool;
|
|
|
|
}
|
|
|
|
if( aServiceSpecifier.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_Service_ImageMapRectangleObject) ) )
|
|
{
|
|
return SvUnoImageMapRectangleObject_createInstance( ImplGetSupportedMacroItems() );
|
|
}
|
|
|
|
if( aServiceSpecifier.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_Service_ImageMapCircleObject) ) )
|
|
{
|
|
return SvUnoImageMapCircleObject_createInstance( ImplGetSupportedMacroItems() );
|
|
}
|
|
|
|
if( aServiceSpecifier.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(sUNO_Service_ImageMapPolygonObject) ) )
|
|
{
|
|
return SvUnoImageMapPolygonObject_createInstance( ImplGetSupportedMacroItems() );
|
|
}
|
|
|
|
if( ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.Settings") ) ) ||
|
|
( !mbImpressDoc && ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.DocumentSettings") ) ) ) ||
|
|
( mbImpressDoc && ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.DocumentSettings") ) ) ) )
|
|
{
|
|
return sd::DocumentSettings_createInstance( this );
|
|
}
|
|
|
|
if( ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.TextField.DateTime") ) ) ||
|
|
( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.textfield.DateTime") ) ) )
|
|
{
|
|
return (::cppu::OWeakObject * )new SvxUnoTextField( ID_EXT_DATEFIELD );
|
|
}
|
|
|
|
if( (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.TextField.Header"))) ||
|
|
(0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.textfield.Header"))) )
|
|
{
|
|
return (::cppu::OWeakObject * )new SvxUnoTextField( ID_HEADERFIELD );
|
|
}
|
|
|
|
if( (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.TextField.Footer"))) ||
|
|
(0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.textfield.Footer"))) )
|
|
{
|
|
return (::cppu::OWeakObject * )new SvxUnoTextField( ID_FOOTERFIELD );
|
|
}
|
|
|
|
if( (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.TextField.DateTime"))) ||
|
|
(0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.textfield.DateTime"))) )
|
|
{
|
|
return (::cppu::OWeakObject * )new SvxUnoTextField( ID_DATETIMEFIELD );
|
|
}
|
|
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.xml.NamespaceMap") ) )
|
|
{
|
|
static sal_uInt16 aWhichIds[] = { SDRATTR_XMLATTRIBUTES, EE_CHAR_XMLATTRIBS, EE_PARA_XMLATTRIBS, 0 };
|
|
|
|
return svx::NamespaceMap_createInstance( aWhichIds, &mpDoc->GetItemPool() );
|
|
}
|
|
|
|
// #99870# Support creation of GraphicObjectResolver and EmbeddedObjectResolver
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ExportGraphicObjectResolver") ) )
|
|
{
|
|
return (::cppu::OWeakObject * )new SvXMLGraphicHelper( GRAPHICHELPER_MODE_WRITE );
|
|
}
|
|
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ImportGraphicObjectResolver") ) )
|
|
{
|
|
return (::cppu::OWeakObject * )new SvXMLGraphicHelper( GRAPHICHELPER_MODE_READ );
|
|
}
|
|
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ExportEmbeddedObjectResolver") ) )
|
|
{
|
|
::comphelper::IEmbeddedHelper *pPersist = mpDoc ? mpDoc->GetPersist() : NULL;
|
|
if( NULL == pPersist )
|
|
throw lang::DisposedException();
|
|
|
|
return (::cppu::OWeakObject * )new SvXMLEmbeddedObjectHelper( *pPersist, EMBEDDEDOBJECTHELPER_MODE_WRITE );
|
|
}
|
|
|
|
if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ImportEmbeddedObjectResolver") ) )
|
|
{
|
|
::comphelper::IEmbeddedHelper *pPersist = mpDoc ? mpDoc->GetPersist() : NULL;
|
|
if( NULL == pPersist )
|
|
throw lang::DisposedException();
|
|
|
|
return (::cppu::OWeakObject * )new SvXMLEmbeddedObjectHelper( *pPersist, EMBEDDEDOBJECTHELPER_MODE_READ );
|
|
}
|
|
|
|
uno::Reference< uno::XInterface > xRet;
|
|
|
|
const String aType( aServiceSpecifier );
|
|
if( aType.EqualsAscii( "com.sun.star.presentation.", 0, 26 ) )
|
|
{
|
|
SvxShape* pShape = NULL;
|
|
|
|
sal_uInt16 nType = OBJ_TEXT;
|
|
// create a shape wrapper
|
|
if( aType.EqualsAscii( "TitleTextShape", 26, 14 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "OutlinerShape", 26, 13 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "SubtitleShape", 26, 13 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "GraphicObjectShape", 26, 18 ) )
|
|
{
|
|
nType = OBJ_GRAF;
|
|
}
|
|
else if( aType.EqualsAscii( "PageShape", 26, 9 ) )
|
|
{
|
|
nType = OBJ_PAGE;
|
|
}
|
|
else if( aType.EqualsAscii( "OLE2Shape", 26, 9 ) )
|
|
{
|
|
nType = OBJ_OLE2;
|
|
}
|
|
else if( aType.EqualsAscii( "ChartShape", 26, 10 ) )
|
|
{
|
|
nType = OBJ_OLE2;
|
|
}
|
|
else if( aType.EqualsAscii( "TableShape", 26, 10 ) )
|
|
{
|
|
nType = OBJ_OLE2;
|
|
}
|
|
else if( aType.EqualsAscii( "OrgChartShape", 26, 13 ) )
|
|
{
|
|
nType = OBJ_OLE2;
|
|
}
|
|
else if( aType.EqualsAscii( "NotesShape", 26, 13 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "HandoutShape", 26, 13 ) )
|
|
{
|
|
nType = OBJ_PAGE;
|
|
}
|
|
else if( aType.EqualsAscii( "FooterShape", 26, 12 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "HeaderShape", 26, 12 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "SlideNumberShape", 26, 17 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "DateTimeShape", 26, 17 ) )
|
|
{
|
|
nType = OBJ_TEXT;
|
|
}
|
|
else if( aType.EqualsAscii( "TableShape", 26, 10 ) )
|
|
{
|
|
nType = OBJ_TABLE;
|
|
}
|
|
else
|
|
{
|
|
throw lang::ServiceNotRegisteredException();
|
|
}
|
|
|
|
// create the API wrapper
|
|
pShape = CreateSvxShapeByTypeAndInventor( nType, SdrInventor );
|
|
|
|
// set shape type
|
|
if( pShape && !mbClipBoard )
|
|
pShape->SetShapeType(aServiceSpecifier);
|
|
|
|
xRet = (uno::XWeak*)pShape;
|
|
}
|
|
else if( aServiceSpecifier.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.TableShape") ) )
|
|
{
|
|
SvxShape* pShape = CreateSvxShapeByTypeAndInventor( OBJ_TABLE, SdrInventor );
|
|
if( pShape && !mbClipBoard )
|
|
pShape->SetShapeType(aServiceSpecifier);
|
|
|
|
xRet = (uno::XWeak*)pShape;
|
|
}
|
|
else
|
|
{
|
|
xRet = SvxFmMSFactory::createInstance( aServiceSpecifier );
|
|
}
|
|
|
|
uno::Reference< drawing::XShape > xShape( xRet, uno::UNO_QUERY );
|
|
if( xShape.is() )
|
|
{
|
|
xRet.clear();
|
|
new SdXShape( SvxShape::getImplementation( xShape ), (SdXImpressDocument*)this );
|
|
xRet = xShape;
|
|
xShape.clear();
|
|
}
|
|
|
|
return xRet;
|
|
}
|
|
|
|
uno::Sequence< OUString > SAL_CALL SdXImpressDocument::getAvailableServiceNames()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
const uno::Sequence< OUString > aSNS_ORG( SvxFmMSFactory::getAvailableServiceNames() );
|
|
|
|
uno::Sequence< OUString > aSNS( mbImpressDoc ? (34) : (19) );
|
|
|
|
sal_uInt16 i(0);
|
|
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.DashTable"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.GradientTable"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.HatchTable"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.BitmapTable"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.TransparencyGradientTable"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.MarkerTable"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.NumberingRules"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.Background"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.Settings"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_Service_ImageMapRectangleObject));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_Service_ImageMapCircleObject));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM(sUNO_Service_ImageMapPolygonObject));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.NamespaceMap"));
|
|
|
|
// #99870# Support creation of GraphicObjectResolver and EmbeddedObjectResolver
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ExportGraphicObjectResolver"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ImportGraphicObjectResolver"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ExportEmbeddedObjectResolver"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ImportEmbeddedObjectResolver"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.TableShape"));
|
|
|
|
if(mbImpressDoc)
|
|
{
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.TitleTextShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.OutlinerShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.SubtitleShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.GraphicObjectShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.ChartShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.PageShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.OLE2Shape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.TableShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.OrgChartShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.NotesShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.HandoutShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.DocumentSettings"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.FooterShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.HeaderShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.SlideNumberShape"));
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.DateTimeShape"));
|
|
}
|
|
else
|
|
{
|
|
aSNS[i++] = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.DocumentSettings"));
|
|
}
|
|
|
|
DBG_ASSERT( i == aSNS.getLength(), "Sequence overrun!" );
|
|
|
|
return comphelper::concatSequences( aSNS_ORG, aSNS );
|
|
}
|
|
|
|
// lang::XServiceInfo
|
|
OUString SAL_CALL SdXImpressDocument::getImplementationName()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return OUString( RTL_CONSTASCII_USTRINGPARAM("SdXImpressDocument"));
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdXImpressDocument::supportsService( const OUString& ServiceName )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if (
|
|
(ServiceName.equalsAscii("com.sun.star.document.OfficeDocument" )) ||
|
|
(ServiceName.equalsAscii("com.sun.star.drawing.GenericDrawingDocument")) ||
|
|
(ServiceName.equalsAscii("com.sun.star.drawing.DrawingDocumentFactory"))
|
|
)
|
|
{
|
|
return sal_True;
|
|
}
|
|
|
|
return (
|
|
( mbImpressDoc && ServiceName.equalsAscii("com.sun.star.presentation.PresentationDocument")) ||
|
|
(!mbImpressDoc && ServiceName.equalsAscii("com.sun.star.drawing.DrawingDocument" ))
|
|
);
|
|
}
|
|
|
|
uno::Sequence< OUString > SAL_CALL SdXImpressDocument::getSupportedServiceNames() throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
uno::Sequence< OUString > aSeq( 4 );
|
|
OUString* pServices = aSeq.getArray();
|
|
|
|
*pServices++ = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.OfficeDocument"));
|
|
*pServices++ = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.GenericDrawingDocument"));
|
|
*pServices++ = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.DrawingDocumentFactory"));
|
|
|
|
if( mbImpressDoc )
|
|
*pServices++ = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.PresentationDocument"));
|
|
else
|
|
*pServices++ = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.DrawingDocument"));
|
|
|
|
return aSeq;
|
|
}
|
|
|
|
// XPropertySet
|
|
uno::Reference< beans::XPropertySetInfo > SAL_CALL SdXImpressDocument::getPropertySetInfo( )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
return mpPropSet->getPropertySetInfo();
|
|
}
|
|
|
|
void SAL_CALL SdXImpressDocument::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
|
|
throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(aPropertyName);
|
|
|
|
switch( pEntry ? pEntry->nWID : -1 )
|
|
{
|
|
case WID_MODEL_LANGUAGE:
|
|
{
|
|
lang::Locale aLocale;
|
|
if(!(aValue >>= aLocale))
|
|
throw lang::IllegalArgumentException();
|
|
|
|
mpDoc->SetLanguage( SvxLocaleToLanguage(aLocale), EE_CHAR_LANGUAGE );
|
|
break;
|
|
}
|
|
case WID_MODEL_TABSTOP:
|
|
{
|
|
sal_Int32 nValue = 0;
|
|
if(!(aValue >>= nValue) || nValue < 0 )
|
|
throw lang::IllegalArgumentException();
|
|
|
|
mpDoc->SetDefaultTabulator((sal_uInt16)nValue);
|
|
break;
|
|
}
|
|
case WID_MODEL_VISAREA:
|
|
{
|
|
SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
|
|
if( !pEmbeddedObj )
|
|
break;
|
|
|
|
awt::Rectangle aVisArea;
|
|
if( !(aValue >>= aVisArea) || (aVisArea.Width < 0) || (aVisArea.Height < 0) )
|
|
throw lang::IllegalArgumentException();
|
|
|
|
pEmbeddedObj->SetVisArea( Rectangle( aVisArea.X, aVisArea.Y, aVisArea.X + aVisArea.Width - 1, aVisArea.Y + aVisArea.Height - 1 ) );
|
|
}
|
|
break;
|
|
case WID_MODEL_CONTFOCUS:
|
|
{
|
|
sal_Bool bFocus = sal_False;
|
|
if( !(aValue >>= bFocus ) )
|
|
throw lang::IllegalArgumentException();
|
|
mpDoc->SetAutoControlFocus( bFocus );
|
|
}
|
|
break;
|
|
case WID_MODEL_DSGNMODE:
|
|
{
|
|
sal_Bool bMode = sal_False;
|
|
if( !(aValue >>= bMode ) )
|
|
throw lang::IllegalArgumentException();
|
|
mpDoc->SetOpenInDesignMode( bMode );
|
|
}
|
|
break;
|
|
case WID_MODEL_BUILDID:
|
|
aValue >>= maBuildId;
|
|
return;
|
|
case WID_MODEL_MAPUNIT:
|
|
case WID_MODEL_BASICLIBS:
|
|
case WID_MODEL_RUNTIMEUID: // is read-only
|
|
case WID_MODEL_DIALOGLIBS:
|
|
throw beans::PropertyVetoException();
|
|
default:
|
|
throw beans::UnknownPropertyException();
|
|
}
|
|
|
|
SetModified();
|
|
}
|
|
|
|
uno::Any SAL_CALL SdXImpressDocument::getPropertyValue( const OUString& PropertyName )
|
|
throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
uno::Any aAny;
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(PropertyName);
|
|
|
|
switch( pEntry ? pEntry->nWID : -1 )
|
|
{
|
|
case WID_MODEL_LANGUAGE:
|
|
{
|
|
LanguageType eLang = mpDoc->GetLanguage( EE_CHAR_LANGUAGE );
|
|
lang::Locale aLocale;
|
|
SvxLanguageToLocale( aLocale, eLang );
|
|
aAny <<= aLocale;
|
|
break;
|
|
}
|
|
case WID_MODEL_TABSTOP:
|
|
aAny <<= (sal_Int32)mpDoc->GetDefaultTabulator();
|
|
break;
|
|
case WID_MODEL_VISAREA:
|
|
{
|
|
SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
|
|
if( !pEmbeddedObj )
|
|
break;
|
|
|
|
const Rectangle& aRect = pEmbeddedObj->GetVisArea();
|
|
awt::Rectangle aVisArea( aRect.nLeft, aRect.nTop, aRect.getWidth(), aRect.getHeight() );
|
|
aAny <<= aVisArea;
|
|
}
|
|
break;
|
|
case WID_MODEL_MAPUNIT:
|
|
{
|
|
SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
|
|
if( !pEmbeddedObj )
|
|
break;
|
|
|
|
sal_Int16 nMeasureUnit = 0;
|
|
SvxMapUnitToMeasureUnit( (const short)pEmbeddedObj->GetMapUnit(), nMeasureUnit );
|
|
aAny <<= (sal_Int16)nMeasureUnit;
|
|
}
|
|
break;
|
|
case WID_MODEL_FORBCHARS:
|
|
{
|
|
aAny <<= getForbiddenCharsTable();
|
|
}
|
|
break;
|
|
case WID_MODEL_CONTFOCUS:
|
|
aAny <<= (sal_Bool)mpDoc->GetAutoControlFocus();
|
|
break;
|
|
case WID_MODEL_DSGNMODE:
|
|
aAny <<= mpDoc->GetOpenInDesignMode();
|
|
break;
|
|
case WID_MODEL_BASICLIBS:
|
|
aAny <<= mpDocShell->GetBasicContainer();
|
|
break;
|
|
case WID_MODEL_DIALOGLIBS:
|
|
aAny <<= mpDocShell->GetDialogContainer();
|
|
break;
|
|
case WID_MODEL_RUNTIMEUID:
|
|
aAny <<= getRuntimeUID();
|
|
break;
|
|
case WID_MODEL_BUILDID:
|
|
return uno::Any( maBuildId );
|
|
case WID_MODEL_HASVALIDSIGNATURES:
|
|
aAny <<= hasValidSignatures();
|
|
break;
|
|
default:
|
|
throw beans::UnknownPropertyException();
|
|
}
|
|
|
|
return aAny;
|
|
}
|
|
|
|
void SAL_CALL SdXImpressDocument::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
|
|
void SAL_CALL SdXImpressDocument::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
|
|
void SAL_CALL SdXImpressDocument::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
|
|
void SAL_CALL SdXImpressDocument::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
|
|
|
|
// XLinkTargetSupplier
|
|
uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getLinks()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< container::XNameAccess > xLinks( mxLinks );
|
|
if( !xLinks.is() )
|
|
mxLinks = xLinks = new SdDocLinkTargets( *this );
|
|
return xLinks;
|
|
}
|
|
|
|
// XStyleFamiliesSupplier
|
|
uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getStyleFamilies( )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< container::XNameAccess > xStyles( dynamic_cast< container::XNameAccess* >( mpDoc->GetStyleSheetPool()) );
|
|
return xStyles;
|
|
}
|
|
|
|
// XAnyCompareFactory
|
|
uno::Reference< com::sun::star::ucb::XAnyCompare > SAL_CALL SdXImpressDocument::createAnyCompareByName( const OUString& )
|
|
throw (uno::RuntimeException)
|
|
{
|
|
return SvxCreateNumRuleCompare();
|
|
}
|
|
|
|
// XRenderable
|
|
sal_Int32 SAL_CALL SdXImpressDocument::getRendererCount( const uno::Any& rSelection,
|
|
const uno::Sequence< beans::PropertyValue >& )
|
|
throw (lang::IllegalArgumentException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
sal_Int32 nRet = 0;
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Sequence< beans::PropertyValue > aRenderer;
|
|
|
|
if( mpDocShell && mpDoc )
|
|
{
|
|
uno::Reference< frame::XModel > xModel;
|
|
|
|
rSelection >>= xModel;
|
|
|
|
if( xModel == mpDocShell->GetModel() )
|
|
nRet = mpDoc->GetSdPageCount( PK_STANDARD );
|
|
else
|
|
{
|
|
uno::Reference< drawing::XShapes > xShapes;
|
|
|
|
rSelection >>= xShapes;
|
|
|
|
if( xShapes.is() && xShapes->getCount() )
|
|
nRet = 1;
|
|
}
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
uno::Sequence< beans::PropertyValue > SAL_CALL SdXImpressDocument::getRenderer( sal_Int32 , const uno::Any& ,
|
|
const uno::Sequence< beans::PropertyValue >& rxOptions )
|
|
throw (lang::IllegalArgumentException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
sal_Bool bExportNotesPages = sal_False;
|
|
for( sal_Int32 nProperty = 0, nPropertyCount = rxOptions.getLength(); nProperty < nPropertyCount; ++nProperty )
|
|
{
|
|
if( rxOptions[ nProperty ].Name == OUString( RTL_CONSTASCII_USTRINGPARAM( "ExportNotesPages" ) ) )
|
|
rxOptions[ nProperty].Value >>= bExportNotesPages;
|
|
}
|
|
uno::Sequence< beans::PropertyValue > aRenderer;
|
|
if( mpDocShell && mpDoc )
|
|
{
|
|
awt::Size aPageSize;
|
|
if ( bExportNotesPages )
|
|
{
|
|
Size aNotesPageSize = mpDoc->GetSdPage( 0, PK_NOTES )->GetSize();
|
|
aPageSize = awt::Size( aNotesPageSize.Width(), aNotesPageSize.Height() );
|
|
}
|
|
else
|
|
{
|
|
const Rectangle aVisArea( mpDocShell->GetVisArea( embed::Aspects::MSOLE_DOCPRINT ) );
|
|
aPageSize = awt::Size( aVisArea.GetWidth(), aVisArea.GetHeight() );
|
|
}
|
|
aRenderer.realloc( 1 );
|
|
|
|
aRenderer[ 0 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) );
|
|
aRenderer[ 0 ].Value <<= aPageSize;
|
|
}
|
|
return aRenderer;
|
|
}
|
|
|
|
class ImplRenderPaintProc : public ::sdr::contact::ViewObjectContactRedirector
|
|
{
|
|
const SdrLayerAdmin& rLayerAdmin;
|
|
SdrPageView* pSdrPageView;
|
|
vcl::PDFExtOutDevData* pPDFExtOutDevData;
|
|
|
|
vcl::PDFWriter::StructElement ImplBegStructureTag( SdrObject& rObject );
|
|
|
|
public:
|
|
sal_Bool IsVisible ( const SdrObject* pObj ) const;
|
|
sal_Bool IsPrintable( const SdrObject* pObj ) const;
|
|
|
|
ImplRenderPaintProc( const SdrLayerAdmin& rLA, SdrPageView* pView, vcl::PDFExtOutDevData* pData );
|
|
virtual ~ImplRenderPaintProc();
|
|
|
|
// all default implementations just call the same methods at the original. To do something
|
|
// different, overload the method and at least do what the method does.
|
|
virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
|
|
const sdr::contact::ViewObjectContact& rOriginal,
|
|
const sdr::contact::DisplayInfo& rDisplayInfo);
|
|
};
|
|
|
|
ImplRenderPaintProc::ImplRenderPaintProc( const SdrLayerAdmin& rLA, SdrPageView* pView, vcl::PDFExtOutDevData* pData )
|
|
: ViewObjectContactRedirector(),
|
|
rLayerAdmin ( rLA ),
|
|
pSdrPageView ( pView ),
|
|
pPDFExtOutDevData ( pData )
|
|
{
|
|
}
|
|
|
|
ImplRenderPaintProc::~ImplRenderPaintProc()
|
|
{
|
|
}
|
|
|
|
sal_Int32 ImplPDFGetBookmarkPage( const String& rBookmark, SdDrawDocument& rDoc )
|
|
{
|
|
sal_Int32 nPage = -1;
|
|
|
|
OSL_TRACE("GotoBookmark %s",
|
|
::rtl::OUStringToOString(rBookmark, RTL_TEXTENCODING_UTF8).getStr());
|
|
|
|
String aBookmark( rBookmark );
|
|
|
|
if( rBookmark.Len() && rBookmark.GetChar( 0 ) == sal_Unicode('#') )
|
|
aBookmark = rBookmark.Copy( 1 );
|
|
|
|
// is the bookmark a page ?
|
|
BOOL bIsMasterPage;
|
|
USHORT nPgNum = rDoc.GetPageByName( aBookmark, bIsMasterPage );
|
|
SdrObject* pObj = NULL;
|
|
|
|
if ( nPgNum == SDRPAGE_NOTFOUND )
|
|
{
|
|
// is the bookmark a object ?
|
|
pObj = rDoc.GetObj( aBookmark );
|
|
if (pObj)
|
|
nPgNum = pObj->GetPage()->GetPageNum();
|
|
}
|
|
if ( nPgNum != SDRPAGE_NOTFOUND )
|
|
nPage = ( nPgNum - 1 ) / 2;
|
|
return nPage;
|
|
}
|
|
|
|
void ImplPDFExportShapeInteraction( uno::Reference< drawing::XShape > xShape, SdDrawDocument& rDoc, vcl::PDFExtOutDevData& rPDFExtOutDevData )
|
|
{
|
|
const rtl::OUString sGroup ( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.GroupShape" ) );
|
|
const rtl::OUString sOnClick ( RTL_CONSTASCII_USTRINGPARAM( "OnClick" ) );
|
|
const rtl::OUString sBookmark( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) );
|
|
|
|
if ( xShape->getShapeType().equals( sGroup ) )
|
|
{
|
|
uno::Reference< container::XIndexAccess > xIndexAccess( xShape, uno::UNO_QUERY );
|
|
if ( xIndexAccess.is() )
|
|
{
|
|
sal_Int32 i, nCount = xIndexAccess->getCount();
|
|
for ( i = 0; i < nCount; i++ )
|
|
{
|
|
uno::Reference< drawing::XShape > xSubShape( xIndexAccess->getByIndex( i ), uno::UNO_QUERY );
|
|
if ( xSubShape.is() )
|
|
ImplPDFExportShapeInteraction( xSubShape, rDoc, rPDFExtOutDevData );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uno::Reference< beans::XPropertySet > xShapePropSet( xShape, uno::UNO_QUERY );
|
|
if( xShapePropSet.is() )
|
|
{
|
|
Size aPageSize( rDoc.GetSdPage( 0, PK_STANDARD )->GetSize() );
|
|
Point aPoint( 0, 0 );
|
|
Rectangle aPageRect( aPoint, aPageSize );
|
|
|
|
awt::Point aShapePos( xShape->getPosition() );
|
|
awt::Size aShapeSize( xShape->getSize() );
|
|
Rectangle aLinkRect( Point( aShapePos.X, aShapePos.Y ), Size( aShapeSize.Width, aShapeSize.Height ) );
|
|
|
|
presentation::ClickAction eCa;
|
|
uno::Any aAny( xShapePropSet->getPropertyValue( sOnClick ) );
|
|
if ( aAny >>= eCa )
|
|
{
|
|
switch ( eCa )
|
|
{
|
|
case presentation::ClickAction_LASTPAGE :
|
|
{
|
|
sal_Int32 nCount = rDoc.GetSdPageCount( PK_STANDARD );
|
|
sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nCount - 1, vcl::PDFWriter::FitRectangle );
|
|
sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
|
|
rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
|
|
}
|
|
break;
|
|
case presentation::ClickAction_FIRSTPAGE :
|
|
{
|
|
sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, 0, vcl::PDFWriter::FitRectangle );
|
|
sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
|
|
rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
|
|
}
|
|
break;
|
|
case presentation::ClickAction_PREVPAGE :
|
|
{
|
|
sal_Int32 nDestPage = rPDFExtOutDevData.GetCurrentPageNumber();
|
|
if ( nDestPage )
|
|
nDestPage--;
|
|
sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nDestPage, vcl::PDFWriter::FitRectangle );
|
|
sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
|
|
rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
|
|
}
|
|
break;
|
|
case presentation::ClickAction_NEXTPAGE :
|
|
{
|
|
sal_Int32 nDestPage = rPDFExtOutDevData.GetCurrentPageNumber() + 1;
|
|
sal_Int32 nLastPage = rDoc.GetSdPageCount( PK_STANDARD ) - 1;
|
|
if ( nDestPage > nLastPage )
|
|
nDestPage = nLastPage;
|
|
sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nDestPage, vcl::PDFWriter::FitRectangle );
|
|
sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
|
|
rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
|
|
}
|
|
break;
|
|
|
|
case presentation::ClickAction_PROGRAM :
|
|
case presentation::ClickAction_BOOKMARK :
|
|
case presentation::ClickAction_DOCUMENT :
|
|
{
|
|
rtl::OUString aBookmark;
|
|
xShapePropSet->getPropertyValue( sBookmark ) >>= aBookmark;
|
|
if( aBookmark.getLength() )
|
|
{
|
|
switch( eCa )
|
|
{
|
|
case presentation::ClickAction_DOCUMENT :
|
|
case presentation::ClickAction_PROGRAM :
|
|
{
|
|
sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
|
|
rPDFExtOutDevData.SetLinkURL( nLinkId, aBookmark );
|
|
}
|
|
break;
|
|
case presentation::ClickAction_BOOKMARK :
|
|
{
|
|
sal_Int32 nPage = ImplPDFGetBookmarkPage( aBookmark, rDoc );
|
|
if ( nPage != -1 )
|
|
{
|
|
sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nPage, vcl::PDFWriter::FitRectangle );
|
|
sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
|
|
rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case presentation::ClickAction_STOPPRESENTATION :
|
|
case presentation::ClickAction_SOUND :
|
|
case presentation::ClickAction_INVISIBLE :
|
|
case presentation::ClickAction_VERB :
|
|
case presentation::ClickAction_VANISH :
|
|
case presentation::ClickAction_MACRO :
|
|
default :
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
vcl::PDFWriter::StructElement ImplRenderPaintProc::ImplBegStructureTag( SdrObject& rObject )
|
|
{
|
|
vcl::PDFWriter::StructElement eElement(vcl::PDFWriter::NonStructElement);
|
|
|
|
if ( pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportTaggedPDF() )
|
|
{
|
|
sal_uInt32 nInventor = rObject.GetObjInventor();
|
|
sal_uInt16 nIdentifier = rObject.GetObjIdentifier();
|
|
sal_Bool bIsTextObj = rObject.ISA( SdrTextObj );
|
|
|
|
if ( nInventor == SdrInventor )
|
|
{
|
|
if ( nIdentifier == OBJ_GRUP )
|
|
eElement = vcl::PDFWriter::Section;
|
|
else if ( nIdentifier == OBJ_TITLETEXT )
|
|
eElement = vcl::PDFWriter::Heading;
|
|
else if ( nIdentifier == OBJ_OUTLINETEXT )
|
|
eElement = vcl::PDFWriter::Division;
|
|
else if ( !bIsTextObj || !((SdrTextObj&)rObject).HasText() )
|
|
eElement = vcl::PDFWriter::Figure;
|
|
}
|
|
}
|
|
|
|
return eElement;
|
|
}
|
|
|
|
drawinglayer::primitive2d::Primitive2DSequence ImplRenderPaintProc::createRedirectedPrimitive2DSequence(
|
|
const sdr::contact::ViewObjectContact& rOriginal,
|
|
const sdr::contact::DisplayInfo& rDisplayInfo)
|
|
{
|
|
SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
|
|
|
|
if(pObject)
|
|
{
|
|
drawinglayer::primitive2d::Primitive2DSequence xRetval;
|
|
|
|
if(pObject->GetPage())
|
|
{
|
|
if(pObject->GetPage()->checkVisibility(rOriginal, rDisplayInfo, false))
|
|
{
|
|
if(IsVisible(pObject) && IsPrintable(pObject))
|
|
{
|
|
const vcl::PDFWriter::StructElement eElement(ImplBegStructureTag( *pObject ));
|
|
const bool bTagUsed(vcl::PDFWriter::NonStructElement != eElement);
|
|
|
|
xRetval = ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
|
|
|
|
if(xRetval.hasElements() && bTagUsed)
|
|
{
|
|
// embed Primitive2DSequence in a structure tag element for
|
|
// exactly this purpose (StructureTagPrimitive2D)
|
|
const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::StructureTagPrimitive2D(eElement, xRetval));
|
|
xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xReference, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return xRetval;
|
|
}
|
|
else
|
|
{
|
|
// not an object, maybe a page
|
|
return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
|
|
}
|
|
}
|
|
|
|
sal_Bool ImplRenderPaintProc::IsVisible( const SdrObject* pObj ) const
|
|
{
|
|
sal_Bool bVisible = sal_True;
|
|
SdrLayerID nLayerId = pObj->GetLayer();
|
|
if( pSdrPageView )
|
|
{
|
|
const SdrLayer* pSdrLayer = rLayerAdmin.GetLayer( nLayerId );
|
|
if ( pSdrLayer )
|
|
{
|
|
String aLayerName = pSdrLayer->GetName();
|
|
bVisible = pSdrPageView->IsLayerVisible( aLayerName );
|
|
}
|
|
}
|
|
return bVisible;
|
|
}
|
|
sal_Bool ImplRenderPaintProc::IsPrintable( const SdrObject* pObj ) const
|
|
{
|
|
sal_Bool bPrintable = sal_True;
|
|
SdrLayerID nLayerId = pObj->GetLayer();
|
|
if( pSdrPageView )
|
|
{
|
|
const SdrLayer* pSdrLayer = rLayerAdmin.GetLayer( nLayerId );
|
|
if ( pSdrLayer )
|
|
{
|
|
String aLayerName = pSdrLayer->GetName();
|
|
bPrintable = pSdrPageView->IsLayerPrintable( aLayerName );
|
|
}
|
|
}
|
|
return bPrintable;
|
|
|
|
}
|
|
void SAL_CALL SdXImpressDocument::render( sal_Int32 nRenderer, const uno::Any& rSelection,
|
|
const uno::Sequence< beans::PropertyValue >& rxOptions )
|
|
throw (lang::IllegalArgumentException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
if( mpDocShell && mpDoc )
|
|
{
|
|
uno::Reference< awt::XDevice > xRenderDevice;
|
|
const sal_Int32 nPageNumber = nRenderer + 1;
|
|
PageKind ePageKind = PK_STANDARD;
|
|
sal_Bool bExportNotesPages = sal_False;
|
|
|
|
for( sal_Int32 nProperty = 0, nPropertyCount = rxOptions.getLength(); nProperty < nPropertyCount; ++nProperty )
|
|
{
|
|
if( rxOptions[ nProperty ].Name == OUString( RTL_CONSTASCII_USTRINGPARAM( "RenderDevice" ) ) )
|
|
rxOptions[ nProperty].Value >>= xRenderDevice;
|
|
else if ( rxOptions[ nProperty ].Name == OUString( RTL_CONSTASCII_USTRINGPARAM( "ExportNotesPages" ) ) )
|
|
{
|
|
rxOptions[ nProperty].Value >>= bExportNotesPages;
|
|
if ( bExportNotesPages )
|
|
ePageKind = PK_NOTES;
|
|
}
|
|
}
|
|
|
|
if( xRenderDevice.is() && nPageNumber && ( nPageNumber <= mpDoc->GetSdPageCount( ePageKind ) ) )
|
|
{
|
|
VCLXDevice* pDevice = VCLXDevice::GetImplementation( xRenderDevice );
|
|
OutputDevice* pOut = pDevice ? pDevice->GetOutputDevice() : NULL;
|
|
|
|
if( pOut )
|
|
{
|
|
vcl::PDFExtOutDevData* pPDFExtOutDevData = PTR_CAST( vcl::PDFExtOutDevData, pOut->GetExtOutDevData() );
|
|
|
|
::sd::ClientView* pView = new ::sd::ClientView( mpDocShell, pOut, NULL );
|
|
Rectangle aVisArea = Rectangle( Point(), mpDoc->GetSdPage( (USHORT)nPageNumber - 1, ePageKind )->GetSize() );
|
|
Region aRegion( aVisArea );
|
|
Point aOrigin;
|
|
|
|
::sd::ViewShell* pOldViewSh = mpDocShell->GetViewShell();
|
|
::sd::View* pOldSdView = pOldViewSh ? pOldViewSh->GetView() : NULL;
|
|
|
|
if ( pOldSdView )
|
|
pOldSdView->SdrEndTextEdit();
|
|
|
|
pView->SetHlplVisible( sal_False );
|
|
pView->SetGridVisible( sal_False );
|
|
pView->SetBordVisible( sal_False );
|
|
pView->SetPageVisible( sal_False );
|
|
pView->SetGlueVisible( sal_False );
|
|
|
|
pOut->SetMapMode( MAP_100TH_MM );
|
|
pOut->IntersectClipRegion( aVisArea );
|
|
|
|
|
|
|
|
uno::Reference< frame::XModel > xModel;
|
|
rSelection >>= xModel;
|
|
|
|
if( xModel == mpDocShell->GetModel() )
|
|
{
|
|
pView->ShowSdrPage( mpDoc->GetSdPage( (USHORT)nPageNumber - 1, ePageKind ));
|
|
SdrPageView* pPV = pView->GetSdrPageView();
|
|
|
|
if( pOldSdView )
|
|
{
|
|
SdrPageView* pOldPV = pOldSdView->GetSdrPageView();
|
|
if( pPV && pOldPV )
|
|
{
|
|
pPV->SetVisibleLayers( pOldPV->GetVisibleLayers() );
|
|
pPV->SetPrintableLayers( pOldPV->GetPrintableLayers() );
|
|
}
|
|
}
|
|
|
|
ImplRenderPaintProc aImplRenderPaintProc( mpDoc->GetLayerAdmin(),
|
|
pPV, pPDFExtOutDevData );
|
|
|
|
// background color for outliner :o
|
|
SdPage* pPage = (SdPage*)pPV->GetPage();
|
|
if( pPage )
|
|
{
|
|
SdrOutliner& rOutl = mpDoc->GetDrawOutliner( NULL );
|
|
bool bScreenDisplay(true);
|
|
|
|
if(bScreenDisplay && pOut && OUTDEV_PRINTER == pOut->GetOutDevType())
|
|
{
|
|
// #i75566# printing; suppress AutoColor BackgroundColor generation
|
|
// for visibility reasons by giving GetPageBackgroundColor()
|
|
// the needed hint
|
|
bScreenDisplay = false;
|
|
}
|
|
|
|
if(bScreenDisplay && pOut && pOut->GetPDFWriter())
|
|
{
|
|
// #i75566# PDF export; suppress AutoColor BackgroundColor generation (see above)
|
|
bScreenDisplay = false;
|
|
}
|
|
|
|
// #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and
|
|
// hint value if screen display. Only then the AutoColor mechanisms shall be applied
|
|
rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor( pPV, bScreenDisplay ) );
|
|
}
|
|
pView->SdrPaintView::CompleteRedraw( pOut, aRegion, &aImplRenderPaintProc );
|
|
|
|
if ( pPDFExtOutDevData )
|
|
{
|
|
try
|
|
{
|
|
uno::Any aAny;
|
|
uno::Reference< drawing::XDrawPage > xPage( uno::Reference< drawing::XDrawPage >::query( pPage->getUnoPage() ) );
|
|
if ( xPage.is() )
|
|
{
|
|
uno::Reference< beans::XPropertySet > xPagePropSet( xPage, uno::UNO_QUERY );
|
|
if( xPagePropSet.is() )
|
|
{
|
|
// exporting object interactions to pdf
|
|
|
|
// if necessary, the master page interactions will be exported first
|
|
sal_Bool bIsBackgroundObjectsVisible = sal_False; // SJ: #i39428# IsBackgroundObjectsVisible not available for Draw
|
|
const rtl::OUString sIsBackgroundObjectsVisible( RTL_CONSTASCII_USTRINGPARAM( "IsBackgroundObjectsVisible" ) );
|
|
if ( mbImpressDoc && ( xPagePropSet->getPropertyValue( sIsBackgroundObjectsVisible ) >>= bIsBackgroundObjectsVisible ) && bIsBackgroundObjectsVisible )
|
|
{
|
|
uno::Reference< drawing::XMasterPageTarget > xMasterPageTarget( xPage, uno::UNO_QUERY );
|
|
if ( xMasterPageTarget.is() )
|
|
{
|
|
uno::Reference< drawing::XDrawPage > xMasterPage = xMasterPageTarget->getMasterPage();
|
|
if ( xMasterPage.is() )
|
|
{
|
|
uno::Reference< drawing::XShapes> xShapes( xMasterPage, uno::UNO_QUERY );
|
|
sal_Int32 i, nCount = xShapes->getCount();
|
|
for ( i = 0; i < nCount; i++ )
|
|
{
|
|
aAny = xShapes->getByIndex( i );
|
|
uno::Reference< drawing::XShape > xShape;
|
|
if ( aAny >>= xShape )
|
|
ImplPDFExportShapeInteraction( xShape, *mpDoc, *pPDFExtOutDevData );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// exporting slide page object interactions
|
|
uno::Reference< drawing::XShapes> xShapes( xPage, uno::UNO_QUERY );
|
|
sal_Int32 i, nCount = xShapes->getCount();
|
|
for ( i = 0; i < nCount; i++ )
|
|
{
|
|
aAny = xShapes->getByIndex( i );
|
|
uno::Reference< drawing::XShape > xShape;
|
|
if ( aAny >>= xShape )
|
|
ImplPDFExportShapeInteraction( xShape, *mpDoc, *pPDFExtOutDevData );
|
|
}
|
|
|
|
// exporting transition effects to pdf
|
|
if ( mbImpressDoc && pPDFExtOutDevData->GetIsExportTransitionEffects() ) // SJ: #i39428# TransitionEffects not available for Draw
|
|
{
|
|
const rtl::OUString sEffect( RTL_CONSTASCII_USTRINGPARAM( "Effect" ) );
|
|
const rtl::OUString sSpeed ( RTL_CONSTASCII_USTRINGPARAM( "Speed" ) );
|
|
sal_Int32 nTime = 800;
|
|
presentation::AnimationSpeed aAs;
|
|
aAny = xPagePropSet->getPropertyValue( sSpeed );
|
|
if ( aAny >>= aAs )
|
|
{
|
|
switch( aAs )
|
|
{
|
|
case presentation::AnimationSpeed_SLOW : nTime = 1500; break;
|
|
case presentation::AnimationSpeed_FAST : nTime = 300; break;
|
|
default:
|
|
case presentation::AnimationSpeed_MEDIUM : nTime = 800;
|
|
}
|
|
}
|
|
presentation::FadeEffect eFe;
|
|
aAny = xPagePropSet->getPropertyValue( sEffect );
|
|
vcl::PDFWriter::PageTransition eType = vcl::PDFWriter::Regular;
|
|
if ( aAny >>= eFe )
|
|
{
|
|
switch( eFe )
|
|
{
|
|
case presentation::FadeEffect_HORIZONTAL_LINES :
|
|
case presentation::FadeEffect_HORIZONTAL_CHECKERBOARD :
|
|
case presentation::FadeEffect_HORIZONTAL_STRIPES : eType = vcl::PDFWriter::BlindsHorizontal; break;
|
|
|
|
case presentation::FadeEffect_VERTICAL_LINES :
|
|
case presentation::FadeEffect_VERTICAL_CHECKERBOARD :
|
|
case presentation::FadeEffect_VERTICAL_STRIPES : eType = vcl::PDFWriter::BlindsVertical; break;
|
|
|
|
case presentation::FadeEffect_UNCOVER_TO_RIGHT :
|
|
case presentation::FadeEffect_UNCOVER_TO_UPPERRIGHT :
|
|
case presentation::FadeEffect_ROLL_FROM_LEFT :
|
|
case presentation::FadeEffect_FADE_FROM_UPPERLEFT :
|
|
case presentation::FadeEffect_MOVE_FROM_UPPERLEFT :
|
|
case presentation::FadeEffect_FADE_FROM_LEFT :
|
|
case presentation::FadeEffect_MOVE_FROM_LEFT : eType = vcl::PDFWriter::WipeLeftToRight; break;
|
|
|
|
case presentation::FadeEffect_UNCOVER_TO_BOTTOM :
|
|
case presentation::FadeEffect_UNCOVER_TO_LOWERRIGHT :
|
|
case presentation::FadeEffect_ROLL_FROM_TOP :
|
|
case presentation::FadeEffect_FADE_FROM_UPPERRIGHT :
|
|
case presentation::FadeEffect_MOVE_FROM_UPPERRIGHT :
|
|
case presentation::FadeEffect_FADE_FROM_TOP :
|
|
case presentation::FadeEffect_MOVE_FROM_TOP : eType = vcl::PDFWriter::WipeTopToBottom; break;
|
|
|
|
case presentation::FadeEffect_UNCOVER_TO_LEFT :
|
|
case presentation::FadeEffect_UNCOVER_TO_LOWERLEFT :
|
|
case presentation::FadeEffect_ROLL_FROM_RIGHT :
|
|
|
|
case presentation::FadeEffect_FADE_FROM_LOWERRIGHT :
|
|
case presentation::FadeEffect_MOVE_FROM_LOWERRIGHT :
|
|
case presentation::FadeEffect_FADE_FROM_RIGHT :
|
|
case presentation::FadeEffect_MOVE_FROM_RIGHT : eType = vcl::PDFWriter::WipeRightToLeft; break;
|
|
|
|
case presentation::FadeEffect_UNCOVER_TO_TOP :
|
|
case presentation::FadeEffect_UNCOVER_TO_UPPERLEFT :
|
|
case presentation::FadeEffect_ROLL_FROM_BOTTOM :
|
|
case presentation::FadeEffect_FADE_FROM_LOWERLEFT :
|
|
case presentation::FadeEffect_MOVE_FROM_LOWERLEFT :
|
|
case presentation::FadeEffect_FADE_FROM_BOTTOM :
|
|
case presentation::FadeEffect_MOVE_FROM_BOTTOM : eType = vcl::PDFWriter::WipeBottomToTop; break;
|
|
|
|
case presentation::FadeEffect_OPEN_VERTICAL : eType = vcl::PDFWriter::SplitHorizontalInward; break;
|
|
case presentation::FadeEffect_CLOSE_HORIZONTAL : eType = vcl::PDFWriter::SplitHorizontalOutward; break;
|
|
|
|
case presentation::FadeEffect_OPEN_HORIZONTAL : eType = vcl::PDFWriter::SplitVerticalInward; break;
|
|
case presentation::FadeEffect_CLOSE_VERTICAL : eType = vcl::PDFWriter::SplitVerticalOutward; break;
|
|
|
|
case presentation::FadeEffect_FADE_TO_CENTER : eType = vcl::PDFWriter::BoxInward; break;
|
|
case presentation::FadeEffect_FADE_FROM_CENTER : eType = vcl::PDFWriter::BoxOutward; break;
|
|
|
|
case presentation::FadeEffect_NONE : eType = vcl::PDFWriter::Regular; break;
|
|
|
|
case presentation::FadeEffect_RANDOM :
|
|
case presentation::FadeEffect_DISSOLVE :
|
|
default: eType = vcl::PDFWriter::Dissolve; break;
|
|
}
|
|
}
|
|
pPDFExtOutDevData->SetPageTransition( eType, nTime, -1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
Size aPageSize( mpDoc->GetSdPage( 0, PK_STANDARD )->GetSize() );
|
|
Point aPoint( 0, 0 );
|
|
Rectangle aPageRect( aPoint, aPageSize );
|
|
|
|
// resolving links found in this page by the method ImpEditEngine::Paint
|
|
std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = pPDFExtOutDevData->GetBookmarks();
|
|
std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIBeg = rBookmarks.begin();
|
|
std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIEnd = rBookmarks.end();
|
|
while ( aIBeg != aIEnd )
|
|
{
|
|
sal_Int32 nPage = ImplPDFGetBookmarkPage( aIBeg->aBookmark, *mpDoc );
|
|
if ( nPage != -1 )
|
|
pPDFExtOutDevData->SetLinkDest( aIBeg->nLinkId, pPDFExtOutDevData->CreateDest( aPageRect, nPage, vcl::PDFWriter::FitRectangle ) );
|
|
else
|
|
pPDFExtOutDevData->SetLinkURL( aIBeg->nLinkId, aIBeg->aBookmark );
|
|
aIBeg++;
|
|
}
|
|
rBookmarks.clear();
|
|
//---> i56629, i40318
|
|
//get the page name, will be used as outline element in PDF bookmark pane
|
|
String aPageName = mpDoc->GetSdPage( (USHORT)nPageNumber - 1 , PK_STANDARD )->GetName();
|
|
if( aPageName.Len() > 0 )
|
|
{
|
|
// insert the bookmark to this page into the NamedDestinations
|
|
if( pPDFExtOutDevData->GetIsExportNamedDestinations() )
|
|
pPDFExtOutDevData->CreateNamedDest( aPageName, aPageRect, nPageNumber - 1 );
|
|
//
|
|
// add the name to the outline, (almost) same code as in sc/source/ui/unoobj/docuno.cxx
|
|
// issue i40318.
|
|
//
|
|
if( pPDFExtOutDevData->GetIsExportBookmarks() )
|
|
{
|
|
// Destination Export
|
|
const sal_Int32 nDestId =
|
|
pPDFExtOutDevData->CreateDest( aPageRect , nPageNumber - 1 );
|
|
|
|
// Create a new outline item:
|
|
pPDFExtOutDevData->CreateOutlineItem( -1 , aPageName, nDestId );
|
|
}
|
|
}
|
|
//<--- i56629, i40318
|
|
}
|
|
catch( uno::Exception& )
|
|
{
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uno::Reference< drawing::XShapes > xShapes;
|
|
rSelection >>= xShapes;
|
|
|
|
if( xShapes.is() && xShapes->getCount() )
|
|
{
|
|
SdrPageView* pPV = NULL;
|
|
|
|
ImplRenderPaintProc aImplRenderPaintProc( mpDoc->GetLayerAdmin(),
|
|
pOldSdView ? pOldSdView->GetSdrPageView() : NULL, pPDFExtOutDevData );
|
|
|
|
for( sal_uInt32 i = 0, nCount = xShapes->getCount(); i < nCount; i++ )
|
|
{
|
|
uno::Reference< drawing::XShape > xShape;
|
|
xShapes->getByIndex( i ) >>= xShape;
|
|
|
|
if( xShape.is() )
|
|
{
|
|
SvxShape* pShape = SvxShape::getImplementation( xShape );
|
|
|
|
if( pShape )
|
|
{
|
|
SdrObject* pObj = pShape->GetSdrObject();
|
|
if( pObj && pObj->GetPage()
|
|
&& aImplRenderPaintProc.IsVisible( pObj )
|
|
&& aImplRenderPaintProc.IsPrintable( pObj ) )
|
|
{
|
|
if( !pPV )
|
|
pPV = pView->ShowSdrPage( pObj->GetPage() );
|
|
|
|
if( pPV )
|
|
pView->MarkObj( pObj, pPV );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pView->DrawMarkedObj(*pOut);
|
|
}
|
|
}
|
|
|
|
delete pView;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uno::Reference< i18n::XForbiddenCharacters > SdXImpressDocument::getForbiddenCharsTable()
|
|
{
|
|
uno::Reference< i18n::XForbiddenCharacters > xForb(mxForbidenCharacters);
|
|
|
|
if( !xForb.is() )
|
|
mxForbidenCharacters = xForb = new SdUnoForbiddenCharsTable( mpDoc );
|
|
|
|
return xForb;
|
|
}
|
|
|
|
void SdXImpressDocument::initializeDocument()
|
|
{
|
|
if( !mbClipBoard )
|
|
{
|
|
switch( mpDoc->GetPageCount() )
|
|
{
|
|
case 1:
|
|
{
|
|
// nasty hack to detect clipboard document
|
|
mbClipBoard = true;
|
|
break;
|
|
}
|
|
case 0:
|
|
{
|
|
mpDoc->CreateFirstPages();
|
|
mpDoc->StopWorkStartupDelay();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SAL_CALL SdXImpressDocument::dispose() throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
if( !mbDisposed )
|
|
{
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( mpDoc )
|
|
{
|
|
EndListening( *mpDoc );
|
|
mpDoc = NULL;
|
|
}
|
|
|
|
// Call the base class dispose() before setting the mbDisposed flag
|
|
// to true. The reason for this is that if close() has not yet been
|
|
// called this is done in SfxBaseModel::dispose(). At the end of
|
|
// that dispose() is called again. It is important to forward this
|
|
// second dispose() to the base class, too.
|
|
// As a consequence the following code has to be able to be run twice.
|
|
SfxBaseModel::dispose();
|
|
mbDisposed = true;
|
|
|
|
uno::Reference< container::XNameAccess > xStyles(mxStyleFamilies);
|
|
if( xStyles.is() )
|
|
{
|
|
uno::Reference< lang::XComponent > xComp( xStyles, uno::UNO_QUERY );
|
|
if( xComp.is() )
|
|
xComp->dispose();
|
|
|
|
xStyles = 0;
|
|
}
|
|
|
|
uno::Reference< presentation::XPresentation > xPresentation( mxPresentation );
|
|
if( xPresentation.is() )
|
|
{
|
|
uno::Reference< ::com::sun::star::presentation::XPresentation2 > xPres( mpDoc->getPresentation().get() );
|
|
uno::Reference< lang::XComponent > xPresComp( xPres, uno::UNO_QUERY );
|
|
if( xPresComp.is() )
|
|
xPresComp->dispose();
|
|
}
|
|
|
|
uno::Reference< container::XNameAccess > xLinks( mxLinks );
|
|
if( xLinks.is() )
|
|
{
|
|
uno::Reference< lang::XComponent > xComp( xLinks, uno::UNO_QUERY );
|
|
if( xComp.is() )
|
|
xComp->dispose();
|
|
|
|
xLinks = 0;
|
|
}
|
|
|
|
uno::Reference< drawing::XDrawPages > xDrawPagesAccess( mxDrawPagesAccess );
|
|
if( xDrawPagesAccess.is() )
|
|
{
|
|
uno::Reference< lang::XComponent > xComp( xDrawPagesAccess, uno::UNO_QUERY );
|
|
if( xComp.is() )
|
|
xComp->dispose();
|
|
|
|
xDrawPagesAccess = 0;
|
|
}
|
|
|
|
uno::Reference< drawing::XDrawPages > xMasterPagesAccess( mxMasterPagesAccess );
|
|
if( xDrawPagesAccess.is() )
|
|
{
|
|
uno::Reference< lang::XComponent > xComp( xMasterPagesAccess, uno::UNO_QUERY );
|
|
if( xComp.is() )
|
|
xComp->dispose();
|
|
|
|
xDrawPagesAccess = 0;
|
|
}
|
|
|
|
uno::Reference< container::XNameAccess > xLayerManager( mxLayerManager );
|
|
if( xLayerManager.is() )
|
|
{
|
|
uno::Reference< lang::XComponent > xComp( xLayerManager, uno::UNO_QUERY );
|
|
if( xComp.is() )
|
|
xComp->dispose();
|
|
|
|
xLayerManager = 0;
|
|
}
|
|
|
|
uno::Reference< container::XNameContainer > xCustomPresentationAccess( mxCustomPresentationAccess );
|
|
if( xCustomPresentationAccess.is() )
|
|
{
|
|
uno::Reference< lang::XComponent > xComp( xCustomPresentationAccess, uno::UNO_QUERY );
|
|
if( xComp.is() )
|
|
xComp->dispose();
|
|
|
|
xCustomPresentationAccess = 0;
|
|
}
|
|
|
|
mxDashTable = 0;
|
|
mxGradientTable = 0;
|
|
mxHatchTable = 0;
|
|
mxBitmapTable = 0;
|
|
mxTransGradientTable = 0;
|
|
mxMarkerTable = 0;
|
|
mxDrawingPool = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
// class SdDrawPagesAccess
|
|
//=============================================================================
|
|
|
|
SdDrawPagesAccess::SdDrawPagesAccess( SdXImpressDocument& rMyModel ) throw()
|
|
: mpModel( &rMyModel)
|
|
{
|
|
}
|
|
|
|
SdDrawPagesAccess::~SdDrawPagesAccess() throw()
|
|
{
|
|
}
|
|
|
|
// XIndexAccess
|
|
sal_Int32 SAL_CALL SdDrawPagesAccess::getCount()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
return mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
|
|
}
|
|
|
|
uno::Any SAL_CALL SdDrawPagesAccess::getByIndex( sal_Int32 Index )
|
|
throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Any aAny;
|
|
|
|
if( (Index < 0) || (Index >= mpModel->mpDoc->GetSdPageCount( PK_STANDARD ) ) )
|
|
throw lang::IndexOutOfBoundsException();
|
|
|
|
SdPage* pPage = mpModel->mpDoc->GetSdPage( (sal_uInt16)Index, PK_STANDARD );
|
|
if( pPage )
|
|
{
|
|
uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
|
|
aAny <<= xDrawPage;
|
|
}
|
|
|
|
return aAny;
|
|
}
|
|
|
|
// XNameAccess
|
|
uno::Any SAL_CALL SdDrawPagesAccess::getByName( const OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
if( aName.getLength() != 0 )
|
|
{
|
|
const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
|
|
sal_uInt16 nPage;
|
|
for( nPage = 0; nPage < nCount; nPage++ )
|
|
{
|
|
SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PK_STANDARD );
|
|
if(NULL == pPage)
|
|
continue;
|
|
|
|
if( aName == SdDrawPage::getPageApiName( pPage ) )
|
|
{
|
|
uno::Any aAny;
|
|
uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
|
|
aAny <<= xDrawPage;
|
|
return aAny;
|
|
}
|
|
}
|
|
}
|
|
|
|
throw container::NoSuchElementException();
|
|
}
|
|
|
|
uno::Sequence< OUString > SAL_CALL SdDrawPagesAccess::getElementNames() throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
|
|
uno::Sequence< OUString > aNames( nCount );
|
|
OUString* pNames = aNames.getArray();
|
|
|
|
sal_uInt16 nPage;
|
|
for( nPage = 0; nPage < nCount; nPage++ )
|
|
{
|
|
SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PK_STANDARD );
|
|
*pNames++ = SdDrawPage::getPageApiName( pPage );
|
|
}
|
|
|
|
return aNames;
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdDrawPagesAccess::hasByName( const OUString& aName ) throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
|
|
sal_uInt16 nPage;
|
|
for( nPage = 0; nPage < nCount; nPage++ )
|
|
{
|
|
SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PK_STANDARD );
|
|
if(NULL == pPage)
|
|
continue;
|
|
|
|
if( aName == SdDrawPage::getPageApiName( pPage ) )
|
|
return sal_True;
|
|
}
|
|
|
|
return sal_False;
|
|
}
|
|
|
|
// XElementAccess
|
|
uno::Type SAL_CALL SdDrawPagesAccess::getElementType()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return ITYPE( drawing::XDrawPage );
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdDrawPagesAccess::hasElements()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return getCount() > 0;
|
|
}
|
|
|
|
// XDrawPages
|
|
|
|
/******************************************************************************
|
|
* Erzeugt eine neue Seite mit Model an der angegebennen Position und gibt die *
|
|
* dazugehoerige SdDrawPage zurueck. *
|
|
******************************************************************************/
|
|
uno::Reference< drawing::XDrawPage > SAL_CALL SdDrawPagesAccess::insertNewByIndex( sal_Int32 nIndex )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
if( mpModel->mpDoc )
|
|
{
|
|
SdPage* pPage = mpModel->InsertSdPage( (sal_uInt16)nIndex );
|
|
if( pPage )
|
|
{
|
|
uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
|
|
return xDrawPage;
|
|
}
|
|
}
|
|
uno::Reference< drawing::XDrawPage > xDrawPage;
|
|
return xDrawPage;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Entfernt die angegebenne SdDrawPage aus dem Model und aus der internen *
|
|
* Liste. Dies funktioniert nur, wenn mindestens eine *normale* Seite im Model *
|
|
* nach dem entfernen dieser Seite vorhanden ist. *
|
|
******************************************************************************/
|
|
void SAL_CALL SdDrawPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel || mpModel->mpDoc == NULL )
|
|
throw lang::DisposedException();
|
|
|
|
SdDrawDocument& rDoc = *mpModel->mpDoc;
|
|
|
|
sal_uInt16 nPageCount = rDoc.GetSdPageCount( PK_STANDARD );
|
|
if( nPageCount > 1 )
|
|
{
|
|
// pPage von xPage besorgen und dann die Id (nPos )ermitteln
|
|
SdDrawPage* pSvxPage = SdDrawPage::getImplementation( xPage );
|
|
if( pSvxPage )
|
|
{
|
|
SdPage* pPage = (SdPage*) pSvxPage->GetSdrPage();
|
|
if(pPage && ( pPage->GetPageKind() == PK_STANDARD ) )
|
|
{
|
|
sal_uInt16 nPage = pPage->GetPageNum();
|
|
|
|
SdPage* pNotesPage = static_cast< SdPage* >( rDoc.GetPage( nPage+1 ) );
|
|
|
|
bool bUndo = rDoc.IsUndoEnabled();
|
|
if( bUndo )
|
|
{
|
|
// Add undo actions and delete the pages. The order of adding
|
|
// the undo actions is important.
|
|
rDoc.BegUndo( SdResId( STR_UNDO_DELETEPAGES ) );
|
|
rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
|
|
rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
|
|
}
|
|
|
|
rDoc.RemovePage( nPage ); // the page
|
|
rDoc.RemovePage( nPage ); // the notes page
|
|
|
|
if( bUndo )
|
|
{
|
|
rDoc.EndUndo();
|
|
}
|
|
else
|
|
{
|
|
delete pNotesPage;
|
|
delete pPage;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mpModel->SetModified();
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Char pSdDrawPagesAccessService[sizeof("com.sun.star.drawing.DrawPages")] = "com.sun.star.drawing.DrawPages";
|
|
|
|
OUString SAL_CALL SdDrawPagesAccess::getImplementationName( ) throw(uno::RuntimeException)
|
|
{
|
|
return OUString( RTL_CONSTASCII_USTRINGPARAM( "SdDrawPagesAccess" ) );
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdDrawPagesAccess::supportsService( const OUString& ServiceName ) throw(uno::RuntimeException)
|
|
{
|
|
return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( pSdDrawPagesAccessService ) );
|
|
}
|
|
|
|
uno::Sequence< OUString > SAL_CALL SdDrawPagesAccess::getSupportedServiceNames( ) throw(uno::RuntimeException)
|
|
{
|
|
OUString aService( RTL_CONSTASCII_USTRINGPARAM( pSdDrawPagesAccessService ) );
|
|
uno::Sequence< OUString > aSeq( &aService, 1 );
|
|
return aSeq;
|
|
}
|
|
|
|
// XComponent
|
|
void SAL_CALL SdDrawPagesAccess::dispose( ) throw (uno::RuntimeException)
|
|
{
|
|
mpModel = NULL;
|
|
}
|
|
|
|
void SAL_CALL SdDrawPagesAccess::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
|
|
{
|
|
DBG_ERROR( "not implemented!" );
|
|
}
|
|
|
|
void SAL_CALL SdDrawPagesAccess::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
|
|
{
|
|
DBG_ERROR( "not implemented!" );
|
|
}
|
|
|
|
//=============================================================================
|
|
// class SdMasterPagesAccess
|
|
//=============================================================================
|
|
|
|
SdMasterPagesAccess::SdMasterPagesAccess( SdXImpressDocument& rMyModel ) throw()
|
|
: mpModel(&rMyModel)
|
|
{
|
|
}
|
|
|
|
SdMasterPagesAccess::~SdMasterPagesAccess() throw()
|
|
{
|
|
}
|
|
|
|
// XComponent
|
|
void SAL_CALL SdMasterPagesAccess::dispose( ) throw (uno::RuntimeException)
|
|
{
|
|
mpModel = NULL;
|
|
}
|
|
|
|
void SAL_CALL SdMasterPagesAccess::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
|
|
{
|
|
DBG_ERROR( "not implemented!" );
|
|
}
|
|
|
|
void SAL_CALL SdMasterPagesAccess::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
|
|
{
|
|
DBG_ERROR( "not implemented!" );
|
|
}
|
|
|
|
// XIndexAccess
|
|
sal_Int32 SAL_CALL SdMasterPagesAccess::getCount()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel->mpDoc )
|
|
throw lang::DisposedException();
|
|
|
|
return mpModel->mpDoc->GetMasterSdPageCount(PK_STANDARD);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Liefert ein drawing::XDrawPage Interface fuer den Zugriff auf die Masterpage and der *
|
|
* angegebennen Position im Model. *
|
|
******************************************************************************/
|
|
uno::Any SAL_CALL SdMasterPagesAccess::getByIndex( sal_Int32 Index )
|
|
throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Any aAny;
|
|
|
|
if( (Index < 0) || (Index >= mpModel->mpDoc->GetMasterSdPageCount( PK_STANDARD ) ) )
|
|
throw lang::IndexOutOfBoundsException();
|
|
|
|
SdPage* pPage = mpModel->mpDoc->GetMasterSdPage( (sal_uInt16)Index, PK_STANDARD );
|
|
if( pPage )
|
|
{
|
|
uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
|
|
aAny <<= xDrawPage;
|
|
}
|
|
|
|
return aAny;
|
|
}
|
|
|
|
// XElementAccess
|
|
uno::Type SAL_CALL SdMasterPagesAccess::getElementType()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return ITYPE(drawing::XDrawPage);
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdMasterPagesAccess::hasElements()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return getCount() > 0;
|
|
}
|
|
|
|
// XDrawPages
|
|
uno::Reference< drawing::XDrawPage > SAL_CALL SdMasterPagesAccess::insertNewByIndex( sal_Int32 nInsertPos )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
uno::Reference< drawing::XDrawPage > xDrawPage;
|
|
|
|
SdDrawDocument* mpDoc = mpModel->mpDoc;
|
|
if( mpDoc )
|
|
{
|
|
// calculate internal index and check for range errors
|
|
const sal_Int32 nMPageCount = mpDoc->GetMasterPageCount();
|
|
nInsertPos = nInsertPos * 2 + 1;
|
|
if( nInsertPos < 0 || nInsertPos > nMPageCount )
|
|
nInsertPos = nMPageCount;
|
|
|
|
// now generate a unique name for the new masterpage
|
|
const String aStdPrefix( SdResId(STR_LAYOUT_DEFAULT_NAME) );
|
|
String aPrefix( aStdPrefix );
|
|
|
|
sal_Bool bUnique = sal_True;
|
|
sal_Int32 i = 0;
|
|
do
|
|
{
|
|
bUnique = sal_True;
|
|
for( sal_Int32 nMaster = 1; nMaster < nMPageCount; nMaster++ )
|
|
{
|
|
SdPage* pPage = (SdPage*)mpDoc->GetMasterPage((USHORT)nMaster);
|
|
if( pPage && pPage->GetName() == aPrefix )
|
|
{
|
|
bUnique = sal_False;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( !bUnique )
|
|
{
|
|
i++;
|
|
aPrefix = aStdPrefix;
|
|
aPrefix += sal_Unicode( ' ' );
|
|
aPrefix += String::CreateFromInt32( i );
|
|
}
|
|
|
|
} while( !bUnique );
|
|
|
|
String aLayoutName( aPrefix );
|
|
aLayoutName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR ));
|
|
aLayoutName += String(SdResId(STR_LAYOUT_OUTLINE));
|
|
|
|
// create styles
|
|
((SdStyleSheetPool*)mpDoc->GetStyleSheetPool())->CreateLayoutStyleSheets( aPrefix );
|
|
|
|
// get the first page for initial size and border settings
|
|
SdPage* pPage = mpModel->mpDoc->GetSdPage( (sal_uInt16)0, PK_STANDARD );
|
|
SdPage* pRefNotesPage = mpModel->mpDoc->GetSdPage( (sal_uInt16)0, PK_NOTES);
|
|
|
|
// create and instert new draw masterpage
|
|
SdPage* pMPage = (SdPage*)mpModel->mpDoc->AllocPage(sal_True);
|
|
pMPage->SetSize( pPage->GetSize() );
|
|
pMPage->SetBorder( pPage->GetLftBorder(),
|
|
pPage->GetUppBorder(),
|
|
pPage->GetRgtBorder(),
|
|
pPage->GetLwrBorder() );
|
|
pMPage->SetLayoutName( aLayoutName );
|
|
mpDoc->InsertMasterPage(pMPage, (USHORT)nInsertPos);
|
|
|
|
{ // insert background object
|
|
Point aBackgroundPos ( pMPage->GetLftBorder(), pMPage->GetUppBorder() );
|
|
Size aBackgroundSize ( pMPage->GetSize() );
|
|
aBackgroundSize.Width() -= pMPage->GetLftBorder() + pMPage->GetRgtBorder() - 1;
|
|
aBackgroundSize.Height() -= pMPage->GetUppBorder() + pMPage->GetLwrBorder() - 1;
|
|
Rectangle aBackgroundRect (aBackgroundPos, aBackgroundSize);
|
|
pMPage->CreatePresObj(PRESOBJ_BACKGROUND, FALSE, aBackgroundRect, sal_True );
|
|
}
|
|
|
|
xDrawPage = uno::Reference< drawing::XDrawPage >::query( pMPage->getUnoPage() );
|
|
|
|
// create and instert new notes masterpage
|
|
SdPage* pMNotesPage = (SdPage*)mpModel->mpDoc->AllocPage(sal_True);
|
|
pMNotesPage->SetSize( pRefNotesPage->GetSize() );
|
|
pMNotesPage->SetPageKind(PK_NOTES);
|
|
pMNotesPage->SetBorder( pRefNotesPage->GetLftBorder(),
|
|
pRefNotesPage->GetUppBorder(),
|
|
pRefNotesPage->GetRgtBorder(),
|
|
pRefNotesPage->GetLwrBorder() );
|
|
pMNotesPage->SetLayoutName( aLayoutName );
|
|
mpDoc->InsertMasterPage(pMNotesPage, (USHORT)nInsertPos + 1);
|
|
// pMNotesPage->InsertMasterPage( pMPage->GetPageNum() );
|
|
pMNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, sal_True, sal_True);
|
|
mpModel->SetModified();
|
|
}
|
|
|
|
return( xDrawPage );
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Entfernt die angegebenne SdMasterPage aus dem Model und aus der internen *
|
|
* Liste. Dies funktioniert nur, wenn keine *normale* Seite im Model diese *
|
|
* Seite als Masterpage benutzt. *
|
|
******************************************************************************/
|
|
void SAL_CALL SdMasterPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel || mpModel->mpDoc == NULL )
|
|
throw lang::DisposedException();
|
|
|
|
SdDrawDocument& rDoc = *mpModel->mpDoc;
|
|
|
|
SdMasterPage* pSdPage = SdMasterPage::getImplementation( xPage );
|
|
if(pSdPage == NULL)
|
|
return;
|
|
|
|
SdPage* pPage = dynamic_cast< SdPage* > (pSdPage->GetSdrPage());
|
|
|
|
DBG_ASSERT( pPage && pPage->IsMasterPage(), "SdMasterPage is not masterpage?");
|
|
|
|
if( !pPage || !pPage->IsMasterPage() || (mpModel->mpDoc->GetMasterPageUserCount(pPage) > 0))
|
|
return; //Todo: this should be excepted
|
|
|
|
// only standard pages can be removed directly
|
|
if( pPage->GetPageKind() == PK_STANDARD )
|
|
{
|
|
sal_uInt16 nPage = pPage->GetPageNum();
|
|
|
|
SdPage* pNotesPage = static_cast< SdPage* >( rDoc.GetMasterPage( nPage+1 ) );
|
|
|
|
bool bUndo = rDoc.IsUndoEnabled();
|
|
if( bUndo )
|
|
{
|
|
// Add undo actions and delete the pages. The order of adding
|
|
// the undo actions is important.
|
|
rDoc.BegUndo( SdResId( STR_UNDO_DELETEPAGES ) );
|
|
rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
|
|
rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
|
|
}
|
|
|
|
rDoc.RemoveMasterPage( nPage );
|
|
rDoc.RemoveMasterPage( nPage );
|
|
|
|
if( bUndo )
|
|
{
|
|
rDoc.EndUndo();
|
|
}
|
|
else
|
|
{
|
|
delete pNotesPage;
|
|
delete pPage;
|
|
}
|
|
}
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Char pSdMasterPagesAccessService[sizeof("com.sun.star.drawing.MasterPages")] = "com.sun.star.drawing.MasterPages";
|
|
|
|
OUString SAL_CALL SdMasterPagesAccess::getImplementationName( ) throw(uno::RuntimeException)
|
|
{
|
|
return OUString( RTL_CONSTASCII_USTRINGPARAM( "SdMasterPagesAccess" ) );
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdMasterPagesAccess::supportsService( const OUString& ServiceName ) throw(uno::RuntimeException)
|
|
{
|
|
return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( pSdMasterPagesAccessService ) );
|
|
}
|
|
|
|
uno::Sequence< OUString > SAL_CALL SdMasterPagesAccess::getSupportedServiceNames( ) throw(uno::RuntimeException)
|
|
{
|
|
OUString aService( RTL_CONSTASCII_USTRINGPARAM( pSdMasterPagesAccessService ) );
|
|
uno::Sequence< OUString > aSeq( &aService, 1 );
|
|
return aSeq;
|
|
}
|
|
|
|
//=============================================================================
|
|
// class SdDocLinkTargets
|
|
//=============================================================================
|
|
|
|
SdDocLinkTargets::SdDocLinkTargets( SdXImpressDocument& rMyModel ) throw()
|
|
: mpModel( &rMyModel )
|
|
{
|
|
}
|
|
|
|
SdDocLinkTargets::~SdDocLinkTargets() throw()
|
|
{
|
|
}
|
|
|
|
// XComponent
|
|
void SAL_CALL SdDocLinkTargets::dispose( ) throw (uno::RuntimeException)
|
|
{
|
|
mpModel = NULL;
|
|
}
|
|
|
|
void SAL_CALL SdDocLinkTargets::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
|
|
{
|
|
DBG_ERROR( "not implemented!" );
|
|
}
|
|
|
|
void SAL_CALL SdDocLinkTargets::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
|
|
{
|
|
DBG_ERROR( "not implemented!" );
|
|
}
|
|
|
|
// XNameAccess
|
|
uno::Any SAL_CALL SdDocLinkTargets::getByName( const OUString& aName )
|
|
throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
SdPage* pPage = FindPage( aName );
|
|
|
|
if( pPage == NULL )
|
|
throw container::NoSuchElementException();
|
|
|
|
uno::Any aAny;
|
|
|
|
uno::Reference< beans::XPropertySet > xProps( pPage->getUnoPage(), uno::UNO_QUERY );
|
|
if( xProps.is() )
|
|
aAny <<= xProps;
|
|
|
|
return aAny;
|
|
}
|
|
|
|
uno::Sequence< OUString > SAL_CALL SdDocLinkTargets::getElementNames()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
SdDrawDocument* mpDoc = mpModel->GetDoc();
|
|
if( mpDoc == NULL )
|
|
{
|
|
uno::Sequence< OUString > aSeq;
|
|
return aSeq;
|
|
}
|
|
|
|
if( mpDoc->GetDocumentType() == DOCUMENT_TYPE_DRAW )
|
|
{
|
|
const sal_uInt16 nMaxPages = mpDoc->GetSdPageCount( PK_STANDARD );
|
|
const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterSdPageCount( PK_STANDARD );
|
|
|
|
uno::Sequence< OUString > aSeq( nMaxPages + nMaxMasterPages );
|
|
OUString* pStr = aSeq.getArray();
|
|
|
|
sal_uInt16 nPage;
|
|
// standard pages
|
|
for( nPage = 0; nPage < nMaxPages; nPage++ )
|
|
*pStr++ = mpDoc->GetSdPage( nPage, PK_STANDARD )->GetName();
|
|
|
|
// master pages
|
|
for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
|
|
*pStr++ = mpDoc->GetMasterSdPage( nPage, PK_STANDARD )->GetName();
|
|
return aSeq;
|
|
}
|
|
else
|
|
{
|
|
const sal_uInt16 nMaxPages = mpDoc->GetPageCount();
|
|
const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterPageCount();
|
|
|
|
uno::Sequence< OUString > aSeq( nMaxPages + nMaxMasterPages );
|
|
OUString* pStr = aSeq.getArray();
|
|
|
|
sal_uInt16 nPage;
|
|
// standard pages
|
|
for( nPage = 0; nPage < nMaxPages; nPage++ )
|
|
*pStr++ = ((SdPage*)mpDoc->GetPage( nPage ))->GetName();
|
|
|
|
// master pages
|
|
for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
|
|
*pStr++ = ((SdPage*)mpDoc->GetMasterPage( nPage ))->GetName();
|
|
return aSeq;
|
|
}
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdDocLinkTargets::hasByName( const OUString& aName )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
return FindPage( aName ) != NULL;
|
|
}
|
|
|
|
// container::XElementAccess
|
|
uno::Type SAL_CALL SdDocLinkTargets::getElementType()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return ITYPE(beans::XPropertySet);
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdDocLinkTargets::hasElements()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
OGuard aGuard( Application::GetSolarMutex() );
|
|
|
|
if( NULL == mpModel )
|
|
throw lang::DisposedException();
|
|
|
|
return mpModel->GetDoc() != NULL;
|
|
}
|
|
|
|
SdPage* SdDocLinkTargets::FindPage( const OUString& rName ) const throw()
|
|
{
|
|
SdDrawDocument* mpDoc = mpModel->GetDoc();
|
|
if( mpDoc == NULL )
|
|
return NULL;
|
|
|
|
const sal_uInt16 nMaxPages = mpDoc->GetPageCount();
|
|
const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterPageCount();
|
|
|
|
sal_uInt16 nPage;
|
|
SdPage* pPage;
|
|
|
|
const String aName( rName );
|
|
|
|
const bool bDraw = mpDoc->GetDocumentType() == DOCUMENT_TYPE_DRAW;
|
|
|
|
// standard pages
|
|
for( nPage = 0; nPage < nMaxPages; nPage++ )
|
|
{
|
|
pPage = (SdPage*)mpDoc->GetPage( nPage );
|
|
if( (pPage->GetName() == aName) && (!bDraw || (pPage->GetPageKind() == PK_STANDARD)) )
|
|
return pPage;
|
|
}
|
|
|
|
// master pages
|
|
for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
|
|
{
|
|
pPage = (SdPage*)mpDoc->GetMasterPage( nPage );
|
|
if( (pPage->GetName() == aName) && (!bDraw || (pPage->GetPageKind() == PK_STANDARD)) )
|
|
return pPage;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// XServiceInfo
|
|
OUString SAL_CALL SdDocLinkTargets::getImplementationName()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return OUString( RTL_CONSTASCII_USTRINGPARAM("SdDocLinkTargets") );
|
|
}
|
|
|
|
sal_Bool SAL_CALL SdDocLinkTargets::supportsService( const OUString& ServiceName )
|
|
throw(uno::RuntimeException)
|
|
{
|
|
return SvxServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
|
|
}
|
|
|
|
uno::Sequence< OUString > SAL_CALL SdDocLinkTargets::getSupportedServiceNames()
|
|
throw(uno::RuntimeException)
|
|
{
|
|
const OUString aSN( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.LinkTargets") );
|
|
uno::Sequence< OUString > aSeq( &aSN, 1 );
|
|
return aSeq;
|
|
}
|
|
|
|
rtl::Reference< SdXImpressDocument > SdXImpressDocument::GetModel( SdDrawDocument* pDocument )
|
|
{
|
|
rtl::Reference< SdXImpressDocument > xRet;
|
|
if( pDocument )
|
|
{
|
|
::sd::DrawDocShell* pDocShell = pDocument->GetDocSh();
|
|
if( pDocShell )
|
|
{
|
|
uno::Reference<frame::XModel> xModel(pDocShell->GetModel());
|
|
|
|
xRet.set( dynamic_cast< SdXImpressDocument* >( xModel.get() ) );
|
|
}
|
|
}
|
|
|
|
return xRet;
|
|
}
|
|
|
|
void NotifyDocumentEvent( SdDrawDocument* pDocument, const rtl::OUString& rEventName )
|
|
{
|
|
rtl::Reference< SdXImpressDocument > xModel( SdXImpressDocument::GetModel( pDocument ) );
|
|
|
|
if( xModel.is() )
|
|
{
|
|
uno::Reference< uno::XInterface > xSource( static_cast<uno::XWeak*>( xModel.get() ) );
|
|
::com::sun::star::document::EventObject aEvent( xSource, rEventName );
|
|
xModel->notifyEvent(aEvent );
|
|
}
|
|
}
|
|
|
|
void NotifyDocumentEvent( SdDrawDocument* pDocument, const rtl::OUString& rEventName, const uno::Reference< uno::XInterface >& xSource )
|
|
{
|
|
rtl::Reference< SdXImpressDocument > xModel( SdXImpressDocument::GetModel( pDocument ) );
|
|
|
|
if( xModel.is() )
|
|
{
|
|
::com::sun::star::document::EventObject aEvent( xSource, rEventName );
|
|
xModel->notifyEvent(aEvent );
|
|
}
|
|
}
|