sc/source/ui/vba/vbachart.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #include "vbachart.hxx"
  20 #include <com/sun/star/beans/XPropertySet.hpp>
  21 #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
  22 #include <com/sun/star/chart/XAxisXSupplier.hpp>
  23 #include <com/sun/star/chart/XAxisYSupplier.hpp>
  24 #include <com/sun/star/chart/XAxisZSupplier.hpp>
  25 #include <com/sun/star/chart/XTwoAxisXSupplier.hpp>
  26 #include <com/sun/star/chart/XTwoAxisYSupplier.hpp>
  27 #include <com/sun/star/chart/XChartDataArray.hpp>
  28 #include <com/sun/star/chart/ChartSymbolType.hpp>
  29 #include <com/sun/star/chart/ChartSolidType.hpp>
  30 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  31 #include <com/sun/star/chart/ChartDataCaption.hpp>
  32 #include <ooo/vba/excel/XlChartType.hpp>
  33 #include <ooo/vba/excel/XlRowCol.hpp>
  34 #include <ooo/vba/excel/XlAxisType.hpp>
  35 #include <ooo/vba/excel/XlAxisGroup.hpp>
  36
  37 #include <basic/sberrors.hxx>
  38 #include "vbachartobject.hxx"
  39 #include "vbarange.hxx"
  40 #include "vbacharttitle.hxx"
  41 #include "vbaaxes.hxx"
  42
  43 using namespace ::com::sun::star;
  44 using namespace ::ooo::vba;
  45 using namespace ::ooo::vba::excel::XlChartType;
  46 using namespace ::ooo::vba::excel::XlRowCol;
  47 using namespace ::ooo::vba::excel::XlAxisType;
  48 using namespace ::ooo::vba::excel::XlAxisGroup;
  49
  50 const OUString CHART_NAME("Name");
  51 // #TODO move this constant to vbaseries.[ch]xx ( when it exists )
  52 const OUString DEFAULTSERIESPREFIX("Series");
  53 const OUString DATAROWSOURCE("DataRowSource");
  54 const OUString UPDOWN("UpDown");
  55 const OUString VOLUME("Volume");
  56 const OUString LINES("Lines");
  57 const OUString SPLINETYPE("SplineType");
  58 const OUString SYMBOLTYPE("SymbolType");
  59 const OUString DEEP("Deep");
  60 const OUString SOLIDTYPE("SolidType");
  61 const OUString VERTICAL("Vertical");
  62 const OUString PERCENT("Percent");
  63 const OUString STACKED("Stacked");
  64 const OUString DIM3D("Dim3D");
  65 const OUString HASMAINTITLE("HasMainTitle");
  66 const OUString HASLEGEND("HasLegend");
  67
  68 ScVbaChart::ScVbaChart( const css::uno::Reference< ov::XHelperInterface >& _xParent, const css::uno::Reference< css::uno::XComponentContext >& _xContext, const css::uno::Reference< css::lang::XComponent >& _xChartComponent, const css::uno::Reference< css::table::XTableChart >& _xTableChart ) : ChartImpl_BASE( _xParent, _xContext ), mxTableChart( _xTableChart )
  69 {
  70     mxChartDocument.set( _xChartComponent, uno::UNO_QUERY_THROW ) ;
  71     // #TODO is it possible that the XPropertySet interface is not set
  72     // code in setPlotBy seems to indicate that this is possible? but
  73     // additionally there is no check in most of the places where it is used
  74     // ( and therefore could possibly be NULL )
  75     // I'm going to let it throw for the moment ( npower )
  76     mxDiagramPropertySet.set( mxChartDocument->getDiagram(), uno::UNO_QUERY_THROW );
  77     mxChartPropertySet.set( _xChartComponent, uno::UNO_QUERY_THROW ) ;
  78 }
  79
  80 OUString SAL_CALL
  81 ScVbaChart::getName() throw (css::uno::RuntimeException, std::exception)
  82 {
  83     OUString sName;
  84     uno::Reference< beans::XPropertySet > xProps( mxChartDocument, uno::UNO_QUERY_THROW );
  85     try
  86     {
  87         xProps->getPropertyValue( CHART_NAME ) >>= sName;
  88     }
  89     catch( const uno::Exception & ) // swallow exceptions
  90     {
  91     }
  92     return sName;
  93 }
  94
  95 uno::Any  SAL_CALL
  96 ScVbaChart::SeriesCollection(const uno::Any&) throw (uno::RuntimeException, std::exception)
  97 {
  98     return uno::Any();
  99 }
 100
 101 ::sal_Int32 SAL_CALL
 102 ScVbaChart::getChartType() throw ( uno::RuntimeException, script::BasicErrorException, std::exception)
 103 {
 104     sal_Int32 nChartType = -1;
 105     try
 106     {
 107         OUString sDiagramType = mxChartDocument->getDiagram()->getDiagramType();
 108         if ( sDiagramType == "com.sun.star.chart.AreaDiagram" )
 109         {
 110             if (is3D())
 111             {
 112                 nChartType = getStackedType(xl3DAreaStacked, xl3DAreaStacked100, xl3DArea);
 113             }
 114             else
 115             {
 116                 nChartType = getStackedType(xlAreaStacked, xlAreaStacked100, xlArea);
 117             }
 118         }
 119         else if ( sDiagramType == "com.sun.star.chart.PieDiagram" )
 120         {
 121             if (is3D())
 122                 nChartType = xl3DPie;
 123             else
 124                 nChartType = xlPie;                 /*TODO XlChartType  xlPieExploded, XlChartType xlPieOfPie */
 125         }
 126         else if ( sDiagramType == "com.sun.star.chart.BarDiagram" )
 127         {
 128             sal_Int32 nSolidType = chart::ChartSolidType::RECTANGULAR_SOLID;
 129             if (mxDiagramPropertySet->getPropertySetInfo()->hasPropertyByName(SOLIDTYPE))
 130             {       //in 2D diagrams 'SolidType' may not be set
 131                 if (is3D())
 132                     mxDiagramPropertySet->getPropertyValue(SOLIDTYPE) >>= nSolidType;
 133             }
 134             switch (nSolidType)
 135             {
 136                 case chart::ChartSolidType::CONE:
 137                     nChartType = getSolidType(xlConeCol, xlConeColStacked, xlConeColStacked100, xlConeColClustered, xlConeBarStacked, xlConeBarStacked100, xlConeBarClustered);
 138                     break;
 139                 case chart::ChartSolidType::CYLINDER:
 140                     nChartType = getSolidType(xlCylinderCol, xlCylinderColStacked, xlCylinderColStacked100, xlCylinderColClustered, xlCylinderBarStacked, xlCylinderBarStacked100, xlCylinderBarClustered);
 141                     break;
 142                 case chart::ChartSolidType::PYRAMID:
 143                     nChartType = getSolidType(xlPyramidCol, xlPyramidColStacked, xlPyramidColStacked100, xlPyramidColClustered, xlPyramidBarStacked, xlPyramidBarStacked100, xlPyramidBarClustered);
 144                     break;
 145                 default: // RECTANGULAR_SOLID
 146                     if (is3D())
 147                     {
 148                         nChartType = getSolidType(xl3DColumn, xl3DColumnStacked, xl3DColumnStacked100, xl3DColumnClustered, xl3DBarStacked, xl3DBarStacked100, xl3DBarClustered);
 149                     }
 150                     else
 151                     {
 152                         nChartType = getSolidType(xlColumnClustered,  xlColumnStacked, xlColumnStacked100, xlColumnClustered, xlBarStacked, xlBarStacked100, xlBarClustered);
 153                     }
 154                     break;
 155                 }
 156             }
 157         else if ( sDiagramType == "com.sun.star.chart.StockDiagram" )
 158         {
 159             bool bVolume = false;
 160             mxDiagramPropertySet->getPropertyValue(VOLUME) >>= bVolume;
 161             if (bVolume)
 162             {
 163                 nChartType = getStockUpDownValue(xlStockVOHLC, xlStockVHLC);
 164             }
 165             else
 166             {
 167                 nChartType = getStockUpDownValue(xlStockOHLC, xlStockHLC);
 168             }
 169         }
 170         else if ( sDiagramType == "com.sun.star.chart.XYDiagram" )
 171         {
 172             bool bHasLines = false;
 173             mxDiagramPropertySet->getPropertyValue(LINES) >>= bHasLines;
 174             sal_Int32 nSplineType = 0;
 175             mxDiagramPropertySet->getPropertyValue(SPLINETYPE) >>= nSplineType;
 176             if (nSplineType == 1)
 177             {
 178                 nChartType = getMarkerType(xlXYScatterSmooth, xlXYScatterSmoothNoMarkers);
 179             }
 180             else if (bHasLines)
 181             {
 182                 nChartType = getMarkerType(xlXYScatterLines, xlXYScatterLinesNoMarkers);
 183             }
 184             else
 185             {
 186                 nChartType = xlXYScatter;
 187             }
 188         }
 189         else if ( sDiagramType == "com.sun.star.chart.LineDiagram" )
 190         {
 191             if (is3D())
 192             {
 193                 nChartType = xl3DLine;
 194             }
 195             else if (hasMarkers())
 196             {
 197                 nChartType = getStackedType(xlLineMarkersStacked, xlLineMarkersStacked100, xlLineMarkers);
 198             }
 199             else
 200             {
 201                 nChartType = getStackedType(xlLineStacked, xlLineStacked100, xlLine);
 202             }
 203         }
 204         else if ( sDiagramType == "com.sun.star.chart.DonutDiagram" )
 205         {
 206             nChartType = xlDoughnut;                    // TODO DoughnutExploded ??
 207         }
 208         else if ( sDiagramType == "com.sun.star.chart.NetDiagram" )
 209         {
 210             nChartType = getMarkerType(xlRadarMarkers, xlRadar);
 211         }
 212     }
 213     catch ( const uno::Exception& )
 214     {
 215         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 216     }
 217     return nChartType;
 218 }
 219
 220 void SAL_CALL
 221 ScVbaChart::setChartType( ::sal_Int32 _nChartType ) throw ( uno::RuntimeException, script::BasicErrorException, std::exception)
 222 {
 223 try
 224 {
 225     switch (_nChartType)
 226     {
 227         case xlColumnClustered:
 228         case xlColumnStacked:
 229         case xlColumnStacked100:
 230         case xl3DColumnClustered:
 231         case xl3DColumnStacked:
 232         case xl3DColumnStacked100:
 233         case xl3DColumn:
 234         case xlBarClustered:
 235         case xlBarStacked:
 236         case xlBarStacked100:
 237         case xl3DBarClustered:
 238         case xl3DBarStacked:
 239         case xl3DBarStacked100:
 240         case xlConeColClustered:
 241         case xlConeColStacked:
 242         case xlConeColStacked100:
 243         case xlConeBarClustered:
 244         case xlConeBarStacked:
 245         case xlConeBarStacked100:
 246         case xlConeCol:
 247         case xlPyramidColClustered:
 248         case xlPyramidColStacked:
 249         case xlPyramidColStacked100:
 250         case xlPyramidBarClustered:
 251         case xlPyramidBarStacked:
 252         case xlPyramidBarStacked100:
 253         case xlPyramidCol:
 254         case xlCylinderColClustered:
 255         case xlCylinderColStacked:
 256         case xlCylinderColStacked100:
 257         case xlCylinderBarClustered:
 258         case xlCylinderBarStacked:
 259         case xlCylinderBarStacked100:
 260         case xlCylinderCol:
 261         case xlSurface: // not possible
 262         case xlSurfaceWireframe:
 263         case xlSurfaceTopView:
 264         case xlSurfaceTopViewWireframe:
 265             setDiagram( OUString("com.sun.star.chart.BarDiagram"));
 266             break;
 267         case xlLine:
 268         case xl3DLine:
 269         case xlLineStacked:
 270         case xlLineStacked100:
 271         case xlLineMarkers:
 272         case xlLineMarkersStacked:
 273         case xlLineMarkersStacked100:
 274             setDiagram( OUString("com.sun.star.chart.LineDiagram"));
 275             break;
 276         case xl3DArea:
 277         case xlArea:
 278         case xlAreaStacked:
 279         case xlAreaStacked100:
 280         case xl3DAreaStacked:
 281         case xl3DAreaStacked100:
 282             setDiagram( OUString("com.sun.star.chart.AreaDiagram") );
 283             break;
 284         case xlDoughnut:
 285         case xlDoughnutExploded:
 286             setDiagram( OUString("com.sun.star.chart.DonutDiagram") );
 287             break;
 288         case xlStockHLC:
 289         case xlStockOHLC:
 290         case xlStockVHLC:
 291         case xlStockVOHLC:
 292             setDiagram( OUString("com.sun.star.chart.StockDiagram"));
 293             mxDiagramPropertySet->setPropertyValue( UPDOWN, uno::makeAny((_nChartType == xlStockOHLC) || (_nChartType == xlStockVOHLC)));
 294             mxDiagramPropertySet->setPropertyValue( VOLUME, uno::makeAny((_nChartType == xlStockVHLC) || (_nChartType == xlStockVOHLC)));
 295             break;
 296
 297         case xlPieOfPie:                            // not possible
 298         case xlPieExploded: // SegmentOffset an ChartDataPointProperties ->am XDiagram abholen //wie macht Excel das?
 299         case xl3DPieExploded:
 300         case xl3DPie:
 301         case xlPie:
 302         case xlBarOfPie:                            // not possible (Zoom pie)
 303             setDiagram( OUString("com.sun.star.chart.PieDiagram"));
 304             break;
 305
 306         case xlRadar:
 307         case xlRadarMarkers:
 308         case xlRadarFilled:
 309             setDiagram( OUString("com.sun.star.chart.NetDiagram"));
 310             break;
 311         case xlXYScatter:
 312         case xlBubble:                      // not possible
 313         case xlBubble3DEffect:              // not possible
 314         case xlXYScatterLines:
 315         case xlXYScatterLinesNoMarkers:
 316         case xlXYScatterSmooth:
 317         case xlXYScatterSmoothNoMarkers:
 318             setDiagram( OUString("com.sun.star.chart.XYDiagram"));
 319             switch(_nChartType)
 320             {
 321                 case xlXYScatter:
 322                 case xlBubble:                      // not possible
 323                 case xlBubble3DEffect:              // not possible
 324                     mxDiagramPropertySet->setPropertyValue(LINES, uno::makeAny( sal_False ));
 325                     break;
 326                 case xlXYScatterLines:
 327                 case xlXYScatterLinesNoMarkers:
 328                     mxDiagramPropertySet->setPropertyValue(LINES, uno::makeAny( sal_True ));
 329                     break;
 330                 case xlXYScatterSmooth:
 331                 case xlXYScatterSmoothNoMarkers:
 332                     mxDiagramPropertySet->setPropertyValue(SPLINETYPE, uno::makeAny( sal_Int32(1)));
 333                     break;
 334                 default:
 335                     break;
 336             }
 337             break;
 338         default:
 339             throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_CONVERSION, OUString() );
 340     }
 341
 342     switch (_nChartType)
 343     {
 344         case xlLineMarkers:
 345         case xlLineMarkersStacked:
 346         case xlLineMarkersStacked100:
 347         case xlRadarMarkers:
 348         case xlXYScatterLines:
 349         case xlXYScatterSmooth:
 350         case xlXYScatter:
 351         case xlBubble:                      // not possible
 352         case xlBubble3DEffect:              // not possible
 353             mxDiagramPropertySet->setPropertyValue(SYMBOLTYPE, uno::makeAny( chart::ChartSymbolType::AUTO));
 354             break;
 355         default:
 356             if (mxDiagramPropertySet->getPropertySetInfo()->hasPropertyByName(SYMBOLTYPE))
 357             {
 358                 mxDiagramPropertySet->setPropertyValue(SYMBOLTYPE, uno::makeAny(chart::ChartSymbolType::NONE));
 359             }
 360             break;
 361     }
 362
 363     switch (_nChartType)
 364     {
 365         case xlConeCol:
 366         case xlPyramidCol:
 367         case xlCylinderCol:
 368         case xl3DColumn:
 369         case xlSurface:                         // not possible
 370         case xlSurfaceWireframe:
 371         case xlSurfaceTopView:
 372         case xlSurfaceTopViewWireframe:
 373             mxDiagramPropertySet->setPropertyValue(DEEP,uno::makeAny( sal_True ));
 374             break;
 375         default:
 376                 if (mxDiagramPropertySet->getPropertySetInfo()->hasPropertyByName(DEEP))
 377                 {
 378                     mxDiagramPropertySet->setPropertyValue(DEEP, uno::makeAny( sal_False));
 379                 }
 380                 break;
 381         }
 382
 383         switch (_nChartType)
 384         {
 385                 case xlConeColClustered:
 386                 case xlConeColStacked:
 387                 case xlConeColStacked100:
 388                 case xlConeBarClustered:
 389                 case xlConeBarStacked:
 390                 case xlConeBarStacked100:
 391                 case xlConeCol:
 392                         mxDiagramPropertySet->setPropertyValue(SOLIDTYPE, uno::makeAny(chart::ChartSolidType::CONE));
 393                         break;
 394                 case xlPyramidColClustered:
 395                 case xlPyramidColStacked:
 396                 case xlPyramidColStacked100:
 397                 case xlPyramidBarClustered:
 398                 case xlPyramidBarStacked:
 399                 case xlPyramidBarStacked100:
 400                 case xlPyramidCol:
 401                         mxDiagramPropertySet->setPropertyValue(SOLIDTYPE, uno::makeAny(chart::ChartSolidType::PYRAMID));
 402                         break;
 403                 case xlCylinderColClustered:
 404                 case xlCylinderColStacked:
 405                 case xlCylinderColStacked100:
 406                 case xlCylinderBarClustered:
 407                 case xlCylinderBarStacked:
 408                 case xlCylinderBarStacked100:
 409                 case xlCylinderCol:
 410                         mxDiagramPropertySet->setPropertyValue(SOLIDTYPE, uno::makeAny(chart::ChartSolidType::CYLINDER));
 411                         break;
 412                 default:
 413                     if (mxDiagramPropertySet->getPropertySetInfo()->hasPropertyByName(SOLIDTYPE))
 414                     {
 415                             mxDiagramPropertySet->setPropertyValue(SOLIDTYPE, uno::makeAny(chart::ChartSolidType::RECTANGULAR_SOLID));
 416                     }
 417                     break;
 418         }
 419
 420         switch ( _nChartType)
 421         {
 422             case xlConeCol:
 423             case xlConeColClustered:
 424             case xlConeColStacked:
 425             case xlConeColStacked100:
 426             case xlPyramidColClustered:
 427             case xlPyramidColStacked:
 428             case xlPyramidColStacked100:
 429             case xlCylinderColClustered:
 430             case xlCylinderColStacked:
 431             case xlCylinderColStacked100:
 432             case xlColumnClustered:
 433             case xlColumnStacked:
 434             case xlColumnStacked100:
 435             case xl3DColumnClustered:
 436             case xl3DColumnStacked:
 437             case xl3DColumnStacked100:
 438             case xlSurface: // not possible
 439             case xlSurfaceWireframe:
 440             case xlSurfaceTopView:
 441             case xlSurfaceTopViewWireframe:
 442                 mxDiagramPropertySet->setPropertyValue(VERTICAL, uno::makeAny( sal_True));
 443                 break;
 444             default:
 445                 if (mxDiagramPropertySet->getPropertySetInfo()->hasPropertyByName(VERTICAL))
 446                 {
 447                     mxDiagramPropertySet->setPropertyValue(VERTICAL, uno::makeAny(sal_False));
 448                 }
 449                 break;
 450         }
 451
 452         switch (_nChartType)
 453         {
 454             case xlColumnStacked:
 455             case xl3DColumnStacked:
 456             case xlBarStacked:
 457             case xl3DBarStacked:
 458             case xlLineStacked:
 459             case xlLineMarkersStacked:
 460             case xlAreaStacked:
 461             case xl3DAreaStacked:
 462             case xlCylinderColStacked:
 463             case xlCylinderBarStacked:
 464             case xlConeColStacked:
 465             case xlConeBarStacked:
 466             case xlPyramidColStacked:
 467             case xlPyramidBarStacked:
 468                 mxDiagramPropertySet->setPropertyValue(PERCENT, uno::makeAny( sal_False ));
 469                 mxDiagramPropertySet->setPropertyValue(STACKED, uno::makeAny( sal_True ));
 470                 break;
 471             case xlPyramidColStacked100:
 472             case xlPyramidBarStacked100:
 473             case xlConeColStacked100:
 474             case xlConeBarStacked100:
 475             case xlCylinderBarStacked100:
 476             case xlCylinderColStacked100:
 477             case xl3DAreaStacked100:
 478             case xlLineMarkersStacked100:
 479             case xlAreaStacked100:
 480             case xlLineStacked100:
 481             case xl3DBarStacked100:
 482             case xlBarStacked100:
 483             case xl3DColumnStacked100:
 484             case xlColumnStacked100:
 485                 mxDiagramPropertySet->setPropertyValue(STACKED, uno::makeAny( sal_True));
 486                 mxDiagramPropertySet->setPropertyValue(PERCENT, uno::makeAny( sal_True ));
 487                 break;
 488             default:
 489                 mxDiagramPropertySet->setPropertyValue(PERCENT, uno::makeAny( sal_False));
 490                 mxDiagramPropertySet->setPropertyValue(STACKED, uno::makeAny( sal_False));
 491                 break;
 492         }
 493         switch (_nChartType)
 494         {
 495             case xl3DArea:
 496             case xl3DAreaStacked:
 497             case xl3DAreaStacked100:
 498             case xl3DBarClustered:
 499             case xl3DBarStacked:
 500             case xl3DBarStacked100:
 501             case xl3DColumn:
 502             case xl3DColumnClustered:
 503             case xl3DColumnStacked:
 504             case xl3DColumnStacked100:
 505             case xl3DLine:
 506             case xl3DPie:
 507             case xl3DPieExploded:
 508             case xlConeColClustered:
 509             case xlConeColStacked:
 510             case xlConeColStacked100:
 511             case xlConeBarClustered:
 512             case xlConeBarStacked:
 513             case xlConeBarStacked100:
 514             case xlConeCol:
 515             case xlPyramidColClustered:
 516             case xlPyramidColStacked:
 517             case xlPyramidColStacked100:
 518             case xlPyramidBarClustered:
 519             case xlPyramidBarStacked:
 520             case xlPyramidBarStacked100:
 521             case xlPyramidCol:
 522             case xlCylinderColClustered:
 523             case xlCylinderColStacked:
 524             case xlCylinderColStacked100:
 525             case xlCylinderBarClustered:
 526             case xlCylinderBarStacked:
 527             case xlCylinderBarStacked100:
 528             case xlCylinderCol:
 529                 mxDiagramPropertySet->setPropertyValue(DIM3D, uno::makeAny( sal_True));
 530                 break;
 531             default:
 532                 if (mxDiagramPropertySet->getPropertySetInfo()->hasPropertyByName(DIM3D))
 533                 {
 534                     mxDiagramPropertySet->setPropertyValue(DIM3D, uno::makeAny( sal_False));
 535                 }
 536                 break;
 537         }
 538     }
 539     catch ( const uno::Exception& )
 540     {
 541         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 542     }
 543 }
 544
 545 void SAL_CALL
 546 ScVbaChart::Activate() throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 547 {
 548     // #TODO how are Chart sheets handled ( I know we don't even consider
 549     // them in the worksheets/sheets collections ), but.....???
 550     // note: in vba for excel the parent of a Chart sheet is a workbook,
 551     // e.g. 'ThisWorkbook'
 552     uno::Reference< XHelperInterface > xParent( getParent() );
 553     ScVbaChartObject* pChartObj = static_cast< ScVbaChartObject* >( xParent.get() );
 554     if ( pChartObj )
 555         pChartObj->Activate();
 556     else
 557         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString( "no ChartObject as parent" ) );
 558 }
 559
 560 void SAL_CALL
 561 ScVbaChart::setSourceData( const css::uno::Reference< ::ooo::vba::excel::XRange >& _xCalcRange, const css::uno::Any& _aPlotBy ) throw (css::script::BasicErrorException, css::uno::RuntimeException, std::exception)
 562 {
 563     try
 564     {
 565         uno::Sequence< table::CellRangeAddress > mRangeAddresses(1);
 566         table::CellRangeAddress mSingleRangeAddress;
 567
 568         uno::Reference< sheet::XCellRangeAddressable > xAddressable( _xCalcRange->getCellRange(), uno::UNO_QUERY_THROW );
 569         mSingleRangeAddress = xAddressable->getRangeAddress();
 570
 571         mRangeAddresses[0] = mSingleRangeAddress;
 572
 573         mxTableChart->setRanges(mRangeAddresses);
 574
 575         bool bsetRowHeaders = false;
 576         bool bsetColumnHeaders = false;
 577
 578         ScVbaRange* pRange = static_cast< ScVbaRange* >( _xCalcRange.get() );
 579         if ( pRange )
 580         {
 581             ScDocument& rDoc = pRange->getScDocument();
 582             bsetRowHeaders = rDoc.HasRowHeader(  static_cast< SCCOL >( mSingleRangeAddress.StartColumn ), static_cast< SCROW >( mSingleRangeAddress.StartRow ), static_cast< SCCOL >( mSingleRangeAddress.EndColumn ), static_cast< SCROW >( mSingleRangeAddress.EndRow ), static_cast< SCTAB >( mSingleRangeAddress.Sheet ) );
 583             bsetColumnHeaders = rDoc.HasColHeader(  static_cast< SCCOL >( mSingleRangeAddress.StartColumn ), static_cast< SCROW >( mSingleRangeAddress.StartRow ), static_cast< SCCOL >( mSingleRangeAddress.EndColumn ), static_cast< SCROW >( mSingleRangeAddress.EndRow ), static_cast< SCTAB >( mSingleRangeAddress.Sheet ));
 584         }
 585         mxTableChart->setHasRowHeaders(bsetRowHeaders);
 586         mxTableChart->setHasColumnHeaders(bsetColumnHeaders);
 587
 588         if ((!bsetColumnHeaders) || (!bsetRowHeaders))
 589         {
 590             uno::Reference< chart::XChartDataArray > xChartDataArray( mxChartDocument->getData(), uno::UNO_QUERY_THROW );
 591             if (!bsetColumnHeaders)
 592             {
 593                 xChartDataArray->setColumnDescriptions( getDefaultSeriesDescriptions(xChartDataArray->getColumnDescriptions().getLength() ));
 594             }
 595             if (!bsetRowHeaders)
 596             {
 597                 xChartDataArray->setRowDescriptions(getDefaultSeriesDescriptions(xChartDataArray->getRowDescriptions().getLength() ));
 598             }
 599         }
 600
 601         if ( _aPlotBy.hasValue() )
 602         {
 603             sal_Int32 nVal = 0;
 604             _aPlotBy >>= nVal;
 605             setPlotBy( nVal );
 606         }
 607         else
 608         {
 609             sal_Int32 nRows =  mSingleRangeAddress.EndRow - mSingleRangeAddress.StartRow;
 610             sal_Int32 nCols = mSingleRangeAddress.EndColumn - mSingleRangeAddress.StartColumn;
 611             // AutoDetect emulation
 612             if ( nRows > nCols )
 613                 setPlotBy( xlColumns );
 614             else if ( nRows <= nCols )
 615                 setPlotBy( xlRows );
 616         }
 617     }
 618     catch (const uno::Exception&)
 619     {
 620         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 621     }
 622 }
 623
 624 uno::Sequence< OUString >
 625 ScVbaChart::getDefaultSeriesDescriptions( sal_Int32 _nCount )
 626 {
 627     uno::Sequence< OUString > sDescriptions ( _nCount );
 628     sal_Int32 nLen = sDescriptions.getLength();
 629     for (sal_Int32 i = 0; i < nLen; i++)
 630     {
 631         sDescriptions[i] = DEFAULTSERIESPREFIX + OUString::number(i+1);
 632     }
 633     return sDescriptions;
 634 }
 635
 636 void
 637 ScVbaChart::setDefaultChartType() throw ( script::BasicErrorException )
 638 {
 639     setChartType( xlColumnClustered );
 640 }
 641
 642 void
 643 ScVbaChart::setPlotBy( ::sal_Int32 _nPlotBy ) throw (css::script::BasicErrorException, css::uno::RuntimeException, std::exception)
 644 {
 645     try
 646     {
 647         if ( !mxDiagramPropertySet.is() )
 648             setDefaultChartType();
 649         switch (_nPlotBy)
 650         {
 651             case xlRows:
 652                 mxDiagramPropertySet->setPropertyValue( DATAROWSOURCE,  uno::makeAny( chart::ChartDataRowSource_ROWS ) );
 653                 break;
 654             case xlColumns:
 655                 mxDiagramPropertySet->setPropertyValue( DATAROWSOURCE, uno::makeAny( chart::ChartDataRowSource_COLUMNS) );
 656                 break;
 657             default:
 658                 throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 659         }
 660     }
 661     catch (const uno::Exception&)
 662     {
 663         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 664     }
 665 }
 666
 667 ::sal_Int32 SAL_CALL
 668 ScVbaChart::getPlotBy(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 669 {
 670     try
 671     {
 672         chart::ChartDataRowSource aChartDataRowSource;
 673         mxDiagramPropertySet->getPropertyValue(DATAROWSOURCE) >>= aChartDataRowSource;
 674         if (aChartDataRowSource == chart::ChartDataRowSource_COLUMNS)
 675         {
 676             return xlColumns;
 677         }
 678         else
 679         {
 680             return xlRows;
 681         }
 682     }
 683     catch (const uno::Exception&)
 684     {
 685         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 686     }
 687 }
 688
 689 void
 690 ScVbaChart::setDiagram( const OUString& _sDiagramType ) throw( script::BasicErrorException )
 691 {
 692     try
 693     {
 694         uno::Reference< lang::XMultiServiceFactory > xMSF( mxChartDocument, uno::UNO_QUERY_THROW );
 695         uno::Reference< chart::XDiagram > xDiagram( xMSF->createInstance( _sDiagramType ), uno::UNO_QUERY_THROW  );
 696         mxChartDocument->setDiagram( xDiagram );
 697         mxDiagramPropertySet.set( xDiagram, uno::UNO_QUERY_THROW );
 698     }
 699     catch ( const uno::Exception& )
 700     {
 701         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 702     }
 703 }
 704
 705 // #TODO find out why we have Location/getLocation ? there is afaiks no
 706 // Location property, just a Location function for the Chart object
 707 sal_Int32 SAL_CALL
 708 ScVbaChart::Location() throw (css::script::BasicErrorException, css::uno::RuntimeException, std::exception)
 709 {
 710     return getLocation();
 711 }
 712
 713 sal_Int32 SAL_CALL
 714 ScVbaChart::getLocation() throw (css::script::BasicErrorException, css::uno::RuntimeException, std::exception)
 715 {
 716      return -1;
 717 }
 718
 719 void SAL_CALL
 720 ScVbaChart::setLocation( ::sal_Int32 /*where*/, const css::uno::Any& /*Name*/ ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 721 {
 722     // Helper api just stubs out the code <shrug>
 723     // #TODO come back and make sense out of this
 724 //        String sheetName = null;
 725 //
 726 //        if ((name != null) && name instanceof String) {
 727 //            sheetName = (String) name;
 728 //        }
 729 //        XSpreadsheetDocument xShDoc = (XSpreadsheetDocument) UnoRuntime.queryInterface( XSpreadsheetDocument.class,getXModel() );
 730 //        com.sun.star.sheet.XSpreadsheets xSheets = xShDoc.Sheets();
 731 //
 732 //        switch (where) {
 733 //        case ClLocationType.clLocationAsObject_value: //{
 734 //
 735 //            if (sheetName == null) {
 736 //                DebugHelper.writeInfo("Can't embed in Chart without knowing SheetName");
 737 //                return;
 738 //            }
 739 //
 740 //            try {
 741 //                Any any = (Any) xSheets.getByName(sheetName);
 742 //                chartSheet = (XSpreadsheet) any.getObject();
 743 //
 744 //                // chartSheet = (XSpreadsheet) xSheets.getByName( sheetName );
 745 //            } catch (NoSuchElementException e) {
 746 //                // TODO Auto-generated catch block
 747 //                e.printStackTrace();
 748 //
 749 //                return;
 750 //            } catch (WrappedTargetException e) {
 751 //                // TODO Auto-generated catch block
 752 //                e.printStackTrace();
 753 //
 754 //                return;
 755 //            } catch (java.lang.Exception e) {
 756 //                e.printStackTrace();
 757 //            }
 758 //
 759 //            XTableChartsSupplier xTCS = (XTableChartsSupplier) UnoRuntime.queryInterface( XTableChartsSupplier.class, chartSheet);
 760 //            XTableCharts xTableCharts = xTCS.getCharts();
 761 //            XIndexAccess xIA = (XIndexAccess) UnoRuntime.queryInterface( XIndexAccess.class, xTableCharts);
 762 //            int numCharts = xIA.getCount();
 763 //            chartName = "Chart " + (numCharts + 1);
 764 //
 765 //            //}
 766 //            break;
 767 //
 768 //        case ClLocationType.clLocationAsNewSheet_value:
 769 //        case ClLocationType.clLocationAutomatic_value:default: //{
 770 //            chartName = "Chart 1"; // Since it's a new sheet, it's the first on it...
 771 //
 772 //            XIndexAccess xSheetIA = (XIndexAccess) UnoRuntime.queryInterface( XIndexAccess.class, xSheets);
 773 //
 774 //            short newSheetNum = (short) (xSheetIA.getCount() + 1);
 775 //
 776 //            if (sheetName == null){
 777 //                sheetName = "ChartSheet " + newSheetNum; // Why not?
 778 //            }
 779 //            // DPK TODO : Probably should use Sheets to create this!
 780 //            xSheets.insertNewByName(sheetName, newSheetNum);
 781 //
 782 //            try {
 783 //                chartSheet =
 784 //                    (XSpreadsheet) xSheets.getByName(sheetName);
 785 //            } catch (NoSuchElementException e) {
 786 //                // TODO Auto-generated catch block
 787 //                e.printStackTrace();
 788 //
 789 //                return;
 790 //            } catch (WrappedTargetException e) {
 791 //                // TODO Auto-generated catch block
 792 //                e.printStackTrace();
 793 //
 794 //                return;
 795 //            }
 796 //
 797 //            //}
 798 //            break;
 799 //        }
 800 //
 801 //        // Last thing should be a call to createChartForReal(), one of them
 802 //        // should succeed.
 803 //        createChartForReal();
 804
 805 }
 806
 807 sal_Bool SAL_CALL
 808 ScVbaChart::getHasTitle(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 809 {
 810     bool bHasTitle = false;
 811     try
 812     {
 813         mxChartPropertySet->getPropertyValue(HASMAINTITLE) >>= bHasTitle;
 814     }
 815     catch (const uno::Exception&)
 816     {
 817         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 818     }
 819     return bHasTitle;
 820 }
 821
 822 void SAL_CALL
 823 ScVbaChart::setHasTitle( sal_Bool bTitle ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 824 {
 825     try
 826     {
 827         mxChartPropertySet->setPropertyValue(HASMAINTITLE, uno::makeAny( bTitle ));
 828     }
 829     catch (const uno::Exception&)
 830     {
 831         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 832     }
 833
 834 }
 835
 836 sal_Bool SAL_CALL
 837 ScVbaChart::getHasLegend(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 838 {
 839     bool bHasLegend = false;
 840     try
 841     {
 842         mxChartPropertySet->getPropertyValue(HASLEGEND) >>= bHasLegend;
 843     }
 844     catch (const uno::Exception&)
 845     {
 846         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 847     }
 848     return bHasLegend;
 849 }
 850
 851 void SAL_CALL
 852 ScVbaChart::setHasLegend( sal_Bool bLegend ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 853 {
 854     try
 855     {
 856         mxChartPropertySet->setPropertyValue(HASLEGEND, uno::makeAny(bLegend));
 857     }
 858     catch (const uno::Exception&)
 859     {
 860         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 861     }
 862 }
 863
 864 uno::Reference< excel::XChartTitle > SAL_CALL
 865 ScVbaChart::getChartTitle(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 866 {
 867     uno::Reference< drawing::XShape > xTitleShape = mxChartDocument->getTitle();
 868     // #TODO check parent
 869     return new ScVbaChartTitle(this, mxContext, xTitleShape);
 870 }
 871
 872 uno::Any SAL_CALL
 873 ScVbaChart::Axes( const uno::Any& Type, const uno::Any& AxisGroup ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
 874 {
 875     // mmm chart probably is the parent, #TODO check parent
 876     uno::Reference< excel::XAxes > xAxes = new ScVbaAxes( this, mxContext, this );
 877     if ( !Type.hasValue() )
 878         return uno::makeAny( xAxes );
 879     return xAxes->Item( Type, AxisGroup );
 880 }
 881 bool
 882 ScVbaChart::is3D() throw ( uno::RuntimeException )
 883 {
 884     // #TODO perhaps provide limited Debughelper functionality
 885     bool is3d = false;
 886     mxDiagramPropertySet->getPropertyValue(DIM3D) >>= is3d;
 887     return is3d;
 888 }
 889
 890 sal_Int32
 891 ScVbaChart::getStackedType( sal_Int32 _nStacked, sal_Int32 _n100PercentStacked, sal_Int32 _nUnStacked ) throw ( uno::RuntimeException )
 892 {
 893     // #TODO perhaps provide limited Debughelper functionality
 894     if (isStacked())
 895     {
 896         if (is100PercentStacked())
 897             return _n100PercentStacked;
 898         else
 899             return _nStacked;
 900     }
 901     else
 902         return _nUnStacked;
 903 }
 904
 905 bool
 906 ScVbaChart::isStacked() throw ( uno::RuntimeException )
 907 {
 908     // #TODO perhaps provide limited Debughelper functionality
 909     bool bStacked = false;
 910     mxDiagramPropertySet->getPropertyValue(STACKED) >>= bStacked;
 911     return bStacked;
 912 }
 913
 914 bool
 915 ScVbaChart::is100PercentStacked() throw ( uno::RuntimeException )
 916 {
 917     // #TODO perhaps provide limited Debughelper functionality
 918     bool b100Percent = false;
 919     mxDiagramPropertySet->getPropertyValue(PERCENT) >>= b100Percent;
 920     return b100Percent;
 921 }
 922
 923 sal_Int32
 924 ScVbaChart::getSolidType(sal_Int32 _nDeep, sal_Int32 _nVertiStacked, sal_Int32 _nVerti100PercentStacked, sal_Int32 _nVertiUnStacked, sal_Int32 _nHoriStacked, sal_Int32 _nHori100PercentStacked, sal_Int32 _nHoriUnStacked) throw ( script::BasicErrorException )
 925 {
 926     try
 927     {
 928         bool bIsVertical = true;
 929         mxDiagramPropertySet->getPropertyValue(VERTICAL) >>= bIsVertical;
 930         bool bIsDeep = false;
 931         mxDiagramPropertySet->getPropertyValue(DEEP) >>= bIsDeep;
 932
 933         if (bIsDeep)
 934         {
 935             return _nDeep;
 936         }
 937         else
 938         {
 939             if (bIsVertical)
 940             {
 941                 return getStackedType(_nVertiStacked, _nVerti100PercentStacked, _nVertiUnStacked);
 942             }
 943             else
 944             {
 945                 return getStackedType(_nHoriStacked, _nHori100PercentStacked, _nHoriUnStacked);
 946             }
 947         }
 948     }
 949     catch (const uno::Exception&)
 950     {
 951         throw script::BasicErrorException( OUString(), uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 952     }
 953 }
 954
 955 sal_Int32
 956 ScVbaChart::getStockUpDownValue(sal_Int32 _nUpDown, sal_Int32 _nNotUpDown) throw (script::BasicErrorException)
 957 {
 958     try
 959     {
 960         bool bUpDown = false;
 961         mxDiagramPropertySet->getPropertyValue(UPDOWN) >>= bUpDown;
 962         if (bUpDown)
 963         {
 964             return _nUpDown;
 965         }
 966         else
 967         {
 968             return _nNotUpDown;
 969         }
 970     }
 971     catch (const uno::Exception&)
 972     {
 973         OUString aTemp;    // temporary needed for g++ 3.3.5
 974         script::BasicErrorException( aTemp, uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 975     }
 976     return _nNotUpDown;
 977 }
 978
 979 bool
 980 ScVbaChart::hasMarkers() throw ( script::BasicErrorException )
 981 {
 982     bool bHasMarkers = false;
 983     try
 984     {
 985         sal_Int32 nSymbol=0;
 986         mxDiagramPropertySet->getPropertyValue(SYMBOLTYPE) >>= nSymbol;
 987         bHasMarkers = nSymbol != chart::ChartSymbolType::NONE;
 988     }
 989     catch (const uno::Exception&)
 990     {
 991         OUString aTemp;    // temporary needed for g++ 3.3.5
 992         script::BasicErrorException( aTemp, uno::Reference< uno::XInterface >(), SbERR_METHOD_FAILED, OUString() );
 993     }
 994     return bHasMarkers;
 995 }
 996
 997 sal_Int32
 998 ScVbaChart::getMarkerType(sal_Int32 _nWithMarkers, sal_Int32 _nWithoutMarkers) throw ( script::BasicErrorException )
 999 {
1000     if (hasMarkers())
1001         return _nWithMarkers;
1002     return _nWithoutMarkers;
1003 }
1004
1005 void
1006 ScVbaChart::assignDiagramAttributes()
1007 {
1008     xAxisXSupplier.set( mxDiagramPropertySet, uno::UNO_QUERY_THROW );
1009     xAxisYSupplier.set( mxDiagramPropertySet, uno::UNO_QUERY_THROW );
1010     xAxisZSupplier.set( mxDiagramPropertySet, uno::UNO_QUERY_THROW );
1011     xTwoAxisXSupplier.set( mxDiagramPropertySet, uno::UNO_QUERY_THROW );
1012     xTwoAxisYSupplier.set( mxDiagramPropertySet, uno::UNO_QUERY_THROW );
1013 }
1014
1015 uno::Reference< beans::XPropertySet >
1016 ScVbaChart::getAxisPropertySet(sal_Int32 _nAxisType, sal_Int32 _nAxisGroup) throw ( script::BasicErrorException, uno::RuntimeException )
1017 {
1018     assignDiagramAttributes();
1019     uno::Reference< beans::XPropertySet > xAxisProps;
1020     switch(_nAxisType)
1021     {
1022         case xlCategory:
1023             if (_nAxisGroup == xlPrimary)
1024             {
1025                 xAxisProps = xAxisXSupplier->getXAxis();
1026             }
1027             else if (_nAxisGroup == xlSecondary)
1028             {
1029                 xAxisProps = xTwoAxisXSupplier->getSecondaryXAxis();
1030             }
1031             break;
1032         case xlSeriesAxis:
1033             xAxisProps = xAxisZSupplier->getZAxis();
1034             break;
1035         case xlValue:
1036             if (_nAxisGroup == xlPrimary)
1037                 xAxisProps = xAxisYSupplier->getYAxis();
1038             else if (_nAxisGroup == xlSecondary)
1039                 xAxisProps = xTwoAxisYSupplier->getSecondaryYAxis();
1040             break;
1041         default:
1042             return xAxisProps;
1043         }
1044     return xAxisProps;
1045 }
1046
1047 OUString
1048 ScVbaChart::getServiceImplName()
1049 {
1050     return OUString("ScVbaChart");
1051 }
1052
1053 uno::Sequence< OUString >
1054 ScVbaChart::getServiceNames()
1055 {
1056     static uno::Sequence< OUString > aServiceNames;
1057     if ( aServiceNames.getLength() == 0 )
1058     {
1059         aServiceNames.realloc( 1 );
1060         aServiceNames[ 0 ] = "ooo.vba.excel.Chart";
1061     }
1062     return aServiceNames;
1063 }
1064
1065 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */