sc/source/core/data/documen9.cxx

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