sc/source/ui/unoobj/chartuno.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: chartuno.cxx,v $
  10  * $Revision: 1.22 $
  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
  35 #include <com/sun/star/embed/Aspects.hpp>
  36 #include <com/sun/star/awt/Size.hpp>
  37 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
  38 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  39 #include <com/sun/star/chart2/XChartDocument.hpp>
  40 #include <com/sun/star/embed/Aspects.hpp>
  41
  42 #include <svx/svditer.hxx>
  43 #include <svx/svdoole2.hxx>
  44 #include <svx/svdpage.hxx>
  45 #include <svx/svdundo.hxx>
  46 #include <sfx2/app.hxx>
  47 #include <svtools/moduleoptions.hxx>
  48 #include <sot/clsids.hxx>
  49 #include <toolkit/helper/vclunohelper.hxx>
  50
  51 #include "chartuno.hxx"
  52 #include "miscuno.hxx"
  53 #include "docsh.hxx"
  54 #include "drwlayer.hxx"
  55 #include "undodat.hxx"
  56 #include "chartarr.hxx"
  57 #include "chartlis.hxx"
  58 #include "unoguard.hxx"
  59 #include "chart2uno.hxx"
  60
  61 using namespace com::sun::star;
  62
  63 //------------------------------------------------------------------------
  64
  65 SC_SIMPLE_SERVICE_INFO( ScChartObj, "ScChartObj", "com.sun.star.table.TableChart" )
  66 SC_SIMPLE_SERVICE_INFO( ScChartsObj, "ScChartsObj", "com.sun.star.table.TableCharts" )
  67
  68 //------------------------------------------------------------------------
  69
  70 SdrOle2Obj* lcl_FindChartObj( ScDocShell* pDocShell, SCTAB nTab, const String& rName )
  71 {
  72     if (pDocShell)
  73     {
  74         ScDocument* pDoc = pDocShell->GetDocument();
  75         ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
  76         if (pDrawLayer)
  77         {
  78             SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
  79             DBG_ASSERT(pPage, "Page nicht gefunden");
  80             if (pPage)
  81             {
  82                 SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
  83                 SdrObject* pObject = aIter.Next();
  84                 while (pObject)
  85                 {
  86                     if ( pObject->GetObjIdentifier() == OBJ_OLE2 && pDoc->IsChart(pObject) )
  87                     {
  88                         uno::Reference < embed::XEmbeddedObject > xObj = ((SdrOle2Obj*)pObject)->GetObjRef();
  89                         if ( xObj.is() )
  90                         {
  91                             String aObjName = pDocShell->GetEmbeddedObjectContainer().GetEmbeddedObjectName( xObj );
  92                             if ( aObjName == rName )
  93                                 return (SdrOle2Obj*)pObject;
  94                         }
  95                     }
  96                     pObject = aIter.Next();
  97                 }
  98             }
  99         }
 100     }
 101     return NULL;
 102 }
 103
 104 //------------------------------------------------------------------------
 105
 106 ScChartsObj::ScChartsObj(ScDocShell* pDocSh, SCTAB nT) :
 107     pDocShell( pDocSh ),
 108     nTab( nT )
 109 {
 110     pDocShell->GetDocument()->AddUnoObject(*this);
 111 }
 112
 113 ScChartsObj::~ScChartsObj()
 114 {
 115     if (pDocShell)
 116         pDocShell->GetDocument()->RemoveUnoObject(*this);
 117 }
 118
 119 void ScChartsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
 120 {
 121     //! Referenz-Update
 122
 123     if ( rHint.ISA( SfxSimpleHint ) &&
 124             ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 125     {
 126         pDocShell = NULL;               // ungueltig geworden
 127     }
 128 }
 129
 130 ScChartObj* ScChartsObj::GetObjectByIndex_Impl(long nIndex) const
 131 {
 132     String aName;
 133     if ( pDocShell )
 134     {
 135         ScDocument* pDoc = pDocShell->GetDocument();
 136         ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
 137         if (pDrawLayer)
 138         {
 139             SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 140             DBG_ASSERT(pPage, "Page nicht gefunden");
 141             if (pPage)
 142             {
 143                 long nPos = 0;
 144                 SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 145                 SdrObject* pObject = aIter.Next();
 146                 while (pObject)
 147                 {
 148                     if ( pObject->GetObjIdentifier() == OBJ_OLE2 && pDoc->IsChart(pObject) )
 149                     {
 150                         if ( nPos == nIndex )
 151                         {
 152                             uno::Reference < embed::XEmbeddedObject > xObj = ((SdrOle2Obj*)pObject)->GetObjRef();
 153                             if ( xObj.is() )
 154                                 aName = pDocShell->GetEmbeddedObjectContainer().GetEmbeddedObjectName( xObj );
 155                             break;      // nicht weitersuchen
 156                         }
 157                         ++nPos;
 158                     }
 159                     pObject = aIter.Next();
 160                 }
 161             }
 162         }
 163     }
 164
 165     if (aName.Len())
 166         return new ScChartObj( pDocShell, nTab, aName );
 167     return NULL;
 168 }
 169
 170 ScChartObj* ScChartsObj::GetObjectByName_Impl(const rtl::OUString& aName) const
 171 {
 172     String aNameString(aName);
 173     if ( lcl_FindChartObj( pDocShell, nTab, aNameString ) )
 174         return new ScChartObj( pDocShell, nTab, aNameString );
 175     return NULL;
 176 }
 177
 178 // XTableCharts
 179
 180 void SAL_CALL ScChartsObj::addNewByName( const rtl::OUString& aName,
 181                                         const awt::Rectangle& aRect,
 182                                         const uno::Sequence<table::CellRangeAddress>& aRanges,
 183                                         sal_Bool bColumnHeaders, sal_Bool bRowHeaders )
 184                                     throw(::com::sun::star::uno::RuntimeException)
 185 {
 186     ScUnoGuard aGuard;
 187     if (!pDocShell)
 188         return;
 189
 190     ScDocument* pDoc = pDocShell->GetDocument();
 191     ScDrawLayer* pModel = pDocShell->MakeDrawLayer();
 192     SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
 193     DBG_ASSERT(pPage,"addChart: keine Page");
 194     if (!pPage || !pDoc)
 195         return;
 196
 197     //  chart can't be inserted if any ole object with that name exists on any table
 198     //  (empty string: generate valid name)
 199
 200     String aNameString(aName);
 201     SCTAB nDummy;
 202     if ( aNameString.Len() && pModel->GetNamedObject( aNameString, OBJ_OLE2, nDummy ) )
 203     {
 204         //      object exists - only RuntimeException is specified
 205         throw uno::RuntimeException();
 206     }
 207
 208     ScRangeList* pList = new ScRangeList;
 209     USHORT nRangeCount = (USHORT)aRanges.getLength();
 210     if (nRangeCount)
 211     {
 212         const table::CellRangeAddress* pAry = aRanges.getConstArray();
 213         for (USHORT i=0; i<nRangeCount; i++)
 214         {
 215             ScRange aRange( static_cast<SCCOL>(pAry[i].StartColumn), pAry[i].StartRow, pAry[i].Sheet,
 216                             static_cast<SCCOL>(pAry[i].EndColumn),   pAry[i].EndRow,   pAry[i].Sheet );
 217             pList->Append( aRange );
 218         }
 219     }
 220     ScRangeListRef xNewRanges( pList );
 221
 222     uno::Reference < embed::XEmbeddedObject > xObj;
 223     ::rtl::OUString aTmp( aNameString );
 224     if ( SvtModuleOptions().IsChart() )
 225         xObj = pDocShell->GetEmbeddedObjectContainer().CreateEmbeddedObject( SvGlobalName( SO3_SCH_CLASSID ).GetByteSequence(), aTmp );
 226     if ( xObj.is() )
 227     {
 228             String aObjName = aNameString;       // wirklich eingefuegter Name...
 229
 230             //  Rechteck anpassen
 231             //! Fehler/Exception, wenn leer/ungueltig ???
 232             Point aRectPos( aRect.X, aRect.Y );
 233             if (aRectPos.X() < 0) aRectPos.X() = 0;
 234             if (aRectPos.Y() < 0) aRectPos.Y() = 0;
 235             Size aRectSize( aRect.Width, aRect.Height );
 236             if (aRectSize.Width() <= 0) aRectSize.Width() = 5000;       // Default-Groesse
 237             if (aRectSize.Height() <= 0) aRectSize.Height() = 5000;
 238             Rectangle aInsRect( aRectPos, aRectSize );
 239
 240             sal_Int64 nAspect(embed::Aspects::MSOLE_CONTENT);
 241             MapUnit aMapUnit(VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) ));
 242             Size aSize(aInsRect.GetSize());
 243             aSize = Window::LogicToLogic( aSize, MapMode( MAP_100TH_MM ), MapMode( aMapUnit ) );
 244             awt::Size aSz;
 245             aSz.Width = aSize.Width();
 246             aSz.Height = aSize.Height();
 247
 248             // Calc -> DataProvider
 249             uno::Reference< chart2::data::XDataProvider > xDataProvider = new
 250                 ScChart2DataProvider( pDoc );
 251             // Chart -> DataReceiver
 252             uno::Reference< chart2::data::XDataReceiver > xReceiver;
 253             uno::Reference< embed::XComponentSupplier > xCompSupp( xObj, uno::UNO_QUERY );
 254             if( xCompSupp.is())
 255                 xReceiver.set( xCompSupp->getComponent(), uno::UNO_QUERY );
 256             if( xReceiver.is())
 257             {
 258                 // connect
 259                 xReceiver->attachDataProvider( xDataProvider );
 260                 uno::Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier( pDocShell->GetModel(), uno::UNO_QUERY );
 261                 xReceiver->attachNumberFormatsSupplier( xNumberFormatsSupplier );
 262
 263                 // set arguments
 264                 String sRangeStr;
 265                 xNewRanges->Format(sRangeStr, SCR_ABS_3D, pDoc);
 266                 uno::Sequence< beans::PropertyValue > aArgs( 4 );
 267                 aArgs[0] = beans::PropertyValue(
 268                     ::rtl::OUString::createFromAscii("CellRangeRepresentation"), -1,
 269                     uno::makeAny( ::rtl::OUString( sRangeStr )), beans::PropertyState_DIRECT_VALUE );
 270                 aArgs[1] = beans::PropertyValue(
 271                     ::rtl::OUString::createFromAscii("HasCategories"), -1,
 272                     uno::makeAny( bRowHeaders ), beans::PropertyState_DIRECT_VALUE );
 273                 aArgs[2] = beans::PropertyValue(
 274                     ::rtl::OUString::createFromAscii("FirstCellAsLabel"), -1,
 275                     uno::makeAny( bColumnHeaders ), beans::PropertyState_DIRECT_VALUE );
 276                 aArgs[3] = beans::PropertyValue(
 277                     ::rtl::OUString::createFromAscii("DataRowSource"), -1,
 278                     uno::makeAny( chart::ChartDataRowSource_COLUMNS ), beans::PropertyState_DIRECT_VALUE );
 279                 xReceiver->setArguments( aArgs );
 280             }
 281
 282             ScChartListener* pChartListener =
 283                 new ScChartListener( aObjName, pDoc, xNewRanges );
 284             pDoc->GetChartListenerCollection()->Insert( pChartListener );
 285             pChartListener->StartListeningTo();
 286
 287             SdrOle2Obj* pObj = new SdrOle2Obj( ::svt::EmbeddedObjectRef( xObj, embed::Aspects::MSOLE_CONTENT ), aObjName, aInsRect );
 288
 289             // set VisArea
 290             if( xObj.is())
 291                 xObj->setVisualAreaSize( nAspect, aSz );
 292
 293             pPage->InsertObject( pObj );
 294             pModel->AddUndo( new SdrUndoInsertObj( *pObj ) );           //! Undo-Kommentar?
 295
 296             // Dies veranlaesst Chart zum sofortigen Update
 297             //SvData aEmpty;
 298             //aIPObj->SendDataChanged( aEmpty );
 299     }
 300 }
 301
 302 void SAL_CALL ScChartsObj::removeByName( const rtl::OUString& aName )
 303                                             throw(uno::RuntimeException)
 304 {
 305     ScUnoGuard aGuard;
 306     String aNameString(aName);
 307     SdrOle2Obj* pObj = lcl_FindChartObj( pDocShell, nTab, aNameString );
 308     if (pObj)
 309     {
 310         ScDocument* pDoc = pDocShell->GetDocument();
 311         ScDrawLayer* pModel = pDoc->GetDrawLayer();             // ist nicht 0
 312         SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));    // ist nicht 0
 313
 314         pModel->AddUndo( new SdrUndoRemoveObj( *pObj ) );       //!     Undo-Kommentar?
 315         pPage->RemoveObject( pObj->GetOrdNum() );
 316
 317         //!     Notify etc.???
 318     }
 319 }
 320
 321 // XEnumerationAccess
 322
 323 uno::Reference<container::XEnumeration> SAL_CALL ScChartsObj::createEnumeration()
 324                                                     throw(uno::RuntimeException)
 325 {
 326     ScUnoGuard aGuard;
 327     return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.table.TableChartsEnumeration")));
 328 }
 329
 330 // XIndexAccess
 331
 332 sal_Int32 SAL_CALL ScChartsObj::getCount() throw(uno::RuntimeException)
 333 {
 334     ScUnoGuard aGuard;
 335     INT32 nCount = 0;
 336     if ( pDocShell )
 337     {
 338         ScDocument* pDoc = pDocShell->GetDocument();
 339         ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
 340         if (pDrawLayer)
 341         {
 342             SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 343             DBG_ASSERT(pPage, "Page nicht gefunden");
 344             if (pPage)
 345             {
 346                 SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 347                 SdrObject* pObject = aIter.Next();
 348                 while (pObject)
 349                 {
 350                     if ( pObject->GetObjIdentifier() == OBJ_OLE2 && pDoc->IsChart(pObject) )
 351                         ++nCount;
 352                     pObject = aIter.Next();
 353                 }
 354             }
 355         }
 356     }
 357     return nCount;
 358 }
 359
 360 uno::Any SAL_CALL ScChartsObj::getByIndex( sal_Int32 nIndex )
 361                             throw(lang::IndexOutOfBoundsException,
 362                                     lang::WrappedTargetException, uno::RuntimeException)
 363 {
 364     ScUnoGuard aGuard;
 365     uno::Reference<table::XTableChart> xChart(GetObjectByIndex_Impl(nIndex));
 366     if (xChart.is())
 367         return uno::makeAny(xChart);
 368     else
 369         throw lang::IndexOutOfBoundsException();
 370 //    return uno::Any();
 371 }
 372
 373 uno::Type SAL_CALL ScChartsObj::getElementType() throw(uno::RuntimeException)
 374 {
 375     ScUnoGuard aGuard;
 376     return getCppuType((uno::Reference<table::XTableChart>*)0);
 377 }
 378
 379 sal_Bool SAL_CALL ScChartsObj::hasElements() throw(uno::RuntimeException)
 380 {
 381     ScUnoGuard aGuard;
 382     return getCount() != 0;
 383 }
 384
 385 uno::Any SAL_CALL ScChartsObj::getByName( const rtl::OUString& aName )
 386             throw(container::NoSuchElementException,
 387                     lang::WrappedTargetException, uno::RuntimeException)
 388 {
 389     ScUnoGuard aGuard;
 390     uno::Reference<table::XTableChart> xChart(GetObjectByName_Impl(aName));
 391     if (xChart.is())
 392         return uno::makeAny(xChart);
 393     else
 394         throw container::NoSuchElementException();
 395 //    return uno::Any();
 396 }
 397
 398 uno::Sequence<rtl::OUString> SAL_CALL ScChartsObj::getElementNames() throw(uno::RuntimeException)
 399 {
 400     ScUnoGuard aGuard;
 401     if (pDocShell)
 402     {
 403         ScDocument* pDoc = pDocShell->GetDocument();
 404
 405         long nCount = getCount();
 406         uno::Sequence<rtl::OUString> aSeq(nCount);
 407         rtl::OUString* pAry = aSeq.getArray();
 408
 409         long nPos = 0;
 410         ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
 411         if (pDrawLayer)
 412         {
 413             SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
 414             DBG_ASSERT(pPage, "Page nicht gefunden");
 415             if (pPage)
 416             {
 417                 SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 418                 SdrObject* pObject = aIter.Next();
 419                 while (pObject)
 420                 {
 421                     if ( pObject->GetObjIdentifier() == OBJ_OLE2 && pDoc->IsChart(pObject) )
 422                     {
 423                         String aName;
 424                         uno::Reference < embed::XEmbeddedObject > xObj = ((SdrOle2Obj*)pObject)->GetObjRef();
 425                         if ( xObj.is() )
 426                             aName = pDocShell->GetEmbeddedObjectContainer().GetEmbeddedObjectName( xObj );
 427
 428                         DBG_ASSERT(nPos<nCount, "huch, verzaehlt?");
 429                         pAry[nPos++] = aName;
 430                     }
 431                     pObject = aIter.Next();
 432                 }
 433             }
 434         }
 435         DBG_ASSERT(nPos==nCount, "nanu, verzaehlt?");
 436
 437         return aSeq;
 438     }
 439     return uno::Sequence<rtl::OUString>(0);
 440 }
 441
 442 sal_Bool SAL_CALL ScChartsObj::hasByName( const rtl::OUString& aName )
 443                                         throw(uno::RuntimeException)
 444 {
 445     ScUnoGuard aGuard;
 446     String aNameString(aName);
 447     return ( lcl_FindChartObj( pDocShell, nTab, aNameString ) != NULL );
 448 }
 449
 450 //------------------------------------------------------------------------
 451
 452 ScChartObj::ScChartObj(ScDocShell* pDocSh, SCTAB nT, const String& rN) :
 453     pDocShell( pDocSh ),
 454     nTab( nT ),
 455     aChartName( rN )
 456 {
 457     pDocShell->GetDocument()->AddUnoObject(*this);
 458 }
 459
 460 ScChartObj::~ScChartObj()
 461 {
 462     if (pDocShell)
 463         pDocShell->GetDocument()->RemoveUnoObject(*this);
 464 }
 465
 466 void ScChartObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
 467 {
 468     //! Referenz-Update
 469
 470     if ( rHint.ISA( SfxSimpleHint ) &&
 471             ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 472     {
 473         pDocShell = NULL;               // ungueltig geworden
 474     }
 475 }
 476
 477 void ScChartObj::GetData_Impl( ScRangeListRef& rRanges, bool& rColHeaders, bool& rRowHeaders ) const
 478 {
 479     bool bFound = false;
 480     ScDocument* pDoc = (pDocShell? pDocShell->GetDocument(): 0);
 481     uno::Reference< embed::XEmbeddedObject > xIPObj;
 482     if( pDoc )
 483         xIPObj.set( pDoc->FindOleObjectByName( aChartName ), uno::UNO_QUERY );
 484     if( xIPObj.is())
 485     {
 486         //make sure that the chart is loaded
 487         svt::EmbeddedObjectRef::TryRunningState( xIPObj );
 488
 489         uno::Reference< chart2::XChartDocument > xChartDoc( xIPObj->getComponent(), uno::UNO_QUERY );
 490         uno::Reference< chart2::data::XDataReceiver > xReceiver( xChartDoc, uno::UNO_QUERY );
 491         if( xReceiver.is() )
 492         {
 493             uno::Reference< chart2::data::XDataProvider > xProvider = xChartDoc->getDataProvider();
 494             if( xProvider.is() )
 495             {
 496                 uno::Sequence< beans::PropertyValue > aArgs( xProvider->detectArguments( xReceiver->getUsedData() ) );
 497
 498                 rtl::OUString aRanges;
 499                 chart::ChartDataRowSource eDataRowSource = chart::ChartDataRowSource_COLUMNS;
 500                 bool bHasCategories=false;
 501                 bool bFirstCellAsLabel=false;
 502                 const beans::PropertyValue* pPropArray = aArgs.getConstArray();
 503                 long nPropCount = aArgs.getLength();
 504                 for (long i = 0; i < nPropCount; i++)
 505                 {
 506                     const beans::PropertyValue& rProp = pPropArray[i];
 507                     String aPropName(rProp.Name);
 508
 509                     if (aPropName.EqualsAscii( "CellRangeRepresentation" ))
 510                         rProp.Value >>= aRanges;
 511                     else if (aPropName.EqualsAscii( "DataRowSource" ))
 512                         eDataRowSource = (chart::ChartDataRowSource)ScUnoHelpFunctions::GetEnumFromAny( rProp.Value );
 513                     else if (aPropName.EqualsAscii( "HasCategories" ))
 514                         bHasCategories = ScUnoHelpFunctions::GetBoolFromAny( rProp.Value );
 515                     else if (aPropName.EqualsAscii( "FirstCellAsLabel" ))
 516                         bFirstCellAsLabel = ScUnoHelpFunctions::GetBoolFromAny( rProp.Value );
 517                 }
 518
 519                 if( chart::ChartDataRowSource_COLUMNS == eDataRowSource )
 520                 {
 521                     rColHeaders=bFirstCellAsLabel;
 522                     rRowHeaders=bHasCategories;
 523                 }
 524                 else
 525                 {
 526                     rColHeaders=bHasCategories;
 527                     rRowHeaders=bFirstCellAsLabel;
 528                 }
 529                 rRanges->Parse( aRanges, pDoc);
 530             }
 531             bFound = true;
 532         }
 533      }
 534     if( !bFound )
 535     {
 536         rRanges = 0;
 537         rColHeaders = false;
 538         rRowHeaders = false;
 539     }
 540 }
 541
 542 void ScChartObj::Update_Impl( const ScRangeListRef& rRanges, bool bColHeaders, bool bRowHeaders )
 543 {
 544     if (pDocShell)
 545     {
 546         ScDocument* pDoc = pDocShell->GetDocument();
 547         BOOL bUndo(pDoc->IsUndoEnabled());
 548
 549         if (bUndo)
 550         {
 551             pDocShell->GetUndoManager()->AddUndoAction(
 552                 new ScUndoChartData( pDocShell, aChartName, rRanges, bColHeaders, bRowHeaders, FALSE ) );
 553         }
 554         pDoc->UpdateChartArea( aChartName, rRanges, bColHeaders, bRowHeaders, FALSE );
 555     }
 556 }
 557
 558 // XTableChart
 559
 560 sal_Bool SAL_CALL ScChartObj::getHasColumnHeaders() throw(uno::RuntimeException)
 561 {
 562     ScUnoGuard aGuard;
 563     ScRangeListRef xRanges = new ScRangeList;
 564     bool bColHeaders, bRowHeaders;
 565     GetData_Impl( xRanges, bColHeaders, bRowHeaders );
 566     return bColHeaders;
 567 }
 568
 569 void SAL_CALL ScChartObj::setHasColumnHeaders( sal_Bool bHasColumnHeaders )
 570                                                 throw(uno::RuntimeException)
 571 {
 572     ScUnoGuard aGuard;
 573     ScRangeListRef xRanges = new ScRangeList;
 574     bool bOldColHeaders, bOldRowHeaders;
 575     GetData_Impl( xRanges, bOldColHeaders, bOldRowHeaders );
 576     if ( bOldColHeaders != (bHasColumnHeaders != sal_False) )
 577         Update_Impl( xRanges, bHasColumnHeaders, bOldRowHeaders );
 578 }
 579
 580 sal_Bool SAL_CALL ScChartObj::getHasRowHeaders() throw(uno::RuntimeException)
 581 {
 582     ScUnoGuard aGuard;
 583     ScRangeListRef xRanges = new ScRangeList;
 584     bool bColHeaders, bRowHeaders;
 585     GetData_Impl( xRanges, bColHeaders, bRowHeaders );
 586     return bRowHeaders;
 587 }
 588
 589 void SAL_CALL ScChartObj::setHasRowHeaders( sal_Bool bHasRowHeaders )
 590                                                 throw(uno::RuntimeException)
 591 {
 592     ScUnoGuard aGuard;
 593     ScRangeListRef xRanges = new ScRangeList;
 594     bool bOldColHeaders, bOldRowHeaders;
 595     GetData_Impl( xRanges, bOldColHeaders, bOldRowHeaders );
 596     if ( bOldRowHeaders != (bHasRowHeaders != sal_False) )
 597         Update_Impl( xRanges, bOldColHeaders, bHasRowHeaders );
 598 }
 599
 600 uno::Sequence<table::CellRangeAddress> SAL_CALL ScChartObj::getRanges() throw(uno::RuntimeException)
 601 {
 602     ScUnoGuard aGuard;
 603     ScRangeListRef xRanges = new ScRangeList;
 604     bool bColHeaders, bRowHeaders;
 605     GetData_Impl( xRanges, bColHeaders, bRowHeaders );
 606     if ( xRanges.Is() )
 607     {
 608         ULONG nCount = xRanges->Count();
 609
 610         table::CellRangeAddress aRangeAddress;
 611         uno::Sequence<table::CellRangeAddress> aSeq(nCount);
 612         table::CellRangeAddress* pAry = aSeq.getArray();
 613         for (USHORT i=0; i<nCount; i++)
 614         {
 615             ScRange aRange(*xRanges->GetObject(i));
 616
 617             aRangeAddress.Sheet           = aRange.aStart.Tab();
 618             aRangeAddress.StartColumn = aRange.aStart.Col();
 619             aRangeAddress.StartRow        = aRange.aStart.Row();
 620             aRangeAddress.EndColumn       = aRange.aEnd.Col();
 621             aRangeAddress.EndRow          = aRange.aEnd.Row();
 622
 623             pAry[i] = aRangeAddress;
 624         }
 625         return aSeq;
 626     }
 627
 628     DBG_ERROR("ScChartObj::getRanges: keine Ranges");
 629     return uno::Sequence<table::CellRangeAddress>();
 630 }
 631
 632 void SAL_CALL ScChartObj::setRanges( const uno::Sequence<table::CellRangeAddress>& aRanges )
 633                                                 throw(uno::RuntimeException)
 634 {
 635     ScUnoGuard aGuard;
 636     ScRangeListRef xOldRanges = new ScRangeList;
 637     bool bColHeaders, bRowHeaders;
 638     GetData_Impl( xOldRanges, bColHeaders, bRowHeaders );
 639
 640     ScRangeList* pList = new ScRangeList;
 641     USHORT nRangeCount = (USHORT)aRanges.getLength();
 642     if (nRangeCount)
 643     {
 644         const table::CellRangeAddress* pAry = aRanges.getConstArray();
 645         for (USHORT i=0; i<nRangeCount; i++)
 646         {
 647             ScRange aRange( static_cast<SCCOL>(pAry[i].StartColumn), pAry[i].StartRow, pAry[i].Sheet,
 648                             static_cast<SCCOL>(pAry[i].EndColumn),   pAry[i].EndRow,   pAry[i].Sheet );
 649             pList->Append( aRange );
 650         }
 651     }
 652     ScRangeListRef xNewRanges( pList );
 653
 654     if ( !xOldRanges.Is() || *xOldRanges != *xNewRanges )
 655         Update_Impl( xNewRanges, bColHeaders, bRowHeaders );
 656 }
 657
 658 // XEmbeddedObjectSupplier
 659
 660 uno::Reference<lang::XComponent> SAL_CALL ScChartObj::getEmbeddedObject() throw(uno::RuntimeException)
 661 {
 662     ScUnoGuard aGuard;
 663     SdrOle2Obj* pObject = lcl_FindChartObj( pDocShell, nTab, aChartName );
 664     if ( pObject && svt::EmbeddedObjectRef::TryRunningState( pObject->GetObjRef() ) )
 665     {
 666         //TODO/LATER: is it OK that something is returned for *all* objects, not only own objects?
 667         return uno::Reference < lang::XComponent > ( pObject->GetObjRef()->getComponent(), uno::UNO_QUERY );
 668     }
 669
 670     return NULL;
 671 }
 672
 673 // XNamed
 674
 675 rtl::OUString SAL_CALL ScChartObj::getName() throw(uno::RuntimeException)
 676 {
 677     ScUnoGuard aGuard;
 678     return aChartName;
 679 }
 680
 681 void SAL_CALL ScChartObj::setName( const rtl::OUString& /* aName */ ) throw(uno::RuntimeException)
 682 {
 683     ScUnoGuard aGuard;
 684     throw uno::RuntimeException();              // name cannot be changed
 685 }
 686
 687 //------------------------------------------------------------------------
 688
 689
 690