Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <com/sun/star/presentation/XPresentation2.hpp>
22 :
23 : #include <com/sun/star/lang/DisposedException.hpp>
24 : #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
25 : #include <com/sun/star/lang/Locale.hpp>
26 : #include <com/sun/star/style/XStyle.hpp>
27 : #include <com/sun/star/awt/XDevice.hpp>
28 :
29 : #include <com/sun/star/embed/Aspects.hpp>
30 :
31 : #include <osl/mutex.hxx>
32 : #include <comphelper/sequence.hxx>
33 : #include <comphelper/servicehelper.hxx>
34 : #include <comphelper/serviceinfohelper.hxx>
35 :
36 : #include <editeng/unofield.hxx>
37 : #include <unomodel.hxx>
38 : #include <sfx2/dispatch.hxx>
39 : #include <sfx2/bindings.hxx>
40 : #include <vcl/svapp.hxx>
41 : #include <editeng/UnoForbiddenCharsTable.hxx>
42 : #include <svx/svdoutl.hxx>
43 : #include <editeng/forbiddencharacterstable.hxx>
44 : #include <svx/UnoNamespaceMap.hxx>
45 : #include <svx/svdlayer.hxx>
46 : #include <svx/svdsob.hxx>
47 : #include <svx/unoapi.hxx>
48 : #include <svx/unofill.hxx>
49 : #include <svx/unopool.hxx>
50 : #include <svx/svdorect.hxx>
51 : #include <editeng/flditem.hxx>
52 : #include <toolkit/awt/vclxdevice.hxx>
53 : #include <svx/svdpool.hxx>
54 : #include <editeng/unolingu.hxx>
55 : #include <svx/svdpagv.hxx>
56 : #include <svtools/unoimap.hxx>
57 : #include <svx/unoshape.hxx>
58 : #include <editeng/unonrule.hxx>
59 : #include <editeng/eeitem.hxx>
60 :
61 : // Support creation of GraphicObjectResolver and EmbeddedObjectResolver
62 : #include <svx/xmleohlp.hxx>
63 : #include <svx/xmlgrhlp.hxx>
64 : #include "DrawDocShell.hxx"
65 : #include "ViewShellBase.hxx"
66 : #include <UnoDocumentSettings.hxx>
67 :
68 : #include <drawdoc.hxx>
69 : #include <glob.hrc>
70 : #include <sdresid.hxx>
71 : #include <sdpage.hxx>
72 :
73 : #include <strings.hrc>
74 : #include "unohelp.hxx"
75 : #include <unolayer.hxx>
76 : #include <unoprnms.hxx>
77 : #include <unopage.hxx>
78 : #include <unocpres.hxx>
79 : #include <unoobj.hxx>
80 : #include <stlpool.hxx>
81 : #include <unopback.hxx>
82 : #include <unokywds.hxx>
83 : #include "FrameView.hxx"
84 : #include "ClientView.hxx"
85 : #include "ViewShell.hxx"
86 : #include "app.hrc"
87 : #include <vcl/pdfextoutdevdata.hxx>
88 : #include <com/sun/star/presentation/AnimationEffect.hpp>
89 : #include <com/sun/star/presentation/AnimationSpeed.hpp>
90 : #include <com/sun/star/presentation/ClickAction.hpp>
91 : #include <svx/sdr/contact/viewobjectcontact.hxx>
92 : #include <svx/sdr/contact/viewcontact.hxx>
93 : #include <svx/sdr/contact/displayinfo.hxx>
94 :
95 : #include <com/sun/star/office/XAnnotation.hpp>
96 : #include <com/sun/star/office/XAnnotationAccess.hpp>
97 : #include <com/sun/star/office/XAnnotationEnumeration.hpp>
98 : #include <com/sun/star/geometry/RealPoint2D.hpp>
99 : #include <com/sun/star/util/DateTime.hpp>
100 :
101 : using ::rtl::OUString;
102 :
103 : #include <drawinglayer/primitive2d/structuretagprimitive2d.hxx>
104 :
105 : using namespace ::osl;
106 : using namespace ::cppu;
107 : using namespace ::com::sun::star;
108 :
109 : extern uno::Reference< uno::XInterface > SdUnoCreatePool( SdDrawDocument* pDrawModel );
110 :
111 : class SdUnoForbiddenCharsTable : public SvxUnoForbiddenCharsTable,
112 : public SfxListener
113 : {
114 : public:
115 : SdUnoForbiddenCharsTable( SdrModel* pModel );
116 : ~SdUnoForbiddenCharsTable();
117 :
118 : // SfxListener
119 : virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) throw ();
120 : protected:
121 : virtual void onChange();
122 :
123 : private:
124 : SdrModel* mpModel;
125 : };
126 :
127 2 : SdUnoForbiddenCharsTable::SdUnoForbiddenCharsTable( SdrModel* pModel )
128 2 : : SvxUnoForbiddenCharsTable( pModel->GetForbiddenCharsTable() ), mpModel( pModel )
129 : {
130 2 : StartListening( *pModel );
131 2 : }
132 :
133 3 : void SdUnoForbiddenCharsTable::onChange()
134 : {
135 3 : if( mpModel )
136 : {
137 3 : mpModel->ReformatAllTextObjects();
138 : }
139 3 : }
140 :
141 6 : SdUnoForbiddenCharsTable::~SdUnoForbiddenCharsTable()
142 : {
143 2 : if( mpModel )
144 2 : EndListening( *mpModel );
145 4 : }
146 :
147 0 : void SdUnoForbiddenCharsTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
148 : {
149 0 : const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
150 :
151 0 : if( pSdrHint )
152 : {
153 0 : if( HINT_MODELCLEARED == pSdrHint->GetKind() )
154 : {
155 0 : mpModel = NULL;
156 : }
157 : }
158 0 : }
159 :
160 : ///////////////////////////////////////////////////////////////////////
161 :
162 : const sal_Int32 WID_MODEL_LANGUAGE = 1;
163 : const sal_Int32 WID_MODEL_TABSTOP = 2;
164 : const sal_Int32 WID_MODEL_VISAREA = 3;
165 : const sal_Int32 WID_MODEL_MAPUNIT = 4;
166 : const sal_Int32 WID_MODEL_FORBCHARS= 5;
167 : const sal_Int32 WID_MODEL_CONTFOCUS = 6;
168 : const sal_Int32 WID_MODEL_DSGNMODE = 7;
169 : const sal_Int32 WID_MODEL_BASICLIBS = 8;
170 : const sal_Int32 WID_MODEL_RUNTIMEUID = 9;
171 : const sal_Int32 WID_MODEL_BUILDID = 10;
172 : const sal_Int32 WID_MODEL_HASVALIDSIGNATURES = 11;
173 : const sal_Int32 WID_MODEL_DIALOGLIBS = 12;
174 :
175 18 : const SvxItemPropertySet* ImplGetDrawModelPropertySet()
176 : {
177 : // Achtung: Der erste Parameter MUSS sortiert vorliegen !!!
178 : const static SfxItemPropertyMapEntry aDrawModelPropertyMap_Impl[] =
179 : {
180 2 : { MAP_CHAR_LEN("BuildId"), WID_MODEL_BUILDID, &::getCppuType(static_cast< const rtl::OUString * >(0)), 0, 0},
181 2 : { MAP_CHAR_LEN(sUNO_Prop_CharLocale), WID_MODEL_LANGUAGE, &::getCppuType((const lang::Locale*)0), 0, 0},
182 2 : { MAP_CHAR_LEN(sUNO_Prop_TabStop), WID_MODEL_TABSTOP, &::getCppuType((const sal_Int32*)0), 0, 0},
183 2 : { MAP_CHAR_LEN(sUNO_Prop_VisibleArea), WID_MODEL_VISAREA, &::getCppuType((const awt::Rectangle*)0), 0, 0},
184 2 : { MAP_CHAR_LEN(sUNO_Prop_MapUnit), WID_MODEL_MAPUNIT, &::getCppuType((const sal_Int16*)0), beans::PropertyAttribute::READONLY, 0},
185 2 : { MAP_CHAR_LEN(sUNO_Prop_ForbiddenCharacters), WID_MODEL_FORBCHARS,&::getCppuType((const uno::Reference< i18n::XForbiddenCharacters > *)0), beans::PropertyAttribute::READONLY, 0 },
186 2 : { MAP_CHAR_LEN(sUNO_Prop_AutomContFocus ), WID_MODEL_CONTFOCUS, &::getBooleanCppuType(), 0, 0},
187 2 : { MAP_CHAR_LEN(sUNO_Prop_ApplyFrmDsgnMode), WID_MODEL_DSGNMODE, &::getBooleanCppuType(), 0, 0},
188 2 : { MAP_CHAR_LEN("BasicLibraries"), WID_MODEL_BASICLIBS,&::getCppuType((const uno::Reference< script::XLibraryContainer > *)0), beans::PropertyAttribute::READONLY, 0 },
189 2 : { MAP_CHAR_LEN("DialogLibraries"), WID_MODEL_DIALOGLIBS, &::getCppuType((const uno::Reference< script::XLibraryContainer > *)0), beans::PropertyAttribute::READONLY, 0 },
190 2 : { MAP_CHAR_LEN(sUNO_Prop_RuntimeUID), WID_MODEL_RUNTIMEUID, &::getCppuType(static_cast< const rtl::OUString * >(0)), beans::PropertyAttribute::READONLY, 0 },
191 2 : { MAP_CHAR_LEN(sUNO_Prop_HasValidSignatures), WID_MODEL_HASVALIDSIGNATURES, &::getCppuType(static_cast< const sal_Bool * >(0)), beans::PropertyAttribute::READONLY, 0 },
192 : { 0,0,0,0,0,0 }
193 42 : };
194 18 : static SvxItemPropertySet aDrawModelPropertySet_Impl( aDrawModelPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
195 18 : return &aDrawModelPropertySet_Impl;
196 : }
197 :
198 : // this ctor is used from the DocShell
199 18 : SdXImpressDocument::SdXImpressDocument (::sd::DrawDocShell* pShell, bool bClipBoard ) throw()
200 : : SfxBaseModel( pShell ),
201 : mpDocShell( pShell ),
202 : mpDoc( pShell ? pShell->GetDoc() : NULL ),
203 : mbDisposed(false),
204 36 : mbImpressDoc( pShell && pShell->GetDoc() && pShell->GetDoc()->GetDocumentType() == DOCUMENT_TYPE_IMPRESS ),
205 : mbClipBoard( bClipBoard ),
206 54 : mpPropSet( ImplGetDrawModelPropertySet() )
207 : {
208 18 : if( mpDoc )
209 : {
210 18 : StartListening( *mpDoc );
211 : }
212 : else
213 : {
214 : OSL_FAIL("DocShell is invalid");
215 : }
216 18 : }
217 :
218 0 : SdXImpressDocument::SdXImpressDocument( SdDrawDocument* pDoc, bool bClipBoard ) throw()
219 : : SfxBaseModel( NULL ),
220 : mpDocShell( NULL ),
221 : mpDoc( pDoc ),
222 : mbDisposed(false),
223 0 : mbImpressDoc( pDoc && pDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS ),
224 : mbClipBoard( bClipBoard ),
225 0 : mpPropSet( ImplGetDrawModelPropertySet() )
226 : {
227 0 : if( mpDoc )
228 : {
229 0 : StartListening( *mpDoc );
230 : }
231 : else
232 : {
233 : OSL_FAIL("SdDrawDocument is invalid");
234 : }
235 0 : }
236 :
237 : /***********************************************************************
238 : * *
239 : ***********************************************************************/
240 32 : SdXImpressDocument::~SdXImpressDocument() throw()
241 : {
242 32 : }
243 :
244 : // XInterface
245 1833 : uno::Any SAL_CALL SdXImpressDocument::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException)
246 : {
247 1833 : uno::Any aAny;
248 :
249 1833 : QUERYINT(lang::XServiceInfo);
250 1805 : else QUERYINT(beans::XPropertySet);
251 1772 : else QUERYINT(lang::XMultiServiceFactory);
252 1527 : else QUERYINT(drawing::XDrawPageDuplicator);
253 1527 : else QUERYINT(drawing::XLayerSupplier);
254 1525 : else QUERYINT(drawing::XMasterPagesSupplier);
255 1513 : else QUERYINT(drawing::XDrawPagesSupplier);
256 1498 : else QUERYINT(presentation::XHandoutMasterSupplier);
257 1497 : else QUERYINT(document::XLinkTargetSupplier);
258 1497 : else QUERYINT(style::XStyleFamiliesSupplier);
259 1375 : else QUERYINT(com::sun::star::ucb::XAnyCompareFactory);
260 1364 : else QUERYINT(view::XRenderable);
261 1364 : else if( mbImpressDoc && rType == ITYPE(presentation::XPresentationSupplier) )
262 1 : aAny <<= uno::Reference< presentation::XPresentationSupplier >(this);
263 1363 : else if( mbImpressDoc && rType == ITYPE(presentation::XCustomPresentationSupplier) )
264 1 : aAny <<= uno::Reference< presentation::XCustomPresentationSupplier >(this);
265 : else
266 1362 : return SfxBaseModel::queryInterface( rType );
267 :
268 471 : return aAny;
269 : }
270 :
271 3651 : void SAL_CALL SdXImpressDocument::acquire() throw ( )
272 : {
273 3651 : SfxBaseModel::acquire();
274 3651 : }
275 :
276 3643 : void SAL_CALL SdXImpressDocument::release() throw ( )
277 : {
278 3643 : if (osl_atomic_decrement( &m_refCount ) == 0)
279 : {
280 : // restore reference count:
281 16 : osl_atomic_increment( &m_refCount );
282 16 : if(!mbDisposed)
283 : {
284 : try
285 : {
286 0 : dispose();
287 : }
288 0 : catch (const uno::RuntimeException& exc)
289 : { // don't break throw ()
290 : OSL_FAIL(
291 : OUStringToOString(
292 : exc.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
293 : static_cast<void>(exc);
294 : }
295 : }
296 16 : SfxBaseModel::release();
297 : }
298 3643 : }
299 :
300 : namespace
301 : {
302 : class theSdXImpressDocumentUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSdXImpressDocumentUnoTunnelId> {};
303 : }
304 :
305 : // XUnoTunnel
306 140 : const ::com::sun::star::uno::Sequence< sal_Int8 > & SdXImpressDocument::getUnoTunnelId() throw()
307 : {
308 140 : return theSdXImpressDocumentUnoTunnelId::get().getSeq();
309 : }
310 :
311 64 : SdXImpressDocument* SdXImpressDocument::getImplementation( const uno::Reference< uno::XInterface >& xInt )
312 : {
313 64 : ::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xUT( xInt, ::com::sun::star::uno::UNO_QUERY );
314 64 : if( xUT.is() )
315 64 : return reinterpret_cast<SdXImpressDocument*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething( SdXImpressDocument::getUnoTunnelId() )));
316 : else
317 0 : return NULL;
318 : }
319 :
320 76 : sal_Int64 SAL_CALL SdXImpressDocument::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rIdentifier ) throw(::com::sun::star::uno::RuntimeException)
321 : {
322 76 : if( rIdentifier.getLength() == 16 )
323 : {
324 76 : if( (0 == memcmp( SdXImpressDocument::getUnoTunnelId().getConstArray(), rIdentifier.getConstArray(), 16 )) )
325 64 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
326 :
327 12 : if( (0 == memcmp( SdrModel::getUnoTunnelImplementationId().getConstArray(), rIdentifier.getConstArray(), 16 )) )
328 0 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(mpDoc));
329 : }
330 :
331 12 : return SfxBaseModel::getSomething( rIdentifier );
332 : }
333 :
334 : // XTypeProvider
335 0 : uno::Sequence< uno::Type > SAL_CALL SdXImpressDocument::getTypes( ) throw(uno::RuntimeException)
336 : {
337 0 : ::SolarMutexGuard aGuard;
338 :
339 0 : if( maTypeSequence.getLength() == 0 )
340 : {
341 0 : const uno::Sequence< uno::Type > aBaseTypes( SfxBaseModel::getTypes() );
342 0 : const sal_Int32 nBaseTypes = aBaseTypes.getLength();
343 0 : const uno::Type* pBaseTypes = aBaseTypes.getConstArray();
344 :
345 0 : const sal_Int32 nOwnTypes = mbImpressDoc ? 14 : 11; // !DANGER! Keep this updated!
346 :
347 0 : maTypeSequence.realloc( nBaseTypes + nOwnTypes );
348 0 : uno::Type* pTypes = maTypeSequence.getArray();
349 :
350 0 : *pTypes++ = ITYPE(beans::XPropertySet);
351 0 : *pTypes++ = ITYPE(lang::XServiceInfo);
352 0 : *pTypes++ = ITYPE(lang::XMultiServiceFactory);
353 0 : *pTypes++ = ITYPE(drawing::XDrawPageDuplicator);
354 0 : *pTypes++ = ITYPE(drawing::XLayerSupplier);
355 0 : *pTypes++ = ITYPE(drawing::XMasterPagesSupplier);
356 0 : *pTypes++ = ITYPE(drawing::XDrawPagesSupplier);
357 0 : *pTypes++ = ITYPE(document::XLinkTargetSupplier);
358 0 : *pTypes++ = ITYPE(style::XStyleFamiliesSupplier);
359 0 : *pTypes++ = ITYPE(com::sun::star::ucb::XAnyCompareFactory);
360 0 : *pTypes++ = ITYPE(view::XRenderable);
361 0 : if( mbImpressDoc )
362 : {
363 0 : *pTypes++ = ITYPE(presentation::XPresentationSupplier);
364 0 : *pTypes++ = ITYPE(presentation::XCustomPresentationSupplier);
365 0 : *pTypes++ = ITYPE(presentation::XHandoutMasterSupplier);
366 : }
367 :
368 0 : for( sal_Int32 nType = 0; nType < nBaseTypes; nType++ )
369 0 : *pTypes++ = *pBaseTypes++;
370 : }
371 :
372 0 : return maTypeSequence;
373 : }
374 :
375 : namespace
376 : {
377 : class theSdXImpressDocumentImplementationId : public rtl::Static< UnoTunnelIdInit, theSdXImpressDocumentImplementationId > {};
378 : }
379 :
380 0 : uno::Sequence< sal_Int8 > SAL_CALL SdXImpressDocument::getImplementationId( ) throw(uno::RuntimeException)
381 : {
382 0 : return theSdXImpressDocumentImplementationId::get().getSeq();
383 : }
384 :
385 : /***********************************************************************
386 : * *
387 : ***********************************************************************/
388 1299 : void SdXImpressDocument::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
389 : {
390 1299 : if( mpDoc )
391 : {
392 1293 : const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
393 :
394 1293 : if( pSdrHint )
395 : {
396 1075 : if( hasEventListeners() )
397 : {
398 0 : document::EventObject aEvent;
399 0 : if( SvxUnoDrawMSFactory::createEvent( mpDoc, pSdrHint, aEvent ) )
400 0 : notifyEvent( aEvent );
401 : }
402 :
403 1075 : if( pSdrHint->GetKind() == HINT_MODELCLEARED )
404 : {
405 0 : if( mpDoc )
406 0 : EndListening( *mpDoc );
407 0 : mpDoc = NULL;
408 0 : mpDocShell = NULL;
409 : }
410 : }
411 : else
412 : {
413 218 : const SfxSimpleHint* pSfxHint = PTR_CAST(SfxSimpleHint, &rHint );
414 :
415 : // ist unser SdDrawDocument gerade gestorben?
416 218 : if(pSfxHint && pSfxHint->GetId() == SFX_HINT_DYING)
417 : {
418 : // yup, also schnell ein neues erfragen
419 0 : if( mpDocShell )
420 : {
421 0 : SdDrawDocument *pNewDoc = mpDocShell->GetDoc();
422 :
423 : // ist ueberhaupt ein neues da?
424 0 : if( pNewDoc != mpDoc )
425 : {
426 0 : mpDoc = pNewDoc;
427 0 : if(mpDoc)
428 0 : StartListening( *mpDoc );
429 : }
430 : }
431 : }
432 : }
433 : }
434 1299 : SfxBaseModel::Notify( rBC, rHint );
435 1299 : }
436 :
437 : /******************************************************************************
438 : * *
439 : ******************************************************************************/
440 7 : SdPage* SdXImpressDocument::InsertSdPage( sal_uInt16 nPage, sal_Bool bDuplicate ) throw()
441 : {
442 7 : sal_uInt16 nPageCount = mpDoc->GetSdPageCount( PK_STANDARD );
443 7 : SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin();
444 7 : sal_uInt8 aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), sal_False);
445 7 : sal_uInt8 aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False);
446 :
447 7 : SdPage* pStandardPage = NULL;
448 :
449 7 : if( 0 == nPageCount )
450 : {
451 : // this is only used for clipboard where we only have one page
452 0 : pStandardPage = (SdPage*) mpDoc->AllocPage(sal_False);
453 :
454 0 : Size aDefSize(21000, 29700); // A4-Hochformat
455 0 : pStandardPage->SetSize( aDefSize );
456 0 : mpDoc->InsertPage(pStandardPage, 0);
457 : }
458 : else
459 : {
460 : // Hier wird die Seite ermittelt, hinter der eingefuegt werden soll
461 7 : SdPage* pPreviousStandardPage = mpDoc->GetSdPage( Min( (sal_uInt16)(nPageCount - 1), nPage ), PK_STANDARD );
462 7 : SetOfByte aVisibleLayers = pPreviousStandardPage->TRG_GetMasterPageVisibleLayers();
463 7 : sal_Bool bIsPageBack = aVisibleLayers.IsSet( aBckgrnd );
464 7 : sal_Bool bIsPageObj = aVisibleLayers.IsSet( aBckgrndObj );
465 :
466 : // AutoLayouts must be ready
467 7 : mpDoc->StopWorkStartupDelay();
468 :
469 : /**************************************************************
470 : * Es wird stets zuerst eine Standardseite und dann eine
471 : * Notizseite erzeugt. Es ist sichergestellt, dass auf eine
472 : * Standardseite stets die zugehoerige Notizseite folgt.
473 : **************************************************************/
474 :
475 7 : sal_uInt16 nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
476 7 : SdPage* pPreviousNotesPage = (SdPage*) mpDoc->GetPage( nStandardPageNum - 1 );
477 7 : sal_uInt16 nNotesPageNum = nStandardPageNum + 1;
478 7 : String aStandardPageName;
479 7 : String aNotesPageName;
480 :
481 : /**************************************************************
482 : * Standardpage
483 : **************************************************************/
484 7 : if( bDuplicate )
485 0 : pStandardPage = (SdPage*) pPreviousStandardPage->Clone();
486 : else
487 7 : pStandardPage = (SdPage*) mpDoc->AllocPage(sal_False);
488 :
489 7 : pStandardPage->SetSize( pPreviousStandardPage->GetSize() );
490 7 : pStandardPage->SetBorder( pPreviousStandardPage->GetLftBorder(),
491 7 : pPreviousStandardPage->GetUppBorder(),
492 7 : pPreviousStandardPage->GetRgtBorder(),
493 28 : pPreviousStandardPage->GetLwrBorder() );
494 7 : pStandardPage->SetOrientation( pPreviousStandardPage->GetOrientation() );
495 7 : pStandardPage->SetName(aStandardPageName);
496 :
497 : // Seite hinter aktueller Seite einfuegen
498 7 : mpDoc->InsertPage(pStandardPage, nStandardPageNum);
499 :
500 7 : if( !bDuplicate )
501 : {
502 : // MasterPage der aktuellen Seite verwenden
503 7 : pStandardPage->TRG_SetMasterPage(pPreviousStandardPage->TRG_GetMasterPage());
504 7 : pStandardPage->SetLayoutName( pPreviousStandardPage->GetLayoutName() );
505 7 : pStandardPage->SetAutoLayout(AUTOLAYOUT_NONE, sal_True );
506 : }
507 :
508 7 : aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), sal_False);
509 7 : aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), sal_False);
510 7 : aVisibleLayers.Set(aBckgrnd, bIsPageBack);
511 7 : aVisibleLayers.Set(aBckgrndObj, bIsPageObj);
512 7 : pStandardPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
513 :
514 : /**************************************************************
515 : * Notespage
516 : **************************************************************/
517 7 : SdPage* pNotesPage = NULL;
518 :
519 7 : if( bDuplicate )
520 0 : pNotesPage = (SdPage*) pPreviousNotesPage->Clone();
521 : else
522 7 : pNotesPage = (SdPage*) mpDoc->AllocPage(sal_False);
523 :
524 7 : pNotesPage->SetSize( pPreviousNotesPage->GetSize() );
525 7 : pNotesPage->SetBorder( pPreviousNotesPage->GetLftBorder(),
526 7 : pPreviousNotesPage->GetUppBorder(),
527 7 : pPreviousNotesPage->GetRgtBorder(),
528 28 : pPreviousNotesPage->GetLwrBorder() );
529 7 : pNotesPage->SetOrientation( pPreviousNotesPage->GetOrientation() );
530 7 : pNotesPage->SetName(aNotesPageName);
531 7 : pNotesPage->SetPageKind(PK_NOTES);
532 :
533 : // Seite hinter aktueller Seite einfuegen
534 7 : mpDoc->InsertPage(pNotesPage, nNotesPageNum);
535 :
536 7 : if( !bDuplicate )
537 : {
538 : // MasterPage der aktuellen Seite verwenden
539 7 : pNotesPage->TRG_SetMasterPage(pPreviousNotesPage->TRG_GetMasterPage());
540 7 : pNotesPage->SetLayoutName( pPreviousNotesPage->GetLayoutName() );
541 7 : pNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, sal_True );
542 7 : }
543 : }
544 :
545 7 : SetModified();
546 :
547 7 : return( pStandardPage );
548 : }
549 :
550 1720 : void SdXImpressDocument::SetModified( sal_Bool bModified /* = sal_True */ ) throw()
551 : {
552 1720 : if( mpDoc )
553 1720 : mpDoc->SetChanged( bModified );
554 1720 : }
555 :
556 : // XModel
557 6 : void SAL_CALL SdXImpressDocument ::lockControllers( )
558 : throw(uno::RuntimeException)
559 : {
560 6 : ::SolarMutexGuard aGuard;
561 :
562 6 : if( NULL == mpDoc )
563 0 : throw lang::DisposedException();
564 :
565 6 : mpDoc->setLock(true);
566 6 : }
567 :
568 6 : void SAL_CALL SdXImpressDocument::unlockControllers( )
569 : throw(uno::RuntimeException)
570 : {
571 6 : ::SolarMutexGuard aGuard;
572 :
573 6 : if( NULL == mpDoc )
574 0 : throw lang::DisposedException();
575 :
576 6 : if( mpDoc->isLocked() )
577 : {
578 6 : mpDoc->setLock(false);
579 6 : }
580 6 : }
581 :
582 0 : sal_Bool SAL_CALL SdXImpressDocument::hasControllersLocked( )
583 : throw(uno::RuntimeException)
584 : {
585 0 : ::SolarMutexGuard aGuard;
586 :
587 0 : if( NULL == mpDoc )
588 0 : throw lang::DisposedException();
589 :
590 0 : return mpDoc && mpDoc->isLocked();
591 : }
592 :
593 : #include <comphelper/processfactory.hxx>
594 :
595 0 : uno::Reference < container::XIndexAccess > SAL_CALL SdXImpressDocument::getViewData() throw( uno::RuntimeException )
596 : {
597 0 : ::SolarMutexGuard aGuard;
598 :
599 0 : if( NULL == mpDoc )
600 0 : throw lang::DisposedException();
601 :
602 0 : uno::Reference < container::XIndexAccess > xRet( SfxBaseModel::getViewData() );
603 :
604 0 : if( !xRet.is() )
605 : {
606 0 : const std::vector<sd::FrameView*> &rList = mpDoc->GetFrameViewList();
607 :
608 0 : if( !rList.empty() )
609 : {
610 0 : xRet = uno::Reference < container::XIndexAccess >::query(::comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.IndexedPropertyValues"));
611 :
612 :
613 0 : uno::Reference < container::XIndexContainer > xCont( xRet, uno::UNO_QUERY );
614 : DBG_ASSERT( xCont.is(), "SdXImpressDocument::getViewData() failed for OLE object" );
615 0 : if( xCont.is() )
616 : {
617 0 : for( sal_uInt32 i = 0, n = rList.size(); i < n; i++ )
618 : {
619 0 : ::sd::FrameView* pFrameView = rList[ i ];
620 :
621 0 : uno::Sequence< beans::PropertyValue > aSeq;
622 0 : pFrameView->WriteUserDataSequence( aSeq );
623 0 : xCont->insertByIndex( i, uno::makeAny( aSeq ) );
624 0 : }
625 0 : }
626 : }
627 : }
628 :
629 0 : return xRet;
630 : }
631 :
632 2 : void SAL_CALL SdXImpressDocument::setViewData( const uno::Reference < container::XIndexAccess >& xData ) throw(::com::sun::star::uno::RuntimeException)
633 : {
634 2 : ::SolarMutexGuard aGuard;
635 :
636 2 : if( NULL == mpDoc )
637 0 : throw lang::DisposedException();
638 :
639 2 : SfxBaseModel::setViewData( xData );
640 2 : if( mpDocShell && (mpDocShell->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED) && xData.is() )
641 : {
642 2 : const sal_Int32 nCount = xData->getCount();
643 :
644 2 : std::vector<sd::FrameView*>::iterator pIter;
645 2 : std::vector<sd::FrameView*> &rViews = mpDoc->GetFrameViewList();
646 :
647 2 : for ( pIter = rViews.begin(); pIter != rViews.end(); ++pIter )
648 0 : delete *pIter;
649 :
650 2 : rViews.clear();
651 :
652 : ::sd::FrameView* pFrameView;
653 2 : uno::Sequence< beans::PropertyValue > aSeq;
654 4 : for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
655 : {
656 2 : if( xData->getByIndex( nIndex ) >>= aSeq )
657 : {
658 2 : pFrameView = new ::sd::FrameView( mpDoc );
659 :
660 2 : pFrameView->ReadUserDataSequence( aSeq );
661 2 : rViews.push_back( pFrameView );
662 : }
663 2 : }
664 2 : }
665 2 : }
666 :
667 : // XDrawPageDuplicator
668 0 : uno::Reference< drawing::XDrawPage > SAL_CALL SdXImpressDocument::duplicate( const uno::Reference< drawing::XDrawPage >& xPage )
669 : throw(uno::RuntimeException)
670 : {
671 0 : ::SolarMutexGuard aGuard;
672 :
673 0 : if( NULL == mpDoc )
674 0 : throw lang::DisposedException();
675 :
676 : // pPage von xPage besorgen und dann die Id (nPos )ermitteln
677 0 : SvxDrawPage* pSvxPage = SvxDrawPage::getImplementation( xPage );
678 0 : if( pSvxPage )
679 : {
680 0 : SdPage* pPage = (SdPage*) pSvxPage->GetSdrPage();
681 0 : sal_uInt16 nPos = pPage->GetPageNum();
682 0 : nPos = ( nPos - 1 ) / 2;
683 0 : pPage = InsertSdPage( nPos, sal_True );
684 0 : if( pPage )
685 : {
686 0 : uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
687 0 : return xDrawPage;
688 : }
689 : }
690 :
691 0 : uno::Reference< drawing::XDrawPage > xDrawPage;
692 0 : return xDrawPage;
693 : }
694 :
695 :
696 : // XDrawPagesSupplier
697 15 : uno::Reference< drawing::XDrawPages > SAL_CALL SdXImpressDocument::getDrawPages()
698 : throw(uno::RuntimeException)
699 : {
700 15 : ::SolarMutexGuard aGuard;
701 :
702 15 : if( NULL == mpDoc )
703 0 : throw lang::DisposedException();
704 :
705 15 : uno::Reference< drawing::XDrawPages > xDrawPages( mxDrawPagesAccess );
706 :
707 15 : if( !xDrawPages.is() )
708 : {
709 14 : initializeDocument();
710 14 : mxDrawPagesAccess = xDrawPages = (drawing::XDrawPages*)new SdDrawPagesAccess(*this);
711 : }
712 :
713 15 : return xDrawPages;
714 : }
715 :
716 : // XMasterPagesSupplier
717 12 : uno::Reference< drawing::XDrawPages > SAL_CALL SdXImpressDocument::getMasterPages()
718 : throw(uno::RuntimeException)
719 : {
720 12 : ::SolarMutexGuard aGuard;
721 :
722 12 : if( NULL == mpDoc )
723 0 : throw lang::DisposedException();
724 :
725 12 : uno::Reference< drawing::XDrawPages > xMasterPages( mxMasterPagesAccess );
726 :
727 12 : if( !xMasterPages.is() )
728 : {
729 12 : initializeDocument();
730 12 : mxMasterPagesAccess = xMasterPages = new SdMasterPagesAccess(*this);
731 : }
732 :
733 12 : return xMasterPages;
734 : }
735 :
736 : // XLayerManagerSupplier
737 2 : uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getLayerManager( )
738 : throw(uno::RuntimeException)
739 : {
740 2 : ::SolarMutexGuard aGuard;
741 :
742 2 : if( NULL == mpDoc )
743 0 : throw lang::DisposedException();
744 :
745 2 : uno::Reference< container::XNameAccess > xLayerManager( mxLayerManager );
746 :
747 2 : if( !xLayerManager.is() )
748 2 : mxLayerManager = xLayerManager = new SdLayerManager(*this);
749 :
750 2 : return xLayerManager;
751 : }
752 :
753 : // XCustomPresentationSupplier
754 1 : uno::Reference< container::XNameContainer > SAL_CALL SdXImpressDocument::getCustomPresentations()
755 : throw(uno::RuntimeException)
756 : {
757 1 : ::SolarMutexGuard aGuard;
758 :
759 1 : if( NULL == mpDoc )
760 0 : throw lang::DisposedException();
761 :
762 1 : uno::Reference< container::XNameContainer > xCustomPres( mxCustomPresentationAccess );
763 :
764 1 : if( !xCustomPres.is() )
765 1 : mxCustomPresentationAccess = xCustomPres = new SdXCustomPresentationAccess(*this);
766 :
767 1 : return xCustomPres;
768 : }
769 :
770 : extern uno::Reference< presentation::XPresentation > createPresentation( SdXImpressDocument& rModel );
771 :
772 : // XPresentationSupplier
773 1 : uno::Reference< presentation::XPresentation > SAL_CALL SdXImpressDocument::getPresentation()
774 : throw(uno::RuntimeException)
775 : {
776 1 : ::SolarMutexGuard aGuard;
777 :
778 1 : if( NULL == mpDoc )
779 0 : throw lang::DisposedException();
780 :
781 1 : return uno::Reference< presentation::XPresentation >( mpDoc->getPresentation().get() );
782 : }
783 :
784 : // XHandoutMasterSupplier
785 1 : uno::Reference< drawing::XDrawPage > SAL_CALL SdXImpressDocument::getHandoutMasterPage()
786 : throw (uno::RuntimeException)
787 : {
788 1 : ::SolarMutexGuard aGuard;
789 :
790 1 : if( NULL == mpDoc )
791 0 : throw lang::DisposedException();
792 :
793 1 : uno::Reference< drawing::XDrawPage > xPage;
794 :
795 1 : if( mpDoc )
796 : {
797 1 : initializeDocument();
798 1 : SdPage* pPage = mpDoc->GetMasterSdPage( 0, PK_HANDOUT );
799 1 : if( pPage )
800 1 : xPage = uno::Reference< drawing::XDrawPage >::query( pPage->getUnoPage() );
801 : }
802 1 : return xPage;
803 : }
804 :
805 : // XMultiServiceFactory ( SvxFmMSFactory )
806 216 : uno::Reference< uno::XInterface > SAL_CALL SdXImpressDocument::createInstance( const OUString& aServiceSpecifier )
807 : throw(uno::Exception, uno::RuntimeException)
808 : {
809 216 : ::SolarMutexGuard aGuard;
810 :
811 216 : if( NULL == mpDoc )
812 0 : throw lang::DisposedException();
813 :
814 216 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.DashTable") ) )
815 : {
816 3 : if( !mxDashTable.is() )
817 2 : mxDashTable = SvxUnoDashTable_createInstance( mpDoc );
818 :
819 3 : return mxDashTable;
820 : }
821 213 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.GradientTable") ) )
822 : {
823 3 : if( !mxGradientTable.is() )
824 2 : mxGradientTable = SvxUnoGradientTable_createInstance( mpDoc );
825 :
826 3 : return mxGradientTable;
827 : }
828 210 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.HatchTable") ) )
829 : {
830 3 : if( !mxHatchTable.is() )
831 2 : mxHatchTable = SvxUnoHatchTable_createInstance( mpDoc );
832 :
833 3 : return mxHatchTable;
834 : }
835 207 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.BitmapTable") ) )
836 : {
837 2 : if( !mxBitmapTable.is() )
838 2 : mxBitmapTable = SvxUnoBitmapTable_createInstance( mpDoc );
839 :
840 2 : return mxBitmapTable;
841 : }
842 205 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.TransparencyGradientTable") ) )
843 : {
844 2 : if( !mxTransGradientTable.is() )
845 2 : mxTransGradientTable = SvxUnoTransGradientTable_createInstance( mpDoc );
846 :
847 2 : return mxTransGradientTable;
848 : }
849 203 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.MarkerTable") ) )
850 : {
851 5 : if( !mxMarkerTable.is() )
852 3 : mxMarkerTable = SvxUnoMarkerTable_createInstance( mpDoc );
853 :
854 5 : return mxMarkerTable;
855 : }
856 198 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.NumberingRules" ) ) )
857 : {
858 7 : return uno::Reference< uno::XInterface >( SvxCreateNumRule( mpDoc ), uno::UNO_QUERY );
859 : }
860 191 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.Background" ) ) )
861 : {
862 : return uno::Reference< uno::XInterface >(
863 11 : static_cast<uno::XWeak*>(new SdUnoPageBackground( mpDoc )));
864 : }
865 :
866 180 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.Defaults") ) )
867 : {
868 2 : if( !mxDrawingPool.is() )
869 2 : mxDrawingPool = SdUnoCreatePool( mpDoc );
870 :
871 2 : return mxDrawingPool;
872 :
873 : }
874 :
875 178 : if ( aServiceSpecifier == sUNO_Service_ImageMapRectangleObject )
876 : {
877 0 : return SvUnoImageMapRectangleObject_createInstance( ImplGetSupportedMacroItems() );
878 : }
879 :
880 178 : if ( aServiceSpecifier == sUNO_Service_ImageMapCircleObject )
881 : {
882 0 : return SvUnoImageMapCircleObject_createInstance( ImplGetSupportedMacroItems() );
883 : }
884 :
885 178 : if ( aServiceSpecifier == sUNO_Service_ImageMapPolygonObject )
886 : {
887 0 : return SvUnoImageMapPolygonObject_createInstance( ImplGetSupportedMacroItems() );
888 : }
889 :
890 526 : if( ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.Settings") ) ) ||
891 174 : ( !mbImpressDoc && ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.DocumentSettings") ) ) ) ||
892 174 : ( mbImpressDoc && ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.DocumentSettings") ) ) ) )
893 : {
894 4 : return sd::DocumentSettings_createInstance( this );
895 : }
896 :
897 347 : if( ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.TextField.DateTime") ) ) ||
898 173 : ( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.textfield.DateTime") ) ) )
899 : {
900 1 : return (::cppu::OWeakObject * )new SvxUnoTextField( text::textfield::Type::DATE );
901 : }
902 :
903 344 : if( (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.TextField.Header"))) ||
904 171 : (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.textfield.Header"))) )
905 : {
906 2 : return (::cppu::OWeakObject * )new SvxUnoTextField( text::textfield::Type::PRESENTATION_HEADER );
907 : }
908 :
909 339 : if( (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.TextField.Footer"))) ||
910 168 : (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.textfield.Footer"))) )
911 : {
912 3 : return (::cppu::OWeakObject * )new SvxUnoTextField( text::textfield::Type::PRESENTATION_FOOTER );
913 : }
914 :
915 333 : if( (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.TextField.DateTime"))) ||
916 165 : (0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.presentation.textfield.DateTime"))) )
917 : {
918 3 : return (::cppu::OWeakObject * )new SvxUnoTextField( text::textfield::Type::PRESENTATION_DATE_TIME );
919 : }
920 :
921 165 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.xml.NamespaceMap") ) )
922 : {
923 : static sal_uInt16 aWhichIds[] = { SDRATTR_XMLATTRIBUTES, EE_CHAR_XMLATTRIBS, EE_PARA_XMLATTRIBS, 0 };
924 :
925 0 : return svx::NamespaceMap_createInstance( aWhichIds, &mpDoc->GetItemPool() );
926 : }
927 :
928 : // Support creation of GraphicObjectResolver and EmbeddedObjectResolver
929 165 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ExportGraphicObjectResolver") ) )
930 : {
931 0 : return (::cppu::OWeakObject * )new SvXMLGraphicHelper( GRAPHICHELPER_MODE_WRITE );
932 : }
933 :
934 165 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ImportGraphicObjectResolver") ) )
935 : {
936 2 : return (::cppu::OWeakObject * )new SvXMLGraphicHelper( GRAPHICHELPER_MODE_READ );
937 : }
938 :
939 163 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ExportEmbeddedObjectResolver") ) )
940 : {
941 0 : ::comphelper::IEmbeddedHelper *pPersist = mpDoc ? mpDoc->GetPersist() : NULL;
942 0 : if( NULL == pPersist )
943 0 : throw lang::DisposedException();
944 :
945 0 : return (::cppu::OWeakObject * )new SvXMLEmbeddedObjectHelper( *pPersist, EMBEDDEDOBJECTHELPER_MODE_WRITE );
946 : }
947 :
948 163 : if( 0 == aServiceSpecifier.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ImportEmbeddedObjectResolver") ) )
949 : {
950 2 : ::comphelper::IEmbeddedHelper *pPersist = mpDoc ? mpDoc->GetPersist() : NULL;
951 2 : if( NULL == pPersist )
952 0 : throw lang::DisposedException();
953 :
954 2 : return (::cppu::OWeakObject * )new SvXMLEmbeddedObjectHelper( *pPersist, EMBEDDEDOBJECTHELPER_MODE_READ );
955 : }
956 :
957 161 : uno::Reference< uno::XInterface > xRet;
958 :
959 161 : const String aType( aServiceSpecifier );
960 161 : if( aType.EqualsAscii( "com.sun.star.presentation.", 0, 26 ) )
961 : {
962 55 : SvxShape* pShape = NULL;
963 :
964 55 : sal_uInt16 nType = OBJ_TEXT;
965 : // create a shape wrapper
966 55 : if( aType.EqualsAscii( "TitleTextShape", 26, 14 ) )
967 : {
968 6 : nType = OBJ_TEXT;
969 : }
970 49 : else if( aType.EqualsAscii( "OutlinerShape", 26, 13 ) )
971 : {
972 4 : nType = OBJ_TEXT;
973 : }
974 45 : else if( aType.EqualsAscii( "SubtitleShape", 26, 13 ) )
975 : {
976 0 : nType = OBJ_TEXT;
977 : }
978 45 : else if( aType.EqualsAscii( "GraphicObjectShape", 26, 18 ) )
979 : {
980 1 : nType = OBJ_GRAF;
981 : }
982 44 : else if( aType.EqualsAscii( "PageShape", 26, 9 ) )
983 : {
984 10 : nType = OBJ_PAGE;
985 : }
986 34 : else if( aType.EqualsAscii( "OLE2Shape", 26, 9 ) )
987 : {
988 0 : nType = OBJ_OLE2;
989 : }
990 34 : else if( aType.EqualsAscii( "ChartShape", 26, 10 ) )
991 : {
992 0 : nType = OBJ_OLE2;
993 : }
994 34 : else if( aType.EqualsAscii( "CalcShape", 26, 9 ) )
995 : {
996 0 : nType = OBJ_OLE2;
997 : }
998 34 : else if( aType.EqualsAscii( "TableShape", 26, 10 ) )
999 : {
1000 0 : nType = OBJ_TABLE;
1001 : }
1002 34 : else if( aType.EqualsAscii( "OrgChartShape", 26, 13 ) )
1003 : {
1004 0 : nType = OBJ_OLE2;
1005 : }
1006 34 : else if( aType.EqualsAscii( "NotesShape", 26, 13 ) )
1007 : {
1008 10 : nType = OBJ_TEXT;
1009 : }
1010 24 : else if( aType.EqualsAscii( "HandoutShape", 26, 13 ) )
1011 : {
1012 6 : nType = OBJ_PAGE;
1013 : }
1014 18 : else if( aType.EqualsAscii( "FooterShape", 26, 12 ) )
1015 : {
1016 5 : nType = OBJ_TEXT;
1017 : }
1018 13 : else if( aType.EqualsAscii( "HeaderShape", 26, 12 ) )
1019 : {
1020 2 : nType = OBJ_TEXT;
1021 : }
1022 11 : else if( aType.EqualsAscii( "SlideNumberShape", 26, 17 ) )
1023 : {
1024 7 : nType = OBJ_TEXT;
1025 : }
1026 4 : else if( aType.EqualsAscii( "DateTimeShape", 26, 17 ) )
1027 : {
1028 4 : nType = OBJ_TEXT;
1029 : }
1030 0 : else if( aType.EqualsAscii( "MediaShape", 26, 10 ) )
1031 : {
1032 0 : nType = OBJ_MEDIA;
1033 : }
1034 : else
1035 : {
1036 0 : throw lang::ServiceNotRegisteredException();
1037 : }
1038 :
1039 : // create the API wrapper
1040 55 : pShape = CreateSvxShapeByTypeAndInventor( nType, SdrInventor );
1041 :
1042 : // set shape type
1043 55 : if( pShape && !mbClipBoard )
1044 55 : pShape->SetShapeType(aServiceSpecifier);
1045 :
1046 55 : xRet = (uno::XWeak*)pShape;
1047 : }
1048 106 : else if ( aServiceSpecifier == "com.sun.star.drawing.TableShape" )
1049 : {
1050 2 : SvxShape* pShape = CreateSvxShapeByTypeAndInventor( OBJ_TABLE, SdrInventor );
1051 2 : if( pShape && !mbClipBoard )
1052 2 : pShape->SetShapeType(aServiceSpecifier);
1053 :
1054 2 : xRet = (uno::XWeak*)pShape;
1055 : }
1056 : else
1057 : {
1058 104 : xRet = SvxFmMSFactory::createInstance( aServiceSpecifier );
1059 : }
1060 :
1061 161 : uno::Reference< drawing::XShape > xShape( xRet, uno::UNO_QUERY );
1062 161 : if( xShape.is() )
1063 : {
1064 154 : xRet.clear();
1065 154 : new SdXShape( SvxShape::getImplementation( xShape ), (SdXImpressDocument*)this );
1066 154 : xRet = xShape;
1067 154 : xShape.clear();
1068 : }
1069 :
1070 161 : return xRet;
1071 : }
1072 :
1073 8 : uno::Sequence< OUString > SAL_CALL SdXImpressDocument::getAvailableServiceNames()
1074 : throw(uno::RuntimeException)
1075 : {
1076 8 : ::SolarMutexGuard aGuard;
1077 :
1078 8 : if( NULL == mpDoc )
1079 0 : throw lang::DisposedException();
1080 :
1081 8 : const uno::Sequence< OUString > aSNS_ORG( SvxFmMSFactory::getAvailableServiceNames() );
1082 :
1083 8 : uno::Sequence< OUString > aSNS( mbImpressDoc ? (36) : (19) );
1084 :
1085 8 : sal_uInt16 i(0);
1086 :
1087 8 : aSNS[i++] = "com.sun.star.drawing.DashTable";
1088 8 : aSNS[i++] = "com.sun.star.drawing.GradientTable";
1089 8 : aSNS[i++] = "com.sun.star.drawing.HatchTable";
1090 8 : aSNS[i++] = "com.sun.star.drawing.BitmapTable";
1091 8 : aSNS[i++] = "com.sun.star.drawing.TransparencyGradientTable";
1092 8 : aSNS[i++] = "com.sun.star.drawing.MarkerTable";
1093 8 : aSNS[i++] = "com.sun.star.text.NumberingRules";
1094 8 : aSNS[i++] = "com.sun.star.drawing.Background";
1095 8 : aSNS[i++] = "com.sun.star.document.Settings";
1096 8 : aSNS[i++] = sUNO_Service_ImageMapRectangleObject;
1097 8 : aSNS[i++] = sUNO_Service_ImageMapCircleObject;
1098 8 : aSNS[i++] = sUNO_Service_ImageMapPolygonObject;
1099 8 : aSNS[i++] = "com.sun.star.xml.NamespaceMap";
1100 :
1101 : // Support creation of GraphicObjectResolver and EmbeddedObjectResolver
1102 8 : aSNS[i++] = "com.sun.star.document.ExportGraphicObjectResolver";
1103 8 : aSNS[i++] = "com.sun.star.document.ImportGraphicObjectResolver";
1104 8 : aSNS[i++] = "com.sun.star.document.ExportEmbeddedObjectResolver";
1105 8 : aSNS[i++] = "com.sun.star.document.ImportEmbeddedObjectResolver";
1106 8 : aSNS[i++] = "com.sun.star.drawing.TableShape";
1107 :
1108 8 : if(mbImpressDoc)
1109 : {
1110 8 : aSNS[i++] = "com.sun.star.presentation.TitleTextShape";
1111 8 : aSNS[i++] = "com.sun.star.presentation.OutlinerShape";
1112 8 : aSNS[i++] = "com.sun.star.presentation.SubtitleShape";
1113 8 : aSNS[i++] = "com.sun.star.presentation.GraphicObjectShape";
1114 8 : aSNS[i++] = "com.sun.star.presentation.ChartShape";
1115 8 : aSNS[i++] = "com.sun.star.presentation.PageShape";
1116 8 : aSNS[i++] = "com.sun.star.presentation.OLE2Shape";
1117 8 : aSNS[i++] = "com.sun.star.presentation.TableShape";
1118 8 : aSNS[i++] = "com.sun.star.presentation.OrgChartShape";
1119 8 : aSNS[i++] = "com.sun.star.presentation.NotesShape";
1120 8 : aSNS[i++] = "com.sun.star.presentation.HandoutShape";
1121 8 : aSNS[i++] = "com.sun.star.presentation.DocumentSettings";
1122 8 : aSNS[i++] = "com.sun.star.presentation.FooterShape";
1123 8 : aSNS[i++] = "com.sun.star.presentation.HeaderShape";
1124 8 : aSNS[i++] = "com.sun.star.presentation.SlideNumberShape";
1125 8 : aSNS[i++] = "com.sun.star.presentation.DateTimeShape";
1126 8 : aSNS[i++] = "com.sun.star.presentation.CalcShape";
1127 8 : aSNS[i++] = "com.sun.star.presentation.MediaShape";
1128 : }
1129 : else
1130 : {
1131 0 : aSNS[i++] = "com.sun.star.drawing.DocumentSettings";
1132 : }
1133 :
1134 : DBG_ASSERT( i == aSNS.getLength(), "Sequence overrun!" );
1135 :
1136 8 : return comphelper::concatSequences( aSNS_ORG, aSNS );
1137 : }
1138 :
1139 : // lang::XServiceInfo
1140 0 : OUString SAL_CALL SdXImpressDocument::getImplementationName()
1141 : throw(uno::RuntimeException)
1142 : {
1143 0 : return OUString( "SdXImpressDocument" );
1144 : }
1145 :
1146 28 : sal_Bool SAL_CALL SdXImpressDocument::supportsService( const OUString& ServiceName )
1147 : throw(uno::RuntimeException)
1148 : {
1149 28 : ::SolarMutexGuard aGuard;
1150 :
1151 60 : if ( ServiceName == "com.sun.star.document.OfficeDocument"
1152 16 : || ServiceName == "com.sun.star.drawing.GenericDrawingDocument"
1153 16 : || ServiceName == "com.sun.star.drawing.DrawingDocumentFactory" )
1154 : {
1155 12 : return sal_True;
1156 : }
1157 :
1158 16 : return ( ( mbImpressDoc && ServiceName == "com.sun.star.presentation.PresentationDocument" )
1159 32 : || ( !mbImpressDoc && ServiceName == "com.sun.star.drawing.DrawingDocument" ) );
1160 : }
1161 :
1162 0 : uno::Sequence< OUString > SAL_CALL SdXImpressDocument::getSupportedServiceNames() throw(uno::RuntimeException)
1163 : {
1164 0 : ::SolarMutexGuard aGuard;
1165 :
1166 0 : uno::Sequence< OUString > aSeq( 4 );
1167 0 : OUString* pServices = aSeq.getArray();
1168 :
1169 0 : *pServices++ = "com.sun.star.document.OfficeDocument";
1170 0 : *pServices++ = "com.sun.star.drawing.GenericDrawingDocument";
1171 0 : *pServices++ = "com.sun.star.drawing.DrawingDocumentFactory";
1172 :
1173 0 : if( mbImpressDoc )
1174 0 : *pServices++ = "com.sun.star.presentation.PresentationDocument";
1175 : else
1176 0 : *pServices++ = "com.sun.star.drawing.DrawingDocument";
1177 :
1178 0 : return aSeq;
1179 : }
1180 :
1181 : // XPropertySet
1182 3 : uno::Reference< beans::XPropertySetInfo > SAL_CALL SdXImpressDocument::getPropertySetInfo( )
1183 : throw(uno::RuntimeException)
1184 : {
1185 3 : ::SolarMutexGuard aGuard;
1186 3 : return mpPropSet->getPropertySetInfo();
1187 : }
1188 :
1189 10 : void SAL_CALL SdXImpressDocument::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
1190 : throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
1191 : {
1192 10 : ::SolarMutexGuard aGuard;
1193 :
1194 10 : if( NULL == mpDoc )
1195 0 : throw lang::DisposedException();
1196 :
1197 10 : const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(aPropertyName);
1198 :
1199 10 : switch( pEntry ? pEntry->nWID : -1 )
1200 : {
1201 : case WID_MODEL_LANGUAGE:
1202 : {
1203 0 : lang::Locale aLocale;
1204 0 : if(!(aValue >>= aLocale))
1205 0 : throw lang::IllegalArgumentException();
1206 :
1207 0 : mpDoc->SetLanguage( LanguageTag(aLocale).getLanguageType(), EE_CHAR_LANGUAGE );
1208 0 : break;
1209 : }
1210 : case WID_MODEL_TABSTOP:
1211 : {
1212 0 : sal_Int32 nValue = 0;
1213 0 : if(!(aValue >>= nValue) || nValue < 0 )
1214 0 : throw lang::IllegalArgumentException();
1215 :
1216 0 : mpDoc->SetDefaultTabulator((sal_uInt16)nValue);
1217 : break;
1218 : }
1219 : case WID_MODEL_VISAREA:
1220 : {
1221 2 : SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
1222 2 : if( !pEmbeddedObj )
1223 : break;
1224 :
1225 2 : awt::Rectangle aVisArea;
1226 2 : if( !(aValue >>= aVisArea) || (aVisArea.Width < 0) || (aVisArea.Height < 0) )
1227 0 : throw lang::IllegalArgumentException();
1228 :
1229 2 : pEmbeddedObj->SetVisArea( Rectangle( aVisArea.X, aVisArea.Y, aVisArea.X + aVisArea.Width - 1, aVisArea.Y + aVisArea.Height - 1 ) );
1230 : }
1231 2 : break;
1232 : case WID_MODEL_CONTFOCUS:
1233 : {
1234 1 : sal_Bool bFocus = sal_False;
1235 1 : if( !(aValue >>= bFocus ) )
1236 0 : throw lang::IllegalArgumentException();
1237 1 : mpDoc->SetAutoControlFocus( bFocus );
1238 : }
1239 1 : break;
1240 : case WID_MODEL_DSGNMODE:
1241 : {
1242 1 : sal_Bool bMode = sal_False;
1243 1 : if( !(aValue >>= bMode ) )
1244 0 : throw lang::IllegalArgumentException();
1245 1 : mpDoc->SetOpenInDesignMode( bMode );
1246 : }
1247 1 : break;
1248 : case WID_MODEL_BUILDID:
1249 2 : aValue >>= maBuildId;
1250 6 : return;
1251 : case WID_MODEL_MAPUNIT:
1252 : case WID_MODEL_BASICLIBS:
1253 : case WID_MODEL_RUNTIMEUID: // is read-only
1254 : case WID_MODEL_DIALOGLIBS:
1255 0 : throw beans::PropertyVetoException();
1256 : default:
1257 4 : throw beans::UnknownPropertyException();
1258 : }
1259 :
1260 8 : SetModified();
1261 : }
1262 :
1263 24 : uno::Any SAL_CALL SdXImpressDocument::getPropertyValue( const OUString& PropertyName )
1264 : throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1265 : {
1266 24 : ::SolarMutexGuard aGuard;
1267 :
1268 24 : uno::Any aAny;
1269 24 : if( NULL == mpDoc )
1270 0 : throw lang::DisposedException();
1271 :
1272 24 : const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(PropertyName);
1273 :
1274 24 : switch( pEntry ? pEntry->nWID : -1 )
1275 : {
1276 : case WID_MODEL_LANGUAGE:
1277 : {
1278 0 : LanguageType eLang = mpDoc->GetLanguage( EE_CHAR_LANGUAGE );
1279 0 : aAny <<= LanguageTag( eLang).getLocale();
1280 0 : break;
1281 : }
1282 : case WID_MODEL_TABSTOP:
1283 0 : aAny <<= (sal_Int32)mpDoc->GetDefaultTabulator();
1284 0 : break;
1285 : case WID_MODEL_VISAREA:
1286 : {
1287 0 : SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
1288 0 : if( !pEmbeddedObj )
1289 : break;
1290 :
1291 0 : const Rectangle& aRect = pEmbeddedObj->GetVisArea();
1292 0 : awt::Rectangle aVisArea( aRect.Left(), aRect.Top(), aRect.getWidth(), aRect.getHeight() );
1293 0 : aAny <<= aVisArea;
1294 : }
1295 0 : break;
1296 : case WID_MODEL_MAPUNIT:
1297 : {
1298 0 : SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
1299 0 : if( !pEmbeddedObj )
1300 : break;
1301 :
1302 0 : sal_Int16 nMeasureUnit = 0;
1303 0 : SvxMapUnitToMeasureUnit( (const short)pEmbeddedObj->GetMapUnit(), nMeasureUnit );
1304 0 : aAny <<= (sal_Int16)nMeasureUnit;
1305 : }
1306 0 : break;
1307 : case WID_MODEL_FORBCHARS:
1308 : {
1309 0 : aAny <<= getForbiddenCharsTable();
1310 : }
1311 0 : break;
1312 : case WID_MODEL_CONTFOCUS:
1313 0 : aAny <<= (sal_Bool)mpDoc->GetAutoControlFocus();
1314 0 : break;
1315 : case WID_MODEL_DSGNMODE:
1316 0 : aAny <<= mpDoc->GetOpenInDesignMode();
1317 0 : break;
1318 : case WID_MODEL_BASICLIBS:
1319 0 : aAny <<= mpDocShell->GetBasicContainer();
1320 0 : break;
1321 : case WID_MODEL_DIALOGLIBS:
1322 0 : aAny <<= mpDocShell->GetDialogContainer();
1323 0 : break;
1324 : case WID_MODEL_RUNTIMEUID:
1325 24 : aAny <<= getRuntimeUID();
1326 24 : break;
1327 : case WID_MODEL_BUILDID:
1328 0 : return uno::Any( maBuildId );
1329 : case WID_MODEL_HASVALIDSIGNATURES:
1330 0 : aAny <<= hasValidSignatures();
1331 0 : break;
1332 : default:
1333 0 : throw beans::UnknownPropertyException();
1334 : }
1335 :
1336 24 : return aAny;
1337 : }
1338 :
1339 0 : void SAL_CALL SdXImpressDocument::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1340 0 : void SAL_CALL SdXImpressDocument::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1341 0 : void SAL_CALL SdXImpressDocument::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1342 0 : void SAL_CALL SdXImpressDocument::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1343 :
1344 : // XLinkTargetSupplier
1345 0 : uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getLinks()
1346 : throw(uno::RuntimeException)
1347 : {
1348 0 : ::SolarMutexGuard aGuard;
1349 :
1350 0 : if( NULL == mpDoc )
1351 0 : throw lang::DisposedException();
1352 :
1353 0 : uno::Reference< container::XNameAccess > xLinks( mxLinks );
1354 0 : if( !xLinks.is() )
1355 0 : mxLinks = xLinks = new SdDocLinkTargets( *this );
1356 0 : return xLinks;
1357 : }
1358 :
1359 : // XStyleFamiliesSupplier
1360 127 : uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getStyleFamilies( )
1361 : throw(uno::RuntimeException)
1362 : {
1363 127 : ::SolarMutexGuard aGuard;
1364 :
1365 127 : if( NULL == mpDoc )
1366 0 : throw lang::DisposedException();
1367 :
1368 127 : uno::Reference< container::XNameAccess > xStyles( dynamic_cast< container::XNameAccess* >( mpDoc->GetStyleSheetPool()) );
1369 127 : return xStyles;
1370 : }
1371 :
1372 : // XAnyCompareFactory
1373 11 : uno::Reference< com::sun::star::ucb::XAnyCompare > SAL_CALL SdXImpressDocument::createAnyCompareByName( const OUString& )
1374 : throw (uno::RuntimeException)
1375 : {
1376 11 : return SvxCreateNumRuleCompare();
1377 : }
1378 :
1379 : // XRenderable
1380 0 : sal_Int32 SAL_CALL SdXImpressDocument::getRendererCount( const uno::Any& rSelection,
1381 : const uno::Sequence< beans::PropertyValue >& )
1382 : throw (lang::IllegalArgumentException, uno::RuntimeException)
1383 : {
1384 0 : ::SolarMutexGuard aGuard;
1385 0 : sal_Int32 nRet = 0;
1386 :
1387 0 : if( NULL == mpDoc )
1388 0 : throw lang::DisposedException();
1389 :
1390 0 : uno::Sequence< beans::PropertyValue > aRenderer;
1391 :
1392 0 : if( mpDocShell && mpDoc )
1393 : {
1394 0 : uno::Reference< frame::XModel > xModel;
1395 :
1396 0 : rSelection >>= xModel;
1397 :
1398 0 : if( xModel == mpDocShell->GetModel() )
1399 0 : nRet = mpDoc->GetSdPageCount( PK_STANDARD );
1400 : else
1401 : {
1402 0 : uno::Reference< drawing::XShapes > xShapes;
1403 :
1404 0 : rSelection >>= xShapes;
1405 :
1406 0 : if( xShapes.is() && xShapes->getCount() )
1407 0 : nRet = 1;
1408 0 : }
1409 : }
1410 0 : return nRet;
1411 : }
1412 :
1413 0 : uno::Sequence< beans::PropertyValue > SAL_CALL SdXImpressDocument::getRenderer( sal_Int32 , const uno::Any& ,
1414 : const uno::Sequence< beans::PropertyValue >& rxOptions )
1415 : throw (lang::IllegalArgumentException, uno::RuntimeException)
1416 : {
1417 0 : ::SolarMutexGuard aGuard;
1418 :
1419 0 : if( NULL == mpDoc )
1420 0 : throw lang::DisposedException();
1421 :
1422 0 : sal_Bool bExportNotesPages = sal_False;
1423 0 : for( sal_Int32 nProperty = 0, nPropertyCount = rxOptions.getLength(); nProperty < nPropertyCount; ++nProperty )
1424 : {
1425 0 : if ( rxOptions[ nProperty ].Name == "ExportNotesPages" )
1426 0 : rxOptions[ nProperty].Value >>= bExportNotesPages;
1427 : }
1428 0 : uno::Sequence< beans::PropertyValue > aRenderer;
1429 0 : if( mpDocShell && mpDoc )
1430 : {
1431 0 : awt::Size aPageSize;
1432 0 : if ( bExportNotesPages )
1433 : {
1434 0 : Size aNotesPageSize = mpDoc->GetSdPage( 0, PK_NOTES )->GetSize();
1435 0 : aPageSize = awt::Size( aNotesPageSize.Width(), aNotesPageSize.Height() );
1436 : }
1437 : else
1438 : {
1439 0 : const Rectangle aVisArea( mpDocShell->GetVisArea( embed::Aspects::MSOLE_DOCPRINT ) );
1440 0 : aPageSize = awt::Size( aVisArea.GetWidth(), aVisArea.GetHeight() );
1441 : }
1442 0 : aRenderer.realloc( 1 );
1443 :
1444 0 : aRenderer[ 0 ].Name = "PageSize" ;
1445 0 : aRenderer[ 0 ].Value <<= aPageSize;
1446 : }
1447 0 : return aRenderer;
1448 : }
1449 :
1450 : class ImplRenderPaintProc : public ::sdr::contact::ViewObjectContactRedirector
1451 : {
1452 : const SdrLayerAdmin& rLayerAdmin;
1453 : SdrPageView* pSdrPageView;
1454 : vcl::PDFExtOutDevData* pPDFExtOutDevData;
1455 :
1456 : vcl::PDFWriter::StructElement ImplBegStructureTag( SdrObject& rObject );
1457 :
1458 : public:
1459 : sal_Bool IsVisible ( const SdrObject* pObj ) const;
1460 : sal_Bool IsPrintable( const SdrObject* pObj ) const;
1461 :
1462 : ImplRenderPaintProc( const SdrLayerAdmin& rLA, SdrPageView* pView, vcl::PDFExtOutDevData* pData );
1463 : virtual ~ImplRenderPaintProc();
1464 :
1465 : // all default implementations just call the same methods at the original. To do something
1466 : // different, overload the method and at least do what the method does.
1467 : virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
1468 : const sdr::contact::ViewObjectContact& rOriginal,
1469 : const sdr::contact::DisplayInfo& rDisplayInfo);
1470 : };
1471 :
1472 0 : ImplRenderPaintProc::ImplRenderPaintProc( const SdrLayerAdmin& rLA, SdrPageView* pView, vcl::PDFExtOutDevData* pData )
1473 : : ViewObjectContactRedirector(),
1474 : rLayerAdmin ( rLA ),
1475 : pSdrPageView ( pView ),
1476 0 : pPDFExtOutDevData ( pData )
1477 : {
1478 0 : }
1479 :
1480 0 : ImplRenderPaintProc::~ImplRenderPaintProc()
1481 : {
1482 0 : }
1483 :
1484 0 : sal_Int32 ImplPDFGetBookmarkPage( const String& rBookmark, SdDrawDocument& rDoc )
1485 : {
1486 0 : sal_Int32 nPage = -1;
1487 :
1488 : OSL_TRACE("GotoBookmark %s",
1489 : ::rtl::OUStringToOString(rBookmark, RTL_TEXTENCODING_UTF8).getStr());
1490 :
1491 0 : String aBookmark( rBookmark );
1492 :
1493 0 : if( rBookmark.Len() && rBookmark.GetChar( 0 ) == sal_Unicode('#') )
1494 0 : aBookmark = rBookmark.Copy( 1 );
1495 :
1496 : // is the bookmark a page ?
1497 : sal_Bool bIsMasterPage;
1498 0 : sal_uInt16 nPgNum = rDoc.GetPageByName( aBookmark, bIsMasterPage );
1499 0 : SdrObject* pObj = NULL;
1500 :
1501 0 : if ( nPgNum == SDRPAGE_NOTFOUND )
1502 : {
1503 : // is the bookmark a object ?
1504 0 : pObj = rDoc.GetObj( aBookmark );
1505 0 : if (pObj)
1506 0 : nPgNum = pObj->GetPage()->GetPageNum();
1507 : }
1508 0 : if ( nPgNum != SDRPAGE_NOTFOUND )
1509 0 : nPage = ( nPgNum - 1 ) / 2;
1510 0 : return nPage;
1511 : }
1512 :
1513 0 : void ImplPDFExportComments( uno::Reference< drawing::XDrawPage > xPage, vcl::PDFExtOutDevData& rPDFExtOutDevData )
1514 : {
1515 : try
1516 : {
1517 0 : uno::Reference< office::XAnnotationAccess > xAnnotationAccess( xPage, uno::UNO_QUERY_THROW );
1518 0 : uno::Reference< office::XAnnotationEnumeration > xAnnotationEnumeration( xAnnotationAccess->createAnnotationEnumeration() );
1519 :
1520 0 : LanguageType eLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
1521 0 : while( xAnnotationEnumeration->hasMoreElements() )
1522 : {
1523 0 : uno::Reference< office::XAnnotation > xAnnotation( xAnnotationEnumeration->nextElement() );
1524 :
1525 0 : geometry::RealPoint2D aRealPoint2D( xAnnotation->getPosition() );
1526 0 : uno::Reference< text::XText > xText( xAnnotation->getTextRange() );
1527 0 : util::DateTime aDateTime( xAnnotation->getDateTime() );
1528 :
1529 0 : Date aDate( aDateTime.Day, aDateTime.Month, aDateTime.Year );
1530 0 : Time aTime( Time::EMPTY );
1531 0 : String aStr( SvxDateTimeField::GetFormatted( aDate, aTime, SVXDATEFORMAT_B, *(SD_MOD()->GetNumberFormatter()), eLanguage ) );
1532 :
1533 0 : vcl::PDFNote aNote;
1534 0 : String sTitle( xAnnotation->getAuthor() );
1535 0 : sTitle.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ", " ) );
1536 0 : sTitle += aStr;
1537 0 : aNote.Title = sTitle;
1538 0 : aNote.Contents = xText->getString();
1539 : rPDFExtOutDevData.CreateNote( Rectangle( Point( static_cast< long >( aRealPoint2D.X * 100 ),
1540 0 : static_cast< long >( aRealPoint2D.Y * 100 ) ), Size( 1000, 1000 ) ), aNote );
1541 0 : }
1542 : }
1543 0 : catch (const uno::Exception&)
1544 : {
1545 : }
1546 0 : }
1547 :
1548 0 : void ImplPDFExportShapeInteraction( uno::Reference< drawing::XShape > xShape, SdDrawDocument& rDoc, vcl::PDFExtOutDevData& rPDFExtOutDevData )
1549 : {
1550 0 : const rtl::OUString sGroup ( "com.sun.star.drawing.GroupShape");
1551 0 : const rtl::OUString sOnClick ( "OnClick" );
1552 0 : const rtl::OUString sBookmark( "Bookmark" );
1553 :
1554 0 : if ( xShape->getShapeType().equals( sGroup ) )
1555 : {
1556 0 : uno::Reference< container::XIndexAccess > xIndexAccess( xShape, uno::UNO_QUERY );
1557 0 : if ( xIndexAccess.is() )
1558 : {
1559 0 : sal_Int32 i, nCount = xIndexAccess->getCount();
1560 0 : for ( i = 0; i < nCount; i++ )
1561 : {
1562 0 : uno::Reference< drawing::XShape > xSubShape( xIndexAccess->getByIndex( i ), uno::UNO_QUERY );
1563 0 : if ( xSubShape.is() )
1564 0 : ImplPDFExportShapeInteraction( xSubShape, rDoc, rPDFExtOutDevData );
1565 0 : }
1566 0 : }
1567 : }
1568 : else
1569 : {
1570 0 : uno::Reference< beans::XPropertySet > xShapePropSet( xShape, uno::UNO_QUERY );
1571 0 : if( xShapePropSet.is() )
1572 : {
1573 0 : Size aPageSize( rDoc.GetSdPage( 0, PK_STANDARD )->GetSize() );
1574 0 : Point aPoint( 0, 0 );
1575 0 : Rectangle aPageRect( aPoint, aPageSize );
1576 :
1577 0 : awt::Point aShapePos( xShape->getPosition() );
1578 0 : awt::Size aShapeSize( xShape->getSize() );
1579 0 : Rectangle aLinkRect( Point( aShapePos.X, aShapePos.Y ), Size( aShapeSize.Width, aShapeSize.Height ) );
1580 :
1581 : presentation::ClickAction eCa;
1582 0 : uno::Any aAny( xShapePropSet->getPropertyValue( sOnClick ) );
1583 0 : if ( aAny >>= eCa )
1584 : {
1585 0 : switch ( eCa )
1586 : {
1587 : case presentation::ClickAction_LASTPAGE :
1588 : {
1589 0 : sal_Int32 nCount = rDoc.GetSdPageCount( PK_STANDARD );
1590 0 : sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nCount - 1, vcl::PDFWriter::FitRectangle );
1591 0 : sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
1592 0 : rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1593 : }
1594 0 : break;
1595 : case presentation::ClickAction_FIRSTPAGE :
1596 : {
1597 0 : sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, 0, vcl::PDFWriter::FitRectangle );
1598 0 : sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
1599 0 : rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1600 : }
1601 0 : break;
1602 : case presentation::ClickAction_PREVPAGE :
1603 : {
1604 0 : sal_Int32 nDestPage = rPDFExtOutDevData.GetCurrentPageNumber();
1605 0 : if ( nDestPage )
1606 0 : nDestPage--;
1607 0 : sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nDestPage, vcl::PDFWriter::FitRectangle );
1608 0 : sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
1609 0 : rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1610 : }
1611 0 : break;
1612 : case presentation::ClickAction_NEXTPAGE :
1613 : {
1614 0 : sal_Int32 nDestPage = rPDFExtOutDevData.GetCurrentPageNumber() + 1;
1615 0 : sal_Int32 nLastPage = rDoc.GetSdPageCount( PK_STANDARD ) - 1;
1616 0 : if ( nDestPage > nLastPage )
1617 0 : nDestPage = nLastPage;
1618 0 : sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nDestPage, vcl::PDFWriter::FitRectangle );
1619 0 : sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
1620 0 : rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1621 : }
1622 0 : break;
1623 :
1624 : case presentation::ClickAction_PROGRAM :
1625 : case presentation::ClickAction_BOOKMARK :
1626 : case presentation::ClickAction_DOCUMENT :
1627 : {
1628 0 : rtl::OUString aBookmark;
1629 0 : xShapePropSet->getPropertyValue( sBookmark ) >>= aBookmark;
1630 0 : if( !aBookmark.isEmpty() )
1631 : {
1632 0 : switch( eCa )
1633 : {
1634 : case presentation::ClickAction_DOCUMENT :
1635 : case presentation::ClickAction_PROGRAM :
1636 : {
1637 0 : sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
1638 0 : rPDFExtOutDevData.SetLinkURL( nLinkId, aBookmark );
1639 : }
1640 0 : break;
1641 : case presentation::ClickAction_BOOKMARK :
1642 : {
1643 0 : sal_Int32 nPage = ImplPDFGetBookmarkPage( aBookmark, rDoc );
1644 0 : if ( nPage != -1 )
1645 : {
1646 0 : sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nPage, vcl::PDFWriter::FitRectangle );
1647 0 : sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect, -1 );
1648 0 : rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1649 : }
1650 : }
1651 0 : break;
1652 : default:
1653 0 : break;
1654 : }
1655 0 : }
1656 : }
1657 0 : break;
1658 :
1659 : case presentation::ClickAction_STOPPRESENTATION :
1660 : case presentation::ClickAction_SOUND :
1661 : case presentation::ClickAction_INVISIBLE :
1662 : case presentation::ClickAction_VERB :
1663 : case presentation::ClickAction_VANISH :
1664 : case presentation::ClickAction_MACRO :
1665 : default :
1666 0 : break;
1667 : }
1668 0 : }
1669 0 : }
1670 0 : }
1671 0 : }
1672 :
1673 0 : vcl::PDFWriter::StructElement ImplRenderPaintProc::ImplBegStructureTag( SdrObject& rObject )
1674 : {
1675 0 : vcl::PDFWriter::StructElement eElement(vcl::PDFWriter::NonStructElement);
1676 :
1677 0 : if ( pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportTaggedPDF() )
1678 : {
1679 0 : sal_uInt32 nInventor = rObject.GetObjInventor();
1680 0 : sal_uInt16 nIdentifier = rObject.GetObjIdentifier();
1681 0 : sal_Bool bIsTextObj = rObject.ISA( SdrTextObj );
1682 :
1683 0 : if ( nInventor == SdrInventor )
1684 : {
1685 0 : if ( nIdentifier == OBJ_GRUP )
1686 0 : eElement = vcl::PDFWriter::Section;
1687 0 : else if ( nIdentifier == OBJ_TITLETEXT )
1688 0 : eElement = vcl::PDFWriter::Heading;
1689 0 : else if ( nIdentifier == OBJ_OUTLINETEXT )
1690 0 : eElement = vcl::PDFWriter::Division;
1691 0 : else if ( !bIsTextObj || !((SdrTextObj&)rObject).HasText() )
1692 0 : eElement = vcl::PDFWriter::Figure;
1693 : }
1694 : }
1695 :
1696 0 : return eElement;
1697 : }
1698 :
1699 0 : drawinglayer::primitive2d::Primitive2DSequence ImplRenderPaintProc::createRedirectedPrimitive2DSequence(
1700 : const sdr::contact::ViewObjectContact& rOriginal,
1701 : const sdr::contact::DisplayInfo& rDisplayInfo)
1702 : {
1703 0 : SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
1704 :
1705 0 : if(pObject)
1706 : {
1707 0 : drawinglayer::primitive2d::Primitive2DSequence xRetval;
1708 :
1709 0 : if(pObject->GetPage())
1710 : {
1711 0 : if(pObject->GetPage()->checkVisibility(rOriginal, rDisplayInfo, false))
1712 : {
1713 0 : if(IsVisible(pObject) && IsPrintable(pObject))
1714 : {
1715 0 : const vcl::PDFWriter::StructElement eElement(ImplBegStructureTag( *pObject ));
1716 0 : const bool bTagUsed(vcl::PDFWriter::NonStructElement != eElement);
1717 :
1718 0 : xRetval = ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
1719 :
1720 0 : if(xRetval.hasElements() && bTagUsed)
1721 : {
1722 : // embed Primitive2DSequence in a structure tag element for
1723 : // exactly this purpose (StructureTagPrimitive2D)
1724 0 : const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::StructureTagPrimitive2D(eElement, xRetval));
1725 0 : xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xReference, 1);
1726 : }
1727 : }
1728 : }
1729 : }
1730 :
1731 0 : return xRetval;
1732 : }
1733 : else
1734 : {
1735 : // not an object, maybe a page
1736 0 : return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
1737 : }
1738 : }
1739 :
1740 0 : sal_Bool ImplRenderPaintProc::IsVisible( const SdrObject* pObj ) const
1741 : {
1742 0 : sal_Bool bVisible = sal_True;
1743 0 : SdrLayerID nLayerId = pObj->GetLayer();
1744 0 : if( pSdrPageView )
1745 : {
1746 0 : const SdrLayer* pSdrLayer = rLayerAdmin.GetLayer( nLayerId );
1747 0 : if ( pSdrLayer )
1748 : {
1749 0 : String aLayerName = pSdrLayer->GetName();
1750 0 : bVisible = pSdrPageView->IsLayerVisible( aLayerName );
1751 : }
1752 : }
1753 0 : return bVisible;
1754 : }
1755 0 : sal_Bool ImplRenderPaintProc::IsPrintable( const SdrObject* pObj ) const
1756 : {
1757 0 : sal_Bool bPrintable = sal_True;
1758 0 : SdrLayerID nLayerId = pObj->GetLayer();
1759 0 : if( pSdrPageView )
1760 : {
1761 0 : const SdrLayer* pSdrLayer = rLayerAdmin.GetLayer( nLayerId );
1762 0 : if ( pSdrLayer )
1763 : {
1764 0 : String aLayerName = pSdrLayer->GetName();
1765 0 : bPrintable = pSdrPageView->IsLayerPrintable( aLayerName );
1766 : }
1767 : }
1768 0 : return bPrintable;
1769 :
1770 : }
1771 0 : void SAL_CALL SdXImpressDocument::render( sal_Int32 nRenderer, const uno::Any& rSelection,
1772 : const uno::Sequence< beans::PropertyValue >& rxOptions )
1773 : throw (lang::IllegalArgumentException, uno::RuntimeException)
1774 : {
1775 0 : ::SolarMutexGuard aGuard;
1776 :
1777 0 : if( NULL == mpDoc )
1778 0 : throw lang::DisposedException();
1779 :
1780 0 : if( mpDocShell && mpDoc )
1781 : {
1782 0 : uno::Reference< awt::XDevice > xRenderDevice;
1783 0 : const sal_Int32 nPageNumber = nRenderer + 1;
1784 0 : PageKind ePageKind = PK_STANDARD;
1785 0 : sal_Bool bExportNotesPages = sal_False;
1786 :
1787 0 : for( sal_Int32 nProperty = 0, nPropertyCount = rxOptions.getLength(); nProperty < nPropertyCount; ++nProperty )
1788 : {
1789 0 : if ( rxOptions[ nProperty ].Name == "RenderDevice" )
1790 0 : rxOptions[ nProperty ].Value >>= xRenderDevice;
1791 0 : else if ( rxOptions[ nProperty ].Name == "ExportNotesPages" )
1792 : {
1793 0 : rxOptions[ nProperty].Value >>= bExportNotesPages;
1794 0 : if ( bExportNotesPages )
1795 0 : ePageKind = PK_NOTES;
1796 : }
1797 : }
1798 :
1799 0 : if( xRenderDevice.is() && nPageNumber && ( nPageNumber <= mpDoc->GetSdPageCount( ePageKind ) ) )
1800 : {
1801 0 : VCLXDevice* pDevice = VCLXDevice::GetImplementation( xRenderDevice );
1802 0 : OutputDevice* pOut = pDevice ? pDevice->GetOutputDevice() : NULL;
1803 :
1804 0 : if( pOut )
1805 : {
1806 0 : vcl::PDFExtOutDevData* pPDFExtOutDevData = PTR_CAST( vcl::PDFExtOutDevData, pOut->GetExtOutDevData() );
1807 :
1808 0 : if ( !( (mpDoc->GetSdPage((sal_Int16) nPageNumber-1, PK_STANDARD))->IsExcluded() ) ||
1809 0 : pPDFExtOutDevData->GetIsExportHiddenSlides() )
1810 : {
1811 0 : ::sd::ClientView* pView = new ::sd::ClientView( mpDocShell, pOut, NULL );
1812 0 : Rectangle aVisArea = Rectangle( Point(), mpDoc->GetSdPage( (sal_uInt16)nPageNumber - 1, ePageKind )->GetSize() );
1813 0 : Region aRegion( aVisArea );
1814 0 : Point aOrigin;
1815 :
1816 0 : ::sd::ViewShell* pOldViewSh = mpDocShell->GetViewShell();
1817 0 : ::sd::View* pOldSdView = pOldViewSh ? pOldViewSh->GetView() : NULL;
1818 :
1819 0 : if ( pOldSdView )
1820 0 : pOldSdView->SdrEndTextEdit();
1821 :
1822 0 : pView->SetHlplVisible( sal_False );
1823 0 : pView->SetGridVisible( sal_False );
1824 0 : pView->SetBordVisible( sal_False );
1825 0 : pView->SetPageVisible( sal_False );
1826 0 : pView->SetGlueVisible( sal_False );
1827 :
1828 0 : pOut->SetMapMode( MAP_100TH_MM );
1829 0 : pOut->IntersectClipRegion( aVisArea );
1830 :
1831 :
1832 :
1833 0 : uno::Reference< frame::XModel > xModel;
1834 0 : rSelection >>= xModel;
1835 :
1836 0 : if( xModel == mpDocShell->GetModel() )
1837 : {
1838 0 : pView->ShowSdrPage( mpDoc->GetSdPage( (sal_uInt16)nPageNumber - 1, ePageKind ));
1839 0 : SdrPageView* pPV = pView->GetSdrPageView();
1840 :
1841 0 : if( pOldSdView )
1842 : {
1843 0 : SdrPageView* pOldPV = pOldSdView->GetSdrPageView();
1844 0 : if( pPV && pOldPV )
1845 : {
1846 0 : pPV->SetVisibleLayers( pOldPV->GetVisibleLayers() );
1847 0 : pPV->SetPrintableLayers( pOldPV->GetPrintableLayers() );
1848 : }
1849 : }
1850 :
1851 0 : ImplRenderPaintProc aImplRenderPaintProc( mpDoc->GetLayerAdmin(),
1852 0 : pPV, pPDFExtOutDevData );
1853 :
1854 : // background color for outliner :o
1855 0 : SdPage* pPage = (SdPage*)pPV->GetPage();
1856 0 : if( pPage )
1857 : {
1858 0 : SdrOutliner& rOutl = mpDoc->GetDrawOutliner( NULL );
1859 0 : bool bScreenDisplay(true);
1860 :
1861 0 : if(bScreenDisplay && pOut && OUTDEV_PRINTER == pOut->GetOutDevType())
1862 : {
1863 : // #i75566# printing; suppress AutoColor BackgroundColor generation
1864 : // for visibility reasons by giving GetPageBackgroundColor()
1865 : // the needed hint
1866 0 : bScreenDisplay = false;
1867 : }
1868 :
1869 0 : if(bScreenDisplay && pOut && pOut->GetPDFWriter())
1870 : {
1871 : // #i75566# PDF export; suppress AutoColor BackgroundColor generation (see above)
1872 0 : bScreenDisplay = false;
1873 : }
1874 :
1875 : // #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and
1876 : // hint value if screen display. Only then the AutoColor mechanisms shall be applied
1877 0 : rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor( pPV, bScreenDisplay ) );
1878 : }
1879 0 : pView->SdrPaintView::CompleteRedraw( pOut, aRegion, &aImplRenderPaintProc );
1880 :
1881 0 : if ( pPDFExtOutDevData )
1882 : {
1883 : try
1884 : {
1885 0 : uno::Any aAny;
1886 0 : uno::Reference< drawing::XDrawPage > xPage( uno::Reference< drawing::XDrawPage >::query( pPage->getUnoPage() ) );
1887 0 : if ( xPage.is() )
1888 : {
1889 0 : if ( pPDFExtOutDevData->GetIsExportNotes() )
1890 0 : ImplPDFExportComments( xPage, *pPDFExtOutDevData );
1891 0 : uno::Reference< beans::XPropertySet > xPagePropSet( xPage, uno::UNO_QUERY );
1892 0 : if( xPagePropSet.is() )
1893 : {
1894 : // exporting object interactions to pdf
1895 :
1896 : // if necessary, the master page interactions will be exported first
1897 0 : sal_Bool bIsBackgroundObjectsVisible = sal_False; // #i39428# IsBackgroundObjectsVisible not available for Draw
1898 0 : if ( mbImpressDoc && xPagePropSet->getPropertySetInfo()->hasPropertyByName( "IsBackgroundObjectsVisible" ) )
1899 0 : xPagePropSet->getPropertyValue( "IsBackgroundObjectsVisible" ) >>= bIsBackgroundObjectsVisible;
1900 0 : if ( bIsBackgroundObjectsVisible && !pPDFExtOutDevData->GetIsExportNotesPages() )
1901 : {
1902 0 : uno::Reference< drawing::XMasterPageTarget > xMasterPageTarget( xPage, uno::UNO_QUERY );
1903 0 : if ( xMasterPageTarget.is() )
1904 : {
1905 0 : uno::Reference< drawing::XDrawPage > xMasterPage = xMasterPageTarget->getMasterPage();
1906 0 : if ( xMasterPage.is() )
1907 : {
1908 0 : uno::Reference< drawing::XShapes> xShapes( xMasterPage, uno::UNO_QUERY );
1909 0 : sal_Int32 i, nCount = xShapes->getCount();
1910 0 : for ( i = 0; i < nCount; i++ )
1911 : {
1912 0 : aAny = xShapes->getByIndex( i );
1913 0 : uno::Reference< drawing::XShape > xShape;
1914 0 : if ( aAny >>= xShape )
1915 0 : ImplPDFExportShapeInteraction( xShape, *mpDoc, *pPDFExtOutDevData );
1916 0 : }
1917 0 : }
1918 0 : }
1919 : }
1920 :
1921 : // exporting slide page object interactions
1922 0 : uno::Reference< drawing::XShapes> xShapes( xPage, uno::UNO_QUERY );
1923 0 : sal_Int32 i, nCount = xShapes->getCount();
1924 0 : for ( i = 0; i < nCount; i++ )
1925 : {
1926 0 : aAny = xShapes->getByIndex( i );
1927 0 : uno::Reference< drawing::XShape > xShape;
1928 0 : if ( aAny >>= xShape )
1929 0 : ImplPDFExportShapeInteraction( xShape, *mpDoc, *pPDFExtOutDevData );
1930 0 : }
1931 :
1932 : // exporting transition effects to pdf
1933 0 : if ( mbImpressDoc && !pPDFExtOutDevData->GetIsExportNotesPages() && pPDFExtOutDevData->GetIsExportTransitionEffects() )
1934 : {
1935 0 : const rtl::OUString sEffect( "Effect" );
1936 0 : const rtl::OUString sSpeed ( "Speed" );
1937 0 : sal_Int32 nTime = 800;
1938 : presentation::AnimationSpeed aAs;
1939 0 : if ( xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sSpeed ) )
1940 : {
1941 0 : aAny = xPagePropSet->getPropertyValue( sSpeed );
1942 0 : if ( aAny >>= aAs )
1943 : {
1944 0 : switch( aAs )
1945 : {
1946 0 : case presentation::AnimationSpeed_SLOW : nTime = 1500; break;
1947 0 : case presentation::AnimationSpeed_FAST : nTime = 300; break;
1948 : default:
1949 0 : case presentation::AnimationSpeed_MEDIUM : nTime = 800;
1950 : }
1951 : }
1952 : }
1953 : presentation::FadeEffect eFe;
1954 0 : vcl::PDFWriter::PageTransition eType = vcl::PDFWriter::Regular;
1955 0 : if ( xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sEffect ) )
1956 : {
1957 0 : aAny = xPagePropSet->getPropertyValue( sEffect );
1958 0 : if ( aAny >>= eFe )
1959 : {
1960 0 : switch( eFe )
1961 : {
1962 : case presentation::FadeEffect_HORIZONTAL_LINES :
1963 : case presentation::FadeEffect_HORIZONTAL_CHECKERBOARD :
1964 0 : case presentation::FadeEffect_HORIZONTAL_STRIPES : eType = vcl::PDFWriter::BlindsHorizontal; break;
1965 :
1966 : case presentation::FadeEffect_VERTICAL_LINES :
1967 : case presentation::FadeEffect_VERTICAL_CHECKERBOARD :
1968 0 : case presentation::FadeEffect_VERTICAL_STRIPES : eType = vcl::PDFWriter::BlindsVertical; break;
1969 :
1970 : case presentation::FadeEffect_UNCOVER_TO_RIGHT :
1971 : case presentation::FadeEffect_UNCOVER_TO_UPPERRIGHT :
1972 : case presentation::FadeEffect_ROLL_FROM_LEFT :
1973 : case presentation::FadeEffect_FADE_FROM_UPPERLEFT :
1974 : case presentation::FadeEffect_MOVE_FROM_UPPERLEFT :
1975 : case presentation::FadeEffect_FADE_FROM_LEFT :
1976 0 : case presentation::FadeEffect_MOVE_FROM_LEFT : eType = vcl::PDFWriter::WipeLeftToRight; break;
1977 :
1978 : case presentation::FadeEffect_UNCOVER_TO_BOTTOM :
1979 : case presentation::FadeEffect_UNCOVER_TO_LOWERRIGHT :
1980 : case presentation::FadeEffect_ROLL_FROM_TOP :
1981 : case presentation::FadeEffect_FADE_FROM_UPPERRIGHT :
1982 : case presentation::FadeEffect_MOVE_FROM_UPPERRIGHT :
1983 : case presentation::FadeEffect_FADE_FROM_TOP :
1984 0 : case presentation::FadeEffect_MOVE_FROM_TOP : eType = vcl::PDFWriter::WipeTopToBottom; break;
1985 :
1986 : case presentation::FadeEffect_UNCOVER_TO_LEFT :
1987 : case presentation::FadeEffect_UNCOVER_TO_LOWERLEFT :
1988 : case presentation::FadeEffect_ROLL_FROM_RIGHT :
1989 :
1990 : case presentation::FadeEffect_FADE_FROM_LOWERRIGHT :
1991 : case presentation::FadeEffect_MOVE_FROM_LOWERRIGHT :
1992 : case presentation::FadeEffect_FADE_FROM_RIGHT :
1993 0 : case presentation::FadeEffect_MOVE_FROM_RIGHT : eType = vcl::PDFWriter::WipeRightToLeft; break;
1994 :
1995 : case presentation::FadeEffect_UNCOVER_TO_TOP :
1996 : case presentation::FadeEffect_UNCOVER_TO_UPPERLEFT :
1997 : case presentation::FadeEffect_ROLL_FROM_BOTTOM :
1998 : case presentation::FadeEffect_FADE_FROM_LOWERLEFT :
1999 : case presentation::FadeEffect_MOVE_FROM_LOWERLEFT :
2000 : case presentation::FadeEffect_FADE_FROM_BOTTOM :
2001 0 : case presentation::FadeEffect_MOVE_FROM_BOTTOM : eType = vcl::PDFWriter::WipeBottomToTop; break;
2002 :
2003 0 : case presentation::FadeEffect_OPEN_VERTICAL : eType = vcl::PDFWriter::SplitHorizontalInward; break;
2004 0 : case presentation::FadeEffect_CLOSE_HORIZONTAL : eType = vcl::PDFWriter::SplitHorizontalOutward; break;
2005 :
2006 0 : case presentation::FadeEffect_OPEN_HORIZONTAL : eType = vcl::PDFWriter::SplitVerticalInward; break;
2007 0 : case presentation::FadeEffect_CLOSE_VERTICAL : eType = vcl::PDFWriter::SplitVerticalOutward; break;
2008 :
2009 0 : case presentation::FadeEffect_FADE_TO_CENTER : eType = vcl::PDFWriter::BoxInward; break;
2010 0 : case presentation::FadeEffect_FADE_FROM_CENTER : eType = vcl::PDFWriter::BoxOutward; break;
2011 :
2012 0 : case presentation::FadeEffect_NONE : eType = vcl::PDFWriter::Regular; break;
2013 :
2014 : case presentation::FadeEffect_RANDOM :
2015 : case presentation::FadeEffect_DISSOLVE :
2016 0 : default: eType = vcl::PDFWriter::Dissolve; break;
2017 : }
2018 : }
2019 : }
2020 :
2021 0 : if ( xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sEffect ) ||
2022 0 : xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sSpeed ) )
2023 : {
2024 0 : pPDFExtOutDevData->SetPageTransition( eType, nTime, -1 );
2025 0 : }
2026 0 : }
2027 0 : }
2028 : }
2029 :
2030 0 : Size aPageSize( mpDoc->GetSdPage( 0, PK_STANDARD )->GetSize() );
2031 0 : Point aPoint( 0, 0 );
2032 0 : Rectangle aPageRect( aPoint, aPageSize );
2033 :
2034 : // resolving links found in this page by the method ImpEditEngine::Paint
2035 0 : std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = pPDFExtOutDevData->GetBookmarks();
2036 0 : std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIBeg = rBookmarks.begin();
2037 0 : std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIEnd = rBookmarks.end();
2038 0 : while ( aIBeg != aIEnd )
2039 : {
2040 0 : sal_Int32 nPage = ImplPDFGetBookmarkPage( aIBeg->aBookmark, *mpDoc );
2041 0 : if ( nPage != -1 )
2042 : {
2043 0 : if ( aIBeg->nLinkId != -1 )
2044 0 : pPDFExtOutDevData->SetLinkDest( aIBeg->nLinkId, pPDFExtOutDevData->CreateDest( aPageRect, nPage, vcl::PDFWriter::FitRectangle ) );
2045 : else
2046 0 : pPDFExtOutDevData->DescribeRegisteredDest( aIBeg->nDestId, aPageRect, nPage, vcl::PDFWriter::FitRectangle );
2047 : }
2048 : else
2049 0 : pPDFExtOutDevData->SetLinkURL( aIBeg->nLinkId, aIBeg->aBookmark );
2050 0 : ++aIBeg;
2051 : }
2052 0 : rBookmarks.clear();
2053 : //---> #i56629, #i40318
2054 : //get the page name, will be used as outline element in PDF bookmark pane
2055 0 : String aPageName = mpDoc->GetSdPage( (sal_uInt16)nPageNumber - 1 , PK_STANDARD )->GetName();
2056 0 : if( aPageName.Len() > 0 )
2057 : {
2058 : // insert the bookmark to this page into the NamedDestinations
2059 0 : if( pPDFExtOutDevData->GetIsExportNamedDestinations() )
2060 0 : pPDFExtOutDevData->CreateNamedDest( aPageName, aPageRect, nPageNumber - 1 );
2061 : //
2062 : // add the name to the outline, (almost) same code as in sc/source/ui/unoobj/docuno.cxx
2063 : // issue #i40318.
2064 : //
2065 0 : if( pPDFExtOutDevData->GetIsExportBookmarks() )
2066 : {
2067 : // Destination Export
2068 : const sal_Int32 nDestId =
2069 0 : pPDFExtOutDevData->CreateDest( aPageRect , nPageNumber - 1 );
2070 :
2071 : // Create a new outline item:
2072 0 : pPDFExtOutDevData->CreateOutlineItem( -1 , aPageName, nDestId );
2073 : }
2074 0 : }
2075 : //<--- #i56629, #i40318
2076 : }
2077 0 : catch (const uno::Exception&)
2078 : {
2079 : }
2080 :
2081 0 : }
2082 : }
2083 : else
2084 : {
2085 0 : uno::Reference< drawing::XShapes > xShapes;
2086 0 : rSelection >>= xShapes;
2087 :
2088 0 : if( xShapes.is() && xShapes->getCount() )
2089 : {
2090 0 : SdrPageView* pPV = NULL;
2091 :
2092 0 : ImplRenderPaintProc aImplRenderPaintProc( mpDoc->GetLayerAdmin(),
2093 0 : pOldSdView ? pOldSdView->GetSdrPageView() : NULL, pPDFExtOutDevData );
2094 :
2095 0 : for( sal_uInt32 i = 0, nCount = xShapes->getCount(); i < nCount; i++ )
2096 : {
2097 0 : uno::Reference< drawing::XShape > xShape;
2098 0 : xShapes->getByIndex( i ) >>= xShape;
2099 :
2100 0 : if( xShape.is() )
2101 : {
2102 0 : SvxShape* pShape = SvxShape::getImplementation( xShape );
2103 :
2104 0 : if( pShape )
2105 : {
2106 0 : SdrObject* pObj = pShape->GetSdrObject();
2107 0 : if( pObj && pObj->GetPage()
2108 0 : && aImplRenderPaintProc.IsVisible( pObj )
2109 0 : && aImplRenderPaintProc.IsPrintable( pObj ) )
2110 : {
2111 0 : if( !pPV )
2112 0 : pPV = pView->ShowSdrPage( pObj->GetPage() );
2113 :
2114 0 : if( pPV )
2115 0 : pView->MarkObj( pObj, pPV );
2116 : }
2117 : }
2118 : }
2119 0 : }
2120 0 : pView->DrawMarkedObj(*pOut);
2121 0 : }
2122 : }
2123 :
2124 0 : delete pView;
2125 : }
2126 : }
2127 0 : }
2128 0 : }
2129 0 : }
2130 :
2131 2 : uno::Reference< i18n::XForbiddenCharacters > SdXImpressDocument::getForbiddenCharsTable()
2132 : {
2133 2 : uno::Reference< i18n::XForbiddenCharacters > xForb(mxForbidenCharacters);
2134 :
2135 2 : if( !xForb.is() )
2136 2 : mxForbidenCharacters = xForb = new SdUnoForbiddenCharsTable( mpDoc );
2137 :
2138 2 : return xForb;
2139 : }
2140 :
2141 27 : void SdXImpressDocument::initializeDocument()
2142 : {
2143 27 : if( !mbClipBoard )
2144 : {
2145 27 : switch( mpDoc->GetPageCount() )
2146 : {
2147 : case 1:
2148 : {
2149 : // nasty hack to detect clipboard document
2150 0 : mbClipBoard = true;
2151 0 : break;
2152 : }
2153 : case 0:
2154 : {
2155 4 : mpDoc->CreateFirstPages();
2156 4 : mpDoc->StopWorkStartupDelay();
2157 4 : break;
2158 : }
2159 : }
2160 : }
2161 27 : }
2162 :
2163 22 : void SAL_CALL SdXImpressDocument::dispose() throw (::com::sun::star::uno::RuntimeException)
2164 : {
2165 22 : if( !mbDisposed )
2166 : {
2167 : {
2168 22 : ::SolarMutexGuard aGuard;
2169 :
2170 22 : if( mpDoc )
2171 : {
2172 16 : EndListening( *mpDoc );
2173 16 : mpDoc = NULL;
2174 : }
2175 :
2176 : // Call the base class dispose() before setting the mbDisposed flag
2177 : // to true. The reason for this is that if close() has not yet been
2178 : // called this is done in SfxBaseModel::dispose(). At the end of
2179 : // that dispose() is called again. It is important to forward this
2180 : // second dispose() to the base class, too.
2181 : // As a consequence the following code has to be able to be run twice.
2182 22 : SfxBaseModel::dispose();
2183 22 : mbDisposed = true;
2184 :
2185 22 : uno::Reference< container::XNameAccess > xStyles(mxStyleFamilies);
2186 22 : if( xStyles.is() )
2187 : {
2188 0 : uno::Reference< lang::XComponent > xComp( xStyles, uno::UNO_QUERY );
2189 0 : if( xComp.is() )
2190 0 : xComp->dispose();
2191 :
2192 0 : xStyles = 0;
2193 : }
2194 :
2195 22 : uno::Reference< presentation::XPresentation > xPresentation( mxPresentation );
2196 22 : if( xPresentation.is() )
2197 : {
2198 0 : uno::Reference< ::com::sun::star::presentation::XPresentation2 > xPres( mpDoc->getPresentation().get() );
2199 0 : uno::Reference< lang::XComponent > xPresComp( xPres, uno::UNO_QUERY );
2200 0 : if( xPresComp.is() )
2201 0 : xPresComp->dispose();
2202 : }
2203 :
2204 22 : uno::Reference< container::XNameAccess > xLinks( mxLinks );
2205 22 : if( xLinks.is() )
2206 : {
2207 0 : uno::Reference< lang::XComponent > xComp( xLinks, uno::UNO_QUERY );
2208 0 : if( xComp.is() )
2209 0 : xComp->dispose();
2210 :
2211 0 : xLinks = 0;
2212 : }
2213 :
2214 22 : uno::Reference< drawing::XDrawPages > xDrawPagesAccess( mxDrawPagesAccess );
2215 22 : if( xDrawPagesAccess.is() )
2216 : {
2217 2 : uno::Reference< lang::XComponent > xComp( xDrawPagesAccess, uno::UNO_QUERY );
2218 2 : if( xComp.is() )
2219 2 : xComp->dispose();
2220 :
2221 2 : xDrawPagesAccess = 0;
2222 : }
2223 :
2224 22 : uno::Reference< drawing::XDrawPages > xMasterPagesAccess( mxMasterPagesAccess );
2225 22 : if( xDrawPagesAccess.is() )
2226 : {
2227 0 : uno::Reference< lang::XComponent > xComp( xMasterPagesAccess, uno::UNO_QUERY );
2228 0 : if( xComp.is() )
2229 0 : xComp->dispose();
2230 :
2231 0 : xDrawPagesAccess = 0;
2232 : }
2233 :
2234 22 : uno::Reference< container::XNameAccess > xLayerManager( mxLayerManager );
2235 22 : if( xLayerManager.is() )
2236 : {
2237 0 : uno::Reference< lang::XComponent > xComp( xLayerManager, uno::UNO_QUERY );
2238 0 : if( xComp.is() )
2239 0 : xComp->dispose();
2240 :
2241 0 : xLayerManager = 0;
2242 : }
2243 :
2244 22 : uno::Reference< container::XNameContainer > xCustomPresentationAccess( mxCustomPresentationAccess );
2245 22 : if( xCustomPresentationAccess.is() )
2246 : {
2247 0 : uno::Reference< lang::XComponent > xComp( xCustomPresentationAccess, uno::UNO_QUERY );
2248 0 : if( xComp.is() )
2249 0 : xComp->dispose();
2250 :
2251 0 : xCustomPresentationAccess = 0;
2252 : }
2253 :
2254 22 : mxDashTable = 0;
2255 22 : mxGradientTable = 0;
2256 22 : mxHatchTable = 0;
2257 22 : mxBitmapTable = 0;
2258 22 : mxTransGradientTable = 0;
2259 22 : mxMarkerTable = 0;
2260 22 : mxDrawingPool = 0;
2261 : }
2262 : }
2263 22 : }
2264 :
2265 : //=============================================================================
2266 : // class SdDrawPagesAccess
2267 : //=============================================================================
2268 :
2269 14 : SdDrawPagesAccess::SdDrawPagesAccess( SdXImpressDocument& rMyModel ) throw()
2270 14 : : mpModel( &rMyModel)
2271 : {
2272 14 : }
2273 :
2274 28 : SdDrawPagesAccess::~SdDrawPagesAccess() throw()
2275 : {
2276 28 : }
2277 :
2278 : // XIndexAccess
2279 26 : sal_Int32 SAL_CALL SdDrawPagesAccess::getCount()
2280 : throw(uno::RuntimeException)
2281 : {
2282 26 : ::SolarMutexGuard aGuard;
2283 :
2284 26 : if( NULL == mpModel )
2285 0 : throw lang::DisposedException();
2286 :
2287 26 : return mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
2288 : }
2289 :
2290 23 : uno::Any SAL_CALL SdDrawPagesAccess::getByIndex( sal_Int32 Index )
2291 : throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
2292 : {
2293 23 : ::SolarMutexGuard aGuard;
2294 :
2295 23 : if( NULL == mpModel )
2296 0 : throw lang::DisposedException();
2297 :
2298 23 : uno::Any aAny;
2299 :
2300 23 : if( (Index < 0) || (Index >= mpModel->mpDoc->GetSdPageCount( PK_STANDARD ) ) )
2301 0 : throw lang::IndexOutOfBoundsException();
2302 :
2303 23 : SdPage* pPage = mpModel->mpDoc->GetSdPage( (sal_uInt16)Index, PK_STANDARD );
2304 23 : if( pPage )
2305 : {
2306 23 : uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
2307 23 : aAny <<= xDrawPage;
2308 : }
2309 :
2310 23 : return aAny;
2311 : }
2312 :
2313 : // XNameAccess
2314 0 : uno::Any SAL_CALL SdDrawPagesAccess::getByName( const OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
2315 : {
2316 0 : ::SolarMutexGuard aGuard;
2317 :
2318 0 : if( NULL == mpModel )
2319 0 : throw lang::DisposedException();
2320 :
2321 0 : if( !aName.isEmpty() )
2322 : {
2323 0 : const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
2324 : sal_uInt16 nPage;
2325 0 : for( nPage = 0; nPage < nCount; nPage++ )
2326 : {
2327 0 : SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PK_STANDARD );
2328 0 : if(NULL == pPage)
2329 0 : continue;
2330 :
2331 0 : if( aName == SdDrawPage::getPageApiName( pPage ) )
2332 : {
2333 0 : uno::Any aAny;
2334 0 : uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
2335 0 : aAny <<= xDrawPage;
2336 0 : return aAny;
2337 : }
2338 : }
2339 : }
2340 :
2341 0 : throw container::NoSuchElementException();
2342 : }
2343 :
2344 0 : uno::Sequence< OUString > SAL_CALL SdDrawPagesAccess::getElementNames() throw(uno::RuntimeException)
2345 : {
2346 0 : ::SolarMutexGuard aGuard;
2347 :
2348 0 : if( NULL == mpModel )
2349 0 : throw lang::DisposedException();
2350 :
2351 0 : const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
2352 0 : uno::Sequence< OUString > aNames( nCount );
2353 0 : OUString* pNames = aNames.getArray();
2354 :
2355 : sal_uInt16 nPage;
2356 0 : for( nPage = 0; nPage < nCount; nPage++ )
2357 : {
2358 0 : SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PK_STANDARD );
2359 0 : *pNames++ = SdDrawPage::getPageApiName( pPage );
2360 : }
2361 :
2362 0 : return aNames;
2363 : }
2364 :
2365 0 : sal_Bool SAL_CALL SdDrawPagesAccess::hasByName( const OUString& aName ) throw(uno::RuntimeException)
2366 : {
2367 0 : ::SolarMutexGuard aGuard;
2368 :
2369 0 : if( NULL == mpModel )
2370 0 : throw lang::DisposedException();
2371 :
2372 0 : const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PK_STANDARD );
2373 : sal_uInt16 nPage;
2374 0 : for( nPage = 0; nPage < nCount; nPage++ )
2375 : {
2376 0 : SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PK_STANDARD );
2377 0 : if(NULL == pPage)
2378 0 : continue;
2379 :
2380 0 : if( aName == SdDrawPage::getPageApiName( pPage ) )
2381 0 : return sal_True;
2382 : }
2383 :
2384 0 : return sal_False;
2385 : }
2386 :
2387 : // XElementAccess
2388 0 : uno::Type SAL_CALL SdDrawPagesAccess::getElementType()
2389 : throw(uno::RuntimeException)
2390 : {
2391 0 : return ITYPE( drawing::XDrawPage );
2392 : }
2393 :
2394 0 : sal_Bool SAL_CALL SdDrawPagesAccess::hasElements()
2395 : throw(uno::RuntimeException)
2396 : {
2397 0 : return getCount() > 0;
2398 : }
2399 :
2400 : // XDrawPages
2401 :
2402 : /******************************************************************************
2403 : * Erzeugt eine neue Seite mit Model an der angegebennen Position und gibt die *
2404 : * dazugehoerige SdDrawPage zurueck. *
2405 : ******************************************************************************/
2406 7 : uno::Reference< drawing::XDrawPage > SAL_CALL SdDrawPagesAccess::insertNewByIndex( sal_Int32 nIndex )
2407 : throw(uno::RuntimeException)
2408 : {
2409 7 : ::SolarMutexGuard aGuard;
2410 :
2411 7 : if( NULL == mpModel )
2412 0 : throw lang::DisposedException();
2413 :
2414 7 : if( mpModel->mpDoc )
2415 : {
2416 7 : SdPage* pPage = mpModel->InsertSdPage( (sal_uInt16)nIndex );
2417 7 : if( pPage )
2418 : {
2419 7 : uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
2420 7 : return xDrawPage;
2421 : }
2422 : }
2423 0 : uno::Reference< drawing::XDrawPage > xDrawPage;
2424 0 : return xDrawPage;
2425 : }
2426 :
2427 : /******************************************************************************
2428 : * Entfernt die angegebenne SdDrawPage aus dem Model und aus der internen *
2429 : * Liste. Dies funktioniert nur, wenn mindestens eine *normale* Seite im Model *
2430 : * nach dem entfernen dieser Seite vorhanden ist. *
2431 : ******************************************************************************/
2432 0 : void SAL_CALL SdDrawPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
2433 : throw(uno::RuntimeException)
2434 : {
2435 0 : ::SolarMutexGuard aGuard;
2436 :
2437 0 : if( NULL == mpModel || mpModel->mpDoc == NULL )
2438 0 : throw lang::DisposedException();
2439 :
2440 0 : SdDrawDocument& rDoc = *mpModel->mpDoc;
2441 :
2442 0 : sal_uInt16 nPageCount = rDoc.GetSdPageCount( PK_STANDARD );
2443 0 : if( nPageCount > 1 )
2444 : {
2445 : // pPage von xPage besorgen und dann die Id (nPos )ermitteln
2446 0 : SdDrawPage* pSvxPage = SdDrawPage::getImplementation( xPage );
2447 0 : if( pSvxPage )
2448 : {
2449 0 : SdPage* pPage = (SdPage*) pSvxPage->GetSdrPage();
2450 0 : if(pPage && ( pPage->GetPageKind() == PK_STANDARD ) )
2451 : {
2452 0 : sal_uInt16 nPage = pPage->GetPageNum();
2453 :
2454 0 : SdPage* pNotesPage = static_cast< SdPage* >( rDoc.GetPage( nPage+1 ) );
2455 :
2456 0 : bool bUndo = rDoc.IsUndoEnabled();
2457 0 : if( bUndo )
2458 : {
2459 : // Add undo actions and delete the pages. The order of adding
2460 : // the undo actions is important.
2461 0 : rDoc.BegUndo( SdResId( STR_UNDO_DELETEPAGES ) );
2462 0 : rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
2463 0 : rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
2464 : }
2465 :
2466 0 : rDoc.RemovePage( nPage ); // the page
2467 0 : rDoc.RemovePage( nPage ); // the notes page
2468 :
2469 0 : if( bUndo )
2470 : {
2471 0 : rDoc.EndUndo();
2472 : }
2473 : else
2474 : {
2475 0 : delete pNotesPage;
2476 0 : delete pPage;
2477 : }
2478 : }
2479 : }
2480 : }
2481 :
2482 0 : mpModel->SetModified();
2483 0 : }
2484 :
2485 : // XServiceInfo
2486 : const char pSdDrawPagesAccessService[] = "com.sun.star.drawing.DrawPages";
2487 :
2488 0 : OUString SAL_CALL SdDrawPagesAccess::getImplementationName( ) throw(uno::RuntimeException)
2489 : {
2490 0 : return OUString( "SdDrawPagesAccess" );
2491 : }
2492 :
2493 0 : sal_Bool SAL_CALL SdDrawPagesAccess::supportsService( const OUString& ServiceName ) throw(uno::RuntimeException)
2494 : {
2495 0 : return ServiceName == pSdDrawPagesAccessService;
2496 : }
2497 :
2498 0 : uno::Sequence< OUString > SAL_CALL SdDrawPagesAccess::getSupportedServiceNames( ) throw(uno::RuntimeException)
2499 : {
2500 0 : OUString aService( pSdDrawPagesAccessService );
2501 0 : uno::Sequence< OUString > aSeq( &aService, 1 );
2502 0 : return aSeq;
2503 : }
2504 :
2505 : // XComponent
2506 2 : void SAL_CALL SdDrawPagesAccess::dispose( ) throw (uno::RuntimeException)
2507 : {
2508 2 : mpModel = NULL;
2509 2 : }
2510 :
2511 0 : void SAL_CALL SdDrawPagesAccess::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
2512 : {
2513 : OSL_FAIL( "not implemented!" );
2514 0 : }
2515 :
2516 0 : void SAL_CALL SdDrawPagesAccess::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
2517 : {
2518 : OSL_FAIL( "not implemented!" );
2519 0 : }
2520 :
2521 : //=============================================================================
2522 : // class SdMasterPagesAccess
2523 : //=============================================================================
2524 :
2525 12 : SdMasterPagesAccess::SdMasterPagesAccess( SdXImpressDocument& rMyModel ) throw()
2526 12 : : mpModel(&rMyModel)
2527 : {
2528 12 : }
2529 :
2530 24 : SdMasterPagesAccess::~SdMasterPagesAccess() throw()
2531 : {
2532 24 : }
2533 :
2534 : // XComponent
2535 0 : void SAL_CALL SdMasterPagesAccess::dispose( ) throw (uno::RuntimeException)
2536 : {
2537 0 : mpModel = NULL;
2538 0 : }
2539 :
2540 0 : void SAL_CALL SdMasterPagesAccess::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
2541 : {
2542 : OSL_FAIL( "not implemented!" );
2543 0 : }
2544 :
2545 0 : void SAL_CALL SdMasterPagesAccess::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
2546 : {
2547 : OSL_FAIL( "not implemented!" );
2548 0 : }
2549 :
2550 : // XIndexAccess
2551 11 : sal_Int32 SAL_CALL SdMasterPagesAccess::getCount()
2552 : throw(uno::RuntimeException)
2553 : {
2554 11 : ::SolarMutexGuard aGuard;
2555 :
2556 11 : if( NULL == mpModel->mpDoc )
2557 0 : throw lang::DisposedException();
2558 :
2559 11 : return mpModel->mpDoc->GetMasterSdPageCount(PK_STANDARD);
2560 : }
2561 :
2562 : /******************************************************************************
2563 : * Liefert ein drawing::XDrawPage Interface fuer den Zugriff auf die Masterpage and der *
2564 : * angegebennen Position im Model. *
2565 : ******************************************************************************/
2566 15 : uno::Any SAL_CALL SdMasterPagesAccess::getByIndex( sal_Int32 Index )
2567 : throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
2568 : {
2569 15 : ::SolarMutexGuard aGuard;
2570 :
2571 15 : if( NULL == mpModel )
2572 0 : throw lang::DisposedException();
2573 :
2574 15 : uno::Any aAny;
2575 :
2576 15 : if( (Index < 0) || (Index >= mpModel->mpDoc->GetMasterSdPageCount( PK_STANDARD ) ) )
2577 0 : throw lang::IndexOutOfBoundsException();
2578 :
2579 15 : SdPage* pPage = mpModel->mpDoc->GetMasterSdPage( (sal_uInt16)Index, PK_STANDARD );
2580 15 : if( pPage )
2581 : {
2582 15 : uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
2583 15 : aAny <<= xDrawPage;
2584 : }
2585 :
2586 15 : return aAny;
2587 : }
2588 :
2589 : // XElementAccess
2590 0 : uno::Type SAL_CALL SdMasterPagesAccess::getElementType()
2591 : throw(uno::RuntimeException)
2592 : {
2593 0 : return ITYPE(drawing::XDrawPage);
2594 : }
2595 :
2596 0 : sal_Bool SAL_CALL SdMasterPagesAccess::hasElements()
2597 : throw(uno::RuntimeException)
2598 : {
2599 0 : return getCount() > 0;
2600 : }
2601 :
2602 : // XDrawPages
2603 0 : uno::Reference< drawing::XDrawPage > SAL_CALL SdMasterPagesAccess::insertNewByIndex( sal_Int32 nInsertPos )
2604 : throw(uno::RuntimeException)
2605 : {
2606 0 : ::SolarMutexGuard aGuard;
2607 :
2608 0 : if( NULL == mpModel )
2609 0 : throw lang::DisposedException();
2610 :
2611 0 : uno::Reference< drawing::XDrawPage > xDrawPage;
2612 :
2613 0 : SdDrawDocument* mpDoc = mpModel->mpDoc;
2614 0 : if( mpDoc )
2615 : {
2616 : // calculate internal index and check for range errors
2617 0 : const sal_Int32 nMPageCount = mpDoc->GetMasterPageCount();
2618 0 : nInsertPos = nInsertPos * 2 + 1;
2619 0 : if( nInsertPos < 0 || nInsertPos > nMPageCount )
2620 0 : nInsertPos = nMPageCount;
2621 :
2622 : // now generate a unique name for the new masterpage
2623 0 : const String aStdPrefix( SdResId(STR_LAYOUT_DEFAULT_NAME) );
2624 0 : String aPrefix( aStdPrefix );
2625 :
2626 0 : sal_Bool bUnique = sal_True;
2627 0 : sal_Int32 i = 0;
2628 0 : do
2629 : {
2630 0 : bUnique = sal_True;
2631 0 : for( sal_Int32 nMaster = 1; nMaster < nMPageCount; nMaster++ )
2632 : {
2633 0 : SdPage* pPage = (SdPage*)mpDoc->GetMasterPage((sal_uInt16)nMaster);
2634 0 : if( pPage && pPage->GetName() == aPrefix )
2635 : {
2636 0 : bUnique = sal_False;
2637 0 : break;
2638 : }
2639 : }
2640 :
2641 0 : if( !bUnique )
2642 : {
2643 0 : i++;
2644 0 : aPrefix = aStdPrefix;
2645 0 : aPrefix += sal_Unicode( ' ' );
2646 0 : aPrefix += String::CreateFromInt32( i );
2647 : }
2648 :
2649 0 : } while( !bUnique );
2650 :
2651 0 : String aLayoutName( aPrefix );
2652 0 : aLayoutName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR ));
2653 0 : aLayoutName += String(SdResId(STR_LAYOUT_OUTLINE));
2654 :
2655 : // create styles
2656 0 : ((SdStyleSheetPool*)mpDoc->GetStyleSheetPool())->CreateLayoutStyleSheets( aPrefix );
2657 :
2658 : // get the first page for initial size and border settings
2659 0 : SdPage* pPage = mpModel->mpDoc->GetSdPage( (sal_uInt16)0, PK_STANDARD );
2660 0 : SdPage* pRefNotesPage = mpModel->mpDoc->GetSdPage( (sal_uInt16)0, PK_NOTES);
2661 :
2662 : // create and instert new draw masterpage
2663 0 : SdPage* pMPage = (SdPage*)mpModel->mpDoc->AllocPage(sal_True);
2664 0 : pMPage->SetSize( pPage->GetSize() );
2665 0 : pMPage->SetBorder( pPage->GetLftBorder(),
2666 0 : pPage->GetUppBorder(),
2667 0 : pPage->GetRgtBorder(),
2668 0 : pPage->GetLwrBorder() );
2669 0 : pMPage->SetLayoutName( aLayoutName );
2670 0 : mpDoc->InsertMasterPage(pMPage, (sal_uInt16)nInsertPos);
2671 :
2672 : {
2673 : // ensure default MasterPage fill
2674 0 : pMPage->EnsureMasterPageDefaultBackground();
2675 : }
2676 :
2677 0 : xDrawPage = uno::Reference< drawing::XDrawPage >::query( pMPage->getUnoPage() );
2678 :
2679 : // create and instert new notes masterpage
2680 0 : SdPage* pMNotesPage = (SdPage*)mpModel->mpDoc->AllocPage(sal_True);
2681 0 : pMNotesPage->SetSize( pRefNotesPage->GetSize() );
2682 0 : pMNotesPage->SetPageKind(PK_NOTES);
2683 0 : pMNotesPage->SetBorder( pRefNotesPage->GetLftBorder(),
2684 0 : pRefNotesPage->GetUppBorder(),
2685 0 : pRefNotesPage->GetRgtBorder(),
2686 0 : pRefNotesPage->GetLwrBorder() );
2687 0 : pMNotesPage->SetLayoutName( aLayoutName );
2688 0 : mpDoc->InsertMasterPage(pMNotesPage, (sal_uInt16)nInsertPos + 1);
2689 0 : pMNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, sal_True, sal_True);
2690 0 : mpModel->SetModified();
2691 : }
2692 :
2693 0 : return( xDrawPage );
2694 : }
2695 :
2696 : /******************************************************************************
2697 : * Entfernt die angegebenne SdMasterPage aus dem Model und aus der internen *
2698 : * Liste. Dies funktioniert nur, wenn keine *normale* Seite im Model diese *
2699 : * Seite als Masterpage benutzt. *
2700 : ******************************************************************************/
2701 0 : void SAL_CALL SdMasterPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
2702 : throw(uno::RuntimeException)
2703 : {
2704 0 : ::SolarMutexGuard aGuard;
2705 :
2706 0 : if( NULL == mpModel || mpModel->mpDoc == NULL )
2707 0 : throw lang::DisposedException();
2708 :
2709 0 : SdDrawDocument& rDoc = *mpModel->mpDoc;
2710 :
2711 0 : SdMasterPage* pSdPage = SdMasterPage::getImplementation( xPage );
2712 0 : if(pSdPage == NULL)
2713 : return;
2714 :
2715 0 : SdPage* pPage = dynamic_cast< SdPage* > (pSdPage->GetSdrPage());
2716 :
2717 : DBG_ASSERT( pPage && pPage->IsMasterPage(), "SdMasterPage is not masterpage?");
2718 :
2719 0 : if( !pPage || !pPage->IsMasterPage() || (mpModel->mpDoc->GetMasterPageUserCount(pPage) > 0))
2720 : return; //Todo: this should be excepted
2721 :
2722 : // only standard pages can be removed directly
2723 0 : if( pPage->GetPageKind() == PK_STANDARD )
2724 : {
2725 0 : sal_uInt16 nPage = pPage->GetPageNum();
2726 :
2727 0 : SdPage* pNotesPage = static_cast< SdPage* >( rDoc.GetMasterPage( nPage+1 ) );
2728 :
2729 0 : bool bUndo = rDoc.IsUndoEnabled();
2730 0 : if( bUndo )
2731 : {
2732 : // Add undo actions and delete the pages. The order of adding
2733 : // the undo actions is important.
2734 0 : rDoc.BegUndo( SdResId( STR_UNDO_DELETEPAGES ) );
2735 0 : rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
2736 0 : rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
2737 : }
2738 :
2739 0 : rDoc.RemoveMasterPage( nPage );
2740 0 : rDoc.RemoveMasterPage( nPage );
2741 :
2742 0 : if( bUndo )
2743 : {
2744 0 : rDoc.EndUndo();
2745 : }
2746 : else
2747 : {
2748 0 : delete pNotesPage;
2749 0 : delete pPage;
2750 : }
2751 0 : }
2752 : }
2753 :
2754 : // XServiceInfo
2755 : const char pSdMasterPagesAccessService[] = "com.sun.star.drawing.MasterPages";
2756 :
2757 0 : OUString SAL_CALL SdMasterPagesAccess::getImplementationName( ) throw(uno::RuntimeException)
2758 : {
2759 0 : return OUString( "SdMasterPagesAccess" );
2760 : }
2761 :
2762 0 : sal_Bool SAL_CALL SdMasterPagesAccess::supportsService( const OUString& ServiceName ) throw(uno::RuntimeException)
2763 : {
2764 0 : return ServiceName == pSdMasterPagesAccessService;
2765 : }
2766 :
2767 0 : uno::Sequence< OUString > SAL_CALL SdMasterPagesAccess::getSupportedServiceNames( ) throw(uno::RuntimeException)
2768 : {
2769 0 : OUString aService( pSdMasterPagesAccessService );
2770 0 : uno::Sequence< OUString > aSeq( &aService, 1 );
2771 0 : return aSeq;
2772 : }
2773 :
2774 : //=============================================================================
2775 : // class SdDocLinkTargets
2776 : //=============================================================================
2777 :
2778 0 : SdDocLinkTargets::SdDocLinkTargets( SdXImpressDocument& rMyModel ) throw()
2779 0 : : mpModel( &rMyModel )
2780 : {
2781 0 : }
2782 :
2783 0 : SdDocLinkTargets::~SdDocLinkTargets() throw()
2784 : {
2785 0 : }
2786 :
2787 : // XComponent
2788 0 : void SAL_CALL SdDocLinkTargets::dispose( ) throw (uno::RuntimeException)
2789 : {
2790 0 : mpModel = NULL;
2791 0 : }
2792 :
2793 0 : void SAL_CALL SdDocLinkTargets::addEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
2794 : {
2795 : OSL_FAIL( "not implemented!" );
2796 0 : }
2797 :
2798 0 : void SAL_CALL SdDocLinkTargets::removeEventListener( const uno::Reference< lang::XEventListener >& ) throw (uno::RuntimeException)
2799 : {
2800 : OSL_FAIL( "not implemented!" );
2801 0 : }
2802 :
2803 : // XNameAccess
2804 0 : uno::Any SAL_CALL SdDocLinkTargets::getByName( const OUString& aName )
2805 : throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
2806 : {
2807 0 : ::SolarMutexGuard aGuard;
2808 :
2809 0 : if( NULL == mpModel )
2810 0 : throw lang::DisposedException();
2811 :
2812 0 : SdPage* pPage = FindPage( aName );
2813 :
2814 0 : if( pPage == NULL )
2815 0 : throw container::NoSuchElementException();
2816 :
2817 0 : uno::Any aAny;
2818 :
2819 0 : uno::Reference< beans::XPropertySet > xProps( pPage->getUnoPage(), uno::UNO_QUERY );
2820 0 : if( xProps.is() )
2821 0 : aAny <<= xProps;
2822 :
2823 0 : return aAny;
2824 : }
2825 :
2826 0 : uno::Sequence< OUString > SAL_CALL SdDocLinkTargets::getElementNames()
2827 : throw(uno::RuntimeException)
2828 : {
2829 0 : ::SolarMutexGuard aGuard;
2830 :
2831 0 : if( NULL == mpModel )
2832 0 : throw lang::DisposedException();
2833 :
2834 0 : SdDrawDocument* mpDoc = mpModel->GetDoc();
2835 0 : if( mpDoc == NULL )
2836 : {
2837 0 : uno::Sequence< OUString > aSeq;
2838 0 : return aSeq;
2839 : }
2840 :
2841 0 : if( mpDoc->GetDocumentType() == DOCUMENT_TYPE_DRAW )
2842 : {
2843 0 : const sal_uInt16 nMaxPages = mpDoc->GetSdPageCount( PK_STANDARD );
2844 0 : const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterSdPageCount( PK_STANDARD );
2845 :
2846 0 : uno::Sequence< OUString > aSeq( nMaxPages + nMaxMasterPages );
2847 0 : OUString* pStr = aSeq.getArray();
2848 :
2849 : sal_uInt16 nPage;
2850 : // standard pages
2851 0 : for( nPage = 0; nPage < nMaxPages; nPage++ )
2852 0 : *pStr++ = mpDoc->GetSdPage( nPage, PK_STANDARD )->GetName();
2853 :
2854 : // master pages
2855 0 : for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
2856 0 : *pStr++ = mpDoc->GetMasterSdPage( nPage, PK_STANDARD )->GetName();
2857 0 : return aSeq;
2858 : }
2859 : else
2860 : {
2861 0 : const sal_uInt16 nMaxPages = mpDoc->GetPageCount();
2862 0 : const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterPageCount();
2863 :
2864 0 : uno::Sequence< OUString > aSeq( nMaxPages + nMaxMasterPages );
2865 0 : OUString* pStr = aSeq.getArray();
2866 :
2867 : sal_uInt16 nPage;
2868 : // standard pages
2869 0 : for( nPage = 0; nPage < nMaxPages; nPage++ )
2870 0 : *pStr++ = ((SdPage*)mpDoc->GetPage( nPage ))->GetName();
2871 :
2872 : // master pages
2873 0 : for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
2874 0 : *pStr++ = ((SdPage*)mpDoc->GetMasterPage( nPage ))->GetName();
2875 0 : return aSeq;
2876 0 : }
2877 : }
2878 :
2879 0 : sal_Bool SAL_CALL SdDocLinkTargets::hasByName( const OUString& aName )
2880 : throw(uno::RuntimeException)
2881 : {
2882 0 : ::SolarMutexGuard aGuard;
2883 :
2884 0 : if( NULL == mpModel )
2885 0 : throw lang::DisposedException();
2886 :
2887 0 : return FindPage( aName ) != NULL;
2888 : }
2889 :
2890 : // container::XElementAccess
2891 0 : uno::Type SAL_CALL SdDocLinkTargets::getElementType()
2892 : throw(uno::RuntimeException)
2893 : {
2894 0 : return ITYPE(beans::XPropertySet);
2895 : }
2896 :
2897 0 : sal_Bool SAL_CALL SdDocLinkTargets::hasElements()
2898 : throw(uno::RuntimeException)
2899 : {
2900 0 : ::SolarMutexGuard aGuard;
2901 :
2902 0 : if( NULL == mpModel )
2903 0 : throw lang::DisposedException();
2904 :
2905 0 : return mpModel->GetDoc() != NULL;
2906 : }
2907 :
2908 0 : SdPage* SdDocLinkTargets::FindPage( const OUString& rName ) const throw()
2909 : {
2910 0 : SdDrawDocument* mpDoc = mpModel->GetDoc();
2911 0 : if( mpDoc == NULL )
2912 0 : return NULL;
2913 :
2914 0 : const sal_uInt16 nMaxPages = mpDoc->GetPageCount();
2915 0 : const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterPageCount();
2916 :
2917 : sal_uInt16 nPage;
2918 : SdPage* pPage;
2919 :
2920 0 : const String aName( rName );
2921 :
2922 0 : const bool bDraw = mpDoc->GetDocumentType() == DOCUMENT_TYPE_DRAW;
2923 :
2924 : // standard pages
2925 0 : for( nPage = 0; nPage < nMaxPages; nPage++ )
2926 : {
2927 0 : pPage = (SdPage*)mpDoc->GetPage( nPage );
2928 0 : if( (pPage->GetName() == aName) && (!bDraw || (pPage->GetPageKind() == PK_STANDARD)) )
2929 0 : return pPage;
2930 : }
2931 :
2932 : // master pages
2933 0 : for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
2934 : {
2935 0 : pPage = (SdPage*)mpDoc->GetMasterPage( nPage );
2936 0 : if( (pPage->GetName() == aName) && (!bDraw || (pPage->GetPageKind() == PK_STANDARD)) )
2937 0 : return pPage;
2938 : }
2939 :
2940 0 : return NULL;
2941 : }
2942 :
2943 : // XServiceInfo
2944 0 : OUString SAL_CALL SdDocLinkTargets::getImplementationName()
2945 : throw(uno::RuntimeException)
2946 : {
2947 0 : return OUString( "SdDocLinkTargets" );
2948 : }
2949 :
2950 0 : sal_Bool SAL_CALL SdDocLinkTargets::supportsService( const OUString& ServiceName )
2951 : throw(uno::RuntimeException)
2952 : {
2953 0 : return comphelper::ServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
2954 : }
2955 :
2956 0 : uno::Sequence< OUString > SAL_CALL SdDocLinkTargets::getSupportedServiceNames()
2957 : throw(uno::RuntimeException)
2958 : {
2959 0 : const OUString aSN( "com.sun.star.document.LinkTargets" );
2960 0 : uno::Sequence< OUString > aSeq( &aSN, 1 );
2961 0 : return aSeq;
2962 : }
2963 :
2964 0 : rtl::Reference< SdXImpressDocument > SdXImpressDocument::GetModel( SdDrawDocument* pDocument )
2965 : {
2966 0 : rtl::Reference< SdXImpressDocument > xRet;
2967 0 : if( pDocument )
2968 : {
2969 0 : ::sd::DrawDocShell* pDocShell = pDocument->GetDocSh();
2970 0 : if( pDocShell )
2971 : {
2972 0 : uno::Reference<frame::XModel> xModel(pDocShell->GetModel());
2973 :
2974 0 : xRet.set( dynamic_cast< SdXImpressDocument* >( xModel.get() ) );
2975 : }
2976 : }
2977 :
2978 0 : return xRet;
2979 : }
2980 :
2981 0 : void NotifyDocumentEvent( SdDrawDocument* pDocument, const rtl::OUString& rEventName )
2982 : {
2983 0 : rtl::Reference< SdXImpressDocument > xModel( SdXImpressDocument::GetModel( pDocument ) );
2984 :
2985 0 : if( xModel.is() )
2986 : {
2987 0 : uno::Reference< uno::XInterface > xSource( static_cast<uno::XWeak*>( xModel.get() ) );
2988 0 : ::com::sun::star::document::EventObject aEvent( xSource, rEventName );
2989 0 : xModel->notifyEvent(aEvent );
2990 0 : }
2991 0 : }
2992 :
2993 0 : void NotifyDocumentEvent( SdDrawDocument* pDocument, const rtl::OUString& rEventName, const uno::Reference< uno::XInterface >& xSource )
2994 : {
2995 0 : rtl::Reference< SdXImpressDocument > xModel( SdXImpressDocument::GetModel( pDocument ) );
2996 :
2997 0 : if( xModel.is() )
2998 : {
2999 0 : ::com::sun::star::document::EventObject aEvent( xSource, rEventName );
3000 0 : xModel->notifyEvent(aEvent );
3001 0 : }
3002 0 : }
3003 :
3004 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
