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