LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdmodel.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1087 0.0 %
Date: 2014-04-14 Functions: 0 117 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10