chart2/source/controller/main/ChartController_Tools.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <ChartController.hxx>
  21 #include <ChartWindow.hxx>
  22 #include <ChartModel.hxx>
  23 #include <ChartModelHelper.hxx>
  24 #include <ChartType.hxx>
  25 #include <TitleHelper.hxx>
  26 #include <DataSeries.hxx>
  27 #include <DataSeriesHelper.hxx>
  28 #include "UndoGuard.hxx"
  29 #include <ControllerLockGuard.hxx>
  30 #include <ResId.hxx>
  31 #include <strings.hrc>
  32 #include <ObjectIdentifier.hxx>
  33 #include <ReferenceSizeProvider.hxx>
  34 #include <chartview/DrawModelWrapper.hxx>
  35 #include "ChartTransferable.hxx"
  36 #include <DrawViewWrapper.hxx>
  37 #include <Legend.hxx>
  38 #include <LegendHelper.hxx>
  39 #include <Axis.hxx>
  40 #include <AxisHelper.hxx>
  41 #include <RegressionCurveModel.hxx>
  42 #include <RegressionCurveHelper.hxx>
  43 #include "ShapeController.hxx"
  44 #include <DiagramHelper.hxx>
  45 #include <Diagram.hxx>
  46 #include <ObjectNameProvider.hxx>
  47 #include <unonames.hxx>
  48
  49 #include <com/sun/star/awt/Gradient.hpp>
  50 #include <com/sun/star/chart2/DataPointLabel.hpp>
  51 #include <com/sun/star/graphic/XGraphic.hpp>
  52 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
  53 #include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
  54 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  55 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
  56
  57 #include <docmodel/uno/UnoGradientTools.hxx>
  58 #include <editeng/editview.hxx>
  59 #include <editeng/outliner.hxx>
  60 #include <svx/ActionDescriptionProvider.hxx>
  61 #include <vcl/transfer.hxx>
  62 #include <sot/storage.hxx>
  63 #include <vcl/graph.hxx>
  64 #include <vcl/TypeSerializer.hxx>
  65 #include <svx/unomodel.hxx>
  66 #include <svx/svdmodel.hxx>
  67 #include <unotools/streamwrap.hxx>
  68 #include <vcl/svapp.hxx>
  69 #include <svx/dialmgr.hxx>
  70 #include <svx/strings.hrc>
  71 #include <svx/svditer.hxx>
  72 #include <svx/svdpage.hxx>
  73 #include <svx/svdundo.hxx>
  74 #include <svx/unoapi.hxx>
  75 #include <svx/unopage.hxx>
  76 #include <svx/unoshape.hxx>
  77 #include <PropertyHelper.hxx>
  78
  79 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  80 #include <tools/debug.hxx>
  81 #include <comphelper/diagnose_ex.hxx>
  82 #include <tools/UnitConversion.hxx>
  83
  84 #include <memory>
  85
  86 using namespace ::com::sun::star;
  87
  88 using ::com::sun::star::uno::Reference;
  89 using ::com::sun::star::uno::Sequence;
  90
  91 namespace chart
  92 {
  93
  94 namespace
  95 {
  96
  97 bool lcl_deleteDataSeries(
  98     std::u16string_view rCID,
  99     const rtl::Reference<::chart::ChartModel> & xModel,
 100     const Reference< document::XUndoManager > & xUndoManager )
 101 {
 102     bool bResult = false;
 103     rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( rCID, xModel );
 104     if( xSeries.is() && xModel.is())
 105     {
 106         rtl::Reference< ::chart::ChartType > xChartType =
 107             DataSeriesHelper::getChartTypeOfSeries( xSeries, xModel->getFirstChartDiagram());
 108         if( xChartType.is())
 109         {
 110             UndoGuard aUndoGuard(
 111                 ActionDescriptionProvider::createDescription(
 112                     ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_DATASERIES )),
 113                 xUndoManager );
 114
 115             rtl::Reference< Diagram > xDiagram = xModel->getFirstChartDiagram();
 116             rtl::Reference< Axis > xAxis = xDiagram->getAttachedAxis( xSeries );
 117
 118             DataSeriesHelper::deleteSeries( xSeries, xChartType );
 119
 120             AxisHelper::hideAxisIfNoDataIsAttached( xAxis, xDiagram );
 121
 122             bResult = true;
 123             aUndoGuard.commit();
 124         }
 125     }
 126     return bResult;
 127 }
 128
 129 bool lcl_deleteDataCurve(
 130     std::u16string_view rCID,
 131     const rtl::Reference<::chart::ChartModel> & xModel,
 132     const Reference< document::XUndoManager > & xUndoManager )
 133 {
 134     bool bResult = false;
 135
 136     uno::Reference< beans::XPropertySet > xProperties(
 137         ObjectIdentifier::getObjectPropertySet( rCID, xModel));
 138
 139     uno::Reference< chart2::XRegressionCurve > xRegressionCurve( xProperties, uno::UNO_QUERY );
 140
 141     if( xRegressionCurve.is())
 142     {
 143         uno::Reference< chart2::XRegressionCurveContainer > xRegressionCurveContainer(
 144             ObjectIdentifier::getObjectPropertySet(
 145                 ObjectIdentifier::getFullParentParticle( rCID ), xModel), uno::UNO_QUERY );
 146
 147         if( xRegressionCurveContainer.is())
 148         {
 149             UndoGuard aUndoGuard(
 150                 ActionDescriptionProvider::createDescription(
 151                     ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_CURVE )),
 152                 xUndoManager );
 153
 154             xRegressionCurveContainer->removeRegressionCurve( xRegressionCurve );
 155
 156             bResult = true;
 157             aUndoGuard.commit();
 158         }
 159     }
 160     return bResult;
 161 }
 162
 163 } // anonymous namespace
 164
 165 ReferenceSizeProvider ChartController::impl_createReferenceSizeProvider()
 166 {
 167     awt::Size aPageSize( ChartModelHelper::getPageSize( getChartModel() ) );
 168
 169     return ReferenceSizeProvider(aPageSize, getChartModel());
 170 }
 171
 172 void ChartController::impl_adaptDataSeriesAutoResize()
 173 {
 174     impl_createReferenceSizeProvider().setValuesAtAllDataSeries();
 175 }
 176
 177 void ChartController::executeDispatch_NewArrangement()
 178 {
 179     // remove manual positions at titles, legend and the diagram, remove manual
 180     // size at the diagram
 181
 182     try
 183     {
 184         rtl::Reference<::chart::ChartModel> xModel( getChartModel() );
 185         rtl::Reference< Diagram > xDiagram = xModel->getFirstChartDiagram();
 186         if( xDiagram.is())
 187         {
 188             UndoGuard aUndoGuard(
 189                 SchResId( STR_ACTION_REARRANGE_CHART ),
 190                 m_xUndoManager );
 191             ControllerLockGuardUNO aCtlLockGuard( xModel );
 192
 193             // diagram
 194             xDiagram->setPropertyToDefault( u"RelativeSize"_ustr);
 195             xDiagram->setPropertyToDefault( u"RelativePosition"_ustr);
 196             xDiagram->setPropertyToDefault( u"PosSizeExcludeAxes"_ustr);
 197
 198             // 3d rotation
 199             xDiagram->set3DSettingsToDefault();
 200
 201             // legend
 202             rtl::Reference< Legend > xLegend = xDiagram->getLegend2();
 203             if( xLegend.is())
 204             {
 205                 xLegend->setPropertyToDefault( u"RelativePosition"_ustr);
 206                 xLegend->setPropertyToDefault( u"RelativeSize"_ustr);
 207                 xLegend->setPropertyToDefault( u"AnchorPosition"_ustr);
 208             }
 209
 210             // titles
 211             for( sal_Int32 eType = TitleHelper::TITLE_BEGIN;
 212                  eType < TitleHelper::NORMAL_TITLE_END;
 213                  ++eType )
 214             {
 215                 rtl::Reference< Title > xTitleState =
 216                     TitleHelper::getTitle(
 217                         static_cast< TitleHelper::eTitleType >( eType ), xModel );
 218                 if( xTitleState.is())
 219                     xTitleState->setPropertyToDefault( u"RelativePosition"_ustr);
 220             }
 221
 222             // regression curve equations
 223             std::vector< rtl::Reference< RegressionCurveModel > > aRegressionCurves =
 224                 xDiagram->getAllRegressionCurvesNotMeanValueLine();
 225
 226             // reset equation position
 227             for( const auto& xCurve : aRegressionCurves )
 228                 RegressionCurveHelper::resetEquationPosition( xCurve );
 229
 230             aUndoGuard.commit();
 231         }
 232     }
 233     catch( const uno::RuntimeException & )
 234     {
 235         DBG_UNHANDLED_EXCEPTION("chart2");
 236     }
 237 }
 238
 239 void ChartController::executeDispatch_ScaleText()
 240 {
 241     SolarMutexGuard aSolarGuard;
 242     UndoGuard aUndoGuard(
 243         SchResId( STR_ACTION_SCALE_TEXT ),
 244         m_xUndoManager );
 245     ControllerLockGuardUNO aCtlLockGuard( getChartModel() );
 246
 247     impl_createReferenceSizeProvider().toggleAutoResizeState();
 248
 249     aUndoGuard.commit();
 250 }
 251
 252 void ChartController::executeDispatch_Paste()
 253 {
 254     SolarMutexGuard aGuard;
 255     auto pChartWindow(GetChartWindow());
 256     if( !pChartWindow )
 257         return;
 258
 259     Graphic aGraphic;
 260     // paste location: center of window
 261     Point aPos = pChartWindow->PixelToLogic( tools::Rectangle(Point{}, pChartWindow->GetSizePixel()).Center());
 262
 263     // handle different formats
 264     TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pChartWindow ));
 265     if( aDataHelper.GetTransferable().is())
 266     {
 267         if ( aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ) )
 268         {
 269             if (std::unique_ptr<SvStream> xStm = aDataHelper.GetSotStorageStream( SotClipboardFormatId::DRAWING) )
 270             {
 271                 xStm->Seek( 0 );
 272                 Reference< io::XInputStream > xInputStream( new utl::OInputStreamWrapper( *xStm ) );
 273
 274                 std::unique_ptr< SdrModel > spModel(
 275                     new SdrModel());
 276
 277                 if ( SvxDrawingLayerImport( spModel.get(), xInputStream ) )
 278                 {
 279                     impl_PasteShapes( spModel.get() );
 280                 }
 281             }
 282         }
 283         else if ( aDataHelper.HasFormat( SotClipboardFormatId::SVXB ) )
 284         {
 285             // graphic exchange format (graphic manager bitmap format?)
 286             if (std::unique_ptr<SvStream> xStm = aDataHelper.GetSotStorageStream( SotClipboardFormatId::SVXB ))
 287             {
 288                 TypeSerializer aSerializer(*xStm);
 289                 aSerializer.readGraphic(aGraphic);
 290             }
 291         }
 292         else if( aDataHelper.HasFormat( SotClipboardFormatId::GDIMETAFILE ))
 293         {
 294             // meta file
 295             GDIMetaFile aMetafile;
 296             if( aDataHelper.GetGDIMetaFile( SotClipboardFormatId::GDIMETAFILE, aMetafile ))
 297                 aGraphic = Graphic( aMetafile );
 298         }
 299         else if( aDataHelper.HasFormat( SotClipboardFormatId::BITMAP ))
 300         {
 301             // bitmap (non-graphic-manager)
 302             BitmapEx aBmpEx;
 303             if( aDataHelper.GetBitmapEx( SotClipboardFormatId::BITMAP, aBmpEx ))
 304                 aGraphic = Graphic( aBmpEx );
 305         }
 306         else if( aDataHelper.HasFormat( SotClipboardFormatId::STRING ))
 307         {
 308             OUString aString;
 309             if( aDataHelper.GetString( SotClipboardFormatId::STRING, aString ) && m_pDrawModelWrapper )
 310             {
 311                 if( m_pDrawViewWrapper )
 312                 {
 313                     OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
 314                     if (pOutlinerView)//in case of edit mode insert the formatted string
 315                         pOutlinerView->PasteSpecial();
 316                     else
 317                     {
 318                         impl_PasteStringAsTextShape( aString, awt::Point( 0, 0 ) );
 319                     }
 320                 }
 321             }
 322         }
 323     }
 324
 325     if( aGraphic.GetType() != GraphicType::NONE )
 326     {
 327         Reference< graphic::XGraphic > xGraphic( aGraphic.GetXGraphic());
 328         if( xGraphic.is())
 329             impl_PasteGraphic( xGraphic, aPos );
 330     }
 331 }
 332
 333 // note: aPosition is ignored for now. The object is always pasted centered to
 334 // the page
 335 void ChartController::impl_PasteGraphic(
 336     uno::Reference< graphic::XGraphic > const & xGraphic,
 337     const ::Point & /* aPosition */ )
 338 {
 339     DBG_TESTSOLARMUTEX();
 340     // note: the XPropertySet of the model is the old API. Also the property
 341     // "AdditionalShapes" that is used there.
 342     rtl::Reference< ChartModel > xModel = getChartModel();
 343     DrawModelWrapper * pDrawModelWrapper( GetDrawModelWrapper());
 344     if( ! (xGraphic.is() && xModel.is()))
 345         return;
 346     rtl::Reference<SvxGraphicObject> xGraphicShape = new SvxGraphicObject(nullptr);
 347     xGraphicShape->setShapeKind(SdrObjKind::Graphic);
 348
 349     uno::Reference< drawing::XShapes > xPage = pDrawModelWrapper->getMainDrawPage();
 350     if( xPage.is())
 351     {
 352         xPage->add( xGraphicShape );
 353         //need to change the model state manually
 354         xModel->setModified( true );
 355         //select new shape
 356         m_aSelection.setSelection( xGraphicShape );
 357         m_aSelection.applySelection( m_pDrawViewWrapper.get() );
 358     }
 359     xGraphicShape->SvxShape::setPropertyValue( u"Graphic"_ustr, uno::Any( xGraphic ));
 360
 361     awt::Size aGraphicSize( 1000, 1000 );
 362     bool bGotGraphicSize = false;
 363     try
 364     {
 365         bGotGraphicSize = xGraphicShape->SvxShape::getPropertyValue( u"Size100thMM"_ustr) >>= aGraphicSize;
 366     }
 367     catch (css::beans::UnknownPropertyException& )
 368     {}
 369     auto pChartWindow(GetChartWindow());
 370     // first try size in 100th mm, then pixel size
 371     if( !bGotGraphicSize )
 372     {
 373         bool bGotSizePixel = false;
 374         try
 375         {
 376             bGotSizePixel = xGraphicShape->SvxShape::getPropertyValue( u"SizePixel"_ustr) >>= aGraphicSize;
 377         }
 378         catch (css::beans::UnknownPropertyException& )
 379         {}
 380         if ( bGotSizePixel && pChartWindow )
 381         {
 382             ::Size aVCLSize( pChartWindow->PixelToLogic( Size( aGraphicSize.Width, aGraphicSize.Height )));
 383             aGraphicSize.Width = aVCLSize.getWidth();
 384             aGraphicSize.Height = aVCLSize.getHeight();
 385         }
 386     }
 387     xGraphicShape->setSize( aGraphicSize );
 388     xGraphicShape->setPosition( awt::Point( 0, 0 ) );
 389 }
 390
 391 void ChartController::impl_PasteShapes( SdrModel* pModel )
 392 {
 393     DrawModelWrapper* pDrawModelWrapper( GetDrawModelWrapper() );
 394     if ( !(pDrawModelWrapper && m_pDrawViewWrapper) )
 395         return;
 396
 397     Reference< drawing::XDrawPage > xDestPage( pDrawModelWrapper->getMainDrawPage() );
 398     SdrPage* pDestPage = GetSdrPageFromXDrawPage( xDestPage );
 399     if ( !pDestPage )
 400         return;
 401
 402     Reference< drawing::XShape > xSelShape;
 403     m_pDrawViewWrapper->BegUndo( SvxResId( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );
 404     sal_uInt16 nCount = pModel->GetPageCount();
 405     for ( sal_uInt16 i = 0; i < nCount; ++i )
 406     {
 407         const SdrPage* pPage = pModel->GetPage( i );
 408         SdrObjListIter aIter( pPage, SdrIterMode::DeepNoGroups );
 409         while ( aIter.IsMore() )
 410         {
 411             SdrObject* pObj(aIter.Next());
 412             // Clone to new SdrModel
 413             rtl::Reference<SdrObject> pNewObj;
 414             if (pObj)
 415                 pNewObj = pObj->CloneSdrObject(pDrawModelWrapper->getSdrModel());
 416
 417             if ( pNewObj )
 418             {
 419                 // set position
 420                 Reference< drawing::XShape > xShape( pNewObj->getUnoShape(), uno::UNO_QUERY );
 421                 if ( xShape.is() )
 422                 {
 423                     xShape->setPosition( awt::Point( 0, 0 ) );
 424                 }
 425
 426                 pDestPage->InsertObject( pNewObj.get() );
 427                 m_pDrawViewWrapper->AddUndo( std::make_unique<SdrUndoInsertObj>( *pNewObj ) );
 428                 xSelShape = std::move(xShape);
 429             }
 430         }
 431     }
 432
 433     rtl::Reference< ChartModel > xModifiable = getChartModel();
 434     if ( xModifiable.is() )
 435     {
 436         xModifiable->setModified( true );
 437     }
 438
 439     // select last inserted shape
 440     m_aSelection.setSelection( xSelShape );
 441     m_aSelection.applySelection( m_pDrawViewWrapper.get() );
 442
 443     m_pDrawViewWrapper->EndUndo();
 444
 445     impl_switchDiagramPositioningToExcludingPositioning();
 446 }
 447
 448 void ChartController::impl_PasteStringAsTextShape( const OUString& rString, const awt::Point& rPosition )
 449 {
 450     DrawModelWrapper* pDrawModelWrapper( GetDrawModelWrapper() );
 451     if ( !(pDrawModelWrapper && m_pDrawViewWrapper) )
 452         return;
 453
 454     const Reference< drawing::XDrawPage > xDrawPage( pDrawModelWrapper->getMainDrawPage() );
 455     OSL_ASSERT( xDrawPage.is() );
 456
 457     if ( !xDrawPage )
 458         return;
 459
 460     try
 461     {
 462         rtl::Reference<SvxShapeText> xTextShape = new SvxShapeText(nullptr);
 463         xTextShape->setShapeKind(SdrObjKind::Text);
 464         xDrawPage->add( xTextShape );
 465
 466         xTextShape->setString( rString );
 467
 468         float fCharHeight = 10.0;
 469         xTextShape->SvxShape::setPropertyValue( u"TextAutoGrowHeight"_ustr, uno::Any( true ) );
 470         xTextShape->SvxShape::setPropertyValue( u"TextAutoGrowWidth"_ustr, uno::Any( true ) );
 471         xTextShape->SvxShape::setPropertyValue( u"CharHeight"_ustr, uno::Any( fCharHeight ) );
 472         xTextShape->SvxShape::setPropertyValue( u"CharHeightAsian"_ustr, uno::Any( fCharHeight ) );
 473         xTextShape->SvxShape::setPropertyValue( u"CharHeightComplex"_ustr, uno::Any( fCharHeight ) );
 474         xTextShape->SvxShape::setPropertyValue( u"TextVerticalAdjust"_ustr, uno::Any( drawing::TextVerticalAdjust_CENTER ) );
 475         xTextShape->SvxShape::setPropertyValue( u"TextHorizontalAdjust"_ustr, uno::Any( drawing::TextHorizontalAdjust_CENTER ) );
 476         xTextShape->SvxShape::setPropertyValue( u"CharFontName"_ustr, uno::Any( u"Albany"_ustr ) );
 477
 478         xTextShape->setPosition( rPosition );
 479
 480         m_aSelection.setSelection( xTextShape );
 481         m_aSelection.applySelection( m_pDrawViewWrapper.get() );
 482
 483         SdrObject* pObj = DrawViewWrapper::getSdrObject( xTextShape );
 484         if ( pObj )
 485         {
 486             m_pDrawViewWrapper->BegUndo( SvxResId( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );
 487             m_pDrawViewWrapper->AddUndo( std::make_unique<SdrUndoInsertObj>( *pObj ) );
 488             m_pDrawViewWrapper->EndUndo();
 489
 490             impl_switchDiagramPositioningToExcludingPositioning();
 491         }
 492     }
 493     catch ( const uno::Exception& )
 494     {
 495         DBG_UNHANDLED_EXCEPTION("chart2");
 496     }
 497 }
 498
 499 void ChartController::executeDispatch_Copy()
 500 {
 501     SolarMutexGuard aSolarGuard;
 502     if (!m_pDrawViewWrapper)
 503         return;
 504
 505     OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
 506     if (pOutlinerView)
 507         pOutlinerView->Copy();
 508     else
 509     {
 510         SdrObject* pSelectedObj = nullptr;
 511         ObjectIdentifier aSelOID(m_aSelection.getSelectedOID());
 512
 513         if (aSelOID.isAutoGeneratedObject())
 514             pSelectedObj = m_pDrawModelWrapper->getNamedSdrObject( aSelOID.getObjectCID() );
 515         else if (aSelOID.isAdditionalShape())
 516             pSelectedObj = DrawViewWrapper::getSdrObject( aSelOID.getAdditionalShape() );
 517
 518         if (pSelectedObj)
 519         {
 520             Reference<datatransfer::clipboard::XClipboard> xClipboard(GetChartWindow()->GetClipboard());
 521             if (xClipboard.is())
 522             {
 523                 Reference< datatransfer::XTransferable > xTransferable(
 524                     new ChartTransferable(m_pDrawModelWrapper->getSdrModel(),
 525                                           pSelectedObj, aSelOID.isAdditionalShape()));
 526                 xClipboard->setContents(xTransferable, Reference< datatransfer::clipboard::XClipboardOwner >());
 527             }
 528         }
 529     }
 530 }
 531
 532 void ChartController::executeDispatch_Cut()
 533 {
 534     executeDispatch_Copy();
 535     executeDispatch_Delete();
 536 }
 537
 538 bool ChartController::isObjectDeleteable( const uno::Any& rSelection )
 539 {
 540     ObjectIdentifier aSelOID( rSelection );
 541     if ( aSelOID.isAutoGeneratedObject() )
 542     {
 543         const OUString& aSelObjCID( aSelOID.getObjectCID() );
 544         ObjectType aObjectType(ObjectIdentifier::getObjectType( aSelObjCID ));
 545
 546         switch(aObjectType)
 547         {
 548         case OBJECTTYPE_TITLE:
 549         case OBJECTTYPE_LEGEND:
 550         case OBJECTTYPE_DATA_SERIES:
 551         case OBJECTTYPE_LEGEND_ENTRY:
 552         case OBJECTTYPE_DATA_CURVE_EQUATION:
 553         case OBJECTTYPE_DATA_CURVE:
 554         case OBJECTTYPE_DATA_AVERAGE_LINE:
 555         case OBJECTTYPE_DATA_ERRORS_X:
 556         case OBJECTTYPE_DATA_ERRORS_Y:
 557         case OBJECTTYPE_DATA_ERRORS_Z:
 558         case OBJECTTYPE_DATA_LABELS:
 559         case OBJECTTYPE_DATA_LABEL:
 560         case OBJECTTYPE_AXIS:
 561         case OBJECTTYPE_GRID:
 562         case OBJECTTYPE_SUBGRID:
 563             return true;
 564         default:
 565             break;
 566         }
 567     }
 568     else if ( aSelOID.isAdditionalShape() )
 569     {
 570         return true;
 571     }
 572
 573     return false;
 574 }
 575
 576 bool ChartController::isShapeContext() const
 577 {
 578     return m_aSelection.isAdditionalShapeSelected() ||
 579          ( m_pDrawViewWrapper && m_pDrawViewWrapper->GetMarkedObjectList().GetMarkCount() != 0 &&
 580            ( m_pDrawViewWrapper->GetCurrentObjIdentifier() == SdrObjKind::Text ) );
 581 }
 582
 583 bool ChartController::IsTextEdit() const
 584 {
 585     // only Title objects and additional shapes are editable textshapes in chart
 586     return m_pDrawViewWrapper && m_pDrawViewWrapper->IsTextEdit() &&
 587         (m_aSelection.isTitleObjectSelected() || m_aSelection.isAdditionalShapeSelected());
 588 }
 589
 590 void ChartController::impl_ClearSelection()
 591 {
 592     if( m_aSelection.hasSelection())
 593     {
 594         m_aSelection.clearSelection();
 595         impl_notifySelectionChangeListeners();
 596     }
 597 }
 598
 599 bool ChartController::executeDispatch_Delete()
 600 {
 601     bool bReturn = false;
 602
 603     // remove the selected object
 604     OUString aCID( m_aSelection.getSelectedCID() );
 605     if( !aCID.isEmpty() )
 606     {
 607         if( !isObjectDeleteable( uno::Any( aCID ) ) )
 608             return false;
 609
 610         //remove chart object
 611         rtl::Reference< ChartModel > xChartDoc = getChartModel();
 612         if( !xChartDoc.is() )
 613             return false;
 614
 615         ObjectType aObjectType( ObjectIdentifier::getObjectType( aCID ));
 616         switch( aObjectType )
 617         {
 618             case OBJECTTYPE_TITLE:
 619             {
 620                 UndoGuard aUndoGuard(
 621                     ActionDescriptionProvider::createDescription(
 622                         ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_TITLE )),
 623                     m_xUndoManager );
 624                 TitleHelper::removeTitle(
 625                     ObjectIdentifier::getTitleTypeForCID( aCID ), getChartModel() );
 626                 bReturn = true;
 627                 aUndoGuard.commit();
 628                 break;
 629             }
 630             case OBJECTTYPE_LEGEND:
 631             {
 632                 rtl::Reference< Diagram > xDiagram( xChartDoc->getFirstChartDiagram());
 633                 if( xDiagram.is())
 634                 {
 635                     rtl::Reference< Legend > xLegend( xDiagram->getLegend2() );
 636                     if( xLegend.is())
 637                     {
 638                         UndoGuard aUndoGuard(
 639                             ActionDescriptionProvider::createDescription(
 640                                 ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_LEGEND )),
 641                             m_xUndoManager );
 642                         xLegend->setPropertyValue( u"Show"_ustr, uno::Any( false ));
 643                         bReturn = true;
 644                         aUndoGuard.commit();
 645                     }
 646                 }
 647                 break;
 648             }
 649
 650             case OBJECTTYPE_DATA_SERIES:
 651                 bReturn = lcl_deleteDataSeries( aCID, getChartModel(), m_xUndoManager );
 652                 break;
 653
 654             case OBJECTTYPE_LEGEND_ENTRY:
 655             {
 656                 ObjectType eParentObjectType = ObjectIdentifier::getObjectType(
 657                     ObjectIdentifier::getFullParentParticle( aCID ));
 658                 if( eParentObjectType == OBJECTTYPE_DATA_SERIES )
 659                 {
 660                     bReturn = lcl_deleteDataSeries( aCID, getChartModel(), m_xUndoManager );
 661                 }
 662                 else if( eParentObjectType == OBJECTTYPE_DATA_CURVE )
 663                 {
 664                     sal_Int32 nEndPos = aCID.lastIndexOf(':');
 665                     OUString aParentCID = aCID.copy(0, nEndPos);
 666
 667                     bReturn = lcl_deleteDataCurve(aParentCID, getChartModel(), m_xUndoManager );
 668                 }
 669                 else if( eParentObjectType == OBJECTTYPE_DATA_AVERAGE_LINE )
 670                 {
 671                     executeDispatch_DeleteMeanValue();
 672                     bReturn = true;
 673                 }
 674                 break;
 675             }
 676
 677             case OBJECTTYPE_DATA_AVERAGE_LINE:
 678             {
 679                 uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
 680                     ObjectIdentifier::getObjectPropertySet(
 681                         ObjectIdentifier::getFullParentParticle( aCID ), getChartModel()), uno::UNO_QUERY );
 682                 if( xRegCurveCnt.is())
 683                 {
 684                     UndoGuard aUndoGuard(
 685                         ActionDescriptionProvider::createDescription(
 686                             ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_AVERAGE_LINE )),
 687                         m_xUndoManager );
 688                     RegressionCurveHelper::removeMeanValueLine( xRegCurveCnt );
 689                     bReturn = true;
 690                     aUndoGuard.commit();
 691                 }
 692             }
 693             break;
 694
 695             case OBJECTTYPE_DATA_CURVE:
 696             {
 697                 bReturn = lcl_deleteDataCurve( aCID, getChartModel(), m_xUndoManager );
 698             }
 699             break;
 700
 701             case OBJECTTYPE_DATA_CURVE_EQUATION:
 702             {
 703                 uno::Reference< beans::XPropertySet > xEqProp(
 704                     ObjectIdentifier::getObjectPropertySet( aCID, getChartModel()));
 705
 706                 if( xEqProp.is())
 707                 {
 708                     rtl::Reference<::chart::ChartModel> xModel( getChartModel() );
 709                     UndoGuard aUndoGuard(
 710                         ActionDescriptionProvider::createDescription(
 711                             ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_CURVE_EQUATION )),
 712                         m_xUndoManager );
 713                     {
 714                         ControllerLockGuardUNO aCtlLockGuard( xModel );
 715                         xEqProp->setPropertyValue( u"ShowEquation"_ustr, uno::Any( false ));
 716                         xEqProp->setPropertyValue( u"XName"_ustr, uno::Any( u"x"_ustr ));
 717                         xEqProp->setPropertyValue( u"YName"_ustr, uno::Any( u"f(x)"_ustr ));
 718                         xEqProp->setPropertyValue( u"ShowCorrelationCoefficient"_ustr, uno::Any( false ));
 719                     }
 720                     bReturn = true;
 721                     aUndoGuard.commit();
 722                 }
 723             }
 724             break;
 725
 726             case OBJECTTYPE_DATA_ERRORS_X:
 727             case OBJECTTYPE_DATA_ERRORS_Y:
 728             case OBJECTTYPE_DATA_ERRORS_Z:
 729             {
 730                 uno::Reference< beans::XPropertySet > xErrorBarProp(
 731                     ObjectIdentifier::getObjectPropertySet( aCID, getChartModel() ));
 732                 if( xErrorBarProp.is())
 733                 {
 734                     TranslateId pId;
 735
 736                     if ( aObjectType == OBJECTTYPE_DATA_ERRORS_X )
 737                         pId = STR_OBJECT_ERROR_BARS_X;
 738                     else if ( aObjectType == OBJECTTYPE_DATA_ERRORS_Y )
 739                         pId = STR_OBJECT_ERROR_BARS_Y;
 740                     else
 741                         pId = STR_OBJECT_ERROR_BARS_Z;
 742
 743                     rtl::Reference<::chart::ChartModel> xModel( getChartModel() );
 744                     UndoGuard aUndoGuard(
 745                         ActionDescriptionProvider::createDescription(
 746                             ActionDescriptionProvider::ActionType::Delete, SchResId(pId)),
 747                         m_xUndoManager);
 748                     {
 749                         ControllerLockGuardUNO aCtlLockGuard( xModel );
 750                         xErrorBarProp->setPropertyValue(
 751                             u"ErrorBarStyle"_ustr,
 752                             uno::Any( css::chart::ErrorBarStyle::NONE ));
 753                     }
 754                     bReturn = true;
 755                     aUndoGuard.commit();
 756                 }
 757                 break;
 758             }
 759
 760             case OBJECTTYPE_DATA_LABELS:
 761             case OBJECTTYPE_DATA_LABEL:
 762             {
 763                 uno::Reference< beans::XPropertySet > xObjectProperties =
 764                     ObjectIdentifier::getObjectPropertySet( aCID, getChartModel() );
 765                 if( xObjectProperties.is() )
 766                 {
 767                     UndoGuard aUndoGuard(
 768                         ActionDescriptionProvider::createDescription(
 769                         ActionDescriptionProvider::ActionType::Delete,
 770                             SchResId( aObjectType == OBJECTTYPE_DATA_LABEL ? STR_OBJECT_LABEL : STR_OBJECT_DATALABELS )),
 771                                 m_xUndoManager );
 772                     chart2::DataPointLabel aLabel;
 773                     xObjectProperties->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel;
 774                     aLabel.ShowNumber = false;
 775                     aLabel.ShowNumberInPercent = false;
 776                     aLabel.ShowCategoryName = false;
 777                     aLabel.ShowLegendSymbol = false;
 778                     aLabel.ShowCustomLabel = false;
 779                     aLabel.ShowSeriesName = false;
 780                     if( aObjectType == OBJECTTYPE_DATA_LABELS )
 781                     {
 782                         rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( aCID, getChartModel() );
 783                         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, CHART_UNONAME_LABEL, uno::Any(aLabel) );
 784                         DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, CHART_UNONAME_CUSTOM_LABEL_FIELDS, uno::Any() );
 785                     }
 786                     else
 787                     {
 788                         xObjectProperties->setPropertyValue(CHART_UNONAME_LABEL, uno::Any(aLabel));
 789                         xObjectProperties->setPropertyValue(CHART_UNONAME_CUSTOM_LABEL_FIELDS, uno::Any());
 790                     }
 791                     bReturn = true;
 792                     aUndoGuard.commit();
 793                 }
 794                 break;
 795             }
 796             case OBJECTTYPE_AXIS:
 797             {
 798                 executeDispatch_DeleteAxis();
 799                 bReturn = true;
 800                 break;
 801             }
 802             case OBJECTTYPE_GRID:
 803             {
 804                 executeDispatch_DeleteMajorGrid();
 805                 bReturn = true;
 806                 break;
 807             }
 808             case OBJECTTYPE_SUBGRID:
 809             {
 810                 executeDispatch_DeleteMinorGrid();
 811                 bReturn = true;
 812                 break;
 813             }
 814
 815             default:
 816             {
 817                 break;
 818             }
 819         }
 820     }
 821     else
 822     {
 823         //remove additional shape
 824         impl_ClearSelection();
 825         {
 826             SolarMutexGuard aSolarGuard;
 827             if ( m_pDrawViewWrapper )
 828             {
 829                 m_pDrawViewWrapper->DeleteMarked();
 830                 bReturn = true;
 831             }
 832         }
 833     }
 834     return bReturn;
 835 }
 836
 837 void ChartController::executeDispatch_ToggleLegend()
 838 {
 839     rtl::Reference< ChartModel > xModel = getChartModel();
 840     UndoGuard aUndoGuard(
 841         SchResId( STR_ACTION_TOGGLE_LEGEND ), m_xUndoManager );
 842     rtl::Reference< Legend > xLegendProp = LegendHelper::getLegend(*xModel);
 843     bool bChanged = false;
 844     if( xLegendProp.is())
 845     {
 846         try
 847         {
 848             bool bShow = false;
 849             if( xLegendProp->getPropertyValue( u"Show"_ustr) >>= bShow )
 850             {
 851                 xLegendProp->setPropertyValue( u"Show"_ustr, uno::Any( ! bShow ));
 852                 bChanged = true;
 853             }
 854         }
 855         catch( const uno::Exception & )
 856         {
 857             DBG_UNHANDLED_EXCEPTION("chart2");
 858         }
 859     }
 860     else
 861     {
 862         xLegendProp = LegendHelper::getLegend(*xModel, m_xCC, true);
 863         if( xLegendProp.is())
 864             bChanged = true;
 865     }
 866
 867     if( bChanged )
 868         aUndoGuard.commit();
 869 }
 870
 871 void ChartController::executeDispatch_ToggleGridHorizontal()
 872 {
 873     UndoGuard aUndoGuard(
 874         SchResId( STR_ACTION_TOGGLE_GRID_HORZ ), m_xUndoManager );
 875     rtl::Reference< Diagram > xDiagram( getFirstDiagram() );
 876     if( !xDiagram.is())
 877         return;
 878
 879     sal_Int32 nDimensionIndex = 1;
 880     sal_Int32 nCooSysIndex = 0;
 881
 882     bool bHasMajorYGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, true,  xDiagram );
 883     bool bHasMinorYGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, false, xDiagram );
 884
 885     if( bHasMajorYGrid )
 886     {
 887         if ( bHasMinorYGrid )
 888         {
 889             AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, true,  xDiagram );
 890             AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
 891         }
 892         else
 893         {
 894             AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
 895         }
 896     }
 897     else
 898     {
 899         AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, true, xDiagram );
 900     }
 901     aUndoGuard.commit();
 902 }
 903
 904 void ChartController::executeDispatch_ToggleGridVertical()
 905 {
 906     UndoGuard aUndoGuard(
 907         SchResId( STR_ACTION_TOGGLE_GRID_VERTICAL ), m_xUndoManager );
 908     rtl::Reference< Diagram > xDiagram( getFirstDiagram() );
 909     if( !xDiagram.is())
 910         return;
 911
 912     sal_Int32 nDimensionIndex = 0;
 913     sal_Int32 nCooSysIndex = 0;
 914
 915     bool bHasMajorXGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, true,  xDiagram );
 916     bool bHasMinorXGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, false, xDiagram );
 917     if( bHasMajorXGrid )
 918     {
 919         if (bHasMinorXGrid)
 920         {
 921             AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, true,  xDiagram );
 922             AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
 923         }
 924         else
 925         {
 926             AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
 927         }
 928     }
 929     else
 930     {
 931         AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, true, xDiagram );
 932     }
 933
 934     aUndoGuard.commit();
 935 }
 936
 937 void ChartController::executeDispatch_FillColor(sal_uInt32 nColor)
 938 {
 939     try
 940     {
 941         OUString aCID( m_aSelection.getSelectedCID() );
 942         rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
 943         if( xChartModel.is() )
 944         {
 945             Reference< beans::XPropertySet > xPointProperties(
 946                 ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
 947             if( xPointProperties.is() )
 948                 xPointProperties->setPropertyValue( u"FillColor"_ustr, uno::Any( nColor ) );
 949         }
 950     }
 951     catch( const uno::Exception& )
 952     {
 953         DBG_UNHANDLED_EXCEPTION( "chart2" );
 954     }
 955 }
 956
 957 void ChartController::executeDispatch_FillGradient(std::u16string_view sJSONGradient)
 958 {
 959     basegfx::BGradient aBGradient = basegfx::BGradient::fromJSON(sJSONGradient);
 960     css::awt::Gradient aGradient = model::gradient::createUnoGradient2(aBGradient);
 961
 962     try
 963     {
 964         OUString aCID( m_aSelection.getSelectedCID() );
 965         rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
 966
 967         if( xChartModel.is() )
 968         {
 969             Reference< beans::XPropertySet > xPropSet(
 970                 ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
 971
 972             if( xPropSet.is() )
 973             {
 974                 OUString aPrefferedName =
 975                     OUString::number(static_cast<sal_Int32>(Color(aBGradient.GetColorStops().front().getStopColor())))
 976                     + OUString::number(static_cast<sal_Int32>(Color(aBGradient.GetColorStops().back().getStopColor())))
 977                     + OUString::number(static_cast<sal_Int32>(aBGradient.GetAngle().get()));
 978
 979                 OUString aNewName = PropertyHelper::addGradientUniqueNameToTable(css::uno::Any(aGradient),
 980                                         xChartModel,
 981                                         aPrefferedName);
 982
 983                 xPropSet->setPropertyValue(u"FillGradientName"_ustr, css::uno::Any(aNewName));
 984             }
 985         }
 986     }
 987     catch( const uno::Exception & )
 988     {
 989         TOOLS_WARN_EXCEPTION("chart2", "" );
 990     }
 991 }
 992
 993 void ChartController::executeDispatch_LineColor(sal_uInt32 nColor)
 994 {
 995     try
 996     {
 997         OUString aCID( m_aSelection.getSelectedCID() );
 998         rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
 999         if( xChartModel.is() )
1000         {
1001             Reference< beans::XPropertySet > xPropSet(
1002                 ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
1003
1004             ObjectType eType = ObjectIdentifier::getObjectType(aCID);
1005             if (eType == OBJECTTYPE_DIAGRAM)
1006             {
1007                 css::uno::Reference<css::chart2::XDiagram> xDiagram(
1008                         xPropSet, css::uno::UNO_QUERY);
1009                 if (xDiagram.is())
1010                     xPropSet.set(xDiagram->getWall());
1011             }
1012
1013             if( xPropSet.is() )
1014                 xPropSet->setPropertyValue( u"LineColor"_ustr, css::uno::Any( Color(ColorTransparency, nColor) ) );
1015         }
1016     }
1017     catch( const uno::Exception& )
1018     {
1019         DBG_UNHANDLED_EXCEPTION( "chart2" );
1020     }
1021 }
1022
1023 void ChartController::executeDispatch_LineWidth(sal_uInt32 nWidth)
1024 {
1025     try
1026     {
1027         OUString aCID( m_aSelection.getSelectedCID() );
1028         rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
1029         if( xChartModel.is() )
1030         {
1031             Reference< beans::XPropertySet > xPropSet(
1032                 ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
1033
1034             ObjectType eType = ObjectIdentifier::getObjectType(aCID);
1035             if (eType == OBJECTTYPE_DIAGRAM)
1036             {
1037                 css::uno::Reference<css::chart2::XDiagram> xDiagram(
1038                         xPropSet, css::uno::UNO_QUERY);
1039                 if (xDiagram.is())
1040                     xPropSet.set(xDiagram->getWall());
1041             }
1042
1043             if( xPropSet.is() )
1044                 xPropSet->setPropertyValue( u"LineWidth"_ustr, css::uno::Any( nWidth ) );
1045         }
1046     }
1047     catch( const uno::Exception& )
1048     {
1049         DBG_UNHANDLED_EXCEPTION( "chart2" );
1050     }
1051 }
1052
1053 void ChartController::executeDispatch_LOKSetTextSelection(int nType, int nX, int nY)
1054 {
1055     if (!m_pDrawViewWrapper)
1056         return;
1057
1058     if (!m_pDrawViewWrapper->IsTextEdit())
1059         return;
1060
1061     OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
1062     if (!pOutlinerView)
1063         return;
1064
1065     EditView& rEditView = pOutlinerView->GetEditView();
1066     Point aPoint(convertTwipToMm100(nX), convertTwipToMm100(nY));
1067     switch (nType)
1068     {
1069         case LOK_SETTEXTSELECTION_START:
1070             rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/false, /*bClearMark=*/false);
1071             break;
1072         case LOK_SETTEXTSELECTION_END:
1073             rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/false);
1074             break;
1075         case LOK_SETTEXTSELECTION_RESET:
1076             rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/true);
1077             break;
1078         default:
1079             assert(false);
1080             break;
1081     }
1082 }
1083
1084 void ChartController::executeDispatch_LOKPieSegmentDragging( int nOffset )
1085 {
1086     try
1087     {
1088         OUString aCID( m_aSelection.getSelectedCID() );
1089         rtl::Reference<::chart::ChartModel> xChartModel = getChartModel();
1090         if( xChartModel.is() )
1091         {
1092             Reference< beans::XPropertySet > xPointProperties(
1093                 ObjectIdentifier::getObjectPropertySet( aCID, xChartModel ) );
1094             if( xPointProperties.is() )
1095                 xPointProperties->setPropertyValue( u"Offset"_ustr, uno::Any( nOffset / 100.0 ) );
1096         }
1097     }
1098     catch( const uno::Exception & )
1099     {
1100         TOOLS_WARN_EXCEPTION("chart2", "" );
1101     }
1102 }
1103
1104 void ChartController::impl_ShapeControllerDispatch( const util::URL& rURL, const Sequence< beans::PropertyValue >& rArgs )
1105 {
1106     Reference< frame::XDispatch > xDispatch( m_aDispatchContainer.getShapeController() );
1107     if ( xDispatch.is() )
1108     {
1109         xDispatch->dispatch( rURL, rArgs );
1110     }
1111 }
1112
1113 void ChartController::impl_switchDiagramPositioningToExcludingPositioning()
1114 {
1115     UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription(
1116         ActionDescriptionProvider::ActionType::PosSize,
1117         ObjectNameProvider::getName( OBJECTTYPE_DIAGRAM)),
1118         m_xUndoManager );
1119     if (DiagramHelper::switchDiagramPositioningToExcludingPositioning(*getChartModel(), true, true))
1120         aUndoGuard.commit();
1121 }
1122
1123 } //  namespace chart
1124
1125 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */