LCOV - code coverage report
Current view: top level - sc/source/core/data - documen9.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 336 0.0 %
Date: 2014-04-14 Functions: 0 41 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             : #include "scitems.hxx"
      21             : #include <editeng/eeitem.hxx>
      22             : 
      23             : #include <sot/exchange.hxx>
      24             : #include <editeng/autokernitem.hxx>
      25             : #include <editeng/fontitem.hxx>
      26             : #include <editeng/forbiddencharacterstable.hxx>
      27             : #include <editeng/langitem.hxx>
      28             : #include <osl/thread.h>
      29             : #include <svx/svdetc.hxx>
      30             : #include <svx/svditer.hxx>
      31             : #include <svx/svdocapt.hxx>
      32             : #include <svx/svdograf.hxx>
      33             : #include <svx/svdoole2.hxx>
      34             : #include <svx/svdouno.hxx>
      35             : #include <svx/svdpage.hxx>
      36             : #include <svx/svdundo.hxx>
      37             : #include <svx/xtable.hxx>
      38             : #include <sfx2/objsh.hxx>
      39             : #include <sfx2/printer.hxx>
      40             : #include <unotools/saveopt.hxx>
      41             : #include <unotools/pathoptions.hxx>
      42             : 
      43             : #include "document.hxx"
      44             : #include "docoptio.hxx"
      45             : #include "table.hxx"
      46             : #include "drwlayer.hxx"
      47             : #include "markdata.hxx"
      48             : #include "patattr.hxx"
      49             : #include "rechead.hxx"
      50             : #include "poolhelp.hxx"
      51             : #include "docpool.hxx"
      52             : #include "detfunc.hxx"
      53             : #include "editutil.hxx"
      54             : #include "postit.hxx"
      55             : #include "charthelper.hxx"
      56             : #include "interpre.hxx"
      57             : #include <documentlinkmgr.hxx>
      58             : 
      59             : using namespace ::com::sun::star;
      60             : #include <stdio.h>
      61             : 
      62           0 : SfxBroadcaster* ScDocument::GetDrawBroadcaster()
      63             : {
      64           0 :     return pDrawLayer;
      65             : }
      66             : 
      67           0 : void ScDocument::BeginDrawUndo()
      68             : {
      69           0 :     if (pDrawLayer)
      70           0 :         pDrawLayer->BeginCalcUndo(false);
      71           0 : }
      72             : 
      73           0 : rtl::Reference<XColorList> ScDocument::GetColorList()
      74             : {
      75           0 :     if (pDrawLayer)
      76           0 :         return pDrawLayer->GetColorList();
      77             :     else
      78             :     {
      79           0 :         if (!pColorList.is())
      80           0 :             pColorList = XColorList::CreateStdColorList();
      81           0 :         return pColorList;
      82             :     }
      83             : }
      84             : 
      85           0 : void ScDocument::TransferDrawPage(ScDocument* pSrcDoc, SCTAB nSrcPos, SCTAB nDestPos)
      86             : {
      87           0 :     if (pDrawLayer && pSrcDoc->pDrawLayer)
      88             :     {
      89           0 :         SdrPage* pOldPage = pSrcDoc->pDrawLayer->GetPage(static_cast<sal_uInt16>(nSrcPos));
      90           0 :         SdrPage* pNewPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nDestPos));
      91             : 
      92           0 :         if (pOldPage && pNewPage)
      93             :         {
      94           0 :             SdrObjListIter aIter( *pOldPage, IM_FLAT );
      95           0 :             SdrObject* pOldObject = aIter.Next();
      96           0 :             while (pOldObject)
      97             :             {
      98             :                 // #116235#
      99           0 :                 SdrObject* pNewObject = pOldObject->Clone();
     100             :                 // SdrObject* pNewObject = pOldObject->Clone( pNewPage, pDrawLayer );
     101           0 :                 pNewObject->SetModel(pDrawLayer);
     102           0 :                 pNewObject->SetPage(pNewPage);
     103             : 
     104           0 :                 pNewObject->NbcMove(Size(0,0));
     105           0 :                 pNewPage->InsertObject( pNewObject );
     106             : 
     107           0 :                 if (pDrawLayer->IsRecording())
     108           0 :                     pDrawLayer->AddCalcUndo( new SdrUndoInsertObj( *pNewObject ) );
     109             : 
     110           0 :                 pOldObject = aIter.Next();
     111           0 :             }
     112             :         }
     113             :     }
     114             : 
     115             :     //  make sure the data references of charts are adapted
     116             :     //  (this must be after InsertObject!)
     117           0 :     ScChartHelper::AdjustRangesOfChartsOnDestinationPage( pSrcDoc, this, nSrcPos, nDestPos );
     118           0 :     ScChartHelper::UpdateChartsOnDestinationPage(this, nDestPos);
     119           0 : }
     120             : 
     121           0 : void ScDocument::InitDrawLayer( SfxObjectShell* pDocShell )
     122             : {
     123           0 :     if (pDocShell && !pShell)
     124           0 :         pShell = pDocShell;
     125             : 
     126           0 :     if (!pDrawLayer)
     127             :     {
     128           0 :         OUString aName;
     129           0 :         if ( pShell && !pShell->IsLoading() )       // don't call GetTitle while loading
     130           0 :             aName = pShell->GetTitle();
     131           0 :         pDrawLayer = new ScDrawLayer( this, aName );
     132             : 
     133           0 :         sfx2::LinkManager* pMgr = GetDocLinkManager().getLinkManager(bAutoCalc);
     134           0 :         if (pMgr)
     135           0 :             pDrawLayer->SetLinkManager(pMgr);
     136             : 
     137             :         //  Drawing pages are accessed by table number, so they must also be present
     138             :         //  for preceding table numbers, even if the tables aren't allocated
     139             :         //  (important for clipboard documents).
     140             : 
     141           0 :         SCTAB nDrawPages = 0;
     142             :         SCTAB nTab;
     143           0 :         for (nTab=0; nTab < static_cast<SCTAB>(maTabs.size()); nTab++)
     144           0 :             if (maTabs[nTab])
     145           0 :                 nDrawPages = nTab + 1;          // needed number of pages
     146             : 
     147           0 :         for (nTab=0; nTab<nDrawPages && nTab < static_cast<SCTAB>(maTabs.size()); nTab++)
     148             :         {
     149           0 :             pDrawLayer->ScAddPage( nTab );      // always add page, with or without the table
     150           0 :             if (maTabs[nTab])
     151             :             {
     152           0 :                 OUString aTabName;
     153           0 :                 maTabs[nTab]->GetName(aTabName);
     154           0 :                 pDrawLayer->ScRenamePage( nTab, aTabName );
     155             : 
     156           0 :                 maTabs[nTab]->SetDrawPageSize(false,false);     // set the right size immediately
     157             :             }
     158             :         }
     159             : 
     160           0 :         pDrawLayer->SetDefaultTabulator( GetDocOptions().GetTabDistance() );
     161             : 
     162           0 :         UpdateDrawPrinter();
     163             : 
     164             :         // set draw defaults directly
     165           0 :         SfxItemPool& rDrawPool = pDrawLayer->GetItemPool();
     166           0 :         rDrawPool.SetPoolDefaultItem( SvxAutoKernItem( true, EE_CHAR_PAIRKERNING ) );
     167             : 
     168           0 :         UpdateDrawLanguages();
     169           0 :         if (bImportingXML)
     170           0 :             pDrawLayer->EnableAdjust(false);
     171             : 
     172           0 :         pDrawLayer->SetForbiddenCharsTable( xForbiddenCharacters );
     173           0 :         pDrawLayer->SetCharCompressType( GetAsianCompression() );
     174           0 :         pDrawLayer->SetKernAsianPunctuation( GetAsianKerning() );
     175             :     }
     176           0 : }
     177             : 
     178           0 : void ScDocument::UpdateDrawLanguages()
     179             : {
     180           0 :     if (pDrawLayer)
     181             :     {
     182           0 :         SfxItemPool& rDrawPool = pDrawLayer->GetItemPool();
     183           0 :         rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eLanguage, EE_CHAR_LANGUAGE ) );
     184           0 :         rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eCjkLanguage, EE_CHAR_LANGUAGE_CJK ) );
     185           0 :         rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eCtlLanguage, EE_CHAR_LANGUAGE_CTL ) );
     186             :     }
     187           0 : }
     188             : 
     189           0 : void ScDocument::UpdateDrawPrinter()
     190             : {
     191           0 :     if (pDrawLayer)
     192             :     {
     193             :         // use the printer even if IsValid is false
     194             :         // Application::GetDefaultDevice causes trouble with changing MapModes
     195           0 :         pDrawLayer->SetRefDevice(GetRefDevice());
     196             :     }
     197           0 : }
     198             : 
     199           0 : void ScDocument::SetDrawPageSize(SCTAB nTab)
     200             : {
     201           0 :     if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
     202           0 :         return;
     203             : 
     204           0 :     maTabs[nTab]->SetDrawPageSize();
     205             : }
     206             : 
     207           0 : bool ScDocument::IsChart( const SdrObject* pObject )
     208             : {
     209             :     // #109985#
     210             :     // IsChart() implementation moved to svx drawinglayer
     211           0 :     if(pObject && OBJ_OLE2 == pObject->GetObjIdentifier())
     212             :     {
     213           0 :         return ((SdrOle2Obj*)pObject)->IsChart();
     214             :     }
     215             : 
     216           0 :     return false;
     217             : }
     218             : 
     219           0 : IMPL_LINK_INLINE_START( ScDocument, GetUserDefinedColor, sal_uInt16 *, pColorIndex )
     220             : {
     221           0 :     return (sal_IntPtr) &((GetColorList()->GetColor(*pColorIndex))->GetColor());
     222             : }
     223           0 : IMPL_LINK_INLINE_END( ScDocument, GetUserDefinedColor, sal_uInt16 *, pColorIndex )
     224             : 
     225           0 : void ScDocument::DeleteDrawLayer()
     226             : {
     227           0 :     delete pDrawLayer;
     228           0 : }
     229             : 
     230           0 : bool ScDocument::DrawGetPrintArea( ScRange& rRange, bool bSetHor, bool bSetVer ) const
     231             : {
     232           0 :     return pDrawLayer->GetPrintArea( rRange, bSetHor, bSetVer );
     233             : }
     234             : 
     235           0 : void ScDocument::DrawMovePage( sal_uInt16 nOldPos, sal_uInt16 nNewPos )
     236             : {
     237           0 :     pDrawLayer->ScMovePage(nOldPos,nNewPos);
     238           0 : }
     239             : 
     240           0 : void ScDocument::DrawCopyPage( sal_uInt16 nOldPos, sal_uInt16 nNewPos )
     241             : {
     242             :     // angelegt wird die Page schon im ScTable ctor
     243           0 :     pDrawLayer->ScCopyPage( nOldPos, nNewPos );
     244           0 : }
     245             : 
     246           0 : void ScDocument::DeleteObjectsInArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
     247             :                         const ScMarkData& rMark )
     248             : {
     249           0 :     if (!pDrawLayer)
     250           0 :         return;
     251             : 
     252           0 :     SCTAB nTabCount = GetTableCount();
     253           0 :     ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
     254           0 :     for (; itr != itrEnd && *itr < nTabCount; ++itr)
     255           0 :         if (maTabs[*itr])
     256           0 :             pDrawLayer->DeleteObjectsInArea( *itr, nCol1, nRow1, nCol2, nRow2 );
     257             : }
     258             : 
     259           0 : void ScDocument::DeleteObjectsInSelection( const ScMarkData& rMark )
     260             : {
     261           0 :     if (!pDrawLayer)
     262           0 :         return;
     263             : 
     264           0 :     pDrawLayer->DeleteObjectsInSelection( rMark );
     265             : }
     266             : 
     267           0 : bool ScDocument::HasOLEObjectsInArea( const ScRange& rRange, const ScMarkData* pTabMark )
     268             : {
     269             :     //  pTabMark is used only for selected tables. If pTabMark is 0, all tables of rRange are used.
     270             : 
     271           0 :     if (!pDrawLayer)
     272           0 :         return false;
     273             : 
     274           0 :     SCTAB nStartTab = 0;
     275           0 :     SCTAB nEndTab = static_cast<SCTAB>(maTabs.size());
     276           0 :     if ( !pTabMark )
     277             :     {
     278           0 :         nStartTab = rRange.aStart.Tab();
     279           0 :         nEndTab = rRange.aEnd.Tab();
     280             :     }
     281             : 
     282           0 :     for (SCTAB nTab = nStartTab; nTab <= nEndTab; nTab++)
     283             :     {
     284           0 :         if ( !pTabMark || pTabMark->GetTableSelect(nTab) )
     285             :         {
     286           0 :             Rectangle aMMRect = GetMMRect( rRange.aStart.Col(), rRange.aStart.Row(),
     287           0 :                                             rRange.aEnd.Col(), rRange.aEnd.Row(), nTab );
     288             : 
     289           0 :             SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
     290             :             OSL_ENSURE(pPage,"Page ?");
     291           0 :             if (pPage)
     292             :             {
     293           0 :                 SdrObjListIter aIter( *pPage, IM_FLAT );
     294           0 :                 SdrObject* pObject = aIter.Next();
     295           0 :                 while (pObject)
     296             :                 {
     297           0 :                     if ( pObject->GetObjIdentifier() == OBJ_OLE2 &&
     298           0 :                             aMMRect.IsInside( pObject->GetCurrentBoundRect() ) )
     299           0 :                         return true;
     300             : 
     301           0 :                     pObject = aIter.Next();
     302           0 :                 }
     303             :             }
     304             :         }
     305             :     }
     306             : 
     307           0 :     return false;
     308             : }
     309             : 
     310             : 
     311           0 : void ScDocument::StartAnimations( SCTAB nTab, Window* pWin )
     312             : {
     313           0 :     if (!pDrawLayer)
     314           0 :         return;
     315           0 :     SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
     316             :     OSL_ENSURE(pPage,"Page ?");
     317           0 :     if (!pPage)
     318           0 :         return;
     319             : 
     320           0 :     SdrObjListIter aIter( *pPage, IM_FLAT );
     321           0 :     SdrObject* pObject = aIter.Next();
     322           0 :     while (pObject)
     323             :     {
     324           0 :         if (pObject->ISA(SdrGrafObj))
     325             :         {
     326           0 :             SdrGrafObj* pGrafObj = (SdrGrafObj*)pObject;
     327           0 :             if ( pGrafObj->IsAnimated() )
     328             :             {
     329           0 :                 const Rectangle& rRect = pGrafObj->GetCurrentBoundRect();
     330           0 :                 pGrafObj->StartAnimation( pWin, rRect.TopLeft(), rRect.GetSize() );
     331             :             }
     332             :         }
     333           0 :         pObject = aIter.Next();
     334           0 :     }
     335             : }
     336             : 
     337             : 
     338           0 : bool ScDocument::HasBackgroundDraw( SCTAB nTab, const Rectangle& rMMRect ) const
     339             : {
     340             :     //  Gibt es Objekte auf dem Hintergrund-Layer, die (teilweise) von rMMRect
     341             :     //  betroffen sind?
     342             :     //  (fuer Drawing-Optimierung, vor dem Hintergrund braucht dann nicht geloescht
     343             :     //   zu werden)
     344             : 
     345           0 :     if (!pDrawLayer)
     346           0 :         return false;
     347           0 :     SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
     348             :     OSL_ENSURE(pPage,"Page ?");
     349           0 :     if (!pPage)
     350           0 :         return false;
     351             : 
     352           0 :     bool bFound = false;
     353             : 
     354           0 :     SdrObjListIter aIter( *pPage, IM_FLAT );
     355           0 :     SdrObject* pObject = aIter.Next();
     356           0 :     while (pObject && !bFound)
     357             :     {
     358           0 :         if ( pObject->GetLayer() == SC_LAYER_BACK && pObject->GetCurrentBoundRect().IsOver( rMMRect ) )
     359           0 :             bFound = true;
     360           0 :         pObject = aIter.Next();
     361             :     }
     362             : 
     363           0 :     return bFound;
     364             : }
     365             : 
     366           0 : bool ScDocument::HasAnyDraw( SCTAB nTab, const Rectangle& rMMRect ) const
     367             : {
     368             :     //  Gibt es ueberhaupt Objekte, die (teilweise) von rMMRect
     369             :     //  betroffen sind?
     370             :     //  (um leere Seiten beim Drucken zu erkennen)
     371             : 
     372           0 :     if (!pDrawLayer)
     373           0 :         return false;
     374           0 :     SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
     375             :     OSL_ENSURE(pPage,"Page ?");
     376           0 :     if (!pPage)
     377           0 :         return false;
     378             : 
     379           0 :     bool bFound = false;
     380             : 
     381           0 :     SdrObjListIter aIter( *pPage, IM_FLAT );
     382           0 :     SdrObject* pObject = aIter.Next();
     383           0 :     while (pObject && !bFound)
     384             :     {
     385           0 :         if ( pObject->GetCurrentBoundRect().IsOver( rMMRect ) )
     386           0 :             bFound = true;
     387           0 :         pObject = aIter.Next();
     388             :     }
     389             : 
     390           0 :     return bFound;
     391             : }
     392             : 
     393           0 : void ScDocument::EnsureGraphicNames()
     394             : {
     395           0 :     if (pDrawLayer)
     396           0 :         pDrawLayer->EnsureGraphicNames();
     397           0 : }
     398             : 
     399           0 : SdrObject* ScDocument::GetObjectAtPoint( SCTAB nTab, const Point& rPos )
     400             : {
     401             :     //  fuer Drag&Drop auf Zeichenobjekt
     402             : 
     403           0 :     SdrObject* pFound = NULL;
     404           0 :     if (pDrawLayer && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
     405             :     {
     406           0 :         SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
     407             :         OSL_ENSURE(pPage,"Page ?");
     408           0 :         if (pPage)
     409             :         {
     410           0 :             SdrObjListIter aIter( *pPage, IM_FLAT );
     411           0 :             SdrObject* pObject = aIter.Next();
     412           0 :             while (pObject)
     413             :             {
     414           0 :                 if ( pObject->GetCurrentBoundRect().IsInside(rPos) )
     415             :                 {
     416             :                     //  Intern interessiert gar nicht
     417             :                     //  Objekt vom Back-Layer nur, wenn kein Objekt von anderem Layer getroffen
     418             : 
     419           0 :                     SdrLayerID nLayer = pObject->GetLayer();
     420           0 :                     if ( (nLayer != SC_LAYER_INTERN) && (nLayer != SC_LAYER_HIDDEN) )
     421             :                     {
     422           0 :                         if ( nLayer != SC_LAYER_BACK ||
     423           0 :                                 !pFound || pFound->GetLayer() == SC_LAYER_BACK )
     424             :                         {
     425           0 :                             pFound = pObject;
     426             :                         }
     427             :                     }
     428             :                 }
     429             :                 //  weitersuchen -> letztes (oberstes) getroffenes Objekt nehmen
     430             : 
     431           0 :                 pObject = aIter.Next();
     432           0 :             }
     433             :         }
     434             :     }
     435           0 :     return pFound;
     436             : }
     437             : 
     438           0 : bool ScDocument::IsPrintEmpty( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
     439             :                                 SCCOL nEndCol, SCROW nEndRow, bool bLeftIsEmpty,
     440             :                                 ScRange* pLastRange, Rectangle* pLastMM ) const
     441             : {
     442           0 :     if (!IsBlockEmpty( nTab, nStartCol, nStartRow, nEndCol, nEndRow ))
     443           0 :         return false;
     444             : 
     445           0 :     if (HasAttrib(ScRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab), HASATTR_LINES))
     446             :         // We want to print sheets with borders even if there is no cell content.
     447           0 :         return false;
     448             : 
     449           0 :     Rectangle aMMRect;
     450           0 :     if ( pLastRange && pLastMM && nTab == pLastRange->aStart.Tab() &&
     451           0 :             nStartRow == pLastRange->aStart.Row() && nEndRow == pLastRange->aEnd.Row() )
     452             :     {
     453             :         //  keep vertical part of aMMRect, only update horizontal position
     454           0 :         aMMRect = *pLastMM;
     455             : 
     456           0 :         long nLeft = 0;
     457             :         SCCOL i;
     458           0 :         for (i=0; i<nStartCol; i++)
     459           0 :             nLeft += GetColWidth(i,nTab);
     460           0 :         long nRight = nLeft;
     461           0 :         for (i=nStartCol; i<=nEndCol; i++)
     462           0 :             nRight += GetColWidth(i,nTab);
     463             : 
     464           0 :         aMMRect.Left()  = (long)(nLeft  * HMM_PER_TWIPS);
     465           0 :         aMMRect.Right() = (long)(nRight * HMM_PER_TWIPS);
     466             :     }
     467             :     else
     468           0 :         aMMRect = GetMMRect( nStartCol, nStartRow, nEndCol, nEndRow, nTab );
     469             : 
     470           0 :     if ( pLastRange && pLastMM )
     471             :     {
     472           0 :         *pLastRange = ScRange( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab );
     473           0 :         *pLastMM = aMMRect;
     474             :     }
     475             : 
     476           0 :     if ( HasAnyDraw( nTab, aMMRect ))
     477           0 :         return false;
     478             : 
     479           0 :     if ( nStartCol > 0 && !bLeftIsEmpty )
     480             :     {
     481             :         //  aehnlich wie in ScPrintFunc::AdjustPrintArea
     482             :         //! ExtendPrintArea erst ab Start-Spalte des Druckbereichs
     483             : 
     484           0 :         SCCOL nExtendCol = nStartCol - 1;
     485           0 :         SCROW nTmpRow = nEndRow;
     486             : 
     487             :         // ExtendMerge() is non-const, but called without refresh. GetPrinter()
     488             :         // might create and assign a printer.
     489           0 :         ScDocument* pThis = const_cast<ScDocument*>(this);
     490             : 
     491             :         pThis->ExtendMerge( 0,nStartRow, nExtendCol,nTmpRow, nTab,
     492           0 :                             false );      // kein Refresh, incl. Attrs
     493             : 
     494           0 :         OutputDevice* pDev = pThis->GetPrinter();
     495           0 :         pDev->SetMapMode( MAP_PIXEL );              // wichtig fuer GetNeededSize
     496           0 :         ExtendPrintArea( pDev, nTab, 0, nStartRow, nExtendCol, nEndRow );
     497           0 :         if ( nExtendCol >= nStartCol )
     498           0 :             return false;
     499             :     }
     500             : 
     501           0 :     return true;
     502             : }
     503             : 
     504           0 : void ScDocument::Clear( bool bFromDestructor )
     505             : {
     506           0 :     TableContainer::iterator it = maTabs.begin();
     507           0 :     for (;it != maTabs.end(); ++it)
     508           0 :         delete *it;
     509           0 :     maTabs.clear();
     510           0 :     delete pSelectionAttr;
     511           0 :     pSelectionAttr = NULL;
     512             : 
     513           0 :     if (pDrawLayer)
     514             :     {
     515           0 :         pDrawLayer->ClearModel( bFromDestructor );
     516             :     }
     517           0 : }
     518             : 
     519           0 : bool ScDocument::HasDetectiveObjects(SCTAB nTab) const
     520             : {
     521             :     //  looks for detective objects, annotations don't count
     522             :     //  (used to adjust scale so detective objects hit their cells better)
     523             : 
     524           0 :     bool bFound = false;
     525             : 
     526           0 :     if (pDrawLayer)
     527             :     {
     528           0 :         SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
     529             :         OSL_ENSURE(pPage,"Page ?");
     530           0 :         if (pPage)
     531             :         {
     532           0 :             SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
     533           0 :             SdrObject* pObject = aIter.Next();
     534           0 :             while (pObject && !bFound)
     535             :             {
     536             :                 // anything on the internal layer except captions (annotations)
     537           0 :                 if ( (pObject->GetLayer() == SC_LAYER_INTERN) && !ScDrawLayer::IsNoteCaption( pObject ) )
     538           0 :                     bFound = true;
     539             : 
     540           0 :                 pObject = aIter.Next();
     541           0 :             }
     542             :         }
     543             :     }
     544             : 
     545           0 :     return bFound;
     546             : }
     547             : 
     548           0 : void ScDocument::UpdateFontCharSet()
     549             : {
     550             :     //  In alten Versionen (bis incl. 4.0 ohne SP) wurden beim Austausch zwischen
     551             :     //  Systemen die CharSets in den Font-Attributen nicht angepasst.
     552             :     //  Das muss fuer Dokumente bis incl SP2 nun nachgeholt werden:
     553             :     //  Alles, was nicht SYMBOL ist, wird auf den System-CharSet umgesetzt.
     554             :     //  Bei neuen Dokumenten (Version SC_FONTCHARSET) sollte der CharSet stimmen.
     555             : 
     556           0 :     bool bUpdateOld = ( nSrcVer < SC_FONTCHARSET );
     557             : 
     558           0 :     rtl_TextEncoding eSysSet = osl_getThreadTextEncoding();
     559           0 :     if ( eSrcSet != eSysSet || bUpdateOld )
     560             :     {
     561             :         sal_uInt32 nCount,i;
     562             :         SvxFontItem* pItem;
     563             : 
     564           0 :         ScDocumentPool* pPool = xPoolHelper->GetDocPool();
     565           0 :         nCount = pPool->GetItemCount2(ATTR_FONT);
     566           0 :         for (i=0; i<nCount; i++)
     567             :         {
     568           0 :             pItem = (SvxFontItem*)pPool->GetItem2(ATTR_FONT, i);
     569           0 :             if ( pItem && ( pItem->GetCharSet() == eSrcSet ||
     570           0 :                             ( bUpdateOld && pItem->GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) )
     571           0 :                 pItem->SetCharSet(eSysSet);
     572             :         }
     573             : 
     574           0 :         if ( pDrawLayer )
     575             :         {
     576           0 :             SfxItemPool& rDrawPool = pDrawLayer->GetItemPool();
     577           0 :             nCount = rDrawPool.GetItemCount2(EE_CHAR_FONTINFO);
     578           0 :             for (i=0; i<nCount; i++)
     579             :             {
     580           0 :                 pItem = (SvxFontItem*)rDrawPool.GetItem2(EE_CHAR_FONTINFO, i);
     581           0 :                 if ( pItem && ( pItem->GetCharSet() == eSrcSet ||
     582           0 :                                 ( bUpdateOld && pItem->GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) )
     583           0 :                     pItem->SetCharSet( eSysSet );
     584             :             }
     585             :         }
     586             :     }
     587           0 : }
     588             : 
     589           0 : void ScDocument::SetLoadingMedium( bool bVal )
     590             : {
     591           0 :     bLoadingMedium = bVal;
     592           0 :     TableContainer::iterator it = maTabs.begin();
     593           0 :     for (; it != maTabs.end(); ++it)
     594             :     {
     595           0 :         if (!*it)
     596           0 :             return;
     597             : 
     598           0 :         (*it)->SetLoadingMedium(bVal);
     599             :     }
     600             : }
     601             : 
     602           0 : void ScDocument::SetImportingXML( bool bVal )
     603             : {
     604           0 :     bImportingXML = bVal;
     605           0 :     if (pDrawLayer)
     606           0 :         pDrawLayer->EnableAdjust(!bImportingXML);
     607             : 
     608           0 :     if ( !bVal )
     609             :     {
     610             :         // #i57869# after loading, do the real RTL mirroring for the sheets that have the LoadingRTL flag set
     611             : 
     612           0 :         for ( SCTAB nTab=0; nTab< static_cast<SCTAB>(maTabs.size()) && maTabs[nTab]; nTab++ )
     613           0 :             if ( maTabs[nTab]->IsLoadingRTL() )
     614             :             {
     615           0 :                 maTabs[nTab]->SetLoadingRTL( false );
     616           0 :                 SetLayoutRTL( nTab, true );             // includes mirroring; bImportingXML must be cleared first
     617             :             }
     618             :     }
     619             : 
     620           0 :     SetLoadingMedium(bVal);
     621           0 : }
     622             : 
     623           0 : void ScDocument::SetXMLFromWrapper( bool bVal )
     624             : {
     625           0 :     bXMLFromWrapper = bVal;
     626           0 : }
     627             : 
     628           0 : rtl::Reference<SvxForbiddenCharactersTable> ScDocument::GetForbiddenCharacters()
     629             : {
     630           0 :     return xForbiddenCharacters;
     631             : }
     632             : 
     633           0 : void ScDocument::SetForbiddenCharacters( const rtl::Reference<SvxForbiddenCharactersTable> xNew )
     634             : {
     635           0 :     xForbiddenCharacters = xNew;
     636           0 :     if ( pEditEngine )
     637           0 :         pEditEngine->SetForbiddenCharsTable( xForbiddenCharacters );
     638           0 :     if ( pDrawLayer )
     639           0 :         pDrawLayer->SetForbiddenCharsTable( xForbiddenCharacters );
     640           0 : }
     641             : 
     642           0 : bool ScDocument::IsValidAsianCompression() const
     643             : {
     644           0 :     return ( nAsianCompression != SC_ASIANCOMPRESSION_INVALID );
     645             : }
     646             : 
     647           0 : sal_uInt8 ScDocument::GetAsianCompression() const
     648             : {
     649           0 :     if ( nAsianCompression == SC_ASIANCOMPRESSION_INVALID )
     650           0 :         return 0;
     651             :     else
     652           0 :         return nAsianCompression;
     653             : }
     654             : 
     655           0 : void ScDocument::SetAsianCompression(sal_uInt8 nNew)
     656             : {
     657           0 :     nAsianCompression = nNew;
     658           0 :     if ( pEditEngine )
     659           0 :         pEditEngine->SetAsianCompressionMode( nAsianCompression );
     660           0 :     if ( pDrawLayer )
     661           0 :         pDrawLayer->SetCharCompressType( nAsianCompression );
     662           0 : }
     663             : 
     664           0 : bool ScDocument::IsValidAsianKerning() const
     665             : {
     666           0 :     return ( nAsianKerning != SC_ASIANKERNING_INVALID );
     667             : }
     668             : 
     669           0 : bool ScDocument::GetAsianKerning() const
     670             : {
     671           0 :     if ( nAsianKerning == SC_ASIANKERNING_INVALID )
     672           0 :         return false;
     673             :     else
     674           0 :         return static_cast<bool>(nAsianKerning);
     675             : }
     676             : 
     677           0 : void ScDocument::SetAsianKerning(bool bNew)
     678             : {
     679           0 :     nAsianKerning = (sal_uInt8)bNew;
     680           0 :     if ( pEditEngine )
     681           0 :         pEditEngine->SetKernAsianPunctuation( static_cast<bool>( nAsianKerning ) );
     682           0 :     if ( pDrawLayer )
     683           0 :         pDrawLayer->SetKernAsianPunctuation( static_cast<bool>( nAsianKerning ) );
     684           0 : }
     685             : 
     686           0 : void ScDocument::ApplyAsianEditSettings( ScEditEngineDefaulter& rEngine )
     687             : {
     688           0 :     rEngine.SetForbiddenCharsTable( xForbiddenCharacters );
     689           0 :     rEngine.SetAsianCompressionMode( GetAsianCompression() );
     690           0 :     rEngine.SetKernAsianPunctuation( GetAsianKerning() );
     691           0 : }
     692             : 
     693             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10