LCOV - code coverage report
Current view: top level - libreoffice/chart2/source/controller/main - ChartController_Properties.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 1 349 0.3 %
Date: 2012-12-27 Functions: 2 14 14.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "ChartController.hxx"
      21             : #include "ChartWindow.hxx"
      22             : #include "chartview/DrawModelWrapper.hxx"
      23             : #include "ObjectIdentifier.hxx"
      24             : #include "chartview/ExplicitValueProvider.hxx"
      25             : #include "macros.hxx"
      26             : #include "dlg_ObjectProperties.hxx"
      27             : #include "dlg_View3D.hxx"
      28             : #include "dlg_InsertErrorBars.hxx"
      29             : #include "ViewElementListProvider.hxx"
      30             : #include "DataPointItemConverter.hxx"
      31             : #include "AxisItemConverter.hxx"
      32             : #include "MultipleChartConverters.hxx"
      33             : #include "TitleItemConverter.hxx"
      34             : #include "LegendItemConverter.hxx"
      35             : #include "RegressionCurveItemConverter.hxx"
      36             : #include "RegressionEquationItemConverter.hxx"
      37             : #include "ErrorBarItemConverter.hxx"
      38             : #include "ChartModelHelper.hxx"
      39             : #include "AxisHelper.hxx"
      40             : #include "TitleHelper.hxx"
      41             : #include "LegendHelper.hxx"
      42             : #include "ChartTypeHelper.hxx"
      43             : #include "ColorPerPointHelper.hxx"
      44             : #include "DiagramHelper.hxx"
      45             : #include "servicenames_charttypes.hxx"
      46             : #include "ControllerLockGuard.hxx"
      47             : #include "UndoGuard.hxx"
      48             : #include "ObjectNameProvider.hxx"
      49             : #include "ResId.hxx"
      50             : #include "Strings.hrc"
      51             : #include "ReferenceSizeProvider.hxx"
      52             : #include "RegressionCurveHelper.hxx"
      53             : #include <com/sun/star/chart2/XChartDocument.hpp>
      54             : 
      55             : //for auto_ptr
      56             : #include <memory>
      57             : 
      58             : // header for define RET_OK
      59             : #include <vcl/msgbox.hxx>
      60             : // for SolarMutex
      61             : #include <vcl/svapp.hxx>
      62             : #include <osl/mutex.hxx>
      63             : #include <svx/ActionDescriptionProvider.hxx>
      64             : 
      65             : //.............................................................................
      66             : namespace chart
      67             : {
      68             : //.............................................................................
      69             : using namespace ::com::sun::star;
      70             : using namespace ::com::sun::star::chart2;
      71             : using ::com::sun::star::uno::Reference;
      72             : using ::rtl::OUString;
      73             : 
      74             : namespace
      75             : {
      76             : 
      77             : SAL_WNODEPRECATED_DECLARATIONS_PUSH
      78           0 : ::comphelper::ItemConverter* createItemConverter(
      79             :     const ::rtl::OUString & aObjectCID
      80             :     , const uno::Reference< frame::XModel > & xChartModel
      81             :     , const uno::Reference< uno::XComponentContext > & xContext
      82             :     , SdrModel & rDrawModel
      83             :     , ExplicitValueProvider * pExplicitValueProvider = NULL
      84             :     , ::std::auto_ptr< ReferenceSizeProvider > pRefSizeProvider =
      85             :           ::std::auto_ptr< ReferenceSizeProvider >()
      86             :     )
      87             : {
      88           0 :     ::comphelper::ItemConverter* pItemConverter=NULL;
      89             : 
      90             :     //-------------------------------------------------------------
      91             :     //get type of selected object
      92           0 :     ObjectType eObjectType = ObjectIdentifier::getObjectType( aObjectCID );
      93           0 :     if( OBJECTTYPE_UNKNOWN==eObjectType )
      94             :     {
      95             :         OSL_FAIL("unknown ObjectType");
      96           0 :         return NULL;
      97             :     }
      98             : 
      99           0 :     rtl::OUString aParticleID = ObjectIdentifier::getParticleID( aObjectCID );
     100           0 :     bool bAffectsMultipleObjects = aParticleID.equals(C2U("ALLELEMENTS"));
     101             :     //-------------------------------------------------------------
     102           0 :     if( !bAffectsMultipleObjects )
     103             :     {
     104             :         uno::Reference< beans::XPropertySet > xObjectProperties =
     105           0 :             ObjectIdentifier::getObjectPropertySet( aObjectCID, xChartModel );
     106           0 :         if(!xObjectProperties.is())
     107           0 :             return NULL;
     108             :         //create itemconverter for a single object
     109           0 :         switch(eObjectType)
     110             :         {
     111             :             case OBJECTTYPE_PAGE:
     112             :                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
     113             :                                         xObjectProperties, rDrawModel.GetItemPool(),
     114             :                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     115           0 :                                         wrapper::GraphicPropertyItemConverter::LINE_AND_FILL_PROPERTIES );
     116           0 :                     break;
     117             :             case OBJECTTYPE_TITLE:
     118             :             {
     119           0 :                 ::std::auto_ptr< awt::Size > pRefSize;
     120           0 :                 if( pRefSizeProvider.get() )
     121           0 :                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
     122             : 
     123             :                 pItemConverter = new wrapper::TitleItemConverter( xObjectProperties,
     124             :                                                                   rDrawModel.GetItemPool(), rDrawModel,
     125             :                                                                   uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     126           0 :                                                                   pRefSize );
     127             :             }
     128           0 :             break;
     129             :             case OBJECTTYPE_LEGEND:
     130             :             {
     131           0 :                 ::std::auto_ptr< awt::Size > pRefSize;
     132           0 :                 if( pRefSizeProvider.get() )
     133           0 :                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
     134             : 
     135             :                 pItemConverter = new wrapper::LegendItemConverter( xObjectProperties,
     136             :                                                                    rDrawModel.GetItemPool(), rDrawModel,
     137             :                                                                    uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     138           0 :                                                                    pRefSize );
     139             :             }
     140           0 :             break;
     141             :             case OBJECTTYPE_LEGEND_ENTRY:
     142           0 :                     break;
     143             :             case OBJECTTYPE_DIAGRAM:
     144           0 :                     break;
     145             :             case OBJECTTYPE_DIAGRAM_WALL:
     146             :             case OBJECTTYPE_DIAGRAM_FLOOR:
     147             :                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
     148             :                                         xObjectProperties, rDrawModel.GetItemPool(),
     149             :                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     150           0 :                                         wrapper::GraphicPropertyItemConverter::LINE_AND_FILL_PROPERTIES );
     151           0 :                     break;
     152             :             case OBJECTTYPE_AXIS:
     153             :             {
     154           0 :                 ::std::auto_ptr< awt::Size > pRefSize;
     155           0 :                 if( pRefSizeProvider.get() )
     156           0 :                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
     157             : 
     158           0 :                 uno::Reference< beans::XPropertySet > xDiaProp;
     159           0 :                 xDiaProp.set( ChartModelHelper::findDiagram( xChartModel ), uno::UNO_QUERY );
     160             : 
     161             :                 // the second property set contains the property CoordinateOrigin
     162             :                 // nOriginIndex is the index of the corresponding index of the
     163             :                 // origin (x=0, y=1, z=2)
     164             : 
     165           0 :                 ExplicitScaleData aExplicitScale;
     166           0 :                 ExplicitIncrementData aExplicitIncrement;
     167           0 :                 if( pExplicitValueProvider )
     168             :                     pExplicitValueProvider->getExplicitValuesForAxis(
     169             :                         uno::Reference< XAxis >( xObjectProperties, uno::UNO_QUERY ),
     170           0 :                         aExplicitScale, aExplicitIncrement );
     171             : 
     172             :                 pItemConverter =  new wrapper::AxisItemConverter(
     173             :                     xObjectProperties, rDrawModel.GetItemPool(),
     174             :                     rDrawModel,
     175             :                     uno::Reference< chart2::XChartDocument >( xChartModel, uno::UNO_QUERY ),
     176             :                     &aExplicitScale, &aExplicitIncrement,
     177           0 :                     pRefSize );
     178             :             }
     179           0 :             break;
     180             :             case OBJECTTYPE_AXIS_UNITLABEL:
     181           0 :                     break;
     182             :             case OBJECTTYPE_DATA_LABELS:
     183             :             case OBJECTTYPE_DATA_SERIES:
     184             :             case OBJECTTYPE_DATA_LABEL:
     185             :             case OBJECTTYPE_DATA_POINT:
     186             :             {
     187           0 :                 ::std::auto_ptr< awt::Size > pRefSize;
     188           0 :                 if( pRefSizeProvider.get() )
     189           0 :                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
     190             : 
     191             :                 wrapper::GraphicPropertyItemConverter::eGraphicObjectType eMapTo =
     192           0 :                     wrapper::GraphicPropertyItemConverter::FILLED_DATA_POINT;
     193             : 
     194           0 :                 uno::Reference< XDataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( aObjectCID, xChartModel );
     195           0 :                 uno::Reference< XChartType > xChartType = ChartModelHelper::getChartTypeOfSeries( xChartModel, xSeries );
     196             : 
     197           0 :                 uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
     198           0 :                 sal_Int32 nDimensionCount = DiagramHelper::getDimension( xDiagram );
     199           0 :                 if( !ChartTypeHelper::isSupportingAreaProperties( xChartType, nDimensionCount ) )
     200           0 :                     eMapTo = wrapper::GraphicPropertyItemConverter::LINE_DATA_POINT;
     201             : 
     202           0 :                 bool bDataSeries = ( eObjectType == OBJECTTYPE_DATA_SERIES || eObjectType == OBJECTTYPE_DATA_LABELS );
     203             : 
     204             :                 //special color for pie chart:
     205           0 :                 bool bUseSpecialFillColor = false;
     206           0 :                 sal_Int32 nSpecialFillColor =0;
     207           0 :                 sal_Int32 nPointIndex = -1; /*-1 for whole series*/
     208           0 :                 if(!bDataSeries)
     209             :                 {
     210           0 :                     nPointIndex = aParticleID.toInt32();
     211           0 :                     uno::Reference< beans::XPropertySet > xSeriesProp( xSeries, uno::UNO_QUERY );
     212           0 :                     bool bVaryColorsByPoint = false;
     213           0 :                     if( xSeriesProp.is() &&
     214           0 :                         (xSeriesProp->getPropertyValue(C2U("VaryColorsByPoint")) >>= bVaryColorsByPoint) &&
     215             :                         bVaryColorsByPoint )
     216             :                     {
     217           0 :                         if( !ColorPerPointHelper::hasPointOwnColor( xSeriesProp, nPointIndex, xObjectProperties ) )
     218             :                         {
     219           0 :                             bUseSpecialFillColor = true;
     220             :                             OSL_ASSERT( xDiagram.is());
     221           0 :                             uno::Reference< XColorScheme > xColorScheme( xDiagram->getDefaultColorScheme() );
     222           0 :                             if( xColorScheme.is())
     223           0 :                                 nSpecialFillColor = xColorScheme->getColorByIndex( nPointIndex );
     224             :                         }
     225           0 :                     }
     226             :                 }
     227           0 :                 sal_Int32 nNumberFormat=ExplicitValueProvider::getExplicitNumberFormatKeyForDataLabel( xObjectProperties, xSeries, nPointIndex, xDiagram );
     228             :                 sal_Int32 nPercentNumberFormat=ExplicitValueProvider::getExplicitPercentageNumberFormatKeyForDataLabel(
     229           0 :                         xObjectProperties,uno::Reference< util::XNumberFormatsSupplier >(xChartModel, uno::UNO_QUERY));
     230             : 
     231             :                 pItemConverter =  new wrapper::DataPointItemConverter( xChartModel, xContext,
     232             :                                         xObjectProperties, xSeries, rDrawModel.GetItemPool(), rDrawModel,
     233             :                                         uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     234             :                                         eMapTo, pRefSize, bDataSeries, bUseSpecialFillColor, nSpecialFillColor, true,
     235           0 :                                         nNumberFormat, nPercentNumberFormat );
     236           0 :                     break;
     237             :             }
     238             :             case OBJECTTYPE_GRID:
     239             :             case OBJECTTYPE_SUBGRID:
     240             :             case OBJECTTYPE_DATA_AVERAGE_LINE:
     241             :                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
     242             :                                         xObjectProperties, rDrawModel.GetItemPool(),
     243             :                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     244           0 :                                         wrapper::GraphicPropertyItemConverter::LINE_PROPERTIES );
     245           0 :                     break;
     246             : 
     247             :             case OBJECTTYPE_DATA_ERRORS_X:
     248             :             case OBJECTTYPE_DATA_ERRORS_Y:
     249             :             case OBJECTTYPE_DATA_ERRORS_Z:
     250             :                 pItemConverter =  new wrapper::ErrorBarItemConverter(
     251             :                     xChartModel, xObjectProperties, rDrawModel.GetItemPool(),
     252           0 :                     rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ));
     253           0 :                 break;
     254             : 
     255             :             case OBJECTTYPE_DATA_CURVE:
     256             :                 pItemConverter =  new wrapper::RegressionCurveItemConverter(
     257             :                     xObjectProperties, uno::Reference< chart2::XRegressionCurveContainer >(
     258             :                         ObjectIdentifier::getDataSeriesForCID( aObjectCID, xChartModel ), uno::UNO_QUERY ),
     259             :                     rDrawModel.GetItemPool(), rDrawModel,
     260           0 :                     uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ));
     261           0 :                 break;
     262             :             case OBJECTTYPE_DATA_CURVE_EQUATION:
     263             :             {
     264           0 :                 ::std::auto_ptr< awt::Size > pRefSize;
     265           0 :                 if( pRefSizeProvider.get() )
     266           0 :                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
     267             : 
     268             :                 pItemConverter =  new wrapper::RegressionEquationItemConverter(
     269             :                                         xObjectProperties, rDrawModel.GetItemPool(), rDrawModel,
     270             :                                         uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     271           0 :                                         pRefSize );
     272           0 :                     break;
     273             :             }
     274             :             case OBJECTTYPE_DATA_STOCK_RANGE:
     275           0 :                     break;
     276             :             case OBJECTTYPE_DATA_STOCK_LOSS:
     277             :             case OBJECTTYPE_DATA_STOCK_GAIN:
     278             :                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
     279             :                                         xObjectProperties, rDrawModel.GetItemPool(),
     280             :                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
     281           0 :                                         wrapper::GraphicPropertyItemConverter::LINE_AND_FILL_PROPERTIES );
     282           0 :                     break;
     283             :             default: //OBJECTTYPE_UNKNOWN
     284           0 :                     break;
     285           0 :         }
     286             :     }
     287             :     else
     288             :     {
     289             :         //create itemconverter for a all objects of given type
     290           0 :         switch(eObjectType)
     291             :         {
     292             :             case OBJECTTYPE_TITLE:
     293             :                 pItemConverter =  new wrapper::AllTitleItemConverter( xChartModel, rDrawModel.GetItemPool(),
     294           0 :                                                                      rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ));
     295           0 :                 break;
     296             :             case OBJECTTYPE_AXIS:
     297             :             {
     298           0 :                 ::std::auto_ptr< awt::Size > pRefSize;
     299           0 :                 if( pRefSizeProvider.get() )
     300           0 :                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
     301             : 
     302             :                 pItemConverter =  new wrapper::AllAxisItemConverter( xChartModel, rDrawModel.GetItemPool(),
     303           0 :                                                                      rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ), pRefSize );
     304             :             }
     305           0 :             break;
     306             :             case OBJECTTYPE_GRID:
     307             :             case OBJECTTYPE_SUBGRID:
     308             :                 pItemConverter =  new wrapper::AllGridItemConverter( xChartModel, rDrawModel.GetItemPool(),
     309           0 :                                                                      rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ));
     310           0 :                 break;
     311             :             default: //for this type it is not supported to change all elements at once
     312           0 :                 break;
     313             :         }
     314             : 
     315             :     }
     316           0 :     return pItemConverter;
     317             : }
     318             : SAL_WNODEPRECATED_DECLARATIONS_POP
     319             : 
     320           0 : rtl::OUString lcl_getTitleCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< frame::XModel > & xChartModel )
     321             : {
     322           0 :     if( rDispatchCommand.equals("AllTitles"))
     323           0 :         return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_TITLE, C2U("ALLELEMENTS") );
     324             : 
     325           0 :     TitleHelper::eTitleType nTitleType( TitleHelper::MAIN_TITLE );
     326           0 :     if( rDispatchCommand.equals("SubTitle") )
     327           0 :         nTitleType = TitleHelper::SUB_TITLE;
     328           0 :     else if( rDispatchCommand.equals("XTitle") )
     329           0 :         nTitleType = TitleHelper::X_AXIS_TITLE;
     330           0 :     else if( rDispatchCommand.equals("YTitle") )
     331           0 :         nTitleType = TitleHelper::Y_AXIS_TITLE;
     332           0 :     else if( rDispatchCommand.equals("ZTitle") )
     333           0 :         nTitleType = TitleHelper::Z_AXIS_TITLE;
     334           0 :     else if( rDispatchCommand.equals("SecondaryXTitle") )
     335           0 :         nTitleType = TitleHelper::SECONDARY_X_AXIS_TITLE;
     336           0 :     else if( rDispatchCommand.equals("SecondaryYTitle") )
     337           0 :         nTitleType = TitleHelper::SECONDARY_Y_AXIS_TITLE;
     338             : 
     339           0 :     uno::Reference< XTitle > xTitle( TitleHelper::getTitle( nTitleType, xChartModel ) );
     340           0 :     return ObjectIdentifier::createClassifiedIdentifierForObject( xTitle, xChartModel );
     341             : }
     342             : 
     343           0 : rtl::OUString lcl_getAxisCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< frame::XModel >& xChartModel )
     344             : {
     345           0 :     if( rDispatchCommand.equals("DiagramAxisAll"))
     346           0 :         return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_AXIS, C2U("ALLELEMENTS") );
     347             : 
     348           0 :     sal_Int32   nDimensionIndex=0;
     349           0 :     bool        bMainAxis=true;
     350           0 :     if( rDispatchCommand.equals("DiagramAxisX"))
     351             :     {
     352           0 :         nDimensionIndex=0; bMainAxis=true;
     353             :     }
     354           0 :     else if( rDispatchCommand.equals("DiagramAxisY"))
     355             :     {
     356           0 :         nDimensionIndex=1; bMainAxis=true;
     357             :     }
     358           0 :     else if( rDispatchCommand.equals("DiagramAxisZ"))
     359             :     {
     360           0 :         nDimensionIndex=2; bMainAxis=true;
     361             :     }
     362           0 :     else if( rDispatchCommand.equals("DiagramAxisA"))
     363             :     {
     364           0 :         nDimensionIndex=0; bMainAxis=false;
     365             :     }
     366           0 :     else if( rDispatchCommand.equals("DiagramAxisB"))
     367             :     {
     368           0 :         nDimensionIndex=1; bMainAxis=false;
     369             :     }
     370             : 
     371           0 :     uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
     372           0 :     uno::Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
     373           0 :     return ObjectIdentifier::createClassifiedIdentifierForObject( xAxis, xChartModel );
     374             : }
     375             : 
     376           0 : rtl::OUString lcl_getGridCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< frame::XModel >& xChartModel )
     377             : {
     378           0 :     uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
     379             : 
     380           0 :     if( rDispatchCommand.equals("DiagramGridAll"))
     381           0 :         return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_GRID, C2U("ALLELEMENTS") );
     382             : 
     383           0 :     sal_Int32   nDimensionIndex=0;
     384           0 :     bool        bMainGrid=true;
     385             : 
     386             :     //x and y is swapped in the commands
     387             : 
     388           0 :     if( rDispatchCommand.equals("DiagramGridYMain"))
     389             :     {
     390           0 :         nDimensionIndex=0; bMainGrid=true;
     391             :     }
     392           0 :     else if( rDispatchCommand.equals("DiagramGridXMain"))
     393             :     {
     394           0 :         nDimensionIndex=1; bMainGrid=true;
     395             :     }
     396           0 :     else if( rDispatchCommand.equals("DiagramGridZMain"))
     397             :     {
     398           0 :         nDimensionIndex=2; bMainGrid=true;
     399             :     }
     400           0 :     else if( rDispatchCommand.equals("DiagramGridYHelp"))
     401             :     {
     402           0 :         nDimensionIndex=0; bMainGrid=false;
     403             :     }
     404           0 :     else if( rDispatchCommand.equals("DiagramGridXHelp"))
     405             :     {
     406           0 :         nDimensionIndex=1; bMainGrid=false;
     407             :     }
     408           0 :     else if( rDispatchCommand.equals("DiagramGridZHelp"))
     409             :     {
     410           0 :         nDimensionIndex=2; bMainGrid=false;
     411             :     }
     412             : 
     413           0 :     bool bMainAxis = true;
     414           0 :     uno::Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
     415             : 
     416           0 :     sal_Int32   nSubGridIndex= bMainGrid ? (-1) : 0;
     417           0 :     rtl::OUString aCID( ObjectIdentifier::createClassifiedIdentifierForGrid( xAxis, xChartModel, nSubGridIndex ) );
     418           0 :     return aCID;
     419             : }
     420             : 
     421           0 : rtl::OUString lcl_getErrorCIDForCommand( const ObjectType eDispatchType, const ObjectType &eSelectedType, const ::rtl::OUString &rSelectedCID)
     422             : {
     423           0 :     if( eSelectedType == eDispatchType )
     424           0 :         return rSelectedCID;
     425             : 
     426           0 :     return ObjectIdentifier::createClassifiedIdentifierWithParent( eDispatchType, ::rtl::OUString(), rSelectedCID );
     427             : }
     428             : 
     429           0 : rtl::OUString lcl_getObjectCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< XChartDocument > & xChartDocument, const rtl::OUString& rSelectedCID )
     430             : {
     431           0 :     ObjectType eObjectType = OBJECTTYPE_UNKNOWN;
     432           0 :     rtl::OUString aParticleID;
     433             : 
     434           0 :     uno::Reference< frame::XModel > xChartModel( xChartDocument, uno::UNO_QUERY );
     435           0 :     const ObjectType eSelectedType = ObjectIdentifier::getObjectType( rSelectedCID );
     436           0 :     uno::Reference< XDataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( rSelectedCID, xChartModel );
     437           0 :     uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt( xSeries, uno::UNO_QUERY );
     438             : 
     439             :     //-------------------------------------------------------------------------
     440             :     //legend
     441           0 :     if( rDispatchCommand.equals("Legend") || rDispatchCommand.equals("FormatLegend") )
     442             :     {
     443           0 :         eObjectType = OBJECTTYPE_LEGEND;
     444             :         //@todo set particular aParticleID if we have more than one legend
     445             :     }
     446             :     //-------------------------------------------------------------------------
     447             :     //wall floor area
     448           0 :     else if( rDispatchCommand.equals("DiagramWall") || rDispatchCommand.equals("FormatWall") )
     449             :     {
     450             :         //OBJECTTYPE_DIAGRAM;
     451           0 :         eObjectType = OBJECTTYPE_DIAGRAM_WALL;
     452             :         //@todo set particular aParticleID if we have more than one diagram
     453             :     }
     454           0 :     else if( rDispatchCommand.equals("DiagramFloor") || rDispatchCommand.equals("FormatFloor") )
     455             :     {
     456           0 :         eObjectType = OBJECTTYPE_DIAGRAM_FLOOR;
     457             :         //@todo set particular aParticleID if we have more than one diagram
     458             :     }
     459           0 :     else if( rDispatchCommand.equals("DiagramArea") || rDispatchCommand.equals("FormatChartArea") )
     460             :     {
     461           0 :         eObjectType = OBJECTTYPE_PAGE;
     462             :     }
     463             :     //-------------------------------------------------------------------------
     464             :     //title
     465           0 :     else if( rDispatchCommand.equals("MainTitle")
     466           0 :         || rDispatchCommand.equals("SubTitle")
     467           0 :         || rDispatchCommand.equals("XTitle")
     468           0 :         || rDispatchCommand.equals("YTitle")
     469           0 :         || rDispatchCommand.equals("ZTitle")
     470           0 :         || rDispatchCommand.equals("SecondaryXTitle")
     471           0 :         || rDispatchCommand.equals("SecondaryYTitle")
     472           0 :         || rDispatchCommand.equals("AllTitles")
     473             :         )
     474             :     {
     475           0 :         return lcl_getTitleCIDForCommand( rDispatchCommand, xChartModel );
     476             :     }
     477             :     //-------------------------------------------------------------------------
     478             :     //axis
     479           0 :     else if( rDispatchCommand.equals("DiagramAxisX")
     480           0 :         || rDispatchCommand.equals("DiagramAxisY")
     481           0 :         || rDispatchCommand.equals("DiagramAxisZ")
     482           0 :         || rDispatchCommand.equals("DiagramAxisA")
     483           0 :         || rDispatchCommand.equals("DiagramAxisB")
     484           0 :         || rDispatchCommand.equals("DiagramAxisAll")
     485             :         )
     486             :     {
     487           0 :         return lcl_getAxisCIDForCommand( rDispatchCommand, xChartModel );
     488             :     }
     489             :     //-------------------------------------------------------------------------
     490             :     //grid
     491           0 :     else if( rDispatchCommand.equals("DiagramGridYMain")
     492           0 :         || rDispatchCommand.equals("DiagramGridXMain")
     493           0 :         || rDispatchCommand.equals("DiagramGridZMain")
     494           0 :         || rDispatchCommand.equals("DiagramGridYHelp")
     495           0 :         || rDispatchCommand.equals("DiagramGridXHelp")
     496           0 :         || rDispatchCommand.equals("DiagramGridZHelp")
     497           0 :         || rDispatchCommand.equals("DiagramGridAll")
     498             :         )
     499             :     {
     500           0 :         return lcl_getGridCIDForCommand( rDispatchCommand, xChartModel );
     501             :     }
     502             :     //-------------------------------------------------------------------------
     503             :     //data series
     504           0 :     else if( rDispatchCommand.equals("FormatDataSeries") )
     505             :     {
     506           0 :         if( eSelectedType == OBJECTTYPE_DATA_SERIES )
     507           0 :             return rSelectedCID;
     508             :         else
     509             :             return ObjectIdentifier::createClassifiedIdentifier(
     510           0 :                 OBJECTTYPE_DATA_SERIES, ObjectIdentifier::getSeriesParticleFromCID( rSelectedCID ) );
     511             :     }
     512             :     //-------------------------------------------------------------------------
     513             :     //data point
     514           0 :     else if( rDispatchCommand.equals("FormatDataPoint") )
     515             :     {
     516           0 :         return rSelectedCID;
     517             :     }
     518             :     //-------------------------------------------------------------------------
     519             :     //data labels
     520           0 :     else if( rDispatchCommand.equals("FormatDataLabels") )
     521             :     {
     522           0 :         if( eSelectedType == OBJECTTYPE_DATA_LABELS )
     523           0 :             return rSelectedCID;
     524             :         else
     525             :             return ObjectIdentifier::createClassifiedIdentifierWithParent(
     526           0 :                 OBJECTTYPE_DATA_LABELS, ::rtl::OUString(), rSelectedCID );
     527             :     }
     528             :     //-------------------------------------------------------------------------
     529             :     //data labels
     530           0 :     else if( rDispatchCommand.equals("FormatDataLabel") )
     531             :     {
     532           0 :         if( eSelectedType == OBJECTTYPE_DATA_LABEL )
     533           0 :             return rSelectedCID;
     534             :         else
     535             :         {
     536           0 :             sal_Int32 nPointIndex = ObjectIdentifier::getParticleID( rSelectedCID ).toInt32();
     537           0 :             if( nPointIndex>=0 )
     538             :             {
     539           0 :                 OUString aSeriesParticle = ObjectIdentifier::getSeriesParticleFromCID( rSelectedCID );
     540           0 :                 OUString aChildParticle( ObjectIdentifier::getStringForType( OBJECTTYPE_DATA_LABELS ) );
     541           0 :                 aChildParticle+=(C2U("="));
     542           0 :                 OUString aLabelsCID = ObjectIdentifier::createClassifiedIdentifierForParticles( aSeriesParticle, aChildParticle );
     543             :                 OUString aLabelCID_Stub = ObjectIdentifier::createClassifiedIdentifierWithParent(
     544           0 :                     OBJECTTYPE_DATA_LABEL, ::rtl::OUString(), aLabelsCID );
     545             : 
     546           0 :                 return ObjectIdentifier::createPointCID( aLabelCID_Stub, nPointIndex );
     547             :             }
     548             :         }
     549             :     }
     550             :     //-------------------------------------------------------------------------
     551             :     //mean value line
     552           0 :     else if( rDispatchCommand.equals("FormatMeanValue") )
     553             :     {
     554           0 :         if( eSelectedType == OBJECTTYPE_DATA_AVERAGE_LINE )
     555           0 :             return rSelectedCID;
     556             :         else
     557             :             return ObjectIdentifier::createDataCurveCID(
     558             :                 ObjectIdentifier::getSeriesParticleFromCID( rSelectedCID ),
     559             :                     RegressionCurveHelper::getRegressionCurveIndex( xRegCurveCnt,
     560           0 :                         RegressionCurveHelper::getMeanValueLine( xRegCurveCnt ) ), true );
     561             :     }
     562             :     //-------------------------------------------------------------------------
     563             :     //trend line
     564           0 :     else if( rDispatchCommand.equals("FormatTrendline") )
     565             :     {
     566           0 :         if( eSelectedType == OBJECTTYPE_DATA_CURVE )
     567           0 :             return rSelectedCID;
     568             :         else
     569             :             return ObjectIdentifier::createDataCurveCID(
     570             :                 ObjectIdentifier::getSeriesParticleFromCID( rSelectedCID ),
     571             :                     RegressionCurveHelper::getRegressionCurveIndex( xRegCurveCnt,
     572           0 :                         RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCurveCnt ) ), false );
     573             :     }
     574             :     //-------------------------------------------------------------------------
     575             :     //trend line equation
     576           0 :     else if( rDispatchCommand.equals("FormatTrendlineEquation") )
     577             :     {
     578           0 :         if( eSelectedType == OBJECTTYPE_DATA_CURVE_EQUATION )
     579           0 :             return rSelectedCID;
     580             :         else
     581             :             return ObjectIdentifier::createDataCurveEquationCID(
     582             :                 ObjectIdentifier::getSeriesParticleFromCID( rSelectedCID ),
     583             :                     RegressionCurveHelper::getRegressionCurveIndex( xRegCurveCnt,
     584           0 :                         RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCurveCnt ) ) );
     585             :     }
     586             :     //-------------------------------------------------------------------------
     587             :     // y error bars
     588           0 :     else if( rDispatchCommand.equals("FormatXErrorBars") )
     589             :     {
     590           0 :         return lcl_getErrorCIDForCommand(OBJECTTYPE_DATA_ERRORS_X, eSelectedType, rSelectedCID );
     591             :     }
     592             :     //-------------------------------------------------------------------------
     593             :     // y error bars
     594           0 :     else if( rDispatchCommand.equals("FormatYErrorBars") )
     595             :     {
     596           0 :         return lcl_getErrorCIDForCommand(OBJECTTYPE_DATA_ERRORS_Y, eSelectedType, rSelectedCID );
     597             :     }
     598             :     //-------------------------------------------------------------------------
     599             :     // axis
     600           0 :     else if( rDispatchCommand.equals("FormatAxis") )
     601             :     {
     602           0 :         if( eSelectedType == OBJECTTYPE_AXIS )
     603           0 :             return rSelectedCID;
     604             :         else
     605             :         {
     606           0 :             Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( rSelectedCID, xChartModel );
     607           0 :             return ObjectIdentifier::createClassifiedIdentifierForObject( xAxis , xChartModel );
     608             :         }
     609             :     }
     610             :     //-------------------------------------------------------------------------
     611             :     // major grid
     612           0 :     else if( rDispatchCommand.equals("FormatMajorGrid") )
     613             :     {
     614           0 :         if( eSelectedType == OBJECTTYPE_GRID )
     615           0 :             return rSelectedCID;
     616             :         else
     617             :         {
     618           0 :             Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( rSelectedCID, xChartModel );
     619           0 :             return ObjectIdentifier::createClassifiedIdentifierForGrid( xAxis, xChartModel );
     620             :         }
     621             : 
     622             :     }
     623             :     //-------------------------------------------------------------------------
     624             :     // minor grid
     625           0 :     else if( rDispatchCommand.equals("FormatMinorGrid") )
     626             :     {
     627           0 :         if( eSelectedType == OBJECTTYPE_SUBGRID )
     628           0 :             return rSelectedCID;
     629             :         else
     630             :         {
     631           0 :             Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( rSelectedCID, xChartModel );
     632           0 :             return ObjectIdentifier::createClassifiedIdentifierForGrid( xAxis, xChartModel, 0 /*sub grid index*/ );
     633             :         }
     634             :     }
     635             :     //-------------------------------------------------------------------------
     636             :     // title
     637           0 :     else if( rDispatchCommand.equals("FormatTitle") )
     638             :     {
     639           0 :         if( eSelectedType == OBJECTTYPE_TITLE )
     640           0 :             return rSelectedCID;
     641             :     }
     642             :     //-------------------------------------------------------------------------
     643             :     // stock loss
     644           0 :     else if( rDispatchCommand.equals("FormatStockLoss") )
     645             :     {
     646           0 :         if( eSelectedType == OBJECTTYPE_DATA_STOCK_LOSS )
     647           0 :             return rSelectedCID;
     648             :         else
     649           0 :             return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DATA_STOCK_LOSS, rtl::OUString());
     650             :     }
     651             :     //-------------------------------------------------------------------------
     652             :     // stock gain
     653           0 :     else if( rDispatchCommand.equals("FormatStockGain") )
     654             :     {
     655           0 :         if( eSelectedType == OBJECTTYPE_DATA_STOCK_GAIN )
     656           0 :             return rSelectedCID;
     657             :         else
     658           0 :             return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DATA_STOCK_GAIN, rtl::OUString() );
     659             :     }
     660             : 
     661             :     return ObjectIdentifier::createClassifiedIdentifier(
     662           0 :         eObjectType, aParticleID );
     663             : }
     664             : 
     665             : }
     666             : // anonymous namespace
     667             : 
     668           0 : void SAL_CALL ChartController::executeDispatch_FormatObject(const ::rtl::OUString& rDispatchCommand)
     669             : {
     670           0 :     uno::Reference< XChartDocument > xChartDocument( getModel(), uno::UNO_QUERY );
     671           0 :     rtl::OString aCommand( rtl::OUStringToOString( rDispatchCommand, RTL_TEXTENCODING_ASCII_US ) );
     672           0 :     rtl::OUString rObjectCID = lcl_getObjectCIDForCommand( aCommand, xChartDocument, m_aSelection.getSelectedCID() );
     673           0 :     executeDlg_ObjectProperties( rObjectCID );
     674           0 : }
     675             : 
     676           0 : void SAL_CALL ChartController::executeDispatch_ObjectProperties()
     677             : {
     678           0 :     executeDlg_ObjectProperties( m_aSelection.getSelectedCID() );
     679           0 : }
     680             : 
     681             : namespace
     682             : {
     683             : 
     684           0 : rtl::OUString lcl_getFormatCIDforSelectedCID( const ::rtl::OUString& rSelectedCID )
     685             : {
     686           0 :     ::rtl::OUString aFormatCID(rSelectedCID);
     687             : 
     688             :     //get type of selected object
     689           0 :     ObjectType eObjectType = ObjectIdentifier::getObjectType( aFormatCID );
     690             : 
     691             :     // some legend entries are handled as if they were data series
     692           0 :     if( OBJECTTYPE_LEGEND_ENTRY==eObjectType )
     693             :     {
     694           0 :         rtl::OUString aParentParticle( ObjectIdentifier::getFullParentParticle( rSelectedCID ) );
     695           0 :         aFormatCID  = ObjectIdentifier::createClassifiedIdentifierForParticle( aParentParticle );
     696             :     }
     697             : 
     698             :     // treat diagram as wall
     699           0 :     if( OBJECTTYPE_DIAGRAM==eObjectType )
     700           0 :         aFormatCID  = ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DIAGRAM_WALL, rtl::OUString() );
     701             : 
     702           0 :     return aFormatCID;
     703             : }
     704             : 
     705             : }//end anonymous namespace
     706             : 
     707           0 : void SAL_CALL ChartController::executeDlg_ObjectProperties( const ::rtl::OUString& rSelectedObjectCID )
     708             : {
     709           0 :     rtl::OUString aObjectCID = lcl_getFormatCIDforSelectedCID( rSelectedObjectCID );
     710             : 
     711             :     UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription(
     712             :                 ActionDescriptionProvider::FORMAT,
     713             :                 ObjectNameProvider::getName( ObjectIdentifier::getObjectType( aObjectCID ))),
     714           0 :             m_xUndoManager );
     715             : 
     716           0 :     bool bSuccess = ChartController::executeDlg_ObjectProperties_withoutUndoGuard( aObjectCID, false );
     717           0 :     if( bSuccess )
     718           0 :         aUndoGuard.commit();
     719           0 : }
     720             : 
     721           0 : bool ChartController::executeDlg_ObjectProperties_withoutUndoGuard( const ::rtl::OUString& rObjectCID, bool bOkClickOnUnchangedDialogSouldBeRatedAsSuccessAlso )
     722             : {
     723             :     //return true if the properties were changed successfully
     724           0 :     bool bRet = false;
     725           0 :     if( rObjectCID.isEmpty() )
     726             :     {
     727           0 :        return bRet;
     728             :     }
     729             :     try
     730             :     {
     731             :         //-------------------------------------------------------------
     732             :         //get type of object
     733           0 :         ObjectType eObjectType = ObjectIdentifier::getObjectType( rObjectCID );
     734           0 :         if( OBJECTTYPE_UNKNOWN==eObjectType )
     735             :         {
     736           0 :             return bRet;
     737             :         }
     738           0 :         if( OBJECTTYPE_DIAGRAM_WALL==eObjectType || OBJECTTYPE_DIAGRAM_FLOOR==eObjectType )
     739             :         {
     740           0 :             if( !DiagramHelper::isSupportingFloorAndWall( ChartModelHelper::findDiagram( getModel() ) ) )
     741           0 :                 return bRet;
     742             :         }
     743             : 
     744             :         //-------------------------------------------------------------
     745             :         //convert properties to ItemSet
     746             : 
     747             :         SAL_WNODEPRECATED_DECLARATIONS_PUSH
     748             :         ::std::auto_ptr< ReferenceSizeProvider > pRefSizeProv(
     749           0 :             impl_createReferenceSizeProvider());
     750             :         ::std::auto_ptr< ::comphelper::ItemConverter > apItemConverter(
     751           0 :             createItemConverter( rObjectCID, getModel(), m_xCC,
     752           0 :                                  m_pDrawModelWrapper->getSdrModel(),
     753             :                                  ExplicitValueProvider::getExplicitValueProvider(m_xChartView),
     754           0 :                                  pRefSizeProv ));
     755             :         SAL_WNODEPRECATED_DECLARATIONS_POP
     756           0 :         if(!apItemConverter.get())
     757           0 :             return bRet;
     758             : 
     759           0 :         SfxItemSet aItemSet = apItemConverter->CreateEmptyItemSet();
     760             : 
     761           0 :         if ( eObjectType == OBJECTTYPE_DATA_ERRORS_X || eObjectType == OBJECTTYPE_DATA_ERRORS_Y )
     762           0 :             aItemSet.Put(SfxBoolItem(SCHATTR_STAT_ERRORBAR_TYPE, eObjectType == OBJECTTYPE_DATA_ERRORS_Y ));
     763             : 
     764           0 :         apItemConverter->FillItemSet( aItemSet );
     765             : 
     766             :         //-------------------------------------------------------------
     767             :         //prepare dialog
     768           0 :         ObjectPropertiesDialogParameter aDialogParameter = ObjectPropertiesDialogParameter( rObjectCID );
     769           0 :         aDialogParameter.init( getModel() );
     770           0 :         ViewElementListProvider aViewElementListProvider( m_pDrawModelWrapper.get() );
     771             : 
     772           0 :         SolarMutexGuard aGuard;
     773             :         SchAttribTabDlg aDlg( m_pChartWindow, &aItemSet, &aDialogParameter, &aViewElementListProvider
     774           0 :             , uno::Reference< util::XNumberFormatsSupplier >( getModel(), uno::UNO_QUERY ) );
     775             : 
     776           0 :         if(aDialogParameter.HasSymbolProperties())
     777             :         {
     778           0 :             SfxItemSet* pSymbolShapeProperties=NULL;
     779             :             uno::Reference< beans::XPropertySet > xObjectProperties =
     780           0 :                 ObjectIdentifier::getObjectPropertySet( rObjectCID, getModel() );
     781           0 :             wrapper::DataPointItemConverter aSymbolItemConverter( getModel(), m_xCC
     782           0 :                                         , xObjectProperties, ObjectIdentifier::getDataSeriesForCID( rObjectCID, getModel() )
     783           0 :                                         , m_pDrawModelWrapper->getSdrModel().GetItemPool()
     784           0 :                                         , m_pDrawModelWrapper->getSdrModel()
     785           0 :                                         , uno::Reference< lang::XMultiServiceFactory >( getModel(), uno::UNO_QUERY )
     786           0 :                                         , wrapper::GraphicPropertyItemConverter::FILLED_DATA_POINT );
     787             : 
     788           0 :             pSymbolShapeProperties = new SfxItemSet( aSymbolItemConverter.CreateEmptyItemSet() );
     789           0 :             aSymbolItemConverter.FillItemSet( *pSymbolShapeProperties );
     790             : 
     791           0 :             sal_Int32   nStandardSymbol=0;//@todo get from somewhere
     792           0 :             Graphic*    pAutoSymbolGraphic = new Graphic( aViewElementListProvider.GetSymbolGraphic( nStandardSymbol, pSymbolShapeProperties ) );
     793             :             // note: the dialog takes the ownership of pSymbolShapeProperties and pAutoSymbolGraphic
     794           0 :             aDlg.setSymbolInformation( pSymbolShapeProperties, pAutoSymbolGraphic );
     795             :         }
     796           0 :         if( aDialogParameter.HasStatisticProperties() )
     797             :         {
     798             :             aDlg.SetAxisMinorStepWidthForErrorBarDecimals(
     799           0 :                 InsertErrorBarsDialog::getAxisMinorStepWidthForErrorBarDecimals( getModel(), m_xChartView, rObjectCID ) );
     800             :         }
     801             : 
     802             :         //-------------------------------------------------------------
     803             :         //open the dialog
     804           0 :         if( aDlg.Execute() == RET_OK || (bOkClickOnUnchangedDialogSouldBeRatedAsSuccessAlso && aDlg.DialogWasClosedWithOK()) )
     805             :         {
     806           0 :             const SfxItemSet* pOutItemSet = aDlg.GetOutputItemSet();
     807           0 :             if(pOutItemSet)
     808             :             {
     809           0 :                 ControllerLockGuard aCLGuard( getModel());
     810           0 :                 apItemConverter->ApplyItemSet( *pOutItemSet );//model should be changed now
     811           0 :                 bRet = true;
     812             :             }
     813           0 :         }
     814             :     }
     815           0 :     catch( const util::CloseVetoException& )
     816             :     {
     817             :     }
     818           0 :     catch( const uno::RuntimeException& )
     819             :     {
     820             :     }
     821           0 :     return bRet;
     822             : }
     823             : 
     824           0 : void SAL_CALL ChartController::executeDispatch_View3D()
     825             : {
     826             :     try
     827             :     {
     828             :         // using assignment for broken gcc 3.3
     829             :         UndoLiveUpdateGuard aUndoGuard = UndoLiveUpdateGuard(
     830             :             String( SchResId( STR_ACTION_EDIT_3D_VIEW )),
     831           0 :             m_xUndoManager );
     832             : 
     833             :         //open dialog
     834           0 :         SolarMutexGuard aSolarGuard;
     835           0 :         View3DDialog aDlg( m_pChartWindow, getModel(), m_pDrawModelWrapper->GetColorList() );
     836           0 :         if( aDlg.Execute() == RET_OK )
     837           0 :             aUndoGuard.commit();
     838             :     }
     839           0 :     catch(const uno::RuntimeException& e)
     840             :     {
     841             :         ASSERT_EXCEPTION( e );
     842             :     }
     843           0 : }
     844             : 
     845             : //.............................................................................
     846           3 : } //namespace chart
     847             : //.............................................................................
     848             : 
     849             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10