?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 6.3.0.0.beta1
[LibreOffice.git] / sd / source / ui / unoidl / unomodel.cxx
blob10941c629d07893163842d04e8e6833edb663ea5
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <memory>
21 #include <boost/property_tree/json_parser.hpp>
22
23 #include <com/sun/star/presentation/XPresentation2.hpp>
24
25 #include <com/sun/star/lang/DisposedException.hpp>
26 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
27 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
28 #include <com/sun/star/lang/Locale.hpp>
29 #include <com/sun/star/style/XStyle.hpp>
30 #include <com/sun/star/awt/XDevice.hpp>
31 #include <com/sun/star/document/IndexedPropertyValues.hpp>
32 #include <com/sun/star/beans/PropertyAttribute.hpp>
33
34 #include <com/sun/star/embed/Aspects.hpp>
35
36 #include <comphelper/lok.hxx>
37 #include <comphelper/sequence.hxx>
38 #include <comphelper/servicehelper.hxx>
39 #include <cppuhelper/supportsservice.hxx>
40 #include <comphelper/processfactory.hxx>
41 #include <comphelper/profilezone.hxx>
42
43 #include <sal/log.hxx>
44 #include <editeng/unofield.hxx>
45 #include <notifydocumentevent.hxx>
46 #include <unomodel.hxx>
47 #include "unopool.hxx"
48 #include <sfx2/dispatch.hxx>
49 #include <sfx2/bindings.hxx>
50 #include <sfx2/lokhelper.hxx>
51 #include <vcl/commandevent.hxx>
52 #include <vcl/svapp.hxx>
53 #include <vcl/settings.hxx>
54 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
55
56 #include <editeng/UnoForbiddenCharsTable.hxx>
57 #include <svx/svdoutl.hxx>
58 #include <editeng/forbiddencharacterstable.hxx>
59 #include <o3tl/safeint.hxx>
60 #include <svx/UnoNamespaceMap.hxx>
61 #include <svx/svdlayer.hxx>
62 #include <svx/svdsob.hxx>
63 #include <svx/svdundo.hxx>
64 #include <svx/unoapi.hxx>
65 #include <svx/unofill.hxx>
66 #include <svx/unopool.hxx>
67 #include <svx/svdorect.hxx>
68 #include <editeng/flditem.hxx>
69 #include <editeng/fontitem.hxx>
70 #include <toolkit/awt/vclxdevice.hxx>
71 #include <svx/svdpool.hxx>
72 #include <editeng/unolingu.hxx>
73 #include <svx/svdpagv.hxx>
74 #include <svtools/unoimap.hxx>
75 #include <svx/unoshape.hxx>
76 #include <editeng/unonrule.hxx>
77 #include <editeng/eeitem.hxx>
78 #include <unotools/datetime.hxx>
79 #include <unotools/saveopt.hxx>
80 #include <xmloff/autolayout.hxx>
81
82 // Support creation of GraphicStorageHandler and EmbeddedObjectResolver
83 #include <svx/xmleohlp.hxx>
84 #include <svx/xmlgrhlp.hxx>
85 #include <DrawDocShell.hxx>
86 #include <ViewShellBase.hxx>
87 #include "UnoDocumentSettings.hxx"
88
89 #include <Annotation.hxx>
90 #include <drawdoc.hxx>
91 #include <sdmod.hxx>
92 #include <sdresid.hxx>
93 #include <sdpage.hxx>
94
95 #include <strings.hrc>
96 #include <strings.hxx>
97 #include "unolayer.hxx"
98 #include <unoprnms.hxx>
99 #include <unopage.hxx>
100 #include "unocpres.hxx"
101 #include "unoobj.hxx"
102 #include <stlpool.hxx>
103 #include "unopback.hxx"
104 #include <unokywds.hxx>
105
106 #include <FrameView.hxx>
107 #include <ClientView.hxx>
108 #include <DrawViewShell.hxx>
109 #include <ViewShell.hxx>
110 #include <Window.hxx>
111 #include <app.hrc>
112 #include <optsitem.hxx>
113
114 #include <vcl/pdfextoutdevdata.hxx>
115 #include <com/sun/star/presentation/AnimationSpeed.hpp>
116 #include <com/sun/star/presentation/ClickAction.hpp>
117 #include <svx/sdr/contact/viewobjectcontact.hxx>
118 #include <svx/sdr/contact/viewcontact.hxx>
119 #include <svx/sdr/contact/displayinfo.hxx>
120
121 #include <com/sun/star/office/XAnnotation.hpp>
122 #include <com/sun/star/office/XAnnotationAccess.hpp>
123 #include <com/sun/star/office/XAnnotationEnumeration.hpp>
124 #include <com/sun/star/geometry/RealPoint2D.hpp>
125 #include <com/sun/star/util/DateTime.hpp>
126
127 #include <drawinglayer/primitive2d/structuretagprimitive2d.hxx>
128
129 #include <sfx2/lokcharthelper.hxx>
130 #include <tools/debug.hxx>
131 #include <tools/diagnose_ex.h>
132
133 #define TWIPS_PER_PIXEL 15
134
135 using namespace ::cppu;
136 using namespace ::com::sun::star;
137 using namespace ::sd;
138
139 class SdUnoForbiddenCharsTable : public SvxUnoForbiddenCharsTable,
140 public SfxListener
141 {
142 public:
143 explicit SdUnoForbiddenCharsTable(SdrModel* pModel);
144 virtual ~SdUnoForbiddenCharsTable() override;
145
146 // SfxListener
147 virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) throw () override;
148 protected:
149 virtual void onChange() override;
150
151 private:
152 SdrModel* mpModel;
153 };
154
155 SdUnoForbiddenCharsTable::SdUnoForbiddenCharsTable( SdrModel* pModel )
156 : SvxUnoForbiddenCharsTable( pModel->GetForbiddenCharsTable() ), mpModel( pModel )
157 {
158 StartListening( *pModel );
159 }
160
161 void SdUnoForbiddenCharsTable::onChange()
162 {
163 if( mpModel )
164 {
165 mpModel->ReformatAllTextObjects();
166 }
167 }
168
169 SdUnoForbiddenCharsTable::~SdUnoForbiddenCharsTable()
170 {
171 SolarMutexGuard g;
172
173 if( mpModel )
174 EndListening( *mpModel );
175 }
176
177 void SdUnoForbiddenCharsTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
178 {
179 if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
180 return;
181 const SdrHint* pSdrHint = static_cast<const SdrHint*>( &rHint );
182 if( SdrHintKind::ModelCleared == pSdrHint->GetKind() )
183 {
184 mpModel = nullptr;
185 }
186 }
187
188 const sal_uInt16 WID_MODEL_LANGUAGE = 1;
189 const sal_uInt16 WID_MODEL_TABSTOP = 2;
190 const sal_uInt16 WID_MODEL_VISAREA = 3;
191 const sal_uInt16 WID_MODEL_MAPUNIT = 4;
192 const sal_uInt16 WID_MODEL_FORBCHARS = 5;
193 const sal_uInt16 WID_MODEL_CONTFOCUS = 6;
194 const sal_uInt16 WID_MODEL_DSGNMODE = 7;
195 const sal_uInt16 WID_MODEL_BASICLIBS = 8;
196 const sal_uInt16 WID_MODEL_RUNTIMEUID = 9;
197 const sal_uInt16 WID_MODEL_BUILDID = 10;
198 const sal_uInt16 WID_MODEL_HASVALIDSIGNATURES = 11;
199 const sal_uInt16 WID_MODEL_DIALOGLIBS = 12;
200 const sal_uInt16 WID_MODEL_FONTS = 13;
201 const sal_uInt16 WID_MODEL_INTEROPGRABBAG = 14;
202
203 static const SvxItemPropertySet* ImplGetDrawModelPropertySet()
204 {
205 // Attention: the first parameter HAS TO BE sorted!!!
206 const static SfxItemPropertyMapEntry aDrawModelPropertyMap_Impl[] =
207 {
208 { OUString("BuildId"), WID_MODEL_BUILDID, ::cppu::UnoType<OUString>::get(), 0, 0},
209 { OUString(sUNO_Prop_CharLocale), WID_MODEL_LANGUAGE, ::cppu::UnoType<lang::Locale>::get(), 0, 0},
210 { OUString(sUNO_Prop_TabStop), WID_MODEL_TABSTOP, ::cppu::UnoType<sal_Int32>::get(), 0, 0},
211 { OUString(sUNO_Prop_VisibleArea), WID_MODEL_VISAREA, ::cppu::UnoType<awt::Rectangle>::get(), 0, 0},
212 { OUString(sUNO_Prop_MapUnit), WID_MODEL_MAPUNIT, ::cppu::UnoType<sal_Int16>::get(), beans::PropertyAttribute::READONLY, 0},
213 { OUString(sUNO_Prop_ForbiddenCharacters), WID_MODEL_FORBCHARS, cppu::UnoType<i18n::XForbiddenCharacters>::get(), beans::PropertyAttribute::READONLY, 0},
214 { OUString(sUNO_Prop_AutomContFocus), WID_MODEL_CONTFOCUS, cppu::UnoType<bool>::get(), 0, 0},
215 { OUString(sUNO_Prop_ApplyFrmDsgnMode), WID_MODEL_DSGNMODE, cppu::UnoType<bool>::get(), 0, 0},
216 { OUString("BasicLibraries"), WID_MODEL_BASICLIBS, cppu::UnoType<script::XLibraryContainer>::get(), beans::PropertyAttribute::READONLY, 0},
217 { OUString("DialogLibraries"), WID_MODEL_DIALOGLIBS, cppu::UnoType<script::XLibraryContainer>::get(), beans::PropertyAttribute::READONLY, 0},
218 { OUString(sUNO_Prop_RuntimeUID), WID_MODEL_RUNTIMEUID, ::cppu::UnoType<OUString>::get(), beans::PropertyAttribute::READONLY, 0},
219 { OUString(sUNO_Prop_HasValidSignatures), WID_MODEL_HASVALIDSIGNATURES, ::cppu::UnoType<sal_Bool>::get(), beans::PropertyAttribute::READONLY, 0},
220 { OUString("Fonts"), WID_MODEL_FONTS, cppu::UnoType<uno::Sequence<uno::Any>>::get(), beans::PropertyAttribute::READONLY, 0},
221 { OUString(sUNO_Prop_InteropGrabBag), WID_MODEL_INTEROPGRABBAG, cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get(), 0, 0},
222 { OUString(), 0, css::uno::Type(), 0, 0 }
223 };
224 static SvxItemPropertySet aDrawModelPropertySet_Impl( aDrawModelPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
225 return &aDrawModelPropertySet_Impl;
226 }
227
228 // this ctor is used from the DocShell
229 SdXImpressDocument::SdXImpressDocument(::sd::DrawDocShell* pShell, bool bClipBoard)
230 : SfxBaseModel( pShell ),
231 mpDocShell( pShell ),
232 mpDoc( pShell ? pShell->GetDoc() : nullptr ),
233 mbDisposed(false),
234 mbImpressDoc( pShell && pShell->GetDoc() && pShell->GetDoc()->GetDocumentType() == DocumentType::Impress ),
235 mbClipBoard( bClipBoard ),
236 mpPropSet( ImplGetDrawModelPropertySet() )
237 {
238 if( mpDoc )
239 {
240 StartListening( *mpDoc );
241 }
242 else
243 {
244 OSL_FAIL("DocShell is invalid");
245 }
246 }
247
248 SdXImpressDocument::SdXImpressDocument(SdDrawDocument* pDoc, bool bClipBoard)
249 : SfxBaseModel( nullptr ),
250 mpDocShell( nullptr ),
251 mpDoc( pDoc ),
252 mbDisposed(false),
253 mbImpressDoc( pDoc && pDoc->GetDocumentType() == DocumentType::Impress ),
254 mbClipBoard( bClipBoard ),
255 mpPropSet( ImplGetDrawModelPropertySet() )
256 {
257 if( mpDoc )
258 {
259 StartListening( *mpDoc );
260 }
261 else
262 {
263 OSL_FAIL("SdDrawDocument is invalid");
264 }
265 }
266
267 /***********************************************************************
268 * *
269 ***********************************************************************/
270 SdXImpressDocument::~SdXImpressDocument() throw()
271 {
272 }
273
274 // XInterface
275 uno::Any SAL_CALL SdXImpressDocument::queryInterface( const uno::Type & rType )
276 {
277 uno::Any aAny;
278
279 if (rType == cppu::UnoType<lang::XServiceInfo>::get())
280 aAny <<= uno::Reference<lang::XServiceInfo>(this);
281 else if (rType == cppu::UnoType<beans::XPropertySet>::get())
282 aAny <<= uno::Reference<beans::XPropertySet>(this);
283 else if (rType == cppu::UnoType<lang::XMultiServiceFactory>::get())
284 aAny <<= uno::Reference<lang::XMultiServiceFactory>(this);
285 else if (rType == cppu::UnoType<drawing::XDrawPageDuplicator>::get())
286 aAny <<= uno::Reference<drawing::XDrawPageDuplicator>(this);
287 else if (rType == cppu::UnoType<drawing::XLayerSupplier>::get())
288 aAny <<= uno::Reference<drawing::XLayerSupplier>(this);
289 else if (rType == cppu::UnoType<drawing::XMasterPagesSupplier>::get())
290 aAny <<= uno::Reference<drawing::XMasterPagesSupplier>(this);
291 else if (rType == cppu::UnoType<drawing::XDrawPagesSupplier>::get())
292 aAny <<= uno::Reference<drawing::XDrawPagesSupplier>(this);
293 else if (rType == cppu::UnoType<presentation::XHandoutMasterSupplier>::get())
294 aAny <<= uno::Reference<presentation::XHandoutMasterSupplier>(this);
295 else if (rType == cppu::UnoType<document::XLinkTargetSupplier>::get())
296 aAny <<= uno::Reference<document::XLinkTargetSupplier>(this);
297 else if (rType == cppu::UnoType<style::XStyleFamiliesSupplier>::get())
298 aAny <<= uno::Reference<style::XStyleFamiliesSupplier>(this);
299 else if (rType == cppu::UnoType<css::ucb::XAnyCompareFactory>::get())
300 aAny <<= uno::Reference<css::ucb::XAnyCompareFactory>(this);
301 else if (rType == cppu::UnoType<view::XRenderable>::get())
302 aAny <<= uno::Reference<view::XRenderable>(this);
303 else if (mbImpressDoc && rType == cppu::UnoType<presentation::XPresentationSupplier>::get())
304 aAny <<= uno::Reference< presentation::XPresentationSupplier >(this);
305 else if (mbImpressDoc && rType == cppu::UnoType<presentation::XCustomPresentationSupplier>::get())
306 aAny <<= uno::Reference< presentation::XCustomPresentationSupplier >(this);
307 else
308 return SfxBaseModel::queryInterface(rType);
309
310 return aAny;
311 }
312
313 void SAL_CALL SdXImpressDocument::acquire() throw ( )
314 {
315 SfxBaseModel::acquire();
316 }
317
318 void SAL_CALL SdXImpressDocument::release() throw ( )
319 {
320 if (osl_atomic_decrement( &m_refCount ) != 0)
321 return;
322
323 // restore reference count:
324 osl_atomic_increment( &m_refCount );
325 if(!mbDisposed)
326 {
327 try
328 {
329 dispose();
330 }
331 catch (const uno::RuntimeException&)
332 { // don't break throw ()
333 css::uno::Any ex( cppu::getCaughtException() );
334 SAL_WARN( "sd", exceptionToString(ex) );
335 }
336 }
337 SfxBaseModel::release();
338 }
339
340 namespace
341 {
342 class theSdXImpressDocumentUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSdXImpressDocumentUnoTunnelId> {};
343 }
344
345 // XUnoTunnel
346 const css::uno::Sequence< sal_Int8 > & SdXImpressDocument::getUnoTunnelId() throw()
347 {
348 return theSdXImpressDocumentUnoTunnelId::get().getSeq();
349 }
350
351 SdXImpressDocument* SdXImpressDocument::getImplementation( const uno::Reference< uno::XInterface >& xInt )
352 {
353 css::uno::Reference< css::lang::XUnoTunnel > xUT( xInt, uno::UNO_QUERY );
354 if( xUT.is() )
355 return reinterpret_cast<SdXImpressDocument*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething( SdXImpressDocument::getUnoTunnelId() )));
356 else
357 return nullptr;
358 }
359
360 sal_Int64 SAL_CALL SdXImpressDocument::getSomething( const css::uno::Sequence< sal_Int8 >& rIdentifier )
361 {
362 if( rIdentifier.getLength() == 16 )
363 {
364 if( 0 == memcmp( SdXImpressDocument::getUnoTunnelId().getConstArray(), rIdentifier.getConstArray(), 16 ) )
365 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
366
367 if( 0 == memcmp( SdrModel::getUnoTunnelImplementationId().getConstArray(), rIdentifier.getConstArray(), 16 ) )
368 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(mpDoc));
369 }
370
371 return SfxBaseModel::getSomething( rIdentifier );
372 }
373
374 // XTypeProvider
375 uno::Sequence< uno::Type > SAL_CALL SdXImpressDocument::getTypes( )
376 {
377 ::SolarMutexGuard aGuard;
378
379 if( maTypeSequence.getLength() == 0 )
380 {
381 uno::Sequence< uno::Type > aTypes( SfxBaseModel::getTypes() );
382 aTypes = comphelper::concatSequences(aTypes,
383 uno::Sequence {
384 cppu::UnoType<beans::XPropertySet>::get(),
385 cppu::UnoType<lang::XServiceInfo>::get(),
386 cppu::UnoType<lang::XMultiServiceFactory>::get(),
387 cppu::UnoType<drawing::XDrawPageDuplicator>::get(),
388 cppu::UnoType<drawing::XLayerSupplier>::get(),
389 cppu::UnoType<drawing::XMasterPagesSupplier>::get(),
390 cppu::UnoType<drawing::XDrawPagesSupplier>::get(),
391 cppu::UnoType<document::XLinkTargetSupplier>::get(),
392 cppu::UnoType<style::XStyleFamiliesSupplier>::get(),
393 cppu::UnoType<css::ucb::XAnyCompareFactory>::get(),
394 cppu::UnoType<view::XRenderable>::get() });
395 if( mbImpressDoc )
396 {
397 aTypes = comphelper::concatSequences(aTypes,
398 uno::Sequence {
399 cppu::UnoType<presentation::XPresentationSupplier>::get(),
400 cppu::UnoType<presentation::XCustomPresentationSupplier>::get(),
401 cppu::UnoType<presentation::XHandoutMasterSupplier>::get() });
402 }
403 maTypeSequence = aTypes;
404 }
405
406 return maTypeSequence;
407 }
408
409 uno::Sequence< sal_Int8 > SAL_CALL SdXImpressDocument::getImplementationId( )
410 {
411 return css::uno::Sequence<sal_Int8>();
412 }
413
414 /***********************************************************************
415 * *
416 ***********************************************************************/
417 void SdXImpressDocument::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
418 {
419 if( mpDoc )
420 {
421 if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint)
422 {
423 const SdrHint* pSdrHint = static_cast<const SdrHint*>( &rHint );
424 if( hasEventListeners() )
425 {
426 document::EventObject aEvent;
427 if( SvxUnoDrawMSFactory::createEvent( mpDoc, pSdrHint, aEvent ) )
428 notifyEvent( aEvent );
429 }
430
431 if( pSdrHint->GetKind() == SdrHintKind::ModelCleared )
432 {
433 if( mpDoc )
434 EndListening( *mpDoc );
435 mpDoc = nullptr;
436 mpDocShell = nullptr;
437 }
438 }
439 else
440 {
441 // did our SdDrawDocument just died?
442 if(rHint.GetId() == SfxHintId::Dying)
443 {
444 // yes, so we ask for a new one
445 if( mpDocShell )
446 {
447 SdDrawDocument *pNewDoc = mpDocShell->GetDoc();
448
449 // is there a new one?
450 if( pNewDoc != mpDoc )
451 {
452 mpDoc = pNewDoc;
453 if(mpDoc)
454 StartListening( *mpDoc );
455 }
456 }
457 }
458 }
459 }
460 SfxBaseModel::Notify( rBC, rHint );
461 }
462
463 /******************************************************************************
464 * *
465 ******************************************************************************/
466 SdPage* SdXImpressDocument::InsertSdPage( sal_uInt16 nPage, bool bDuplicate )
467 {
468 sal_uInt16 nPageCount = mpDoc->GetSdPageCount( PageKind::Standard );
469 SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin();
470 SdrLayerID aBckgrnd = rLayerAdmin.GetLayerID(sUNO_LayerName_background);
471 SdrLayerID aBckgrndObj = rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects);
472
473 SdPage* pStandardPage = nullptr;
474
475 if( 0 == nPageCount )
476 {
477 // this is only used for clipboard where we only have one page
478 pStandardPage = mpDoc->AllocSdPage(false);
479
480 Size aDefSize(21000, 29700); // A4 portrait orientation
481 pStandardPage->SetSize( aDefSize );
482 mpDoc->InsertPage(pStandardPage, 0);
483 }
484 else
485 {
486 // here we determine the page after which we should insert
487 SdPage* pPreviousStandardPage = mpDoc->GetSdPage( std::min( static_cast<sal_uInt16>(nPageCount - 1), nPage ), PageKind::Standard );
488 SdrLayerIDSet aVisibleLayers = pPreviousStandardPage->TRG_GetMasterPageVisibleLayers();
489 bool bIsPageBack = aVisibleLayers.IsSet( aBckgrnd );
490 bool bIsPageObj = aVisibleLayers.IsSet( aBckgrndObj );
491
492 // AutoLayouts must be ready
493 mpDoc->StopWorkStartupDelay();
494
495 /* First we create a standard page and then a notes page. It is
496 guaranteed, that after a standard page the corresponding notes page
497 follows. */
498
499 sal_uInt16 nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
500 SdPage* pPreviousNotesPage = static_cast<SdPage*>( mpDoc->GetPage( nStandardPageNum - 1 ) );
501 sal_uInt16 nNotesPageNum = nStandardPageNum + 1;
502
503 /**************************************************************
504 * standard page
505 **************************************************************/
506 if( bDuplicate )
507 pStandardPage = static_cast<SdPage*>( pPreviousStandardPage->CloneSdrPage(*mpDoc) );
508 else
509 pStandardPage = mpDoc->AllocSdPage(false);
510
511 pStandardPage->SetSize( pPreviousStandardPage->GetSize() );
512 pStandardPage->SetBorder( pPreviousStandardPage->GetLeftBorder(),
513 pPreviousStandardPage->GetUpperBorder(),
514 pPreviousStandardPage->GetRightBorder(),
515 pPreviousStandardPage->GetLowerBorder() );
516 pStandardPage->SetOrientation( pPreviousStandardPage->GetOrientation() );
517 pStandardPage->SetName(OUString());
518
519 // insert page after current page
520 mpDoc->InsertPage(pStandardPage, nStandardPageNum);
521
522 if( !bDuplicate )
523 {
524 // use MasterPage of the current page
525 pStandardPage->TRG_SetMasterPage(pPreviousStandardPage->TRG_GetMasterPage());
526 pStandardPage->SetLayoutName( pPreviousStandardPage->GetLayoutName() );
527 pStandardPage->SetAutoLayout(AUTOLAYOUT_NONE, true );
528 }
529
530 aBckgrnd = rLayerAdmin.GetLayerID(sUNO_LayerName_background);
531 aBckgrndObj = rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects);
532 aVisibleLayers.Set(aBckgrnd, bIsPageBack);
533 aVisibleLayers.Set(aBckgrndObj, bIsPageObj);
534 pStandardPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
535
536 /**************************************************************
537 * notes page
538 **************************************************************/
539 SdPage* pNotesPage = nullptr;
540
541 if( bDuplicate )
542 pNotesPage = static_cast<SdPage*>( pPreviousNotesPage->CloneSdrPage(*mpDoc) );
543 else
544 pNotesPage = mpDoc->AllocSdPage(false);
545
546 pNotesPage->SetSize( pPreviousNotesPage->GetSize() );
547 pNotesPage->SetBorder( pPreviousNotesPage->GetLeftBorder(),
548 pPreviousNotesPage->GetUpperBorder(),
549 pPreviousNotesPage->GetRightBorder(),
550 pPreviousNotesPage->GetLowerBorder() );
551 pNotesPage->SetOrientation( pPreviousNotesPage->GetOrientation() );
552 pNotesPage->SetName(OUString());
553 pNotesPage->SetPageKind(PageKind::Notes);
554
555 // insert page after current page
556 mpDoc->InsertPage(pNotesPage, nNotesPageNum);
557
558 if( !bDuplicate )
559 {
560 // use MasterPage of the current page
561 pNotesPage->TRG_SetMasterPage(pPreviousNotesPage->TRG_GetMasterPage());
562 pNotesPage->SetLayoutName( pPreviousNotesPage->GetLayoutName() );
563 pNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, true );
564 }
565 }
566
567 SetModified();
568
569 return pStandardPage;
570 }
571
572 void SdXImpressDocument::SetModified() throw()
573 {
574 if( mpDoc )
575 mpDoc->SetChanged();
576 }
577
578 // XModel
579 void SAL_CALL SdXImpressDocument::lockControllers( )
580 {
581 ::SolarMutexGuard aGuard;
582
583 if( nullptr == mpDoc )
584 throw lang::DisposedException();
585
586 mpDoc->setLock(true);
587 }
588
589 void SAL_CALL SdXImpressDocument::unlockControllers( )
590 {
591 ::SolarMutexGuard aGuard;
592
593 if( nullptr == mpDoc )
594 throw lang::DisposedException();
595
596 if( mpDoc->isLocked() )
597 {
598 mpDoc->setLock(false);
599 }
600 }
601
602 sal_Bool SAL_CALL SdXImpressDocument::hasControllersLocked( )
603 {
604 ::SolarMutexGuard aGuard;
605
606 if( nullptr == mpDoc )
607 throw lang::DisposedException();
608
609 return mpDoc->isLocked();
610 }
611
612 uno::Reference < container::XIndexAccess > SAL_CALL SdXImpressDocument::getViewData()
613 {
614 ::SolarMutexGuard aGuard;
615
616 if( nullptr == mpDoc )
617 throw lang::DisposedException();
618
619 uno::Reference < container::XIndexAccess > xRet( SfxBaseModel::getViewData() );
620
621 if( !xRet.is() )
622 {
623 const std::vector<std::unique_ptr<sd::FrameView>> &rList = mpDoc->GetFrameViewList();
624
625 if( !rList.empty() )
626 {
627 xRet.set(document::IndexedPropertyValues::create( ::comphelper::getProcessComponentContext() ), uno::UNO_QUERY);
628
629 uno::Reference < container::XIndexContainer > xCont( xRet, uno::UNO_QUERY );
630 DBG_ASSERT( xCont.is(), "SdXImpressDocument::getViewData() failed for OLE object" );
631 if( xCont.is() )
632 {
633 for( sal_uInt32 i = 0, n = rList.size(); i < n; i++ )
634 {
635 ::sd::FrameView* pFrameView = rList[ i ].get();
636
637 uno::Sequence< beans::PropertyValue > aSeq;
638 pFrameView->WriteUserDataSequence( aSeq );
639 xCont->insertByIndex( i, uno::makeAny( aSeq ) );
640 }
641 }
642 }
643 }
644
645 return xRet;
646 }
647
648 void SAL_CALL SdXImpressDocument::setViewData( const uno::Reference < container::XIndexAccess >& xData )
649 {
650 ::SolarMutexGuard aGuard;
651
652 if( nullptr == mpDoc )
653 throw lang::DisposedException();
654
655 SfxBaseModel::setViewData( xData );
656 if( !(mpDocShell && (mpDocShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED) && xData.is()) )
657 return;
658
659 const sal_Int32 nCount = xData->getCount();
660
661 std::vector<std::unique_ptr<sd::FrameView>> &rViews = mpDoc->GetFrameViewList();
662
663 rViews.clear();
664
665 uno::Sequence< beans::PropertyValue > aSeq;
666 for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
667 {
668 if( xData->getByIndex( nIndex ) >>= aSeq )
669 {
670 std::unique_ptr<::sd::FrameView> pFrameView(new ::sd::FrameView( mpDoc ));
671 pFrameView->ReadUserDataSequence( aSeq );
672 rViews.push_back( std::move(pFrameView) );
673 }
674 }
675 }
676
677 // XDrawPageDuplicator
678 uno::Reference< drawing::XDrawPage > SAL_CALL SdXImpressDocument::duplicate( const uno::Reference< drawing::XDrawPage >& xPage )
679 {
680 ::SolarMutexGuard aGuard;
681
682 if( nullptr == mpDoc )
683 throw lang::DisposedException();
684
685 // get pPage from xPage and determine the Id (nPos ) afterwards
686 SvxDrawPage* pSvxPage = SvxDrawPage::getImplementation( xPage );
687 if( pSvxPage )
688 {
689 SdPage* pPage = static_cast<SdPage*>( pSvxPage->GetSdrPage() );
690 sal_uInt16 nPos = pPage->GetPageNum();
691 nPos = ( nPos - 1 ) / 2;
692 pPage = InsertSdPage( nPos, true );
693 if( pPage )
694 {
695 uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
696 return xDrawPage;
697 }
698 }
699
700 uno::Reference< drawing::XDrawPage > xDrawPage;
701 return xDrawPage;
702 }
703
704 // XDrawPagesSupplier
705 uno::Reference< drawing::XDrawPages > SAL_CALL SdXImpressDocument::getDrawPages()
706 {
707 ::SolarMutexGuard aGuard;
708
709 if( nullptr == mpDoc )
710 throw lang::DisposedException();
711
712 uno::Reference< drawing::XDrawPages > xDrawPages( mxDrawPagesAccess );
713
714 if( !xDrawPages.is() )
715 {
716 initializeDocument();
717 mxDrawPagesAccess = xDrawPages = new SdDrawPagesAccess(*this);
718 }
719
720 return xDrawPages;
721 }
722
723 // XMasterPagesSupplier
724 uno::Reference< drawing::XDrawPages > SAL_CALL SdXImpressDocument::getMasterPages()
725 {
726 ::SolarMutexGuard aGuard;
727
728 if( nullptr == mpDoc )
729 throw lang::DisposedException();
730
731 uno::Reference< drawing::XDrawPages > xMasterPages( mxMasterPagesAccess );
732
733 if( !xMasterPages.is() )
734 {
735 if ( !hasControllersLocked() )
736 initializeDocument();
737 mxMasterPagesAccess = xMasterPages = new SdMasterPagesAccess(*this);
738 }
739
740 return xMasterPages;
741 }
742
743 // XLayerManagerSupplier
744 uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getLayerManager( )
745 {
746 ::SolarMutexGuard aGuard;
747
748 if( nullptr == mpDoc )
749 throw lang::DisposedException();
750
751 uno::Reference< container::XNameAccess > xLayerManager( mxLayerManager );
752
753 if( !xLayerManager.is() )
754 mxLayerManager = xLayerManager = new SdLayerManager(*this);
755
756 return xLayerManager;
757 }
758
759 // XCustomPresentationSupplier
760 uno::Reference< container::XNameContainer > SAL_CALL SdXImpressDocument::getCustomPresentations()
761 {
762 ::SolarMutexGuard aGuard;
763
764 if( nullptr == mpDoc )
765 throw lang::DisposedException();
766
767 uno::Reference< container::XNameContainer > xCustomPres( mxCustomPresentationAccess );
768
769 if( !xCustomPres.is() )
770 mxCustomPresentationAccess = xCustomPres = new SdXCustomPresentationAccess(*this);
771
772 return xCustomPres;
773 }
774
775 // XPresentationSupplier
776 uno::Reference< presentation::XPresentation > SAL_CALL SdXImpressDocument::getPresentation()
777 {
778 ::SolarMutexGuard aGuard;
779
780 if( nullptr == mpDoc )
781 throw lang::DisposedException();
782
783 return uno::Reference< presentation::XPresentation >( mpDoc->getPresentation().get() );
784 }
785
786 // XHandoutMasterSupplier
787 uno::Reference< drawing::XDrawPage > SAL_CALL SdXImpressDocument::getHandoutMasterPage()
788 {
789 ::SolarMutexGuard aGuard;
790
791 if( nullptr == mpDoc )
792 throw lang::DisposedException();
793
794 uno::Reference< drawing::XDrawPage > xPage;
795
796 initializeDocument();
797 SdPage* pPage = mpDoc->GetMasterSdPage(0, PageKind::Handout);
798 if (pPage)
799 xPage.set(pPage->getUnoPage(), uno::UNO_QUERY);
800 return xPage;
801 }
802
803 // XMultiServiceFactory ( SvxFmMSFactory )
804
805 css::uno::Reference<css::uno::XInterface> SdXImpressDocument::create(
806 OUString const & aServiceSpecifier, OUString const & referer)
807 {
808 ::SolarMutexGuard aGuard;
809
810 if( nullptr == mpDoc )
811 throw lang::DisposedException();
812
813 if( aServiceSpecifier == "com.sun.star.drawing.DashTable" )
814 {
815 if( !mxDashTable.is() )
816 mxDashTable = SvxUnoDashTable_createInstance( mpDoc );
817
818 return mxDashTable;
819 }
820 if( aServiceSpecifier == "com.sun.star.drawing.GradientTable" )
821 {
822 if( !mxGradientTable.is() )
823 mxGradientTable = SvxUnoGradientTable_createInstance( mpDoc );
824
825 return mxGradientTable;
826 }
827 if( aServiceSpecifier == "com.sun.star.drawing.HatchTable" )
828 {
829 if( !mxHatchTable.is() )
830 mxHatchTable = SvxUnoHatchTable_createInstance( mpDoc );
831
832 return mxHatchTable;
833 }
834 if( aServiceSpecifier == "com.sun.star.drawing.BitmapTable" )
835 {
836 if( !mxBitmapTable.is() )
837 mxBitmapTable = SvxUnoBitmapTable_createInstance( mpDoc );
838
839 return mxBitmapTable;
840 }
841 if( aServiceSpecifier == "com.sun.star.drawing.TransparencyGradientTable" )
842 {
843 if( !mxTransGradientTable.is() )
844 mxTransGradientTable = SvxUnoTransGradientTable_createInstance( mpDoc );
845
846 return mxTransGradientTable;
847 }
848 if( aServiceSpecifier == "com.sun.star.drawing.MarkerTable" )
849 {
850 if( !mxMarkerTable.is() )
851 mxMarkerTable = SvxUnoMarkerTable_createInstance( mpDoc );
852
853 return mxMarkerTable;
854 }
855 if( aServiceSpecifier == "com.sun.star.text.NumberingRules" )
856 {
857 return uno::Reference< uno::XInterface >( SvxCreateNumRule( mpDoc ), uno::UNO_QUERY );
858 }
859 if( aServiceSpecifier == "com.sun.star.drawing.Background" )
860 {
861 return uno::Reference< uno::XInterface >(
862 static_cast<uno::XWeak*>(new SdUnoPageBackground( mpDoc )));
863 }
864
865 if( aServiceSpecifier == "com.sun.star.drawing.Defaults" )
866 {
867 if( !mxDrawingPool.is() )
868 mxDrawingPool = SdUnoCreatePool( mpDoc );
869
870 return mxDrawingPool;
871
872 }
873
874 if ( aServiceSpecifier == sUNO_Service_ImageMapRectangleObject )
875 {
876 return SvUnoImageMapRectangleObject_createInstance( ImplGetSupportedMacroItems() );
877 }
878
879 if ( aServiceSpecifier == sUNO_Service_ImageMapCircleObject )
880 {
881 return SvUnoImageMapCircleObject_createInstance( ImplGetSupportedMacroItems() );
882 }
883
884 if ( aServiceSpecifier == sUNO_Service_ImageMapPolygonObject )
885 {
886 return SvUnoImageMapPolygonObject_createInstance( ImplGetSupportedMacroItems() );
887 }
888
889 if( aServiceSpecifier == "com.sun.star.document.Settings" ||
890 ( !mbImpressDoc && ( aServiceSpecifier == "com.sun.star.drawing.DocumentSettings" ) ) ||
891 ( mbImpressDoc && ( aServiceSpecifier == "com.sun.star.presentation.DocumentSettings" ) ) )
892 {
893 return sd::DocumentSettings_createInstance( this );
894 }
895
896 if( aServiceSpecifier == "com.sun.star.text.TextField.DateTime" ||
897 aServiceSpecifier == "com.sun.star.text.textfield.DateTime" )
898 {
899 return static_cast<cppu::OWeakObject *>(new SvxUnoTextField( text::textfield::Type::DATE ));
900 }
901
902 if( aServiceSpecifier == "com.sun.star.presentation.TextField.Header" ||
903 aServiceSpecifier == "com.sun.star.presentation.textfield.Header" )
904 {
905 return static_cast<cppu::OWeakObject *>(new SvxUnoTextField( text::textfield::Type::PRESENTATION_HEADER ));
906 }
907
908 if( aServiceSpecifier == "com.sun.star.presentation.TextField.Footer" ||
909 aServiceSpecifier == "com.sun.star.presentation.textfield.Footer" )
910 {
911 return static_cast<cppu::OWeakObject *>(new SvxUnoTextField( text::textfield::Type::PRESENTATION_FOOTER ));
912 }
913
914 if( aServiceSpecifier == "com.sun.star.presentation.TextField.DateTime" ||
915 aServiceSpecifier == "com.sun.star.presentation.textfield.DateTime" )
916 {
917 return static_cast<cppu::OWeakObject *>(new SvxUnoTextField( text::textfield::Type::PRESENTATION_DATE_TIME ));
918 }
919
920 if( aServiceSpecifier == "com.sun.star.text.TextField.PageName" ||
921 aServiceSpecifier == "com.sun.star.text.textfield.PageName" )
922 {
923 return static_cast<cppu::OWeakObject *>(new SvxUnoTextField( text::textfield::Type::PAGE_NAME ));
924 }
925
926 if (aServiceSpecifier == "com.sun.star.text.TextField.DocInfo.Custom" ||
927 aServiceSpecifier == "com.sun.star.text.textfield.DocInfo.Custom")
928 {
929 return static_cast<cppu::OWeakObject *>(new SvxUnoTextField(text::textfield::Type::DOCINFO_CUSTOM));
930 }
931
932 if( aServiceSpecifier == "com.sun.star.xml.NamespaceMap" )
933 {
934 static sal_uInt16 aWhichIds[] = { SDRATTR_XMLATTRIBUTES, EE_CHAR_XMLATTRIBS, EE_PARA_XMLATTRIBS, 0 };
935
936 return svx::NamespaceMap_createInstance( aWhichIds, &mpDoc->GetItemPool() );
937 }
938
939 // Support creation of GraphicStorageHandler and EmbeddedObjectResolver
940 if (aServiceSpecifier == "com.sun.star.document.ExportGraphicStorageHandler")
941 {
942 return static_cast<cppu::OWeakObject *>(new SvXMLGraphicHelper( SvXMLGraphicHelperMode::Write ));
943 }
944
945 if (aServiceSpecifier == "com.sun.star.document.ImportGraphicStorageHandler")
946 {
947 return static_cast<cppu::OWeakObject *>(new SvXMLGraphicHelper( SvXMLGraphicHelperMode::Read ));
948 }
949
950 if( aServiceSpecifier == "com.sun.star.document.ExportEmbeddedObjectResolver" )
951 {
952 comphelper::IEmbeddedHelper* pPersist = mpDoc->GetPersist();
953 if( nullptr == pPersist )
954 throw lang::DisposedException();
955
956 return static_cast<cppu::OWeakObject *>(new SvXMLEmbeddedObjectHelper( *pPersist, SvXMLEmbeddedObjectHelperMode::Write ));
957 }
958
959 if( aServiceSpecifier == "com.sun.star.document.ImportEmbeddedObjectResolver" )
960 {
961 comphelper::IEmbeddedHelper* pPersist = mpDoc->GetPersist();
962 if( nullptr == pPersist )
963 throw lang::DisposedException();
964
965 return static_cast<cppu::OWeakObject *>(new SvXMLEmbeddedObjectHelper( *pPersist, SvXMLEmbeddedObjectHelperMode::Read ));
966 }
967
968 uno::Reference< uno::XInterface > xRet;
969
970 if( aServiceSpecifier.startsWith( "com.sun.star.presentation.") )
971 {
972 const OUString aType( aServiceSpecifier.copy(26) );
973 SvxShape* pShape = nullptr;
974
975 sal_uInt16 nType = OBJ_TEXT;
976 // create a shape wrapper
977 if( aType.startsWith( "TitleTextShape" ) )
978 {
979 nType = OBJ_TEXT;
980 }
981 else if( aType.startsWith( "OutlinerShape" ) )
982 {
983 nType = OBJ_TEXT;
984 }
985 else if( aType.startsWith( "SubtitleShape" ) )
986 {
987 nType = OBJ_TEXT;
988 }
989 else if( aType.startsWith( "GraphicObjectShape" ) )
990 {
991 nType = OBJ_GRAF;
992 }
993 else if( aType.startsWith( "PageShape" ) )
994 {
995 nType = OBJ_PAGE;
996 }
997 else if( aType.startsWith( "OLE2Shape" ) )
998 {
999 nType = OBJ_OLE2;
1000 }
1001 else if( aType.startsWith( "ChartShape" ) )
1002 {
1003 nType = OBJ_OLE2;
1004 }
1005 else if( aType.startsWith( "CalcShape" ) )
1006 {
1007 nType = OBJ_OLE2;
1008 }
1009 else if( aType.startsWith( "TableShape" ) )
1010 {
1011 nType = OBJ_TABLE;
1012 }
1013 else if( aType.startsWith( "OrgChartShape" ) )
1014 {
1015 nType = OBJ_OLE2;
1016 }
1017 else if( aType.startsWith( "NotesShape" ) )
1018 {
1019 nType = OBJ_TEXT;
1020 }
1021 else if( aType.startsWith( "HandoutShape" ) )
1022 {
1023 nType = OBJ_PAGE;
1024 }
1025 else if( aType.startsWith( "FooterShape" ) )
1026 {
1027 nType = OBJ_TEXT;
1028 }
1029 else if( aType.startsWith( "HeaderShape" ) )
1030 {
1031 nType = OBJ_TEXT;
1032 }
1033 else if( aType.startsWith( "SlideNumberShape" ) )
1034 {
1035 nType = OBJ_TEXT;
1036 }
1037 else if( aType.startsWith( "DateTimeShape" ) )
1038 {
1039 nType = OBJ_TEXT;
1040 }
1041 else if( aType.startsWith( "MediaShape" ) )
1042 {
1043 nType = OBJ_MEDIA;
1044 }
1045 else
1046 {
1047 throw lang::ServiceNotRegisteredException();
1048 }
1049
1050 // create the API wrapper
1051 pShape = CreateSvxShapeByTypeAndInventor( nType, SdrInventor::Default, referer );
1052
1053 // set shape type
1054 if( pShape && !mbClipBoard )
1055 pShape->SetShapeType(aServiceSpecifier);
1056
1057 xRet = static_cast<uno::XWeak*>(pShape);
1058 }
1059 else if ( aServiceSpecifier == "com.sun.star.drawing.TableShape" )
1060 {
1061 SvxShape* pShape = CreateSvxShapeByTypeAndInventor( OBJ_TABLE, SdrInventor::Default, referer );
1062 if( pShape && !mbClipBoard )
1063 pShape->SetShapeType(aServiceSpecifier);
1064
1065 xRet = static_cast<uno::XWeak*>(pShape);
1066 }
1067 else
1068 {
1069 xRet = SvxFmMSFactory::createInstance( aServiceSpecifier );
1070 }
1071
1072 uno::Reference< drawing::XShape > xShape( xRet, uno::UNO_QUERY );
1073 SvxShape* pShape = xShape.is() ? SvxShape::getImplementation(xShape) : nullptr;
1074 if (pShape)
1075 {
1076 xRet.clear();
1077 new SdXShape( pShape, this );
1078 xRet = xShape;
1079 xShape.clear();
1080 }
1081
1082 return xRet;
1083 }
1084
1085 uno::Reference< uno::XInterface > SAL_CALL SdXImpressDocument::createInstance( const OUString& aServiceSpecifier )
1086 {
1087 return create(aServiceSpecifier, "");
1088 }
1089
1090 css::uno::Reference<css::uno::XInterface>
1091 SdXImpressDocument::createInstanceWithArguments(
1092 OUString const & ServiceSpecifier,
1093 css::uno::Sequence<css::uno::Any> const & Arguments)
1094 {
1095 OUString arg;
1096 if ((ServiceSpecifier == "com.sun.star.drawing.GraphicObjectShape"
1097 || ServiceSpecifier == "com.sun.star.drawing.MediaShape"
1098 || ServiceSpecifier == "com.sun.star.presentation.MediaShape")
1099 && Arguments.getLength() == 1 && (Arguments[0] >>= arg))
1100 {
1101 return create(ServiceSpecifier, arg);
1102 }
1103 return SvxFmMSFactory::createInstanceWithArguments(
1104 ServiceSpecifier, Arguments);
1105 }
1106
1107 uno::Sequence< OUString > SAL_CALL SdXImpressDocument::getAvailableServiceNames()
1108 {
1109 ::SolarMutexGuard aGuard;
1110
1111 if( nullptr == mpDoc )
1112 throw lang::DisposedException();
1113
1114 const uno::Sequence< OUString > aSNS_ORG( SvxFmMSFactory::getAvailableServiceNames() );
1115
1116 uno::Sequence< OUString > aSNS( mbImpressDoc ? 36 : 19 );
1117
1118 sal_uInt16 i(0);
1119
1120 aSNS[i++] = "com.sun.star.drawing.DashTable";
1121 aSNS[i++] = "com.sun.star.drawing.GradientTable";
1122 aSNS[i++] = "com.sun.star.drawing.HatchTable";
1123 aSNS[i++] = "com.sun.star.drawing.BitmapTable";
1124 aSNS[i++] = "com.sun.star.drawing.TransparencyGradientTable";
1125 aSNS[i++] = "com.sun.star.drawing.MarkerTable";
1126 aSNS[i++] = "com.sun.star.text.NumberingRules";
1127 aSNS[i++] = "com.sun.star.drawing.Background";
1128 aSNS[i++] = "com.sun.star.document.Settings";
1129 aSNS[i++] = sUNO_Service_ImageMapRectangleObject;
1130 aSNS[i++] = sUNO_Service_ImageMapCircleObject;
1131 aSNS[i++] = sUNO_Service_ImageMapPolygonObject;
1132 aSNS[i++] = "com.sun.star.xml.NamespaceMap";
1133
1134 // Support creation of GraphicStorageHandler and EmbeddedObjectResolver
1135 aSNS[i++] = "com.sun.star.document.ExportGraphicStorageHandler";
1136 aSNS[i++] = "com.sun.star.document.ImportGraphicStorageHandler";
1137 aSNS[i++] = "com.sun.star.document.ExportEmbeddedObjectResolver";
1138 aSNS[i++] = "com.sun.star.document.ImportEmbeddedObjectResolver";
1139 aSNS[i++] = "com.sun.star.drawing.TableShape";
1140
1141 if(mbImpressDoc)
1142 {
1143 aSNS[i++] = "com.sun.star.presentation.TitleTextShape";
1144 aSNS[i++] = "com.sun.star.presentation.OutlinerShape";
1145 aSNS[i++] = "com.sun.star.presentation.SubtitleShape";
1146 aSNS[i++] = "com.sun.star.presentation.GraphicObjectShape";
1147 aSNS[i++] = "com.sun.star.presentation.ChartShape";
1148 aSNS[i++] = "com.sun.star.presentation.PageShape";
1149 aSNS[i++] = "com.sun.star.presentation.OLE2Shape";
1150 aSNS[i++] = "com.sun.star.presentation.TableShape";
1151 aSNS[i++] = "com.sun.star.presentation.OrgChartShape";
1152 aSNS[i++] = "com.sun.star.presentation.NotesShape";
1153 aSNS[i++] = "com.sun.star.presentation.HandoutShape";
1154 aSNS[i++] = "com.sun.star.presentation.DocumentSettings";
1155 aSNS[i++] = "com.sun.star.presentation.FooterShape";
1156 aSNS[i++] = "com.sun.star.presentation.HeaderShape";
1157 aSNS[i++] = "com.sun.star.presentation.SlideNumberShape";
1158 aSNS[i++] = "com.sun.star.presentation.DateTimeShape";
1159 aSNS[i++] = "com.sun.star.presentation.CalcShape";
1160 aSNS[i++] = "com.sun.star.presentation.MediaShape";
1161 }
1162 else
1163 {
1164 aSNS[i++] = "com.sun.star.drawing.DocumentSettings";
1165 }
1166
1167 DBG_ASSERT( i == aSNS.getLength(), "Sequence overrun!" );
1168
1169 return comphelper::concatSequences( aSNS_ORG, aSNS );
1170 }
1171
1172 // lang::XServiceInfo
1173 OUString SAL_CALL SdXImpressDocument::getImplementationName()
1174 {
1175 return OUString( "SdXImpressDocument" );
1176 /* // Matching the .component information:
1177 return mbImpressDoc
1178 ? OUString("com.sun.star.comp.Draw.PresentationDocument")
1179 : OUString("com.sun.star.comp.Draw.DrawingDocument");
1180 */
1181 }
1182
1183 sal_Bool SAL_CALL SdXImpressDocument::supportsService( const OUString& ServiceName )
1184 {
1185 return cppu::supportsService(this, ServiceName);
1186 }
1187
1188 uno::Sequence< OUString > SAL_CALL SdXImpressDocument::getSupportedServiceNames()
1189 {
1190 ::SolarMutexGuard aGuard;
1191
1192 uno::Sequence< OUString > aSeq( 4 );
1193 OUString* pServices = aSeq.getArray();
1194
1195 *pServices++ = "com.sun.star.document.OfficeDocument";
1196 *pServices++ = "com.sun.star.drawing.GenericDrawingDocument";
1197 *pServices++ = "com.sun.star.drawing.DrawingDocumentFactory";
1198
1199 if( mbImpressDoc )
1200 *pServices++ = "com.sun.star.presentation.PresentationDocument";
1201 else
1202 *pServices++ = "com.sun.star.drawing.DrawingDocument";
1203
1204 return aSeq;
1205 }
1206
1207 // XPropertySet
1208 uno::Reference< beans::XPropertySetInfo > SAL_CALL SdXImpressDocument::getPropertySetInfo( )
1209 {
1210 ::SolarMutexGuard aGuard;
1211 return mpPropSet->getPropertySetInfo();
1212 }
1213
1214 void SAL_CALL SdXImpressDocument::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
1215 {
1216 ::SolarMutexGuard aGuard;
1217
1218 if( nullptr == mpDoc )
1219 throw lang::DisposedException();
1220
1221 const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(aPropertyName);
1222
1223 switch( pEntry ? pEntry->nWID : -1 )
1224 {
1225 case WID_MODEL_LANGUAGE:
1226 {
1227 lang::Locale aLocale;
1228 if(!(aValue >>= aLocale))
1229 throw lang::IllegalArgumentException();
1230
1231 mpDoc->SetLanguage( LanguageTag::convertToLanguageType(aLocale), EE_CHAR_LANGUAGE );
1232 break;
1233 }
1234 case WID_MODEL_TABSTOP:
1235 {
1236 sal_Int32 nValue = 0;
1237 if(!(aValue >>= nValue) || nValue < 0 )
1238 throw lang::IllegalArgumentException();
1239
1240 mpDoc->SetDefaultTabulator(static_cast<sal_uInt16>(nValue));
1241 break;
1242 }
1243 case WID_MODEL_VISAREA:
1244 {
1245 SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
1246 if( !pEmbeddedObj )
1247 break;
1248
1249 awt::Rectangle aVisArea;
1250 if( !(aValue >>= aVisArea) || (aVisArea.Width < 0) || (aVisArea.Height < 0) )
1251 throw lang::IllegalArgumentException();
1252
1253 sal_Int32 nRight, nTop;
1254 if (o3tl::checked_add(aVisArea.X, aVisArea.Width, nRight) || o3tl::checked_add(aVisArea.Y, aVisArea.Height, nTop))
1255 throw lang::IllegalArgumentException();
1256
1257 pEmbeddedObj->SetVisArea(::tools::Rectangle(aVisArea.X, aVisArea.Y, nRight, nTop));
1258 }
1259 break;
1260 case WID_MODEL_CONTFOCUS:
1261 {
1262 bool bFocus = false;
1263 if( !(aValue >>= bFocus ) )
1264 throw lang::IllegalArgumentException();
1265 mpDoc->SetAutoControlFocus( bFocus );
1266 }
1267 break;
1268 case WID_MODEL_DSGNMODE:
1269 {
1270 bool bMode = false;
1271 if( !(aValue >>= bMode ) )
1272 throw lang::IllegalArgumentException();
1273 mpDoc->SetOpenInDesignMode( bMode );
1274 }
1275 break;
1276 case WID_MODEL_BUILDID:
1277 aValue >>= maBuildId;
1278 return;
1279 case WID_MODEL_MAPUNIT:
1280 case WID_MODEL_BASICLIBS:
1281 case WID_MODEL_RUNTIMEUID: // is read-only
1282 case WID_MODEL_DIALOGLIBS:
1283 case WID_MODEL_FONTS:
1284 throw beans::PropertyVetoException();
1285 case WID_MODEL_INTEROPGRABBAG:
1286 setGrabBagItem(aValue);
1287 break;
1288 default:
1289 throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
1290 }
1291
1292 SetModified();
1293 }
1294
1295 uno::Any SAL_CALL SdXImpressDocument::getPropertyValue( const OUString& PropertyName )
1296 {
1297 ::SolarMutexGuard aGuard;
1298
1299 uno::Any aAny;
1300 if( nullptr == mpDoc )
1301 throw lang::DisposedException();
1302
1303 const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(PropertyName);
1304
1305 switch( pEntry ? pEntry->nWID : -1 )
1306 {
1307 case WID_MODEL_LANGUAGE:
1308 {
1309 LanguageType eLang = mpDoc->GetLanguage( EE_CHAR_LANGUAGE );
1310 aAny <<= LanguageTag::convertToLocale( eLang);
1311 break;
1312 }
1313 case WID_MODEL_TABSTOP:
1314 aAny <<= static_cast<sal_Int32>(mpDoc->GetDefaultTabulator());
1315 break;
1316 case WID_MODEL_VISAREA:
1317 {
1318 SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
1319 if( !pEmbeddedObj )
1320 break;
1321
1322 const ::tools::Rectangle& aRect = pEmbeddedObj->GetVisArea();
1323 awt::Rectangle aVisArea( aRect.Left(), aRect.Top(), aRect.getWidth(), aRect.getHeight() );
1324 aAny <<= aVisArea;
1325 }
1326 break;
1327 case WID_MODEL_MAPUNIT:
1328 {
1329 SfxObjectShell* pEmbeddedObj = mpDoc->GetDocSh();
1330 if( !pEmbeddedObj )
1331 break;
1332
1333 sal_Int16 nMeasureUnit = 0;
1334 SvxMapUnitToMeasureUnit( pEmbeddedObj->GetMapUnit(), nMeasureUnit );
1335 aAny <<= nMeasureUnit;
1336 }
1337 break;
1338 case WID_MODEL_FORBCHARS:
1339 {
1340 aAny <<= getForbiddenCharsTable();
1341 }
1342 break;
1343 case WID_MODEL_CONTFOCUS:
1344 aAny <<= mpDoc->GetAutoControlFocus();
1345 break;
1346 case WID_MODEL_DSGNMODE:
1347 aAny <<= mpDoc->GetOpenInDesignMode();
1348 break;
1349 case WID_MODEL_BASICLIBS:
1350 aAny <<= mpDocShell->GetBasicContainer();
1351 break;
1352 case WID_MODEL_DIALOGLIBS:
1353 aAny <<= mpDocShell->GetDialogContainer();
1354 break;
1355 case WID_MODEL_RUNTIMEUID:
1356 aAny <<= getRuntimeUID();
1357 break;
1358 case WID_MODEL_BUILDID:
1359 return uno::Any( maBuildId );
1360 case WID_MODEL_HASVALIDSIGNATURES:
1361 aAny <<= hasValidSignatures();
1362 break;
1363 case WID_MODEL_FONTS:
1364 {
1365 uno::Sequence<uno::Any> aSeq;
1366 int nSeqIndex = 0;
1367
1368 sal_uInt16 const aWhichIds[] { EE_CHAR_FONTINFO, EE_CHAR_FONTINFO_CJK,
1369 EE_CHAR_FONTINFO_CTL };
1370
1371 const SfxItemPool& rPool = mpDoc->GetPool();
1372
1373 for(sal_uInt16 nWhichId : aWhichIds)
1374 {
1375 sal_uInt32 nItems = rPool.GetItemCount2( nWhichId );
1376
1377 aSeq.realloc( aSeq.getLength() + nItems*5 + 5 );
1378
1379 for (const SfxPoolItem* pItem : rPool.GetItemSurrogates(nWhichId))
1380 {
1381 const SvxFontItem *pFont = static_cast<const SvxFontItem *>(pItem);
1382
1383 aSeq[nSeqIndex++] <<= pFont->GetFamilyName();
1384 aSeq[nSeqIndex++] <<= pFont->GetStyleName();
1385 aSeq[nSeqIndex++] <<= sal_Int16(pFont->GetFamily());
1386 aSeq[nSeqIndex++] <<= sal_Int16(pFont->GetPitch());
1387 aSeq[nSeqIndex++] <<= sal_Int16(pFont->GetCharSet());
1388 }
1389
1390 const SvxFontItem& rFont = static_cast<const SvxFontItem&>(rPool.GetDefaultItem( nWhichId ));
1391
1392 aSeq[nSeqIndex++] <<= rFont.GetFamilyName();
1393 aSeq[nSeqIndex++] <<= rFont.GetStyleName();
1394 aSeq[nSeqIndex++] <<= sal_Int16(rFont.GetFamily());
1395 aSeq[nSeqIndex++] <<= sal_Int16(rFont.GetPitch());
1396 aSeq[nSeqIndex++] <<= sal_Int16(rFont.GetCharSet());
1397
1398 }
1399
1400 aSeq.realloc( nSeqIndex );
1401 aAny <<= aSeq;
1402 break;
1403 }
1404 case WID_MODEL_INTEROPGRABBAG:
1405 getGrabBagItem(aAny);
1406 break;
1407 default:
1408 throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
1409 }
1410
1411 return aAny;
1412 }
1413
1414 void SAL_CALL SdXImpressDocument::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) {}
1415 void SAL_CALL SdXImpressDocument::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) {}
1416 void SAL_CALL SdXImpressDocument::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) {}
1417 void SAL_CALL SdXImpressDocument::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) {}
1418
1419 // XLinkTargetSupplier
1420 uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getLinks()
1421 {
1422 ::SolarMutexGuard aGuard;
1423
1424 if( nullptr == mpDoc )
1425 throw lang::DisposedException();
1426
1427 uno::Reference< container::XNameAccess > xLinks( mxLinks );
1428 if( !xLinks.is() )
1429 mxLinks = xLinks = new SdDocLinkTargets( *this );
1430 return xLinks;
1431 }
1432
1433 // XStyleFamiliesSupplier
1434 uno::Reference< container::XNameAccess > SAL_CALL SdXImpressDocument::getStyleFamilies( )
1435 {
1436 ::SolarMutexGuard aGuard;
1437
1438 if( nullptr == mpDoc )
1439 throw lang::DisposedException();
1440
1441 uno::Reference< container::XNameAccess > xStyles( dynamic_cast< container::XNameAccess* >( mpDoc->GetStyleSheetPool()) );
1442 return xStyles;
1443 }
1444
1445 // XAnyCompareFactory
1446 uno::Reference< css::ucb::XAnyCompare > SAL_CALL SdXImpressDocument::createAnyCompareByName( const OUString& )
1447 {
1448 return SvxCreateNumRuleCompare();
1449 }
1450
1451 // XRenderable
1452 sal_Int32 SAL_CALL SdXImpressDocument::getRendererCount( const uno::Any& rSelection,
1453 const uno::Sequence< beans::PropertyValue >& )
1454 {
1455 ::SolarMutexGuard aGuard;
1456 sal_Int32 nRet = 0;
1457
1458 if( nullptr == mpDoc )
1459 throw lang::DisposedException();
1460
1461 if (mpDocShell)
1462 {
1463 uno::Reference< frame::XModel > xModel;
1464
1465 rSelection >>= xModel;
1466
1467 if( xModel == mpDocShell->GetModel() )
1468 nRet = mpDoc->GetSdPageCount( PageKind::Standard );
1469 else
1470 {
1471 uno::Reference< drawing::XShapes > xShapes;
1472
1473 rSelection >>= xShapes;
1474
1475 if( xShapes.is() && xShapes->getCount() )
1476 nRet = 1;
1477 }
1478 }
1479 return nRet;
1480 }
1481
1482 uno::Sequence< beans::PropertyValue > SAL_CALL SdXImpressDocument::getRenderer( sal_Int32 , const uno::Any& ,
1483 const uno::Sequence< beans::PropertyValue >& rxOptions )
1484 {
1485 ::SolarMutexGuard aGuard;
1486
1487 if( nullptr == mpDoc )
1488 throw lang::DisposedException();
1489
1490 bool bExportNotesPages = false;
1491 for( sal_Int32 nProperty = 0, nPropertyCount = rxOptions.getLength(); nProperty < nPropertyCount; ++nProperty )
1492 {
1493 if ( rxOptions[ nProperty ].Name == "ExportNotesPages" )
1494 rxOptions[ nProperty].Value >>= bExportNotesPages;
1495 }
1496 uno::Sequence< beans::PropertyValue > aRenderer;
1497 if (mpDocShell)
1498 {
1499 awt::Size aPageSize;
1500 if ( bExportNotesPages )
1501 {
1502 Size aNotesPageSize = mpDoc->GetSdPage( 0, PageKind::Notes )->GetSize();
1503 aPageSize = awt::Size( aNotesPageSize.Width(), aNotesPageSize.Height() );
1504 }
1505 else
1506 {
1507 const ::tools::Rectangle aVisArea( mpDocShell->GetVisArea( embed::Aspects::MSOLE_DOCPRINT ) );
1508 aPageSize = awt::Size( aVisArea.GetWidth(), aVisArea.GetHeight() );
1509 }
1510 aRenderer.realloc( 1 );
1511
1512 aRenderer[ 0 ].Name = "PageSize" ;
1513 aRenderer[ 0 ].Value <<= aPageSize;
1514 }
1515 return aRenderer;
1516 }
1517
1518 class ImplRenderPaintProc : public sdr::contact::ViewObjectContactRedirector
1519 {
1520 const SdrLayerAdmin& rLayerAdmin;
1521 SdrPageView* const pSdrPageView;
1522 vcl::PDFExtOutDevData* const pPDFExtOutDevData;
1523
1524 vcl::PDFWriter::StructElement ImplBegStructureTag( SdrObject& rObject );
1525
1526 public:
1527 bool IsVisible ( const SdrObject* pObj ) const;
1528 bool IsPrintable( const SdrObject* pObj ) const;
1529
1530 ImplRenderPaintProc( const SdrLayerAdmin& rLA, SdrPageView* pView, vcl::PDFExtOutDevData* pData );
1531
1532 // all default implementations just call the same methods at the original. To do something
1533 // different, override the method and at least do what the method does.
1534 virtual drawinglayer::primitive2d::Primitive2DContainer createRedirectedPrimitive2DSequence(
1535 const sdr::contact::ViewObjectContact& rOriginal,
1536 const sdr::contact::DisplayInfo& rDisplayInfo) override;
1537 };
1538
1539 ImplRenderPaintProc::ImplRenderPaintProc( const SdrLayerAdmin& rLA, SdrPageView* pView, vcl::PDFExtOutDevData* pData )
1540 : ViewObjectContactRedirector(),
1541 rLayerAdmin ( rLA ),
1542 pSdrPageView ( pView ),
1543 pPDFExtOutDevData ( pData )
1544 {
1545 }
1546
1547 static sal_Int32 ImplPDFGetBookmarkPage( const OUString& rBookmark, SdDrawDocument const & rDoc )
1548 {
1549 sal_Int32 nPage = -1;
1550
1551 OUString aBookmark( rBookmark );
1552
1553 if( rBookmark.startsWith("#") )
1554 aBookmark = rBookmark.copy( 1 );
1555
1556 // is the bookmark a page ?
1557 bool bIsMasterPage;
1558 sal_uInt16 nPgNum = rDoc.GetPageByName( aBookmark, bIsMasterPage );
1559 SdrObject* pObj = nullptr;
1560
1561 if ( nPgNum == SDRPAGE_NOTFOUND )
1562 {
1563 // is the bookmark a object ?
1564 pObj = rDoc.GetObj( aBookmark );
1565 if (pObj)
1566 nPgNum = pObj->getSdrPageFromSdrObject()->GetPageNum();
1567 }
1568 if ( nPgNum != SDRPAGE_NOTFOUND )
1569 nPage = ( nPgNum - 1 ) / 2;
1570 return nPage;
1571 }
1572
1573 static void ImplPDFExportComments( const uno::Reference< drawing::XDrawPage >& xPage, vcl::PDFExtOutDevData& rPDFExtOutDevData )
1574 {
1575 try
1576 {
1577 uno::Reference< office::XAnnotationAccess > xAnnotationAccess( xPage, uno::UNO_QUERY_THROW );
1578 uno::Reference< office::XAnnotationEnumeration > xAnnotationEnumeration( xAnnotationAccess->createAnnotationEnumeration() );
1579
1580 LanguageType eLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
1581 while( xAnnotationEnumeration->hasMoreElements() )
1582 {
1583 uno::Reference< office::XAnnotation > xAnnotation( xAnnotationEnumeration->nextElement() );
1584
1585 geometry::RealPoint2D aRealPoint2D( xAnnotation->getPosition() );
1586 uno::Reference< text::XText > xText( xAnnotation->getTextRange() );
1587 util::DateTime aDateTime( xAnnotation->getDateTime() );
1588
1589 Date aDate( aDateTime.Day, aDateTime.Month, aDateTime.Year );
1590 ::tools::Time aTime( ::tools::Time::EMPTY );
1591 OUString aStr = SvxDateTimeField::GetFormatted( aDate, aTime,
1592 SvxDateFormat::B, SvxTimeFormat::AppDefault,
1593 *(SD_MOD()->GetNumberFormatter()), eLanguage );
1594
1595 vcl::PDFNote aNote;
1596 OUString sTitle( xAnnotation->getAuthor() );
1597 sTitle += ", ";
1598 sTitle += aStr;
1599 aNote.Title = sTitle;
1600 aNote.Contents = xText->getString();
1601 rPDFExtOutDevData.CreateNote( ::tools::Rectangle( Point( static_cast< long >( aRealPoint2D.X * 100 ),
1602 static_cast< long >( aRealPoint2D.Y * 100 ) ), Size( 1000, 1000 ) ), aNote );
1603 }
1604 }
1605 catch (const uno::Exception&)
1606 {
1607 }
1608 }
1609
1610 static void ImplPDFExportShapeInteraction( const uno::Reference< drawing::XShape >& xShape, SdDrawDocument& rDoc, vcl::PDFExtOutDevData& rPDFExtOutDevData )
1611 {
1612 if ( xShape->getShapeType() == "com.sun.star.drawing.GroupShape" )
1613 {
1614 uno::Reference< container::XIndexAccess > xIndexAccess( xShape, uno::UNO_QUERY );
1615 if ( xIndexAccess.is() )
1616 {
1617 sal_Int32 i, nCount = xIndexAccess->getCount();
1618 for ( i = 0; i < nCount; i++ )
1619 {
1620 uno::Reference< drawing::XShape > xSubShape( xIndexAccess->getByIndex( i ), uno::UNO_QUERY );
1621 if ( xSubShape.is() )
1622 ImplPDFExportShapeInteraction( xSubShape, rDoc, rPDFExtOutDevData );
1623 }
1624 }
1625 }
1626 else
1627 {
1628 uno::Reference< beans::XPropertySet > xShapePropSet( xShape, uno::UNO_QUERY );
1629 if( xShapePropSet.is() )
1630 {
1631 Size aPageSize( rDoc.GetSdPage( 0, PageKind::Standard )->GetSize() );
1632 Point aPoint( 0, 0 );
1633 ::tools::Rectangle aPageRect( aPoint, aPageSize );
1634
1635 awt::Point aShapePos( xShape->getPosition() );
1636 awt::Size aShapeSize( xShape->getSize() );
1637 ::tools::Rectangle aLinkRect( Point( aShapePos.X, aShapePos.Y ), Size( aShapeSize.Width, aShapeSize.Height ) );
1638
1639 // Handle linked videos.
1640 if (xShape->getShapeType() == "com.sun.star.drawing.MediaShape" || xShape->getShapeType() == "com.sun.star.presentation.MediaShape")
1641 {
1642 OUString aMediaURL;
1643 xShapePropSet->getPropertyValue("MediaURL") >>= aMediaURL;
1644 if (!aMediaURL.isEmpty())
1645 {
1646 sal_Int32 nScreenId = rPDFExtOutDevData.CreateScreen(aLinkRect, rPDFExtOutDevData.GetCurrentPageNumber());
1647 if (aMediaURL.startsWith("vnd.sun.star.Package:"))
1648 {
1649 OUString aTempFileURL;
1650 xShapePropSet->getPropertyValue("PrivateTempFileURL") >>= aTempFileURL;
1651 rPDFExtOutDevData.SetScreenStream(nScreenId, aTempFileURL);
1652 }
1653 else
1654 rPDFExtOutDevData.SetScreenURL(nScreenId, aMediaURL);
1655 }
1656 }
1657
1658 presentation::ClickAction eCa;
1659 uno::Any aAny( xShapePropSet->getPropertyValue( "OnClick" ) );
1660 if ( aAny >>= eCa )
1661 {
1662 switch ( eCa )
1663 {
1664 case presentation::ClickAction_LASTPAGE :
1665 {
1666 sal_Int32 nCount = rDoc.GetSdPageCount( PageKind::Standard );
1667 sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nCount - 1, vcl::PDFWriter::DestAreaType::FitRectangle );
1668 sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect );
1669 rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1670 }
1671 break;
1672 case presentation::ClickAction_FIRSTPAGE :
1673 {
1674 sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, 0, vcl::PDFWriter::DestAreaType::FitRectangle );
1675 sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect );
1676 rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1677 }
1678 break;
1679 case presentation::ClickAction_PREVPAGE :
1680 {
1681 sal_Int32 nDestPage = rPDFExtOutDevData.GetCurrentPageNumber();
1682 if ( nDestPage )
1683 nDestPage--;
1684 sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nDestPage, vcl::PDFWriter::DestAreaType::FitRectangle );
1685 sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect );
1686 rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1687 }
1688 break;
1689 case presentation::ClickAction_NEXTPAGE :
1690 {
1691 sal_Int32 nDestPage = rPDFExtOutDevData.GetCurrentPageNumber() + 1;
1692 sal_Int32 nLastPage = rDoc.GetSdPageCount( PageKind::Standard ) - 1;
1693 if ( nDestPage > nLastPage )
1694 nDestPage = nLastPage;
1695 sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nDestPage, vcl::PDFWriter::DestAreaType::FitRectangle );
1696 sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect );
1697 rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1698 }
1699 break;
1700
1701 case presentation::ClickAction_PROGRAM :
1702 case presentation::ClickAction_BOOKMARK :
1703 case presentation::ClickAction_DOCUMENT :
1704 {
1705 OUString aBookmark;
1706 xShapePropSet->getPropertyValue( "Bookmark" ) >>= aBookmark;
1707 if( !aBookmark.isEmpty() )
1708 {
1709 switch( eCa )
1710 {
1711 case presentation::ClickAction_DOCUMENT :
1712 case presentation::ClickAction_PROGRAM :
1713 {
1714 sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect );
1715 rPDFExtOutDevData.SetLinkURL( nLinkId, aBookmark );
1716 }
1717 break;
1718 case presentation::ClickAction_BOOKMARK :
1719 {
1720 sal_Int32 nPage = ImplPDFGetBookmarkPage( aBookmark, rDoc );
1721 if ( nPage != -1 )
1722 {
1723 sal_Int32 nDestId = rPDFExtOutDevData.CreateDest( aPageRect, nPage, vcl::PDFWriter::DestAreaType::FitRectangle );
1724 sal_Int32 nLinkId = rPDFExtOutDevData.CreateLink( aLinkRect );
1725 rPDFExtOutDevData.SetLinkDest( nLinkId, nDestId );
1726 }
1727 }
1728 break;
1729 default:
1730 break;
1731 }
1732 }
1733 }
1734 break;
1735
1736 case presentation::ClickAction_STOPPRESENTATION :
1737 case presentation::ClickAction_SOUND :
1738 case presentation::ClickAction_INVISIBLE :
1739 case presentation::ClickAction_VERB :
1740 case presentation::ClickAction_VANISH :
1741 case presentation::ClickAction_MACRO :
1742 default :
1743 break;
1744 }
1745 }
1746 }
1747 }
1748 }
1749
1750 vcl::PDFWriter::StructElement ImplRenderPaintProc::ImplBegStructureTag( SdrObject& rObject )
1751 {
1752 vcl::PDFWriter::StructElement eElement(vcl::PDFWriter::NonStructElement);
1753
1754 if ( pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportTaggedPDF() )
1755 {
1756 SdrInventor nInventor = rObject.GetObjInventor();
1757 sal_uInt16 nIdentifier = rObject.GetObjIdentifier();
1758 bool bIsTextObj = dynamic_cast< const SdrTextObj *>( &rObject ) != nullptr;
1759
1760 if ( nInventor == SdrInventor::Default )
1761 {
1762 if ( nIdentifier == OBJ_GRUP )
1763 eElement = vcl::PDFWriter::Section;
1764 else if ( nIdentifier == OBJ_TITLETEXT )
1765 eElement = vcl::PDFWriter::Heading;
1766 else if ( nIdentifier == OBJ_OUTLINETEXT )
1767 eElement = vcl::PDFWriter::Division;
1768 else if ( !bIsTextObj || !static_cast<SdrTextObj&>(rObject).HasText() )
1769 eElement = vcl::PDFWriter::Figure;
1770 }
1771 }
1772
1773 return eElement;
1774 }
1775
1776 drawinglayer::primitive2d::Primitive2DContainer ImplRenderPaintProc::createRedirectedPrimitive2DSequence(
1777 const sdr::contact::ViewObjectContact& rOriginal,
1778 const sdr::contact::DisplayInfo& rDisplayInfo)
1779 {
1780 SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
1781
1782 if(pObject)
1783 {
1784 drawinglayer::primitive2d::Primitive2DContainer xRetval;
1785
1786 if(pObject->getSdrPageFromSdrObject())
1787 {
1788 if(pObject->getSdrPageFromSdrObject()->checkVisibility(rOriginal, rDisplayInfo, false))
1789 {
1790 if(IsVisible(pObject) && IsPrintable(pObject))
1791 {
1792 const vcl::PDFWriter::StructElement eElement(ImplBegStructureTag( *pObject ));
1793 const bool bTagUsed(vcl::PDFWriter::NonStructElement != eElement);
1794
1795 xRetval = sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
1796
1797 if(!xRetval.empty() && bTagUsed)
1798 {
1799 // embed Primitive2DSequence in a structure tag element for
1800 // exactly this purpose (StructureTagPrimitive2D)
1801
1802 const SdrPage* pSdrPage(pObject->getSdrPageFromSdrObject());
1803 const bool bBackground(nullptr != pSdrPage && pSdrPage->IsMasterPage());
1804 const bool bImage(pObject->GetObjIdentifier() == OBJ_GRAF);
1805
1806 const drawinglayer::primitive2d::Primitive2DReference xReference(
1807 new drawinglayer::primitive2d::StructureTagPrimitive2D(
1808 eElement,
1809 bBackground,
1810 bImage,
1811 xRetval));
1812
1813 xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference };
1814 }
1815 }
1816 }
1817 }
1818
1819 return xRetval;
1820 }
1821 else
1822 {
1823 // not an object, maybe a page
1824 return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
1825 }
1826 }
1827
1828 bool ImplRenderPaintProc::IsVisible( const SdrObject* pObj ) const
1829 {
1830 bool bVisible = true;
1831 SdrLayerID nLayerId = pObj->GetLayer();
1832 if( pSdrPageView )
1833 {
1834 const SdrLayer* pSdrLayer = rLayerAdmin.GetLayerPerID( nLayerId );
1835 if ( pSdrLayer )
1836 {
1837 const OUString& aLayerName = pSdrLayer->GetName();
1838 bVisible = pSdrPageView->IsLayerVisible( aLayerName );
1839 }
1840 }
1841 return bVisible;
1842 }
1843 bool ImplRenderPaintProc::IsPrintable( const SdrObject* pObj ) const
1844 {
1845 bool bPrintable = true;
1846 SdrLayerID nLayerId = pObj->GetLayer();
1847 if( pSdrPageView )
1848 {
1849 const SdrLayer* pSdrLayer = rLayerAdmin.GetLayerPerID( nLayerId );
1850 if ( pSdrLayer )
1851 {
1852 const OUString& aLayerName = pSdrLayer->GetName();
1853 bPrintable = pSdrPageView->IsLayerPrintable( aLayerName );
1854 }
1855 }
1856 return bPrintable;
1857
1858 }
1859
1860 namespace
1861 {
1862 sal_Int16 CalcOutputPageNum(vcl::PDFExtOutDevData const * pPDFExtOutDevData, SdDrawDocument const *pDoc, sal_Int16 nPageNumber)
1863 {
1864 //export all pages, simple one to one case
1865 if (pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportHiddenSlides())
1866 return nPageNumber-1;
1867 //check all preceding pages, and only count non-hidden ones
1868 sal_Int16 nRet = 0;
1869 for (sal_Int16 i = 0; i < nPageNumber-1; ++i)
1870 {
1871 if (!pDoc->GetSdPage(i, PageKind::Standard)->IsExcluded())
1872 ++nRet;
1873 }
1874 return nRet;
1875 }
1876 }
1877
1878 void SAL_CALL SdXImpressDocument::render( sal_Int32 nRenderer, const uno::Any& rSelection,
1879 const uno::Sequence< beans::PropertyValue >& rxOptions )
1880 {
1881 ::SolarMutexGuard aGuard;
1882
1883 if( nullptr == mpDoc )
1884 throw lang::DisposedException();
1885
1886 if (!mpDocShell)
1887 return;
1888
1889 uno::Reference< awt::XDevice > xRenderDevice;
1890 const sal_Int32 nPageNumber = nRenderer + 1;
1891 PageKind ePageKind = PageKind::Standard;
1892 bool bExportNotesPages = false;
1893
1894 for( sal_Int32 nProperty = 0, nPropertyCount = rxOptions.getLength(); nProperty < nPropertyCount; ++nProperty )
1895 {
1896 if ( rxOptions[ nProperty ].Name == "RenderDevice" )
1897 rxOptions[ nProperty ].Value >>= xRenderDevice;
1898 else if ( rxOptions[ nProperty ].Name == "ExportNotesPages" )
1899 {
1900 rxOptions[ nProperty].Value >>= bExportNotesPages;
1901 if ( bExportNotesPages )
1902 ePageKind = PageKind::Notes;
1903 }
1904 }
1905
1906 if( !(xRenderDevice.is() && nPageNumber && ( nPageNumber <= mpDoc->GetSdPageCount( ePageKind ) )) )
1907 return;
1908
1909 VCLXDevice* pDevice = VCLXDevice::GetImplementation( xRenderDevice );
1910 VclPtr< OutputDevice> pOut = pDevice ? pDevice->GetOutputDevice() : VclPtr< OutputDevice >();
1911
1912 if( !pOut )
1913 return;
1914
1915 vcl::PDFExtOutDevData* pPDFExtOutDevData = dynamic_cast<vcl::PDFExtOutDevData* >( pOut->GetExtOutDevData() );
1916
1917 if ( !(!( mpDoc->GetSdPage(static_cast<sal_Int16>(nPageNumber)-1, PageKind::Standard)->IsExcluded() ) ||
1918 (pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportHiddenSlides())) )
1919 return;
1920
1921 std::unique_ptr<::sd::ClientView> pView( new ::sd::ClientView( mpDocShell, pOut ) );
1922 ::tools::Rectangle aVisArea = ::tools::Rectangle( Point(), mpDoc->GetSdPage( static_cast<sal_uInt16>(nPageNumber) - 1, ePageKind )->GetSize() );
1923 vcl::Region aRegion( aVisArea );
1924
1925 ::sd::ViewShell* pOldViewSh = mpDocShell->GetViewShell();
1926 ::sd::View* pOldSdView = pOldViewSh ? pOldViewSh->GetView() : nullptr;
1927
1928 if ( pOldSdView )
1929 pOldSdView->SdrEndTextEdit();
1930
1931 pView->SetHlplVisible( false );
1932 pView->SetGridVisible( false );
1933 pView->SetBordVisible( false );
1934 pView->SetPageVisible( false );
1935 pView->SetGlueVisible( false );
1936
1937 pOut->SetMapMode(MapMode(MapUnit::Map100thMM));
1938 pOut->IntersectClipRegion( aVisArea );
1939
1940 uno::Reference< frame::XModel > xModel;
1941 rSelection >>= xModel;
1942
1943 if( xModel == mpDocShell->GetModel() )
1944 {
1945 pView->ShowSdrPage( mpDoc->GetSdPage( static_cast<sal_uInt16>(nPageNumber) - 1, ePageKind ));
1946 SdrPageView* pPV = pView->GetSdrPageView();
1947
1948 if( pOldSdView )
1949 {
1950 SdrPageView* pOldPV = pOldSdView->GetSdrPageView();
1951 if( pPV && pOldPV )
1952 {
1953 pPV->SetVisibleLayers( pOldPV->GetVisibleLayers() );
1954 pPV->SetPrintableLayers( pOldPV->GetPrintableLayers() );
1955 }
1956 }
1957
1958 ImplRenderPaintProc aImplRenderPaintProc( mpDoc->GetLayerAdmin(),
1959 pPV, pPDFExtOutDevData );
1960
1961 // background color for outliner :o
1962 SdPage* pPage = pPV ? static_cast<SdPage*>(pPV->GetPage()) : nullptr;
1963 if( pPage )
1964 {
1965 SdrOutliner& rOutl = mpDoc->GetDrawOutliner();
1966 bool bScreenDisplay(true);
1967
1968 // #i75566# printing; suppress AutoColor BackgroundColor generation
1969 // for visibility reasons by giving GetPageBackgroundColor()
1970 // the needed hint
1971 // #i75566# PDF export; suppress AutoColor BackgroundColor generation (see printing)
1972 if (pOut && ((OUTDEV_PRINTER == pOut->GetOutDevType())
1973 || (OUTDEV_PDF == pOut->GetOutDevType())))
1974 bScreenDisplay = false;
1975
1976 // #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and
1977 // hint value if screen display. Only then the AutoColor mechanisms shall be applied
1978 rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor( pPV, bScreenDisplay ) );
1979 }
1980 pView->SdrPaintView::CompleteRedraw( pOut, aRegion, &aImplRenderPaintProc );
1981
1982 if ( pPDFExtOutDevData && pPage )
1983 {
1984 try
1985 {
1986 uno::Any aAny;
1987 uno::Reference< drawing::XDrawPage > xPage( uno::Reference< drawing::XDrawPage >::query( pPage->getUnoPage() ) );
1988 if ( xPage.is() )
1989 {
1990 if ( pPDFExtOutDevData->GetIsExportNotes() )
1991 ImplPDFExportComments( xPage, *pPDFExtOutDevData );
1992 uno::Reference< beans::XPropertySet > xPagePropSet( xPage, uno::UNO_QUERY );
1993 if( xPagePropSet.is() )
1994 {
1995 // exporting object interactions to pdf
1996
1997 // if necessary, the master page interactions will be exported first
1998 bool bIsBackgroundObjectsVisible = false; // #i39428# IsBackgroundObjectsVisible not available for Draw
1999 if ( mbImpressDoc && xPagePropSet->getPropertySetInfo()->hasPropertyByName( "IsBackgroundObjectsVisible" ) )
2000 xPagePropSet->getPropertyValue( "IsBackgroundObjectsVisible" ) >>= bIsBackgroundObjectsVisible;
2001 if ( bIsBackgroundObjectsVisible && !pPDFExtOutDevData->GetIsExportNotesPages() )
2002 {
2003 uno::Reference< drawing::XMasterPageTarget > xMasterPageTarget( xPage, uno::UNO_QUERY );
2004 if ( xMasterPageTarget.is() )
2005 {
2006 uno::Reference< drawing::XDrawPage > xMasterPage = xMasterPageTarget->getMasterPage();
2007 if ( xMasterPage.is() )
2008 {
2009 uno::Reference< drawing::XShapes> xShapes( xMasterPage, uno::UNO_QUERY );
2010 sal_Int32 i, nCount = xShapes->getCount();
2011 for ( i = 0; i < nCount; i++ )
2012 {
2013 aAny = xShapes->getByIndex( i );
2014 uno::Reference< drawing::XShape > xShape;
2015 if ( aAny >>= xShape )
2016 ImplPDFExportShapeInteraction( xShape, *mpDoc, *pPDFExtOutDevData );
2017 }
2018 }
2019 }
2020 }
2021
2022 // exporting slide page object interactions
2023 uno::Reference< drawing::XShapes> xShapes( xPage, uno::UNO_QUERY );
2024 sal_Int32 i, nCount = xShapes->getCount();
2025 for ( i = 0; i < nCount; i++ )
2026 {
2027 aAny = xShapes->getByIndex( i );
2028 uno::Reference< drawing::XShape > xShape;
2029 if ( aAny >>= xShape )
2030 ImplPDFExportShapeInteraction( xShape, *mpDoc, *pPDFExtOutDevData );
2031 }
2032
2033 // exporting transition effects to pdf
2034 if ( mbImpressDoc && !pPDFExtOutDevData->GetIsExportNotesPages() && pPDFExtOutDevData->GetIsExportTransitionEffects() )
2035 {
2036 const OUString sEffect( "Effect" );
2037 const OUString sSpeed ( "Speed" );
2038 sal_Int32 nTime = 800;
2039 presentation::AnimationSpeed aAs;
2040 if ( xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sSpeed ) )
2041 {
2042 aAny = xPagePropSet->getPropertyValue( sSpeed );
2043 if ( aAny >>= aAs )
2044 {
2045 switch( aAs )
2046 {
2047 case presentation::AnimationSpeed_SLOW : nTime = 1500; break;
2048 case presentation::AnimationSpeed_FAST : nTime = 300; break;
2049 default:
2050 case presentation::AnimationSpeed_MEDIUM : nTime = 800;
2051 }
2052 }
2053 }
2054 presentation::FadeEffect eFe;
2055 vcl::PDFWriter::PageTransition eType = vcl::PDFWriter::PageTransition::Regular;
2056 if ( xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sEffect ) )
2057 {
2058 aAny = xPagePropSet->getPropertyValue( sEffect );
2059 if ( aAny >>= eFe )
2060 {
2061 switch( eFe )
2062 {
2063 case presentation::FadeEffect_HORIZONTAL_LINES :
2064 case presentation::FadeEffect_HORIZONTAL_CHECKERBOARD :
2065 case presentation::FadeEffect_HORIZONTAL_STRIPES : eType = vcl::PDFWriter::PageTransition::BlindsHorizontal; break;
2066
2067 case presentation::FadeEffect_VERTICAL_LINES :
2068 case presentation::FadeEffect_VERTICAL_CHECKERBOARD :
2069 case presentation::FadeEffect_VERTICAL_STRIPES : eType = vcl::PDFWriter::PageTransition::BlindsVertical; break;
2070
2071 case presentation::FadeEffect_UNCOVER_TO_RIGHT :
2072 case presentation::FadeEffect_UNCOVER_TO_UPPERRIGHT :
2073 case presentation::FadeEffect_ROLL_FROM_LEFT :
2074 case presentation::FadeEffect_FADE_FROM_UPPERLEFT :
2075 case presentation::FadeEffect_MOVE_FROM_UPPERLEFT :
2076 case presentation::FadeEffect_FADE_FROM_LEFT :
2077 case presentation::FadeEffect_MOVE_FROM_LEFT : eType = vcl::PDFWriter::PageTransition::WipeLeftToRight; break;
2078
2079 case presentation::FadeEffect_UNCOVER_TO_BOTTOM :
2080 case presentation::FadeEffect_UNCOVER_TO_LOWERRIGHT :
2081 case presentation::FadeEffect_ROLL_FROM_TOP :
2082 case presentation::FadeEffect_FADE_FROM_UPPERRIGHT :
2083 case presentation::FadeEffect_MOVE_FROM_UPPERRIGHT :
2084 case presentation::FadeEffect_FADE_FROM_TOP :
2085 case presentation::FadeEffect_MOVE_FROM_TOP : eType = vcl::PDFWriter::PageTransition::WipeTopToBottom; break;
2086
2087 case presentation::FadeEffect_UNCOVER_TO_LEFT :
2088 case presentation::FadeEffect_UNCOVER_TO_LOWERLEFT :
2089 case presentation::FadeEffect_ROLL_FROM_RIGHT :
2090
2091 case presentation::FadeEffect_FADE_FROM_LOWERRIGHT :
2092 case presentation::FadeEffect_MOVE_FROM_LOWERRIGHT :
2093 case presentation::FadeEffect_FADE_FROM_RIGHT :
2094 case presentation::FadeEffect_MOVE_FROM_RIGHT : eType = vcl::PDFWriter::PageTransition::WipeRightToLeft; break;
2095
2096 case presentation::FadeEffect_UNCOVER_TO_TOP :
2097 case presentation::FadeEffect_UNCOVER_TO_UPPERLEFT :
2098 case presentation::FadeEffect_ROLL_FROM_BOTTOM :
2099 case presentation::FadeEffect_FADE_FROM_LOWERLEFT :
2100 case presentation::FadeEffect_MOVE_FROM_LOWERLEFT :
2101 case presentation::FadeEffect_FADE_FROM_BOTTOM :
2102 case presentation::FadeEffect_MOVE_FROM_BOTTOM : eType = vcl::PDFWriter::PageTransition::WipeBottomToTop; break;
2103
2104 case presentation::FadeEffect_OPEN_VERTICAL : eType = vcl::PDFWriter::PageTransition::SplitHorizontalInward; break;
2105 case presentation::FadeEffect_CLOSE_HORIZONTAL : eType = vcl::PDFWriter::PageTransition::SplitHorizontalOutward; break;
2106
2107 case presentation::FadeEffect_OPEN_HORIZONTAL : eType = vcl::PDFWriter::PageTransition::SplitVerticalInward; break;
2108 case presentation::FadeEffect_CLOSE_VERTICAL : eType = vcl::PDFWriter::PageTransition::SplitVerticalOutward; break;
2109
2110 case presentation::FadeEffect_FADE_TO_CENTER : eType = vcl::PDFWriter::PageTransition::BoxInward; break;
2111 case presentation::FadeEffect_FADE_FROM_CENTER : eType = vcl::PDFWriter::PageTransition::BoxOutward; break;
2112
2113 case presentation::FadeEffect_NONE : eType = vcl::PDFWriter::PageTransition::Regular; break;
2114
2115 case presentation::FadeEffect_RANDOM :
2116 case presentation::FadeEffect_DISSOLVE :
2117 default: eType = vcl::PDFWriter::PageTransition::Dissolve; break;
2118 }
2119 }
2120 }
2121
2122 if ( xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sEffect ) ||
2123 xPagePropSet->getPropertySetInfo( )->hasPropertyByName( sSpeed ) )
2124 {
2125 pPDFExtOutDevData->SetPageTransition( eType, nTime );
2126 }
2127 }
2128 }
2129 }
2130
2131 Size aPageSize( mpDoc->GetSdPage( 0, PageKind::Standard )->GetSize() );
2132 Point aPoint( 0, 0 );
2133 ::tools::Rectangle aPageRect( aPoint, aPageSize );
2134
2135 // resolving links found in this page by the method ImpEditEngine::Paint
2136 std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = pPDFExtOutDevData->GetBookmarks();
2137 for ( const auto& rBookmark : rBookmarks )
2138 {
2139 sal_Int32 nPage = ImplPDFGetBookmarkPage( rBookmark.aBookmark, *mpDoc );
2140 if ( nPage != -1 )
2141 {
2142 if ( rBookmark.nLinkId != -1 )
2143 pPDFExtOutDevData->SetLinkDest( rBookmark.nLinkId, pPDFExtOutDevData->CreateDest( aPageRect, nPage, vcl::PDFWriter::DestAreaType::FitRectangle ) );
2144 else
2145 pPDFExtOutDevData->DescribeRegisteredDest( rBookmark.nDestId, aPageRect, nPage, vcl::PDFWriter::DestAreaType::FitRectangle );
2146 }
2147 else
2148 pPDFExtOutDevData->SetLinkURL( rBookmark.nLinkId, rBookmark.aBookmark );
2149 }
2150 rBookmarks.clear();
2151 //---> #i56629, #i40318
2152 //get the page name, will be used as outline element in PDF bookmark pane
2153 OUString aPageName = mpDoc->GetSdPage( static_cast<sal_uInt16>(nPageNumber) - 1 , PageKind::Standard )->GetName();
2154 if( !aPageName.isEmpty() )
2155 {
2156 // Destination PageNum
2157 const sal_Int32 nDestPageNum = CalcOutputPageNum(pPDFExtOutDevData, mpDoc, nPageNumber);
2158
2159 // insert the bookmark to this page into the NamedDestinations
2160 if( pPDFExtOutDevData->GetIsExportNamedDestinations() )
2161 pPDFExtOutDevData->CreateNamedDest(aPageName, aPageRect, nDestPageNum);
2162
2163 // add the name to the outline, (almost) same code as in sc/source/ui/unoobj/docuno.cxx
2164 // issue #i40318.
2165
2166 if( pPDFExtOutDevData->GetIsExportBookmarks() )
2167 {
2168 // Destination Export
2169 const sal_Int32 nDestId =
2170 pPDFExtOutDevData->CreateDest(aPageRect , nDestPageNum);
2171
2172 // Create a new outline item:
2173 pPDFExtOutDevData->CreateOutlineItem( -1 , aPageName, nDestId );
2174 }
2175 }
2176 //<--- #i56629, #i40318
2177 }
2178 catch (const uno::Exception&)
2179 {
2180 }
2181
2182 }
2183 }
2184 else
2185 {
2186 uno::Reference< drawing::XShapes > xShapes;
2187 rSelection >>= xShapes;
2188
2189 if( xShapes.is() && xShapes->getCount() )
2190 {
2191 SdrPageView* pPV = nullptr;
2192
2193 ImplRenderPaintProc aImplRenderPaintProc( mpDoc->GetLayerAdmin(),
2194 pOldSdView ? pOldSdView->GetSdrPageView() : nullptr, pPDFExtOutDevData );
2195
2196 for( sal_uInt32 i = 0, nCount = xShapes->getCount(); i < nCount; i++ )
2197 {
2198 uno::Reference< drawing::XShape > xShape;
2199 xShapes->getByIndex( i ) >>= xShape;
2200
2201 if( xShape.is() )
2202 {
2203 SvxShape* pShape = SvxShape::getImplementation( xShape );
2204
2205 if( pShape )
2206 {
2207 SdrObject* pObj = pShape->GetSdrObject();
2208 if( pObj && pObj->getSdrPageFromSdrObject()
2209 && aImplRenderPaintProc.IsVisible( pObj )
2210 && aImplRenderPaintProc.IsPrintable( pObj ) )
2211 {
2212 if( !pPV )
2213 pPV = pView->ShowSdrPage( pObj->getSdrPageFromSdrObject() );
2214
2215 if( pPV )
2216 pView->MarkObj( pObj, pPV );
2217 }
2218 }
2219 }
2220 }
2221 pView->DrawMarkedObj(*pOut);
2222 }
2223 }
2224 }
2225
2226 DrawViewShell* SdXImpressDocument::GetViewShell()
2227 {
2228 DrawViewShell* pViewSh = dynamic_cast<DrawViewShell*>(mpDocShell->GetViewShell());
2229 if (!pViewSh)
2230 {
2231 SAL_WARN("sd", "DrawViewShell not available!");
2232 return nullptr;
2233 }
2234 return pViewSh;
2235 }
2236
2237 void SdXImpressDocument::paintTile( VirtualDevice& rDevice,
2238 int nOutputWidth, int nOutputHeight,
2239 int nTilePosX, int nTilePosY,
2240 long nTileWidth, long nTileHeight )
2241 {
2242 DrawViewShell* pViewSh = GetViewShell();
2243 if (!pViewSh)
2244 return;
2245
2246 // Scaling. Must convert from pixels to twips. We know
2247 // that VirtualDevices use a DPI of 96.
2248 // We specifically calculate these scales first as we're still
2249 // in TWIPs, and might as well minimize the number of conversions.
2250 Fraction scaleX = Fraction( nOutputWidth, 96 ) * Fraction(1440) /
2251 Fraction( nTileWidth);
2252 Fraction scaleY = Fraction( nOutputHeight, 96 ) * Fraction(1440) /
2253 Fraction( nTileHeight);
2254
2255 // svx seems to be the only component that works natively in
2256 // 100th mm rather than TWIP. It makes most sense just to
2257 // convert here and in getDocumentSize, and leave the tiled
2258 // rendering API working in TWIPs.
2259 long nTileWidthHMM = convertTwipToMm100( nTileWidth );
2260 long nTileHeightHMM = convertTwipToMm100( nTileHeight );
2261 int nTilePosXHMM = convertTwipToMm100( nTilePosX );
2262 int nTilePosYHMM = convertTwipToMm100( nTilePosY );
2263
2264 MapMode aMapMode = rDevice.GetMapMode();
2265 aMapMode.SetMapUnit( MapUnit::Map100thMM );
2266 aMapMode.SetOrigin( Point( -nTilePosXHMM,
2267 -nTilePosYHMM) );
2268 aMapMode.SetScaleX( scaleX );
2269 aMapMode.SetScaleY( scaleY );
2270
2271 rDevice.SetMapMode( aMapMode );
2272
2273 rDevice.SetOutputSizePixel( Size(nOutputWidth, nOutputHeight) );
2274
2275 Point aPoint(nTilePosXHMM, nTilePosYHMM);
2276 Size aSize(nTileWidthHMM, nTileHeightHMM);
2277 ::tools::Rectangle aRect(aPoint, aSize);
2278
2279 pViewSh->GetView()->CompleteRedraw(&rDevice, vcl::Region(aRect));
2280
2281 LokChartHelper::PaintAllChartsOnTile(rDevice, nOutputWidth, nOutputHeight,
2282 nTilePosX, nTilePosY, nTileWidth, nTileHeight);
2283 }
2284
2285 void SdXImpressDocument::setPart( int nPart )
2286 {
2287 DrawViewShell* pViewSh = GetViewShell();
2288 if (!pViewSh)
2289 return;
2290
2291 pViewSh->SwitchPage( nPart );
2292 }
2293
2294 int SdXImpressDocument::getParts()
2295 {
2296 // TODO: master pages?
2297 // Read: drviews1.cxx
2298 return mpDoc->GetSdPageCount(PageKind::Standard);
2299 }
2300
2301 int SdXImpressDocument::getPart()
2302 {
2303 DrawViewShell* pViewSh = GetViewShell();
2304 if (!pViewSh)
2305 return 0;
2306
2307 return pViewSh->GetViewShellBase().getPart();
2308 }
2309
2310 OUString SdXImpressDocument::getPartName( int nPart )
2311 {
2312 SdPage* pPage = mpDoc->GetSdPage( nPart, PageKind::Standard );
2313 if (!pPage)
2314 {
2315 SAL_WARN("sd", "DrawViewShell not available!");
2316 return OUString();
2317 }
2318
2319 return pPage->GetName();
2320 }
2321
2322 OUString SdXImpressDocument::getPartHash( int nPart )
2323 {
2324 SdPage* pPage = mpDoc->GetSdPage( nPart, PageKind::Standard );
2325 if (!pPage)
2326 {
2327 SAL_WARN("sd", "DrawViewShell not available!");
2328 return OUString();
2329 }
2330
2331 return OUString::number(pPage->GetHashCode());
2332 }
2333
2334 VclPtr<vcl::Window> SdXImpressDocument::getDocWindow()
2335 {
2336 SolarMutexGuard aGuard;
2337 DrawViewShell* pViewShell = GetViewShell();
2338 VclPtr<vcl::Window> pWindow;
2339 if (pViewShell)
2340 pWindow = pViewShell->GetActiveWindow();
2341
2342 LokChartHelper aChartHelper(pViewShell->GetViewShell());
2343 VclPtr<vcl::Window> pChartWindow = aChartHelper.GetWindow();
2344 if (pChartWindow)
2345 pWindow = pChartWindow;
2346
2347 return pWindow;
2348 }
2349
2350 void SdXImpressDocument::setPartMode( int nPartMode )
2351 {
2352 DrawViewShell* pViewSh = GetViewShell();
2353 if (!pViewSh)
2354 return;
2355
2356 PageKind aPageKind( PageKind::Standard );
2357 switch ( nPartMode )
2358 {
2359 case LOK_PARTMODE_SLIDES:
2360 break;
2361 case LOK_PARTMODE_NOTES:
2362 aPageKind = PageKind::Notes;
2363 break;
2364 }
2365 pViewSh->SetPageKind( aPageKind );
2366 }
2367
2368 Size SdXImpressDocument::getDocumentSize()
2369 {
2370 DrawViewShell* pViewSh = GetViewShell();
2371 if (!pViewSh)
2372 return Size();
2373
2374 SdrView *pSdrView = pViewSh->GetView();
2375 if (!pSdrView)
2376 return Size();
2377
2378 SdrPageView* pCurPageView = pSdrView->GetSdrPageView();
2379 if (!pCurPageView)
2380 return Size();
2381
2382 Size aSize = pCurPageView->GetPageRect().GetSize();
2383 // Convert the size in 100th mm to TWIP
2384 // See paintTile above for further info.
2385 return Size(convertMm100ToTwip(aSize.getWidth()), convertMm100ToTwip(aSize.getHeight()));
2386 }
2387
2388 OUString SdXImpressDocument::getPostIts()
2389 {
2390 boost::property_tree::ptree aAnnotations;
2391 // Return annotations on master pages too ?
2392 const sal_uInt16 nMaxPages = mpDoc->GetPageCount();
2393 SdPage* pPage;
2394 for (sal_uInt16 nPage = 0; nPage < nMaxPages; ++nPage)
2395 {
2396 pPage = static_cast<SdPage*>(mpDoc->GetPage(nPage));
2397 const sd::AnnotationVector& aPageAnnotations = pPage->getAnnotations();
2398
2399 for (const uno::Reference<office::XAnnotation>& xAnnotation : aPageAnnotations)
2400 {
2401 boost::property_tree::ptree aAnnotation;
2402 aAnnotation.put("id", sd::getAnnotationId(xAnnotation));
2403 aAnnotation.put("author", xAnnotation->getAuthor());
2404 aAnnotation.put("dateTime", utl::toISO8601(xAnnotation->getDateTime()));
2405 uno::Reference<text::XText> xText(xAnnotation->getTextRange());
2406 aAnnotation.put("text", xText->getString());
2407 aAnnotation.put("parthash", OUString::number(pPage->GetHashCode()));
2408
2409 aAnnotations.push_back(std::make_pair("", aAnnotation));
2410 }
2411 }
2412
2413 boost::property_tree::ptree aTree;
2414 aTree.add_child("comments", aAnnotations);
2415 std::stringstream aStream;
2416 boost::property_tree::write_json(aStream, aTree);
2417
2418 return OUString::fromUtf8(aStream.str().c_str());
2419 }
2420
2421 void SdXImpressDocument::initializeForTiledRendering(const css::uno::Sequence<css::beans::PropertyValue>& rArguments)
2422 {
2423 SolarMutexGuard aGuard;
2424
2425 if (DrawViewShell* pViewShell = GetViewShell())
2426 {
2427 DrawView* pDrawView = pViewShell->GetDrawView();
2428 for (sal_Int32 i = 0; i < rArguments.getLength(); ++i)
2429 {
2430 const beans::PropertyValue& rValue = rArguments[i];
2431 if (rValue.Name == ".uno:ShowBorderShadow" && rValue.Value.has<bool>())
2432 pDrawView->SetPageShadowVisible(rValue.Value.get<bool>());
2433 else if (rValue.Name == ".uno:Author" && rValue.Value.has<OUString>())
2434 pDrawView->SetAuthor(rValue.Value.get<OUString>());
2435 }
2436
2437 // Disable comments if requested
2438 SdOptions* pOptions = SD_MOD()->GetSdOptions(mpDoc->GetDocumentType());
2439 pOptions->SetShowComments(comphelper::LibreOfficeKit::isTiledAnnotations());
2440
2441 pViewShell->SetRuler(false);
2442 pViewShell->SetScrollBarsVisible(false);
2443
2444 if (sd::Window* pWindow = pViewShell->GetActiveWindow())
2445 {
2446 // get the full page size in pixels
2447 pWindow->EnableMapMode();
2448 Size aSize(pWindow->LogicToPixel(pDrawView->GetSdrPageView()->GetPage()->GetSize()));
2449 // Disable map mode, so that it's possible to send mouse event
2450 // coordinates in logic units
2451 pWindow->EnableMapMode(false);
2452
2453 // arrange UI elements again with new view size
2454 pViewShell->GetParentWindow()->SetSizePixel(aSize);
2455 pViewShell->Resize();
2456 }
2457
2458 // Forces all images to be swapped in synchronously, this
2459 // ensures that images are available when paintTile is called
2460 // (whereas with async loading images start being loaded after
2461 // we have painted the tile, resulting in an invalidate, followed
2462 // by the tile being rerendered - which is wasteful and ugly).
2463 pDrawView->SetSwapAsynchron(false);
2464 }
2465
2466 // when the "This document may contain formatting or content that cannot
2467 // be saved..." dialog appears, it is auto-cancelled with tiled rendering,
2468 // causing 'Save' being disabled; so let's always save to the original
2469 // format
2470 SvtSaveOptions().SetWarnAlienFormat(false);
2471 }
2472
2473 void SdXImpressDocument::postKeyEvent(int nType, int nCharCode, int nKeyCode)
2474 {
2475 SolarMutexGuard aGuard;
2476 SfxLokHelper::postKeyEventAsync(getDocWindow(), nType, nCharCode, nKeyCode);
2477 }
2478
2479 void SdXImpressDocument::postMouseEvent(int nType, int nX, int nY, int nCount, int nButtons, int nModifier)
2480 {
2481 SolarMutexGuard aGuard;
2482
2483 DrawViewShell* pViewShell = GetViewShell();
2484 if (!pViewShell)
2485 return;
2486
2487 double fScale = 1.0/TWIPS_PER_PIXEL;
2488
2489 // check if user hit a chart which is being edited by him
2490 LokChartHelper aChartHelper(pViewShell->GetViewShell());
2491 if (aChartHelper.postMouseEvent(nType, nX, nY,
2492 nCount, nButtons, nModifier,
2493 fScale, fScale))
2494 return;
2495
2496 // check if the user hit a chart which is being edited by someone else
2497 // and, if so, skip current mouse event
2498 if (nType != LOK_MOUSEEVENT_MOUSEMOVE)
2499 {
2500 if (LokChartHelper::HitAny(Point(nX, nY)))
2501 return;
2502 }
2503
2504 const Point aPos(Point(convertTwipToMm100(nX), convertTwipToMm100(nY)));
2505 SfxLokHelper::postMouseEventAsync(pViewShell->GetActiveWindow(), nType,
2506 aPos, nCount,
2507 MouseEventModifiers::SIMPLECLICK,
2508 nButtons, nModifier);
2509 }
2510
2511 void SdXImpressDocument::setTextSelection(int nType, int nX, int nY)
2512 {
2513 SolarMutexGuard aGuard;
2514
2515 DrawViewShell* pViewShell = GetViewShell();
2516 if (!pViewShell)
2517 return;
2518
2519 LokChartHelper aChartHelper(pViewShell->GetViewShell());
2520 if (aChartHelper.setTextSelection(nType, nX, nY))
2521 return;
2522
2523 Point aPoint(convertTwipToMm100(nX), convertTwipToMm100(nY));
2524 switch (nType)
2525 {
2526 case LOK_SETTEXTSELECTION_START:
2527 pViewShell->SetCursorMm100Position(aPoint, /*bPoint=*/false, /*bClearMark=*/false);
2528 break;
2529 case LOK_SETTEXTSELECTION_END:
2530 pViewShell->SetCursorMm100Position(aPoint, /*bPoint=*/true, /*bClearMark=*/false);
2531 break;
2532 case LOK_SETTEXTSELECTION_RESET:
2533 pViewShell->SetCursorMm100Position(aPoint, /*bPoint=*/true, /*bClearMark=*/true);
2534 break;
2535 default:
2536 assert(false);
2537 break;
2538 }
2539 }
2540
2541 OString SdXImpressDocument::getTextSelection(const char* pMimeType, OString& rUsedMimeType)
2542 {
2543 SolarMutexGuard aGuard;
2544
2545 DrawViewShell* pViewShell = GetViewShell();
2546 if (!pViewShell)
2547 return OString();
2548
2549 return pViewShell->GetTextSelection(pMimeType, rUsedMimeType);
2550 }
2551
2552 void SdXImpressDocument::setGraphicSelection(int nType, int nX, int nY)
2553 {
2554 SolarMutexGuard aGuard;
2555
2556 DrawViewShell* pViewShell = GetViewShell();
2557 if (!pViewShell)
2558 return;
2559
2560 double fScale = 1.0/TWIPS_PER_PIXEL;
2561
2562 LokChartHelper aChartHelper(pViewShell->GetViewShell());
2563 if (aChartHelper.setGraphicSelection(nType, nX, nY, fScale, fScale))
2564 return;
2565
2566 Point aPoint(convertTwipToMm100(nX), convertTwipToMm100(nY));
2567 switch (nType)
2568 {
2569 case LOK_SETGRAPHICSELECTION_START:
2570 pViewShell->SetGraphicMm100Position(/*bStart=*/true, aPoint);
2571 break;
2572 case LOK_SETGRAPHICSELECTION_END:
2573 pViewShell->SetGraphicMm100Position(/*bStart=*/false, aPoint);
2574 break;
2575 default:
2576 assert(false);
2577 break;
2578 }
2579 }
2580
2581 void SdXImpressDocument::resetSelection()
2582 {
2583 SolarMutexGuard aGuard;
2584
2585 DrawViewShell* pViewShell = GetViewShell();
2586 if (!pViewShell)
2587 return;
2588
2589 SdrView* pSdrView = pViewShell->GetView();
2590 if (!pSdrView)
2591 return;
2592
2593 if (pSdrView->IsTextEdit())
2594 {
2595 // Reset the editeng selection.
2596 pSdrView->UnmarkAll();
2597 // Finish editing.
2598 pSdrView->SdrEndTextEdit();
2599 }
2600 // Reset graphic selection.
2601 pSdrView->UnmarkAll();
2602 }
2603
2604 void SdXImpressDocument::setClipboard(const uno::Reference<datatransfer::clipboard::XClipboard>& xClipboard)
2605 {
2606 SolarMutexGuard aGuard;
2607
2608 DrawViewShell* pViewShell = GetViewShell();
2609 if (!pViewShell)
2610 return;
2611
2612 pViewShell->GetActiveWindow()->SetClipboard(xClipboard);
2613 }
2614
2615 bool SdXImpressDocument::isMimeTypeSupported()
2616 {
2617 SolarMutexGuard aGuard;
2618 DrawViewShell* pViewShell = GetViewShell();
2619 if (!pViewShell)
2620 return false;
2621
2622 TransferableDataHelper aDataHelper(TransferableDataHelper::CreateFromSystemClipboard(pViewShell->GetActiveWindow()));
2623 return EditEngine::HasValidData(aDataHelper.GetTransferable());
2624 }
2625
2626 PointerStyle SdXImpressDocument::getPointer()
2627 {
2628 SolarMutexGuard aGuard;
2629 DrawViewShell* pViewShell = GetViewShell();
2630 if (!pViewShell)
2631 return PointerStyle::Arrow;
2632
2633 Window* pWindow = pViewShell->GetActiveWindow();
2634 if (!pWindow)
2635 return PointerStyle::Arrow;
2636
2637 return pWindow->GetPointer();
2638 }
2639
2640 uno::Reference< i18n::XForbiddenCharacters > SdXImpressDocument::getForbiddenCharsTable()
2641 {
2642 uno::Reference< i18n::XForbiddenCharacters > xForb(mxForbiddenCharacters);
2643
2644 if( !xForb.is() )
2645 mxForbiddenCharacters = xForb = new SdUnoForbiddenCharsTable( mpDoc );
2646
2647 return xForb;
2648 }
2649
2650 void SdXImpressDocument::initializeDocument()
2651 {
2652 if( mbClipBoard )
2653 return;
2654
2655 switch( mpDoc->GetPageCount() )
2656 {
2657 case 1:
2658 {
2659 // nasty hack to detect clipboard document
2660 mbClipBoard = true;
2661 break;
2662 }
2663 case 0:
2664 {
2665 mpDoc->CreateFirstPages();
2666 mpDoc->StopWorkStartupDelay();
2667 break;
2668 }
2669 }
2670 }
2671
2672 SdrModel& SdXImpressDocument::getSdrModelFromUnoModel() const
2673 {
2674 OSL_ENSURE(GetDoc(), "No SdrModel in draw/Impress, should not happen");
2675 return *GetDoc(); // TTTT should be reference
2676 }
2677
2678 void SAL_CALL SdXImpressDocument::dispose()
2679 {
2680 if( mbDisposed )
2681 return;
2682
2683 ::SolarMutexGuard aGuard;
2684
2685 if( mpDoc )
2686 {
2687 EndListening( *mpDoc );
2688 mpDoc = nullptr;
2689 }
2690
2691 // Call the base class dispose() before setting the mbDisposed flag
2692 // to true. The reason for this is that if close() has not yet been
2693 // called this is done in SfxBaseModel::dispose(). At the end of
2694 // that dispose() is called again. It is important to forward this
2695 // second dispose() to the base class, too.
2696 // As a consequence the following code has to be able to be run twice.
2697 SfxBaseModel::dispose();
2698 mbDisposed = true;
2699
2700 uno::Reference< container::XNameAccess > xLinks( mxLinks );
2701 if( xLinks.is() )
2702 {
2703 uno::Reference< lang::XComponent > xComp( xLinks, uno::UNO_QUERY );
2704 if( xComp.is() )
2705 xComp->dispose();
2706
2707 xLinks = nullptr;
2708 }
2709
2710 uno::Reference< drawing::XDrawPages > xDrawPagesAccess( mxDrawPagesAccess );
2711 if( xDrawPagesAccess.is() )
2712 {
2713 uno::Reference< lang::XComponent > xComp( xDrawPagesAccess, uno::UNO_QUERY );
2714 if( xComp.is() )
2715 xComp->dispose();
2716
2717 xDrawPagesAccess = nullptr;
2718 }
2719
2720 uno::Reference< drawing::XDrawPages > xMasterPagesAccess( mxMasterPagesAccess );
2721 if( xDrawPagesAccess.is() )
2722 {
2723 uno::Reference< lang::XComponent > xComp( xMasterPagesAccess, uno::UNO_QUERY );
2724 if( xComp.is() )
2725 xComp->dispose();
2726
2727 xDrawPagesAccess = nullptr;
2728 }
2729
2730 uno::Reference< container::XNameAccess > xLayerManager( mxLayerManager );
2731 if( xLayerManager.is() )
2732 {
2733 uno::Reference< lang::XComponent > xComp( xLayerManager, uno::UNO_QUERY );
2734 if( xComp.is() )
2735 xComp->dispose();
2736
2737 xLayerManager = nullptr;
2738 }
2739
2740 uno::Reference< container::XNameContainer > xCustomPresentationAccess( mxCustomPresentationAccess );
2741 if( xCustomPresentationAccess.is() )
2742 {
2743 uno::Reference< lang::XComponent > xComp( xCustomPresentationAccess, uno::UNO_QUERY );
2744 if( xComp.is() )
2745 xComp->dispose();
2746
2747 xCustomPresentationAccess = nullptr;
2748 }
2749
2750 mxDashTable = nullptr;
2751 mxGradientTable = nullptr;
2752 mxHatchTable = nullptr;
2753 mxBitmapTable = nullptr;
2754 mxTransGradientTable = nullptr;
2755 mxMarkerTable = nullptr;
2756 mxDrawingPool = nullptr;
2757 }
2758
2759 // class SdDrawPagesAccess
2760
2761 SdDrawPagesAccess::SdDrawPagesAccess( SdXImpressDocument& rMyModel ) throw()
2762 : mpModel( &rMyModel)
2763 {
2764 }
2765
2766 SdDrawPagesAccess::~SdDrawPagesAccess() throw()
2767 {
2768 }
2769
2770 // XIndexAccess
2771 sal_Int32 SAL_CALL SdDrawPagesAccess::getCount()
2772 {
2773 ::SolarMutexGuard aGuard;
2774
2775 if( nullptr == mpModel )
2776 throw lang::DisposedException();
2777
2778 return mpModel->mpDoc->GetSdPageCount( PageKind::Standard );
2779 }
2780
2781 uno::Any SAL_CALL SdDrawPagesAccess::getByIndex( sal_Int32 Index )
2782 {
2783 ::SolarMutexGuard aGuard;
2784
2785 if( nullptr == mpModel )
2786 throw lang::DisposedException();
2787
2788 uno::Any aAny;
2789
2790 if( (Index < 0) || (Index >= mpModel->mpDoc->GetSdPageCount( PageKind::Standard ) ) )
2791 throw lang::IndexOutOfBoundsException();
2792
2793 SdPage* pPage = mpModel->mpDoc->GetSdPage( static_cast<sal_uInt16>(Index), PageKind::Standard );
2794 if( pPage )
2795 {
2796 uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
2797 aAny <<= xDrawPage;
2798 }
2799
2800 return aAny;
2801 }
2802
2803 // XNameAccess
2804 uno::Any SAL_CALL SdDrawPagesAccess::getByName( const OUString& aName )
2805 {
2806 ::SolarMutexGuard aGuard;
2807
2808 if( nullptr == mpModel )
2809 throw lang::DisposedException();
2810
2811 if( !aName.isEmpty() )
2812 {
2813 const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PageKind::Standard );
2814 sal_uInt16 nPage;
2815 for( nPage = 0; nPage < nCount; nPage++ )
2816 {
2817 SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PageKind::Standard );
2818 if(nullptr == pPage)
2819 continue;
2820
2821 if( aName == SdDrawPage::getPageApiName( pPage ) )
2822 {
2823 uno::Any aAny;
2824 uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
2825 aAny <<= xDrawPage;
2826 return aAny;
2827 }
2828 }
2829 }
2830
2831 throw container::NoSuchElementException();
2832 }
2833
2834 uno::Sequence< OUString > SAL_CALL SdDrawPagesAccess::getElementNames()
2835 {
2836 ::SolarMutexGuard aGuard;
2837
2838 if( nullptr == mpModel )
2839 throw lang::DisposedException();
2840
2841 const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PageKind::Standard );
2842 uno::Sequence< OUString > aNames( nCount );
2843 OUString* pNames = aNames.getArray();
2844
2845 sal_uInt16 nPage;
2846 for( nPage = 0; nPage < nCount; nPage++ )
2847 {
2848 SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PageKind::Standard );
2849 *pNames++ = SdDrawPage::getPageApiName( pPage );
2850 }
2851
2852 return aNames;
2853 }
2854
2855 sal_Bool SAL_CALL SdDrawPagesAccess::hasByName( const OUString& aName )
2856 {
2857 ::SolarMutexGuard aGuard;
2858
2859 if( nullptr == mpModel )
2860 throw lang::DisposedException();
2861
2862 const sal_uInt16 nCount = mpModel->mpDoc->GetSdPageCount( PageKind::Standard );
2863 sal_uInt16 nPage;
2864 for( nPage = 0; nPage < nCount; nPage++ )
2865 {
2866 SdPage* pPage = mpModel->mpDoc->GetSdPage( nPage, PageKind::Standard );
2867 if(nullptr == pPage)
2868 continue;
2869
2870 if( aName == SdDrawPage::getPageApiName( pPage ) )
2871 return true;
2872 }
2873
2874 return false;
2875 }
2876
2877 // XElementAccess
2878 uno::Type SAL_CALL SdDrawPagesAccess::getElementType()
2879 {
2880 return cppu::UnoType<drawing::XDrawPage>::get();
2881 }
2882
2883 sal_Bool SAL_CALL SdDrawPagesAccess::hasElements()
2884 {
2885 return getCount() > 0;
2886 }
2887
2888 // XDrawPages
2889
2890 /**
2891 * Creates a new page with model at the specified position.
2892 * @returns corresponding SdDrawPage
2893 */
2894 uno::Reference< drawing::XDrawPage > SAL_CALL SdDrawPagesAccess::insertNewByIndex( sal_Int32 nIndex )
2895 {
2896 ::SolarMutexGuard aGuard;
2897 comphelper::ProfileZone aZone("insertNewByIndex");
2898
2899 if( nullptr == mpModel )
2900 throw lang::DisposedException();
2901
2902 if( mpModel->mpDoc )
2903 {
2904 SdPage* pPage = mpModel->InsertSdPage( static_cast<sal_uInt16>(nIndex), false );
2905 if( pPage )
2906 {
2907 uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
2908 return xDrawPage;
2909 }
2910 }
2911 uno::Reference< drawing::XDrawPage > xDrawPage;
2912 return xDrawPage;
2913 }
2914
2915 /**
2916 * Removes the specified SdDrawPage from the model and the internal list. It
2917 * only works, if there is at least one *normal* page in the model after
2918 * removing this page.
2919 */
2920 void SAL_CALL SdDrawPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
2921 {
2922 ::SolarMutexGuard aGuard;
2923
2924 if( nullptr == mpModel || mpModel->mpDoc == nullptr )
2925 throw lang::DisposedException();
2926
2927 SdDrawDocument& rDoc = *mpModel->mpDoc;
2928
2929 sal_uInt16 nPageCount = rDoc.GetSdPageCount( PageKind::Standard );
2930 if( nPageCount > 1 )
2931 {
2932 // get pPage from xPage and determine the Id (nPos ) afterwards
2933 SdDrawPage* pSvxPage = SdDrawPage::getImplementation( xPage );
2934 if( pSvxPage )
2935 {
2936 SdPage* pPage = static_cast<SdPage*>(pSvxPage->GetSdrPage());
2937 if(pPage && ( pPage->GetPageKind() == PageKind::Standard ) )
2938 {
2939 sal_uInt16 nPage = pPage->GetPageNum();
2940
2941 SdPage* pNotesPage = static_cast< SdPage* >( rDoc.GetPage( nPage+1 ) );
2942
2943 bool bUndo = rDoc.IsUndoEnabled();
2944 if( bUndo )
2945 {
2946 // Add undo actions and delete the pages. The order of adding
2947 // the undo actions is important.
2948 rDoc.BegUndo( SdResId( STR_UNDO_DELETEPAGES ) );
2949 rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
2950 rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
2951 }
2952
2953 rDoc.RemovePage( nPage ); // the page
2954 rDoc.RemovePage( nPage ); // the notes page
2955
2956 if( bUndo )
2957 {
2958 rDoc.EndUndo();
2959 }
2960 else
2961 {
2962 delete pNotesPage;
2963 delete pPage;
2964 }
2965 }
2966 }
2967 }
2968
2969 mpModel->SetModified();
2970 }
2971
2972 // XServiceInfo
2973
2974 OUString SAL_CALL SdDrawPagesAccess::getImplementationName( )
2975 {
2976 return OUString( "SdDrawPagesAccess" );
2977 }
2978
2979 sal_Bool SAL_CALL SdDrawPagesAccess::supportsService( const OUString& ServiceName )
2980 {
2981 return cppu::supportsService(this, ServiceName);
2982 }
2983
2984 uno::Sequence< OUString > SAL_CALL SdDrawPagesAccess::getSupportedServiceNames( )
2985 {
2986 OUString aService( "com.sun.star.drawing.DrawPages" );
2987 uno::Sequence< OUString > aSeq( &aService, 1 );
2988 return aSeq;
2989 }
2990
2991 // XComponent
2992 void SAL_CALL SdDrawPagesAccess::dispose( )
2993 {
2994 mpModel = nullptr;
2995 }
2996
2997 void SAL_CALL SdDrawPagesAccess::addEventListener( const uno::Reference< lang::XEventListener >& )
2998 {
2999 OSL_FAIL( "not implemented!" );
3000 }
3001
3002 void SAL_CALL SdDrawPagesAccess::removeEventListener( const uno::Reference< lang::XEventListener >& )
3003 {
3004 OSL_FAIL( "not implemented!" );
3005 }
3006
3007 // class SdMasterPagesAccess
3008
3009 SdMasterPagesAccess::SdMasterPagesAccess( SdXImpressDocument& rMyModel ) throw()
3010 : mpModel(&rMyModel)
3011 {
3012 }
3013
3014 SdMasterPagesAccess::~SdMasterPagesAccess() throw()
3015 {
3016 }
3017
3018 // XComponent
3019 void SAL_CALL SdMasterPagesAccess::dispose( )
3020 {
3021 mpModel = nullptr;
3022 }
3023
3024 void SAL_CALL SdMasterPagesAccess::addEventListener( const uno::Reference< lang::XEventListener >& )
3025 {
3026 OSL_FAIL( "not implemented!" );
3027 }
3028
3029 void SAL_CALL SdMasterPagesAccess::removeEventListener( const uno::Reference< lang::XEventListener >& )
3030 {
3031 OSL_FAIL( "not implemented!" );
3032 }
3033
3034 // XIndexAccess
3035 sal_Int32 SAL_CALL SdMasterPagesAccess::getCount()
3036 {
3037 ::SolarMutexGuard aGuard;
3038
3039 if( nullptr == mpModel->mpDoc )
3040 throw lang::DisposedException();
3041
3042 return mpModel->mpDoc->GetMasterSdPageCount(PageKind::Standard);
3043 }
3044
3045 /**
3046 * Provides a drawing::XDrawPage interface for accessing the Masterpage at the
3047 * specified position in the model.
3048 */
3049 uno::Any SAL_CALL SdMasterPagesAccess::getByIndex( sal_Int32 Index )
3050 {
3051 ::SolarMutexGuard aGuard;
3052 comphelper::ProfileZone aZone("SdMasterPagesAccess::getByIndex");
3053
3054 if( nullptr == mpModel )
3055 throw lang::DisposedException();
3056
3057 uno::Any aAny;
3058
3059 if( (Index < 0) || (Index >= mpModel->mpDoc->GetMasterSdPageCount( PageKind::Standard ) ) )
3060 throw lang::IndexOutOfBoundsException();
3061
3062 SdPage* pPage = mpModel->mpDoc->GetMasterSdPage( static_cast<sal_uInt16>(Index), PageKind::Standard );
3063 if( pPage )
3064 {
3065 uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
3066 aAny <<= xDrawPage;
3067 }
3068
3069 return aAny;
3070 }
3071
3072 // XElementAccess
3073 uno::Type SAL_CALL SdMasterPagesAccess::getElementType()
3074 {
3075 return cppu::UnoType<drawing::XDrawPage>::get();
3076 }
3077
3078 sal_Bool SAL_CALL SdMasterPagesAccess::hasElements()
3079 {
3080 return getCount() > 0;
3081 }
3082
3083 // XDrawPages
3084 uno::Reference< drawing::XDrawPage > SAL_CALL SdMasterPagesAccess::insertNewByIndex( sal_Int32 nInsertPos )
3085 {
3086 ::SolarMutexGuard aGuard;
3087
3088 if( nullptr == mpModel )
3089 throw lang::DisposedException();
3090
3091 uno::Reference< drawing::XDrawPage > xDrawPage;
3092
3093 SdDrawDocument* pDoc = mpModel->mpDoc;
3094 if( pDoc )
3095 {
3096 // calculate internal index and check for range errors
3097 const sal_Int32 nMPageCount = pDoc->GetMasterPageCount();
3098 nInsertPos = nInsertPos * 2 + 1;
3099 if( nInsertPos < 0 || nInsertPos > nMPageCount )
3100 nInsertPos = nMPageCount;
3101
3102 // now generate a unique name for the new masterpage
3103 const OUString aStdPrefix( SdResId(STR_LAYOUT_DEFAULT_NAME) );
3104 OUString aPrefix( aStdPrefix );
3105
3106 bool bUnique = true;
3107
3108 std::vector<OUString> aPageNames;
3109 for (sal_Int32 nMaster = 1; nMaster < nMPageCount; ++nMaster)
3110 {
3111 const SdPage* pPage = static_cast<const SdPage*>(pDoc->GetMasterPage(static_cast<sal_uInt16>(nMaster)));
3112 if (!pPage)
3113 continue;
3114 aPageNames.push_back(pPage->GetName());
3115 if (aPageNames.back() == aPrefix)
3116 bUnique = false;
3117 }
3118
3119 sal_Int32 i = 0;
3120 while (!bUnique)
3121 {
3122 aPrefix = aStdPrefix + " " + OUString::number(++i);
3123 bUnique = std::find(aPageNames.begin(), aPageNames.end(), aPrefix) == aPageNames.end();
3124 }
3125
3126 OUString aLayoutName( aPrefix );
3127 aLayoutName += SD_LT_SEPARATOR;
3128 aLayoutName += STR_LAYOUT_OUTLINE;
3129
3130 // create styles
3131 static_cast<SdStyleSheetPool*>(pDoc->GetStyleSheetPool())->CreateLayoutStyleSheets( aPrefix );
3132
3133 // get the first page for initial size and border settings
3134 SdPage* pPage = mpModel->mpDoc->GetSdPage( sal_uInt16(0), PageKind::Standard );
3135 SdPage* pRefNotesPage = mpModel->mpDoc->GetSdPage( sal_uInt16(0), PageKind::Notes);
3136
3137 // create and insert new draw masterpage
3138 SdPage* pMPage = mpModel->mpDoc->AllocSdPage(true);
3139 pMPage->SetSize( pPage->GetSize() );
3140 pMPage->SetBorder( pPage->GetLeftBorder(),
3141 pPage->GetUpperBorder(),
3142 pPage->GetRightBorder(),
3143 pPage->GetLowerBorder() );
3144 pMPage->SetLayoutName( aLayoutName );
3145 pDoc->InsertMasterPage(pMPage, static_cast<sal_uInt16>(nInsertPos));
3146
3147 {
3148 // ensure default MasterPage fill
3149 pMPage->EnsureMasterPageDefaultBackground();
3150 }
3151
3152 xDrawPage.set( pMPage->getUnoPage(), uno::UNO_QUERY );
3153
3154 // create and insert new notes masterpage
3155 SdPage* pMNotesPage = mpModel->mpDoc->AllocSdPage(true);
3156 pMNotesPage->SetSize( pRefNotesPage->GetSize() );
3157 pMNotesPage->SetPageKind(PageKind::Notes);
3158 pMNotesPage->SetBorder( pRefNotesPage->GetLeftBorder(),
3159 pRefNotesPage->GetUpperBorder(),
3160 pRefNotesPage->GetRightBorder(),
3161 pRefNotesPage->GetLowerBorder() );
3162 pMNotesPage->SetLayoutName( aLayoutName );
3163 pDoc->InsertMasterPage(pMNotesPage, static_cast<sal_uInt16>(nInsertPos) + 1);
3164 pMNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, true, true);
3165 mpModel->SetModified();
3166 }
3167
3168 return xDrawPage;
3169 }
3170
3171 /**
3172 * Removes the specified SdMasterPage from the model and the internal list. It
3173 * only works, if there is no *normal* page using this page as MasterPage in
3174 * the model.
3175 */
3176 void SAL_CALL SdMasterPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
3177 {
3178 ::SolarMutexGuard aGuard;
3179
3180 if( nullptr == mpModel || mpModel->mpDoc == nullptr )
3181 throw lang::DisposedException();
3182
3183 SdMasterPage* pSdPage = SdMasterPage::getImplementation( xPage );
3184 if(pSdPage == nullptr)
3185 return;
3186
3187 SdPage* pPage = dynamic_cast< SdPage* > (pSdPage->GetSdrPage());
3188
3189 DBG_ASSERT( pPage && pPage->IsMasterPage(), "SdMasterPage is not masterpage?");
3190
3191 if( !pPage || !pPage->IsMasterPage() || (mpModel->mpDoc->GetMasterPageUserCount(pPage) > 0))
3192 return; //Todo: this should be excepted
3193
3194 // only standard pages can be removed directly
3195 if( pPage->GetPageKind() != PageKind::Standard )
3196 return;
3197
3198 sal_uInt16 nPage = pPage->GetPageNum();
3199
3200 SdDrawDocument& rDoc = *mpModel->mpDoc;
3201
3202 SdPage* pNotesPage = static_cast< SdPage* >( rDoc.GetMasterPage( nPage+1 ) );
3203
3204 bool bUndo = rDoc.IsUndoEnabled();
3205 if( bUndo )
3206 {
3207 // Add undo actions and delete the pages. The order of adding
3208 // the undo actions is important.
3209 rDoc.BegUndo( SdResId( STR_UNDO_DELETEPAGES ) );
3210 rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
3211 rDoc.AddUndo(rDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
3212 }
3213
3214 // remove both pages
3215 rDoc.RemoveMasterPage( nPage );
3216 rDoc.RemoveMasterPage( nPage );
3217
3218 if( bUndo )
3219 {
3220 rDoc.EndUndo();
3221 }
3222 else
3223 {
3224 delete pNotesPage;
3225 delete pPage;
3226 }
3227 }
3228
3229 // XServiceInfo
3230
3231 OUString SAL_CALL SdMasterPagesAccess::getImplementationName( )
3232 {
3233 return OUString( "SdMasterPagesAccess" );
3234 }
3235
3236 sal_Bool SAL_CALL SdMasterPagesAccess::supportsService( const OUString& ServiceName )
3237 {
3238 return cppu::supportsService(this, ServiceName);
3239 }
3240
3241 uno::Sequence< OUString > SAL_CALL SdMasterPagesAccess::getSupportedServiceNames( )
3242 {
3243 OUString aService( "com.sun.star.drawing.MasterPages" );
3244 uno::Sequence< OUString > aSeq( &aService, 1 );
3245 return aSeq;
3246 }
3247
3248 // class SdDocLinkTargets
3249
3250 SdDocLinkTargets::SdDocLinkTargets( SdXImpressDocument& rMyModel ) throw()
3251 : mpModel( &rMyModel )
3252 {
3253 }
3254
3255 SdDocLinkTargets::~SdDocLinkTargets() throw()
3256 {
3257 }
3258
3259 // XComponent
3260 void SAL_CALL SdDocLinkTargets::dispose( )
3261 {
3262 mpModel = nullptr;
3263 }
3264
3265 void SAL_CALL SdDocLinkTargets::addEventListener( const uno::Reference< lang::XEventListener >& )
3266 {
3267 OSL_FAIL( "not implemented!" );
3268 }
3269
3270 void SAL_CALL SdDocLinkTargets::removeEventListener( const uno::Reference< lang::XEventListener >& )
3271 {
3272 OSL_FAIL( "not implemented!" );
3273 }
3274
3275 // XNameAccess
3276 uno::Any SAL_CALL SdDocLinkTargets::getByName( const OUString& aName )
3277 {
3278 ::SolarMutexGuard aGuard;
3279
3280 if( nullptr == mpModel )
3281 throw lang::DisposedException();
3282
3283 SdPage* pPage = FindPage( aName );
3284
3285 if( pPage == nullptr )
3286 throw container::NoSuchElementException();
3287
3288 uno::Any aAny;
3289
3290 uno::Reference< beans::XPropertySet > xProps( pPage->getUnoPage(), uno::UNO_QUERY );
3291 if( xProps.is() )
3292 aAny <<= xProps;
3293
3294 return aAny;
3295 }
3296
3297 uno::Sequence< OUString > SAL_CALL SdDocLinkTargets::getElementNames()
3298 {
3299 ::SolarMutexGuard aGuard;
3300
3301 if( nullptr == mpModel )
3302 throw lang::DisposedException();
3303
3304 SdDrawDocument* pDoc = mpModel->GetDoc();
3305 if( pDoc == nullptr )
3306 {
3307 uno::Sequence< OUString > aSeq;
3308 return aSeq;
3309 }
3310
3311 if( pDoc->GetDocumentType() == DocumentType::Draw )
3312 {
3313 const sal_uInt16 nMaxPages = pDoc->GetSdPageCount( PageKind::Standard );
3314 const sal_uInt16 nMaxMasterPages = pDoc->GetMasterSdPageCount( PageKind::Standard );
3315
3316 uno::Sequence< OUString > aSeq( nMaxPages + nMaxMasterPages );
3317 OUString* pStr = aSeq.getArray();
3318
3319 sal_uInt16 nPage;
3320 // standard pages
3321 for( nPage = 0; nPage < nMaxPages; nPage++ )
3322 *pStr++ = pDoc->GetSdPage( nPage, PageKind::Standard )->GetName();
3323
3324 // master pages
3325 for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
3326 *pStr++ = pDoc->GetMasterSdPage( nPage, PageKind::Standard )->GetName();
3327 return aSeq;
3328 }
3329 else
3330 {
3331 const sal_uInt16 nMaxPages = pDoc->GetPageCount();
3332 const sal_uInt16 nMaxMasterPages = pDoc->GetMasterPageCount();
3333
3334 uno::Sequence< OUString > aSeq( nMaxPages + nMaxMasterPages );
3335 OUString* pStr = aSeq.getArray();
3336
3337 sal_uInt16 nPage;
3338 // standard pages
3339 for( nPage = 0; nPage < nMaxPages; nPage++ )
3340 *pStr++ = static_cast<SdPage*>(pDoc->GetPage( nPage ))->GetName();
3341
3342 // master pages
3343 for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
3344 *pStr++ = static_cast<SdPage*>(pDoc->GetMasterPage( nPage ))->GetName();
3345 return aSeq;
3346 }
3347 }
3348
3349 sal_Bool SAL_CALL SdDocLinkTargets::hasByName( const OUString& aName )
3350 {
3351 ::SolarMutexGuard aGuard;
3352
3353 if( nullptr == mpModel )
3354 throw lang::DisposedException();
3355
3356 return FindPage( aName ) != nullptr;
3357 }
3358
3359 // container::XElementAccess
3360 uno::Type SAL_CALL SdDocLinkTargets::getElementType()
3361 {
3362 return cppu::UnoType<beans::XPropertySet>::get();
3363 }
3364
3365 sal_Bool SAL_CALL SdDocLinkTargets::hasElements()
3366 {
3367 ::SolarMutexGuard aGuard;
3368
3369 if( nullptr == mpModel )
3370 throw lang::DisposedException();
3371
3372 return mpModel->GetDoc() != nullptr;
3373 }
3374
3375 SdPage* SdDocLinkTargets::FindPage( const OUString& rName ) const
3376 {
3377 SdDrawDocument* pDoc = mpModel->GetDoc();
3378 if( pDoc == nullptr )
3379 return nullptr;
3380
3381 const sal_uInt16 nMaxPages = pDoc->GetPageCount();
3382 const sal_uInt16 nMaxMasterPages = pDoc->GetMasterPageCount();
3383
3384 sal_uInt16 nPage;
3385 SdPage* pPage;
3386
3387 const bool bDraw = pDoc->GetDocumentType() == DocumentType::Draw;
3388
3389 // standard pages
3390 for( nPage = 0; nPage < nMaxPages; nPage++ )
3391 {
3392 pPage = static_cast<SdPage*>(pDoc->GetPage( nPage ));
3393 if( (pPage->GetName() == rName) && (!bDraw || (pPage->GetPageKind() == PageKind::Standard)) )
3394 return pPage;
3395 }
3396
3397 // master pages
3398 for( nPage = 0; nPage < nMaxMasterPages; nPage++ )
3399 {
3400 pPage = static_cast<SdPage*>(pDoc->GetMasterPage( nPage ));
3401 if( (pPage->GetName() == rName) && (!bDraw || (pPage->GetPageKind() == PageKind::Standard)) )
3402 return pPage;
3403 }
3404
3405 return nullptr;
3406 }
3407
3408 // XServiceInfo
3409 OUString SAL_CALL SdDocLinkTargets::getImplementationName()
3410 {
3411 return OUString( "SdDocLinkTargets" );
3412 }
3413
3414 sal_Bool SAL_CALL SdDocLinkTargets::supportsService( const OUString& ServiceName )
3415 {
3416 return cppu::supportsService( this, ServiceName );
3417 }
3418
3419 uno::Sequence< OUString > SAL_CALL SdDocLinkTargets::getSupportedServiceNames()
3420 {
3421 const OUString aSN( "com.sun.star.document.LinkTargets" );
3422 uno::Sequence< OUString > aSeq( &aSN, 1 );
3423 return aSeq;
3424 }
3425
3426 rtl::Reference< SdXImpressDocument > SdXImpressDocument::GetModel( SdDrawDocument const & rDocument )
3427 {
3428 rtl::Reference< SdXImpressDocument > xRet;
3429 ::sd::DrawDocShell* pDocShell(rDocument.GetDocSh());
3430 if( pDocShell )
3431 {
3432 uno::Reference<frame::XModel> xModel(pDocShell->GetModel());
3433
3434 xRet.set( dynamic_cast< SdXImpressDocument* >( xModel.get() ) );
3435 }
3436
3437 return xRet;
3438 }
3439
3440 void NotifyDocumentEvent( SdDrawDocument const & rDocument, const OUString& rEventName )
3441 {
3442 rtl::Reference< SdXImpressDocument > xModel( SdXImpressDocument::GetModel( rDocument ) );
3443
3444 if( xModel.is() )
3445 {
3446 uno::Reference< uno::XInterface > xSource( static_cast<uno::XWeak*>( xModel.get() ) );
3447 css::document::EventObject aEvent( xSource, rEventName );
3448 xModel->notifyEvent(aEvent );
3449 }
3450 }
3451
3452 void NotifyDocumentEvent( SdDrawDocument const & rDocument, const OUString& rEventName, const uno::Reference< uno::XInterface >& xSource )
3453 {
3454 rtl::Reference< SdXImpressDocument > xModel( SdXImpressDocument::GetModel( rDocument ) );
3455
3456 if( xModel.is() )
3457 {
3458 css::document::EventObject aEvent( xSource, rEventName );
3459 xModel->notifyEvent(aEvent );
3460 }
3461 }
3462
3463 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE