chart2/source/controller/main/ChartController_Properties.cxx

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