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

Generated by: LCOV version 1.10