sc/source/core/data/documen9.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: documen9.cxx,v $
  10  * $Revision: 1.43.52.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  35 #include <com/sun/star/embed/XClassifiedObject.hpp>
  36 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
  37
  38 // INCLUDE ---------------------------------------------------------------
  39
  40 #include "scitems.hxx"
  41 #include <svx/eeitem.hxx>
  42
  43 #include <sot/exchange.hxx>
  44 #include <svx/akrnitem.hxx>
  45 #include <svx/fontitem.hxx>
  46 #include <svx/forbiddencharacterstable.hxx>
  47 #include <svx/langitem.hxx>
  48 #include <svx/svdetc.hxx>
  49 #include <svx/svditer.hxx>
  50 #include <svx/svdocapt.hxx>
  51 #include <svx/svdograf.hxx>
  52 #include <svx/svdoole2.hxx>
  53 #include <svx/svdouno.hxx>
  54 #include <svx/svdpage.hxx>
  55 #include <svx/svdundo.hxx>
  56 #include <svx/xtable.hxx>
  57 #include <sfx2/objsh.hxx>
  58 #include <sfx2/printer.hxx>
  59 #include <svtools/saveopt.hxx>
  60 #include <svtools/pathoptions.hxx>
  61
  62 #include "document.hxx"
  63 #include "docoptio.hxx"
  64 #include "table.hxx"
  65 #include "drwlayer.hxx"
  66 #include "markdata.hxx"
  67 #include "patattr.hxx"
  68 #include "rechead.hxx"
  69 #include "poolhelp.hxx"
  70 #include "docpool.hxx"
  71 #include "chartarr.hxx"
  72 #include "detfunc.hxx"          // for UpdateAllComments
  73 #include "editutil.hxx"
  74 #include "postit.hxx"
  75
  76 using namespace ::com::sun::star;
  77
  78 // -----------------------------------------------------------------------
  79
  80
  81 SfxBroadcaster* ScDocument::GetDrawBroadcaster()
  82 {
  83     return pDrawLayer;
  84 }
  85
  86 void ScDocument::BeginDrawUndo()
  87 {
  88     if (pDrawLayer)
  89         pDrawLayer->BeginCalcUndo();
  90 }
  91
  92 XColorTable* ScDocument::GetColorTable()
  93 {
  94     if (pDrawLayer)
  95         return pDrawLayer->GetColorTable();
  96     else
  97     {
  98         if (!pColorTable)
  99         {
 100             SvtPathOptions aPathOpt;
 101             pColorTable = new XColorTable( aPathOpt.GetPalettePath() );
 102         }
 103
 104         return pColorTable;
 105     }
 106 }
 107
 108 BOOL lcl_AdjustRanges( ScRangeList& rRanges, SCTAB nSource, SCTAB nDest, SCTAB nTabCount )
 109 {
 110     //! if multiple sheets are copied, update references into the other copied sheets?
 111
 112     BOOL bChanged = FALSE;
 113
 114     ULONG nCount = rRanges.Count();
 115     for (ULONG i=0; i<nCount; i++)
 116     {
 117         ScRange* pRange = rRanges.GetObject(i);
 118         if ( pRange->aStart.Tab() == nSource && pRange->aEnd.Tab() == nSource )
 119         {
 120             pRange->aStart.SetTab( nDest );
 121             pRange->aEnd.SetTab( nDest );
 122             bChanged = TRUE;
 123         }
 124         if ( pRange->aStart.Tab() >= nTabCount )
 125         {
 126             pRange->aStart.SetTab( nTabCount > 0 ? ( nTabCount - 1 ) : 0 );
 127             bChanged = TRUE;
 128         }
 129         if ( pRange->aEnd.Tab() >= nTabCount )
 130         {
 131             pRange->aEnd.SetTab( nTabCount > 0 ? ( nTabCount - 1 ) : 0 );
 132             bChanged = TRUE;
 133         }
 134     }
 135
 136     return bChanged;
 137 }
 138
 139 void ScDocument::TransferDrawPage(ScDocument* pSrcDoc, SCTAB nSrcPos, SCTAB nDestPos)
 140 {
 141     if (pDrawLayer && pSrcDoc->pDrawLayer)
 142     {
 143         SdrPage* pOldPage = pSrcDoc->pDrawLayer->GetPage(static_cast<sal_uInt16>(nSrcPos));
 144         SdrPage* pNewPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nDestPos));
 145
 146         if (pOldPage && pNewPage)
 147         {
 148             SdrObjListIter aIter( *pOldPage, IM_FLAT );
 149             SdrObject* pOldObject = aIter.Next();
 150             while (pOldObject)
 151             {
 152                 // #116235#
 153                 SdrObject* pNewObject = pOldObject->Clone();
 154                 // SdrObject* pNewObject = pOldObject->Clone( pNewPage, pDrawLayer );
 155                 pNewObject->SetModel(pDrawLayer);
 156                 pNewObject->SetPage(pNewPage);
 157
 158                 pNewObject->NbcMove(Size(0,0));
 159                 pNewPage->InsertObject( pNewObject );
 160
 161                 if (pDrawLayer->IsRecording())
 162                     pDrawLayer->AddCalcUndo( new SdrUndoInsertObj( *pNewObject ) );
 163
 164                 //      #71726# if it's a chart, make sure the data references are valid
 165                 //      (this must be after InsertObject!)
 166
 167                 if ( pNewObject->GetObjIdentifier() == OBJ_OLE2 )
 168                 {
 169                     uno::Reference< embed::XEmbeddedObject > xIPObj = ((SdrOle2Obj*)pNewObject)->GetObjRef();
 170                     uno::Reference< embed::XClassifiedObject > xClassified( xIPObj, uno::UNO_QUERY );
 171                     SvGlobalName aObjectClassName;
 172                     if ( xClassified.is() )
 173                     {
 174                         try {
 175                             aObjectClassName = SvGlobalName( xClassified->getClassID() );
 176                         } catch( uno::Exception& )
 177                         {
 178                             // TODO: handle error?
 179                         }
 180                     }
 181
 182                     if ( xIPObj.is() && SotExchange::IsChart( aObjectClassName ) )
 183                     {
 184                         String aChartName = ((SdrOle2Obj*)pNewObject)->GetPersistName();
 185
 186                         uno::Reference< chart2::XChartDocument > xChartDoc( GetChartByName( aChartName ) );
 187                         uno::Reference< chart2::data::XDataReceiver > xReceiver( xChartDoc, uno::UNO_QUERY );
 188                         if( xChartDoc.is() && xReceiver.is() )
 189                         {
 190                             if( !xChartDoc->hasInternalDataProvider() )
 191                             {
 192                                 ::std::vector< ScRangeList > aRangesVector;
 193                                 GetChartRanges( aChartName, aRangesVector, pSrcDoc );
 194
 195                                 ::std::vector< ScRangeList >::iterator aIt( aRangesVector.begin() );
 196                                 for( ; aIt!=aRangesVector.end(); aIt++ )
 197                                 {
 198                                     ScRangeList& rScRangeList( *aIt );
 199                                     lcl_AdjustRanges( rScRangeList, nSrcPos, nDestPos, GetTableCount() );
 200                                 }
 201                                 SetChartRanges( aChartName, aRangesVector );
 202                             }
 203                         }
 204                     }
 205                 }
 206
 207                 pOldObject = aIter.Next();
 208             }
 209         }
 210     }
 211 }
 212
 213 void ScDocument::InitDrawLayer( SfxObjectShell* pDocShell )
 214 {
 215     if (pDocShell && !pShell)
 216         pShell = pDocShell;
 217
 218 //      DBG_ASSERT(pShell,"InitDrawLayer ohne Shell");
 219
 220     if (!pDrawLayer)
 221     {
 222         String aName;
 223         if ( pShell && !pShell->IsLoading() )           // #88438# don't call GetTitle while loading
 224             aName = pShell->GetTitle();
 225         pDrawLayer = new ScDrawLayer( this, aName );
 226         if (GetLinkManager())
 227             pDrawLayer->SetLinkManager( pLinkManager );
 228
 229         //      Drawing pages are accessed by table number, so they must also be present
 230         //      for preceding table numbers, even if the tables aren't allocated
 231         //      (important for clipboard documents).
 232
 233         SCTAB nDrawPages = 0;
 234         SCTAB nTab;
 235         for (nTab=0; nTab<=MAXTAB; nTab++)
 236             if (pTab[nTab])
 237                 nDrawPages = nTab + 1;                  // needed number of pages
 238
 239         for (nTab=0; nTab<nDrawPages; nTab++)
 240         {
 241             pDrawLayer->ScAddPage( nTab );              // always add page, with or without the table
 242             if (pTab[nTab])
 243             {
 244                 String aTabName;
 245                 pTab[nTab]->GetName(aTabName);
 246                 pDrawLayer->ScRenamePage( nTab, aTabName );
 247
 248                 pTab[nTab]->SetDrawPageSize(false);     // #54782# set the right size immediately
 249 #if 0
 250                 ULONG nx = (ULONG) ((double) (MAXCOL+1) * STD_COL_WIDTH                   * HMM_PER_TWIPS );
 251                 ULONG ny = (ULONG) ((double) (MAXROW+1) * ScGlobal::nStdRowHeight * HMM_PER_TWIPS );
 252                 pDrawLayer->SetPageSize( nTab, Size( nx, ny ) );
 253 #endif
 254             }
 255         }
 256
 257         pDrawLayer->SetDefaultTabulator( GetDocOptions().GetTabDistance() );
 258
 259         UpdateDrawPrinter();
 260         UpdateDrawDefaults();
 261         UpdateDrawLanguages();
 262         if (bImportingXML)
 263             pDrawLayer->EnableAdjust(FALSE);
 264
 265         pDrawLayer->SetForbiddenCharsTable( xForbiddenCharacters );
 266         pDrawLayer->SetCharCompressType( GetAsianCompression() );
 267         pDrawLayer->SetKernAsianPunctuation( GetAsianKerning() );
 268     }
 269 }
 270
 271 void ScDocument::UpdateDrawLanguages()
 272 {
 273     if (pDrawLayer)
 274     {
 275         SfxItemPool& rDrawPool = pDrawLayer->GetItemPool();
 276         rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eLanguage, EE_CHAR_LANGUAGE ) );
 277         rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eCjkLanguage, EE_CHAR_LANGUAGE_CJK ) );
 278         rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eCtlLanguage, EE_CHAR_LANGUAGE_CTL ) );
 279     }
 280 }
 281
 282 void ScDocument::UpdateDrawDefaults()
 283 {
 284     // drawing layer defaults that are set for new documents (if InitNew was called)
 285
 286     if ( pDrawLayer && bSetDrawDefaults )
 287     {
 288         SfxItemPool& rDrawPool = pDrawLayer->GetItemPool();
 289         rDrawPool.SetPoolDefaultItem( SvxAutoKernItem( TRUE, EE_CHAR_PAIRKERNING ) );
 290     }
 291 }
 292
 293 void ScDocument::UpdateDrawPrinter()
 294 {
 295     if (pDrawLayer)
 296     {
 297         // use the printer even if IsValid is false
 298         // Application::GetDefaultDevice causes trouble with changing MapModes
 299
 300 //              OutputDevice* pRefDev = GetPrinter();
 301 //              pRefDev->SetMapMode( MAP_100TH_MM );
 302         pDrawLayer->SetRefDevice(GetRefDevice());
 303     }
 304 }
 305
 306 sal_Bool ScDocument::IsChart( const SdrObject* pObject )
 307 {
 308     // #109985#
 309     // IsChart() implementation moved to svx drawinglayer
 310     if(pObject && OBJ_OLE2 == pObject->GetObjIdentifier())
 311     {
 312         return ((SdrOle2Obj*)pObject)->IsChart();
 313     }
 314
 315     return sal_False;
 316 }
 317
 318 IMPL_LINK_INLINE_START( ScDocument, GetUserDefinedColor, USHORT *, pColorIndex )
 319 {
 320     return (long) &((GetColorTable()->GetColor(*pColorIndex))->GetColor());
 321 }
 322 IMPL_LINK_INLINE_END( ScDocument, GetUserDefinedColor, USHORT *, pColorIndex )
 323
 324 void ScDocument::DeleteDrawLayer()
 325 {
 326     delete pDrawLayer;
 327 }
 328
 329 void ScDocument::DeleteColorTable()
 330 {
 331     delete pColorTable;
 332 }
 333
 334 BOOL ScDocument::DrawGetPrintArea( ScRange& rRange, BOOL bSetHor, BOOL bSetVer ) const
 335 {
 336     return pDrawLayer->GetPrintArea( rRange, bSetHor, bSetVer );
 337 }
 338
 339 void ScDocument::DrawMovePage( USHORT nOldPos, USHORT nNewPos )
 340 {
 341     pDrawLayer->ScMovePage(nOldPos,nNewPos);
 342 }
 343
 344 void ScDocument::DrawCopyPage( USHORT nOldPos, USHORT nNewPos )
 345 {
 346     // angelegt wird die Page schon im ScTable ctor
 347     pDrawLayer->ScCopyPage( nOldPos, nNewPos, FALSE );
 348 }
 349
 350 void ScDocument::DeleteObjectsInArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
 351                         const ScMarkData& rMark )
 352 {
 353     if (!pDrawLayer)
 354         return;
 355
 356     SCTAB nTabCount = GetTableCount();
 357     for (SCTAB nTab=0; nTab<=nTabCount; nTab++)
 358         if (pTab[nTab] && rMark.GetTableSelect(nTab))
 359             pDrawLayer->DeleteObjectsInArea( nTab, nCol1, nRow1, nCol2, nRow2 );
 360 }
 361
 362 void ScDocument::DeleteObjectsInSelection( const ScMarkData& rMark )
 363 {
 364     if (!pDrawLayer)
 365         return;
 366
 367     pDrawLayer->DeleteObjectsInSelection( rMark );
 368 }
 369
 370 BOOL ScDocument::HasOLEObjectsInArea( const ScRange& rRange, const ScMarkData* pTabMark )
 371 {
 372     //  pTabMark is used only for selected tables. If pTabMark is 0, all tables of rRange are used.
 373
 374     if (!pDrawLayer)
 375         return FALSE;
 376
 377     SCTAB nStartTab = 0;
 378     SCTAB nEndTab = MAXTAB;
 379     if ( !pTabMark )
 380     {
 381         nStartTab = rRange.aStart.Tab();
 382         nEndTab = rRange.aEnd.Tab();
 383     }
 384
 385     for (SCTAB nTab = nStartTab; nTab <= nEndTab; nTab++)
 386     {
 387         if ( !pTabMark || pTabMark->GetTableSelect(nTab) )
 388         {
 389             Rectangle aMMRect = GetMMRect( rRange.aStart.Col(), rRange.aStart.Row(),
 390                                             rRange.aEnd.Col(), rRange.aEnd.Row(), nTab );
 391
 392             SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 393             DBG_ASSERT(pPage,"Page ?");
 394             if (pPage)
 395             {
 396                 SdrObjListIter aIter( *pPage, IM_FLAT );
 397                 SdrObject* pObject = aIter.Next();
 398                 while (pObject)
 399                 {
 400                     if ( pObject->GetObjIdentifier() == OBJ_OLE2 &&
 401                             aMMRect.IsInside( pObject->GetCurrentBoundRect() ) )
 402                         return TRUE;
 403
 404                     pObject = aIter.Next();
 405                 }
 406             }
 407         }
 408     }
 409
 410     return FALSE;
 411 }
 412
 413
 414 void ScDocument::StartAnimations( SCTAB nTab, Window* pWin )
 415 {
 416     if (!pDrawLayer)
 417         return;
 418     SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 419     DBG_ASSERT(pPage,"Page ?");
 420     if (!pPage)
 421         return;
 422
 423     SdrObjListIter aIter( *pPage, IM_FLAT );
 424     SdrObject* pObject = aIter.Next();
 425     while (pObject)
 426     {
 427         if (pObject->ISA(SdrGrafObj))
 428         {
 429             SdrGrafObj* pGrafObj = (SdrGrafObj*)pObject;
 430             if ( pGrafObj->IsAnimated() )
 431             {
 432                 const Rectangle& rRect = pGrafObj->GetCurrentBoundRect();
 433                 pGrafObj->StartAnimation( pWin, rRect.TopLeft(), rRect.GetSize() );
 434             }
 435         }
 436         pObject = aIter.Next();
 437     }
 438 }
 439
 440 //UNUSED2008-05  void ScDocument::RefreshNoteFlags()
 441 //UNUSED2008-05  {
 442 //UNUSED2008-05      if (!pDrawLayer)
 443 //UNUSED2008-05          return;
 444 //UNUSED2008-05
 445 //UNUSED2008-05      BOOL bAnyIntObj = FALSE;
 446 //UNUSED2008-05      SCTAB nTab;
 447 //UNUSED2008-05      ScPostIt aNote(this);
 448 //UNUSED2008-05      for (nTab=0; nTab<=MAXTAB && pTab[nTab]; nTab++)
 449 //UNUSED2008-05      {
 450 //UNUSED2008-05          SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 451 //UNUSED2008-05          DBG_ASSERT(pPage,"Page ?");
 452 //UNUSED2008-05          if (pPage)
 453 //UNUSED2008-05          {
 454 //UNUSED2008-05              SdrObjListIter aIter( *pPage, IM_FLAT );
 455 //UNUSED2008-05              SdrObject* pObject = aIter.Next();
 456 //UNUSED2008-05              while (pObject)
 457 //UNUSED2008-05              {
 458 //UNUSED2008-05                  if ( pObject->GetLayer() == SC_LAYER_INTERN )
 459 //UNUSED2008-05                  {
 460 //UNUSED2008-05                      bAnyIntObj = TRUE;  // for all internal objects, including detective
 461 //UNUSED2008-05
 462 //UNUSED2008-05                      if ( pObject->ISA( SdrCaptionObj ) )
 463 //UNUSED2008-05                      {
 464 //UNUSED2008-05                          ScDrawObjData* pData = ScDrawLayer::GetObjData( pObject );
 465 //UNUSED2008-05                          if ( pData )
 466 //UNUSED2008-05                          {
 467 //UNUSED2008-05                              if ( GetNote( pData->aStt.Col(), pData->aStt.Row(), nTab, aNote))
 468 //UNUSED2008-05                                  if ( !aNote.IsShown() )
 469 //UNUSED2008-05                                  {
 470 //UNUSED2008-05                                      aNote.SetShown(TRUE);
 471 //UNUSED2008-05                                      SetNote( pData->aStt.Col(), pData->aStt.Row(), nTab, aNote);
 472 //UNUSED2008-05                                  }
 473 //UNUSED2008-05                          }
 474 //UNUSED2008-05                      }
 475 //UNUSED2008-05                  }
 476 //UNUSED2008-05                  pObject = aIter.Next();
 477 //UNUSED2008-05              }
 478 //UNUSED2008-05          }
 479 //UNUSED2008-05      }
 480 //UNUSED2008-05
 481 //UNUSED2008-05      if (bAnyIntObj)
 482 //UNUSED2008-05      {
 483 //UNUSED2008-05          //  update attributes for all note objects and the colors of detective objects
 484 //UNUSED2008-05          //  (we don't know with which settings the file was created)
 485 //UNUSED2008-05
 486 //UNUSED2008-05          ScDetectiveFunc aFunc( this, 0 );
 487 //UNUSED2008-05          aFunc.UpdateAllComments();
 488 //UNUSED2008-05          aFunc.UpdateAllArrowColors();
 489 //UNUSED2008-05      }
 490 //UNUSED2008-05  }
 491
 492 BOOL ScDocument::HasBackgroundDraw( SCTAB nTab, const Rectangle& rMMRect )
 493 {
 494     //  Gibt es Objekte auf dem Hintergrund-Layer, die (teilweise) von rMMRect
 495     //  betroffen sind?
 496     //  (fuer Drawing-Optimierung, vor dem Hintergrund braucht dann nicht geloescht
 497     //   zu werden)
 498
 499     if (!pDrawLayer)
 500         return FALSE;
 501     SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 502     DBG_ASSERT(pPage,"Page ?");
 503     if (!pPage)
 504         return FALSE;
 505
 506     BOOL bFound = FALSE;
 507
 508     SdrObjListIter aIter( *pPage, IM_FLAT );
 509     SdrObject* pObject = aIter.Next();
 510     while (pObject && !bFound)
 511     {
 512         if ( pObject->GetLayer() == SC_LAYER_BACK && pObject->GetCurrentBoundRect().IsOver( rMMRect ) )
 513             bFound = TRUE;
 514         pObject = aIter.Next();
 515     }
 516
 517     return bFound;
 518 }
 519
 520 BOOL ScDocument::HasAnyDraw( SCTAB nTab, const Rectangle& rMMRect )
 521 {
 522     //  Gibt es ueberhaupt Objekte, die (teilweise) von rMMRect
 523     //  betroffen sind?
 524     //  (um leere Seiten beim Drucken zu erkennen)
 525
 526     if (!pDrawLayer)
 527         return FALSE;
 528     SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 529     DBG_ASSERT(pPage,"Page ?");
 530     if (!pPage)
 531         return FALSE;
 532
 533     BOOL bFound = FALSE;
 534
 535     SdrObjListIter aIter( *pPage, IM_FLAT );
 536     SdrObject* pObject = aIter.Next();
 537     while (pObject && !bFound)
 538     {
 539         if ( pObject->GetCurrentBoundRect().IsOver( rMMRect ) )
 540             bFound = TRUE;
 541         pObject = aIter.Next();
 542     }
 543
 544     return bFound;
 545 }
 546
 547 void ScDocument::EnsureGraphicNames()
 548 {
 549     if (pDrawLayer)
 550         pDrawLayer->EnsureGraphicNames();
 551 }
 552
 553 SdrObject* ScDocument::GetObjectAtPoint( SCTAB nTab, const Point& rPos )
 554 {
 555     //  fuer Drag&Drop auf Zeichenobjekt
 556
 557     SdrObject* pFound = NULL;
 558     if (pDrawLayer && pTab[nTab])
 559     {
 560         SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 561         DBG_ASSERT(pPage,"Page ?");
 562         if (pPage)
 563         {
 564             SdrObjListIter aIter( *pPage, IM_FLAT );
 565             SdrObject* pObject = aIter.Next();
 566             while (pObject)
 567             {
 568                 if ( pObject->GetCurrentBoundRect().IsInside(rPos) )
 569                 {
 570                     //  Intern interessiert gar nicht
 571                     //  Objekt vom Back-Layer nur, wenn kein Objekt von anderem Layer getroffen
 572
 573                     SdrLayerID nLayer = pObject->GetLayer();
 574                     if ( (nLayer != SC_LAYER_INTERN) && (nLayer != SC_LAYER_HIDDEN) )
 575                     {
 576                         if ( nLayer != SC_LAYER_BACK ||
 577                                 !pFound || pFound->GetLayer() == SC_LAYER_BACK )
 578                         {
 579                             pFound = pObject;
 580                         }
 581                     }
 582                 }
 583                 //      weitersuchen -> letztes (oberstes) getroffenes Objekt nehmen
 584
 585                 pObject = aIter.Next();
 586             }
 587         }
 588     }
 589     return pFound;
 590 }
 591
 592 BOOL ScDocument::IsPrintEmpty( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
 593                                 SCCOL nEndCol, SCROW nEndRow, BOOL bLeftIsEmpty,
 594                                 ScRange* pLastRange, Rectangle* pLastMM ) const
 595 {
 596     if (!IsBlockEmpty( nTab, nStartCol, nStartRow, nEndCol, nEndRow ))
 597         return FALSE;
 598
 599     ScDocument* pThis = (ScDocument*)this;      //! GetMMRect / HasAnyDraw etc. const !!!
 600
 601     Rectangle aMMRect;
 602     if ( pLastRange && pLastMM && nTab == pLastRange->aStart.Tab() &&
 603             nStartRow == pLastRange->aStart.Row() && nEndRow == pLastRange->aEnd.Row() )
 604     {
 605         //      keep vertical part of aMMRect, only update horizontal position
 606         aMMRect = *pLastMM;
 607
 608         long nLeft = 0;
 609         SCCOL i;
 610         for (i=0; i<nStartCol; i++)
 611             nLeft += GetColWidth(i,nTab);
 612         long nRight = nLeft;
 613         for (i=nStartCol; i<=nEndCol; i++)
 614             nRight += GetColWidth(i,nTab);
 615
 616         aMMRect.Left()  = (long)(nLeft  * HMM_PER_TWIPS);
 617         aMMRect.Right() = (long)(nRight * HMM_PER_TWIPS);
 618     }
 619     else
 620         aMMRect = pThis->GetMMRect( nStartCol, nStartRow, nEndCol, nEndRow, nTab );
 621
 622     if ( pLastRange && pLastMM )
 623     {
 624         *pLastRange = ScRange( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab );
 625         *pLastMM = aMMRect;
 626     }
 627
 628     if ( pThis->HasAnyDraw( nTab, aMMRect ))
 629         return FALSE;
 630
 631     if ( nStartCol > 0 && !bLeftIsEmpty )
 632     {
 633         //      aehnlich wie in ScPrintFunc::AdjustPrintArea
 634         //!     ExtendPrintArea erst ab Start-Spalte des Druckbereichs
 635
 636         SCCOL nExtendCol = nStartCol - 1;
 637         SCROW nTmpRow = nEndRow;
 638
 639         pThis->ExtendMerge( 0,nStartRow, nExtendCol,nTmpRow, nTab,
 640                             FALSE, TRUE );              // kein Refresh, incl. Attrs
 641
 642         OutputDevice* pDev = pThis->GetPrinter();
 643         pDev->SetMapMode( MAP_PIXEL );                          // wichtig fuer GetNeededSize
 644         pThis->ExtendPrintArea( pDev, nTab, 0, nStartRow, nExtendCol, nEndRow );
 645         if ( nExtendCol >= nStartCol )
 646             return FALSE;
 647     }
 648
 649     return TRUE;
 650 }
 651
 652 void ScDocument::Clear( sal_Bool bFromDestructor )
 653 {
 654     for (SCTAB i=0; i<=MAXTAB; i++)
 655         if (pTab[i])
 656         {
 657             delete pTab[i];
 658             pTab[i]=NULL;
 659         }
 660     delete pSelectionAttr;
 661     pSelectionAttr = NULL;
 662
 663     if (pDrawLayer)
 664     {
 665         // #116168#
 666         //pDrawLayer->Clear();
 667         pDrawLayer->ClearModel( bFromDestructor );
 668     }
 669 }
 670
 671 BOOL ScDocument::HasControl( SCTAB nTab, const Rectangle& rMMRect )
 672 {
 673     BOOL bFound = FALSE;
 674
 675     if (pDrawLayer)
 676     {
 677         SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 678         DBG_ASSERT(pPage,"Page ?");
 679         if (pPage)
 680         {
 681             SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 682             SdrObject* pObject = aIter.Next();
 683             while (pObject && !bFound)
 684             {
 685                 if (pObject->ISA(SdrUnoObj))
 686                 {
 687                     Rectangle aObjRect = pObject->GetLogicRect();
 688                     if ( aObjRect.IsOver( rMMRect ) )
 689                         bFound = TRUE;
 690                 }
 691
 692                 pObject = aIter.Next();
 693             }
 694         }
 695     }
 696
 697     return bFound;
 698 }
 699
 700 void ScDocument::InvalidateControls( Window* pWin, SCTAB nTab, const Rectangle& rMMRect )
 701 {
 702     if (pDrawLayer)
 703     {
 704         SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 705         DBG_ASSERT(pPage,"Page ?");
 706         if (pPage)
 707         {
 708             SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 709             SdrObject* pObject = aIter.Next();
 710             while (pObject)
 711             {
 712                 if (pObject->ISA(SdrUnoObj))
 713                 {
 714                     Rectangle aObjRect = pObject->GetLogicRect();
 715                     if ( aObjRect.IsOver( rMMRect ) )
 716                     {
 717                         //      Uno-Controls zeichnen sich immer komplett, ohne Ruecksicht
 718                         //      auf ClippingRegions. Darum muss das ganze Objekt neu gepainted
 719                         //      werden, damit die Selektion auf der Tabelle nicht uebermalt wird.
 720
 721                         //pWin->Invalidate( aObjRect.GetIntersection( rMMRect ) );
 722                         pWin->Invalidate( aObjRect );
 723                     }
 724                 }
 725
 726                 pObject = aIter.Next();
 727             }
 728         }
 729     }
 730 }
 731
 732 BOOL ScDocument::HasDetectiveObjects(SCTAB nTab) const
 733 {
 734     //  looks for detective objects, annotations don't count
 735     //  (used to adjust scale so detective objects hit their cells better)
 736
 737     BOOL bFound = FALSE;
 738
 739     if (pDrawLayer)
 740     {
 741         SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 742         DBG_ASSERT(pPage,"Page ?");
 743         if (pPage)
 744         {
 745             SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 746             SdrObject* pObject = aIter.Next();
 747             while (pObject && !bFound)
 748             {
 749                 // anything on the internal layer except captions (annotations)
 750                 if ( (pObject->GetLayer() == SC_LAYER_INTERN) && !ScDrawLayer::IsNoteCaption( pObject ) )
 751                     bFound = TRUE;
 752
 753                 pObject = aIter.Next();
 754             }
 755         }
 756     }
 757
 758     return bFound;
 759 }
 760
 761 void ScDocument::UpdateFontCharSet()
 762 {
 763     //  In alten Versionen (bis incl. 4.0 ohne SP) wurden beim Austausch zwischen
 764     //  Systemen die CharSets in den Font-Attributen nicht angepasst.
 765     //  Das muss fuer Dokumente bis incl SP2 nun nachgeholt werden:
 766     //  Alles, was nicht SYMBOL ist, wird auf den System-CharSet umgesetzt.
 767     //  Bei neuen Dokumenten (Version SC_FONTCHARSET) sollte der CharSet stimmen.
 768
 769     BOOL bUpdateOld = ( nSrcVer < SC_FONTCHARSET );
 770
 771     CharSet eSysSet = gsl_getSystemTextEncoding();
 772     if ( eSrcSet != eSysSet || bUpdateOld )
 773     {
 774         USHORT nCount,i;
 775         SvxFontItem* pItem;
 776
 777         ScDocumentPool* pPool = xPoolHelper->GetDocPool();
 778         nCount = pPool->GetItemCount(ATTR_FONT);
 779         for (i=0; i<nCount; i++)
 780         {
 781             pItem = (SvxFontItem*)pPool->GetItem(ATTR_FONT, i);
 782             if ( pItem && ( pItem->GetCharSet() == eSrcSet ||
 783                             ( bUpdateOld && pItem->GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) )
 784                 pItem->GetCharSet() = eSysSet;
 785         }
 786
 787         if ( pDrawLayer )
 788         {
 789             SfxItemPool& rDrawPool = pDrawLayer->GetItemPool();
 790             nCount = rDrawPool.GetItemCount(EE_CHAR_FONTINFO);
 791             for (i=0; i<nCount; i++)
 792             {
 793                 pItem = (SvxFontItem*)rDrawPool.GetItem(EE_CHAR_FONTINFO, i);
 794                 if ( pItem && ( pItem->GetCharSet() == eSrcSet ||
 795                                 ( bUpdateOld && pItem->GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) )
 796                     pItem->GetCharSet() = eSysSet;
 797             }
 798         }
 799     }
 800 }
 801
 802 void ScDocument::SetLoadingMedium( bool bVal )
 803 {
 804     bLoadingMedium = bVal;
 805 }
 806
 807 bool ScDocument::IsLoadingMedium() const
 808 {
 809     return bLoadingMedium;
 810 }
 811
 812 void ScDocument::SetImportingXML( BOOL bVal )
 813 {
 814     bImportingXML = bVal;
 815     if (pDrawLayer)
 816         pDrawLayer->EnableAdjust(!bImportingXML);
 817
 818     if ( !bVal )
 819     {
 820         // #i57869# after loading, do the real RTL mirroring for the sheets that have the LoadingRTL flag set
 821
 822         for ( SCTAB nTab=0; nTab<=MAXTAB && pTab[nTab]; nTab++ )
 823             if ( pTab[nTab]->IsLoadingRTL() )
 824             {
 825                 pTab[nTab]->SetLoadingRTL( FALSE );
 826                 SetLayoutRTL( nTab, TRUE );             // includes mirroring; bImportingXML must be cleared first
 827             }
 828     }
 829 }
 830
 831 void ScDocument::SetXMLFromWrapper( BOOL bVal )
 832 {
 833     bXMLFromWrapper = bVal;
 834 }
 835
 836 vos::ORef<SvxForbiddenCharactersTable> ScDocument::GetForbiddenCharacters()
 837 {
 838     return xForbiddenCharacters;
 839 }
 840
 841 void ScDocument::SetForbiddenCharacters( const vos::ORef<SvxForbiddenCharactersTable> xNew )
 842 {
 843     xForbiddenCharacters = xNew;
 844     if ( pEditEngine )
 845         pEditEngine->SetForbiddenCharsTable( xForbiddenCharacters );
 846     if ( pDrawLayer )
 847         pDrawLayer->SetForbiddenCharsTable( xForbiddenCharacters );
 848 }
 849
 850 BOOL ScDocument::IsValidAsianCompression() const
 851 {
 852     return ( nAsianCompression != SC_ASIANCOMPRESSION_INVALID );
 853 }
 854
 855 BYTE ScDocument::GetAsianCompression() const
 856 {
 857     if ( nAsianCompression == SC_ASIANCOMPRESSION_INVALID )
 858         return 0;
 859     else
 860         return nAsianCompression;
 861 }
 862
 863 void ScDocument::SetAsianCompression(BYTE nNew)
 864 {
 865     nAsianCompression = nNew;
 866     if ( pEditEngine )
 867         pEditEngine->SetAsianCompressionMode( nAsianCompression );
 868     if ( pDrawLayer )
 869         pDrawLayer->SetCharCompressType( nAsianCompression );
 870 }
 871
 872 BOOL ScDocument::IsValidAsianKerning() const
 873 {
 874     return ( nAsianKerning != SC_ASIANKERNING_INVALID );
 875 }
 876
 877 BOOL ScDocument::GetAsianKerning() const
 878 {
 879     if ( nAsianKerning == SC_ASIANKERNING_INVALID )
 880         return FALSE;
 881     else
 882         return (BOOL)nAsianKerning;
 883 }
 884
 885 void ScDocument::SetAsianKerning(BOOL bNew)
 886 {
 887     nAsianKerning = (BYTE)bNew;
 888     if ( pEditEngine )
 889         pEditEngine->SetKernAsianPunctuation( (BOOL)nAsianKerning );
 890     if ( pDrawLayer )
 891         pDrawLayer->SetKernAsianPunctuation( (BOOL)nAsianKerning );
 892 }
 893