xref: /aoo42x/main/sd/source/core/drawdoc.cxx (revision 3e413e36)
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 "PageListWatcher.hxx"
28 #include <com/sun/star/text/WritingMode.hpp>
29 #include <com/sun/star/document/PrinterIndependentLayout.hpp>
30 #include <com/sun/star/i18n/ScriptType.hpp>
31 #include <editeng/forbiddencharacterstable.hxx>
32 
33 #include <svx/svxids.hrc>
34 #include <svl/srchitem.hxx>
35 #include <editeng/eeitem.hxx>
36 #include <editeng/scriptspaceitem.hxx>
37 
38 #include <unotools/useroptions.hxx>
39 
40 #include <sfx2/printer.hxx>
41 #include <sfx2/app.hxx>
42 #include <sfx2/linkmgr.hxx>
43 #include <svx/dialogs.hrc>
44 #include "Outliner.hxx"
45 #include "app.hxx"
46 #include <editeng/eeitem.hxx>
47 #include <editeng/editstat.hxx>
48 #include <editeng/fontitem.hxx>
49 #include <svl/flagitem.hxx>
50 #include <svx/svdoattr.hxx>
51 #include <svx/svdotext.hxx>
52 #include <editeng/bulitem.hxx>
53 #include <editeng/numitem.hxx>
54 #include <svx/svditer.hxx>
55 #include <editeng/unolingu.hxx>
56 #include <svl/itempool.hxx>
57 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
58 #include <svx/xtable.hxx>
59 #include <com/sun/star/linguistic2/XHyphenator.hpp>
60 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
61 #include <com/sun/star/beans/XPropertySet.hpp>
62 #include <editeng/outlobj.hxx>
63 #include <unotools/saveopt.hxx>
64 #include <comphelper/extract.hxx>
65 #include <i18npool/mslangid.hxx>
66 #include <unotools/charclass.hxx>
67 #include <comphelper/processfactory.hxx>
68 #ifndef _SVTOOLS_PATHOPTIONS_HXX_
69 #include <unotools/pathoptions.hxx>
70 #endif
71 #include <unotools/lingucfg.hxx>
72 #include <unotools/linguprops.hxx>
73 
74 #include "eetext.hxx"
75 #include "drawdoc.hxx"
76 #include "sdpage.hxx"
77 #include "pglink.hxx"
78 #include "sdattr.hxx"
79 #include "glob.hrc"
80 #include "glob.hxx"
81 #include "stlpool.hxx"
82 #include "sdiocmpt.hxx"
83 #include "sdresid.hxx"
84 #include "cusshow.hxx"
85 #include "../ui/inc/DrawDocShell.hxx"
86 #include "../ui/inc/GraphicDocShell.hxx"
87 #include "../ui/inc/sdxfer.hxx"
88 #include "../ui/inc/ViewShell.hxx"
89 #include "../ui/inc/optsitem.hxx"
90 #include "../ui/inc/FrameView.hxx"
91 
92 // #90477#
93 #include <tools/tenccvt.hxx>
94 
95 using ::rtl::OUString;
96 using namespace ::sd;
97 using namespace ::com::sun::star;
98 using namespace ::com::sun::star::uno;
99 using namespace ::com::sun::star::lang;
100 using namespace ::com::sun::star::linguistic2;
101 
102 //////////////////////////////////////////////////////////////////////////////
103 
104 TYPEINIT1( SdDrawDocument, FmFormModel );
105 
106 SdDrawDocument* SdDrawDocument::pDocLockedInsertingLinks = NULL;
107 
108 //////////////////////////////////////////////////////////////////////////////
109 
PresentationSettings()110 PresentationSettings::PresentationSettings()
111 :	mbAll( true ),
112 	mbEndless( false ),
113 	mbCustomShow(false),
114 	mbManual( false ),
115 	mbMouseVisible( false ),
116 	mbMouseAsPen( false ),
117 	mbLockedPages( false ),
118 	mbAlwaysOnTop( false ),
119 	mbFullScreen( true ),
120 	mbAnimationAllowed( true ),
121 	mnPauseTimeout( 10 ),
122 	mbShowPauseLogo( false ),
123 	mbStartWithNavigator(false)
124 {
125 }
126 
127 // ---------------------------------------------------------------------------
128 
PresentationSettings(const PresentationSettings & r)129 PresentationSettings::PresentationSettings( const PresentationSettings& r )
130 :	maPresPage( r.maPresPage ),
131 	mbAll( r.mbAll ),
132 	mbEndless( r.mbEndless ),
133 	mbCustomShow( r.mbCustomShow ),
134 	mbManual( r.mbManual ),
135 	mbMouseVisible( r.mbMouseVisible ),
136 	mbMouseAsPen( r.mbMouseAsPen ),
137 	mbLockedPages( r.mbLockedPages ),
138 	mbAlwaysOnTop( r.mbAlwaysOnTop ),
139 	mbFullScreen( r.mbFullScreen ),
140 	mbAnimationAllowed( r.mbAnimationAllowed ),
141 	mnPauseTimeout( r.mnPauseTimeout ),
142 	mbShowPauseLogo( r.mbShowPauseLogo ),
143 	mbStartWithNavigator( r.mbStartWithNavigator )
144 {
145 }
146 
147 // ---------------------------------------------------------------------------
148 
SdDrawDocument(DocumentType eType,SfxObjectShell * pDrDocSh)149 SdDrawDocument::SdDrawDocument(DocumentType eType, SfxObjectShell* pDrDocSh)
150 : FmFormModel( SvtPathOptions().GetPalettePath(), NULL, pDrDocSh )
151 , bReadOnly(sal_False)
152 , mpOutliner(NULL)
153 , mpInternalOutliner(NULL)
154 , mpWorkStartupTimer(NULL)
155 , mpOnlineSpellingTimer(NULL)
156 , mpOnlineSpellingList(NULL)
157 , mpOnlineSearchItem(NULL)
158 , mpFrameViewList( new List() )
159 , mpCustomShowList(NULL)
160 , mpDocSh(static_cast< ::sd::DrawDocShell*>(pDrDocSh))
161 , mpCreatingTransferable( NULL )
162 , mbHasOnlineSpellErrors(sal_False)
163 , mbInitialOnlineSpellingEnabled(sal_True)
164 , mbNewOrLoadCompleted(sal_False)
165 , mbStartWithPresentation( false )
166 , meLanguage( LANGUAGE_SYSTEM )
167 , meLanguageCJK( LANGUAGE_SYSTEM )
168 , meLanguageCTL( LANGUAGE_SYSTEM )
169 , mePageNumType(SVX_ARABIC)
170 , mbAllocDocSh(sal_False)
171 , meDocType(eType)
172 , mpCharClass(NULL)
173 , mpLocale(NULL)
174 , mpDrawPageListWatcher(0)
175 , mpMasterPageListWatcher(0)
176 {
177 	// #109538#
178 	mpDrawPageListWatcher = ::std::auto_ptr<ImpDrawPageListWatcher>(
179         new ImpDrawPageListWatcher(*this));
180 	mpMasterPageListWatcher = ::std::auto_ptr<ImpMasterPageListWatcher>(
181         new ImpMasterPageListWatcher(*this));
182 
183 	SetObjectShell(pDrDocSh);		// for the VCDrawModel
184 
185 	if (mpDocSh)
186 	{
187 		SetSwapGraphics(sal_True);
188 	}
189 
190 	// set measurement unit (of App) and scale (of SdMod)
191 	sal_Int32 nX, nY;
192 	SdOptions* pOptions = SD_MOD()->GetSdOptions(meDocType);
193 	pOptions->GetScale( nX, nY );
194 
195     // #92067# Allow UI scale only for draw documents.
196     if( eType == DOCUMENT_TYPE_DRAW )
197         SetUIUnit( (FieldUnit)pOptions->GetMetric(), Fraction( nX, nY ) );	// user-defined
198     else
199         SetUIUnit( (FieldUnit)pOptions->GetMetric(), Fraction( 1, 1 ) );	// default
200 
201 	SetScaleUnit(MAP_100TH_MM);
202 	SetScaleFraction(Fraction(1, 1));
203 	SetDefaultFontHeight(847);     // 24p
204 
205 	pItemPool->SetDefaultMetric(SFX_MAPUNIT_100TH_MM);
206 	pItemPool->FreezeIdRanges();
207 	SetTextDefaults();
208 
209 	// also the DrawingEngine needs to know where it is
210 	FmFormModel::SetStyleSheetPool( new SdStyleSheetPool( GetPool(), this ) );
211 
212 	// Set the StyleSheetPool to the DrawOutliner, in order to read text objects
213 	// correctly. The link to the StyleRequest handler of the document will be
214 	// set first in NewOrLoadCompleted, because only then all templates exist.
215 	SdrOutliner& rOutliner = GetDrawOutliner();
216 	rOutliner.SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool());
217 	SetCalcFieldValueHdl( &rOutliner );
218 
219 	// set linguistic options
220 	{
221         const SvtLinguConfig    aLinguConfig;
222 		SvtLinguOptions			aOptions;
223 		aLinguConfig.GetOptions( aOptions );
224 
225 		SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage,
226             ::com::sun::star::i18n::ScriptType::LATIN), EE_CHAR_LANGUAGE );
227 		SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CJK,
228             ::com::sun::star::i18n::ScriptType::ASIAN), EE_CHAR_LANGUAGE_CJK );
229 		SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CTL,
230             ::com::sun::star::i18n::ScriptType::COMPLEX), EE_CHAR_LANGUAGE_CTL );
231 
232 		mbOnlineSpell = aOptions.bIsSpellAuto;
233 	}
234 
235 	LanguageType eRealLanguage = MsLangId::getRealLanguage( meLanguage );
236 	mpLocale = new ::com::sun::star::lang::Locale( MsLangId::convertLanguageToLocale( eRealLanguage ));
237 	mpCharClass = new CharClass( *mpLocale );
238 
239 	// If the current application language is a language that uses right-to-left text...
240 	LanguageType eRealCTLLanguage = Application::GetSettings().GetLanguage();
241 	if( MsLangId::isRightToLeft( eRealCTLLanguage ) )
242 	{
243 		// ... then we have to set this as a default
244 		SetDefaultWritingMode( ::com::sun::star::text::WritingMode_RL_TB );
245 	}
246 
247 	// for korean and japanese languages we have a different default for apply spacing between asian, latin and ctl text
248 	if( ( LANGUAGE_KOREAN  == eRealCTLLanguage ) || ( LANGUAGE_KOREAN_JOHAB == eRealCTLLanguage ) || ( LANGUAGE_JAPANESE == eRealCTLLanguage ) )
249 	{
250         GetPool().GetSecondaryPool()->SetPoolDefaultItem( SvxScriptSpaceItem( sal_False, EE_PARA_ASIANCJKSPACING ) );
251 	}
252 
253 	// set DefTab and SpellOptions
254 	// now at the module (SD)
255 	sal_uInt16 nDefTab = pOptions->GetDefTab();
256 	SetDefaultTabulator( nDefTab );
257 
258 	try
259 	{
260 	    Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
261 	    if ( xSpellChecker.is() )
262 		    rOutliner.SetSpeller( xSpellChecker );
263 
264 	    Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
265 	    if( xHyphenator.is() )
266 		    rOutliner.SetHyphenator( xHyphenator );
267 
268 		SetForbiddenCharsTable( new SvxForbiddenCharactersTable( ::comphelper::getProcessServiceFactory() ) );
269 	}
270 	catch(...)
271 	{
272 		DBG_ERROR("Can't get SpellChecker");
273 	}
274 
275 	rOutliner.SetDefaultLanguage( Application::GetSettings().GetLanguage() );
276 
277 	if (mpDocSh)
278 	{
279         sfx2::LinkManager *linkMgr = new sfx2::LinkManager(mpDocSh);
280         linkMgr->SetAutoAskUpdateAllLinks();
281 		SetLinkManager( linkMgr );
282 	}
283 
284 	sal_uLong nCntrl = rOutliner.GetControlWord();
285 	nCntrl |= EE_CNTRL_ALLOWBIGOBJS;
286 	nCntrl |= EE_CNTRL_URLSFXEXECUTE;
287 
288 	if (mbOnlineSpell)
289 		nCntrl |= EE_CNTRL_ONLINESPELLING;
290 	else
291 		nCntrl &= ~EE_CNTRL_ONLINESPELLING;
292 
293 	nCntrl &= ~ EE_CNTRL_ULSPACESUMMATION;
294     if ( meDocType != DOCUMENT_TYPE_IMPRESS )
295         SetSummationOfParagraphs( sal_False );
296     else
297     {
298         SetSummationOfParagraphs( pOptions->IsSummationOfParagraphs() );
299     	if ( pOptions->IsSummationOfParagraphs() )
300 	    	nCntrl |= EE_CNTRL_ULSPACESUMMATION;
301     }
302 	rOutliner.SetControlWord(nCntrl);
303 
304     // Initialize the printer independent layout mode.
305     SetPrinterIndependentLayout (pOptions->GetPrinterIndependentLayout());
306 
307 	// Set the StyleSheetPool to the HitTestOutliner.
308 	// The link to the StyleRequest handler of the document will be set
309 	// first in NewOrLoadCompleted, because only then all templates exist.
310 	SfxItemSet aSet2( pHitTestOutliner->GetEmptyItemSet() );
311 	pHitTestOutliner->SetStyleSheetPool( (SfxStyleSheetPool*)GetStyleSheetPool() );
312 
313 	SetCalcFieldValueHdl( pHitTestOutliner );
314 
315 	try
316 	{
317 	    Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
318 	    if ( xSpellChecker.is() )
319 		    pHitTestOutliner->SetSpeller( xSpellChecker );
320 
321 	    Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
322 	    if( xHyphenator.is() )
323 		    pHitTestOutliner->SetHyphenator( xHyphenator );
324 	}
325 	catch(...)
326 	{
327 		DBG_ERROR("Can't get SpellChecker");
328 	}
329 
330 	pHitTestOutliner->SetDefaultLanguage( Application::GetSettings().GetLanguage() );
331 
332 	sal_uLong nCntrl2 = pHitTestOutliner->GetControlWord();
333 	nCntrl2 |= EE_CNTRL_ALLOWBIGOBJS;
334 	nCntrl2 |= EE_CNTRL_URLSFXEXECUTE;
335 	nCntrl2 &= ~EE_CNTRL_ONLINESPELLING;
336 
337 	nCntrl2 &= ~ EE_CNTRL_ULSPACESUMMATION;
338 	if ( pOptions->IsSummationOfParagraphs() )
339 		nCntrl2 |= EE_CNTRL_ULSPACESUMMATION;
340 
341 	pHitTestOutliner->SetControlWord( nCntrl2 );
342 
343 	/**************************************************************************
344 	* Create layer
345 	*
346 	* The following default layer will created on Pages and MasterPages:
347 	*
348 	* Layer STR_LAYOUT	: Default layer for all drawing objects
349 	*
350 	* Layer STR_BCKGRND	: Background of the MasterPage
351 	*			  (it's currently not used on normal Pages)
352 	*
353 	* Layer STR_BCKGRNDOBJ	: Objects on the background of the MasterPage
354 	*			  (it's currently not used on normal Pages)
355 	*
356 	* Layer STR_CONTROLS 	: Default layer for Controls
357 	*
358 	**************************************************************************/
359 	{
360 		String aControlLayerName( SdResId(STR_LAYER_CONTROLS) );
361 
362 		SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
363 		rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_LAYOUT)) );
364 		rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_BCKGRND)) );
365 		rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_BCKGRNDOBJ)) );
366 		rLayerAdmin.NewLayer( aControlLayerName );
367 		rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_MEASURELINES)) );
368 
369 		rLayerAdmin.SetControlLayerName(aControlLayerName);
370 	}
371 
372 
373 }
374 
375 /*************************************************************************
376 |*
377 |* Destructor
378 |*
379 \************************************************************************/
380 
~SdDrawDocument()381 SdDrawDocument::~SdDrawDocument()
382 {
383 	Broadcast(SdrHint(HINT_MODELCLEARED));
384 
385 	if (mpWorkStartupTimer)
386 	{
387 		if ( mpWorkStartupTimer->IsActive() )
388 			mpWorkStartupTimer->Stop();
389 
390 		delete mpWorkStartupTimer;
391 		mpWorkStartupTimer = NULL;
392 	}
393 
394 	StopOnlineSpelling();
395 	delete mpOnlineSearchItem;
396 	mpOnlineSearchItem = NULL;
397 
398 	CloseBookmarkDoc();
399 	SetAllocDocSh(sal_False);
400 
401 	// #116168#
402 	ClearModel(sal_True);
403 
404 	if (pLinkManager)
405 	{
406 		// deallocate BaseLinks
407 		if ( pLinkManager->GetLinks().Count() )
408 		{
409 			pLinkManager->Remove( 0, pLinkManager->GetLinks().Count() );
410 		}
411 
412 		delete pLinkManager;
413 		pLinkManager = NULL;
414 	}
415 
416 	::sd::FrameView* pFrameView = NULL;
417 
418 	for (sal_uLong i = 0; i < mpFrameViewList->Count(); i++)
419 	{
420 		// if necessary delete FrameViews
421 		pFrameView =
422             static_cast< ::sd::FrameView*>(mpFrameViewList->GetObject(i));
423 
424 		if (pFrameView)
425 			delete pFrameView;
426 	}
427 
428 	delete mpFrameViewList;
429 	mpFrameViewList = NULL;
430 
431 	if (mpCustomShowList)
432 	{
433 		for (sal_uLong j = 0; j < mpCustomShowList->Count(); j++)
434 		{
435 			// if necessary delete CustomShows
436 			SdCustomShow* pCustomShow = (SdCustomShow*) mpCustomShowList->GetObject(j);
437 			delete pCustomShow;
438 		}
439 
440 		delete mpCustomShowList;
441 		mpCustomShowList = NULL;
442 	}
443 
444 	delete mpOutliner;
445 	mpOutliner = NULL;
446 
447 	delete mpInternalOutliner;
448 	mpInternalOutliner = NULL;
449 
450 	delete mpLocale;
451 	mpLocale = NULL;
452 
453 	delete mpCharClass;
454 	mpCharClass = NULL;
455 }
456 
457 /*************************************************************************
458 |*
459 |* This methods creates a new document (SdDrawDocument) and gives back a
460 |* pointer to it. The Drawing Engine uses this method to be able to put
461 |* the document or parts of it into Clipboard/DragServer.
462 |*
463 \************************************************************************/
464 
AllocModel() const465 SdrModel* SdDrawDocument::AllocModel() const
466 {
467 	SdDrawDocument* pNewModel = NULL;
468 
469 	if( mpCreatingTransferable )
470 	{
471 		// the document will created for Drag&Drop/Clipboard,
472 		// for this the document has to know a DocShell (SvPersist)
473         SfxObjectShell*   pObj = NULL;
474 		::sd::DrawDocShell*		pNewDocSh = NULL;
475 
476     	if( meDocType == DOCUMENT_TYPE_IMPRESS )
477     		mpCreatingTransferable->SetDocShell( new ::sd::DrawDocShell(
478                 SFX_CREATE_MODE_EMBEDDED, sal_True, meDocType ) );
479 		else
480 	        mpCreatingTransferable->SetDocShell( new ::sd::GraphicDocShell(
481                 SFX_CREATE_MODE_EMBEDDED, sal_True, meDocType ) );
482 
483         pNewDocSh = static_cast< ::sd::DrawDocShell*>( pObj = mpCreatingTransferable->GetDocShell() );
484 		pNewDocSh->DoInitNew( NULL );
485 		pNewModel = pNewDocSh->GetDoc();
486 
487 		// only necessary for Clipboard,
488 		// for Drag&Drop this will happen in DragServer
489 		SdStyleSheetPool* pOldStylePool = (SdStyleSheetPool*) GetStyleSheetPool();
490 		SdStyleSheetPool* pNewStylePool = (SdStyleSheetPool*) pNewModel->GetStyleSheetPool();
491 
492 		pNewStylePool->CopyGraphicSheets(*pOldStylePool);
493 		pNewStylePool->CopyCellSheets(*pOldStylePool);
494 		pNewStylePool->CopyTableStyles(*pOldStylePool);
495 
496 
497 		for (sal_uInt16 i = 0; i < GetMasterSdPageCount(PK_STANDARD); i++)
498 		{
499 			// take all layouts of the MasterPage
500 			String aOldLayoutName(((SdDrawDocument*) this)->GetMasterSdPage(i, PK_STANDARD)->GetLayoutName());
501 			aOldLayoutName.Erase( aOldLayoutName.SearchAscii( SD_LT_SEPARATOR ) );
502 			SdStyleSheetVector aCreatedSheets;
503 			pNewStylePool->CopyLayoutSheets(aOldLayoutName, *pOldStylePool, aCreatedSheets );
504 		}
505 
506 		pNewModel->NewOrLoadCompleted( DOC_LOADED );  // loaded from source document
507 	}
508 	else if( mbAllocDocSh )
509 	{
510 		// a DocShell will be created which will be returned with GetAllocedDocSh()
511 		SdDrawDocument* pDoc = (SdDrawDocument*) this;
512 		pDoc->SetAllocDocSh(sal_False);
513 		pDoc->mxAllocedDocShRef = new ::sd::DrawDocShell(
514             SFX_CREATE_MODE_EMBEDDED, sal_True, meDocType);
515 		pDoc->mxAllocedDocShRef->DoInitNew(NULL);
516 		pNewModel = pDoc->mxAllocedDocShRef->GetDoc();
517 	}
518 	else
519 	{
520 		pNewModel = new SdDrawDocument(meDocType, NULL);
521 	}
522 
523 	return pNewModel;
524 }
525 
526 /*************************************************************************
527 |*
528 |* This methods creates a new page (SdPage) and gives back a pointer to it.
529 |* The Drawing Engine uses this method when loading to create pages (whose
530 |* types are not knowed for it because these are DERIVATIONS of SdrPage).
531 |*
532 \************************************************************************/
533 
AllocPage(FASTBOOL bMasterPage)534 SdrPage* SdDrawDocument::AllocPage(FASTBOOL bMasterPage)
535 {
536 	return new SdPage(*this, NULL, (sal_Bool)bMasterPage);
537 }
538 
539 /*************************************************************************
540 |*
541 |* SetChanged(), the modele was changed
542 |*
543 \************************************************************************/
544 
SetChanged(sal_Bool bFlag)545 void SdDrawDocument::SetChanged(sal_Bool bFlag)
546 {
547 	if (mpDocSh)
548 	{
549 		if (mbNewOrLoadCompleted && mpDocSh->IsEnableSetModified())
550 		{
551 			// forward to baseclass
552 			FmFormModel::SetChanged(bFlag);
553 
554 			// pass to ObjectShell
555 			mpDocSh->SetModified(bFlag);
556 		}
557 	}
558 	else
559 	{
560 		// forward to baseclass
561 		FmFormModel::SetChanged(bFlag);
562 	}
563 }
564 
565 /*************************************************************************
566 |*
567 |* NbcSetChanged(), the model changed, don't call anybody else
568 |*
569 \************************************************************************/
570 
NbcSetChanged(sal_Bool bFlag)571 void SdDrawDocument::NbcSetChanged(sal_Bool bFlag)
572 {
573     // #100237# forward to baseclass
574     FmFormModel::SetChanged(bFlag);
575 }
576 
577 /*************************************************************************
578 |*
579 |* NewOrLoadCompleted
580 |*
581 |* Will be called when the document was loaded respectively when it is
582 |* certain that it will not be loaded any longer.
583 |*
584 \************************************************************************/
585 
NewOrLoadCompleted(DocCreationMode eMode)586 void SdDrawDocument::NewOrLoadCompleted(DocCreationMode eMode)
587 {
588 	if (eMode == NEW_DOC)
589 	{
590 		// new document:
591 		// create Presentation and default templates,
592 		// create pool for virtual controls
593 		CreateLayoutTemplates();
594 		CreateDefaultCellStyles();
595 
596 		static_cast< SdStyleSheetPool* >( mxStyleSheetPool.get() )->CreatePseudosIfNecessary();
597 	}
598 	else if (eMode == DOC_LOADED)
599 	{
600 			// document was loaded:
601 
602 		CheckMasterPages();
603 
604 		if ( GetMasterSdPageCount(PK_STANDARD) > 1 )
605 			RemoveUnnecessaryMasterPages( NULL, sal_True, sal_False );
606 
607 		for ( sal_uInt16 i = 0; i < GetPageCount(); i++ )
608 		{
609 			// Check for correct layout names
610 			SdPage* pPage = (SdPage*) GetPage( i );
611 
612 			if(pPage->TRG_HasMasterPage())
613 			{
614 				SdPage& rMaster = (SdPage&)pPage->TRG_GetMasterPage();
615 
616 				if(rMaster.GetLayoutName() != pPage->GetLayoutName())
617 				{
618 					pPage->SetLayoutName(rMaster.GetLayoutName());
619 				}
620 			}
621 		}
622 
623 		for ( sal_uInt16 nPage = 0; nPage < GetMasterPageCount(); nPage++)
624 		{
625 			// LayoutName and PageName must be the same
626 			SdPage* pPage = (SdPage*) GetMasterPage( nPage );
627 
628 			String aName( pPage->GetLayoutName() );
629 			aName.Erase( aName.SearchAscii( SD_LT_SEPARATOR ) );
630 
631 			if( aName != pPage->GetName() )
632 				pPage->SetName( aName );
633 		}
634 
635 		// create language-dependent names of the default layer
636 		RestoreLayerNames();
637 
638 		// set language-dependent names of the templates
639 		static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->UpdateStdNames();
640 
641 		// if necessary create missing templates (e.g., formerly there was no Subtitle)
642 		static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->CreatePseudosIfNecessary();
643 	}
644 
645 	// set default template at the Drawing Engine
646 	String aName( SdResId(STR_STANDARD_STYLESHEET_NAME));
647 	SetDefaultStyleSheet(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(aName, SD_STYLE_FAMILY_GRAPHICS)));
648 
649     // #119287# Set default StyleSheet for SdrGrafObj and SdrOle2Obj
650 	SetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(String( SdResId(STR_POOLSHEET_OBJNOLINENOFILL)), SD_STYLE_FAMILY_GRAPHICS)));
651 
652 	// initialize Draw-Outliner and Document Outliner,
653 	// but not the global Outliner because it is not document-specific
654 	// like StyleSheetPool and StyleRequestHandler
655 	::Outliner& rDrawOutliner = GetDrawOutliner();
656 	rDrawOutliner.SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool());
657 	sal_uLong nCntrl = rDrawOutliner.GetControlWord();
658 	if (mbOnlineSpell)
659 		nCntrl |= EE_CNTRL_ONLINESPELLING;
660 	else
661 		nCntrl &= ~EE_CNTRL_ONLINESPELLING;
662 	rDrawOutliner.SetControlWord(nCntrl);
663 
664 	// initialize HitTest-Outliner and Document Outliner,
665 	// but not the global Outliner because it is not document-specific
666 	// like StyleSheetPool and StyleRequestHandler
667 	pHitTestOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool());
668 
669 	if(mpOutliner)
670 	{
671 		mpOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool());
672 	}
673 	if(mpInternalOutliner)
674 	{
675 		mpInternalOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool());
676 	}
677 
678 	if ( eMode == DOC_LOADED )
679 	{
680 		// presentation objects have to be Listener again of the respective templates
681 		SdStyleSheetPool* pSPool = (SdStyleSheetPool*) GetStyleSheetPool();
682 		sal_uInt16 nPage, nPageCount;
683 
684 		// #96323# create missing layout style sheets for broken documents
685 		//		   that where created with the 5.2
686 		nPageCount = GetMasterSdPageCount( PK_STANDARD );
687 		for (nPage = 0; nPage < nPageCount; nPage++)
688 		{
689 			SdPage* pPage = GetMasterSdPage(nPage, PK_STANDARD);
690 			pSPool->CreateLayoutStyleSheets( pPage->GetName(), sal_True );
691 		}
692 
693 		// Default and note pages:
694 		for (nPage = 0; nPage < GetPageCount(); nPage++)
695 		{
696 			SdPage* pPage = (SdPage*)GetPage(nPage);
697 			NewOrLoadCompleted( pPage, pSPool );
698 		}
699 
700 		// Masterpages:
701 		for (nPage = 0; nPage < GetMasterPageCount(); nPage++)
702 		{
703 			SdPage* pPage = (SdPage*)GetMasterPage(nPage);
704 
705 			NewOrLoadCompleted( pPage, pSPool );
706 		}
707 	}
708 
709 	mbNewOrLoadCompleted = sal_True;
710 
711 	/**************************************************************************
712 	* Update all linked Pages
713 	**************************************************************************/
714 	SdPage* pPage = NULL;
715 	sal_uInt16 nMaxSdPages = GetSdPageCount(PK_STANDARD);
716 
717 	for (sal_uInt16 nSdPage=0; nSdPage < nMaxSdPages; nSdPage++)
718 	{
719 		pPage = (SdPage*) GetSdPage(nSdPage, PK_STANDARD);
720 
721 		if (pPage && pPage->GetFileName().Len() && pPage->GetBookmarkName().Len())
722 		{
723 			pPage->SetModel(this);
724 		}
725 	}
726 
727 	UpdateAllLinks();
728 
729 	SetChanged( sal_False );
730 }
731 
732 /** updates all links, only links in this document should by resolved */
UpdateAllLinks()733 void SdDrawDocument::UpdateAllLinks()
734 {
735 	if ( !pDocLockedInsertingLinks && pLinkManager && pLinkManager->GetLinks().Count() )
736 	{
737 		pDocLockedInsertingLinks = this; // lock inserting links. only links in this document should by resolved
738 
739 		pLinkManager->UpdateAllLinks();  // query box: update all links?
740 
741 		if( pDocLockedInsertingLinks == this )
742 			pDocLockedInsertingLinks = NULL;  // unlock inserting links
743 	}
744 }
745 
746 /** this loops over the presentation objectes of a page and repairs some new settings
747 	from old binary files and resets all default strings for empty presentation objects.
748 */
NewOrLoadCompleted(SdPage * pPage,SdStyleSheetPool * pSPool)749 void SdDrawDocument::NewOrLoadCompleted( SdPage* pPage, SdStyleSheetPool* pSPool )
750 {
751 /* cl removed because not needed anymore since binfilter
752 	SdrObjListIter aShapeIter( *pPage );
753 	while( aShapeIter.IsMore() )
754 	{
755 		OutlinerParaObject* pOPO = aShapeIter.Next()->GetOutlinerParaObject();
756 		if( pOPO )
757 		{
758 			if( pOPO->GetOutlinerMode() == OUTLINERMODE_DONTKNOW )
759 				pOPO->SetOutlinerMode( OUTLINERMODE_TEXTOBJECT );
760 
761 			pOPO->FinishLoad( pSPool );
762 		}
763 	}
764 */
765 
766 	const sd::ShapeList& rPresentationShapes( pPage->GetPresentationShapeList() );
767 	if(!rPresentationShapes.isEmpty())
768 	{
769 		// create lists with title and outline templates
770 		String aName = pPage->GetLayoutName();
771 		aName.Erase( aName.SearchAscii( SD_LT_SEPARATOR ));
772 
773 		List* pOutlineList = pSPool->CreateOutlineSheetList(aName);
774 		SfxStyleSheet* pTitleSheet = (SfxStyleSheet*)
775 										pSPool->GetTitleSheet(aName);
776 
777 		SdrObject* pObj = rPresentationShapes.getNextShape(0);
778 
779 		// now search for title and outline text objects and
780 		// change objects into Listener
781 		while(pObj)
782 		{
783 			if (pObj->GetObjInventor() == SdrInventor)
784 			{
785 				OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
786 				sal_uInt16 nId = pObj->GetObjIdentifier();
787 
788 				if (nId == OBJ_TITLETEXT)
789 				{
790 					if( pOPO && pOPO->GetOutlinerMode() == OUTLINERMODE_DONTKNOW )
791 						pOPO->SetOutlinerMode( OUTLINERMODE_TITLEOBJECT );
792 
793 					// sal_True: in doing so do not delete hard attributes
794 					if (pTitleSheet)
795 						pObj->SetStyleSheet(pTitleSheet, sal_True);
796 				}
797 				else if (nId == OBJ_OUTLINETEXT)
798 				{
799 					if( pOPO && pOPO->GetOutlinerMode() == OUTLINERMODE_DONTKNOW )
800 						pOPO->SetOutlinerMode( OUTLINERMODE_OUTLINEOBJECT );
801 
802 					for (sal_uInt16 nSheet = 0; nSheet < 10; nSheet++)
803 					{
804 						SfxStyleSheet* pSheet = (SfxStyleSheet*)pOutlineList->GetObject(nSheet);
805 						if (pSheet)
806 						{
807 							pObj->StartListening(*pSheet);
808 
809 							if( nSheet == 0)
810 								// text frame listen to StyleSheet of Layer1
811 								pObj->NbcSetStyleSheet(pSheet, sal_True);
812 						}
813 					}
814 				}
815 
816 				if (pObj->ISA(SdrTextObj) && pObj->IsEmptyPresObj() && pPage)
817 				{
818 					PresObjKind ePresObjKind = pPage->GetPresObjKind(pObj);
819 					String aString( pPage->GetPresObjText(ePresObjKind) );
820 
821 					if (aString.Len())
822 					{
823 						sd::Outliner* pInternalOutl = GetInternalOutliner(sal_True);
824 						pPage->SetObjText( (SdrTextObj*) pObj, pInternalOutl, ePresObjKind, aString );
825 						pObj->NbcSetStyleSheet( pPage->GetStyleSheetForPresObj( ePresObjKind ), sal_True );
826 						pInternalOutl->Clear();
827 					}
828 				}
829 			}
830 
831 			pObj = rPresentationShapes.getNextShape(pObj);
832 		}
833 
834 		delete pOutlineList;
835 	}
836 }
837 
838 /*************************************************************************
839 |*
840 |* Local Outliner that is used for the outline mode.
841 |* If necessary, insert OutlinerViews into this outliner !
842 |*
843 \************************************************************************/
844 
GetOutliner(sal_Bool bCreateOutliner)845 ::sd::Outliner* SdDrawDocument::GetOutliner(sal_Bool bCreateOutliner)
846 {
847 	if (!mpOutliner && bCreateOutliner)
848 	{
849 		mpOutliner = new ::sd::Outliner( this, OUTLINERMODE_TEXTOBJECT );
850 
851 		if (mpDocSh)
852 			mpOutliner->SetRefDevice( SD_MOD()->GetRefDevice( *mpDocSh ) );
853 
854 		mpOutliner->SetDefTab( nDefaultTabulator );
855 		mpOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool());
856 	}
857 
858 	return(mpOutliner);
859 }
860 
861 
862 /*************************************************************************
863 |*
864 |* Internal Outliner that is used for creating text objects.
865 |* No OutlinerViews will be inserted into this Outliner!
866 |*
867 \************************************************************************/
868 
GetInternalOutliner(sal_Bool bCreateOutliner)869 ::sd::Outliner* SdDrawDocument::GetInternalOutliner(sal_Bool bCreateOutliner)
870 {
871 	if ( !mpInternalOutliner && bCreateOutliner )
872 	{
873 		mpInternalOutliner = new ::sd::Outliner( this, OUTLINERMODE_TEXTOBJECT );
874 		// MT:
875 		// This Outliner is used to create special text objects only.
876 		// As no portion information have to be saved in these text objects,
877 		// the update mode can/should stay always sal_False.
878 		mpInternalOutliner->SetUpdateMode( sal_False );
879 		mpInternalOutliner->EnableUndo( sal_False );
880 
881 		if (mpDocSh)
882 			mpInternalOutliner->SetRefDevice( SD_MOD()->GetRefDevice( *mpDocSh ) );
883 
884 		mpInternalOutliner->SetDefTab( nDefaultTabulator );
885 		mpInternalOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool());
886 	}
887 
888 	DBG_ASSERT( !mpInternalOutliner || ( mpInternalOutliner->GetUpdateMode() == sal_False ) , "InternalOutliner: UpdateMode = sal_True !" );
889 	DBG_ASSERT( !mpInternalOutliner || ( mpInternalOutliner->IsUndoEnabled() == sal_False ), "InternalOutliner: Undo = sal_True !" );
890 
891 	// MT: Who fills it with spam has to empty it right after:
892 	// Advantages:
893 	// a) No uncessary clear calls.
894 	// b) No spam in memory.
895 	DBG_ASSERT( !mpInternalOutliner || ( ( mpInternalOutliner->GetParagraphCount() == 1 ) && ( mpInternalOutliner->GetText( mpInternalOutliner->GetParagraph( 0 ) ).Len() == 0 ) ), "InternalOutliner: Nicht leer!" );
896 
897 	return mpInternalOutliner;
898 }
899 
900 /*************************************************************************
901 |*
902 |* OnlineSpelling on/off
903 |*
904 \************************************************************************/
905 
SetOnlineSpell(sal_Bool bIn)906 void SdDrawDocument::SetOnlineSpell(sal_Bool bIn)
907 {
908 	mbOnlineSpell = bIn;
909 	sal_uLong nCntrl = 0;
910 
911 	if(mpOutliner)
912 	{
913 		nCntrl = mpOutliner->GetControlWord();
914 
915 		if(mbOnlineSpell)
916 			nCntrl |= EE_CNTRL_ONLINESPELLING;
917 		else
918 			nCntrl &= ~EE_CNTRL_ONLINESPELLING;
919 
920 		mpOutliner->SetControlWord(nCntrl);
921 	}
922 
923 	if (mpInternalOutliner)
924 	{
925 		nCntrl = mpInternalOutliner->GetControlWord();
926 
927 		if (mbOnlineSpell)
928 			nCntrl |= EE_CNTRL_ONLINESPELLING;
929 		else
930 			nCntrl &= ~EE_CNTRL_ONLINESPELLING;
931 
932 		mpInternalOutliner->SetControlWord(nCntrl);
933 	}
934 
935 	::Outliner& rOutliner = GetDrawOutliner();
936 
937 	nCntrl = rOutliner.GetControlWord();
938 
939 	if (mbOnlineSpell)
940 		nCntrl |= EE_CNTRL_ONLINESPELLING;
941 	else
942 		nCntrl &= ~EE_CNTRL_ONLINESPELLING;
943 
944 	rOutliner.SetControlWord(nCntrl);
945 
946 	if (mbOnlineSpell)
947 	{
948 		StartOnlineSpelling();
949 	}
950 	else
951 	{
952 		StopOnlineSpelling();
953 	}
954 }
955 
956 
957 /*************************************************************************
958 |*
959 |* OnlineSpelling: Marking on/off
960 |*
961 \************************************************************************/
962 
createUnoModel()963 uno::Reference< uno::XInterface > SdDrawDocument::createUnoModel()
964 {
965 	uno::Reference< uno::XInterface > xModel;
966 
967 	try
968 	{
969 		if ( mpDocSh )
970 			xModel = mpDocSh->GetModel();
971 	}
972 	catch( uno::RuntimeException& )
973 	{
974 	}
975 
976 	return xModel;
977 }
978 
GetPageNumType() const979 SvxNumType SdDrawDocument::GetPageNumType() const
980 {
981 	return mePageNumType;
982 }
983 
984 
985 
986 
SetPrinterIndependentLayout(sal_Int32 nMode)987 void SdDrawDocument::SetPrinterIndependentLayout (sal_Int32 nMode)
988 {
989 	// #108104#
990     // DBG_ASSERT (mpDocSh!=NULL, "No available document shell to set ref device at.");
991 
992 	switch (nMode)
993     {
994         case ::com::sun::star::document::PrinterIndependentLayout::DISABLED:
995         case ::com::sun::star::document::PrinterIndependentLayout::ENABLED:
996             // Just store supported modes and inform the doc shell.
997             mnPrinterIndependentLayout = nMode;
998 
999 			// #108104#
1000 			// Since it is possible that a SdDrawDocument is constructed without a
1001 			// SdDrawDocShell the pointer member mpDocSh needs to be tested
1002 			// before the call is executed. This is e.-g. used for copy/paste.
1003 			if(mpDocSh)
1004 			{
1005 				mpDocSh->UpdateRefDevice ();
1006 			}
1007 
1008             break;
1009 
1010         default:
1011             // Ignore unknown values.
1012             break;
1013     }
1014 }
1015 
GetPrinterIndependentLayout(void)1016 sal_Int32 SdDrawDocument::GetPrinterIndependentLayout (void)
1017 {
1018     return mnPrinterIndependentLayout;
1019 }
1020 
IsStartWithPresentation() const1021 bool SdDrawDocument::IsStartWithPresentation() const
1022 {
1023 	return mbStartWithPresentation;
1024 }
1025 
SetStartWithPresentation(bool bStartWithPresentation)1026 void SdDrawDocument::SetStartWithPresentation( bool bStartWithPresentation )
1027 {
1028 	mbStartWithPresentation = bStartWithPresentation;
1029 }
1030 
1031 // #109538#
PageListChanged()1032 void SdDrawDocument::PageListChanged()
1033 {
1034 	mpDrawPageListWatcher->Invalidate();
1035 }
1036 
1037 // #109538#
MasterPageListChanged()1038 void SdDrawDocument::MasterPageListChanged()
1039 {
1040 	mpMasterPageListWatcher->Invalidate();
1041 }
1042 
SetCalcFieldValueHdl(::Outliner * pOutliner)1043 void SdDrawDocument::SetCalcFieldValueHdl(::Outliner* pOutliner)
1044 {
1045 	pOutliner->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
1046 }
1047 
GetAnnotationAuthorIndex(const rtl::OUString & rAuthor)1048 sal_uInt16 SdDrawDocument::GetAnnotationAuthorIndex( const rtl::OUString& rAuthor )
1049 {
1050     // force current user to have first color
1051     if( maAnnotationAuthors.empty() )
1052     {
1053         SvtUserOptions aUserOptions;
1054         maAnnotationAuthors.push_back( aUserOptions.GetFullName() );
1055     }
1056 
1057     sal_uInt16 idx = 0;
1058     for( std::vector< OUString >::iterator iter( maAnnotationAuthors.begin() ); iter != maAnnotationAuthors.end(); iter++ )
1059     {
1060         if( (*iter) == rAuthor )
1061         {
1062             break;
1063         }
1064         idx++;
1065     }
1066 
1067     if( idx == maAnnotationAuthors.size() )
1068     {
1069         maAnnotationAuthors.push_back( rAuthor );
1070     }
1071 
1072     return idx;
1073 }
1074 
1075 // eof
1076