Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <svx/svdmodel.hxx>
22 :
23 : #include <cassert>
24 : #include <math.h>
25 :
26 : #include <osl/endian.h>
27 : #include <rtl/strbuf.hxx>
28 :
29 : #include <com/sun/star/lang/XComponent.hpp>
30 : #include <com/sun/star/document/XStorageBasedDocument.hpp>
31 : #include <com/sun/star/embed/ElementModes.hpp>
32 :
33 : #include <unotools/ucbstreamhelper.hxx>
34 :
35 : #include <svl/whiter.hxx>
36 : #include <svx/xit.hxx>
37 : #include <svx/xbtmpit.hxx>
38 : #include <svx/xlndsit.hxx>
39 : #include <svx/xlnedit.hxx>
40 : #include <svx/xflgrit.hxx>
41 : #include <svx/xflftrit.hxx>
42 : #include <svx/xflhtit.hxx>
43 : #include <svx/xlnstit.hxx>
44 :
45 : #include <editeng/editdata.hxx>
46 : #include <editeng/editeng.hxx>
47 :
48 : #include <svx/xtable.hxx>
49 :
50 : #include "svx/svditer.hxx"
51 : #include <svx/svdtrans.hxx>
52 : #include <svx/svdpage.hxx>
53 : #include <svx/svdlayer.hxx>
54 : #include <svx/svdundo.hxx>
55 : #include <svx/svdpool.hxx>
56 : #include <svx/svdobj.hxx>
57 : #include <svx/svdotext.hxx>
58 : #include <svx/svdetc.hxx>
59 : #include <svx/svdoutl.hxx>
60 : #include <svx/svdoole2.hxx>
61 : #include "svdglob.hxx"
62 : #include "svx/svdstr.hrc"
63 : #include "svdoutlinercache.hxx"
64 :
65 : #include "svx/xflclit.hxx"
66 : #include "svx/xlnclit.hxx"
67 :
68 : #include "officecfg/Office/Common.hxx"
69 : #include "editeng/fontitem.hxx"
70 : #include <editeng/colritem.hxx>
71 : #include <editeng/fhgtitem.hxx>
72 : #include <svl/style.hxx>
73 : #include <editeng/numitem.hxx>
74 : #include <editeng/bulletitem.hxx>
75 : #include <editeng/outlobj.hxx>
76 : #include "editeng/forbiddencharacterstable.hxx"
77 : #include <svl/zforlist.hxx>
78 : #include <comphelper/servicehelper.hxx>
79 : #include <comphelper/storagehelper.hxx>
80 :
81 : #include <tools/tenccvt.hxx>
82 : #include <unotools/syslocale.hxx>
83 :
84 : #include <svx/sdr/properties/properties.hxx>
85 : #include <editeng/eeitem.hxx>
86 : #include <svl/itemset.hxx>
87 : #include <vcl/settings.hxx>
88 : #include <vcl/svapp.hxx>
89 : #include <boost/scoped_array.hpp>
90 : #include <libxml/xmlwriter.h>
91 :
92 : using namespace ::com::sun::star;
93 : using namespace ::com::sun::star::uno;
94 : using namespace ::com::sun::star::lang;
95 :
96 :
97 :
98 : struct SdrModelImpl
99 : {
100 : SfxUndoManager* mpUndoManager;
101 : SdrUndoFactory* mpUndoFactory;
102 : };
103 :
104 :
105 :
106 981 : TYPEINIT1(SdrModel,SfxBroadcaster);
107 4148 : void SdrModel::ImpCtor(SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* _pEmbeddedHelper,
108 : bool bUseExtColorTable, bool bLoadRefCounts)
109 : {
110 4148 : mpImpl = new SdrModelImpl;
111 4148 : mpImpl->mpUndoManager=0;
112 4148 : mpImpl->mpUndoFactory=0;
113 4148 : mbInDestruction = false;
114 4148 : aObjUnit=SdrEngineDefaults::GetMapFraction();
115 4148 : eObjUnit=SdrEngineDefaults::GetMapUnit();
116 4148 : eUIUnit=FUNIT_MM;
117 4148 : aUIScale=Fraction(1,1);
118 4148 : nUIUnitKomma=0;
119 4148 : bUIOnlyKomma=false;
120 4148 : pLayerAdmin=NULL;
121 4148 : pItemPool=pPool;
122 4148 : bMyPool=false;
123 4148 : m_pEmbeddedHelper=_pEmbeddedHelper;
124 4148 : pDrawOutliner=NULL;
125 4148 : pHitTestOutliner=NULL;
126 4148 : pRefOutDev=NULL;
127 4148 : mbTiledRendering = false;
128 4148 : mpLibreOfficeKitCallback = 0;
129 4148 : mpLibreOfficeKitData = 0;
130 4148 : nProgressAkt=0;
131 4148 : nProgressMax=0;
132 4148 : nProgressOfs=0;
133 4148 : pDefaultStyleSheet=NULL;
134 4148 : mpDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj = 0;
135 4148 : pLinkManager=NULL;
136 4148 : pUndoStack=NULL;
137 4148 : pRedoStack=NULL;
138 4148 : nMaxUndoCount=16;
139 4148 : mnUniqueCommentID=0;
140 4148 : pAktUndoGroup=NULL;
141 4148 : nUndoLevel=0;
142 4148 : mbUndoEnabled=true;
143 4148 : nProgressPercent=0;
144 4148 : nLoadVersion=0;
145 4148 : bExtColorTable=false;
146 4148 : mbChanged = false;
147 4148 : bInfoChanged=false;
148 4148 : bPagNumsDirty=false;
149 4148 : bMPgNumsDirty=false;
150 4148 : bPageNotValid=false;
151 4148 : bSavePortable=false;
152 4148 : bSaveCompressed=false;
153 4148 : bSaveNative=false;
154 4148 : bSwapGraphics=false;
155 4148 : nSwapGraphicsMode=SdrSwapGraphicsMode::DEFAULT;
156 4148 : bSaveOLEPreview=false;
157 4148 : bPasteResize=false;
158 4148 : bNoBitmapCaching=false;
159 4148 : bReadOnly=false;
160 4148 : nStreamNumberFormat=SvStreamEndian::BIG;
161 4148 : nDefaultTabulator=0;
162 4148 : mpNumberFormatter = NULL;
163 4148 : bTransparentTextFrames=false;
164 4148 : bStarDrawPreviewMode = false;
165 4148 : nStarDrawPreviewMasterPageNum = SDRPAGE_NOTFOUND;
166 4148 : mpForbiddenCharactersTable = NULL;
167 4148 : mbModelLocked = false;
168 4148 : mpOutlinerCache = NULL;
169 4148 : mbKernAsianPunctuation = false;
170 4148 : mbAddExtLeading = false;
171 4148 : mnHandoutPageCount = 0;
172 4148 : nReserveUInt6 = 0;
173 4148 : nReserveUInt7 = 0;
174 :
175 4148 : mbDisableTextEditUsesCommonUndoManager = false;
176 :
177 : mnCharCompressType =
178 : officecfg::Office::Common::AsianLayout::CompressCharacterDistance::
179 4148 : get();
180 :
181 : #ifdef OSL_LITENDIAN
182 4148 : nStreamNumberFormat=SvStreamEndian::LITTLE;
183 : #endif
184 4148 : bExtColorTable=bUseExtColorTable;
185 :
186 4148 : if ( pPool == NULL )
187 : {
188 1190 : pItemPool=new SdrItemPool(0L, bLoadRefCounts);
189 : // Outliner doesn't have its own Pool, so use the EditEngine's
190 1190 : SfxItemPool* pOutlPool=EditEngine::CreatePool( bLoadRefCounts );
191 : // OutlinerPool as SecondaryPool of SdrPool
192 1190 : pItemPool->SetSecondaryPool(pOutlPool);
193 : // remember that I created both pools myself
194 1190 : bMyPool=true;
195 : }
196 4148 : pItemPool->SetDefaultMetric((SfxMapUnit)eObjUnit);
197 :
198 : // using static SdrEngineDefaults only if default SvxFontHeight item is not available
199 4148 : const SfxPoolItem* pPoolItem = pItemPool->GetPoolDefaultItem( EE_CHAR_FONTHEIGHT );
200 4148 : if ( pPoolItem )
201 2958 : nDefTextHgt = static_cast<const SvxFontHeightItem*>(pPoolItem)->GetHeight();
202 : else
203 1190 : nDefTextHgt = SdrEngineDefaults::GetFontHeight();
204 :
205 4148 : pItemPool->SetPoolDefaultItem( makeSdrTextWordWrapItem( false ) );
206 :
207 4148 : SetTextDefaults();
208 4148 : pLayerAdmin=new SdrLayerAdmin;
209 4148 : pLayerAdmin->SetModel(this);
210 4148 : ImpSetUIUnit();
211 :
212 : // can't create DrawOutliner OnDemand, because I can't get the Pool,
213 : // then (only from 302 onwards!)
214 4148 : pDrawOutliner = SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, *this);
215 4148 : ImpSetOutlinerDefaults(pDrawOutliner, true);
216 :
217 4148 : pHitTestOutliner = SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, *this);
218 4148 : ImpSetOutlinerDefaults(pHitTestOutliner, true);
219 :
220 4148 : ImpCreateTables();
221 4148 : }
222 :
223 0 : SdrModel::SdrModel():
224 : aReadDate( DateTime::EMPTY ),
225 : maMaPag(),
226 0 : maPages()
227 : {
228 0 : ImpCtor(NULL, NULL, false, LOADREFCOUNTS);
229 0 : }
230 :
231 0 : SdrModel::SdrModel(SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, bool bUseExtColorTable, bool bLoadRefCounts):
232 : aReadDate( DateTime::EMPTY ),
233 : maMaPag(),
234 0 : maPages()
235 : {
236 0 : ImpCtor(pPool,pPers,bUseExtColorTable, bLoadRefCounts);
237 0 : }
238 :
239 4148 : SdrModel::SdrModel(const OUString& rPath, SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, bool bUseExtColorTable, bool bLoadRefCounts):
240 : aReadDate( DateTime::EMPTY ),
241 : maMaPag(),
242 : maPages(),
243 4148 : aTablePath(rPath)
244 : {
245 4148 : ImpCtor(pPool,pPers,bUseExtColorTable, bLoadRefCounts);
246 4148 : }
247 :
248 8218 : SdrModel::~SdrModel()
249 : {
250 :
251 4109 : mbInDestruction = true;
252 :
253 4109 : Broadcast(SdrHint(HINT_MODELCLEARED));
254 :
255 4109 : delete mpOutlinerCache;
256 :
257 4109 : ClearUndoBuffer();
258 : #ifdef DBG_UTIL
259 : if(pAktUndoGroup)
260 : {
261 : OStringBuffer aStr("In the Dtor of the SdrModel there is an open Undo left: \"");
262 : aStr.append(OUStringToOString(pAktUndoGroup->GetComment(), osl_getThreadTextEncoding()))
263 : .append('\"');
264 : OSL_FAIL(aStr.getStr());
265 : }
266 : #endif
267 4109 : delete pAktUndoGroup;
268 :
269 4109 : ClearModel(true);
270 :
271 4109 : delete pLayerAdmin;
272 :
273 : // Delete DrawOutliner only after deleting ItemPool, because ItemPool
274 : // references Items of the DrawOutliner!
275 4109 : delete pHitTestOutliner;
276 4109 : delete pDrawOutliner;
277 :
278 : // delete StyleSheetPool, derived classes should not do this since
279 : // the DrawingEngine may need it in its destructor
280 4109 : if( mxStyleSheetPool.is() )
281 : {
282 315 : Reference< XComponent > xComponent( dynamic_cast< cppu::OWeakObject* >( mxStyleSheetPool.get() ), UNO_QUERY );
283 315 : if( xComponent.is() ) try
284 : {
285 315 : xComponent->dispose();
286 : }
287 0 : catch( RuntimeException& )
288 : {
289 : }
290 315 : mxStyleSheetPool.clear();
291 : }
292 :
293 4109 : if (bMyPool)
294 : {
295 : // delete Pools if they're mine
296 1160 : SfxItemPool* pOutlPool=pItemPool->GetSecondaryPool();
297 1160 : SfxItemPool::Free(pItemPool);
298 : // OutlinerPool has to be deleted after deleting ItemPool, because
299 : // ItemPool contains SetItems that themselves reference Items from OutlinerPool.
300 1160 : SfxItemPool::Free(pOutlPool);
301 : }
302 :
303 4109 : if( mpForbiddenCharactersTable )
304 3300 : mpForbiddenCharactersTable->release();
305 :
306 4109 : delete mpNumberFormatter;
307 :
308 4109 : delete mpImpl->mpUndoFactory;
309 4109 : delete mpImpl;
310 4109 : }
311 :
312 3825 : void SdrModel::SetSwapGraphics( bool bSwap )
313 : {
314 3825 : bSwapGraphics = bSwap;
315 3825 : }
316 :
317 2 : bool SdrModel::IsReadOnly() const
318 : {
319 2 : return bReadOnly;
320 : }
321 :
322 0 : void SdrModel::SetReadOnly(bool bYes)
323 : {
324 0 : bReadOnly=bYes;
325 0 : }
326 :
327 :
328 :
329 3804 : void SdrModel::SetMaxUndoActionCount(sal_uIntPtr nCount)
330 : {
331 3804 : if (nCount<1) nCount=1;
332 3804 : nMaxUndoCount=nCount;
333 3804 : if (pUndoStack!=NULL) {
334 0 : while (pUndoStack->size()>nMaxUndoCount) {
335 0 : delete pUndoStack->back();
336 0 : pUndoStack->pop_back();
337 : }
338 : }
339 3804 : }
340 :
341 7913 : void SdrModel::ClearUndoBuffer()
342 : {
343 7913 : if (pUndoStack!=NULL) {
344 0 : while (!pUndoStack->empty()) {
345 0 : delete pUndoStack->back();
346 0 : pUndoStack->pop_back();
347 : }
348 0 : delete pUndoStack;
349 0 : pUndoStack=NULL;
350 : }
351 7913 : if (pRedoStack!=NULL) {
352 0 : while (!pRedoStack->empty()) {
353 0 : delete pRedoStack->back();
354 0 : pRedoStack->pop_back();
355 : }
356 0 : delete pRedoStack;
357 0 : pRedoStack=NULL;
358 : }
359 7913 : }
360 :
361 0 : bool SdrModel::HasUndoActions() const
362 : {
363 0 : return pUndoStack && !pUndoStack->empty();
364 : }
365 :
366 0 : bool SdrModel::HasRedoActions() const
367 : {
368 0 : return pRedoStack && !pRedoStack->empty();
369 : }
370 :
371 0 : bool SdrModel::Undo()
372 : {
373 0 : bool bRet = false;
374 0 : if( mpImpl->mpUndoManager )
375 : {
376 : OSL_FAIL("svx::SdrModel::Undo(), method not supported with application undo manager!");
377 : }
378 : else
379 : {
380 0 : SfxUndoAction* pDo = HasUndoActions() ? pUndoStack->front() : NULL;
381 0 : if(pDo!=NULL)
382 : {
383 0 : const bool bWasUndoEnabled = mbUndoEnabled;
384 0 : mbUndoEnabled = false;
385 0 : pDo->Undo();
386 0 : if(pRedoStack==NULL)
387 0 : pRedoStack=new std::deque<SfxUndoAction*>;
388 0 : SfxUndoAction* p = pUndoStack->front();
389 0 : pUndoStack->pop_front();
390 0 : pRedoStack->push_front(p);
391 0 : mbUndoEnabled = bWasUndoEnabled;
392 : }
393 : }
394 0 : return bRet;
395 : }
396 :
397 0 : bool SdrModel::Redo()
398 : {
399 0 : bool bRet = false;
400 0 : if( mpImpl->mpUndoManager )
401 : {
402 : OSL_FAIL("svx::SdrModel::Redo(), method not supported with application undo manager!");
403 : }
404 : else
405 : {
406 0 : SfxUndoAction* pDo = HasRedoActions() ? pRedoStack->front() : NULL;
407 0 : if(pDo!=NULL)
408 : {
409 0 : const bool bWasUndoEnabled = mbUndoEnabled;
410 0 : mbUndoEnabled = false;
411 0 : pDo->Redo();
412 0 : if(pUndoStack==NULL)
413 0 : pUndoStack=new std::deque<SfxUndoAction*>;
414 0 : SfxUndoAction* p = pRedoStack->front();
415 0 : pRedoStack->pop_front();
416 0 : pUndoStack->push_front(p);
417 0 : mbUndoEnabled = bWasUndoEnabled;
418 : }
419 : }
420 0 : return bRet;
421 : }
422 :
423 0 : bool SdrModel::Repeat(SfxRepeatTarget& rView)
424 : {
425 0 : bool bRet = false;
426 0 : if( mpImpl->mpUndoManager )
427 : {
428 : OSL_FAIL("svx::SdrModel::Redo(), method not supported with application undo manager!");
429 : }
430 : else
431 : {
432 0 : SfxUndoAction* pDo = HasUndoActions() ? pUndoStack->front() : NULL;
433 0 : if(pDo!=NULL)
434 : {
435 0 : if(pDo->CanRepeat(rView))
436 : {
437 0 : pDo->Repeat(rView);
438 0 : bRet = true;
439 : }
440 : }
441 : }
442 0 : return bRet;
443 : }
444 :
445 5701 : void SdrModel::ImpPostUndoAction(SdrUndoAction* pUndo)
446 : {
447 : DBG_ASSERT( mpImpl->mpUndoManager == 0, "svx::SdrModel::ImpPostUndoAction(), method not supported with application undo manager!" );
448 5701 : if( IsUndoEnabled() )
449 : {
450 5701 : if (aUndoLink.IsSet())
451 : {
452 5701 : aUndoLink.Call(pUndo);
453 : }
454 : else
455 : {
456 0 : if (pUndoStack==NULL)
457 0 : pUndoStack=new std::deque<SfxUndoAction*>;
458 0 : pUndoStack->push_front(pUndo);
459 0 : while (pUndoStack->size()>nMaxUndoCount)
460 : {
461 0 : delete pUndoStack->back();
462 0 : pUndoStack->pop_back();
463 : }
464 0 : if (pRedoStack!=NULL)
465 0 : pRedoStack->clear();
466 : }
467 : }
468 : else
469 : {
470 0 : delete pUndo;
471 : }
472 5701 : }
473 :
474 136 : void SdrModel::BegUndo()
475 : {
476 136 : if( mpImpl->mpUndoManager )
477 : {
478 6 : const OUString aEmpty;
479 6 : mpImpl->mpUndoManager->EnterListAction(aEmpty,aEmpty);
480 6 : nUndoLevel++;
481 : }
482 130 : else if( IsUndoEnabled() )
483 : {
484 130 : if(pAktUndoGroup==NULL)
485 : {
486 129 : pAktUndoGroup = new SdrUndoGroup(*this);
487 129 : nUndoLevel=1;
488 : }
489 : else
490 : {
491 1 : nUndoLevel++;
492 : }
493 : }
494 136 : }
495 :
496 1163 : void SdrModel::BegUndo(const OUString& rComment)
497 : {
498 1163 : if( mpImpl->mpUndoManager )
499 : {
500 1043 : const OUString aEmpty;
501 1043 : mpImpl->mpUndoManager->EnterListAction( rComment, aEmpty );
502 1043 : nUndoLevel++;
503 : }
504 120 : else if( IsUndoEnabled() )
505 : {
506 120 : BegUndo();
507 120 : if (nUndoLevel==1)
508 : {
509 120 : pAktUndoGroup->SetComment(rComment);
510 : }
511 : }
512 1163 : }
513 :
514 799 : void SdrModel::BegUndo(const OUString& rComment, const OUString& rObjDescr, SdrRepeatFunc eFunc)
515 : {
516 799 : if( mpImpl->mpUndoManager )
517 : {
518 790 : OUString aComment(rComment);
519 790 : if( !aComment.isEmpty() && !rObjDescr.isEmpty() )
520 : {
521 775 : aComment = aComment.replaceFirst("%1", rObjDescr);
522 : }
523 1580 : const OUString aEmpty;
524 790 : mpImpl->mpUndoManager->EnterListAction( aComment,aEmpty );
525 1580 : nUndoLevel++;
526 : }
527 9 : else if( IsUndoEnabled() )
528 : {
529 9 : BegUndo();
530 9 : if (nUndoLevel==1)
531 : {
532 9 : pAktUndoGroup->SetComment(rComment);
533 9 : pAktUndoGroup->SetObjDescription(rObjDescr);
534 9 : pAktUndoGroup->SetRepeatFunction(eFunc);
535 : }
536 : }
537 799 : }
538 :
539 1969 : void SdrModel::EndUndo()
540 : {
541 : DBG_ASSERT(nUndoLevel!=0,"SdrModel::EndUndo(): UndoLevel is already 0!");
542 1969 : if( mpImpl->mpUndoManager )
543 : {
544 1839 : if( nUndoLevel )
545 : {
546 1839 : nUndoLevel--;
547 1839 : mpImpl->mpUndoManager->LeaveListAction();
548 : }
549 : }
550 : else
551 : {
552 130 : if(pAktUndoGroup!=NULL && IsUndoEnabled())
553 : {
554 130 : nUndoLevel--;
555 130 : if(nUndoLevel==0)
556 : {
557 129 : if(pAktUndoGroup->GetActionCount()!=0)
558 : {
559 127 : SdrUndoAction* pUndo=pAktUndoGroup;
560 127 : pAktUndoGroup=NULL;
561 127 : ImpPostUndoAction(pUndo);
562 : }
563 : else
564 : {
565 : // was empty
566 2 : delete pAktUndoGroup;
567 2 : pAktUndoGroup=NULL;
568 : }
569 : }
570 : }
571 : }
572 1969 : }
573 :
574 0 : void SdrModel::SetUndoComment(const OUString& rComment)
575 : {
576 : DBG_ASSERT(nUndoLevel!=0,"SdrModel::SetUndoComment(): UndoLevel is already 0!");
577 :
578 0 : if( mpImpl->mpUndoManager )
579 : {
580 : OSL_FAIL("svx::SdrModel::SetUndoComment(), method not supported with application undo manager!" );
581 : }
582 0 : else if( IsUndoEnabled() )
583 : {
584 0 : if(nUndoLevel==1)
585 : {
586 0 : pAktUndoGroup->SetComment(rComment);
587 : }
588 : }
589 0 : }
590 :
591 17 : void SdrModel::SetUndoComment(const OUString& rComment, const OUString& rObjDescr)
592 : {
593 : DBG_ASSERT(nUndoLevel!=0,"SdrModel::SetUndoComment(): UndoLevel is already 0!");
594 17 : if( mpImpl->mpUndoManager )
595 : {
596 : OSL_FAIL("svx::SdrModel::SetUndoComment(), method not supported with application undo manager!" );
597 : }
598 : else
599 : {
600 2 : if (nUndoLevel==1)
601 : {
602 2 : pAktUndoGroup->SetComment(rComment);
603 2 : pAktUndoGroup->SetObjDescription(rObjDescr);
604 : }
605 : }
606 17 : }
607 :
608 8371 : void SdrModel::AddUndo(SdrUndoAction* pUndo)
609 : {
610 8371 : if( mpImpl->mpUndoManager )
611 : {
612 2650 : mpImpl->mpUndoManager->AddUndoAction( pUndo );
613 : }
614 5721 : else if( !IsUndoEnabled() )
615 : {
616 0 : delete pUndo;
617 : }
618 : else
619 : {
620 5721 : if (pAktUndoGroup!=NULL)
621 : {
622 147 : pAktUndoGroup->AddAction(pUndo);
623 : }
624 : else
625 : {
626 5574 : ImpPostUndoAction(pUndo);
627 : }
628 : }
629 8371 : }
630 :
631 107897 : void SdrModel::EnableUndo( bool bEnable )
632 : {
633 107897 : if( mpImpl->mpUndoManager )
634 : {
635 112 : mpImpl->mpUndoManager->EnableUndo( bEnable );
636 : }
637 : else
638 : {
639 107785 : mbUndoEnabled = bEnable;
640 : }
641 107897 : }
642 :
643 67590 : bool SdrModel::IsUndoEnabled() const
644 : {
645 67590 : if( mpImpl->mpUndoManager )
646 : {
647 3506 : return mpImpl->mpUndoManager->IsUndoEnabled();
648 : }
649 : else
650 : {
651 64084 : return mbUndoEnabled;
652 : }
653 : }
654 :
655 4148 : void SdrModel::ImpCreateTables()
656 : {
657 29036 : for( int i = 0; i < XPROPERTY_LIST_COUNT; i++ )
658 : {
659 24888 : if( !bExtColorTable || i != XCOLOR_LIST )
660 42762 : maProperties[i] = XPropertyList::CreatePropertyList (
661 21381 : (XPropertyListType) i, aTablePath, ""/*TODO?*/ );
662 : }
663 4148 : }
664 :
665 8453 : void SdrModel::ClearModel(bool bCalledFromDestructor)
666 : {
667 8453 : if(bCalledFromDestructor)
668 : {
669 8453 : mbInDestruction = true;
670 : }
671 :
672 : sal_Int32 i;
673 : // delete all drawing pages
674 8453 : sal_Int32 nCount=GetPageCount();
675 13561 : for (i=nCount-1; i>=0; i--)
676 : {
677 5108 : DeletePage( (sal_uInt16)i );
678 : }
679 8453 : maPages.clear();
680 8453 : PageListChanged();
681 :
682 : // delete all Masterpages
683 8453 : nCount=GetMasterPageCount();
684 9220 : for(i=nCount-1; i>=0; i--)
685 : {
686 767 : DeleteMasterPage( (sal_uInt16)i );
687 : }
688 8453 : maMaPag.clear();
689 8453 : MasterPageListChanged();
690 :
691 8453 : pLayerAdmin->ClearLayer();
692 8453 : }
693 :
694 0 : SdrModel* SdrModel::AllocModel() const
695 : {
696 0 : SdrModel* pModel=new SdrModel;
697 0 : pModel->SetScaleUnit(eObjUnit,aObjUnit);
698 0 : return pModel;
699 : }
700 :
701 0 : SdrPage* SdrModel::AllocPage(bool bMasterPage)
702 : {
703 0 : return new SdrPage(*this,bMasterPage);
704 : }
705 :
706 4148 : void SdrModel::SetTextDefaults() const
707 : {
708 4148 : SetTextDefaults( pItemPool, nDefTextHgt );
709 4148 : }
710 :
711 4666 : void SdrModel::SetTextDefaults( SfxItemPool* pItemPool, sal_uIntPtr nDefTextHgt )
712 : {
713 : // set application-language specific dynamic pool language defaults
714 4666 : SvxFontItem aSvxFontItem( EE_CHAR_FONTINFO) ;
715 9332 : SvxFontItem aSvxFontItemCJK(EE_CHAR_FONTINFO_CJK);
716 9332 : SvxFontItem aSvxFontItemCTL(EE_CHAR_FONTINFO_CTL);
717 4666 : sal_uInt16 nLanguage(Application::GetSettings().GetLanguageTag().getLanguageType());
718 :
719 : // get DEFAULTFONT_LATIN_TEXT and set at pool as dynamic default
720 9332 : vcl::Font aFont(OutputDevice::GetDefaultFont(DefaultFontType::LATIN_TEXT, nLanguage, GetDefaultFontFlags::OnlyOne, 0));
721 4666 : aSvxFontItem.SetFamily(aFont.GetFamily());
722 4666 : aSvxFontItem.SetFamilyName(aFont.GetName());
723 4666 : aSvxFontItem.SetStyleName(OUString());
724 4666 : aSvxFontItem.SetPitch( aFont.GetPitch());
725 4666 : aSvxFontItem.SetCharSet( aFont.GetCharSet() );
726 4666 : pItemPool->SetPoolDefaultItem(aSvxFontItem);
727 :
728 : // get DEFAULTFONT_CJK_TEXT and set at pool as dynamic default
729 9332 : vcl::Font aFontCJK(OutputDevice::GetDefaultFont(DefaultFontType::CJK_TEXT, nLanguage, GetDefaultFontFlags::OnlyOne, 0));
730 4666 : aSvxFontItemCJK.SetFamily( aFontCJK.GetFamily());
731 4666 : aSvxFontItemCJK.SetFamilyName(aFontCJK.GetName());
732 4666 : aSvxFontItemCJK.SetStyleName(OUString());
733 4666 : aSvxFontItemCJK.SetPitch( aFontCJK.GetPitch());
734 4666 : aSvxFontItemCJK.SetCharSet( aFontCJK.GetCharSet());
735 4666 : pItemPool->SetPoolDefaultItem(aSvxFontItemCJK);
736 :
737 : // get DEFAULTFONT_CTL_TEXT and set at pool as dynamic default
738 9332 : vcl::Font aFontCTL(OutputDevice::GetDefaultFont(DefaultFontType::CTL_TEXT, nLanguage, GetDefaultFontFlags::OnlyOne, 0));
739 4666 : aSvxFontItemCTL.SetFamily(aFontCTL.GetFamily());
740 4666 : aSvxFontItemCTL.SetFamilyName(aFontCTL.GetName());
741 4666 : aSvxFontItemCTL.SetStyleName(OUString());
742 4666 : aSvxFontItemCTL.SetPitch( aFontCTL.GetPitch() );
743 4666 : aSvxFontItemCTL.SetCharSet( aFontCTL.GetCharSet());
744 4666 : pItemPool->SetPoolDefaultItem(aSvxFontItemCTL);
745 :
746 : // set dynamic FontHeight defaults
747 4666 : pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT ) );
748 4666 : pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT_CJK ) );
749 4666 : pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT_CTL ) );
750 :
751 : // set FontColor defaults
752 9332 : pItemPool->SetPoolDefaultItem( SvxColorItem(SdrEngineDefaults::GetFontColor(), EE_CHAR_COLOR) );
753 4666 : }
754 :
755 582109 : SdrOutliner& SdrModel::GetDrawOutliner(const SdrTextObj* pObj) const
756 : {
757 582109 : pDrawOutliner->SetTextObj(pObj);
758 582109 : return *pDrawOutliner;
759 : }
760 :
761 652 : const SdrTextObj* SdrModel::GetFormattingTextObj() const
762 : {
763 652 : if (pDrawOutliner!=NULL) {
764 652 : return pDrawOutliner->GetTextObj();
765 : }
766 0 : return NULL;
767 : }
768 :
769 36570 : void SdrModel::ImpSetOutlinerDefaults( SdrOutliner* pOutliner, bool bInit )
770 : {
771 : // Initialization of the Outliners for drawing text and HitTest
772 36570 : if( bInit )
773 : {
774 8296 : pOutliner->EraseVirtualDevice();
775 8296 : pOutliner->SetUpdateMode(false);
776 8296 : pOutliner->SetEditTextObjectPool(pItemPool);
777 8296 : pOutliner->SetDefTab(nDefaultTabulator);
778 : }
779 :
780 36570 : pOutliner->SetRefDevice(GetRefDevice());
781 36570 : Outliner::SetForbiddenCharsTable(GetForbiddenCharsTable());
782 36570 : pOutliner->SetAsianCompressionMode( mnCharCompressType );
783 36570 : pOutliner->SetKernAsianPunctuation( IsKernAsianPunctuation() );
784 36570 : pOutliner->SetAddExtLeading( IsAddExtLeading() );
785 :
786 36570 : if ( !GetRefDevice() )
787 : {
788 26686 : MapMode aMapMode(eObjUnit, Point(0,0), aObjUnit, aObjUnit);
789 26686 : pOutliner->SetRefMapMode(aMapMode);
790 : }
791 36570 : }
792 :
793 4244 : void SdrModel::SetRefDevice(OutputDevice* pDev)
794 : {
795 4244 : pRefOutDev=pDev;
796 4244 : ImpSetOutlinerDefaults( pDrawOutliner );
797 4244 : ImpSetOutlinerDefaults( pHitTestOutliner );
798 4244 : RefDeviceChanged();
799 4244 : }
800 :
801 19 : void SdrModel::setTiledRendering(bool bTiledRendering)
802 : {
803 19 : mbTiledRendering = bTiledRendering;
804 19 : }
805 :
806 437847 : bool SdrModel::isTiledRendering() const
807 : {
808 437847 : return mbTiledRendering;
809 : }
810 :
811 6 : void SdrModel::registerLibreOfficeKitCallback(LibreOfficeKitCallback pCallback, void* pData)
812 : {
813 6 : mpLibreOfficeKitCallback = pCallback;
814 6 : mpLibreOfficeKitData = pData;
815 6 : }
816 :
817 70903 : void SdrModel::libreOfficeKitCallback(int nType, const char* pPayload) const
818 : {
819 70903 : if (mpLibreOfficeKitCallback)
820 290 : mpLibreOfficeKitCallback(nType, pPayload, mpLibreOfficeKitData);
821 70903 : }
822 :
823 9 : LibreOfficeKitCallback SdrModel::getLibreOfficeKitCallback() const
824 : {
825 9 : return mpLibreOfficeKitCallback;
826 : }
827 :
828 9 : void* SdrModel::getLibreOfficeKitData() const
829 : {
830 9 : return mpLibreOfficeKitData;
831 : }
832 :
833 8765 : void SdrModel::ImpReformatAllTextObjects()
834 : {
835 8765 : if( isLocked() )
836 8892 : return;
837 :
838 8638 : sal_uInt16 nCount=GetMasterPageCount();
839 : sal_uInt16 nNum;
840 8638 : for (nNum=0; nNum<nCount; nNum++) {
841 0 : GetMasterPage(nNum)->ReformatAllTextObjects();
842 : }
843 8638 : nCount=GetPageCount();
844 13050 : for (nNum=0; nNum<nCount; nNum++) {
845 4412 : GetPage(nNum)->ReformatAllTextObjects();
846 : }
847 : }
848 :
849 : /* steps over all available pages and sends notify messages to
850 : all edge objects that are connected to other objects so that
851 : they may reposition themselves
852 : */
853 1897 : void SdrModel::ImpReformatAllEdgeObjects()
854 : {
855 1897 : if( isLocked() )
856 1897 : return;
857 :
858 1897 : sal_uInt16 nCount=GetMasterPageCount();
859 : sal_uInt16 nNum;
860 2652 : for (nNum=0; nNum<nCount; nNum++)
861 : {
862 755 : GetMasterPage(nNum)->ReformatAllEdgeObjects();
863 : }
864 1897 : nCount=GetPageCount();
865 4505 : for (nNum=0; nNum<nCount; nNum++)
866 : {
867 2608 : GetPage(nNum)->ReformatAllEdgeObjects();
868 : }
869 : }
870 :
871 49 : uno::Reference<embed::XStorage> SdrModel::GetDocumentStorage() const
872 : {
873 : uno::Reference<document::XStorageBasedDocument> const xSBD(
874 49 : const_cast<SdrModel*>(this)->getUnoModel(), uno::UNO_QUERY);
875 49 : if (!xSBD.is())
876 : {
877 : SAL_WARN("svx", "no UNO model");
878 0 : return 0;
879 : }
880 49 : return xSBD->getDocumentStorage();
881 : }
882 :
883 : uno::Reference<io::XInputStream>
884 60 : SdrModel::GetDocumentStream( OUString const& rURL,
885 : ::comphelper::LifecycleProxy & rProxy) const
886 : {
887 60 : uno::Reference<embed::XStorage> const xStorage(GetDocumentStorage());
888 60 : if (!xStorage.is())
889 : {
890 : SAL_WARN("svx", "no storage?");
891 0 : return 0;
892 : }
893 : try {
894 : uno::Reference<io::XStream> const xStream(
895 : ::comphelper::OStorageHelper::GetStreamAtPackageURL(
896 60 : xStorage, rURL, embed::ElementModes::READ, rProxy));
897 57 : return (xStream.is()) ? xStream->getInputStream() : 0;
898 : }
899 0 : catch (container::NoSuchElementException const&)
900 : {
901 : SAL_INFO("svx", "not found");
902 : }
903 3 : catch (uno::Exception const& e)
904 : {
905 : SAL_WARN("svx", "exception: '" << e.Message << "'");
906 : }
907 3 : return 0;
908 : }
909 :
910 : // convert template attributes from the string into "hard" attributes
911 0 : void SdrModel::BurnInStyleSheetAttributes()
912 : {
913 0 : sal_uInt16 nCount=GetMasterPageCount();
914 : sal_uInt16 nNum;
915 0 : for (nNum=0; nNum<nCount; nNum++) {
916 0 : GetMasterPage(nNum)->BurnInStyleSheetAttributes();
917 : }
918 0 : nCount=GetPageCount();
919 0 : for (nNum=0; nNum<nCount; nNum++) {
920 0 : GetPage(nNum)->BurnInStyleSheetAttributes();
921 : }
922 0 : }
923 :
924 4244 : void SdrModel::RefDeviceChanged()
925 : {
926 4244 : Broadcast(SdrHint(HINT_REFDEVICECHG));
927 4244 : ImpReformatAllTextObjects();
928 4244 : }
929 :
930 641 : void SdrModel::SetDefaultFontHeight(sal_uIntPtr nVal)
931 : {
932 641 : if (nVal!=nDefTextHgt) {
933 321 : nDefTextHgt=nVal;
934 321 : Broadcast(SdrHint(HINT_DEFFONTHGTCHG));
935 321 : ImpReformatAllTextObjects();
936 : }
937 641 : }
938 :
939 913 : void SdrModel::SetDefaultTabulator(sal_uInt16 nVal)
940 : {
941 913 : if (nDefaultTabulator!=nVal) {
942 880 : nDefaultTabulator=nVal;
943 880 : Outliner& rOutliner=GetDrawOutliner();
944 880 : rOutliner.SetDefTab(nVal);
945 880 : Broadcast(SdrHint(HINT_DEFAULTTABCHG));
946 880 : ImpReformatAllTextObjects();
947 : }
948 913 : }
949 :
950 7426 : void SdrModel::ImpSetUIUnit()
951 : {
952 7426 : if(0 == aUIScale.GetNumerator() || 0 == aUIScale.GetDenominator())
953 : {
954 0 : aUIScale = Fraction(1,1);
955 : }
956 :
957 : // set start values
958 7426 : nUIUnitKomma = 0;
959 7426 : sal_Int64 nMul(1);
960 7426 : sal_Int64 nDiv(1);
961 :
962 : // normalize on meters resp. inch
963 7426 : switch (eObjUnit)
964 : {
965 4468 : case MAP_100TH_MM : nUIUnitKomma+=5; break;
966 0 : case MAP_10TH_MM : nUIUnitKomma+=4; break;
967 0 : case MAP_MM : nUIUnitKomma+=3; break;
968 0 : case MAP_CM : nUIUnitKomma+=2; break;
969 0 : case MAP_1000TH_INCH: nUIUnitKomma+=3; break;
970 0 : case MAP_100TH_INCH : nUIUnitKomma+=2; break;
971 0 : case MAP_10TH_INCH : nUIUnitKomma+=1; break;
972 0 : case MAP_INCH : nUIUnitKomma+=0; break;
973 0 : case MAP_POINT : nDiv=72; break; // 1Pt = 1/72"
974 2958 : case MAP_TWIP : nDiv=144; nUIUnitKomma++; break; // 1Twip = 1/1440"
975 0 : case MAP_PIXEL : break;
976 0 : case MAP_SYSFONT : break;
977 0 : case MAP_APPFONT : break;
978 0 : case MAP_RELATIVE : break;
979 0 : default: break;
980 : } // switch
981 :
982 : // 1 mile = 8 furlong = 63.360" = 1.609.344,0mm
983 : // 1 furlong = 10 chains = 7.920" = 201.168,0mm
984 : // 1 chain = 4 poles = 792" = 20.116,8mm
985 : // 1 pole = 5 1/2 yd = 198" = 5.029,2mm
986 : // 1 yd = 3 ft = 36" = 914,4mm
987 : // 1 ft = 12 " = 1" = 304,8mm
988 7426 : switch (eUIUnit)
989 : {
990 0 : case FUNIT_NONE : break;
991 : // metric
992 0 : case FUNIT_100TH_MM: nUIUnitKomma-=5; break;
993 7106 : case FUNIT_MM : nUIUnitKomma-=3; break;
994 0 : case FUNIT_CM : nUIUnitKomma-=2; break;
995 0 : case FUNIT_M : nUIUnitKomma+=0; break;
996 0 : case FUNIT_KM : nUIUnitKomma+=3; break;
997 : // Inch
998 0 : case FUNIT_TWIP : nMul=144; nUIUnitKomma--; break; // 1Twip = 1/1440"
999 0 : case FUNIT_POINT : nMul=72; break; // 1Pt = 1/72"
1000 0 : case FUNIT_PICA : nMul=6; break; // 1Pica = 1/6"
1001 320 : case FUNIT_INCH : break; // 1" = 1"
1002 0 : case FUNIT_FOOT : nDiv*=12; break; // 1Ft = 12"
1003 0 : case FUNIT_MILE : nDiv*=6336; nUIUnitKomma++; break; // 1mile = 63360"
1004 : // other
1005 0 : case FUNIT_CUSTOM : break;
1006 0 : case FUNIT_PERCENT: nUIUnitKomma+=2; break;
1007 : // TODO: Add code to handle the following if needed (added to remove warning)
1008 0 : case FUNIT_CHAR : break;
1009 0 : case FUNIT_LINE : break;
1010 0 : case FUNIT_PIXEL : break;
1011 0 : case FUNIT_DEGREE : break;
1012 0 : case FUNIT_SECOND : break;
1013 0 : case FUNIT_MILLISECOND : break;
1014 : } // switch
1015 :
1016 : // check if mapping is from metric to inch and adapt
1017 7426 : const bool bMapInch(IsInch(eObjUnit));
1018 7426 : const bool bUIMetr(IsMetric(eUIUnit));
1019 :
1020 7426 : if (bMapInch && bUIMetr)
1021 : {
1022 2958 : nUIUnitKomma += 4;
1023 2958 : nMul *= 254;
1024 : }
1025 :
1026 : // check if mapping is from inch to metric and adapt
1027 7426 : const bool bMapMetr(IsMetric(eObjUnit));
1028 7426 : const bool bUIInch(IsInch(eUIUnit));
1029 :
1030 7426 : if (bMapMetr && bUIInch)
1031 : {
1032 320 : nUIUnitKomma -= 4;
1033 320 : nDiv *= 254;
1034 : }
1035 :
1036 : // use temporary fraction for reduction (fallback to 32bit here),
1037 : // may need to be changed in the future, too
1038 7426 : if(1 != nMul || 1 != nDiv)
1039 : {
1040 3278 : const Fraction aTemp(static_cast< long >(nMul), static_cast< long >(nDiv));
1041 3278 : nMul = aTemp.GetNumerator();
1042 3278 : nDiv = aTemp.GetDenominator();
1043 : }
1044 :
1045 : // #i89872# take Unit of Measurement into account
1046 7426 : if(1 != aUIScale.GetDenominator() || 1 != aUIScale.GetNumerator())
1047 : {
1048 : // divide by UIScale
1049 0 : nMul *= aUIScale.GetDenominator();
1050 0 : nDiv *= aUIScale.GetNumerator();
1051 : }
1052 :
1053 : // shorten trailing zeros for dividend
1054 14852 : while(0 == (nMul % 10))
1055 : {
1056 0 : nUIUnitKomma--;
1057 0 : nMul /= 10;
1058 : }
1059 :
1060 : // shorten trailing zeros for divisor
1061 14852 : while(0 == (nDiv % 10))
1062 : {
1063 0 : nUIUnitKomma++;
1064 0 : nDiv /= 10;
1065 : }
1066 :
1067 : // end preparations, set member values
1068 7426 : aUIUnitFact = Fraction(sal_Int32(nMul), sal_Int32(nDiv));
1069 7426 : bUIOnlyKomma = (nMul == nDiv);
1070 7426 : TakeUnitStr(eUIUnit, aUIUnitStr);
1071 7426 : }
1072 :
1073 0 : void SdrModel::SetScaleUnit(MapUnit eMap, const Fraction& rFrac)
1074 : {
1075 0 : if (eObjUnit!=eMap || aObjUnit!=rFrac) {
1076 0 : eObjUnit=eMap;
1077 0 : aObjUnit=rFrac;
1078 0 : pItemPool->SetDefaultMetric((SfxMapUnit)eObjUnit);
1079 0 : ImpSetUIUnit();
1080 0 : ImpSetOutlinerDefaults( pDrawOutliner );
1081 0 : ImpSetOutlinerDefaults( pHitTestOutliner );
1082 0 : ImpReformatAllTextObjects();
1083 : }
1084 0 : }
1085 :
1086 4148 : void SdrModel::SetScaleUnit(MapUnit eMap)
1087 : {
1088 4148 : if (eObjUnit!=eMap) {
1089 2958 : eObjUnit=eMap;
1090 2958 : pItemPool->SetDefaultMetric((SfxMapUnit)eObjUnit);
1091 2958 : ImpSetUIUnit();
1092 2958 : ImpSetOutlinerDefaults( pDrawOutliner );
1093 2958 : ImpSetOutlinerDefaults( pHitTestOutliner );
1094 2958 : ImpReformatAllTextObjects();
1095 : }
1096 4148 : }
1097 :
1098 641 : void SdrModel::SetScaleFraction(const Fraction& rFrac)
1099 : {
1100 641 : if (aObjUnit!=rFrac) {
1101 0 : aObjUnit=rFrac;
1102 0 : ImpSetUIUnit();
1103 0 : ImpSetOutlinerDefaults( pDrawOutliner );
1104 0 : ImpSetOutlinerDefaults( pHitTestOutliner );
1105 0 : ImpReformatAllTextObjects();
1106 : }
1107 641 : }
1108 :
1109 1 : void SdrModel::SetUIUnit(FieldUnit eUnit)
1110 : {
1111 1 : if (eUIUnit!=eUnit) {
1112 0 : eUIUnit=eUnit;
1113 0 : ImpSetUIUnit();
1114 0 : ImpReformatAllTextObjects();
1115 : }
1116 1 : }
1117 :
1118 2 : void SdrModel::SetUIScale(const Fraction& rScale)
1119 : {
1120 2 : if (aUIScale!=rScale) {
1121 0 : aUIScale=rScale;
1122 0 : ImpSetUIUnit();
1123 0 : ImpReformatAllTextObjects();
1124 : }
1125 2 : }
1126 :
1127 320 : void SdrModel::SetUIUnit(FieldUnit eUnit, const Fraction& rScale)
1128 : {
1129 320 : if (eUIUnit!=eUnit || aUIScale!=rScale) {
1130 320 : eUIUnit=eUnit;
1131 320 : aUIScale=rScale;
1132 320 : ImpSetUIUnit();
1133 320 : ImpReformatAllTextObjects();
1134 : }
1135 320 : }
1136 :
1137 7543 : void SdrModel::TakeUnitStr(FieldUnit eUnit, OUString& rStr)
1138 : {
1139 7543 : switch(eUnit)
1140 : {
1141 : default:
1142 : case FUNIT_NONE :
1143 : case FUNIT_CUSTOM :
1144 : {
1145 0 : rStr.clear();
1146 0 : break;
1147 : }
1148 : case FUNIT_100TH_MM:
1149 : {
1150 0 : rStr = "/100mm";
1151 0 : break;
1152 : }
1153 : case FUNIT_MM :
1154 : {
1155 7223 : rStr = "mm";
1156 7223 : break;
1157 : }
1158 : case FUNIT_CM :
1159 : {
1160 0 : rStr = "cm";
1161 0 : break;
1162 : }
1163 : case FUNIT_M :
1164 : {
1165 0 : rStr = "m";
1166 0 : break;
1167 : }
1168 : case FUNIT_KM :
1169 : {
1170 0 : rStr ="km";
1171 0 : break;
1172 : }
1173 : case FUNIT_TWIP :
1174 : {
1175 0 : rStr = "twip";
1176 0 : break;
1177 : }
1178 : case FUNIT_POINT :
1179 : {
1180 0 : rStr = "pt";
1181 0 : break;
1182 : }
1183 : case FUNIT_PICA :
1184 : {
1185 0 : rStr = "pica";
1186 0 : break;
1187 : }
1188 : case FUNIT_INCH :
1189 : {
1190 320 : rStr = "\"";
1191 320 : break;
1192 : }
1193 : case FUNIT_FOOT :
1194 : {
1195 0 : rStr = "ft";
1196 0 : break;
1197 : }
1198 : case FUNIT_MILE :
1199 : {
1200 0 : rStr = "mile(s)";
1201 0 : break;
1202 : }
1203 : case FUNIT_PERCENT:
1204 : {
1205 0 : rStr = "%";
1206 0 : break;
1207 : }
1208 : }
1209 7543 : }
1210 :
1211 117 : void SdrModel::TakeMetricStr(long nVal, OUString& rStr, bool bNoUnitChars, sal_Int32 nNumDigits) const
1212 : {
1213 : // #i22167#
1214 : // change to double precision usage to not lose decimal places
1215 117 : const bool bNegative(nVal < 0L);
1216 117 : SvtSysLocale aSysLoc;
1217 117 : const LocaleDataWrapper& rLoc(aSysLoc.GetLocaleData());
1218 117 : double fLocalValue(double(nVal) * double(aUIUnitFact));
1219 :
1220 117 : if(bNegative)
1221 : {
1222 0 : fLocalValue = -fLocalValue;
1223 : }
1224 :
1225 117 : if( -1 == nNumDigits )
1226 : {
1227 0 : nNumDigits = LocaleDataWrapper::getNumDigits();
1228 : }
1229 :
1230 117 : sal_Int32 nKomma(nUIUnitKomma);
1231 :
1232 117 : if(nKomma > nNumDigits)
1233 : {
1234 0 : const sal_Int32 nDiff(nKomma - nNumDigits);
1235 0 : const double fFactor(pow(10.0, static_cast<const int>(nDiff)));
1236 :
1237 0 : fLocalValue /= fFactor;
1238 0 : nKomma = nNumDigits;
1239 : }
1240 117 : else if(nKomma < nNumDigits)
1241 : {
1242 0 : const sal_Int32 nDiff(nNumDigits - nKomma);
1243 0 : const double fFactor(pow(10.0, static_cast<const int>(nDiff)));
1244 :
1245 0 : fLocalValue *= fFactor;
1246 0 : nKomma = nNumDigits;
1247 : }
1248 :
1249 234 : OUStringBuffer aBuf;
1250 117 : aBuf.append(static_cast<sal_Int32>(fLocalValue + 0.5));
1251 :
1252 117 : if(nKomma < 0)
1253 : {
1254 : // negative nKomma (decimal point) means: add zeros
1255 0 : sal_Int32 nCount(-nKomma);
1256 :
1257 0 : for(sal_Int32 i=0; i<nCount; i++)
1258 0 : aBuf.append('0');
1259 :
1260 0 : nKomma = 0;
1261 : }
1262 :
1263 : // the second condition needs to be <= since inside this loop
1264 : // also the leading zero is inserted.
1265 117 : if (nKomma > 0 && aBuf.getLength() <= nKomma)
1266 : {
1267 : // if necessary, add zeros before the decimal point
1268 91 : sal_Int32 nCount = nKomma - aBuf.getLength();
1269 :
1270 91 : if(nCount >= 0 && LocaleDataWrapper::isNumLeadingZero())
1271 91 : nCount++;
1272 :
1273 182 : for(sal_Int32 i=0; i<nCount; i++)
1274 91 : aBuf.insert(0, '0');
1275 : }
1276 :
1277 117 : sal_Unicode cDec( rLoc.getNumDecimalSep()[0] );
1278 :
1279 : // insert KommaChar (decimal point character)
1280 117 : sal_Int32 nVorKomma = aBuf.getLength() - nKomma;
1281 :
1282 117 : if(nKomma > 0)
1283 117 : aBuf.insert(nVorKomma, cDec);
1284 :
1285 117 : if(!LocaleDataWrapper::isNumTrailingZeros())
1286 : {
1287 : // Remove all trailing zeros.
1288 0 : while (!aBuf.isEmpty() && aBuf[aBuf.getLength()-1] == '0')
1289 0 : aBuf.remove(aBuf.getLength()-1, 1);
1290 :
1291 : // Remove decimal if it's the last character.
1292 0 : if (!aBuf.isEmpty() && aBuf[aBuf.getLength()-1] == cDec)
1293 0 : aBuf.remove(aBuf.getLength()-1, 1);
1294 : }
1295 :
1296 : // if necessary, add separators before every third digit
1297 117 : if( nVorKomma > 3 )
1298 : {
1299 0 : OUString aThoSep( rLoc.getNumThousandSep() );
1300 0 : if ( !aThoSep.isEmpty() )
1301 : {
1302 0 : sal_Unicode cTho( aThoSep[0] );
1303 0 : sal_Int32 i(nVorKomma - 3);
1304 :
1305 0 : while(i > 0)
1306 : {
1307 0 : aBuf.insert(i, cTho);
1308 0 : i -= 3;
1309 : }
1310 0 : }
1311 : }
1312 :
1313 117 : if (aBuf.isEmpty())
1314 0 : aBuf.append("0");
1315 :
1316 117 : if(bNegative)
1317 : {
1318 0 : aBuf.insert(0, "-");
1319 : }
1320 :
1321 117 : if(!bNoUnitChars)
1322 0 : aBuf.append(aUIUnitStr);
1323 :
1324 234 : rStr = aBuf.makeStringAndClear();
1325 117 : }
1326 :
1327 0 : void SdrModel::TakeAngleStr(long nAngle, OUString& rStr, bool bNoDegChar)
1328 : {
1329 0 : bool bNeg = nAngle < 0;
1330 :
1331 0 : if(bNeg)
1332 0 : nAngle = -nAngle;
1333 :
1334 0 : OUStringBuffer aBuf;
1335 0 : aBuf.append(static_cast<sal_Int32>(nAngle));
1336 :
1337 0 : SvtSysLocale aSysLoc;
1338 0 : const LocaleDataWrapper& rLoc = aSysLoc.GetLocaleData();
1339 0 : sal_Int32 nCount = 2;
1340 :
1341 0 : if(LocaleDataWrapper::isNumLeadingZero())
1342 0 : nCount++;
1343 :
1344 0 : while(aBuf.getLength() < nCount)
1345 0 : aBuf.insert(0, '0');
1346 :
1347 0 : aBuf.insert(aBuf.getLength()-2, rLoc.getNumDecimalSep()[0]);
1348 :
1349 0 : if(bNeg)
1350 0 : aBuf.insert(0, '-');
1351 :
1352 0 : if(!bNoDegChar)
1353 0 : aBuf.append(DEGREE_CHAR);
1354 :
1355 0 : rStr = aBuf.makeStringAndClear();
1356 0 : }
1357 :
1358 0 : void SdrModel::TakePercentStr(const Fraction& rVal, OUString& rStr, bool bNoPercentChar)
1359 : {
1360 0 : sal_Int32 nMul(rVal.GetNumerator());
1361 0 : sal_Int32 nDiv(rVal.GetDenominator());
1362 0 : bool bNeg(nMul < 0);
1363 :
1364 0 : if(nDiv < 0)
1365 0 : bNeg = !bNeg;
1366 :
1367 0 : if(nMul < 0)
1368 0 : nMul = -nMul;
1369 :
1370 0 : if(nDiv < 0)
1371 0 : nDiv = -nDiv;
1372 :
1373 0 : nMul *= 100;
1374 0 : nMul += nDiv/2;
1375 0 : nMul /= nDiv;
1376 :
1377 0 : rStr = OUString::number(nMul);
1378 :
1379 0 : if(bNeg)
1380 0 : rStr = "-" + rStr;
1381 :
1382 0 : if(!bNoPercentChar)
1383 0 : rStr += "%";
1384 0 : }
1385 :
1386 2798506 : void SdrModel::SetChanged(bool bFlg)
1387 : {
1388 2798506 : mbChanged = bFlg;
1389 2798506 : }
1390 :
1391 351 : void SdrModel::RecalcPageNums(bool bMaster)
1392 : {
1393 351 : if(bMaster)
1394 : {
1395 5 : sal_uInt16 nCount=sal_uInt16(maMaPag.size());
1396 : sal_uInt16 i;
1397 42 : for (i=0; i<nCount; i++) {
1398 37 : SdrPage* pPg=maMaPag[i];
1399 37 : pPg->SetPageNum(i);
1400 : }
1401 5 : bMPgNumsDirty=false;
1402 : }
1403 : else
1404 : {
1405 346 : sal_uInt16 nCount=sal_uInt16(maPages.size());
1406 : sal_uInt16 i;
1407 1433 : for (i=0; i<nCount; i++) {
1408 1087 : SdrPage* pPg=maPages[i];
1409 1087 : pPg->SetPageNum(i);
1410 : }
1411 346 : bPagNumsDirty=false;
1412 : }
1413 351 : }
1414 :
1415 5817 : void SdrModel::InsertPage(SdrPage* pPage, sal_uInt16 nPos)
1416 : {
1417 5817 : sal_uInt16 nCount=GetPageCount();
1418 5817 : if (nPos>nCount) nPos=nCount;
1419 5817 : maPages.insert(maPages.begin()+nPos,pPage);
1420 5817 : PageListChanged();
1421 5817 : pPage->SetInserted(true);
1422 5817 : pPage->SetPageNum(nPos);
1423 5817 : pPage->SetModel(this);
1424 5817 : if (nPos<nCount) bPagNumsDirty=true;
1425 5817 : SetChanged();
1426 5817 : SdrHint aHint(HINT_PAGEORDERCHG);
1427 5817 : aHint.SetPage(pPage);
1428 5817 : Broadcast(aHint);
1429 5817 : }
1430 :
1431 5112 : void SdrModel::DeletePage(sal_uInt16 nPgNum)
1432 : {
1433 5112 : SdrPage* pPg=RemovePage(nPgNum);
1434 5112 : delete pPg;
1435 5112 : }
1436 :
1437 5756 : SdrPage* SdrModel::RemovePage(sal_uInt16 nPgNum)
1438 : {
1439 5756 : SdrPage* pPg=maPages[nPgNum];
1440 5756 : maPages.erase(maPages.begin()+nPgNum);
1441 5756 : PageListChanged();
1442 5756 : if (pPg!=NULL) {
1443 5756 : pPg->SetInserted(false);
1444 : }
1445 5756 : bPagNumsDirty=true;
1446 5756 : SetChanged();
1447 5756 : SdrHint aHint(HINT_PAGEORDERCHG);
1448 5756 : aHint.SetPage(pPg);
1449 5756 : Broadcast(aHint);
1450 5756 : return pPg;
1451 : }
1452 :
1453 1 : void SdrModel::MovePage(sal_uInt16 nPgNum, sal_uInt16 nNewPos)
1454 : {
1455 1 : SdrPage* pPg=maPages[nPgNum];
1456 1 : if (pPg!=NULL) {
1457 1 : maPages.erase(maPages.begin()+nPgNum); // shortcut to avoid two broadcasts
1458 1 : PageListChanged();
1459 1 : pPg->SetInserted(false);
1460 1 : InsertPage(pPg,nNewPos);
1461 : }
1462 : else
1463 0 : RemovePage(nPgNum);
1464 1 : }
1465 :
1466 786 : void SdrModel::InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos)
1467 : {
1468 786 : sal_uInt16 nCount=GetMasterPageCount();
1469 786 : if (nPos>nCount) nPos=nCount;
1470 786 : maMaPag.insert(maMaPag.begin()+nPos,pPage);
1471 786 : MasterPageListChanged();
1472 786 : pPage->SetInserted(true);
1473 786 : pPage->SetPageNum(nPos);
1474 786 : pPage->SetModel(this);
1475 786 : if (nPos<nCount) {
1476 2 : bMPgNumsDirty=true;
1477 : }
1478 786 : SetChanged();
1479 786 : SdrHint aHint(HINT_PAGEORDERCHG);
1480 786 : aHint.SetPage(pPage);
1481 786 : Broadcast(aHint);
1482 786 : }
1483 :
1484 769 : void SdrModel::DeleteMasterPage(sal_uInt16 nPgNum)
1485 : {
1486 769 : SdrPage* pPg=RemoveMasterPage(nPgNum);
1487 769 : delete pPg;
1488 769 : }
1489 :
1490 771 : SdrPage* SdrModel::RemoveMasterPage(sal_uInt16 nPgNum)
1491 : {
1492 771 : SdrPage* pRetPg=maMaPag[nPgNum];
1493 771 : maMaPag.erase(maMaPag.begin()+nPgNum);
1494 771 : MasterPageListChanged();
1495 :
1496 771 : if(pRetPg)
1497 : {
1498 : // Now delete the links from the normal drawing pages to the deleted master page.
1499 771 : sal_uInt16 nPageAnz(GetPageCount());
1500 :
1501 777 : for(sal_uInt16 np(0); np < nPageAnz; np++)
1502 : {
1503 6 : GetPage(np)->TRG_ImpMasterPageRemoved(*pRetPg);
1504 : }
1505 :
1506 771 : pRetPg->SetInserted(false);
1507 : }
1508 :
1509 771 : bMPgNumsDirty=true;
1510 771 : SetChanged();
1511 771 : SdrHint aHint(HINT_PAGEORDERCHG);
1512 771 : aHint.SetPage(pRetPg);
1513 771 : Broadcast(aHint);
1514 771 : return pRetPg;
1515 : }
1516 :
1517 0 : void SdrModel::MoveMasterPage(sal_uInt16 nPgNum, sal_uInt16 nNewPos)
1518 : {
1519 0 : SdrPage* pPg=maMaPag[nPgNum];
1520 0 : maMaPag.erase(maMaPag.begin()+nPgNum);
1521 0 : MasterPageListChanged();
1522 0 : if (pPg!=NULL) {
1523 0 : pPg->SetInserted(false);
1524 0 : maMaPag.insert(maMaPag.begin()+nNewPos,pPg);
1525 0 : MasterPageListChanged();
1526 : }
1527 0 : bMPgNumsDirty=true;
1528 0 : SetChanged();
1529 0 : SdrHint aHint(HINT_PAGEORDERCHG);
1530 0 : aHint.SetPage(pPg);
1531 0 : Broadcast(aHint);
1532 0 : }
1533 :
1534 :
1535 :
1536 0 : void SdrModel::CopyPages(sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
1537 : sal_uInt16 nDestPos,
1538 : bool bUndo, bool bMoveNoCopy)
1539 : {
1540 0 : if( bUndo && !IsUndoEnabled() )
1541 0 : bUndo = false;
1542 :
1543 0 : if( bUndo )
1544 0 : BegUndo(ImpGetResStr(STR_UndoMergeModel));
1545 :
1546 0 : sal_uInt16 nPageAnz=GetPageCount();
1547 0 : sal_uInt16 nMaxPage=nPageAnz;
1548 :
1549 0 : if (nMaxPage!=0)
1550 0 : nMaxPage--;
1551 0 : if (nFirstPageNum>nMaxPage)
1552 0 : nFirstPageNum=nMaxPage;
1553 0 : if (nLastPageNum>nMaxPage)
1554 0 : nLastPageNum =nMaxPage;
1555 0 : bool bReverse=nLastPageNum<nFirstPageNum;
1556 0 : if (nDestPos>nPageAnz)
1557 0 : nDestPos=nPageAnz;
1558 :
1559 : // at first, save the pointers of the affected pages in an array
1560 0 : sal_uInt16 nPageNum=nFirstPageNum;
1561 0 : sal_uInt16 nCopyAnz=((!bReverse)?(nLastPageNum-nFirstPageNum):(nFirstPageNum-nLastPageNum))+1;
1562 0 : boost::scoped_array<SdrPage*> pPagePtrs(new SdrPage*[nCopyAnz]);
1563 : sal_uInt16 nCopyNum;
1564 0 : for(nCopyNum=0; nCopyNum<nCopyAnz; nCopyNum++)
1565 : {
1566 0 : pPagePtrs[nCopyNum]=GetPage(nPageNum);
1567 0 : if (bReverse)
1568 0 : nPageNum--;
1569 : else
1570 0 : nPageNum++;
1571 : }
1572 :
1573 : // now copy the pages
1574 0 : sal_uInt16 nDestNum=nDestPos;
1575 0 : for (nCopyNum=0; nCopyNum<nCopyAnz; nCopyNum++)
1576 : {
1577 0 : SdrPage* pPg=pPagePtrs[nCopyNum];
1578 0 : sal_uInt16 nPageNum2=pPg->GetPageNum();
1579 0 : if (!bMoveNoCopy)
1580 : {
1581 0 : const SdrPage* pPg1=GetPage(nPageNum2);
1582 0 : pPg=pPg1->Clone();
1583 0 : InsertPage(pPg,nDestNum);
1584 0 : if (bUndo)
1585 0 : AddUndo(GetSdrUndoFactory().CreateUndoCopyPage(*pPg));
1586 0 : nDestNum++;
1587 : }
1588 : else
1589 : {
1590 : // TODO: Move is untested!
1591 0 : if (nDestNum>nPageNum2)
1592 0 : nDestNum--;
1593 :
1594 0 : if(bUndo)
1595 0 : AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*GetPage(nPageNum2),nPageNum2,nDestNum));
1596 :
1597 0 : pPg=RemovePage(nPageNum2);
1598 0 : InsertPage(pPg,nDestNum);
1599 0 : nDestNum++;
1600 : }
1601 :
1602 0 : if(bReverse)
1603 0 : nPageNum2--;
1604 : else
1605 0 : nPageNum2++;
1606 : }
1607 :
1608 0 : pPagePtrs.reset();
1609 0 : if(bUndo)
1610 0 : EndUndo();
1611 0 : }
1612 :
1613 0 : void SdrModel::Merge(SdrModel& rSourceModel,
1614 : sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
1615 : sal_uInt16 nDestPos,
1616 : bool bMergeMasterPages, bool bAllMasterPages,
1617 : bool bUndo, bool bTreadSourceAsConst)
1618 : {
1619 0 : if (&rSourceModel==this)
1620 : {
1621 0 : CopyPages(nFirstPageNum,nLastPageNum,nDestPos,bUndo,!bTreadSourceAsConst);
1622 0 : return;
1623 : }
1624 :
1625 0 : if( bUndo && !IsUndoEnabled() )
1626 0 : bUndo = false;
1627 :
1628 0 : if (bUndo)
1629 0 : BegUndo(ImpGetResStr(STR_UndoMergeModel));
1630 :
1631 0 : sal_uInt16 nSrcPageAnz=rSourceModel.GetPageCount();
1632 0 : sal_uInt16 nSrcMasterPageAnz=rSourceModel.GetMasterPageCount();
1633 0 : sal_uInt16 nDstMasterPageAnz=GetMasterPageCount();
1634 0 : bool bInsPages=(nFirstPageNum<nSrcPageAnz || nLastPageNum<nSrcPageAnz);
1635 0 : sal_uInt16 nMaxSrcPage=nSrcPageAnz; if (nMaxSrcPage!=0) nMaxSrcPage--;
1636 0 : if (nFirstPageNum>nMaxSrcPage) nFirstPageNum=nMaxSrcPage;
1637 0 : if (nLastPageNum>nMaxSrcPage) nLastPageNum =nMaxSrcPage;
1638 0 : bool bReverse=nLastPageNum<nFirstPageNum;
1639 :
1640 0 : boost::scoped_array<sal_uInt16> pMasterMap;
1641 0 : boost::scoped_array<bool> pMasterNeed;
1642 0 : sal_uInt16 nMasterNeed=0;
1643 0 : if (bMergeMasterPages && nSrcMasterPageAnz!=0) {
1644 : // determine which MasterPages from rSrcModel we need
1645 0 : pMasterMap.reset(new sal_uInt16[nSrcMasterPageAnz]);
1646 0 : pMasterNeed.reset(new bool[nSrcMasterPageAnz]);
1647 0 : memset(pMasterMap.get(),0xFF,nSrcMasterPageAnz*sizeof(sal_uInt16));
1648 0 : if (bAllMasterPages) {
1649 0 : memset(pMasterNeed.get(), true, nSrcMasterPageAnz * sizeof(bool));
1650 : } else {
1651 0 : memset(pMasterNeed.get(), false, nSrcMasterPageAnz * sizeof(bool));
1652 0 : sal_uInt16 nAnf= bReverse ? nLastPageNum : nFirstPageNum;
1653 0 : sal_uInt16 nEnd= bReverse ? nFirstPageNum : nLastPageNum;
1654 0 : for (sal_uInt16 i=nAnf; i<=nEnd; i++) {
1655 0 : const SdrPage* pPg=rSourceModel.GetPage(i);
1656 0 : if(pPg->TRG_HasMasterPage())
1657 : {
1658 0 : SdrPage& rMasterPage = pPg->TRG_GetMasterPage();
1659 0 : sal_uInt16 nMPgNum(rMasterPage.GetPageNum());
1660 :
1661 0 : if(nMPgNum < nSrcMasterPageAnz)
1662 : {
1663 0 : pMasterNeed[nMPgNum] = true;
1664 : }
1665 : }
1666 : }
1667 : }
1668 : // now determine the Mapping of the MasterPages
1669 0 : sal_uInt16 nAktMaPagNum=nDstMasterPageAnz;
1670 0 : for (sal_uInt16 i=0; i<nSrcMasterPageAnz; i++) {
1671 0 : if (pMasterNeed[i]) {
1672 0 : pMasterMap[i]=nAktMaPagNum;
1673 0 : nAktMaPagNum++;
1674 0 : nMasterNeed++;
1675 : }
1676 : }
1677 : }
1678 :
1679 : // get the MasterPages
1680 0 : if (pMasterMap && pMasterNeed && nMasterNeed!=0) {
1681 0 : for (sal_uInt16 i=nSrcMasterPageAnz; i>0;) {
1682 0 : i--;
1683 0 : if (pMasterNeed[i]) {
1684 0 : SdrPage* pPg=NULL;
1685 0 : if (bTreadSourceAsConst) {
1686 0 : const SdrPage* pPg1=rSourceModel.GetMasterPage(i);
1687 0 : pPg=pPg1->Clone();
1688 : } else {
1689 0 : pPg=rSourceModel.RemoveMasterPage(i);
1690 : }
1691 0 : if (pPg!=NULL) {
1692 : // Now append all of them to the end of the DstModel.
1693 : // Don't use InsertMasterPage(), because everything is
1694 : // inconsistent until all are in.
1695 0 : maMaPag.insert(maMaPag.begin()+nDstMasterPageAnz, pPg);
1696 0 : MasterPageListChanged();
1697 0 : pPg->SetInserted(true);
1698 0 : pPg->SetModel(this);
1699 0 : bMPgNumsDirty=true;
1700 0 : if (bUndo) AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pPg));
1701 : } else {
1702 : OSL_FAIL("SdrModel::Merge(): MasterPage not found in SourceModel.");
1703 : }
1704 : }
1705 : }
1706 : }
1707 :
1708 : // get the drawing pages
1709 0 : if (bInsPages) {
1710 0 : sal_uInt16 nSourcePos=nFirstPageNum;
1711 0 : sal_uInt16 nMergeCount=sal_uInt16(std::abs((long)((long)nFirstPageNum-nLastPageNum))+1);
1712 0 : if (nDestPos>GetPageCount()) nDestPos=GetPageCount();
1713 0 : while (nMergeCount>0) {
1714 0 : SdrPage* pPg=NULL;
1715 0 : if (bTreadSourceAsConst) {
1716 0 : const SdrPage* pPg1=rSourceModel.GetPage(nSourcePos);
1717 0 : pPg=pPg1->Clone();
1718 : } else {
1719 0 : pPg=rSourceModel.RemovePage(nSourcePos);
1720 : }
1721 0 : if (pPg!=NULL) {
1722 0 : InsertPage(pPg,nDestPos);
1723 0 : if (bUndo) AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pPg));
1724 :
1725 0 : if(pPg->TRG_HasMasterPage())
1726 : {
1727 0 : SdrPage& rMasterPage = pPg->TRG_GetMasterPage();
1728 0 : sal_uInt16 nMaPgNum(rMasterPage.GetPageNum());
1729 :
1730 0 : if (bMergeMasterPages)
1731 : {
1732 0 : sal_uInt16 nNeuNum(0xFFFF);
1733 :
1734 0 : if(pMasterMap)
1735 : {
1736 0 : nNeuNum = pMasterMap[nMaPgNum];
1737 : }
1738 :
1739 0 : if(nNeuNum != 0xFFFF)
1740 : {
1741 0 : if(bUndo)
1742 : {
1743 0 : AddUndo(GetSdrUndoFactory().CreateUndoPageChangeMasterPage(*pPg));
1744 : }
1745 :
1746 0 : pPg->TRG_SetMasterPage(*GetMasterPage(nNeuNum));
1747 : }
1748 : DBG_ASSERT(nNeuNum!=0xFFFF,"SdrModel::Merge(): Something is crooked with the mapping of the MasterPages.");
1749 : } else {
1750 0 : if (nMaPgNum>=nDstMasterPageAnz) {
1751 : // This is outside of the original area of the MasterPage of the DstModel.
1752 0 : pPg->TRG_ClearMasterPage();
1753 : }
1754 : }
1755 : }
1756 :
1757 : } else {
1758 : OSL_FAIL("SdrModel::Merge(): Drawing page not found in SourceModel.");
1759 : }
1760 0 : nDestPos++;
1761 0 : if (bReverse) nSourcePos--;
1762 0 : else if (bTreadSourceAsConst) nSourcePos++;
1763 0 : nMergeCount--;
1764 : }
1765 : }
1766 :
1767 0 : pMasterMap.reset();
1768 0 : pMasterNeed.reset();
1769 :
1770 0 : bMPgNumsDirty=true;
1771 0 : bPagNumsDirty=true;
1772 :
1773 0 : SetChanged();
1774 : // TODO: Missing: merging and mapping of layers
1775 : // at the objects as well as at the MasterPageDescriptors
1776 0 : if (bUndo) EndUndo();
1777 : }
1778 :
1779 0 : void SdrModel::SetStarDrawPreviewMode(bool bPreview)
1780 : {
1781 0 : if (!bPreview && bStarDrawPreviewMode && GetPageCount())
1782 : {
1783 : // Resetting is not allowed, because the Model might not be loaded completely
1784 : DBG_ASSERT(false,"SdrModel::SetStarDrawPreviewMode(): Resetting not allowed, because Model might not be complete.");
1785 : }
1786 : else
1787 : {
1788 0 : bStarDrawPreviewMode = bPreview;
1789 : }
1790 0 : }
1791 :
1792 7130 : uno::Reference< uno::XInterface > SdrModel::getUnoModel()
1793 : {
1794 7130 : if( !mxUnoModel.is() )
1795 761 : mxUnoModel = createUnoModel();
1796 :
1797 7130 : return mxUnoModel;
1798 : }
1799 :
1800 0 : void SdrModel::setUnoModel( ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xModel )
1801 : {
1802 0 : mxUnoModel = xModel;
1803 0 : }
1804 :
1805 0 : uno::Reference< uno::XInterface > SdrModel::createUnoModel()
1806 : {
1807 : OSL_FAIL( "SdrModel::createUnoModel() - base implementation should not be called!" );
1808 0 : ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xInt;
1809 0 : return xInt;
1810 : }
1811 :
1812 4088 : void SdrModel::setLock( bool bLock )
1813 : {
1814 4088 : if( mbModelLocked != bLock )
1815 : {
1816 : // #i120437# need to set first, else ImpReformatAllEdgeObjects will do nothing
1817 3802 : mbModelLocked = bLock;
1818 :
1819 3802 : if( !bLock )
1820 : {
1821 1897 : ImpReformatAllEdgeObjects();
1822 : }
1823 : }
1824 4088 : }
1825 :
1826 :
1827 :
1828 13072 : void SdrModel::MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSet, SdrModel* pNewModel )
1829 : {
1830 : assert(pNewModel != 0);
1831 13072 : if( pSourceSet && pDestSet && (pSourceSet != pDestSet ) )
1832 : {
1833 13072 : SfxWhichIter aWhichIter(*pSourceSet);
1834 13072 : sal_uInt16 nWhich(aWhichIter.FirstWhich());
1835 : const SfxPoolItem *pPoolItem;
1836 :
1837 1834503 : while(nWhich)
1838 : {
1839 1808359 : if(SfxItemState::SET == pSourceSet->GetItemState(nWhich, false, &pPoolItem))
1840 : {
1841 67414 : const SfxPoolItem* pResultItem = NULL;
1842 :
1843 67414 : switch( nWhich )
1844 : {
1845 : case XATTR_FILLBITMAP:
1846 0 : pResultItem = static_cast<const XFillBitmapItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
1847 0 : break;
1848 : case XATTR_LINEDASH:
1849 130 : pResultItem = static_cast<const XLineDashItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
1850 130 : break;
1851 : case XATTR_LINESTART:
1852 62 : pResultItem = static_cast<const XLineStartItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
1853 62 : break;
1854 : case XATTR_LINEEND:
1855 66 : pResultItem = static_cast<const XLineEndItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
1856 66 : break;
1857 : case XATTR_FILLGRADIENT:
1858 1 : pResultItem = static_cast<const XFillGradientItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
1859 1 : break;
1860 : case XATTR_FILLFLOATTRANSPARENCE:
1861 : // allow all kinds of XFillFloatTransparenceItem to be set
1862 0 : pResultItem = static_cast<const XFillFloatTransparenceItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
1863 0 : break;
1864 : case XATTR_FILLHATCH:
1865 32 : pResultItem = static_cast<const XFillHatchItem*>(pPoolItem)->checkForUniqueItem( pNewModel );
1866 32 : break;
1867 : }
1868 :
1869 : // set item
1870 67414 : if( pResultItem )
1871 : {
1872 107 : pDestSet->Put(*pResultItem);
1873 107 : delete pResultItem;
1874 : }
1875 : else
1876 67307 : pDestSet->Put(*pPoolItem);
1877 : }
1878 1808359 : nWhich = aWhichIter.NextWhich();
1879 13072 : }
1880 : }
1881 13072 : }
1882 :
1883 :
1884 :
1885 3947 : void SdrModel::SetForbiddenCharsTable( rtl::Reference<SvxForbiddenCharactersTable> xForbiddenChars )
1886 : {
1887 3947 : if( mpForbiddenCharactersTable )
1888 90 : mpForbiddenCharactersTable->release();
1889 :
1890 3947 : mpForbiddenCharactersTable = xForbiddenChars.get();
1891 :
1892 3947 : if( mpForbiddenCharactersTable )
1893 3405 : mpForbiddenCharactersTable->acquire();
1894 :
1895 3947 : ImpSetOutlinerDefaults( pDrawOutliner );
1896 3947 : ImpSetOutlinerDefaults( pHitTestOutliner );
1897 3947 : }
1898 :
1899 :
1900 3570 : void SdrModel::SetCharCompressType( sal_uInt16 nType )
1901 : {
1902 3570 : if( nType != mnCharCompressType )
1903 : {
1904 19 : mnCharCompressType = nType;
1905 19 : ImpSetOutlinerDefaults( pDrawOutliner );
1906 19 : ImpSetOutlinerDefaults( pHitTestOutliner );
1907 : }
1908 3570 : }
1909 :
1910 595 : void SdrModel::SetKernAsianPunctuation( bool bEnabled )
1911 : {
1912 595 : if( mbKernAsianPunctuation != bEnabled )
1913 : {
1914 2 : mbKernAsianPunctuation = bEnabled;
1915 2 : ImpSetOutlinerDefaults( pDrawOutliner );
1916 2 : ImpSetOutlinerDefaults( pHitTestOutliner );
1917 : }
1918 595 : }
1919 :
1920 2968 : void SdrModel::SetAddExtLeading( bool bEnabled )
1921 : {
1922 2968 : if( mbAddExtLeading != bEnabled )
1923 : {
1924 2967 : mbAddExtLeading = bEnabled;
1925 2967 : ImpSetOutlinerDefaults( pDrawOutliner );
1926 2967 : ImpSetOutlinerDefaults( pHitTestOutliner );
1927 : }
1928 2968 : }
1929 :
1930 42 : void SdrModel::ReformatAllTextObjects()
1931 : {
1932 42 : ImpReformatAllTextObjects();
1933 42 : }
1934 :
1935 27149 : SdrOutliner* SdrModel::createOutliner( sal_uInt16 nOutlinerMode )
1936 : {
1937 27149 : if( NULL == mpOutlinerCache )
1938 882 : mpOutlinerCache = new SdrOutlinerCache(this);
1939 :
1940 27149 : return mpOutlinerCache->createOutliner( nOutlinerMode );
1941 : }
1942 :
1943 0 : std::vector<SdrOutliner*> SdrModel::GetActiveOutliners() const
1944 : {
1945 : std::vector<SdrOutliner*> aRet(mpOutlinerCache ?
1946 0 : mpOutlinerCache->GetActiveOutliners() : std::vector<SdrOutliner*>());
1947 :
1948 0 : aRet.push_back(pDrawOutliner);
1949 0 : aRet.push_back(pHitTestOutliner);
1950 :
1951 0 : return aRet;
1952 : }
1953 :
1954 26996 : void SdrModel::disposeOutliner( SdrOutliner* pOutliner )
1955 : {
1956 26996 : if( mpOutlinerCache )
1957 : {
1958 26996 : mpOutlinerCache->disposeOutliner( pOutliner );
1959 : }
1960 : else
1961 : {
1962 0 : delete pOutliner;
1963 : }
1964 26996 : }
1965 :
1966 0 : SvxNumType SdrModel::GetPageNumType() const
1967 : {
1968 0 : return SVX_ARABIC;
1969 : }
1970 :
1971 8706 : const SdrPage* SdrModel::GetPage(sal_uInt16 nPgNum) const
1972 : {
1973 : DBG_ASSERT(nPgNum < maPages.size(), "SdrModel::GetPage: Access out of range (!)");
1974 8706 : return nPgNum < maPages.size() ? maPages[nPgNum] : NULL;
1975 : }
1976 :
1977 54993 : SdrPage* SdrModel::GetPage(sal_uInt16 nPgNum)
1978 : {
1979 : DBG_ASSERT(nPgNum < maPages.size(), "SdrModel::GetPage: Access out of range (!)");
1980 54993 : return nPgNum < maPages.size() ? maPages[nPgNum] : NULL;
1981 : }
1982 :
1983 41841 : sal_uInt16 SdrModel::GetPageCount() const
1984 : {
1985 41841 : return sal_uInt16(maPages.size());
1986 : }
1987 :
1988 16581 : void SdrModel::PageListChanged()
1989 : {
1990 16581 : }
1991 :
1992 1464 : const SdrPage* SdrModel::GetMasterPage(sal_uInt16 nPgNum) const
1993 : {
1994 : DBG_ASSERT(nPgNum < maMaPag.size(), "SdrModel::GetMasterPage: Access out of range (!)");
1995 1464 : return maMaPag[nPgNum];
1996 : }
1997 :
1998 3364 : SdrPage* SdrModel::GetMasterPage(sal_uInt16 nPgNum)
1999 : {
2000 : DBG_ASSERT(nPgNum < maMaPag.size(), "SdrModel::GetMasterPage: Access out of range (!)");
2001 3364 : return maMaPag[nPgNum];
2002 : }
2003 :
2004 22759 : sal_uInt16 SdrModel::GetMasterPageCount() const
2005 : {
2006 22759 : return sal_uInt16(maMaPag.size());
2007 : }
2008 :
2009 8138 : void SdrModel::MasterPageListChanged()
2010 : {
2011 8138 : }
2012 :
2013 631 : void SdrModel::SetSdrUndoManager( SfxUndoManager* pUndoManager )
2014 : {
2015 631 : mpImpl->mpUndoManager = pUndoManager;
2016 631 : }
2017 :
2018 14 : SfxUndoManager* SdrModel::GetSdrUndoManager() const
2019 : {
2020 14 : return mpImpl->mpUndoManager;
2021 : }
2022 :
2023 1843 : SdrUndoFactory& SdrModel::GetSdrUndoFactory() const
2024 : {
2025 1843 : if( !mpImpl->mpUndoFactory )
2026 4 : mpImpl->mpUndoFactory = new SdrUndoFactory;
2027 1843 : return *mpImpl->mpUndoFactory;
2028 : }
2029 :
2030 318 : void SdrModel::SetSdrUndoFactory( SdrUndoFactory* pUndoFactory )
2031 : {
2032 318 : if( pUndoFactory && (pUndoFactory != mpImpl->mpUndoFactory) )
2033 : {
2034 318 : delete mpImpl->mpUndoFactory;
2035 318 : mpImpl->mpUndoFactory = pUndoFactory;
2036 : }
2037 318 : }
2038 :
2039 0 : void SdrModel::dumpAsXml(xmlTextWriterPtr pWriter) const
2040 : {
2041 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("sdrModel"));
2042 0 : xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
2043 :
2044 0 : sal_uInt16 nPageCount = GetPageCount();
2045 0 : for (sal_uInt16 i = 0; i < nPageCount; ++i)
2046 : {
2047 0 : if (const SdrPage* pPage = GetPage(i))
2048 0 : pPage->dumpAsXml(pWriter);
2049 : }
2050 :
2051 0 : xmlTextWriterEndElement(pWriter);
2052 0 : }
2053 :
2054 : namespace
2055 : {
2056 : class theSdrModelUnoTunnelImplementationId : public rtl::Static< UnoTunnelIdInit, theSdrModelUnoTunnelImplementationId > {};
2057 : }
2058 :
2059 6201 : const ::com::sun::star::uno::Sequence< sal_Int8 >& SdrModel::getUnoTunnelImplementationId()
2060 : {
2061 6201 : return theSdrModelUnoTunnelImplementationId::get().getSeq();
2062 : }
2063 :
2064 :
2065 :
2066 51680 : SdrHint::SdrHint(SdrHintKind eNewHint)
2067 : : mpPage(0L),
2068 : mpObj(0L),
2069 : mpObjList(0L),
2070 51680 : meHint(eNewHint)
2071 : {
2072 51680 : }
2073 :
2074 198177 : SdrHint::SdrHint(const SdrObject& rNewObj)
2075 198177 : : mpPage(rNewObj.GetPage()),
2076 : mpObj(&rNewObj),
2077 198177 : mpObjList(rNewObj.GetObjList()),
2078 594531 : meHint(HINT_OBJCHG)
2079 : {
2080 198177 : maRectangle = rNewObj.GetLastBoundRect();
2081 198177 : }
2082 :
2083 23247 : void SdrHint::SetPage(const SdrPage* pNewPage)
2084 : {
2085 23247 : mpPage = pNewPage;
2086 23247 : }
2087 :
2088 1 : void SdrHint::SetObject(const SdrObject* pNewObj)
2089 : {
2090 1 : mpObj = pNewObj;
2091 1 : }
2092 :
2093 119111 : void SdrHint::SetKind(SdrHintKind eNewKind)
2094 : {
2095 119111 : meHint = eNewKind;
2096 119546 : }
2097 :
2098 :
2099 :
2100 :
2101 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
