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 <com/sun/star/chart2/XChartDocument.hpp>
  66
  67 //for auto_ptr
  68 #include <memory>
  69
  70 // header for define RET_OK
  71 #include <vcl/msgbox.hxx>
  72 // for SolarMutex
  73 #include <vcl/svapp.hxx>
  74 #include <vos/mutex.hxx>
  75 #include <svx/ActionDescriptionProvider.hxx>
  76
  77 //.............................................................................
  78 namespace chart
  79 {
  80 //.............................................................................
  81 using namespace ::com::sun::star;
  82 using namespace ::com::sun::star::chart2;
  83
  84 namespace
  85 {
  86
  87 ::comphelper::ItemConverter* createItemConverter(
  88     const ::rtl::OUString & aObjectCID
  89     , const uno::Reference< frame::XModel > & xChartModel
  90     , const uno::Reference< uno::XComponentContext > & xContext
  91     , SdrModel & rDrawModel
  92     , NumberFormatterWrapper * pNumberFormatterWrapper = NULL
  93     , ExplicitValueProvider * pExplicitValueProvider = NULL
  94     , ::std::auto_ptr< ReferenceSizeProvider > pRefSizeProvider =
  95           ::std::auto_ptr< ReferenceSizeProvider >()
  96     )
  97 {
  98     ::comphelper::ItemConverter* pItemConverter=NULL;
  99
 100     //-------------------------------------------------------------
 101     //get type of selected object
 102     ObjectType eObjectType = ObjectIdentifier::getObjectType( aObjectCID );
 103     if( OBJECTTYPE_UNKNOWN==eObjectType )
 104     {
 105         DBG_ERROR("unknown ObjectType");
 106         return NULL;
 107     }
 108     //--
 109     rtl::OUString aParticleID = ObjectIdentifier::getParticleID( aObjectCID );
 110     bool bAffectsMultipleObjects = aParticleID.equals(C2U("ALLELEMENTS"));
 111     //-------------------------------------------------------------
 112     if( !bAffectsMultipleObjects )
 113     {
 114         uno::Reference< beans::XPropertySet > xObjectProperties =
 115             ObjectIdentifier::getObjectPropertySet( aObjectCID, xChartModel );
 116         if(!xObjectProperties.is())
 117             return NULL;
 118         //create itemconverter for a single object
 119         switch(eObjectType)
 120         {
 121             case OBJECTTYPE_PAGE:
 122                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
 123                                         xObjectProperties, rDrawModel.GetItemPool(),
 124                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
 125                                         wrapper::GraphicPropertyItemConverter::LINE_AND_FILL_PROPERTIES );
 126                     break;
 127             case OBJECTTYPE_TITLE:
 128             {
 129                 ::std::auto_ptr< awt::Size > pRefSize;
 130                 if( pRefSizeProvider.get() )
 131                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
 132
 133                 pItemConverter = new wrapper::TitleItemConverter( xObjectProperties,
 134                                                                   rDrawModel.GetItemPool(), rDrawModel,
 135                                                                   uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
 136                                                                   pRefSize );
 137             }
 138             break;
 139             case OBJECTTYPE_LEGEND:
 140             {
 141                 ::std::auto_ptr< awt::Size > pRefSize;
 142                 if( pRefSizeProvider.get() )
 143                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
 144
 145                 pItemConverter = new wrapper::LegendItemConverter( xObjectProperties,
 146                                                                    rDrawModel.GetItemPool(), rDrawModel,
 147                                                                    uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
 148                                                                    pRefSize );
 149             }
 150             break;
 151             case OBJECTTYPE_LEGEND_ENTRY:
 152                     break;
 153             case OBJECTTYPE_DIAGRAM:
 154                     break;
 155             case OBJECTTYPE_DIAGRAM_WALL:
 156             case OBJECTTYPE_DIAGRAM_FLOOR:
 157                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
 158                                         xObjectProperties, rDrawModel.GetItemPool(),
 159                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
 160                                         wrapper::GraphicPropertyItemConverter::LINE_AND_FILL_PROPERTIES );
 161                     break;
 162             case OBJECTTYPE_AXIS:
 163             {
 164                 ::std::auto_ptr< awt::Size > pRefSize;
 165                 if( pRefSizeProvider.get() )
 166                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
 167
 168                 uno::Reference< beans::XPropertySet > xDiaProp;
 169                 xDiaProp.set( ChartModelHelper::findDiagram( xChartModel ), uno::UNO_QUERY );
 170
 171                 // the second property set contains the property CoordinateOrigin
 172                 // nOriginIndex is the index of the corresponding index of the
 173                 // origin (x=0, y=1, z=2)
 174
 175                 ExplicitScaleData aExplicitScale;
 176                 ExplicitIncrementData aExplicitIncrement;
 177                 if( pExplicitValueProvider )
 178                     pExplicitValueProvider->getExplicitValuesForAxis(
 179                         uno::Reference< XAxis >( xObjectProperties, uno::UNO_QUERY ),
 180                         aExplicitScale, aExplicitIncrement );
 181
 182                 pItemConverter =  new wrapper::AxisItemConverter(
 183                     xObjectProperties, rDrawModel.GetItemPool(),
 184                     rDrawModel,
 185                     uno::Reference< chart2::XChartDocument >( xChartModel, uno::UNO_QUERY ),
 186                     &aExplicitScale, &aExplicitIncrement,
 187                     pRefSize );
 188             }
 189             break;
 190             case OBJECTTYPE_AXIS_UNITLABEL:
 191                     break;
 192             case OBJECTTYPE_DATA_LABELS:
 193             case OBJECTTYPE_DATA_SERIES:
 194             case OBJECTTYPE_DATA_LABEL:
 195             case OBJECTTYPE_DATA_POINT:
 196             {
 197                 ::std::auto_ptr< awt::Size > pRefSize;
 198                 if( pRefSizeProvider.get() )
 199                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
 200
 201                 wrapper::GraphicPropertyItemConverter::eGraphicObjectType eMapTo =
 202                     wrapper::GraphicPropertyItemConverter::FILLED_DATA_POINT;
 203
 204                 uno::Reference< XDataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( aObjectCID, xChartModel );
 205                 uno::Reference< XChartType > xChartType = ChartModelHelper::getChartTypeOfSeries( xChartModel, xSeries );
 206
 207                 uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
 208                 sal_Int32 nDimensionCount = DiagramHelper::getDimension( xDiagram );
 209                 if( !ChartTypeHelper::isSupportingAreaProperties( xChartType, nDimensionCount ) )
 210                     eMapTo = wrapper::GraphicPropertyItemConverter::LINE_DATA_POINT;
 211                 /*
 212                 FILLED_DATA_POINT,
 213                 LINE_DATA_POINT,
 214                 LINE_PROPERTIES,
 215                 FILL_PROPERTIES,
 216                 LINE_AND_FILL_PROPERTIES
 217                 */
 218                 bool bDataSeries = ( eObjectType == OBJECTTYPE_DATA_SERIES || eObjectType == OBJECTTYPE_DATA_LABELS );
 219
 220                 //special color for pie chart:
 221                 bool bUseSpecialFillColor = false;
 222                 sal_Int32 nSpecialFillColor =0;
 223                 sal_Int32 nPointIndex = -1; /*-1 for whole series*/
 224                 if(!bDataSeries)
 225                 {
 226                     nPointIndex = aParticleID.toInt32();
 227                     uno::Reference< beans::XPropertySet > xSeriesProp( xSeries, uno::UNO_QUERY );
 228                     bool bVaryColorsByPoint = false;
 229                     if( xSeriesProp.is() &&
 230                         (xSeriesProp->getPropertyValue(C2U("VaryColorsByPoint")) >>= bVaryColorsByPoint) &&
 231                         bVaryColorsByPoint )
 232                     {
 233                         if( !ColorPerPointHelper::hasPointOwnColor( xSeriesProp, nPointIndex, xObjectProperties ) )
 234                         {
 235                             bUseSpecialFillColor = true;
 236                             OSL_ASSERT( xDiagram.is());
 237                             uno::Reference< XColorScheme > xColorScheme( xDiagram->getDefaultColorScheme() );
 238                             if( xColorScheme.is())
 239                                 nSpecialFillColor = xColorScheme->getColorByIndex( nPointIndex );
 240                         }
 241                     }
 242                 }
 243                 sal_Int32 nNumberFormat=ExplicitValueProvider::getExplicitNumberFormatKeyForDataLabel( xObjectProperties, xSeries, nPointIndex, xDiagram );
 244                 sal_Int32 nPercentNumberFormat=ExplicitValueProvider::getExplicitPercentageNumberFormatKeyForDataLabel(
 245                         xObjectProperties,uno::Reference< util::XNumberFormatsSupplier >(xChartModel, uno::UNO_QUERY));
 246
 247                 pItemConverter =  new wrapper::DataPointItemConverter( xChartModel, xContext,
 248                                         xObjectProperties, xSeries, rDrawModel.GetItemPool(), rDrawModel,
 249                                         pNumberFormatterWrapper,
 250                                         uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
 251                                         eMapTo, pRefSize, bDataSeries, bUseSpecialFillColor, nSpecialFillColor, false,
 252                                         nNumberFormat, nPercentNumberFormat );
 253                     break;
 254             }
 255             case OBJECTTYPE_GRID:
 256             case OBJECTTYPE_SUBGRID:
 257             case OBJECTTYPE_DATA_AVERAGE_LINE:
 258                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
 259                                         xObjectProperties, rDrawModel.GetItemPool(),
 260                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
 261                                         wrapper::GraphicPropertyItemConverter::LINE_PROPERTIES );
 262                     break;
 263
 264             case OBJECTTYPE_DATA_ERRORS:
 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                 ::std::auto_ptr< awt::Size > pRefSize;
 280                 if( pRefSizeProvider.get() )
 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 );
 287                     break;
 288             }
 289             case OBJECTTYPE_DATA_ERRORS_X:
 290                     break;
 291             case OBJECTTYPE_DATA_ERRORS_Y:
 292                     break;
 293             case OBJECTTYPE_DATA_ERRORS_Z:
 294                     break;
 295             case OBJECTTYPE_DATA_STOCK_RANGE:
 296                     break;
 297             case OBJECTTYPE_DATA_STOCK_LOSS:
 298             case OBJECTTYPE_DATA_STOCK_GAIN:
 299                 pItemConverter =  new wrapper::GraphicPropertyItemConverter(
 300                                         xObjectProperties, rDrawModel.GetItemPool(),
 301                                         rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ),
 302                                         wrapper::GraphicPropertyItemConverter::LINE_AND_FILL_PROPERTIES );
 303                     break;
 304             default: //OBJECTTYPE_UNKNOWN
 305                     break;
 306         }
 307     }
 308     else
 309     {
 310         //create itemconverter for a all objects of given type
 311         switch(eObjectType)
 312         {
 313             case OBJECTTYPE_TITLE:
 314                 pItemConverter =  new wrapper::AllTitleItemConverter( xChartModel, rDrawModel.GetItemPool(),
 315                                                                      rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ));
 316                 break;
 317             case OBJECTTYPE_AXIS:
 318             {
 319                 ::std::auto_ptr< awt::Size > pRefSize;
 320                 if( pRefSizeProvider.get() )
 321                     pRefSize.reset( new awt::Size( pRefSizeProvider->getPageSize()));
 322
 323                 pItemConverter =  new wrapper::AllAxisItemConverter( xChartModel, rDrawModel.GetItemPool(),
 324                                                                      rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ), pRefSize );
 325             }
 326             break;
 327             case OBJECTTYPE_GRID:
 328             case OBJECTTYPE_SUBGRID:
 329                 pItemConverter =  new wrapper::AllGridItemConverter( xChartModel, rDrawModel.GetItemPool(),
 330                                                                      rDrawModel, uno::Reference< lang::XMultiServiceFactory >( xChartModel, uno::UNO_QUERY ));
 331                 break;
 332             default: //for this type it is not supported to change all elements at once
 333                 break;
 334         }
 335
 336     }
 337     return pItemConverter;
 338 }
 339
 340 rtl::OUString lcl_getTitleCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< frame::XModel > & xChartModel )
 341 {
 342     if( rDispatchCommand.equals("AllTitles"))
 343         return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_TITLE, C2U("ALLELEMENTS") );
 344
 345     TitleHelper::eTitleType nTitleType( TitleHelper::MAIN_TITLE );
 346     if( rDispatchCommand.equals("SubTitle") )
 347         nTitleType = TitleHelper::SUB_TITLE;
 348     else if( rDispatchCommand.equals("XTitle") )
 349         nTitleType = TitleHelper::X_AXIS_TITLE;
 350     else if( rDispatchCommand.equals("YTitle") )
 351         nTitleType = TitleHelper::Y_AXIS_TITLE;
 352     else if( rDispatchCommand.equals("ZTitle") )
 353         nTitleType = TitleHelper::Z_AXIS_TITLE;
 354     else if( rDispatchCommand.equals("SecondaryXTitle") )
 355         nTitleType = TitleHelper::SECONDARY_X_AXIS_TITLE;
 356     else if( rDispatchCommand.equals("SecondaryYTitle") )
 357         nTitleType = TitleHelper::SECONDARY_Y_AXIS_TITLE;
 358
 359     uno::Reference< XTitle > xTitle( TitleHelper::getTitle( nTitleType, xChartModel ) );
 360     return ObjectIdentifier::createClassifiedIdentifierForObject( xTitle, xChartModel );
 361 }
 362
 363 rtl::OUString lcl_getAxisCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< frame::XModel >& xChartModel )
 364 {
 365     if( rDispatchCommand.equals("DiagramAxisAll"))
 366         return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_AXIS, C2U("ALLELEMENTS") );
 367
 368     sal_Int32   nDimensionIndex=0;
 369     bool        bMainAxis=true;
 370     if( rDispatchCommand.equals("DiagramAxisX"))
 371     {
 372         nDimensionIndex=0; bMainAxis=true;
 373     }
 374     else if( rDispatchCommand.equals("DiagramAxisY"))
 375     {
 376         nDimensionIndex=1; bMainAxis=true;
 377     }
 378     else if( rDispatchCommand.equals("DiagramAxisZ"))
 379     {
 380         nDimensionIndex=2; bMainAxis=true;
 381     }
 382     else if( rDispatchCommand.equals("DiagramAxisA"))
 383     {
 384         nDimensionIndex=0; bMainAxis=false;
 385     }
 386     else if( rDispatchCommand.equals("DiagramAxisB"))
 387     {
 388         nDimensionIndex=1; bMainAxis=false;
 389     }
 390
 391     uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
 392     uno::Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
 393     return ObjectIdentifier::createClassifiedIdentifierForObject( xAxis, xChartModel );
 394 }
 395
 396 rtl::OUString lcl_getGridCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< frame::XModel >& xChartModel )
 397 {
 398     uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
 399
 400     if( rDispatchCommand.equals("DiagramGridAll"))
 401         return ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_GRID, C2U("ALLELEMENTS") );
 402
 403     sal_Int32   nDimensionIndex=0;
 404     bool        bMainGrid=true;
 405
 406     //x and y is swapped in the commands
 407
 408     if( rDispatchCommand.equals("DiagramGridYMain"))
 409     {
 410         nDimensionIndex=0; bMainGrid=true;
 411     }
 412     else if( rDispatchCommand.equals("DiagramGridXMain"))
 413     {
 414         nDimensionIndex=1; bMainGrid=true;
 415     }
 416     else if( rDispatchCommand.equals("DiagramGridZMain"))
 417     {
 418         nDimensionIndex=2; bMainGrid=true;
 419     }
 420     else if( rDispatchCommand.equals("DiagramGridYHelp"))
 421     {
 422         nDimensionIndex=0; bMainGrid=false;
 423     }
 424     else if( rDispatchCommand.equals("DiagramGridXHelp"))
 425     {
 426         nDimensionIndex=1; bMainGrid=false;
 427     }
 428     else if( rDispatchCommand.equals("DiagramGridZHelp"))
 429     {
 430         nDimensionIndex=2; bMainGrid=false;
 431     }
 432
 433     bool bMainAxis = true;
 434     uno::Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
 435
 436     sal_Int32   nSubGridIndex= bMainGrid ? (-1) : 0;
 437     rtl::OUString aCID( ObjectIdentifier::createClassifiedIdentifierForGrid( xAxis, xChartModel, nSubGridIndex ) );
 438     return aCID;
 439 }
 440 rtl::OUString lcl_getObjectCIDForCommand( const ::rtl::OString& rDispatchCommand, const uno::Reference< XChartDocument > & xChartDocument )
 441 {
 442     ObjectType eObjectType = OBJECTTYPE_UNKNOWN;
 443     rtl::OUString aParticleID;
 444
 445     uno::Reference< frame::XModel > xChartModel( xChartDocument, uno::UNO_QUERY );
 446
 447     //-------------------------------------------------------------------------
 448     //legend
 449     if( rDispatchCommand.equals("Legend"))
 450     {
 451         eObjectType = OBJECTTYPE_LEGEND;
 452         //@todo set particular aParticleID if we have more than one legend
 453     }
 454     //-------------------------------------------------------------------------
 455     //wall floor area
 456     else if( rDispatchCommand.equals("DiagramWall"))
 457     {
 458         //OBJECTTYPE_DIAGRAM;
 459         eObjectType = OBJECTTYPE_DIAGRAM_WALL;
 460         //@todo set particular aParticleID if we have more than one diagram
 461     }
 462     else if( rDispatchCommand.equals("DiagramFloor"))
 463     {
 464         eObjectType = OBJECTTYPE_DIAGRAM_FLOOR;
 465         //@todo set particular aParticleID if we have more than one diagram
 466     }
 467     else if( rDispatchCommand.equals("DiagramArea"))
 468     {
 469         eObjectType = OBJECTTYPE_PAGE;
 470     }
 471     //-------------------------------------------------------------------------
 472     //title
 473     else if( rDispatchCommand.equals("MainTitle")
 474         || rDispatchCommand.equals("SubTitle")
 475         || rDispatchCommand.equals("XTitle")
 476         || rDispatchCommand.equals("YTitle")
 477         || rDispatchCommand.equals("ZTitle")
 478         || rDispatchCommand.equals("SecondaryXTitle")
 479         || rDispatchCommand.equals("SecondaryYTitle")
 480         || rDispatchCommand.equals("AllTitles")
 481         )
 482     {
 483         return lcl_getTitleCIDForCommand( rDispatchCommand, xChartModel );
 484     }
 485     //-------------------------------------------------------------------------
 486     //axis
 487     else if( rDispatchCommand.equals("DiagramAxisX")
 488         || rDispatchCommand.equals("DiagramAxisY")
 489         || rDispatchCommand.equals("DiagramAxisZ")
 490         || rDispatchCommand.equals("DiagramAxisA")
 491         || rDispatchCommand.equals("DiagramAxisB")
 492         || rDispatchCommand.equals("DiagramAxisAll")
 493         )
 494     {
 495         return lcl_getAxisCIDForCommand( rDispatchCommand, xChartModel );
 496     }
 497     //-------------------------------------------------------------------------
 498     //grid
 499     else if( rDispatchCommand.equals("DiagramGridYMain")
 500         || rDispatchCommand.equals("DiagramGridXMain")
 501         || rDispatchCommand.equals("DiagramGridZMain")
 502         || rDispatchCommand.equals("DiagramGridYHelp")
 503         || rDispatchCommand.equals("DiagramGridXHelp")
 504         || rDispatchCommand.equals("DiagramGridZHelp")
 505         || rDispatchCommand.equals("DiagramGridAll")
 506         )
 507     {
 508         return lcl_getGridCIDForCommand( rDispatchCommand, xChartModel );
 509     }
 510     return ObjectIdentifier::createClassifiedIdentifier(
 511         eObjectType, aParticleID );
 512 }
 513
 514 }
 515 // anonymous namespace
 516
 517 void SAL_CALL ChartController::executeDispatch_FormatObject(const ::rtl::OUString& rDispatchCommand)
 518 {
 519     uno::Reference< XChartDocument > xChartDocument( m_aModel->getModel(), uno::UNO_QUERY );
 520     rtl::OString aCommand( rtl::OUStringToOString( rDispatchCommand, RTL_TEXTENCODING_ASCII_US ) );
 521     rtl::OUString rObjectCID = lcl_getObjectCIDForCommand( aCommand, xChartDocument );
 522     executeDlg_ObjectProperties( rObjectCID );
 523 }
 524
 525 void SAL_CALL ChartController::executeDispatch_ObjectProperties()
 526 {
 527     executeDlg_ObjectProperties( m_aSelection.getSelectedCID() );
 528 }
 529
 530 void SAL_CALL ChartController::executeDlg_ObjectProperties( const ::rtl::OUString& rObjectCID )
 531 {
 532     if( !rObjectCID.getLength() )
 533     {
 534         //DBG_ERROR("empty ObjectID");
 535         return;
 536     }
 537     try
 538     {
 539         ::rtl::OUString aObjectCID(rObjectCID);
 540         NumberFormatterWrapper aNumberFormatterWrapper( uno::Reference< util::XNumberFormatsSupplier >(m_aModel->getModel(), uno::UNO_QUERY) );
 541
 542         //-------------------------------------------------------------
 543         //get type of selected object
 544         ObjectType eObjectType = ObjectIdentifier::getObjectType( aObjectCID );
 545         if( OBJECTTYPE_UNKNOWN==eObjectType )
 546         {
 547             //DBG_ERROR("unknown ObjectType");
 548             return;
 549         }
 550
 551         // some legend entries are handled as if they were data series
 552         if( OBJECTTYPE_LEGEND_ENTRY==eObjectType )
 553         {
 554             rtl::OUString aParentParticle( ObjectIdentifier::getFullParentParticle( aObjectCID ) );
 555             eObjectType = ObjectIdentifier::getObjectType( aParentParticle );
 556             aObjectCID  = ObjectIdentifier::createClassifiedIdentifierForParticle( aParentParticle );
 557         }
 558
 559         // treat diagram as wall
 560         if( OBJECTTYPE_DIAGRAM==eObjectType )
 561         {
 562             aObjectCID  = ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DIAGRAM_WALL, rtl::OUString() );
 563             eObjectType = OBJECTTYPE_DIAGRAM_WALL;
 564         }
 565
 566         if( OBJECTTYPE_DIAGRAM_WALL==eObjectType || OBJECTTYPE_DIAGRAM_FLOOR==eObjectType )
 567         {
 568             if( !DiagramHelper::isSupportingFloorAndWall( ChartModelHelper::findDiagram( m_aModel->getModel() ) ) )
 569                 return;
 570         }
 571
 572         //-------------------------------------------------------------
 573         UndoGuard aUndoGuard(
 574             ActionDescriptionProvider::createDescription(
 575                 ActionDescriptionProvider::FORMAT,
 576                 ObjectNameProvider::getName( ObjectIdentifier::getObjectType( aObjectCID ))),
 577             m_xUndoManager, m_aModel->getModel() );
 578
 579         //-------------------------------------------------------------
 580         //convert properties to ItemSet
 581
 582         awt::Size aPageSize( ChartModelHelper::getPageSize(m_aModel->getModel()) );
 583
 584         ::std::auto_ptr< ReferenceSizeProvider > pRefSizeProv(
 585             impl_createReferenceSizeProvider());
 586         ::std::auto_ptr< ::comphelper::ItemConverter > apItemConverter(
 587             createItemConverter( aObjectCID, m_aModel->getModel(), m_xCC,
 588                                  m_pDrawModelWrapper->getSdrModel(),
 589                                  &aNumberFormatterWrapper,
 590                                  ExplicitValueProvider::getExplicitValueProvider(m_xChartView),
 591                                  pRefSizeProv ));
 592         if(!apItemConverter.get())
 593             return;
 594
 595         SfxItemSet aItemSet = apItemConverter->CreateEmptyItemSet();
 596         apItemConverter->FillItemSet( aItemSet );
 597
 598         //-------------------------------------------------------------
 599         //prepare dialog
 600         ObjectPropertiesDialogParameter aDialogParameter = ObjectPropertiesDialogParameter( aObjectCID );
 601         aDialogParameter.init( m_aModel->getModel() );
 602         ViewElementListProvider aViewElementListProvider( m_pDrawModelWrapper.get() );
 603
 604         ::vos::OGuard aGuard( Application::GetSolarMutex());
 605         SchAttribTabDlg aDlg( m_pChartWindow, &aItemSet, &aDialogParameter, &aViewElementListProvider
 606             , uno::Reference< util::XNumberFormatsSupplier >( m_aModel->getModel(), uno::UNO_QUERY ) );
 607
 608         if(aDialogParameter.HasSymbolProperties())
 609         {
 610             SfxItemSet* pSymbolShapeProperties=NULL;
 611             uno::Reference< beans::XPropertySet > xObjectProperties =
 612                 ObjectIdentifier::getObjectPropertySet( aObjectCID, m_aModel->getModel() );
 613             wrapper::DataPointItemConverter aSymbolItemConverter( m_aModel->getModel(), m_xCC
 614                                         , xObjectProperties, ObjectIdentifier::getDataSeriesForCID( aObjectCID, m_aModel->getModel() )
 615                                         , m_pDrawModelWrapper->getSdrModel().GetItemPool()
 616                                         , m_pDrawModelWrapper->getSdrModel()
 617                                         , &aNumberFormatterWrapper
 618                                         , uno::Reference< lang::XMultiServiceFactory >( m_aModel->getModel(), uno::UNO_QUERY )
 619                                         , wrapper::GraphicPropertyItemConverter::FILLED_DATA_POINT );
 620
 621             pSymbolShapeProperties = new SfxItemSet( aSymbolItemConverter.CreateEmptyItemSet() );
 622             aSymbolItemConverter.FillItemSet( *pSymbolShapeProperties );
 623
 624             sal_Int32   nStandardSymbol=0;//@todo get from somewhere
 625             Graphic*    pAutoSymbolGraphic = new Graphic( aViewElementListProvider.GetSymbolGraphic( nStandardSymbol, pSymbolShapeProperties ) );
 626             // note: the dialog takes the ownership of pSymbolShapeProperties and pAutoSymbolGraphic
 627             aDlg.setSymbolInformation( pSymbolShapeProperties, pAutoSymbolGraphic );
 628         }
 629         if( aDialogParameter.HasStatisticProperties() )
 630         {
 631             aDlg.SetAxisMinorStepWidthForErrorBarDecimals(
 632                 InsertErrorBarsDialog::getAxisMinorStepWidthForErrorBarDecimals( m_aModel->getModel(), m_xChartView, aObjectCID ) );
 633         }
 634
 635         //-------------------------------------------------------------
 636         //open the dialog
 637         if( aDlg.Execute() == RET_OK )
 638         {
 639             const SfxItemSet* pOutItemSet = aDlg.GetOutputItemSet();
 640             if(pOutItemSet)
 641             {
 642                 bool bChanged = false;
 643                 {
 644                     ControllerLockGuard aCLGuard( m_aModel->getModel());
 645                     bChanged = apItemConverter->ApplyItemSet( *pOutItemSet );//model should be changed now
 646                 }
 647
 648                 if( bChanged )
 649                     aUndoGuard.commitAction();
 650             }
 651         }
 652     }
 653     catch( util::CloseVetoException& )
 654     {
 655     }
 656     catch( uno::RuntimeException& )
 657     {
 658     }
 659 }
 660
 661 void SAL_CALL ChartController::executeDispatch_View3D()
 662 {
 663     try
 664     {
 665         // using assignment for broken gcc 3.3
 666         UndoLiveUpdateGuard aUndoGuard = UndoLiveUpdateGuard(
 667             ::rtl::OUString( String( SchResId( STR_ACTION_EDIT_3D_VIEW ))),
 668             m_xUndoManager, m_aModel->getModel());
 669
 670         // /--
 671         //open dialog
 672         ::vos::OGuard aSolarGuard( Application::GetSolarMutex());
 673         View3DDialog aDlg( m_pChartWindow, m_aModel->getModel(), m_pDrawModelWrapper->GetColorTable() );
 674         if( aDlg.Execute() == RET_OK )
 675             aUndoGuard.commitAction();
 676         // \--
 677     }
 678     catch( uno::RuntimeException& e)
 679     {
 680         ASSERT_EXCEPTION( e );
 681     }
 682 }
 683
 684 //.............................................................................
 685 } //namespace chart
 686 //.............................................................................