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