chart2/source/controller/main/ChartController_Insert.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
  22 #include "dlg_InsertAxis_Grid.hxx"
  23 #include "dlg_InsertDataLabel.hxx"
  24 #include "dlg_InsertLegend.hxx"
  25 #include "dlg_InsertErrorBars.hxx"
  26 #include "dlg_InsertTitle.hxx"
  27 #include "dlg_ObjectProperties.hxx"
  28
  29 #include "ChartWindow.hxx"
  30 #include "ChartModelHelper.hxx"
  31 #include "AxisHelper.hxx"
  32 #include "TitleHelper.hxx"
  33 #include "DiagramHelper.hxx"
  34 #include "macros.hxx"
  35 #include "chartview/DrawModelWrapper.hxx"
  36 #include "NumberFormatterWrapper.hxx"
  37 #include "ViewElementListProvider.hxx"
  38 #include "MultipleChartConverters.hxx"
  39 #include "ControllerLockGuard.hxx"
  40 #include "UndoGuard.hxx"
  41 #include "ResId.hxx"
  42 #include "Strings.hrc"
  43 #include "ReferenceSizeProvider.hxx"
  44 #include "ObjectIdentifier.hxx"
  45 #include "RegressionCurveHelper.hxx"
  46 #include "RegressionCurveItemConverter.hxx"
  47 #include "StatisticsHelper.hxx"
  48 #include "ErrorBarItemConverter.hxx"
  49 #include "MultipleItemConverter.hxx"
  50 #include "DataSeriesHelper.hxx"
  51 #include "ObjectNameProvider.hxx"
  52 #include "LegendHelper.hxx"
  53
  54 #include <com/sun/star/chart2/XRegressionCurve.hpp>
  55 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  56 #include <svx/ActionDescriptionProvider.hxx>
  57
  58 #include <vcl/msgbox.hxx>
  59 #include <rtl/ustrbuf.hxx>
  60 #include <vcl/svapp.hxx>
  61 #include <osl/mutex.hxx>
  62
  63 using namespace ::com::sun::star;
  64 using namespace ::com::sun::star::chart2;
  65 using ::com::sun::star::uno::Reference;
  66 using ::com::sun::star::uno::Sequence;
  67
  68 namespace
  69 {
  70 struct lcl_InsertMeanValueLine
  71 {
  72 public:
  73     lcl_InsertMeanValueLine( const uno::Reference< uno::XComponentContext > & xContext ) :
  74             m_xContext( xContext )
  75     {}
  76
  77     void operator()( const uno::Reference< chart2::XDataSeries > & xSeries )
  78     {
  79         uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
  80             xSeries, uno::UNO_QUERY );
  81         if( xRegCurveCnt.is())
  82         {
  83             ::chart::RegressionCurveHelper::addMeanValueLine(
  84                 xRegCurveCnt, m_xContext, uno::Reference< beans::XPropertySet >( xSeries, uno::UNO_QUERY ));
  85         }
  86     }
  87
  88 private:
  89     uno::Reference< uno::XComponentContext > m_xContext;
  90 };
  91
  92 } // anonymous namespace
  93
  94 namespace chart
  95 {
  96
  97 void ChartController::executeDispatch_InsertAxes()
  98 {
  99     UndoGuard aUndoGuard(
 100         ActionDescriptionProvider::createDescription(
 101             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_AXES )),
 102         m_xUndoManager );
 103
 104     try
 105     {
 106         InsertAxisOrGridDialogData aDialogInput;
 107         uno::Reference< XDiagram > xDiagram = ChartModelHelper::findDiagram(getModel());
 108         AxisHelper::getAxisOrGridExcistence( aDialogInput.aExistenceList, xDiagram, true );
 109         AxisHelper::getAxisOrGridPossibilities( aDialogInput.aPossibilityList, xDiagram, true );
 110
 111         SolarMutexGuard aGuard;
 112         ScopedVclPtrInstance<SchAxisDlg> aDlg( m_pChartWindow, aDialogInput );
 113         if( aDlg->Execute() == RET_OK )
 114         {
 115             // lock controllers till end of block
 116             ControllerLockGuardUNO aCLGuard( getModel() );
 117
 118             InsertAxisOrGridDialogData aDialogOutput;
 119             aDlg->getResult( aDialogOutput );
 120             boost::scoped_ptr< ReferenceSizeProvider > mpRefSizeProvider(
 121                 impl_createReferenceSizeProvider());
 122             bool bChanged = AxisHelper::changeVisibilityOfAxes( xDiagram
 123                 , aDialogInput.aExistenceList, aDialogOutput.aExistenceList, m_xCC
 124                 , mpRefSizeProvider.get() );
 125             if( bChanged )
 126                 aUndoGuard.commit();
 127         }
 128     }
 129     catch(const uno::RuntimeException& e)
 130     {
 131         ASSERT_EXCEPTION( e );
 132     }
 133 }
 134
 135 void ChartController::executeDispatch_InsertGrid()
 136 {
 137     UndoGuard aUndoGuard(
 138         ActionDescriptionProvider::createDescription(
 139             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_GRIDS )),
 140         m_xUndoManager );
 141
 142     try
 143     {
 144         InsertAxisOrGridDialogData aDialogInput;
 145         uno::Reference< XDiagram > xDiagram = ChartModelHelper::findDiagram(getModel());
 146         AxisHelper::getAxisOrGridExcistence( aDialogInput.aExistenceList, xDiagram, false );
 147         AxisHelper::getAxisOrGridPossibilities( aDialogInput.aPossibilityList, xDiagram, false );
 148
 149         SolarMutexGuard aGuard;
 150         ScopedVclPtrInstance<SchGridDlg> aDlg(m_pChartWindow, aDialogInput);//aItemSet, b3D, bNet, bSecondaryX, bSecondaryY );
 151         if( aDlg->Execute() == RET_OK )
 152         {
 153             // lock controllers till end of block
 154             ControllerLockGuardUNO aCLGuard( getModel() );
 155             InsertAxisOrGridDialogData aDialogOutput;
 156             aDlg->getResult( aDialogOutput );
 157             bool bChanged = AxisHelper::changeVisibilityOfGrids( xDiagram
 158                 , aDialogInput.aExistenceList, aDialogOutput.aExistenceList, m_xCC );
 159             if( bChanged )
 160                 aUndoGuard.commit();
 161         }
 162     }
 163     catch(const uno::RuntimeException& e)
 164     {
 165         ASSERT_EXCEPTION( e );
 166     }
 167 }
 168
 169 void ChartController::executeDispatch_InsertTitles()
 170 {
 171     UndoGuard aUndoGuard(
 172         ActionDescriptionProvider::createDescription(
 173             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_TITLES )),
 174         m_xUndoManager );
 175
 176     try
 177     {
 178         TitleDialogData aDialogInput;
 179         aDialogInput.readFromModel( getModel() );
 180
 181         SolarMutexGuard aGuard;
 182         ScopedVclPtrInstance< SchTitleDlg > aDlg( m_pChartWindow, aDialogInput );
 183         if( aDlg->Execute() == RET_OK )
 184         {
 185             // lock controllers till end of block
 186             ControllerLockGuardUNO aCLGuard( getModel() );
 187             TitleDialogData aDialogOutput(impl_createReferenceSizeProvider());
 188             aDlg->getResult( aDialogOutput );
 189             bool bChanged = aDialogOutput.writeDifferenceToModel( getModel(), m_xCC, &aDialogInput );
 190             if( bChanged )
 191                 aUndoGuard.commit();
 192         }
 193     }
 194     catch(const uno::RuntimeException& e)
 195     {
 196         ASSERT_EXCEPTION( e );
 197     }
 198 }
 199
 200 void ChartController::executeDispatch_DeleteLegend()
 201 {
 202     UndoGuard aUndoGuard(
 203         ActionDescriptionProvider::createDescription(
 204             ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_LEGEND )),
 205         m_xUndoManager );
 206
 207     ChartModel& rModel = dynamic_cast<ChartModel&>(*getModel().get());
 208     LegendHelper::hideLegend(rModel);
 209     aUndoGuard.commit();
 210 }
 211
 212 void ChartController::executeDispatch_InsertLegend()
 213 {
 214     UndoGuard aUndoGuard(
 215         ActionDescriptionProvider::createDescription(
 216             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_LEGEND )),
 217         m_xUndoManager );
 218
 219     ChartModel& rModel = dynamic_cast<ChartModel&>(*getModel().get());
 220     Reference< chart2::XLegend > xLegend = LegendHelper::showLegend(rModel, m_xCC);
 221     aUndoGuard.commit();
 222 }
 223
 224 void ChartController::executeDispatch_OpenLegendDialog()
 225 {
 226     UndoGuard aUndoGuard(
 227         ActionDescriptionProvider::createDescription(
 228             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_LEGEND )),
 229         m_xUndoManager );
 230
 231     try
 232     {
 233         //prepare and open dialog
 234         SolarMutexGuard aGuard;
 235         ScopedVclPtrInstance< SchLegendDlg > aDlg( m_pChartWindow, m_xCC );
 236         aDlg->init( getModel() );
 237         if( aDlg->Execute() == RET_OK )
 238         {
 239             // lock controllers till end of block
 240             ControllerLockGuardUNO aCLGuard( getModel() );
 241             bool bChanged = aDlg->writeToModel( getModel() );
 242             if( bChanged )
 243                 aUndoGuard.commit();
 244         }
 245     }
 246     catch(const uno::RuntimeException& e)
 247     {
 248         ASSERT_EXCEPTION( e );
 249     }
 250 }
 251
 252 void ChartController::executeDispatch_InsertMenu_DataLabels()
 253 {
 254     UndoGuard aUndoGuard(
 255         ActionDescriptionProvider::createDescription(
 256             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_DATALABELS )),
 257         m_xUndoManager );
 258
 259     //if a series is selected insert labels for that series only:
 260     uno::Reference< chart2::XDataSeries > xSeries(
 261         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel()), uno::UNO_QUERY );
 262     if( xSeries.is() )
 263     {
 264         // add labels
 265         DataSeriesHelper::insertDataLabelsToSeriesAndAllPoints( xSeries );
 266
 267         OUString aChildParticle( ObjectIdentifier::getStringForType( OBJECTTYPE_DATA_LABELS ) + "=" );
 268         OUString aObjectCID = ObjectIdentifier::createClassifiedIdentifierForParticles(
 269             ObjectIdentifier::getSeriesParticleFromCID(m_aSelection.getSelectedCID()), aChildParticle );
 270
 271         bool bSuccess = ChartController::executeDlg_ObjectProperties_withoutUndoGuard( aObjectCID, true );
 272         if( bSuccess )
 273             aUndoGuard.commit();
 274         return;
 275     }
 276
 277     try
 278     {
 279         wrapper::AllDataLabelItemConverter aItemConverter(
 280             getModel(),
 281             m_pDrawModelWrapper->GetItemPool(),
 282             m_pDrawModelWrapper->getSdrModel(),
 283             uno::Reference< lang::XMultiServiceFactory >( getModel(), uno::UNO_QUERY ));
 284         SfxItemSet aItemSet = aItemConverter.CreateEmptyItemSet();
 285         aItemConverter.FillItemSet( aItemSet );
 286
 287         //prepare and open dialog
 288         SolarMutexGuard aGuard;
 289
 290         //get number formatter
 291         uno::Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier( getModel(), uno::UNO_QUERY );
 292         NumberFormatterWrapper aNumberFormatterWrapper( xNumberFormatsSupplier );
 293         SvNumberFormatter* pNumberFormatter = aNumberFormatterWrapper.getSvNumberFormatter();
 294
 295         ScopedVclPtrInstance< DataLabelsDialog > aDlg( m_pChartWindow, aItemSet, pNumberFormatter);
 296
 297         if( aDlg->Execute() == RET_OK )
 298         {
 299             SfxItemSet aOutItemSet = aItemConverter.CreateEmptyItemSet();
 300             aDlg->FillItemSet( aOutItemSet );
 301             // lock controllers till end of block
 302             ControllerLockGuardUNO aCLGuard( getModel() );
 303             bool bChanged = aItemConverter.ApplyItemSet( aOutItemSet );//model should be changed now
 304             if( bChanged )
 305                 aUndoGuard.commit();
 306         }
 307     }
 308     catch(const uno::RuntimeException& e)
 309     {
 310         ASSERT_EXCEPTION( e );
 311     }
 312 }
 313
 314 void ChartController::executeDispatch_InsertMeanValue()
 315 {
 316     UndoGuard aUndoGuard(
 317         ActionDescriptionProvider::createDescription(
 318             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_AVERAGE_LINE )),
 319         m_xUndoManager );
 320     lcl_InsertMeanValueLine( m_xCC ).operator()(
 321         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ));
 322     aUndoGuard.commit();
 323 }
 324
 325 void ChartController::executeDispatch_InsertMenu_MeanValues()
 326 {
 327     UndoGuard aUndoGuard(
 328         ActionDescriptionProvider::createDescription(
 329             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_AVERAGE_LINE )),
 330         m_xUndoManager );
 331
 332     uno::Reference< chart2::XDataSeries > xSeries(
 333         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 334     if( xSeries.is() )
 335     {
 336         //if a series is selected insert mean value only for that series:
 337         lcl_InsertMeanValueLine( m_xCC ).operator()(xSeries);
 338     }
 339     else
 340     {
 341         ::std::vector< uno::Reference< chart2::XDataSeries > > aSeries(
 342             DiagramHelper::getDataSeriesFromDiagram( ChartModelHelper::findDiagram( getModel() )));
 343         ::std::for_each( aSeries.begin(), aSeries.end(), lcl_InsertMeanValueLine( m_xCC ));
 344     }
 345     aUndoGuard.commit();
 346 }
 347
 348 void ChartController::executeDispatch_InsertMenu_Trendlines()
 349 {
 350     OUString aCID = m_aSelection.getSelectedCID();
 351
 352     uno::Reference< chart2::XDataSeries > xSeries(
 353         ObjectIdentifier::getDataSeriesForCID( aCID, getModel() ), uno::UNO_QUERY );
 354
 355     if( !xSeries.is() )
 356         return;
 357
 358     executeDispatch_InsertTrendline();
 359 }
 360
 361 void ChartController::executeDispatch_InsertTrendline()
 362 {
 363     uno::Reference< chart2::XRegressionCurveContainer > xRegressionCurveContainer(
 364         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel()), uno::UNO_QUERY );
 365
 366     if( !xRegressionCurveContainer.is() )
 367         return;
 368
 369     UndoLiveUpdateGuard aUndoGuard(
 370         ActionDescriptionProvider::createDescription(
 371             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_CURVE )),
 372         m_xUndoManager );
 373
 374     uno::Reference< chart2::XRegressionCurve > xCurve =
 375         RegressionCurveHelper::addRegressionCurve(
 376             CHREGRESS_LINEAR,
 377             xRegressionCurveContainer,
 378             m_xCC );
 379
 380     uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
 381
 382     if( !xProperties.is())
 383         return;
 384
 385     wrapper::RegressionCurveItemConverter aItemConverter(
 386         xProperties, xRegressionCurveContainer, m_pDrawModelWrapper->getSdrModel().GetItemPool(),
 387         m_pDrawModelWrapper->getSdrModel(),
 388         uno::Reference< lang::XMultiServiceFactory >( getModel(), uno::UNO_QUERY ));
 389
 390     // open dialog
 391     SfxItemSet aItemSet = aItemConverter.CreateEmptyItemSet();
 392     aItemConverter.FillItemSet( aItemSet );
 393     ObjectPropertiesDialogParameter aDialogParameter = ObjectPropertiesDialogParameter(
 394         ObjectIdentifier::createDataCurveCID(
 395             ObjectIdentifier::getSeriesParticleFromCID( m_aSelection.getSelectedCID()),
 396             RegressionCurveHelper::getRegressionCurveIndex( xRegressionCurveContainer, xCurve ), false ));
 397     aDialogParameter.init( getModel() );
 398     ViewElementListProvider aViewElementListProvider( m_pDrawModelWrapper.get());
 399     SolarMutexGuard aGuard;
 400     ScopedVclPtrInstance<SchAttribTabDlg> aDialog(
 401         m_pChartWindow, &aItemSet, &aDialogParameter,
 402         &aViewElementListProvider,
 403         uno::Reference< util::XNumberFormatsSupplier >(
 404                 getModel(), uno::UNO_QUERY ) );
 405
 406     // note: when a user pressed "OK" but didn't change any settings in the
 407     // dialog, the SfxTabDialog returns "Cancel"
 408     if( aDialog->Execute() == RET_OK || aDialog->DialogWasClosedWithOK())
 409     {
 410         const SfxItemSet* pOutItemSet = aDialog->GetOutputItemSet();
 411         if( pOutItemSet )
 412         {
 413             ControllerLockGuardUNO aCLGuard( getModel() );
 414             aItemConverter.ApplyItemSet( *pOutItemSet );
 415         }
 416         aUndoGuard.commit();
 417     }
 418 }
 419
 420 void ChartController::executeDispatch_InsertErrorBars( bool bYError )
 421 {
 422     ObjectType objType = bYError ? OBJECTTYPE_DATA_ERRORS_Y : OBJECTTYPE_DATA_ERRORS_X;
 423
 424     //if a series is selected insert error bars for that series only:
 425     uno::Reference< chart2::XDataSeries > xSeries(
 426         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 427
 428     if( xSeries.is())
 429     {
 430         UndoLiveUpdateGuard aUndoGuard(
 431             ActionDescriptionProvider::createDescription(
 432                 ActionDescriptionProvider::INSERT,
 433                 SCH_RESSTR( bYError ? STR_OBJECT_ERROR_BARS_Y : STR_OBJECT_ERROR_BARS_X )),
 434             m_xUndoManager );
 435
 436         // add error bars with standard deviation
 437         uno::Reference< beans::XPropertySet > xErrorBarProp(
 438             StatisticsHelper::addErrorBars( xSeries, m_xCC,
 439                                             ::com::sun::star::chart::ErrorBarStyle::STANDARD_DEVIATION,
 440                                             bYError));
 441
 442         // get an appropriate item converter
 443         wrapper::ErrorBarItemConverter aItemConverter(
 444             getModel(), xErrorBarProp, m_pDrawModelWrapper->getSdrModel().GetItemPool(),
 445             m_pDrawModelWrapper->getSdrModel(),
 446             uno::Reference< lang::XMultiServiceFactory >( getModel(), uno::UNO_QUERY ));
 447
 448         // open dialog
 449         SfxItemSet aItemSet = aItemConverter.CreateEmptyItemSet();
 450         aItemSet.Put(SfxBoolItem(SCHATTR_STAT_ERRORBAR_TYPE,bYError));
 451         aItemConverter.FillItemSet( aItemSet );
 452         ObjectPropertiesDialogParameter aDialogParameter = ObjectPropertiesDialogParameter(
 453             ObjectIdentifier::createClassifiedIdentifierWithParent(
 454                 objType, OUString(), m_aSelection.getSelectedCID()));
 455         aDialogParameter.init( getModel() );
 456         ViewElementListProvider aViewElementListProvider( m_pDrawModelWrapper.get());
 457         SolarMutexGuard aGuard;
 458         ScopedVclPtrInstance<SchAttribTabDlg> aDlg(
 459                 m_pChartWindow, &aItemSet, &aDialogParameter,
 460                 &aViewElementListProvider,
 461                 uno::Reference< util::XNumberFormatsSupplier >(
 462                         getModel(), uno::UNO_QUERY ) );
 463         aDlg->SetAxisMinorStepWidthForErrorBarDecimals(
 464             InsertErrorBarsDialog::getAxisMinorStepWidthForErrorBarDecimals( getModel(),
 465                                                                              m_xChartView, m_aSelection.getSelectedCID()));
 466
 467         // note: when a user pressed "OK" but didn't change any settings in the
 468         // dialog, the SfxTabDialog returns "Cancel"
 469         if( aDlg->Execute() == RET_OK || aDlg->DialogWasClosedWithOK())
 470         {
 471             const SfxItemSet* pOutItemSet = aDlg->GetOutputItemSet();
 472             if( pOutItemSet )
 473             {
 474                 ControllerLockGuardUNO aCLGuard( getModel() );
 475                 aItemConverter.ApplyItemSet( *pOutItemSet );
 476             }
 477             aUndoGuard.commit();
 478         }
 479     }
 480     else
 481     {
 482         //if no series is selected insert error bars for all series
 483         UndoGuard aUndoGuard(
 484             ActionDescriptionProvider::createDescription(
 485                 ActionDescriptionProvider::INSERT,
 486                 ObjectNameProvider::getName_ObjectForAllSeries( objType ) ),
 487             m_xUndoManager );
 488
 489         try
 490         {
 491             wrapper::AllSeriesStatisticsConverter aItemConverter(
 492                 getModel(), m_pDrawModelWrapper->GetItemPool() );
 493             SfxItemSet aItemSet = aItemConverter.CreateEmptyItemSet();
 494             aItemConverter.FillItemSet( aItemSet );
 495
 496             //prepare and open dialog
 497             SolarMutexGuard aGuard;
 498             ScopedVclPtrInstance<InsertErrorBarsDialog> aDlg(
 499                 m_pChartWindow, aItemSet,
 500                 uno::Reference< chart2::XChartDocument >( getModel(), uno::UNO_QUERY ),
 501                 bYError ? ErrorBarResources::ERROR_BAR_Y : ErrorBarResources::ERROR_BAR_X);
 502
 503             aDlg->SetAxisMinorStepWidthForErrorBarDecimals(
 504                 InsertErrorBarsDialog::getAxisMinorStepWidthForErrorBarDecimals( getModel(), m_xChartView, OUString() ) );
 505
 506             if( aDlg->Execute() == RET_OK )
 507             {
 508                 SfxItemSet aOutItemSet = aItemConverter.CreateEmptyItemSet();
 509                 aDlg->FillItemSet( aOutItemSet );
 510
 511                 // lock controllers till end of block
 512                 ControllerLockGuardUNO aCLGuard( getModel() );
 513                 bool bChanged = aItemConverter.ApplyItemSet( aOutItemSet );//model should be changed now
 514                 if( bChanged )
 515                     aUndoGuard.commit();
 516             }
 517         }
 518         catch(const uno::RuntimeException& e)
 519         {
 520             ASSERT_EXCEPTION( e );
 521         }
 522     }
 523 }
 524
 525 void ChartController::executeDispatch_InsertTrendlineEquation( bool bInsertR2 )
 526 {
 527     uno::Reference< chart2::XRegressionCurve > xRegCurve(
 528         ObjectIdentifier::getObjectPropertySet( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 529     if( !xRegCurve.is() )
 530     {
 531         uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
 532             ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 533         xRegCurve.set( RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCurveCnt ) );
 534     }
 535     if( xRegCurve.is())
 536     {
 537         uno::Reference< beans::XPropertySet > xEqProp( xRegCurve->getEquationProperties());
 538         if( xEqProp.is())
 539         {
 540             // using assignment for broken gcc 3.3
 541             UndoGuard aUndoGuard = UndoGuard(
 542                 ActionDescriptionProvider::createDescription(
 543                     ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_CURVE_EQUATION )),
 544                 m_xUndoManager );
 545             xEqProp->setPropertyValue( "ShowEquation", uno::makeAny( true ));
 546             xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::makeAny( bInsertR2 ));
 547             aUndoGuard.commit();
 548         }
 549     }
 550 }
 551
 552 void ChartController::executeDispatch_InsertR2Value()
 553 {
 554     uno::Reference< beans::XPropertySet > xEqProp(
 555         ObjectIdentifier::getObjectPropertySet( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 556     if( xEqProp.is())
 557     {
 558         UndoGuard aUndoGuard = UndoGuard(
 559             ActionDescriptionProvider::createDescription(
 560                 ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_CURVE_EQUATION )),
 561             m_xUndoManager );
 562         xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::makeAny( true ));
 563         aUndoGuard.commit();
 564     }
 565 }
 566
 567 void ChartController::executeDispatch_DeleteR2Value()
 568 {
 569     uno::Reference< beans::XPropertySet > xEqProp(
 570         ObjectIdentifier::getObjectPropertySet( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 571     if( xEqProp.is())
 572     {
 573         UndoGuard aUndoGuard = UndoGuard(
 574             ActionDescriptionProvider::createDescription(
 575                 ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_CURVE_EQUATION )),
 576             m_xUndoManager );
 577         xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::makeAny( false ));
 578         aUndoGuard.commit();
 579     }
 580 }
 581
 582 void ChartController::executeDispatch_DeleteMeanValue()
 583 {
 584     uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
 585         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 586     if( xRegCurveCnt.is())
 587     {
 588         UndoGuard aUndoGuard(
 589             ActionDescriptionProvider::createDescription(
 590                 ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_AVERAGE_LINE )),
 591             m_xUndoManager );
 592         RegressionCurveHelper::removeMeanValueLine( xRegCurveCnt );
 593         aUndoGuard.commit();
 594     }
 595 }
 596
 597 void ChartController::executeDispatch_DeleteTrendline()
 598 {
 599     uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
 600         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 601     if( xRegCurveCnt.is())
 602     {
 603         UndoGuard aUndoGuard(
 604             ActionDescriptionProvider::createDescription(
 605                 ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_CURVE )),
 606             m_xUndoManager );
 607         RegressionCurveHelper::removeAllExceptMeanValueLine( xRegCurveCnt );
 608         aUndoGuard.commit();
 609     }
 610 }
 611
 612 void ChartController::executeDispatch_DeleteTrendlineEquation()
 613 {
 614     uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
 615         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 616     if( xRegCurveCnt.is())
 617     {
 618         UndoGuard aUndoGuard(
 619             ActionDescriptionProvider::createDescription(
 620                 ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_CURVE_EQUATION )),
 621             m_xUndoManager );
 622         RegressionCurveHelper::removeEquations( xRegCurveCnt );
 623         aUndoGuard.commit();
 624     }
 625 }
 626
 627 void ChartController::executeDispatch_DeleteErrorBars( bool bYError )
 628 {
 629     uno::Reference< chart2::XDataSeries > xDataSeries(
 630         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ));
 631     if( xDataSeries.is())
 632     {
 633         UndoGuard aUndoGuard(
 634             ActionDescriptionProvider::createDescription(
 635                 ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_CURVE )),
 636             m_xUndoManager );
 637         StatisticsHelper::removeErrorBars( xDataSeries, bYError );
 638         aUndoGuard.commit();
 639     }
 640 }
 641
 642 void ChartController::executeDispatch_InsertDataLabels()
 643 {
 644     uno::Reference< chart2::XDataSeries > xSeries(
 645         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 646     if( xSeries.is() )
 647     {
 648         UndoGuard aUndoGuard = UndoGuard( ActionDescriptionProvider::createDescription( ActionDescriptionProvider::INSERT,
 649             SCH_RESSTR( STR_OBJECT_DATALABELS )),
 650             m_xUndoManager );
 651         DataSeriesHelper::insertDataLabelsToSeriesAndAllPoints( xSeries );
 652         aUndoGuard.commit();
 653     }
 654 }
 655
 656 void ChartController::executeDispatch_InsertDataLabel()
 657 {
 658     UndoGuard aUndoGuard = UndoGuard( ActionDescriptionProvider::createDescription( ActionDescriptionProvider::INSERT,
 659         SCH_RESSTR( STR_OBJECT_LABEL )),
 660         m_xUndoManager );
 661     DataSeriesHelper::insertDataLabelToPoint( ObjectIdentifier::getObjectPropertySet( m_aSelection.getSelectedCID(), getModel() ) );
 662     aUndoGuard.commit();
 663 }
 664
 665 void ChartController::executeDispatch_DeleteDataLabels()
 666 {
 667     uno::Reference< chart2::XDataSeries > xSeries(
 668         ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 669     if( xSeries.is() )
 670     {
 671         UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription( ActionDescriptionProvider::DELETE,
 672             SCH_RESSTR( STR_OBJECT_DATALABELS )),
 673             m_xUndoManager );
 674         DataSeriesHelper::deleteDataLabelsFromSeriesAndAllPoints( xSeries );
 675         aUndoGuard.commit();
 676     }
 677 }
 678
 679 void ChartController::executeDispatch_DeleteDataLabel()
 680 {
 681     UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription( ActionDescriptionProvider::DELETE,
 682         SCH_RESSTR( STR_OBJECT_LABEL )),
 683         m_xUndoManager );
 684     DataSeriesHelper::deleteDataLabelsFromPoint( ObjectIdentifier::getObjectPropertySet( m_aSelection.getSelectedCID(), getModel() ) );
 685     aUndoGuard.commit();
 686 }
 687
 688 void ChartController::executeDispatch_ResetAllDataPoints()
 689 {
 690     UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription( ActionDescriptionProvider::FORMAT,
 691         SCH_RESSTR( STR_OBJECT_DATAPOINTS )),
 692         m_xUndoManager );
 693     uno::Reference< chart2::XDataSeries > xSeries( ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 694     if( xSeries.is() )
 695         xSeries->resetAllDataPoints();
 696     aUndoGuard.commit();
 697 }
 698 void ChartController::executeDispatch_ResetDataPoint()
 699 {
 700     UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription( ActionDescriptionProvider::FORMAT,
 701         SCH_RESSTR( STR_OBJECT_DATAPOINT )),
 702         m_xUndoManager );
 703     uno::Reference< chart2::XDataSeries > xSeries( ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() ), uno::UNO_QUERY );
 704     if( xSeries.is() )
 705     {
 706         sal_Int32 nPointIndex = ObjectIdentifier::getIndexFromParticleOrCID( m_aSelection.getSelectedCID() );
 707         xSeries->resetDataPoint( nPointIndex );
 708     }
 709     aUndoGuard.commit();
 710 }
 711
 712 void ChartController::executeDispatch_InsertAxisTitle()
 713 {
 714     try
 715     {
 716         uno::Reference< XTitle > xTitle;
 717         {
 718             UndoGuard aUndoGuard(
 719             ActionDescriptionProvider::createDescription(
 720                 ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_TITLE )),
 721             m_xUndoManager );
 722
 723             Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
 724             sal_Int32 nDimensionIndex = -1;
 725             sal_Int32 nCooSysIndex = -1;
 726             sal_Int32 nAxisIndex = -1;
 727             AxisHelper::getIndicesForAxis( xAxis, ChartModelHelper::findDiagram(getModel()), nCooSysIndex, nDimensionIndex, nAxisIndex );
 728
 729             TitleHelper::eTitleType eTitleType = TitleHelper::X_AXIS_TITLE;
 730             if( nDimensionIndex==0 )
 731                 eTitleType = nAxisIndex==0 ? TitleHelper::X_AXIS_TITLE : TitleHelper::SECONDARY_X_AXIS_TITLE;
 732             else if( nDimensionIndex==1 )
 733                 eTitleType = nAxisIndex==0 ? TitleHelper::Y_AXIS_TITLE : TitleHelper::SECONDARY_Y_AXIS_TITLE;
 734             else
 735                 eTitleType = TitleHelper::Z_AXIS_TITLE;
 736
 737             boost::scoped_ptr< ReferenceSizeProvider > apRefSizeProvider( impl_createReferenceSizeProvider());
 738             xTitle = TitleHelper::createTitle( eTitleType, ObjectNameProvider::getTitleNameByType(eTitleType), getModel(), m_xCC, apRefSizeProvider.get() );
 739             aUndoGuard.commit();
 740         }
 741     }
 742     catch(const uno::RuntimeException& e)
 743     {
 744         ASSERT_EXCEPTION( e );
 745     }
 746 }
 747
 748 void ChartController::executeDispatch_InsertAxis()
 749 {
 750     UndoGuard aUndoGuard(
 751         ActionDescriptionProvider::createDescription(
 752             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_AXIS )),
 753         m_xUndoManager );
 754
 755     try
 756     {
 757         Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
 758         if( xAxis.is() )
 759         {
 760             AxisHelper::makeAxisVisible( xAxis );
 761             aUndoGuard.commit();
 762         }
 763     }
 764     catch(const uno::RuntimeException& e)
 765     {
 766         ASSERT_EXCEPTION( e );
 767     }
 768 }
 769
 770 void ChartController::executeDispatch_DeleteAxis()
 771 {
 772     UndoGuard aUndoGuard(
 773         ActionDescriptionProvider::createDescription(
 774             ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_AXIS )),
 775         m_xUndoManager );
 776
 777     try
 778     {
 779         Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
 780         if( xAxis.is() )
 781         {
 782             AxisHelper::makeAxisInvisible( xAxis );
 783             aUndoGuard.commit();
 784         }
 785     }
 786     catch(const uno::RuntimeException& e)
 787     {
 788         ASSERT_EXCEPTION( e );
 789     }
 790 }
 791
 792 void ChartController::executeDispatch_InsertMajorGrid()
 793 {
 794     UndoGuard aUndoGuard(
 795         ActionDescriptionProvider::createDescription(
 796             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_GRID )),
 797         m_xUndoManager );
 798
 799     try
 800     {
 801         Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
 802         if( xAxis.is() )
 803         {
 804             AxisHelper::makeGridVisible( xAxis->getGridProperties() );
 805             aUndoGuard.commit();
 806         }
 807     }
 808     catch(const uno::RuntimeException& e)
 809     {
 810         ASSERT_EXCEPTION( e );
 811     }
 812 }
 813
 814 void ChartController::executeDispatch_DeleteMajorGrid()
 815 {
 816     UndoGuard aUndoGuard(
 817         ActionDescriptionProvider::createDescription(
 818             ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_GRID )),
 819         m_xUndoManager );
 820
 821     try
 822     {
 823         Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
 824         if( xAxis.is() )
 825         {
 826             AxisHelper::makeGridInvisible( xAxis->getGridProperties() );
 827             aUndoGuard.commit();
 828         }
 829     }
 830     catch(const uno::RuntimeException& e)
 831     {
 832         ASSERT_EXCEPTION( e );
 833     }
 834 }
 835
 836 void ChartController::executeDispatch_InsertMinorGrid()
 837 {
 838     UndoGuard aUndoGuard(
 839         ActionDescriptionProvider::createDescription(
 840             ActionDescriptionProvider::INSERT, SCH_RESSTR( STR_OBJECT_GRID )),
 841         m_xUndoManager );
 842
 843     try
 844     {
 845         Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
 846         if( xAxis.is() )
 847         {
 848             Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
 849             for( sal_Int32 nN=0; nN<aSubGrids.getLength(); nN++)
 850                 AxisHelper::makeGridVisible( aSubGrids[nN] );
 851             aUndoGuard.commit();
 852         }
 853     }
 854     catch(const uno::RuntimeException& e)
 855     {
 856         ASSERT_EXCEPTION( e );
 857     }
 858 }
 859
 860 void ChartController::executeDispatch_DeleteMinorGrid()
 861 {
 862     UndoGuard aUndoGuard(
 863         ActionDescriptionProvider::createDescription(
 864             ActionDescriptionProvider::DELETE, SCH_RESSTR(STR_OBJECT_GRID)),
 865         m_xUndoManager );
 866
 867     try
 868     {
 869         Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
 870         if( xAxis.is() )
 871         {
 872             Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
 873             for( sal_Int32 nN=0; nN<aSubGrids.getLength(); nN++)
 874                 AxisHelper::makeGridInvisible( aSubGrids[nN] );
 875             aUndoGuard.commit();
 876         }
 877     }
 878     catch(const uno::RuntimeException& e)
 879     {
 880         ASSERT_EXCEPTION( e );
 881     }
 882 }
 883
 884 } //namespace chart
 885
 886 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */