chart2/source/controller/main/ChartController_Properties.cxx

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