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

Generated by: LCOV version 1.10