xref: /aoo41x/main/svx/source/svdraw/svdmodel.cxx (revision a840a559)
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_svx.hxx"
26 
27 #include <svx/svdmodel.hxx>
28 
29 #include <rtl/uuid.h>
30 #include <com/sun/star/lang/XComponent.hpp>
31 #include <osl/endian.h>
32 #include <rtl/logfile.hxx>
33 #include <math.h>
34 #include <tools/urlobj.hxx>
35 #include <unotools/ucbstreamhelper.hxx>
36 
37 #include <tools/string.hxx>
38 #include <svl/whiter.hxx>
39 #include <svx/xit.hxx>
40 #include <svx/xbtmpit.hxx>
41 #include <svx/xlndsit.hxx>
42 #include <svx/xlnedit.hxx>
43 #include <svx/xflgrit.hxx>
44 #include <svx/xflftrit.hxx>
45 #include <svx/xflhtit.hxx>
46 #include <svx/xlnstit.hxx>
47 
48 #include "svx/svditext.hxx"
49 #include <editeng/editeng.hxx>   // Fuer EditEngine::CreatePool()
50 
51 #include <svx/xtable.hxx>
52 
53 #include "svx/svditer.hxx"
54 #include <svx/svdtrans.hxx>
55 #include <svx/svdpage.hxx>
56 #include <svx/svdlayer.hxx>
57 #include <svx/svdundo.hxx>
58 #include <svx/svdpool.hxx>
59 #include <svx/svdobj.hxx>
60 #include <svx/svdotext.hxx>  // fuer ReformatAllTextObjects und CalcFieldValue
61 #include <svx/svdetc.hxx>
62 #include <svx/svdoutl.hxx>
63 #include <svx/svdoole2.hxx>
64 #include "svx/svdglob.hxx"  // Stringcache
65 #include "svx/svdstr.hrc"   // Objektname
66 #include "svdoutlinercache.hxx"
67 
68 #include "svx/xflclit.hxx"
69 #include "svx/xflhtit.hxx"
70 #include "svx/xlnclit.hxx"
71 
72 #include <svl/asiancfg.hxx>
73 #include "editeng/fontitem.hxx"
74 #include <editeng/colritem.hxx>
75 #include <editeng/fhgtitem.hxx>
76 #include <svl/style.hxx>
77 #include <tools/bigint.hxx>
78 #include <editeng/numitem.hxx>
79 #include <editeng/bulitem.hxx>
80 #include <editeng/outlobj.hxx>
81 #include "editeng/forbiddencharacterstable.hxx"
82 #include <svl/zforlist.hxx>
83 #include <comphelper/processfactory.hxx>
84 
85 // #90477#
86 #include <tools/tenccvt.hxx>
87 #include <unotools/syslocale.hxx>
88 
89 // #95114#
90 #include <vcl/svapp.hxx>
91 #include <svx/sdr/properties/properties.hxx>
92 #include <editeng/eeitem.hxx>
93 #include <svl/itemset.hxx>
94 
95 using namespace ::com::sun::star;
96 using namespace ::com::sun::star::uno;
97 using namespace ::com::sun::star::lang;
98 
99 ////////////////////////////////////////////////////////////////////////////////////////////////////
100 
101 struct SdrModelImpl
102 {
103 	SfxUndoManager*	mpUndoManager;
104 	SdrUndoFactory* mpUndoFactory;
105 	bool mbAllowShapePropertyChangeListener;
106 };
107 
108 ////////////////////////////////////////////////////////////////////////////////////////////////////
109 
110 DBG_NAME(SdrModel)
111 TYPEINIT1(SdrModel,SfxBroadcaster);
ImpCtor(SfxItemPool * pPool,::comphelper::IEmbeddedHelper * _pEmbeddedHelper,bool bLoadRefCounts)112 void SdrModel::ImpCtor(SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* _pEmbeddedHelper,bool bLoadRefCounts)
113 {
114 	mpImpl = new SdrModelImpl;
115 	mpImpl->mpUndoManager=0;
116 	mpImpl->mpUndoFactory=0;
117 	mpImpl->mbAllowShapePropertyChangeListener=false;
118 	mbInDestruction=false;
119 	aObjUnit=SdrEngineDefaults::GetMapFraction();
120 	eObjUnit=SdrEngineDefaults::GetMapUnit();
121 	eUIUnit=FUNIT_MM;
122 	aUIScale=Fraction(1,1);
123 	nUIUnitKomma=0;
124 	bUIOnlyKomma=sal_False;
125 	pLayerAdmin=NULL;
126 	pItemPool=pPool;
127 	bMyPool=sal_False;
128 	m_pEmbeddedHelper=_pEmbeddedHelper;
129 	pDrawOutliner=NULL;
130 	pHitTestOutliner=NULL;
131 	pRefOutDev=NULL;
132 	nProgressAkt=0;
133 	nProgressMax=0;
134 	nProgressOfs=0;
135 	pDefaultStyleSheet=NULL;
136     mpDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj = 0;
137 	pLinkManager=NULL;
138 	pUndoStack=NULL;
139 	pRedoStack=NULL;
140 	nMaxUndoCount=16;
141 	pAktUndoGroup=NULL;
142 	nUndoLevel=0;
143 	mbUndoEnabled=true;
144 	nProgressPercent=0;
145 	nLoadVersion=0;
146 	mbChanged = sal_False;
147 	bInfoChanged=sal_False;
148 	bPagNumsDirty=sal_False;
149 	bMPgNumsDirty=sal_False;
150 	bPageNotValid=sal_False;
151 	bSavePortable=sal_False;
152 	bSaveCompressed=sal_False;
153 	bSaveNative=sal_False;
154 	bSwapGraphics=sal_False;
155 	nSwapGraphicsMode=SDR_SWAPGRAPHICSMODE_DEFAULT;
156 	bSaveOLEPreview=sal_False;
157 	bPasteResize=sal_False;
158 	bNoBitmapCaching=sal_False;
159 	bReadOnly=sal_False;
160 	nStreamCompressMode=COMPRESSMODE_NONE;
161 	nStreamNumberFormat=NUMBERFORMAT_INT_BIGENDIAN;
162 	nDefaultTabulator=0;
163 	mpNumberFormatter = NULL;
164 	bTransparentTextFrames=sal_False;
165 	bStarDrawPreviewMode = sal_False;
166 	nStarDrawPreviewMasterPageNum = SDRPAGE_NOTFOUND;
167 	pModelStorage = NULL;
168 	mpForbiddenCharactersTable = NULL;
169 	mbModelLocked = sal_False;
170 	mpOutlinerCache = NULL;
171 	mbKernAsianPunctuation = sal_False;
172     mbAddExtLeading = sal_False;
173 	mnHandoutPageCount = 0;
174     mbDisableTextEditUsesCommonUndoManager = false;
175     SvxAsianConfig aAsian;
176 	mnCharCompressType = aAsian.GetCharDistanceCompression();
177 
178 #ifdef OSL_LITENDIAN
179 	nStreamNumberFormat=NUMBERFORMAT_INT_LITTLEENDIAN;
180 #endif
181 	if ( pPool == NULL )
182     {
183 		pItemPool=new SdrItemPool(0L, bLoadRefCounts);
184 		// Der Outliner hat keinen eigenen Pool, deshalb den der EditEngine
185 		SfxItemPool* pOutlPool=EditEngine::CreatePool( bLoadRefCounts );
186 		// OutlinerPool als SecondaryPool des SdrPool
187 		pItemPool->SetSecondaryPool(pOutlPool);
188 		// Merken, dass ich mir die beiden Pools selbst gemacht habe
189 		bMyPool=sal_True;
190 	}
191 	pItemPool->SetDefaultMetric((SfxMapUnit)eObjUnit);
192 
193 // SJ: #95129# using static SdrEngineDefaults only if default SvxFontHeight item is not available
194     const SfxPoolItem* pPoolItem = pItemPool->GetPoolDefaultItem( EE_CHAR_FONTHEIGHT );
195     if ( pPoolItem )
196         nDefTextHgt = ((SvxFontHeightItem*)pPoolItem)->GetHeight();
197     else
198         nDefTextHgt = SdrEngineDefaults::GetFontHeight();
199 
200 	pItemPool->SetPoolDefaultItem( SdrTextWordWrapItem( sal_False ) );
201 
202 	SetTextDefaults();
203 
204 	pLayerAdmin=new SdrLayerAdmin;
205 	pLayerAdmin->SetModel(this);
206 	ImpSetUIUnit();
207 
208 	// den DrawOutliner OnDemand erzeugen geht noch nicht, weil ich den Pool
209 	// sonst nicht kriege (erst ab 302!)
210 	pDrawOutliner = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, this );
211 	ImpSetOutlinerDefaults(pDrawOutliner, sal_True);
212 
213 	pHitTestOutliner = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, this );
214 	ImpSetOutlinerDefaults(pHitTestOutliner, sal_True);
215 }
216 
SdrModel(SfxItemPool * pPool,::comphelper::IEmbeddedHelper * pPers,sal_Bool bLoadRefCounts)217 SdrModel::SdrModel(SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, sal_Bool bLoadRefCounts):
218 	maMaPag(1024,32,32),
219 	maPages(1024,32,32)
220 {
221 #ifdef TIMELOG
222     RTL_LOGFILE_CONTEXT_AUTHOR ( aLog, "svx", "aw93748", "SdrModel::SdrModel(...)" );
223 #endif
224 
225 	DBG_CTOR(SdrModel,NULL);
226 	ImpCtor(pPool,pPers,(FASTBOOL)bLoadRefCounts);
227 }
228 
SdrModel(const String & rPath,SfxItemPool * pPool,::comphelper::IEmbeddedHelper * pPers,sal_Bool bLoadRefCounts)229 SdrModel::SdrModel(const String& rPath, SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, sal_Bool bLoadRefCounts):
230 	maMaPag(1024,32,32),
231 	maPages(1024,32,32),
232 	aTablePath(rPath)
233 {
234 #ifdef TIMELOG
235     RTL_LOGFILE_CONTEXT_AUTHOR ( aLog, "svx", "aw93748", "SdrModel::SdrModel(...)" );
236 #endif
237 
238 	DBG_CTOR(SdrModel,NULL);
239 	ImpCtor(pPool,pPers,(FASTBOOL)bLoadRefCounts);
240 }
241 
SdrModel(const SdrModel &)242 SdrModel::SdrModel(const SdrModel& /*rSrcModel*/):
243 	SfxBroadcaster(),
244 	tools::WeakBase< SdrModel >(),
245 	maMaPag(1024,32,32),
246 	maPages(1024,32,32)
247 {
248 #ifdef TIMELOG
249     RTL_LOGFILE_CONTEXT_AUTHOR ( aLog, "svx", "aw93748", "SdrModel::SdrModel(...)" );
250 #endif
251 
252 	// noch nicht implementiert
253 	DBG_ERROR("SdrModel::CopyCtor() ist noch nicht implementiert");
254 }
255 
~SdrModel()256 SdrModel::~SdrModel()
257 {
258 #ifdef TIMELOG
259     RTL_LOGFILE_CONTEXT_AUTHOR ( aLog, "svx", "aw93748", "SdrModel::~SdrModel(...)" );
260 #endif
261 
262 	DBG_DTOR(SdrModel,NULL);
263 
264 	mbInDestruction = true;
265 
266 	Broadcast(SdrHint(HINT_MODELCLEARED));
267 
268 	delete mpOutlinerCache;
269 
270 	ClearUndoBuffer();
271 #ifdef DBG_UTIL
272 	if(pAktUndoGroup)
273 	{
274 		ByteString aStr("Im Dtor des SdrModel steht noch ein offenes Undo rum: \"");
275 
276 		aStr += ByteString(pAktUndoGroup->GetComment(), gsl_getSystemTextEncoding());
277 		aStr += '\"';
278 
279 		DBG_ERROR(aStr.GetBuffer());
280 	}
281 #endif
282 	if (pAktUndoGroup!=NULL)
283 		delete pAktUndoGroup;
284 
285 	// #116168#
286 	ClearModel(sal_True);
287 
288 	delete pLayerAdmin;
289 
290 	// Den DrawOutliner erst nach dem ItemPool loeschen, da
291 	// der ItemPool Items des DrawOutliners referenziert !!! (<- das war mal)
292 	// Wg. Problem bei Malte Reihenfolge wieder umgestellt.
293 	// Loeschen des Outliners vor dem loeschen des ItemPools
294 	delete pHitTestOutliner;
295 	delete pDrawOutliner;
296 
297 	// delete StyleSheetPool, derived classes should not do this since
298 	// the DrawingEngine may need it in its destrctor (SB)
299 	if( mxStyleSheetPool.is() )
300 	{
301 		Reference< XComponent > xComponent( dynamic_cast< cppu::OWeakObject* >( mxStyleSheetPool.get() ), UNO_QUERY );
302 		if( xComponent.is() ) try
303 		{
304 			xComponent->dispose();
305 		}
306 		catch( RuntimeException& )
307 		{
308 		}
309 		mxStyleSheetPool.clear();
310 	}
311 
312 	if (bMyPool)
313 	{
314 		// Pools loeschen, falls es meine sind
315 		SfxItemPool* pOutlPool=pItemPool->GetSecondaryPool();
316         SfxItemPool::Free(pItemPool);
317 		// Der OutlinerPool muss nach dem ItemPool plattgemacht werden, da der
318 		// ItemPool SetItems enthaelt die ihrerseits Items des OutlinerPools
319 		// referenzieren (Joe)
320         SfxItemPool::Free(pOutlPool);
321 	}
322 
323 	if( mpForbiddenCharactersTable )
324 		mpForbiddenCharactersTable->release();
325 
326 	if(mpNumberFormatter)
327 		delete mpNumberFormatter;
328 
329 	delete mpImpl->mpUndoFactory;
330 	delete mpImpl;
331 }
332 
IsInDestruction() const333 bool SdrModel::IsInDestruction() const
334 {
335 	return mbInDestruction;
336 }
337 
GetNumberFormatter() const338 const SvNumberFormatter& SdrModel::GetNumberFormatter() const
339 {
340 	if(!mpNumberFormatter)
341 	{
342 		// use cast here since from outside view this IS a const method
343 		((SdrModel*)this)->mpNumberFormatter = new SvNumberFormatter(
344 			::comphelper::getProcessServiceFactory(), LANGUAGE_SYSTEM);
345 	}
346 
347 	return *mpNumberFormatter;
348 }
349 
350 // noch nicht implementiert:
operator =(const SdrModel &)351 void SdrModel::operator=(const SdrModel& /*rSrcModel*/)
352 {
353 	DBG_ERROR("SdrModel::operator=() ist noch nicht implementiert");
354 }
355 
operator ==(const SdrModel &) const356 FASTBOOL SdrModel::operator==(const SdrModel& /*rCmpModel*/) const
357 {
358 	DBG_ERROR("SdrModel::operator==() ist noch nicht implementiert");
359 	return sal_False;
360 }
361 
SetSwapGraphics(FASTBOOL bSwap)362 void SdrModel::SetSwapGraphics( FASTBOOL bSwap )
363 {
364 	bSwapGraphics = bSwap;
365 }
366 
IsReadOnly() const367 FASTBOOL SdrModel::IsReadOnly() const
368 {
369 	return bReadOnly;
370 }
371 
SetReadOnly(FASTBOOL bYes)372 void SdrModel::SetReadOnly(FASTBOOL bYes)
373 {
374 	bReadOnly=bYes;
375 }
376 
377 ////////////////////////////////////////////////////////////////////////////////////////////////////
378 
SetMaxUndoActionCount(sal_uIntPtr nAnz)379 void SdrModel::SetMaxUndoActionCount(sal_uIntPtr nAnz)
380 {
381 	if (nAnz<1) nAnz=1;
382 	nMaxUndoCount=nAnz;
383 	if (pUndoStack!=NULL) {
384 		while (pUndoStack->Count()>nMaxUndoCount) {
385 			delete (SfxUndoAction*) pUndoStack->Remove(pUndoStack->Count());
386 		}
387 	}
388 }
389 
ClearUndoBuffer()390 void SdrModel::ClearUndoBuffer()
391 {
392 	if (pUndoStack!=NULL) {
393 		while (pUndoStack->Count()!=0) {
394 			delete (SfxUndoAction*) pUndoStack->Remove(pUndoStack->Count()-1);
395 		}
396 		delete pUndoStack;
397 		pUndoStack=NULL;
398 	}
399 	if (pRedoStack!=NULL) {
400 		while (pRedoStack->Count()!=0) {
401 			delete (SfxUndoAction*) pRedoStack->Remove(pRedoStack->Count()-1);
402 		}
403 		delete pRedoStack;
404 		pRedoStack=NULL;
405 	}
406 }
407 
Undo()408 FASTBOOL SdrModel::Undo()
409 {
410 	FASTBOOL bRet=sal_False;
411 	if( mpImpl->mpUndoManager )
412 	{
413 		DBG_ERROR("svx::SdrModel::Undo(), method not supported with application undo manager!");
414 	}
415 	else
416 	{
417 		SfxUndoAction* pDo=(SfxUndoAction*)GetUndoAction(0);
418 		if(pDo!=NULL)
419 		{
420 			const bool bWasUndoEnabled = mbUndoEnabled;
421 			mbUndoEnabled = false;
422 			pDo->Undo();
423 			if(pRedoStack==NULL)
424 				pRedoStack=new Container(1024,16,16);
425 			pRedoStack->Insert(pUndoStack->Remove((sal_uIntPtr)0),(sal_uIntPtr)0);
426 			mbUndoEnabled = bWasUndoEnabled;
427 		}
428 	}
429 	return bRet;
430 }
431 
Redo()432 FASTBOOL SdrModel::Redo()
433 {
434 	FASTBOOL bRet=sal_False;
435 	if( mpImpl->mpUndoManager )
436 	{
437 		DBG_ERROR("svx::SdrModel::Redo(), method not supported with application undo manager!");
438 	}
439 	else
440 	{
441 		SfxUndoAction* pDo=(SfxUndoAction*)GetRedoAction(0);
442 		if(pDo!=NULL)
443 		{
444 			const bool bWasUndoEnabled = mbUndoEnabled;
445 			mbUndoEnabled = false;
446 			pDo->Redo();
447 			if(pUndoStack==NULL)
448 				pUndoStack=new Container(1024,16,16);
449 			pUndoStack->Insert(pRedoStack->Remove((sal_uIntPtr)0),(sal_uIntPtr)0);
450 			mbUndoEnabled = bWasUndoEnabled;
451 		}
452 	}
453 	return bRet;
454 }
455 
Repeat(SfxRepeatTarget & rView)456 FASTBOOL SdrModel::Repeat(SfxRepeatTarget& rView)
457 {
458 	FASTBOOL bRet=sal_False;
459 	if( mpImpl->mpUndoManager )
460 	{
461 		DBG_ERROR("svx::SdrModel::Redo(), method not supported with application undo manager!");
462 	}
463 	else
464 	{
465 		SfxUndoAction* pDo=(SfxUndoAction*)GetUndoAction(0);
466 		if(pDo!=NULL)
467 		{
468 			if(pDo->CanRepeat(rView))
469 			{
470 				pDo->Repeat(rView);
471 				bRet=sal_True;
472 			}
473 		}
474 	}
475 	return bRet;
476 }
477 
ImpPostUndoAction(SdrUndoAction * pUndo)478 void SdrModel::ImpPostUndoAction(SdrUndoAction* pUndo)
479 {
480 	DBG_ASSERT( mpImpl->mpUndoManager == 0, "svx::SdrModel::ImpPostUndoAction(), method not supported with application undo manager!" );
481 	if( IsUndoEnabled() )
482 	{
483 		if (aUndoLink.IsSet())
484 		{
485 			aUndoLink.Call(pUndo);
486 		}
487 		else
488 		{
489 			if (pUndoStack==NULL)
490 				pUndoStack=new Container(1024,16,16);
491 			pUndoStack->Insert(pUndo,(sal_uIntPtr)0);
492 			while (pUndoStack->Count()>nMaxUndoCount)
493 			{
494 				delete (SfxUndoAction*)pUndoStack->Remove(pUndoStack->Count()-1);
495 			}
496 			if (pRedoStack!=NULL)
497 				pRedoStack->Clear();
498 		}
499 	}
500 	else
501 	{
502 		delete pUndo;
503 	}
504 }
505 
BegUndo()506 void SdrModel::BegUndo()
507 {
508 	if( mpImpl->mpUndoManager )
509 	{
510 		const String aEmpty;
511 		mpImpl->mpUndoManager->EnterListAction(aEmpty,aEmpty);
512 		nUndoLevel++;
513 	}
514 	else if( IsUndoEnabled() )
515 	{
516 		if(pAktUndoGroup==NULL)
517 		{
518 			pAktUndoGroup = new SdrUndoGroup(*this);
519 			nUndoLevel=1;
520 		}
521 		else
522 		{
523 			nUndoLevel++;
524 		}
525 	}
526 }
527 
BegUndo(const XubString & rComment)528 void SdrModel::BegUndo(const XubString& rComment)
529 {
530 	if( mpImpl->mpUndoManager )
531 	{
532 		const String aEmpty;
533 		mpImpl->mpUndoManager->EnterListAction( rComment, aEmpty );
534 		nUndoLevel++;
535 	}
536 	else if( IsUndoEnabled() )
537 	{
538 		BegUndo();
539 		if (nUndoLevel==1)
540 		{
541 			pAktUndoGroup->SetComment(rComment);
542 		}
543 	}
544 }
545 
BegUndo(const XubString & rComment,const XubString & rObjDescr,SdrRepeatFunc eFunc)546 void SdrModel::BegUndo(const XubString& rComment, const XubString& rObjDescr, SdrRepeatFunc eFunc)
547 {
548 	if( mpImpl->mpUndoManager )
549 	{
550 		String aComment(rComment);
551 		if( aComment.Len() && rObjDescr.Len() )
552 		{
553 			String aSearchString(RTL_CONSTASCII_USTRINGPARAM("%1"));
554 			aComment.SearchAndReplace(aSearchString, rObjDescr);
555 		}
556 		const String aEmpty;
557 		mpImpl->mpUndoManager->EnterListAction( aComment,aEmpty );
558 		nUndoLevel++;
559 	}
560 	else if( IsUndoEnabled() )
561 	{
562 		BegUndo();
563 		if (nUndoLevel==1)
564 		{
565 			pAktUndoGroup->SetComment(rComment);
566 			pAktUndoGroup->SetObjDescription(rObjDescr);
567 			pAktUndoGroup->SetRepeatFunction(eFunc);
568 		}
569 	}
570 }
571 
BegUndo(SdrUndoGroup * pUndoGrp)572 void SdrModel::BegUndo(SdrUndoGroup* pUndoGrp)
573 {
574 	if( mpImpl->mpUndoManager )
575 	{
576 		DBG_ERROR("svx::SdrModel::BegUndo(), method not supported with application undo manager!" );
577 		nUndoLevel++;
578 	}
579 	else if( IsUndoEnabled() )
580 	{
581 		if (pAktUndoGroup==NULL)
582 		{
583 			pAktUndoGroup=pUndoGrp;
584 			nUndoLevel=1;
585 		}
586 		else
587 		{
588 			delete pUndoGrp;
589 			nUndoLevel++;
590 		}
591 	}
592 	else
593 	{
594 		delete pUndoGrp;
595 	}
596 }
597 
EndUndo()598 void SdrModel::EndUndo()
599 {
600 	DBG_ASSERT(nUndoLevel!=0,"SdrModel::EndUndo(): UndoLevel is already 0!");
601 	if( mpImpl->mpUndoManager )
602 	{
603 		if( nUndoLevel )
604 		{
605 			nUndoLevel--;
606 			mpImpl->mpUndoManager->LeaveListAction();
607 		}
608 	}
609 	else
610 	{
611 		if(pAktUndoGroup!=NULL && IsUndoEnabled())
612 		{
613 			nUndoLevel--;
614 			if(nUndoLevel==0)
615 			{
616 				if(pAktUndoGroup->GetActionCount()!=0)
617 				{
618 					SdrUndoAction* pUndo=pAktUndoGroup;
619 					pAktUndoGroup=NULL;
620 					ImpPostUndoAction(pUndo);
621 				}
622 				else
623 				{
624 					// was empty
625 					delete pAktUndoGroup;
626 					pAktUndoGroup=NULL;
627 				}
628 			}
629 		}
630 	}
631 }
632 
SetUndoComment(const XubString & rComment)633 void SdrModel::SetUndoComment(const XubString& rComment)
634 {
635 	DBG_ASSERT(nUndoLevel!=0,"SdrModel::SetUndoComment(): UndoLevel is on level 0!");
636 
637 	if( mpImpl->mpUndoManager )
638 	{
639 		DBG_ERROR("svx::SdrModel::SetUndoComment(), method not supported with application undo manager!" );
640 	}
641 	else if( IsUndoEnabled() )
642 	{
643 		if(nUndoLevel==1)
644 		{
645 			pAktUndoGroup->SetComment(rComment);
646 		}
647 	}
648 }
649 
SetUndoComment(const XubString & rComment,const XubString & rObjDescr)650 void SdrModel::SetUndoComment(const XubString& rComment, const XubString& rObjDescr)
651 {
652 	DBG_ASSERT(nUndoLevel!=0,"SdrModel::SetUndoComment(): UndoLevel is 0!");
653 	if( mpImpl->mpUndoManager )
654 	{
655 		DBG_ERROR("svx::SdrModel::SetUndoComment(), method not supported with application undo manager!" );
656 	}
657 	else
658 	{
659 		if (nUndoLevel==1)
660 		{
661 			pAktUndoGroup->SetComment(rComment);
662 			pAktUndoGroup->SetObjDescription(rObjDescr);
663 		}
664 	}
665 }
666 
AddUndo(SdrUndoAction * pUndo)667 void SdrModel::AddUndo(SdrUndoAction* pUndo)
668 {
669 	if( mpImpl->mpUndoManager )
670 	{
671 		mpImpl->mpUndoManager->AddUndoAction( pUndo );
672 	}
673 	else if( !IsUndoEnabled() )
674 	{
675 		delete pUndo;
676 	}
677 	else
678 	{
679 		if (pAktUndoGroup!=NULL)
680 		{
681 			pAktUndoGroup->AddAction(pUndo);
682 		}
683 		else
684 		{
685 			ImpPostUndoAction(pUndo);
686 		}
687 	}
688 }
689 
EnableUndo(bool bEnable)690 void SdrModel::EnableUndo( bool bEnable )
691 {
692 	if( mpImpl->mpUndoManager )
693 	{
694 		mpImpl->mpUndoManager->EnableUndo( bEnable );
695 	}
696 	else
697 	{
698 		mbUndoEnabled = bEnable;
699 	}
700 }
701 
IsUndoEnabled() const702 bool SdrModel::IsUndoEnabled() const
703 {
704 	if( mpImpl->mpUndoManager )
705 	{
706 		return mpImpl->mpUndoManager->IsUndoEnabled();
707 	}
708 	else
709 	{
710 		return mbUndoEnabled;
711 	}
712 }
713 
714 ////////////////////////////////////////////////////////////////////////////////////////////////////
715 
716 // #116168#
ClearModel(sal_Bool bCalledFromDestructor)717 void SdrModel::ClearModel(sal_Bool bCalledFromDestructor)
718 {
719 	if(bCalledFromDestructor)
720 	{
721 		mbInDestruction = true;
722 	}
723 
724 	sal_Int32 i;
725 	// delete all drawing pages
726 	sal_Int32 nAnz=GetPageCount();
727 	for (i=nAnz-1; i>=0; i--)
728 	{
729 		DeletePage( (sal_uInt16)i );
730 	}
731 	maPages.Clear();
732 	// #109538#
733 	PageListChanged();
734 
735 	// delete all Masterpages
736 	nAnz=GetMasterPageCount();
737 	for(i=nAnz-1; i>=0; i--)
738 	{
739 		DeleteMasterPage( (sal_uInt16)i );
740 	}
741 	maMaPag.Clear();
742 	// #109538#
743 	MasterPageListChanged();
744 
745 	pLayerAdmin->ClearLayer();
746 }
747 
AllocModel() const748 SdrModel* SdrModel::AllocModel() const
749 {
750 	SdrModel* pModel=new SdrModel;
751 	pModel->SetScaleUnit(eObjUnit,aObjUnit);
752 	return pModel;
753 }
754 
AllocPage(FASTBOOL bMasterPage)755 SdrPage* SdrModel::AllocPage(FASTBOOL bMasterPage)
756 {
757 	return new SdrPage(*this,bMasterPage);
758 }
759 
SetTextDefaults() const760 void SdrModel::SetTextDefaults() const
761 {
762 	SetTextDefaults( pItemPool, nDefTextHgt );
763 }
764 
ImpGetDefaultFontsLanguage(SvxFontItem & rLatin,SvxFontItem & rAsian,SvxFontItem & rComplex)765 void ImpGetDefaultFontsLanguage( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex)
766 {
767 	const sal_uInt16 nItemCnt = 3;
768 	static struct {
769 		sal_uInt16 nFntType, nLanguage;
770 	}  aOutTypeArr[ nItemCnt ] = {
771 		{  DEFAULTFONT_LATIN_TEXT, LANGUAGE_ENGLISH_US },
772 		{  DEFAULTFONT_CJK_TEXT, LANGUAGE_ENGLISH_US },
773 		{  DEFAULTFONT_CTL_TEXT, LANGUAGE_ARABIC_SAUDI_ARABIA }
774 	};
775 	SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex };
776 
777 	for( sal_uInt16 n = 0; n < nItemCnt; ++n )
778 	{
779 		Font aFnt( OutputDevice::GetDefaultFont(
780 			aOutTypeArr[ n ].nFntType, aOutTypeArr[ n ].nLanguage,
781 			DEFAULTFONT_FLAGS_ONLYONE, 0 ));
782 		SvxFontItem* pI = aItemArr[ n ];
783         pI->SetFamily( aFnt.GetFamily());
784         pI->SetFamilyName( aFnt.GetName());
785         pI->SetStyleName( String() );
786         pI->SetPitch( aFnt.GetPitch());
787         pI->SetCharSet( aFnt.GetCharSet() );
788 	}
789 }
790 
SetTextDefaults(SfxItemPool * pItemPool,sal_uIntPtr nDefTextHgt)791 void SdrModel::SetTextDefaults( SfxItemPool* pItemPool, sal_uIntPtr nDefTextHgt )
792 {
793 	// #95114# set application-language specific dynamic pool language defaults
794     SvxFontItem aSvxFontItem( EE_CHAR_FONTINFO) ;
795 	SvxFontItem aSvxFontItemCJK(EE_CHAR_FONTINFO_CJK);
796 	SvxFontItem aSvxFontItemCTL(EE_CHAR_FONTINFO_CTL);
797 	sal_uInt16 nLanguage(Application::GetSettings().GetLanguage());
798 
799 	// get DEFAULTFONT_LATIN_TEXT and set at pool as dynamic default
800 	Font aFont(OutputDevice::GetDefaultFont(DEFAULTFONT_LATIN_TEXT, nLanguage, DEFAULTFONT_FLAGS_ONLYONE, 0));
801     aSvxFontItem.SetFamily(aFont.GetFamily());
802     aSvxFontItem.SetFamilyName(aFont.GetName());
803     aSvxFontItem.SetStyleName(String());
804     aSvxFontItem.SetPitch( aFont.GetPitch());
805     aSvxFontItem.SetCharSet( aFont.GetCharSet() );
806 	pItemPool->SetPoolDefaultItem(aSvxFontItem);
807 
808 	// get DEFAULTFONT_CJK_TEXT and set at pool as dynamic default
809 	Font aFontCJK(OutputDevice::GetDefaultFont(DEFAULTFONT_CJK_TEXT, nLanguage, DEFAULTFONT_FLAGS_ONLYONE, 0));
810     aSvxFontItemCJK.SetFamily( aFontCJK.GetFamily());
811     aSvxFontItemCJK.SetFamilyName(aFontCJK.GetName());
812     aSvxFontItemCJK.SetStyleName(String());
813     aSvxFontItemCJK.SetPitch( aFontCJK.GetPitch());
814     aSvxFontItemCJK.SetCharSet( aFontCJK.GetCharSet());
815 	pItemPool->SetPoolDefaultItem(aSvxFontItemCJK);
816 
817 	// get DEFAULTFONT_CTL_TEXT and set at pool as dynamic default
818 	Font aFontCTL(OutputDevice::GetDefaultFont(DEFAULTFONT_CTL_TEXT, nLanguage, DEFAULTFONT_FLAGS_ONLYONE, 0));
819     aSvxFontItemCTL.SetFamily(aFontCTL.GetFamily());
820     aSvxFontItemCTL.SetFamilyName(aFontCTL.GetName());
821     aSvxFontItemCTL.SetStyleName(String());
822     aSvxFontItemCTL.SetPitch( aFontCTL.GetPitch() );
823     aSvxFontItemCTL.SetCharSet( aFontCTL.GetCharSet());
824 	pItemPool->SetPoolDefaultItem(aSvxFontItemCTL);
825 
826 	// set dynamic FontHeight defaults
827 	pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT ) );
828 	pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT_CJK ) );
829 	pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT_CTL ) );
830 
831 	// set FontColor defaults
832     pItemPool->SetPoolDefaultItem( SvxColorItem(SdrEngineDefaults::GetFontColor(), EE_CHAR_COLOR) );
833 }
834 
GetDrawOutliner(const SdrTextObj * pObj) const835 SdrOutliner& SdrModel::GetDrawOutliner(const SdrTextObj* pObj) const
836 {
837 	pDrawOutliner->SetTextObj(pObj);
838 	return *pDrawOutliner;
839 }
840 
CreateDrawOutliner(const SdrTextObj * pObj)841 boost::shared_ptr< SdrOutliner > SdrModel::CreateDrawOutliner(const SdrTextObj* pObj)
842 {
843 	boost::shared_ptr< SdrOutliner > xDrawOutliner( SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, this ) );
844 	ImpSetOutlinerDefaults(xDrawOutliner.get(), sal_True);
845 	xDrawOutliner->SetTextObj(pObj);
846 	return xDrawOutliner;
847 }
848 
GetFormattingTextObj() const849 const SdrTextObj* SdrModel::GetFormattingTextObj() const
850 {
851 	if (pDrawOutliner!=NULL) {
852 		return pDrawOutliner->GetTextObj();
853 	}
854 	return NULL;
855 }
856 
ImpSetOutlinerDefaults(SdrOutliner * pOutliner,sal_Bool bInit)857 void SdrModel::ImpSetOutlinerDefaults( SdrOutliner* pOutliner, sal_Bool bInit )
858 {
859 	/**************************************************************************
860 	* Initialisierung der Outliner fuer Textausgabe und HitTest
861 	**************************************************************************/
862 	if( bInit )
863 	{
864 		pOutliner->EraseVirtualDevice();
865 		pOutliner->SetUpdateMode(sal_False);
866 		pOutliner->SetEditTextObjectPool(pItemPool);
867 		pOutliner->SetDefTab(nDefaultTabulator);
868 	}
869 
870 	pOutliner->SetRefDevice(GetRefDevice());
871 	pOutliner->SetForbiddenCharsTable(GetForbiddenCharsTable());
872 	pOutliner->SetAsianCompressionMode( mnCharCompressType );
873 	pOutliner->SetKernAsianPunctuation( IsKernAsianPunctuation() );
874     pOutliner->SetAddExtLeading( IsAddExtLeading() );
875 
876 	if ( !GetRefDevice() )
877 	{
878 		MapMode aMapMode(eObjUnit, Point(0,0), aObjUnit, aObjUnit);
879 		pOutliner->SetRefMapMode(aMapMode);
880 	}
881 }
882 
SetRefDevice(OutputDevice * pDev)883 void SdrModel::SetRefDevice(OutputDevice* pDev)
884 {
885 	pRefOutDev=pDev;
886 	ImpSetOutlinerDefaults( pDrawOutliner );
887 	ImpSetOutlinerDefaults( pHitTestOutliner );
888 	RefDeviceChanged();
889 }
890 
ImpReformatAllTextObjects()891 void SdrModel::ImpReformatAllTextObjects()
892 {
893 	if( isLocked() )
894 		return;
895 
896 	sal_uInt16 nAnz=GetMasterPageCount();
897 	sal_uInt16 nNum;
898 	for (nNum=0; nNum<nAnz; nNum++) {
899 		GetMasterPage(nNum)->ReformatAllTextObjects();
900 	}
901 	nAnz=GetPageCount();
902 	for (nNum=0; nNum<nAnz; nNum++) {
903 		GetPage(nNum)->ReformatAllTextObjects();
904 	}
905 }
906 
907 /** #103122#
908 	steps over all available pages and sends notify messages to
909 	all edge objects that are connected to other objects so that
910 	they may reposition itselfs
911 */
ImpReformatAllEdgeObjects()912 void SdrModel::ImpReformatAllEdgeObjects()
913 {
914 	if( isLocked() )
915 		return;
916 
917 	sal_uInt16 nAnz=GetMasterPageCount();
918 	sal_uInt16 nNum;
919 	for (nNum=0; nNum<nAnz; nNum++)
920 	{
921 		GetMasterPage(nNum)->ReformatAllEdgeObjects();
922 	}
923 	nAnz=GetPageCount();
924 	for (nNum=0; nNum<nAnz; nNum++)
925 	{
926 		GetPage(nNum)->ReformatAllEdgeObjects();
927 	}
928 }
929 
GetDocumentStream(SdrDocumentStreamInfo &) const930 SvStream* SdrModel::GetDocumentStream(SdrDocumentStreamInfo& /*rStreamInfo*/) const
931 {
932 	return NULL;
933 }
934 
935 // Die Vorlagenattribute der Zeichenobjekte in harte Attribute verwandeln.
BurnInStyleSheetAttributes()936 void SdrModel::BurnInStyleSheetAttributes()
937 {
938 	sal_uInt16 nAnz=GetMasterPageCount();
939 	sal_uInt16 nNum;
940 	for (nNum=0; nNum<nAnz; nNum++) {
941 		GetMasterPage(nNum)->BurnInStyleSheetAttributes();
942 	}
943 	nAnz=GetPageCount();
944 	for (nNum=0; nNum<nAnz; nNum++) {
945 		GetPage(nNum)->BurnInStyleSheetAttributes();
946 	}
947 }
948 
RefDeviceChanged()949 void SdrModel::RefDeviceChanged()
950 {
951 	Broadcast(SdrHint(HINT_REFDEVICECHG));
952 	ImpReformatAllTextObjects();
953 }
954 
SetDefaultFontHeight(sal_uIntPtr nVal)955 void SdrModel::SetDefaultFontHeight(sal_uIntPtr nVal)
956 {
957 	if (nVal!=nDefTextHgt) {
958 		nDefTextHgt=nVal;
959 		Broadcast(SdrHint(HINT_DEFFONTHGTCHG));
960 		ImpReformatAllTextObjects();
961 	}
962 }
963 
SetDefaultTabulator(sal_uInt16 nVal)964 void SdrModel::SetDefaultTabulator(sal_uInt16 nVal)
965 {
966 	if (nDefaultTabulator!=nVal) {
967 		nDefaultTabulator=nVal;
968 		Outliner& rOutliner=GetDrawOutliner();
969 		rOutliner.SetDefTab(nVal);
970 		Broadcast(SdrHint(HINT_DEFAULTTABCHG));
971 		ImpReformatAllTextObjects();
972 	}
973 }
974 
ImpSetUIUnit()975 void SdrModel::ImpSetUIUnit()
976 {
977 	if(0 == aUIScale.GetNumerator() || 0 == aUIScale.GetDenominator())
978     {
979         aUIScale = Fraction(1,1);
980     }
981 
982     // set start values
983 	nUIUnitKomma = 0;
984 	sal_Int64 nMul(1);
985 	sal_Int64 nDiv(1);
986 
987 	// normalize on meters resp. inch
988 	switch (eObjUnit)
989     {
990 		case MAP_100TH_MM   : nUIUnitKomma+=5; break;
991 		case MAP_10TH_MM    : nUIUnitKomma+=4; break;
992 		case MAP_MM         : nUIUnitKomma+=3; break;
993 		case MAP_CM         : nUIUnitKomma+=2; break;
994 		case MAP_1000TH_INCH: nUIUnitKomma+=3; break;
995 		case MAP_100TH_INCH : nUIUnitKomma+=2; break;
996 		case MAP_10TH_INCH  : nUIUnitKomma+=1; break;
997 		case MAP_INCH       : nUIUnitKomma+=0; break;
998 		case MAP_POINT      : nDiv=72;     break;          // 1Pt   = 1/72"
999 		case MAP_TWIP       : nDiv=144; nUIUnitKomma++; break; // 1Twip = 1/1440"
1000 		case MAP_PIXEL      : break;
1001 		case MAP_SYSFONT    : break;
1002 		case MAP_APPFONT    : break;
1003 		case MAP_RELATIVE   : break;
1004 		default: break;
1005 	} // switch
1006 
1007 	// 1 mile    =  8 furlong = 63.360" = 1.609.344,0mm
1008 	// 1 furlong = 10 chains  =  7.920" =   201.168,0mm
1009 	// 1 chain   =  4 poles   =    792" =    20.116,8mm
1010 	// 1 pole    =  5 1/2 yd  =    198" =     5.029,2mm
1011 	// 1 yd      =  3 ft      =     36" =       914,4mm
1012 	// 1 ft      = 12 "       =      1" =       304,8mm
1013 	switch (eUIUnit)
1014     {
1015 		case FUNIT_NONE   : break;
1016 		// Metrisch
1017 		case FUNIT_100TH_MM: nUIUnitKomma-=5; break;
1018 		case FUNIT_MM     : nUIUnitKomma-=3; break;
1019 		case FUNIT_CM     : nUIUnitKomma-=2; break;
1020 		case FUNIT_M      : nUIUnitKomma+=0; break;
1021 		case FUNIT_KM     : nUIUnitKomma+=3; break;
1022 		// Inch
1023 		case FUNIT_TWIP   : nMul=144; nUIUnitKomma--;  break;  // 1Twip = 1/1440"
1024 		case FUNIT_POINT  : nMul=72;     break;            // 1Pt   = 1/72"
1025 		case FUNIT_PICA   : nMul=6;      break;            // 1Pica = 1/6"  ?
1026 		case FUNIT_INCH   : break;                         // 1"    = 1"
1027 		case FUNIT_FOOT   : nDiv*=12;    break;            // 1Ft   = 12"
1028 		case FUNIT_MILE   : nDiv*=6336; nUIUnitKomma++; break; // 1mile = 63360"
1029 		// sonstiges
1030 		case FUNIT_CUSTOM : break;
1031 		case FUNIT_PERCENT: nUIUnitKomma+=2; break;
1032 	} // switch
1033 
1034     // check if mapping is from metric to inch and adapt
1035 	const bool bMapInch(IsInch(eObjUnit));
1036 	const bool bUIMetr(IsMetric(eUIUnit));
1037 
1038     if (bMapInch && bUIMetr)
1039     {
1040 		nUIUnitKomma += 4;
1041 		nMul *= 254;
1042 	}
1043 
1044     // check if mapping is from inch to metric and adapt
1045 	const bool bMapMetr(IsMetric(eObjUnit));
1046 	const bool bUIInch(IsInch(eUIUnit));
1047 
1048     if (bMapMetr && bUIInch)
1049     {
1050 		nUIUnitKomma -= 4;
1051 		nDiv *= 254;
1052 	}
1053 
1054 	// use temporary fraction for reduction (fallback to 32bit here),
1055     // may need to be changed in the future, too
1056     if(1 != nMul || 1 != nDiv)
1057     {
1058         const Fraction aTemp(static_cast< long >(nMul), static_cast< long >(nDiv));
1059         nMul = aTemp.GetNumerator();
1060         nDiv = aTemp.GetDenominator();
1061     }
1062 
1063     // #i89872# take Unit of Measurement into account
1064     if(1 != aUIScale.GetDenominator() || 1 != aUIScale.GetNumerator())
1065     {
1066         // divide by UIScale
1067 	    nMul *= aUIScale.GetDenominator();
1068 	    nDiv *= aUIScale.GetNumerator();
1069     }
1070 
1071     // shorten trailing zeroes for dividend
1072     while(0 == (nMul % 10))
1073     {
1074 	    nUIUnitKomma--;
1075 	    nMul /= 10;
1076     }
1077 
1078     // shorten trailing zeroes for divisor
1079     while(0 == (nDiv % 10))
1080     {
1081 	    nUIUnitKomma++;
1082 	    nDiv /= 10;
1083     }
1084 
1085     // end preparations, set member values
1086     aUIUnitFact = Fraction(sal_Int32(nMul), sal_Int32(nDiv));
1087 	bUIOnlyKomma = (nMul == nDiv);
1088 	TakeUnitStr(eUIUnit, aUIUnitStr);
1089 }
1090 
SetScaleUnit(MapUnit eMap,const Fraction & rFrac)1091 void SdrModel::SetScaleUnit(MapUnit eMap, const Fraction& rFrac)
1092 {
1093 	if (eObjUnit!=eMap || aObjUnit!=rFrac) {
1094 		eObjUnit=eMap;
1095 		aObjUnit=rFrac;
1096 		pItemPool->SetDefaultMetric((SfxMapUnit)eObjUnit);
1097 		ImpSetUIUnit();
1098 		ImpSetOutlinerDefaults( pDrawOutliner );
1099 		ImpSetOutlinerDefaults( pHitTestOutliner );
1100 		ImpReformatAllTextObjects(); // #40424#
1101 	}
1102 }
1103 
SetScaleUnit(MapUnit eMap)1104 void SdrModel::SetScaleUnit(MapUnit eMap)
1105 {
1106 	if (eObjUnit!=eMap) {
1107 		eObjUnit=eMap;
1108 		pItemPool->SetDefaultMetric((SfxMapUnit)eObjUnit);
1109 		ImpSetUIUnit();
1110 		ImpSetOutlinerDefaults( pDrawOutliner );
1111 		ImpSetOutlinerDefaults( pHitTestOutliner );
1112 		ImpReformatAllTextObjects(); // #40424#
1113 	}
1114 }
1115 
SetScaleFraction(const Fraction & rFrac)1116 void SdrModel::SetScaleFraction(const Fraction& rFrac)
1117 {
1118 	if (aObjUnit!=rFrac) {
1119 		aObjUnit=rFrac;
1120 		ImpSetUIUnit();
1121 		ImpSetOutlinerDefaults( pDrawOutliner );
1122 		ImpSetOutlinerDefaults( pHitTestOutliner );
1123 		ImpReformatAllTextObjects(); // #40424#
1124 	}
1125 }
1126 
SetUIUnit(FieldUnit eUnit)1127 void SdrModel::SetUIUnit(FieldUnit eUnit)
1128 {
1129 	if (eUIUnit!=eUnit) {
1130 		eUIUnit=eUnit;
1131 		ImpSetUIUnit();
1132 		ImpReformatAllTextObjects(); // #40424#
1133 	}
1134 }
1135 
SetUIScale(const Fraction & rScale)1136 void SdrModel::SetUIScale(const Fraction& rScale)
1137 {
1138 	if (aUIScale!=rScale) {
1139 		aUIScale=rScale;
1140 		ImpSetUIUnit();
1141 		ImpReformatAllTextObjects(); // #40424#
1142 	}
1143 }
1144 
SetUIUnit(FieldUnit eUnit,const Fraction & rScale)1145 void SdrModel::SetUIUnit(FieldUnit eUnit, const Fraction& rScale)
1146 {
1147 	if (eUIUnit!=eUnit || aUIScale!=rScale) {
1148 		eUIUnit=eUnit;
1149 		aUIScale=rScale;
1150 		ImpSetUIUnit();
1151 		ImpReformatAllTextObjects(); // #40424#
1152 	}
1153 }
1154 
TakeUnitStr(FieldUnit eUnit,XubString & rStr)1155 void SdrModel::TakeUnitStr(FieldUnit eUnit, XubString& rStr)
1156 {
1157 	switch(eUnit)
1158 	{
1159 		default:
1160 		case FUNIT_NONE   :
1161 		case FUNIT_CUSTOM :
1162 		{
1163 			rStr = String();
1164 			break;
1165 		}
1166 		case FUNIT_100TH_MM:
1167 		{
1168 			const sal_Char aText[] = "/100mm";
1169 			rStr = UniString(aText, sizeof(aText)-1);
1170 			break;
1171 		}
1172 		case FUNIT_MM     :
1173 		{
1174 			const sal_Char aText[] = "mm";
1175 			rStr = UniString(aText, sizeof(aText)-1);
1176 			break;
1177 		}
1178 		case FUNIT_CM     :
1179 		{
1180 			const sal_Char aText[] = "cm";
1181 			rStr = UniString(aText, sizeof(aText)-1);
1182 			break;
1183 		}
1184 		case FUNIT_M      :
1185 		{
1186 			rStr = String();
1187 			rStr += sal_Unicode('m');
1188 			break;
1189 		}
1190 		case FUNIT_KM     :
1191 		{
1192 			const sal_Char aText[] = "km";
1193 			rStr = UniString(aText, sizeof(aText)-1);
1194 			break;
1195 		}
1196 		case FUNIT_TWIP   :
1197 		{
1198 			const sal_Char aText[] = "twip";
1199 			rStr = UniString(aText, sizeof(aText)-1);
1200 			break;
1201 		}
1202 		case FUNIT_POINT  :
1203 		{
1204 			const sal_Char aText[] = "pt";
1205 			rStr = UniString(aText, sizeof(aText)-1);
1206 			break;
1207 		}
1208 		case FUNIT_PICA   :
1209 		{
1210 			sal_Char aText[] = "pica";
1211 			rStr = UniString(aText, sizeof(aText)-1);
1212 			break;
1213 		}
1214 		case FUNIT_INCH   :
1215 		{
1216 			rStr = String();
1217 			rStr += sal_Unicode('"');
1218 			break;
1219 		}
1220 		case FUNIT_FOOT   :
1221 		{
1222 			const sal_Char aText[] = "ft";
1223 			rStr = UniString(aText, sizeof(aText)-1);
1224 			break;
1225 		}
1226 		case FUNIT_MILE   :
1227 		{
1228 			const sal_Char aText[] = "mile(s)";
1229 			rStr = UniString(aText, sizeof(aText)-1);
1230 			break;
1231 		}
1232 		case FUNIT_PERCENT:
1233 		{
1234 			rStr = String();
1235 			rStr += sal_Unicode('%');
1236 			break;
1237 		}
1238 	}
1239 }
1240 
TakeMetricStr(long nVal,XubString & rStr,FASTBOOL bNoUnitChars,sal_Int32 nNumDigits) const1241 void SdrModel::TakeMetricStr(long nVal, XubString& rStr, FASTBOOL bNoUnitChars, sal_Int32 nNumDigits) const
1242 {
1243 	// #i22167#
1244 	// change to double precision usage to not loose decimal places after comma
1245 	const bool bNegative(nVal < 0L);
1246     SvtSysLocale aSysLoc;
1247     const LocaleDataWrapper& rLoc(aSysLoc.GetLocaleData());
1248 	double fLocalValue(double(nVal) * double(aUIUnitFact));
1249 
1250 	if(bNegative)
1251 	{
1252 		fLocalValue = -fLocalValue;
1253 	}
1254 
1255 	if( -1 == nNumDigits )
1256 	{
1257 		nNumDigits = rLoc.getNumDigits();
1258 	}
1259 
1260 	sal_Int32 nKomma(nUIUnitKomma);
1261 
1262 	if(nKomma > nNumDigits)
1263 	{
1264 		const sal_Int32 nDiff(nKomma - nNumDigits);
1265 		const double fFactor(pow(10.0, static_cast<const int>(nDiff)));
1266 
1267 		fLocalValue /= fFactor;
1268 		nKomma = nNumDigits;
1269 	}
1270 	else if(nKomma < nNumDigits)
1271 	{
1272 		const sal_Int32 nDiff(nNumDigits - nKomma);
1273 		const double fFactor(pow(10.0, static_cast<const int>(nDiff)));
1274 
1275 		fLocalValue *= fFactor;
1276 		nKomma = nNumDigits;
1277 	}
1278 
1279 	rStr = UniString::CreateFromInt32(static_cast<sal_Int32>(fLocalValue + 0.5));
1280 
1281 	if(nKomma < 0)
1282 	{
1283 		// Negatives Komma bedeutet: Nullen dran
1284 		sal_Int32 nAnz(-nKomma);
1285 
1286 		for(sal_Int32 i=0; i<nAnz; i++)
1287 			rStr += sal_Unicode('0');
1288 
1289 		nKomma = 0;
1290 	}
1291 
1292 	// #83257# the second condition needs to be <= since inside this loop
1293 	// also the leading zero is inserted.
1294 	if(nKomma > 0 && rStr.Len() <= nKomma)
1295 	{
1296 		// Fuer Komma evtl. vorne Nullen dran
1297 		sal_Int32 nAnz(nKomma - rStr.Len());
1298 
1299         if(nAnz >= 0 && rLoc.isNumLeadingZero())
1300 			nAnz++;
1301 
1302 		for(sal_Int32 i=0; i<nAnz; i++)
1303 			rStr.Insert(sal_Unicode('0'), 0);
1304 	}
1305 
1306     sal_Unicode cDec( rLoc.getNumDecimalSep().GetChar(0) );
1307 
1308 	// KommaChar einfuegen
1309 	sal_Int32 nVorKomma(rStr.Len() - nKomma);
1310 
1311 	if(nKomma > 0)
1312         rStr.Insert(cDec, (xub_StrLen) nVorKomma);
1313 
1314     if(!rLoc.isNumTrailingZeros())
1315 	{
1316 		while(rStr.Len() && rStr.GetChar(rStr.Len() - 1) == sal_Unicode('0'))
1317 			rStr.Erase(rStr.Len() - 1);
1318 
1319 		if(rStr.Len() && rStr.GetChar(rStr.Len() - 1) == cDec)
1320 			rStr.Erase(rStr.Len() - 1);
1321 	}
1322 
1323 	// ggf. Trennpunkte bei jedem Tausender einfuegen
1324     if( nVorKomma > 3 )
1325 	{
1326         String aThoSep( rLoc.getNumThousandSep() );
1327         if ( aThoSep.Len() > 0 )
1328         {
1329             sal_Unicode cTho( aThoSep.GetChar(0) );
1330             sal_Int32 i(nVorKomma - 3);
1331 
1332             while(i > 0) // #78311#
1333             {
1334                 rStr.Insert(cTho, (xub_StrLen)i);
1335                 i -= 3;
1336             }
1337         }
1338 	}
1339 
1340 	if(!rStr.Len())
1341 	{
1342 		rStr = String();
1343 		rStr += sal_Unicode('0');
1344 	}
1345 
1346 	if(bNegative)
1347 	{
1348 		rStr.Insert(sal_Unicode('-'), 0);
1349 	}
1350 
1351 	if(!bNoUnitChars)
1352 		rStr += aUIUnitStr;
1353 }
1354 
TakeWinkStr(long nWink,XubString & rStr,FASTBOOL bNoDegChar) const1355 void SdrModel::TakeWinkStr(long nWink, XubString& rStr, FASTBOOL bNoDegChar) const
1356 {
1357 	sal_Bool bNeg(nWink < 0);
1358 
1359 	if(bNeg)
1360 		nWink = -nWink;
1361 
1362 	rStr = UniString::CreateFromInt32(nWink);
1363 
1364     SvtSysLocale aSysLoc;
1365     const LocaleDataWrapper& rLoc = aSysLoc.GetLocaleData();
1366 	xub_StrLen nAnz(2);
1367 
1368     if(rLoc.isNumLeadingZero())
1369 		nAnz++;
1370 
1371 	while(rStr.Len() < nAnz)
1372 		rStr.Insert(sal_Unicode('0'), 0);
1373 
1374     rStr.Insert(rLoc.getNumDecimalSep().GetChar(0), rStr.Len() - 2);
1375 
1376 	if(bNeg)
1377 		rStr.Insert(sal_Unicode('-'), 0);
1378 
1379 	if(!bNoDegChar)
1380 		rStr += DEGREE_CHAR;
1381 }
1382 
TakePercentStr(const Fraction & rVal,XubString & rStr,FASTBOOL bNoPercentChar) const1383 void SdrModel::TakePercentStr(const Fraction& rVal, XubString& rStr, FASTBOOL bNoPercentChar) const
1384 {
1385 	sal_Int32 nMul(rVal.GetNumerator());
1386 	sal_Int32 nDiv(rVal.GetDenominator());
1387 	sal_Bool bNeg(nMul < 0);
1388 
1389 	if(nDiv < 0)
1390 		bNeg = !bNeg;
1391 
1392 	if(nMul < 0)
1393 		nMul = -nMul;
1394 
1395 	if(nDiv < 0)
1396 		nDiv = -nDiv;
1397 
1398 	nMul *= 100;
1399 	nMul += nDiv/2;
1400 	nMul /= nDiv;
1401 
1402 	rStr = UniString::CreateFromInt32(nMul);
1403 
1404 	if(bNeg)
1405 		rStr.Insert(sal_Unicode('-'), 0);
1406 
1407 	if(!bNoPercentChar)
1408 		rStr += sal_Unicode('%');
1409 }
1410 
SetChanged(sal_Bool bFlg)1411 void SdrModel::SetChanged(sal_Bool bFlg)
1412 {
1413 	mbChanged = bFlg;
1414 }
1415 
RecalcPageNums(FASTBOOL bMaster)1416 void SdrModel::RecalcPageNums(FASTBOOL bMaster)
1417 {
1418 	Container& rPL=*(bMaster ? &maMaPag : &maPages);
1419 	sal_uInt16 nAnz=sal_uInt16(rPL.Count());
1420 	sal_uInt16 i;
1421 	for (i=0; i<nAnz; i++) {
1422 		SdrPage* pPg=(SdrPage*)(rPL.GetObject(i));
1423 		pPg->SetPageNum(i);
1424 	}
1425 	if (bMaster) bMPgNumsDirty=sal_False;
1426 	else bPagNumsDirty=sal_False;
1427 }
1428 
InsertPage(SdrPage * pPage,sal_uInt16 nPos)1429 void SdrModel::InsertPage(SdrPage* pPage, sal_uInt16 nPos)
1430 {
1431 	sal_uInt16 nAnz=GetPageCount();
1432 	if (nPos>nAnz) nPos=nAnz;
1433 	maPages.Insert(pPage,nPos);
1434 	// #109538#
1435 	PageListChanged();
1436 	pPage->SetInserted(sal_True);
1437 	pPage->SetPageNum(nPos);
1438 	pPage->SetModel(this);
1439 	if (nPos<nAnz) bPagNumsDirty=sal_True;
1440 	SetChanged();
1441 	SdrHint aHint(HINT_PAGEORDERCHG);
1442 	aHint.SetPage(pPage);
1443 	Broadcast(aHint);
1444 }
1445 
DeletePage(sal_uInt16 nPgNum)1446 void SdrModel::DeletePage(sal_uInt16 nPgNum)
1447 {
1448 	SdrPage* pPg=RemovePage(nPgNum);
1449 	delete pPg;
1450 }
1451 
RemovePage(sal_uInt16 nPgNum)1452 SdrPage* SdrModel::RemovePage(sal_uInt16 nPgNum)
1453 {
1454 	SdrPage* pPg=(SdrPage*)maPages.Remove(nPgNum);
1455 	// #109538#
1456 	PageListChanged();
1457 	if (pPg!=NULL) {
1458 		pPg->SetInserted(sal_False);
1459 	}
1460 	bPagNumsDirty=sal_True;
1461 	SetChanged();
1462 	SdrHint aHint(HINT_PAGEORDERCHG);
1463 	aHint.SetPage(pPg);
1464 	Broadcast(aHint);
1465 	return pPg;
1466 }
1467 
MovePage(sal_uInt16 nPgNum,sal_uInt16 nNewPos)1468 void SdrModel::MovePage(sal_uInt16 nPgNum, sal_uInt16 nNewPos)
1469 {
1470 	SdrPage* pPg=(SdrPage*)maPages.Remove(nPgNum);
1471 	// #109538#
1472 	PageListChanged();
1473 	if (pPg!=NULL) {
1474 		pPg->SetInserted(sal_False);
1475 		InsertPage(pPg,nNewPos);
1476 	}
1477 }
1478 
InsertMasterPage(SdrPage * pPage,sal_uInt16 nPos)1479 void SdrModel::InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos)
1480 {
1481 	sal_uInt16 nAnz=GetMasterPageCount();
1482 	if (nPos>nAnz) nPos=nAnz;
1483 	maMaPag.Insert(pPage,nPos);
1484 	// #109538#
1485 	MasterPageListChanged();
1486 	pPage->SetInserted(sal_True);
1487 	pPage->SetPageNum(nPos);
1488 	pPage->SetModel(this);
1489 	if (nPos<nAnz) {
1490 		bMPgNumsDirty=sal_True;
1491 	}
1492 	SetChanged();
1493 	SdrHint aHint(HINT_PAGEORDERCHG);
1494 	aHint.SetPage(pPage);
1495 	Broadcast(aHint);
1496 }
1497 
DeleteMasterPage(sal_uInt16 nPgNum)1498 void SdrModel::DeleteMasterPage(sal_uInt16 nPgNum)
1499 {
1500 	SdrPage* pPg=RemoveMasterPage(nPgNum);
1501 	if (pPg!=NULL) delete pPg;
1502 }
1503 
RemoveMasterPage(sal_uInt16 nPgNum)1504 SdrPage* SdrModel::RemoveMasterPage(sal_uInt16 nPgNum)
1505 {
1506 	SdrPage* pRetPg=(SdrPage*)maMaPag.Remove(nPgNum);
1507 	// #109538#
1508 	MasterPageListChanged();
1509 
1510 	if(pRetPg)
1511 	{
1512 		// Nun die Verweise der normalen Zeichenseiten auf die entfernte MasterPage loeschen
1513 		sal_uInt16 nPageAnz(GetPageCount());
1514 
1515 		for(sal_uInt16 np(0); np < nPageAnz; np++)
1516 		{
1517 			GetPage(np)->TRG_ImpMasterPageRemoved(*pRetPg);
1518 		}
1519 
1520 		pRetPg->SetInserted(sal_False);
1521 	}
1522 
1523 	bMPgNumsDirty=sal_True;
1524 	SetChanged();
1525 	SdrHint aHint(HINT_PAGEORDERCHG);
1526 	aHint.SetPage(pRetPg);
1527 	Broadcast(aHint);
1528 	return pRetPg;
1529 }
1530 
MoveMasterPage(sal_uInt16 nPgNum,sal_uInt16 nNewPos)1531 void SdrModel::MoveMasterPage(sal_uInt16 nPgNum, sal_uInt16 nNewPos)
1532 {
1533 	SdrPage* pPg=(SdrPage*)maMaPag.Remove(nPgNum);
1534 	// #109538#
1535 	MasterPageListChanged();
1536 	if (pPg!=NULL) {
1537 		pPg->SetInserted(sal_False);
1538 		maMaPag.Insert(pPg,nNewPos);
1539 		// #109538#
1540 		MasterPageListChanged();
1541 	}
1542 	bMPgNumsDirty=sal_True;
1543 	SetChanged();
1544 	SdrHint aHint(HINT_PAGEORDERCHG);
1545 	aHint.SetPage(pPg);
1546 	Broadcast(aHint);
1547 }
1548 
1549 ////////////////////////////////////////////////////////////////////////////////////////////////////
1550 
CheckConsistence() const1551 FASTBOOL SdrModel::CheckConsistence() const
1552 {
1553 	FASTBOOL bRet=sal_True;
1554 #ifdef DBG_UTIL
1555 	DBG_CHKTHIS(SdrModel,NULL);
1556 #endif
1557 	return bRet;
1558 }
1559 
1560 ////////////////////////////////////////////////////////////////////////////////////////////////////
1561 
1562 // #48289#
CopyPages(sal_uInt16 nFirstPageNum,sal_uInt16 nLastPageNum,sal_uInt16 nDestPos,FASTBOOL bUndo,FASTBOOL bMoveNoCopy)1563 void SdrModel::CopyPages(sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
1564 						 sal_uInt16 nDestPos,
1565 						 FASTBOOL bUndo, FASTBOOL bMoveNoCopy)
1566 {
1567 	if( bUndo && !IsUndoEnabled() )
1568 		bUndo = false;
1569 
1570 	if( bUndo )
1571 		BegUndo(ImpGetResStr(STR_UndoMergeModel));
1572 
1573 	sal_uInt16 nPageAnz=GetPageCount();
1574 	sal_uInt16 nMaxPage=nPageAnz;
1575 
1576 	if (nMaxPage!=0)
1577 		nMaxPage--;
1578 	if (nFirstPageNum>nMaxPage)
1579 		nFirstPageNum=nMaxPage;
1580 	if (nLastPageNum>nMaxPage)
1581 		nLastPageNum =nMaxPage;
1582 	FASTBOOL bReverse=nLastPageNum<nFirstPageNum;
1583 	if (nDestPos>nPageAnz)
1584 		nDestPos=nPageAnz;
1585 
1586 	// Zunaechst die Zeiger der betroffenen Seiten in einem Array sichern
1587 	sal_uInt16 nPageNum=nFirstPageNum;
1588 	sal_uInt16 nCopyAnz=((!bReverse)?(nLastPageNum-nFirstPageNum):(nFirstPageNum-nLastPageNum))+1;
1589 	SdrPage** pPagePtrs=new SdrPage*[nCopyAnz];
1590 	sal_uInt16 nCopyNum;
1591 	for(nCopyNum=0; nCopyNum<nCopyAnz; nCopyNum++)
1592 	{
1593 		pPagePtrs[nCopyNum]=GetPage(nPageNum);
1594 		if (bReverse)
1595 			nPageNum--;
1596 		else
1597 			nPageNum++;
1598 	}
1599 
1600 	// Jetzt die Seiten kopieren
1601 	sal_uInt16 nDestNum=nDestPos;
1602 	for (nCopyNum=0; nCopyNum<nCopyAnz; nCopyNum++)
1603 	{
1604 		SdrPage* pPg=pPagePtrs[nCopyNum];
1605 		sal_uInt16 nPageNum2=pPg->GetPageNum();
1606 		if (!bMoveNoCopy)
1607 		{
1608 			const SdrPage* pPg1=GetPage(nPageNum2);
1609 			pPg=pPg1->Clone();
1610 			InsertPage(pPg,nDestNum);
1611 			if (bUndo)
1612 				AddUndo(GetSdrUndoFactory().CreateUndoCopyPage(*pPg));
1613 			nDestNum++;
1614 		}
1615 		else
1616 		{
1617 			// Move ist nicht getestet!
1618 			if (nDestNum>nPageNum2)
1619 				nDestNum--;
1620 
1621 			if(bUndo)
1622 				AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*GetPage(nPageNum2),nPageNum2,nDestNum));
1623 
1624 			pPg=RemovePage(nPageNum2);
1625 			InsertPage(pPg,nDestNum);
1626 			nDestNum++;
1627 		}
1628 
1629 		if(bReverse)
1630 			nPageNum2--;
1631 		else
1632 			nPageNum2++;
1633 	}
1634 
1635 	delete[] pPagePtrs;
1636 	if(bUndo)
1637 		EndUndo();
1638 }
1639 
Merge(SdrModel & rSourceModel,sal_uInt16 nFirstPageNum,sal_uInt16 nLastPageNum,sal_uInt16 nDestPos,FASTBOOL bMergeMasterPages,FASTBOOL bAllMasterPages,FASTBOOL bUndo,FASTBOOL bTreadSourceAsConst)1640 void SdrModel::Merge(SdrModel& rSourceModel,
1641 					 sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
1642 					 sal_uInt16 nDestPos,
1643 					 FASTBOOL bMergeMasterPages, FASTBOOL bAllMasterPages,
1644 					 FASTBOOL bUndo, FASTBOOL bTreadSourceAsConst)
1645 {
1646 	if (&rSourceModel==this)
1647 	{ // #48289#
1648 		CopyPages(nFirstPageNum,nLastPageNum,nDestPos,bUndo,!bTreadSourceAsConst);
1649 		return;
1650 	}
1651 
1652 	if( bUndo && !IsUndoEnabled() )
1653 		bUndo = false;
1654 
1655 	if (bUndo)
1656 		BegUndo(ImpGetResStr(STR_UndoMergeModel));
1657 
1658 	sal_uInt16 nSrcPageAnz=rSourceModel.GetPageCount();
1659 	sal_uInt16 nSrcMasterPageAnz=rSourceModel.GetMasterPageCount();
1660 	sal_uInt16 nDstMasterPageAnz=GetMasterPageCount();
1661 	FASTBOOL bInsPages=(nFirstPageNum<nSrcPageAnz || nLastPageNum<nSrcPageAnz);
1662 	sal_uInt16 nMaxSrcPage=nSrcPageAnz; if (nMaxSrcPage!=0) nMaxSrcPage--;
1663 	if (nFirstPageNum>nMaxSrcPage) nFirstPageNum=nMaxSrcPage;
1664 	if (nLastPageNum>nMaxSrcPage)  nLastPageNum =nMaxSrcPage;
1665 	FASTBOOL bReverse=nLastPageNum<nFirstPageNum;
1666 
1667 	sal_uInt16*   pMasterMap=NULL;
1668 	int* pMasterNeed=NULL;
1669 	sal_uInt16    nMasterNeed=0;
1670 	if (bMergeMasterPages && nSrcMasterPageAnz!=0) {
1671 		// Feststellen, welche MasterPages aus rSrcModel benoetigt werden
1672 		pMasterMap=new sal_uInt16[nSrcMasterPageAnz];
1673 		pMasterNeed=new int[nSrcMasterPageAnz];
1674 		memset(pMasterMap,0xFF,nSrcMasterPageAnz*sizeof(sal_uInt16));
1675 		if (bAllMasterPages) {
1676 			memset(pMasterNeed,sal_True,nSrcMasterPageAnz*sizeof(FASTBOOL));
1677 		} else {
1678 			memset(pMasterNeed,sal_False,nSrcMasterPageAnz*sizeof(FASTBOOL));
1679 			sal_uInt16 nAnf= bReverse ? nLastPageNum : nFirstPageNum;
1680 			sal_uInt16 nEnd= bReverse ? nFirstPageNum : nLastPageNum;
1681 			for (sal_uInt16 i=nAnf; i<=nEnd; i++) {
1682 				const SdrPage* pPg=rSourceModel.GetPage(i);
1683 				if(pPg->TRG_HasMasterPage())
1684 				{
1685 					SdrPage& rMasterPage = pPg->TRG_GetMasterPage();
1686 					sal_uInt16 nMPgNum(rMasterPage.GetPageNum());
1687 
1688 					if(nMPgNum < nSrcMasterPageAnz)
1689 					{
1690 						pMasterNeed[nMPgNum] = sal_True;
1691 					}
1692 				}
1693 			}
1694 		}
1695 		// Nun das Mapping der MasterPages bestimmen
1696 		sal_uInt16 nAktMaPagNum=nDstMasterPageAnz;
1697 		for (sal_uInt16 i=0; i<nSrcMasterPageAnz; i++) {
1698 			if (pMasterNeed[i]) {
1699 				pMasterMap[i]=nAktMaPagNum;
1700 				nAktMaPagNum++;
1701 				nMasterNeed++;
1702 			}
1703 		}
1704 	}
1705 
1706 	// rueberholen der Masterpages
1707 	if (pMasterMap!=NULL && pMasterNeed!=NULL && nMasterNeed!=0) {
1708 		for (sal_uInt16 i=nSrcMasterPageAnz; i>0;) {
1709 			i--;
1710 			if (pMasterNeed[i]) {
1711 				SdrPage* pPg=NULL;
1712 				if (bTreadSourceAsConst) {
1713 					const SdrPage* pPg1=rSourceModel.GetMasterPage(i);
1714 					pPg=pPg1->Clone();
1715 				} else {
1716 					pPg=rSourceModel.RemoveMasterPage(i);
1717 				}
1718 				if (pPg!=NULL) {
1719 					// und alle ans einstige Ende des DstModel reinschieben.
1720 					// nicht InsertMasterPage() verwenden da die Sache
1721 					// inkonsistent ist bis alle drin sind
1722 					maMaPag.Insert(pPg,nDstMasterPageAnz);
1723 					// #109538#
1724 					MasterPageListChanged();
1725 					pPg->SetInserted(sal_True);
1726 					pPg->SetModel(this);
1727 					bMPgNumsDirty=sal_True;
1728 					if (bUndo) AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pPg));
1729 				} else {
1730 					DBG_ERROR("SdrModel::Merge(): MasterPage im SourceModel nicht gefunden");
1731 				}
1732 			}
1733 		}
1734 	}
1735 
1736 	// rueberholen der Zeichenseiten
1737 	if (bInsPages) {
1738 		sal_uInt16 nSourcePos=nFirstPageNum;
1739 		sal_uInt16 nMergeCount=sal_uInt16(Abs((long)((long)nFirstPageNum-nLastPageNum))+1);
1740 		if (nDestPos>GetPageCount()) nDestPos=GetPageCount();
1741 		while (nMergeCount>0) {
1742 			SdrPage* pPg=NULL;
1743 			if (bTreadSourceAsConst) {
1744 				const SdrPage* pPg1=rSourceModel.GetPage(nSourcePos);
1745 				pPg=pPg1->Clone();
1746 			} else {
1747 				pPg=rSourceModel.RemovePage(nSourcePos);
1748 			}
1749 			if (pPg!=NULL) {
1750 				InsertPage(pPg,nDestPos);
1751 				if (bUndo) AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pPg));
1752 				// und nun zu den MasterPageDescriptoren
1753 
1754 				if(pPg->TRG_HasMasterPage())
1755 				{
1756 					SdrPage& rMasterPage = pPg->TRG_GetMasterPage();
1757 					sal_uInt16 nMaPgNum(rMasterPage.GetPageNum());
1758 
1759 					if (bMergeMasterPages)
1760 					{
1761 						sal_uInt16 nNeuNum(0xFFFF);
1762 
1763 						if(pMasterMap)
1764 						{
1765 							nNeuNum = pMasterMap[nMaPgNum];
1766 						}
1767 
1768 						if(nNeuNum != 0xFFFF)
1769 						{
1770 							if(bUndo)
1771 							{
1772 								AddUndo(GetSdrUndoFactory().CreateUndoPageChangeMasterPage(*pPg));
1773 							}
1774 
1775 							pPg->TRG_SetMasterPage(*GetMasterPage(nNeuNum));
1776 						}
1777 						DBG_ASSERT(nNeuNum!=0xFFFF,"SdrModel::Merge(): Irgendwas ist krumm beim Mappen der MasterPages");
1778 					} else {
1779 						if (nMaPgNum>=nDstMasterPageAnz) {
1780 							// Aha, die ist ausserbalb des urspruenglichen Bereichs der Masterpages des DstModel
1781 							pPg->TRG_ClearMasterPage();
1782 						}
1783 					}
1784 				}
1785 
1786 			} else {
1787 				DBG_ERROR("SdrModel::Merge(): Zeichenseite im SourceModel nicht gefunden");
1788 			}
1789 			nDestPos++;
1790 			if (bReverse) nSourcePos--;
1791 			else if (bTreadSourceAsConst) nSourcePos++;
1792 			nMergeCount--;
1793 		}
1794 	}
1795 
1796 	delete [] pMasterMap;
1797 	delete [] pMasterNeed;
1798 
1799 	bMPgNumsDirty=sal_True;
1800 	bPagNumsDirty=sal_True;
1801 
1802 	SetChanged();
1803 	// Fehlt: Mergen und Mapping der Layer
1804 	// an den Objekten sowie an den MasterPageDescriptoren
1805 	if (bUndo) EndUndo();
1806 }
1807 
SetStarDrawPreviewMode(sal_Bool bPreview)1808 void SdrModel::SetStarDrawPreviewMode(sal_Bool bPreview)
1809 {
1810 	if (!bPreview && bStarDrawPreviewMode && GetPageCount())
1811 	{
1812 		// Das Zuruecksetzen ist nicht erlaubt, da das Model ev. nicht vollstaendig geladen wurde
1813 		DBG_ASSERT(sal_False,"SdrModel::SetStarDrawPreviewMode(): Zuruecksetzen nicht erlaubt, da Model ev. nicht vollstaendig");
1814 	}
1815 	else
1816 	{
1817 		bStarDrawPreviewMode = bPreview;
1818 	}
1819 }
1820 
getUnoModel()1821 uno::Reference< uno::XInterface > SdrModel::getUnoModel()
1822 {
1823 	if( !mxUnoModel.is() )
1824 		mxUnoModel = createUnoModel();
1825 
1826 	return mxUnoModel;
1827 }
1828 
setUnoModel(::com::sun::star::uno::Reference<::com::sun::star::uno::XInterface> xModel)1829 void SdrModel::setUnoModel( ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xModel )
1830 {
1831     mxUnoModel = xModel;
1832 }
1833 
createUnoModel()1834 uno::Reference< uno::XInterface > SdrModel::createUnoModel()
1835 {
1836 	DBG_ERROR( "SdrModel::createUnoModel() - base implementation should not be called!" );
1837 	::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xInt;
1838 	return xInt;
1839 }
1840 
setLock(sal_Bool bLock)1841 void SdrModel::setLock( sal_Bool bLock )
1842 {
1843 	if( mbModelLocked != bLock )
1844 	{
1845         // #120437# need to set first, else ImpReformatAllEdgeObjects will do nothing
1846 		mbModelLocked = bLock;
1847 
1848         if( sal_False == bLock )
1849 		{
1850 			// ReformatAllTextObjects(); #103122# due to a typo in the above if, this code was never
1851 			//							 executed, so I remove it until we discover that we need it here
1852 			ImpReformatAllEdgeObjects();	// #103122#
1853 		}
1854 	}
1855 }
1856 
1857 ////////////////////////////////////////////////////////////////////////////////////////////////////
1858 
MigrateItemSet(const SfxItemSet * pSourceSet,SfxItemSet * pDestSet,SdrModel * pNewModel)1859 void SdrModel::MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSet, SdrModel* pNewModel )
1860 {
1861 	if( pSourceSet && pDestSet && (pSourceSet != pDestSet ) )
1862 	{
1863 		if( pNewModel == NULL )
1864 			pNewModel = this;
1865 
1866 		SfxWhichIter aWhichIter(*pSourceSet);
1867 		sal_uInt16 nWhich(aWhichIter.FirstWhich());
1868 		const SfxPoolItem *pPoolItem;
1869 
1870 		while(nWhich)
1871 		{
1872 			if(SFX_ITEM_SET == pSourceSet->GetItemState(nWhich, sal_False, &pPoolItem))
1873 			{
1874 				const SfxPoolItem* pItem = pPoolItem;
1875 
1876 				switch( nWhich )
1877 				{
1878 				case XATTR_FILLBITMAP:
1879 					pItem = ((XFillBitmapItem*)pItem)->checkForUniqueItem( pNewModel );
1880 					break;
1881 				case XATTR_LINEDASH:
1882 					pItem = ((XLineDashItem*)pItem)->checkForUniqueItem( pNewModel );
1883 					break;
1884 				case XATTR_LINESTART:
1885 					pItem = ((XLineStartItem*)pItem)->checkForUniqueItem( pNewModel );
1886 					break;
1887 				case XATTR_LINEEND:
1888 					pItem = ((XLineEndItem*)pItem)->checkForUniqueItem( pNewModel );
1889 					break;
1890 				case XATTR_FILLGRADIENT:
1891 					pItem = ((XFillGradientItem*)pItem)->checkForUniqueItem( pNewModel );
1892 					break;
1893 				case XATTR_FILLFLOATTRANSPARENCE:
1894 					// #85953# allow all kinds of XFillFloatTransparenceItem to be set
1895 					pItem = ((XFillFloatTransparenceItem*)pItem)->checkForUniqueItem( pNewModel );
1896 					break;
1897 				case XATTR_FILLHATCH:
1898 					pItem = ((XFillHatchItem*)pItem)->checkForUniqueItem( pNewModel );
1899 					break;
1900 				}
1901 
1902 				// set item
1903 				if( pItem )
1904 				{
1905 					pDestSet->Put(*pItem);
1906 
1907 					// delete item if it was a generated one
1908 					if( pItem != pPoolItem)
1909 						delete (SfxPoolItem*)pItem;
1910 				}
1911 			}
1912 			nWhich = aWhichIter.NextWhich();
1913 		}
1914 	}
1915 }
1916 
1917 ////////////////////////////////////////////////////////////////////////////////////////////////////
1918 
SetForbiddenCharsTable(vos::ORef<SvxForbiddenCharactersTable> xForbiddenChars)1919 void SdrModel::SetForbiddenCharsTable( vos::ORef<SvxForbiddenCharactersTable> xForbiddenChars )
1920 {
1921 	if( mpForbiddenCharactersTable )
1922 		mpForbiddenCharactersTable->release();
1923 
1924 	mpForbiddenCharactersTable = xForbiddenChars.getBodyPtr();
1925 
1926 	if( mpForbiddenCharactersTable )
1927 		mpForbiddenCharactersTable->acquire();
1928 
1929 	ImpSetOutlinerDefaults( pDrawOutliner );
1930 	ImpSetOutlinerDefaults( pHitTestOutliner );
1931 }
1932 
GetForbiddenCharsTable() const1933 vos::ORef<SvxForbiddenCharactersTable> SdrModel::GetForbiddenCharsTable() const
1934 {
1935 	return mpForbiddenCharactersTable;
1936 }
1937 
SetCharCompressType(sal_uInt16 nType)1938 void SdrModel::SetCharCompressType( sal_uInt16 nType )
1939 {
1940 	if( nType != mnCharCompressType )
1941 	{
1942 		mnCharCompressType = nType;
1943 		ImpSetOutlinerDefaults( pDrawOutliner );
1944 		ImpSetOutlinerDefaults( pHitTestOutliner );
1945 	}
1946 }
1947 
SetKernAsianPunctuation(sal_Bool bEnabled)1948 void SdrModel::SetKernAsianPunctuation( sal_Bool bEnabled )
1949 {
1950 	if( mbKernAsianPunctuation != bEnabled )
1951 	{
1952 		mbKernAsianPunctuation = bEnabled;
1953 		ImpSetOutlinerDefaults( pDrawOutliner );
1954 		ImpSetOutlinerDefaults( pHitTestOutliner );
1955 	}
1956 }
1957 
SetAddExtLeading(sal_Bool bEnabled)1958 void SdrModel::SetAddExtLeading( sal_Bool bEnabled )
1959 {
1960     if( mbAddExtLeading != bEnabled )
1961     {
1962         mbAddExtLeading = bEnabled;
1963         ImpSetOutlinerDefaults( pDrawOutliner );
1964         ImpSetOutlinerDefaults( pHitTestOutliner );
1965     }
1966 }
1967 
ReformatAllTextObjects()1968 void SdrModel::ReformatAllTextObjects()
1969 {
1970 	ImpReformatAllTextObjects();
1971 }
1972 
HasTransparentObjects(sal_Bool bCheckForAlphaChannel) const1973 FASTBOOL SdrModel::HasTransparentObjects( sal_Bool bCheckForAlphaChannel ) const
1974 {
1975 	FASTBOOL	bRet = sal_False;
1976 	sal_uInt16		n, nCount;
1977 
1978 	for( n = 0, nCount = GetMasterPageCount(); ( n < nCount ) && !bRet; n++ )
1979 		if( GetMasterPage( n )->HasTransparentObjects( bCheckForAlphaChannel ) )
1980 			bRet = sal_True;
1981 
1982 	if( !bRet )
1983 	{
1984 		for( n = 0, nCount = GetPageCount(); ( n < nCount ) && !bRet; n++ )
1985 			if( GetPage( n )->HasTransparentObjects( bCheckForAlphaChannel ) )
1986 				bRet = sal_True;
1987 	}
1988 
1989 	return bRet;
1990 }
1991 
createOutliner(sal_uInt16 nOutlinerMode)1992 SdrOutliner* SdrModel::createOutliner( sal_uInt16 nOutlinerMode )
1993 {
1994 	if( NULL == mpOutlinerCache )
1995 		mpOutlinerCache = new SdrOutlinerCache(this);
1996 
1997 	return mpOutlinerCache->createOutliner( nOutlinerMode );
1998 }
1999 
disposeOutliner(SdrOutliner * pOutliner)2000 void SdrModel::disposeOutliner( SdrOutliner* pOutliner )
2001 {
2002 	if( mpOutlinerCache )
2003 	{
2004 		mpOutlinerCache->disposeOutliner( pOutliner );
2005 	}
2006 	else
2007 	{
2008 		delete pOutliner;
2009 	}
2010 }
2011 
GetPageNumType() const2012 SvxNumType SdrModel::GetPageNumType() const
2013 {
2014 	return SVX_ARABIC;
2015 }
2016 
GetPage(sal_uInt16 nPgNum) const2017 const SdrPage* SdrModel::GetPage(sal_uInt16 nPgNum) const
2018 {
2019 	DBG_ASSERT(nPgNum < maPages.Count(), "SdrModel::GetPage: Access out of range (!)");
2020 	return (SdrPage*)(maPages.GetObject(nPgNum));
2021 }
2022 
GetPage(sal_uInt16 nPgNum)2023 SdrPage* SdrModel::GetPage(sal_uInt16 nPgNum)
2024 {
2025 	DBG_ASSERT(nPgNum < maPages.Count(), "SdrModel::GetPage: Access out of range (!)");
2026 	return (SdrPage*)(maPages.GetObject(nPgNum));
2027 }
2028 
GetPageCount() const2029 sal_uInt16 SdrModel::GetPageCount() const
2030 {
2031 	return sal_uInt16(maPages.Count());
2032 }
2033 
PageListChanged()2034 void SdrModel::PageListChanged()
2035 {
2036 }
2037 
GetMasterPage(sal_uInt16 nPgNum) const2038 const SdrPage* SdrModel::GetMasterPage(sal_uInt16 nPgNum) const
2039 {
2040 	DBG_ASSERT(nPgNum < maMaPag.Count(), "SdrModel::GetMasterPage: Access out of range (!)");
2041 	return (SdrPage*)(maMaPag.GetObject(nPgNum));
2042 }
2043 
GetMasterPage(sal_uInt16 nPgNum)2044 SdrPage* SdrModel::GetMasterPage(sal_uInt16 nPgNum)
2045 {
2046 	DBG_ASSERT(nPgNum < maMaPag.Count(), "SdrModel::GetMasterPage: Access out of range (!)");
2047 	return (SdrPage*)(maMaPag.GetObject(nPgNum));
2048 }
2049 
GetMasterPageCount() const2050 sal_uInt16 SdrModel::GetMasterPageCount() const
2051 {
2052 	return sal_uInt16(maMaPag.Count());
2053 }
2054 
MasterPageListChanged()2055 void SdrModel::MasterPageListChanged()
2056 {
2057 }
2058 
SetSdrUndoManager(SfxUndoManager * pUndoManager)2059 void SdrModel::SetSdrUndoManager( SfxUndoManager* pUndoManager )
2060 {
2061 	mpImpl->mpUndoManager = pUndoManager;
2062 }
2063 
GetSdrUndoManager() const2064 SfxUndoManager* SdrModel::GetSdrUndoManager() const
2065 {
2066     return mpImpl->mpUndoManager;
2067 }
2068 
GetSdrUndoFactory() const2069 SdrUndoFactory& SdrModel::GetSdrUndoFactory() const
2070 {
2071 	if( !mpImpl->mpUndoFactory )
2072 		mpImpl->mpUndoFactory = new SdrUndoFactory;
2073 	return *mpImpl->mpUndoFactory;
2074 }
2075 
SetSdrUndoFactory(SdrUndoFactory * pUndoFactory)2076 void SdrModel::SetSdrUndoFactory( SdrUndoFactory* pUndoFactory )
2077 {
2078 	if( pUndoFactory && (pUndoFactory != mpImpl->mpUndoFactory) )
2079 	{
2080 		delete mpImpl->mpUndoFactory;
2081 		mpImpl->mpUndoFactory = pUndoFactory;
2082 	}
2083 }
2084 
2085 /** cl: added this for OJ to complete his reporting engine, does not work
2086 	correctly so only enable it for his model */
IsAllowShapePropertyChangeListener() const2087 bool SdrModel::IsAllowShapePropertyChangeListener() const
2088 {
2089 	return mpImpl && mpImpl->mbAllowShapePropertyChangeListener;
2090 }
2091 
SetAllowShapePropertyChangeListener(bool bAllow)2092 void SdrModel::SetAllowShapePropertyChangeListener( bool bAllow )
2093 {
2094 	if( mpImpl )
2095 	{
2096 		mpImpl->mbAllowShapePropertyChangeListener = bAllow;
2097 	}
2098 }
2099 
getUnoTunnelImplementationId()2100 const ::com::sun::star::uno::Sequence< sal_Int8 >& SdrModel::getUnoTunnelImplementationId()
2101 {
2102 	static ::com::sun::star::uno::Sequence< sal_Int8 > * pSeq = 0;
2103 	if( !pSeq )
2104 	{
2105 		::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
2106 		if( !pSeq )
2107 		{
2108 			static Sequence< sal_Int8 > aSeq( 16 );
2109 			rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
2110 			pSeq = &aSeq;
2111 		}
2112 	}
2113 	return *pSeq;
2114 }
2115 
2116 ////////////////////////////////////////////////////////////////////////////////////////////////////
2117 
SetColorTableAtSdrModel(XColorListSharedPtr aTable)2118 void SdrModel::SetColorTableAtSdrModel(XColorListSharedPtr aTable)
2119 {
2120     maColorTable = aTable;
2121 }
2122 
GetColorTableFromSdrModel() const2123 XColorListSharedPtr SdrModel::GetColorTableFromSdrModel() const
2124 {
2125     if(!maColorTable.get())
2126     {
2127         const_cast< SdrModel* >(this)->maColorTable = XPropertyListFactory::CreateSharedXColorList(aTablePath);
2128     }
2129 
2130     return maColorTable;
2131 }
2132 
SetDashListAtSdrModel(XDashListSharedPtr aList)2133 void SdrModel::SetDashListAtSdrModel(XDashListSharedPtr aList)
2134 {
2135     maDashList = aList;
2136 }
2137 
GetDashListFromSdrModel() const2138 XDashListSharedPtr SdrModel::GetDashListFromSdrModel() const
2139 {
2140     if(!maDashList.get())
2141     {
2142         const_cast< SdrModel* >(this)->maDashList = XPropertyListFactory::CreateSharedXDashList(aTablePath);
2143     }
2144 
2145     return maDashList;
2146 }
2147 
SetLineEndListAtSdrModel(XLineEndListSharedPtr aList)2148 void SdrModel::SetLineEndListAtSdrModel(XLineEndListSharedPtr aList)
2149 {
2150     maLineEndList = aList;
2151 }
2152 
GetLineEndListFromSdrModel() const2153 XLineEndListSharedPtr SdrModel::GetLineEndListFromSdrModel() const
2154 {
2155     if(!maLineEndList.get())
2156     {
2157         const_cast< SdrModel* >(this)->maLineEndList = XPropertyListFactory::CreateSharedXLineEndList(aTablePath);
2158     }
2159 
2160     return maLineEndList;
2161 }
2162 
SetHatchListAtSdrModel(XHatchListSharedPtr aList)2163 void SdrModel::SetHatchListAtSdrModel(XHatchListSharedPtr aList)
2164 {
2165     maHatchList = aList;
2166 }
2167 
GetHatchListFromSdrModel() const2168 XHatchListSharedPtr SdrModel::GetHatchListFromSdrModel() const
2169 {
2170     if(!maHatchList.get())
2171     {
2172         const_cast< SdrModel* >(this)->maHatchList = XPropertyListFactory::CreateSharedXHatchList(aTablePath);
2173     }
2174 
2175     return maHatchList;
2176 }
2177 
SetGradientListAtSdrModel(XGradientListSharedPtr aList)2178 void SdrModel::SetGradientListAtSdrModel(XGradientListSharedPtr aList)
2179 {
2180     maGradientList = aList;
2181 }
2182 
GetGradientListFromSdrModel() const2183 XGradientListSharedPtr SdrModel::GetGradientListFromSdrModel() const
2184 {
2185     if(!maGradientList.get())
2186     {
2187         const_cast< SdrModel* >(this)->maGradientList = XPropertyListFactory::CreateSharedXGradientList(aTablePath);
2188     }
2189 
2190     return maGradientList;
2191 }
2192 
SetBitmapListAtSdrModel(XBitmapListSharedPtr aList)2193 void SdrModel::SetBitmapListAtSdrModel(XBitmapListSharedPtr aList)
2194 {
2195     maBitmapList = aList;
2196 }
2197 
GetBitmapListFromSdrModel() const2198 XBitmapListSharedPtr SdrModel::GetBitmapListFromSdrModel() const
2199 {
2200     if(!maBitmapList.get())
2201     {
2202         const_cast< SdrModel* >(this)->maBitmapList = XPropertyListFactory::CreateSharedXBitmapList(aTablePath);
2203     }
2204 
2205     return maBitmapList;
2206 }
2207 
2208 ////////////////////////////////////////////////////////////////////////////////////////////////////
2209 
2210 TYPEINIT1(SdrHint,SfxHint);
2211 
SdrHint()2212 SdrHint::SdrHint()
2213 :	mpPage(0L),
2214 	mpObj(0L),
2215 	mpObjList(0L),
2216 	meHint(HINT_UNKNOWN)
2217 {
2218 }
2219 
SdrHint(SdrHintKind eNewHint)2220 SdrHint::SdrHint(SdrHintKind eNewHint)
2221 :	mpPage(0L),
2222 	mpObj(0L),
2223 	mpObjList(0L),
2224 	meHint(eNewHint)
2225 {
2226 }
2227 
SdrHint(const SdrObject & rNewObj)2228 SdrHint::SdrHint(const SdrObject& rNewObj)
2229 :	mpPage(rNewObj.GetPage()),
2230 	mpObj(&rNewObj),
2231 	mpObjList(rNewObj.GetObjList()),
2232 	meHint(HINT_OBJCHG)
2233 {
2234 	maRectangle = rNewObj.GetLastBoundRect();
2235 }
2236 
SdrHint(const SdrObject & rNewObj,const Rectangle & rRect)2237 SdrHint::SdrHint(const SdrObject& rNewObj, const Rectangle& rRect)
2238 :	mpPage(rNewObj.GetPage()),
2239 	mpObj(&rNewObj),
2240 	mpObjList(rNewObj.GetObjList()),
2241 	meHint(HINT_OBJCHG)
2242 {
2243 	maRectangle = rRect;
2244 }
2245 
SetPage(const SdrPage * pNewPage)2246 void SdrHint::SetPage(const SdrPage* pNewPage)
2247 {
2248 	mpPage = pNewPage;
2249 }
2250 
SetObjList(const SdrObjList * pNewOL)2251 void SdrHint::SetObjList(const SdrObjList* pNewOL)
2252 {
2253 	mpObjList = pNewOL;
2254 }
2255 
SetObject(const SdrObject * pNewObj)2256 void SdrHint::SetObject(const SdrObject* pNewObj)
2257 {
2258 	mpObj = pNewObj;
2259 }
2260 
SetKind(SdrHintKind eNewKind)2261 void SdrHint::SetKind(SdrHintKind eNewKind)
2262 {
2263 	meHint = eNewKind;
2264 }
2265 
SetRect(const Rectangle & rNewRect)2266 void SdrHint::SetRect(const Rectangle& rNewRect)
2267 {
2268 	maRectangle = rNewRect;
2269 }
2270 
GetPage() const2271 const SdrPage* SdrHint::GetPage() const
2272 {
2273 	return mpPage;
2274 }
2275 
GetObjList() const2276 const SdrObjList* SdrHint::GetObjList() const
2277 {
2278 	return mpObjList;
2279 }
2280 
GetObject() const2281 const SdrObject* SdrHint::GetObject() const
2282 {
2283 	return mpObj;
2284 }
2285 
GetKind() const2286 SdrHintKind SdrHint::GetKind() const
2287 {
2288 	return meHint;
2289 }
2290 
GetRect() const2291 const Rectangle& SdrHint::GetRect() const
2292 {
2293 	return maRectangle;
2294 }
2295 
2296 // eof
2297