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